Python学习笔记（一)

写在前面

​ 摸鱼时候发现大家现在普遍对python感兴趣，于是萌生了写这个文档的想法，希望能够帮助你加深一点对python编程语言的了解。我不生产知识，我只是一名勤劳的搬运工。本混子已经尽力搬运但文档内容有限，请配合网络资源食用。

​ 暑假被学弟的几个问题问倒了，看来以后确实要好好学python辣，顺便采访了一下为什么想要学python，得到的答案大抵是想要学爬虫、很多人都在学不学就落伍了、python比较好入门之类的，果然越来越卷了。

一、什么是Python？

​ Python 是一种易于解释的高级面向对象的编程语言，它采用易于阅读的语法。Python 是一种提供原型和即席任务的理想方式，它广泛用于科学计算、Web 开发和自动化。作为通用、便于初学者使用的编程语言，Python 支持全球许多顶级计算机科学家和应用开发人员。

​ 1989 年，Guido Van Rossum 在荷兰的一个计算机科学实验室工作。他决定写一种能够改善他时间最受欢迎的故障的语言。五年半后，他发布了这部声明，称其为“Python”。这是英国喜剧《 Monty Python 的飞马戏团》后，他是“Python”。

刚开始的时候进展缓慢，但当一名年轻的 Google 宣布其使用 Python 执行许多内部流程时，Python 取得了很大的休息。

​ 2005 年，Python 发行了 Django，这是一个构建 Web 应用的框架。丹戈在流行性中爆炸，并前来挑战当时位于铁路框架上的主要 Ruby。

​ 到 2011 年，Python 是全国计算机科学项目中最讲授的语言。几年后，由于其易于使用和可读性，它成为机器学习和人工智能领域研究人员的事实标准。

​ 现如今，作为一个ICT从业者，如果你没听说过Python，那就太out了。作为现在最热门的程序语言，Python拥有超高的人气，可以说是IT界的新一代网红。尤其是Python和目前红得发紫的人工智能之间密切的关系，使得大家都对它投入了特别的关注。

二、为什么学Python？

Python迅速走红的原因其实是多方面的，主要是以下几点：

1. 容易上手，非常适合编程初学者作为启蒙的语言。

2. 语法简洁易懂，有点类似英语的表达，很接近自然语言。

3. Python还有个昵称，叫“胶水语言”，是说Python可以很方便地调用别的语言（如C++、Java）编写的功能模块，将他们有机结合在一起形成更高效的新程序。

4. 丰富、强大的库支持是Python的坚强后盾。

​ Python拥有一个强大的标准库。Python语言的核心只包含数字、字符串、列表、字典、文件等常见类型和函数，而由Python标准库提供了系统管理、网络通信、文本处理、数据库接口、图形系统、XML处理等额外的功能。Python标准库命名接口清晰、文档良好，很容易学习和使用。

​ 如果对数据科学和机器学习有任何兴趣，可以进一步了解。

好了，话不多说，不管你有没有兴趣，接下来让我们继续深入了解一下吧

三、环境搭建

可参考自动化科协视频2022冬令营（1）——Python环境安装

Window 平台安装 Python

​ 需要到Python的官网上下载Windows系统的安装包就可以了。根据自己电脑的系统选择32位或者64位,x86 表示是 32 位机子的，x86-64 表示 64 位机子的。

记得勾选 Add Python 3.10 to PATH。

Anaconda 安装

下载地址：清华大学开源软件镜像站

下载版本：选择 Windows 比较新的版本即可，此处以 Anaconda3-2021.05-Windows-x86_64.exe 为例。

（1）双击下载好的安装包，选择“next”

（2）点击“I Agree”

（3）选择默认

（4）选择安装路径，尽量避免在 C 盘，因为后续安装环境也在此处，会占用很大空间。 避免路径中出现中文，防止后续使用出现错误

（5）选择将 anaconda 加入系统环境变量，否则需要自己手动添加。

（6）点击安装，等待安装完成。

（7）安装完成

在已经安装 anaconda 的基础上，创建自己的 Python 环境。

(1) 打开 Anaconda 安装包中的 Anaconda PowerShell Prompt.

(2) 输入如下命令： conda create -n testENV python=3.7 并回车（enter 键）

输入 y 并回车

(3) 基本环境安装完成后，输入 conda activate testENV 激活环境并切换到该环 境，此时最前面括号中的环境显示已经切换为 testENV 环境了，在此基础上进一步安装我 们所需要的环境。 如果以后需要在该环境中追加安装 python 的包，也是用“conda activate 环境名” 来切换到该环境，进行安装。

(4) 安装一些常用的 python 包，此处仅作为测试，具体安装请按照使用需求而定。

1）为 anaconda 添加清华源，因为部分 python 安装包的服务器在国外，直接下载速 度比较慢，可能会被 anaconda 软件认为下载超时而导致下载失败。清华大学在国内建立了 一个镜像服务器，将国外的资源预先下载到了他们的仓库，国内用户可以直接访问清华大 学的服务器来获取这些 python 安装包，大大提高了安装速度。

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/ conda config --set show_channel_urls yes

2）安装 numpy 和 matplotlib 安装命令格式 ： pip install python 数据包名称 有些 python 库本身又依赖于别的库，所以安装时会将其依赖的库自动安装。 自此，简单的 anaconda 环境创建完毕，如需安装其他 Python 库，可以仿照上述方法”pip intsll 库名”进行安装。

编辑器的选择

比较受初学者欢迎的有两种：pycharm与vscode

个人更加推荐pycharm

点击进入官网下载使用即可

四、Python基础

1. Python基本数据类型

赋值

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

执行以上程序会输出如下结果：

100
1000.0
runoob

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1py

标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• **不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）；

• **可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。

Number（数字）

Python 3 支持 4 种类型的数字：int(整数类型)、float(浮点类型)、bool(布尔类型)、complex (复数类型)。

在 Python 3 中可以使用 type() 函数来查看数字类型，如下所示:

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

Python3 所支持的运算类型包括加法、减法、除法、整除、取余、乘法和乘方：

  
  1.  print((3+1)) #加法运算，输出结果是 4
  2.  print((8.4-3)) #减法运算，输出结果是5.4
  3.  print(15/4) #除法运算，输出结果是 3.75
  4.  print(15//4) #整除运算，输出结果是 3
  5.  print(15%4) #取余运算，输出结果是 3
  6.  print(2*3) #乘法运算，输出结果是 6
  7.  print(2**3) #乘方运算，输出结果是 8
  
  

String (字符串)

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 ** 转义特殊字符。

除了数字，Python 还可以操作字符串。字符串有多种表现形式，用单引号（'……'）或双引号（"……"）标注的结果相同 。反斜杠 \ 用于转义：

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

字符串的索引

字符串的切片的语法格式如下：

变量[头下标:尾下标]

例如：

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

字符串的序列操作

操作符	说明
s+t	拼接两个字符串s和 t
s*n	将字符串s重复n次生成新的字符串
s[i]	索引，返回字符串s的第i项
s[i:j:k]	切片，返回字符串从i到j(不包括j)，步长为k的字符串，默认为1
len(s)	返回字符串s的长度
x in s	如果x与字符串s任一子串相等，返回True，否则返回False
x not in s	如果x与字符串s任一子串不相等，返回True，否则返回False

字符串的方法

方法名	描述
str.upper()	转换字符串str中所有字母为大写
str.lower()	转换字符串str 中所有字母为小写
str.swapcase()	翻转字符串str中的大小写字母
str.replace(old, new[, count])	把字符串str中的old 替换成new，如果count 指定，则替换不超过count次，否则有多个old子串时全部替换为new。
str.split()	通过指定分隔符对字符串进行切片，将一个字符串分裂成多个字符串列表，缺省时根据空格切分，可指定逗号或制表符等。
str.find(	搜索指定字符串

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

列表的索引和切片与字符串类似

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

与Python字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 []
>>> a
[9, 2, 6]

注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接。
• 4、List中的元素是可以改变的。

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

以上实例输出结果：

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

string、list 和 tuple 都属于 sequence（序列）。

注意：

• 1、与字符串一样，元组的元素不能修改。

• 2、元组也可以被索引和切片，方法一样。

• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。

• 4、元组也可以使用+操作符进行拼接。

Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

字典（dictionary）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

d = {key1 : value1, key2 : value2, key3 : value3 }

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。使用大括号 { } 创建空字典

实例：

# 使用大括号 {} 来创建空字典
emptyDict = {}
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))

2. 输入与输出语句

print函数与格式化输出

语法:

print(valuel, value2,value3,…, sep='', end=,')

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

str.format() 的基本使用如下:

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

>>> print('{0} 和 {1}'.format('NJUPT', 'AI'))
NJUPT 和 AI
>>> print('{1} 和 {0}'.format('NJUPT', 'AI'))
AI 和 NJUPT

input函数

str = input("请输入：");
print ("你输入的内容是: ", str)

input的返回值是字符型变量

eval()可将字符串转化为有效表达式，并参与求值运算

>>>a='1'
>>>b='2'
>>>eval(a+b)
12

3. 流程控制语句

条件控制

if语句

Python中if语句的一般形式如下所示：

if condition_1:    statement_block_1 elif condition_2:    statement_block_2 else:    statement_block_3

• 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
• 如果 “condition_1” 为False，将判断 “condition_2”
• 如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
• 如果 “condition_2” 为False，将执行"statement_block_3"块语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

• 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在Python中没有switch – case语句。

年龄转化小游戏：

age = int(input("请输入你家狗狗的年龄: "))
print("")
if age <= 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)
 
### 退出提示
input("点击 enter 键退出")

if 嵌套

在嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

实例

num=int(input("输入一个数字：")) 
if num%2==0:
	if num%3==0:
		print ("你输入的数字可以整除 2 和 3")    
	else:
		print ("你输入的数字可以整除 2，但不能整除 3") 
else:    
	if num%3==0:
		print ("你输入的数字可以整除 3，但不能整除 2")    
	else:
		print  ("你输入的数字不能整除 2 和 3")

将以上程序保存到 test_if.py 文件中，执行后输出结果为：

$ python3 test.py 
输入一个数字：6
你输入的数字可以整除 2 和 3

循环语句

for循环与range函数

for循环变量in可遍历结构:
语句块1
else:
语句块2

这些可遍历结构包括: range、字符串、文件、列表等组合。程序执行时，从可遍历机构逐一提取元素，赋值给循环变量，每提取一次元素，便执行一次语句块1，当循环结束时，才会执行else后面的语句块2。
range函数语法:

range (start, stop, step)

start、stop和step必须为整型数字，start省略时，默认值为0，step省略时默认值为1，stop不可省略。start和 stop代表生成数字序列区间的开头和结尾，step为步长。
range(4):生成一个0，1，2，3的序列
range(1,5):生成一个1，2，3，4的序列(range函数产生的是一个左闭右开的序列)
range(1,6,2):生成一个1，3，5的序列

实例：计算1+2+3+……+n的前n项和

n=int(input('请输人一个止整数n:'))#将输入字符转变为整型参与后续运算
sum=O
for i in range(1,n+1):
#遍历从1到n，并依次赋值给i，参与下面的运算
	sum=i+sum
#每次循环后产生的i值，加到sum 上
print(sum)

while循环

while判断条件:
执行语句

while循环一般用于循环次数无法确定的情况，而for循环则用于循环次数已经确定的情况。

实例：编写程序，使得十进制整数可以用二进制表示，具体表示方法如下，将十进制整数除以2，取出余数，商继续除以2，继续取余数，直到得到0为止，将取出的余数逆序输出，即为二进制表示方法。

num=int(input('请输入一个十进制数:'))
s=''
#创建空字符串，用来容纳余数
while num!=O:
#输入的数字不能为0，当为0时结束循环，执行print 语句
	s=s+str(num%2)
	#将整数除2后取余数
	num=num//2
	#求整数除以2之后的商
print('二进制表示方法为:'+s[::-1])

循环中的break和else语句
在while或者for 的循环结构中，当存在未达到循环次数便跳出循环的要求时，常用break语句，目的是提前结束该层循环。

实例：素数又俗称质数，指在大于1的自然数中，除了1和他本身以外不再有其他因数的数字，请编程输出100以内的所有素数。
分析:一部分是产生100以内的所有整数，需要用一层循环，而另一部分是判断一个数字是否为素数，需要第二层循环。题目中告诉我们素数大于1所以外层循环可以从2开始，到99结束，内层循环则对外层循环传入的i对2~i-1的每一个数字取模，也就是求余数，如果存在数字j使模为О也就是被整除，那说明i就不是素数，此时用break结束循环，不需要继续测试。

`for i in range(2,100):`
	`for j in range(2,i):`
		`if(i%j==O):`
			`break`
	`else:`
		`print(i,end=' ')`

4. 函数

函数定义

函数是可以重复使用的、具有单一或相关联功能的一组程序语句，当需要重复运用一组程序语句时，可以将这组程序封装成函数，通过函数名进行调用。进而实现代码的重复使用
格式:

def函数名(“[参数列表]”):文档注释”
函数体
return返回值

def:定义函数的关键字
函数名:必须由数字、字母、下划线组成，不能用python的关键字命名参数列表:由外部传入，若为空，则不需要外部传入参数就可以执行。

return语句:return是函数在调用过程中执行的最后一个语句，每个函数可以有多个return语句但只能有一个被执行，一旦某个return语句被执行，函数调用即结束，将返回值返回给调用函数的位置。
注释:解释这个被定义函数的作用

函数的调用

遵循先定义后调用的规则，将函数的定义放在程序的开头，函数调用必须位于函数定义之后，调用时只需要输入函数名和后面的参数即可调用。

def f(n):
#定义第一个函数3n
	return 3*n
def f(n):
#定义第二个函数5n
	return 5*n
m=5
#m=5传递给函数中的n
print(f(m))
#当函数名被重复定义时，调用函数时，调用离他最近的函数定义

输出:25

实例：请定义一个用于计算x的n次方的函数

def power(x,n):
#定义函数中可以有两个或多个参数
	a=1
	for i in range(n):
	#循环n次
		a=a*x
		#共有n个x相乘，也就是a的n次方
	return a
b=int(input('请输入x:'))
#函数中有多个参数时，
c=int(input('请输入n: '))
#调用时也需要按照顺序给出函数中的值
print(power(b,c))

函数返回值
每一个函数都会实现一定的功能，其处理结果可以直接输出，也可以返回调用处做进一步处理，此时需要return语句向外提供该函数的处理结果。函数返回值没有类型限制，也没有个数限制,当函数返回值为多个时，以元组形式返回。

5. 类与对象

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• **方法：**类中定义的函数。
• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• **数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。
• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• **局部变量：**定义在方法中的变量，只作用于当前实例的类。
• **实例变量：**在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• **实例化：**创建一个类的实例，类的具体对象。
• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类定义

语法格式如下：

class ClassName:
	<statement-1>
    .    
    .    
    .    
    <statement-N>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

实例

class MyClass:
	"""一个简单的类实例"""    
	i = 12345    
	def f(self):        
		return 'hello world'  
		
# 实例化类 
x = MyClass()  

# 访问类的属性和方法 
print("MyClass 类的属性 i 为：", x.i) 
print("MyClass 类的方法 f 输出为：", x.f())

以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

执行以上程序输出结果为：

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

---

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def init(self): self.data = []

类定义了 init() 方法，类的实例化操作会自动调用 init() 方法。如下实例化类 MyClass，对应的 init() 方法就会被调用:

x = MyClass()

当然， init() 方法可以有参数，参数通过 init() 传递到类的实例化操作上。例如:

实例

class Complex:   
	def __init__(self, realpart, imagpart):        			self.r = realpart        
		self.i = imagpart 
x = Complex(3.0, -4.5) 
print(x.r, x.i)   # 输出结果：3.0 -4.5

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:    
	def prt(self):        
		print(self)        
		print(self.__class__)  
t = Test() 
t.prt()

以上实例执行结果为：

<__main__.Test instance at 0x100771878>
__main__.Test

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 python 关键字，我们把他换成 NJUPT 也是可以正常执行的:

class Test:    
	def prt(NJUPT):        
		print(NJUPT)        
		print(NJUPT.__class__)  
t = Test() 
t.prt()

以上实例执行结果为：

<__main__.Test object at 0x000002B374F0E860>
<class '__main__.Test'>

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

实例

#类定义
class people:    
    #定义基本属性    
    name = ''    
    age = 0    
    #定义私有属性,私有属性在类外部无法直接进行访问    		__weight = 0    
    #定义构造方法    
    def __init__(self,n,a,w):
        self.name = n        
        self.age = a        
        self.__weight = w    
     def speak(self):        
        print("%s 说: 我 %d 岁。"%(self.name,self.age))  
        
 # 实例化类 
p = people('NJUPTer',18,30) 
p.speak()

执行以上程序输出结果为：

NJUPTer 说: 我 18 岁。

五、推荐的资源文档

python官方教程

菜鸟教程

python中文文档

python中文学习大本营
‘main.Test’>

#### 类的方法

在类的内部，使用 **def** 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

实例

```python
#类定义
class people:    
    #定义基本属性    
    name = ''    
    age = 0    
    #定义私有属性,私有属性在类外部无法直接进行访问    		__weight = 0    
    #定义构造方法    
    def __init__(self,n,a,w):
        self.name = n        
        self.age = a        
        self.__weight = w    
     def speak(self):        
        print("%s 说: 我 %d 岁。"%(self.name,self.age))  
        
 # 实例化类 
p = people('NJUPTer',18,30) 
p.speak()

执行以上程序输出结果为：

NJUPTer 说: 我 18 岁。

五、推荐的资源文档

python官方教程

菜鸟教程

python中文文档

python中文学习大本营