Python学习快速参考手册
目录
文章目录
- Python学习快速参考手册
下载
Python下载与配置
Python在[这里][https://www.python.org/getit/]下载,我使用的版本是3.6.8。
下载好python后,需要进行环境变量的配置,具体方法在[这里][https://blog.csdn.net/airenKKK/article/details/81386932]。
IDE下载与配置
编译器配置在[这里][https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/]下载,我选择的是Anaconda3-5.2.0-Windows-x86_64.exe.这是python学习使用的编译器组合套。
IPython交互窗口(Anaconda安装好后的工具)
是CMD的加强板,可以用交互模式实时运行所输入的python程序,不需要创建文件。一般用来进行短行语言测试使用。
Spyder编辑器(Anaconda安装好后的工具)
轻量化的python编辑器和ide,主要使用spyder进行Python学习,F5开始编译,进行输入操作的时候,直接在console上点击命令行即可输入。
第一章 · Python的基本语法
变量
在Python中变量是不需要定义即可使用的,如果要使用一个变量,可以进行一个赋值操作,例如:
a=0
在这之后,a就可以作为一个被编译器所知的变量进行使用了,不会出现变量未定义的错误。
Python的变量不被数据类型所限制,可以随时转换一个变量的数据类型,例如:
a=0
a="hello"
数据类型
在Python中有一下五种数据类型:
数据类型 | 说明 |
---|---|
int(整型) | 用于存储整型数,包括十进制、二进制、八进制和十六进制。存储十进制数可以直接用等号赋值;二进制数需要给数字前缀0b 或者0B ;八进制数需要给数字前缀0o 或者0O ;十六进制数需要给数字前缀0x 或者0X 。 |
float(浮点型) | 用于存储小数,如0.1,-0.2等。 |
bool(布尔型) | 只有两个取值,True 和False 他们隐式表示True 是1,False 是0,可以使用他们进行加减运算,计算结果会变为int。 |
complex(复数) | 用于存储复数,如3+4j、complex(3,4)。 |
String(字符串类型) | 用于存储单个字符或者一串字符,赋值的时候需要用单引号或者双引号将字符引用,例如a=“hello world”。 |
注释
Python注释分为单行注释和多行注释,注释并不会被编译器编译,用来进行说明。
单行注释使用#
标记开头,#
后的内容将会被标记为注释,一直延伸到本行结束。
#这是一个单行注释,后面无论多长只要不换行都是注释,但是#前面的代码还是会被检测和编译
多行注释使用三个单引号或者三个双引号作为其实或者结束的标签。
"""这里是多行注释的开始
此下是内容
只要没有遇到结束的标志
就可以一直换行
然后这段注释在标志前结束"""
'''你也可以用标签来在行内进行注释,同一行内标签外的内容依旧会被编译器检查和翻译'''
单行注释常用作对某一行的说明,多行注释可以把不确定的代码括起来,让编译时这段代码不运行来查错。
数据类型的强制转换
Python库给了三个常用的数据转换函数:
int()
:将括号里的内容强制转换为int型,向下取整(去掉小数取整,而非舍入取整)。
float()
:强制转换成浮点型。
str()
:强制转换为字符串型。
a=12345
b=0.5
c=b+float(a)
d=str(c)
print(d) #将计算结果打印出来
字符和整型之间转换可以通过这两个函数进行转换:
ord()
:获取单个字符的ASCII码值。
chr()
:根据一个ASCII码值给出对应的字符。
a="M"
b=ord(a) #a必须只能是单个字符,多个字符会报错
print("M在ascii码表上的位置是",b)
特别注意的是,如果数字和字符串同时输出时,需要将数字强制转换成字符串类型,否则系统会报错:
a="M"
b=ord(a)
print("M在ascii码表上的位置是第"+str(b)+"位")
#实际上print里面有两种连接方式,逗号和加号都可以作为连接符。当使用加号连接符时,加号两边必须都是字符串,非字符串数必须强制转换
运算符与表达式
基本运算符
除了四则运算加+
减-
乘*
除/
,之外Python还内置了幂运算**
,取余运算%
和取整运算//
。
运算符 | 说明 | 示例(非程序代码) |
---|---|---|
** | 取一个数的幂次方 | 3**2=9 |
% | 取两数整除结果的余数 | 9%2=1 |
// | 去两数整除结果的商 | 9%2=4 |
赋值运算符
除了基础的赋值运算符之外,还有简化的复合赋值运算符。
运算符 | 说明 |
---|---|
+= (加号可以切换成任意简单运算符) | A+=B等价于A=A+B |
**= | A**=B等价于A=A**B |
%= | A%=B等价于A=A%B |
//= | A//=B等价于A=A//B |
关系运算符
关系运算符是作为比较的运算符,关系运算符的计算结果只能为True或者是False。
运算符 | 说明 | 示例 |
---|---|---|
== | 等于 | A= 1==2,此时A=False |
!=或者<> | 不等于 | A= 1!=2,此时A=True |
> | 大于 | A= 1>2,此时A=False |
< | 小于 | A= 1<2,此时A=True |
>= | 大于等于 | A= 1>=2,此时A=False |
<= | 小于等于 | A= 1<=2,此时A=True |
逻辑运算符
常用来连接比较计算式,组成更长的逻辑计算式。
运算符 | 说明 | 示例(非程序代码) |
---|---|---|
and | and两遍都为True时运算结果才为True,否则为False | True and False =False |
or | or两遍只要有一个为True时运算结果就为True,否则为False | False and False =False |
not | not是单元计算符,类似于前缀,只在后面连接一个比较式。作用是将比较式的真假反转。 | not True =False |
逻辑运算符可以通过括号连接组成很长的比较式,用于处理复杂情况。
A=1,B=2
C=(A>B)and(A<B)
D=(not(A>B))or(A<B)
#逻辑运算符一般是在循环结构或者条件结构的条件框中出现
逻辑短路现象
在类C语言的程序语言中,一切非零数字都可以代表True,而零代表False。所以你可以仅用逻辑运算符而不用关系运算符的情况下连接两个int数据,它们的计算结果是有效的,但是计算结果不是True或False而是int。
A=3
B=-1
C=A and B
#这样的计算结果是有效的,C是int型数据,真假与A和B的值有关
这样的算术式,会出现逻辑短路现象。逻辑短路现象普遍的存在于各种编程语言中,用于减轻逻辑计算时的计算时长和资源消耗。
逻辑短路现象提高了程序的运行速率也同样带来了一些问题,例如在C语言中,如果B中含有赋值运算则这段运算也不会运行,相当于这段代码被跳过了。比如这样:
int A=1;
int B=2
if(A!=B || A=B)
{
printf("A",%d);
}
//条件框翻译:如果A不等于B 或者 B赋值给A
//B赋值给A的计算结果等于A,所以A=B的计算结果是true,按道理来说最后打印结果应当是2,因为进行了B对A的赋值运算
//但是由于短路现象的存在,打印结果为1,因为赋值运算被跳过了
所以由于以上原因,只有C/C++支持在逻辑运算中使用赋值运算,Python等大部分计算机语言都禁止了赋值运算在逻辑运算表达式中出现。但是Python中依旧存在逻辑短路现象,其表现为逻辑运算符两边为int类型数据时的计算。
A=3
B=4
C=A or B
print(C)
#输出结果C=A=3,而不是True或者4,因为3是非零数逻辑定义为True,所以编译器不会再检测B
A=0
B=-1
C=A and B
print(C)
#输出结果C=A=0,因为0代表False,所以A为假,编译器不会再检测B,于是计算结果为C=A
运算符优先级顺序
算术运算符>关系运算符>not>and>or>赋值运算符
通过合理的使用括号可以限制运算符的优先顺序。
第二章 · 数据的输入与输出
print()函数
print函数可以用于输出各种变量,基本语法示例如下:
print("hello,wrold")
#控制台输出:hello,world
事实上,对于print()来说"hello,wrold"
相当于一个字符串变量,应当理解为print的输出是以变量为基本单位的。同理print()可以单个输出其他变量,示例如下:
A=True
print(A)
#控制台输出:True
B=3
print(B)
#控制台输出:3
C="goodbye"
print(C)
#控制台输出:goodbye
print()提供了,
逗号分隔符,逗号分隔符会在控制台输出时生成一个空格占位符,逗号分隔符可以分隔多个变量让print()函数一次输出更多东西。
A=1
B="天"
print(A,B)
#控制台输出:1 天
A="hello"
B="world"
print(A,B)
#控制台输出:hello world
sep:自定义分隔符,写在print()括号内所有变量最后,语法为sep="~自定义分隔符号~"
。默认值为一个空格。
end:自定义终止符,写在print()括号内所有变量最后,语法为end="~自定义终止符号~"
。默认值为换行符\n
。
print("hello","world",sep="and")
#控制台输出:helloandworld
print("hello","world",sep="and",end="\nthis is the end")
#控制台输出:
#helloandworld
#this is the end
转义符
计算机中有一类特殊的字符通过键盘直接输出,或者进入代码中会影响当前程序,此时就需要用到转义符。这里将常用的分隔符加入了*
号。
转义符 | 说明 |
---|---|
\ | 用在行尾,表示续行符 |
\\ | 输出反斜杠 |
\' | 输出单引号 |
\" | 输出双引号 |
*****\n | 输出换行符 |
*****\t | 输出制表符 |
input()函数
基础语法如下:
A=input()
其中,input括号中可以加入一行提示字符,给用户在输入前输出一行提示。
A=input("请输入一个10以内的整数")
print("您输入的数字为",A)
#控制台:
#请输入一个10以内的整数
#[用户输入]:20
#您输入的数字为20
特别注意,input并不能分清字符串与bool变量,所以如果输入True或者False将会储存"True"或"False"的字符串变量,并不是bool类型,所以想要通过用户输入来给bool赋值必须要通过条件语句才能实现,不能直接使用input()函数实现。
第三章 · 结构语句
条件语句
条件语句常用来处理需要分条件来实现代码的情况,基本语法为:
if 条件 :#可以在条件前后加上括号,这样会更像其他高级语言的if结构
<代码块>
- Python中没有花括号限制if的域,所以if的作用空间通过缩进来限制。
- [条件]可以用逻辑运算符连接很长的代码。
- 比较其他高级语言的if,Python的if中条件的括号框是可选的,但是条件结束后无论有没有括号都需要在行末加上一个冒号
:
用于表示代码块的开始。
条件语句存在双分支的情况,所以此时还可以写为:
if 条件 :
<代码块1>
else :
<代码块2>
- else是可选的,但是一个if条件语句中,至多允许存在一个else。
- else是没有[条件]的,其内的代码仅在if条件为假时才会运行。
条件语句还存在更复杂的分支情况,所以还可以写为:
if 条件1 :
<代码块1>
elif 条件2 :
<代码块2>
elif 条件3 :
<代码块3>
- 一个if可以匹配多条elif,elif应当都有只属于自己的条件。
- if-elif组合中,在程序从上到下运行时,当if或者有一条elif的条件符合,将会运行其中的代码块,并且在完成后直接跳出if-elif组合,不会继续检测剩下的elif。
- 可以在if-elif组合中加入else,当if和所有elif条件全部为假时,else内的代码块才会实现。
循环语句
while循环语句
while循环是最基础的循环语句,基础语法如下:
while 循环条件 :
<循环操作>
- 循环一旦开始,在循环条件为假之前会一直运行
- 可以在循环条件中填入True来构造一个无限循环。
while循环还可以继续扩展,这是Python独有的写法:
while 循环条件 :
<循环操作>
else :
<语句块>
- 如果进入循环时检测条件为假(即从一开始循环条件就是假),else会直接运行。
- while循环操作执行完成后,else会运行一遍,这是因为while循环执行完成的标志就是循环条件为假,而这是else的运行条件。
- 综上,只要while不是无限循环,else总会并且只会运行一次。
for循环语句
for语句常用于快速遍历数组,其基本语法如下:
for <循环变量> in <遍历结构> :
<语句块>
其中遍历结构可以是字符串、range()函数、文件或者组合数据类型。下面是使用案例:
for A in range(3): #range(N)函数表示循环N次
print("循环")
#控制台输出:
#循环
#循环
#循环
A="hello"
for B in A :
print(B)
#控制台输出:
#h
#e
#l
#l
#o
for循环语句同样可以进行扩展,这也是Python独有的:
for <循环变量> in <遍历结构> :
<语句块1>
else :
<语句块2>
else内容和while中的一样,只要for不是无限循环,那么else总会运行一次。
第四章 · 组合数据类型
关系概述
Python共有三类组合数据类型,分别是序列类型、集合类型和映射类型。
- 序列类型是一个元素向量,元素有顺序,通过序号访问,可以有相同的元素。[数组]
- 集合类型是一个元素集合,元素无顺序,元素在集合中是唯一存在。[无序号,不可重复枚举集合]
- 映射类型是“键-值”数据项的组合,每个元素是一个点键值对,表示为(key,value)。
序列类型
Python常见的序列类型比如列表(list)、元组(tuple)、字符串(str)。
-
列表是一个可以修改数据项的序列类型,使用也最为灵活。[可变长数组]
-
元组是包含0个或多个数据项的补课边序列类型,元组生成后是固定的,其中的数据项是不能被替换或者删除的。[枚举数组]
-
字符串创建后是不可变的,但是字符串可以进行切片操作,切片自身会创建新的内存对象。但是这不会影响原本字符串的内存空间。
由于序列类型的通用性,不同类型的的序列类型都可以使用以下的操作方式来操作序列类型。
操作符 | 说明(定义S为序列类型) |
---|---|
x in s | 若x是s的元素则返回True,否则返回False |
x not in s | 若x不是s的元素则返回True,否则返回False |
s+t | s和t都是字符串类型,连接s和t |
s*n | 将序列s赋值n次 |
s[i] | 索引,返回序列中第i个元素 |
s[i:j] | 分片,返回包含序列s第i个元素到第j个元素的子序列 |
s[i:j:k] | 按步分片,返回包含序列s第i个元素到第j个元素并以k为步长的子序列 |
len(s) | 序列s的元素个数(或长度) |
min(s) | 序列s中最小的元素 |
max(s) | 序列s中最大的元素 |
s.index(x[,i[,j]]) | 序列s中从i开始到j位置中第一次出现x元素的位置 |
s.count(x) | 序列s中出现x的次数 |
列表[可变长数组]
列表的定义语法与类C语言定义数组的方式相似,但是使用的限制是中括号。
List=["元素1","元素2","元素3"]
列表支持索引序列访问,所以可以用访问数组元素的方式访问它的各个元素,和类C语言一样,序列的第一位元素的索引值为0.
List=["元素1","元素2","元素3"]
A=List[0]
print(A)
#控制台输出:元素1
列表索引下标也可以是负数,-1是列表的最后一个元素,以此类推可以用负数反向访问列表。
List=["元素1","元素2","元素3"]
A=List[-2]
print(A)
#控制台输出:元素2
列表除了可以使用序列类型通用的操作方式之外,还有自己独特的操作方式。
函数 | 说明 |
---|---|
ls[i]=x | 将ls表第i项修改为x |
ls[i:j]=lt | 用列表lt替换列表ls第i到第j-1项数据 |
ls[i:j:k]=lt | 用列表lt替换列表ls第i到第j-1并且步长为k的数据 |
del ls[i:j:k] | 删除列表ls第i到j-1项数据,可以等价为ls[i:j:k]=[] |
ls+= lt或者ls.extend(lt) | 将列表lt中的元素添加到ls中 |
ls *=n | 更新列表ls,其元素重复n次 |
ls.append(x) | 在列表ls最后添加一个元素x |
ls.clear() | 删除ls中所有元素 |
ls.copy() | 生成一个新列表,复制ls中的项数内容 |
ls.insert(i,x) | 在ls列表第i为添加元素x |
ls.pop(i) | 将列表ls中的第i项元素取出并删除该项**(出栈)** |
ls.remove(x) | 将列表中出现的第一个x元素删除 |
ls.reverse(x) | 将列表ls中的元素反转 |
列表会经常进行遍历修改操作,可以用for循环构造一个遍历代码,方便操作。
for <循环变量名> in <列表名>
<代码块>
#请注意,python的循环变量作用和类C语言的循环变量是有区别的,例如下面程序完成下面这个列表全输出操作:
I=[1,2,3]
for i in I:
print(i)
'''这里的i直接代表了每次循环时I内部的元素,不能写成这样:
print(I[i])
虽然在类C语言中,循环变量都是这样使用的,但是在python中这样的写法会导致程序出现序列越界的情况'''
除此之外,列表可能会进行排序操作,而Python内置了sorted()和sort()两个方法适用于不同情况下的列表排序。
sorted()函数可以生成一个新序列,将排序好的元素加入到新序列中。这样做的好处是原列表不会被修改。
list1=[3,2,1]
list2=sorted(list1)
print(list2)
#控制台输出:[1,2,3]
当然如果原列表已经没有用了,可以用<list>.sort()
方法直接进行修改,这样会更加节约空间。
list1=[3,2,1]
list1.sort()
print(list1)
#控制台输出:[1,2,3]
元组[枚举数组]
元组类似于类C语言中的枚举数组,内容一旦确定后,元组内的元素不能再进行改变。
元组的创建和列表类似,元组使用的是小括号(小括号是可选的)
tu1=("h","o")
tu2="l","l","o"
print(tu1,tu2)
#控制台输出:('h', 'o') ('l', 'l', 'o')
元组的单个元素是禁止被修改的,但是可以使用del来删除整个元组。删除后的元组将会释放所有的空间,原本的变量名重新进入未定义状态。
tu1=("h","o")
tu2="l","l","o"
del tu1
del tu2
print(tu1,tu2)
'''控制台报错:tu1和tu2是未定义的变量'''
元组有自己的操作方法,如表所示:
函数 | 说明 |
---|---|
len(tu) | 计算tu的元素个数 |
max(tu) | 返回tu中最大的元素 |
min(tu) | 返回tu中最小的元素 |
tu=tuple(ls) | 将元组tu赋值为ls列表内的元素 |
字符串
字符串在每种编程语言中几乎都有自己的特性,在Python中,字符串的定义如下:
str="hellopython"
字符串实际上是一种定长的列表,和列表一样可以使用索引访问单个字符。
print(str[0])
#控制台输出:h
字符串拥有自己的运算符,用于适应一些字符串的运算。
运算符 | 说明 |
---|---|
+ | 字符串连接 |
* | 重复输出字符串 |
<string> [i] | 字符串索引取单个字符 |
<string> [i:j] | 截取字符串从第i到j |
in | 成员运算符,检测是否为子元素,是为真,否则为假 |
not in | 成员运算符,检测是否为子元素,是为假,否则为真 |
for <var> in <string> | 字符串迭代 |
Python还内置了一些用于方便处理字符串运算的函数。
函数 | 说明 |
---|---|
len(str) | 返回字符串的长度 |
str.capitalize() | 返回一个第一个字符大写的新字符串 |
str.center(width) | 返回一个内容橘红,并使用空格填充至width的字符串 |
str.cont(chr,beg=0,end=len(str)) | 返回chr在字符串中1出现次数。如果制定了beg和end,则返回指定范围内的 |
str.find(chr,beg=0,end=len(str)) | 检测chr是否包含在字符串中,如果制定了beg和end,则检测是否在一定范围内。如果包含则返回第一次匹配的索引值,否则返回-1 |
str.isspace() | 如果字符串中只包含空格,则返回True,否则返回False |
str.join(seq) | 以整个字符串作为分隔符,将sep中所有的元素合并成一个新的字符串 |
str.lower() | 返回一个将所有大写转化成小写的新字符串 |
str.replace(chr1,chr2,num=str.count(chr)) | 返回一个新字符串,把原字符串的chr1转化成chr2,如果制定了num,则不超过num次 |
str.split(chr="",num=string.count(chr)) | 以chr为分隔符切片字符串,如果制定了num,则仅分隔num个子字符串 |
str.strip() | 返回一个去除首尾空格的行字符串 |
str.upper() | 返回一个将字符串中所有小写转化为大写的新字符串 |
字典
集合使用大括号进行赋值,可以在赋值前标加上键作为索引,键可以是数字或者其他类型的值(比如字符串)。集合用处和枚举变量相当,例如:
local={1:"食堂",2:"宿舍",3:"软件楼"}
集合的访问和类的属性调用相当,需要前缀集合名加上键作为索引,键需要使用中括号。
a=local[1]
#a的键为1,所带的值为"食堂"
Python有第三方字典作为中文的分词字典,可以用来划分词序,记录词语。
这是Jieba库的介绍:[介绍][https://blog.csdn.net/dongzixian/article/details/103240861?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163272200516780271524237%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=163272200516780271524237&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_click~default-2-103240861.pc_search_ecpm_flag&utm_term=JIEBA&spm=1018.2226.3001.4187]
Jieba库在联网的情况下可以直接使用命令行(CMD)进行下载:
第五章 · 函数与模块
函数的定义
Python函数的基本定义与大多数第四代计算机语言相同:
def <函数名>(参数列表):
函数体
[return 返回参数列表]
其中,return是否书写作为可选,如果不写表示return None
。虽然Python没有主函数,但文件运行逻辑中相当于整个函数都包含在一个main函数中,所以可以在函数范围外直接写主函数内容,相当于定义的函数只是一个特殊变量,不需要缩进代码来表示主函数范围。
参数的传递
和基础编程语言一样,一般的传参都是值传递,即传进函数的参数在参数列表完成一次复制产生虚参,虚参传入函数进行计算,而外部原本的实参不会因为函数内部的计算改变。
def sum(a,b):
a=a+1
b=b+1
a=1
b=2
sum(a,b)
print(a,b)
#控制台输出:1,2
和C语言一样,Python也支持可变数量的参数。只要在参数前加一个*
即表明这个参数是可变量参数,通常情况下可变参数会被编译器认定为一个元组。例如:
def test(a,*b):
for i in b:
print(a+i)
test(1,2,3,4)
#控制台输出:3
4
5
参数的返回
return语句和大部分语言一样用来退出函数,与其他语言不太相同的是,Python的return语句可以返回多个值,例如:
def test(a,b):
return a+b,a-b
a=test(1,2)
print(a)
#控制台输出:(3, -1)
在接收时,可以多个变量用逗号隔开进行接收返回值。例如:
a=1
b=2
def test(a,b):
a=a+b
b=a-b
return a,b
a,b=test(a,b)
print(a,b)
#控制台输出:3 1
注意,这种返回机制可能会出现以下问题:
-
如果返回值不止一个,但接收变量只有一个时,接收变量将会被定义为一个元组来接纳所有返回值。
-
如果返回值变量数和接收值变量数不相等并且接收变量大于一个时,无论哪边多,系统会报告一个错误。
以下是这种返回机制的实例:
a=1
b=2
def test(a,b):
a=a+b
b=a-b
return a
a,b=test(a,b) '''这里将会报告一个错误'''
print(a,b)
a=1
b=2
def test(a,b):
a=a+b
b=a-b
return a,b,3
a,b=test(a,b) '''这里将会报告一个错误'''
print(a,b)
a=1
b=2
def test(a,b):
a=a+b
b=a-b
return a,b,3
a=test(a,b)
print(a,b)
#控制台输出:(3, 1, 3) 2
Python没有显式的引用传递机制,也就是说,用户不能定义一个值是否能够引用传递。**在一定规则内,数字,元组,字符串只能进行值传递;列表,字典。只能引用传递。**与大部分语言不同的是,python的全局变量也是值传递的,使用时一定要注意全局变量不是引用传递,并且全局变量时需要用global
进行表示才能使用,否则使用的是局部变量。例如:
n=10
def test():
global n
n=n+1
print(n)
#控制台输出:10
第六章 · 面向对象编程
导言
先看一个实例:
class test:
def __init__(self,name,year):
self.name=name
self.year=year
def testfuc(self):
print("hello,class")
a=test("hi",13)
print(a.name,a.year)
a.testfuc()
#控制台输出:hi 13
#hello,class
总结出以下要点:
类的定义
因为类通常包括属性(变量)和方法(函数),所以需要分开定义。其中:
self
关键字:作用相当于this
指针,self关键字后引用的变量都表示类的属性变量,用来防止和局部变量冲突。类的所有函数包括无参函数中,参数列表都必须带有self
,否则会报错。- +
__init__()
函数:是构造函数,一般用于初始化属性,利用self引用的变量就是这个类的属性。如果其中的参数没有用self关键字进行引用将被认为是__init__()
函数的局部函数,无法使用对象将其引用。这个函数是所有类共有的。 - 属性:定义在方法之外的变量都是类的属性,如果在
__init__()
函数中使用self引用定义了的变量也会被编译器识别为属性。 - 方法:和普通函数的区别在于缩进和参数列表的self。
class test:
def __init__(self,name,year): #__init__()是系统函数,所有类的构造函数。有init两边都是两道斜杠
self.name=name #self类似于this指针
self.year=year #name和year都是这个类的属性
def testfuc(self): #方法书写方式和普通函数一样
print("hello,class")
对象的定义
Python类的定义很像函数定义,是一个赋值计算。等号左侧是对象名,等号右侧是类名和构造函数参数列表。注意,无论是构造函数还是普通方法,self都是不占有参数列表位置的。可以认为self被隐藏了。
a=test("hi",13)
对象的使用
对象使用方法和常规面向对象编程语言一样,都是用点来表示对象对类方法或者属性的引用。
print(a.name,a.year) #a.name引用的是对象a的属性name
a.testfuc() #a.testfuc()引用的是对象a的方法testfuc()
继承
继承方法是在定义类的时候在后面用括号将父类填入,例如:
class son(father):
<类模块>
注意:Python是支持多继承的(一个子类继承于两个以上的父类),这对面向对象来说是个不好的特性,虽然多继承对可以减少代码重写,但是多继承往往会出现属性方法混乱,所以尽量不要使用多继承。书写方法是将父类用逗号隔开。
class son(fa1,fa2):
<类模块>
重写
如果子类有和父类的同名函数,则会发生函数重写。重写会将子类定义的对象中所有同名的函数用子类的定义实现,父类的函数将会被隐藏。父类定义的对象不受影响。属性也会发生重写,但是Python的变量的类型本来就可以随意变化,所以Python中属性重写意义不大。例如:
class test:
sha=1
def __init__(self,name,year):
self.name=name
self.year=year
def hw(self):
print("yes")
class test2(test):
def hw(self):
print("no")
a=test("ab",1)
b=test2("ba",0) #b的属性继承自a
a.hw()
b.hw()
#控制台输出:yes
#no
多态
Python实际上不支持多态,但是有super()函数进行使用。Python的super()函数只能在类的方法这中使用,用这个在子类方法中调用父类方法。
class test:
sha=1
def __init__(self,name,year):
self.name=name
self.year=year
def hw(self):
print("yes")
class test2(test):
def hw(self):
print("no")
super().hw() #super()函数的调用
a=test("ab",1)
b=test2("ba",0)
b.hw()
#控制台输出:no
#yes
lass son(father):
<类模块>
注意:Python是支持多继承的(一个子类继承于两个以上的父类),这对面向对象来说是个不好的特性,虽然多继承对可以减少代码重写,但是多继承往往会出现属性方法混乱,所以尽量不要使用多继承。书写方法是将父类用逗号隔开。
```python
class son(fa1,fa2):
<类模块>
重写
如果子类有和父类的同名函数,则会发生函数重写。重写会将子类定义的对象中所有同名的函数用子类的定义实现,父类的函数将会被隐藏。父类定义的对象不受影响。属性也会发生重写,但是Python的变量的类型本来就可以随意变化,所以Python中属性重写意义不大。例如:
class test:
sha=1
def __init__(self,name,year):
self.name=name
self.year=year
def hw(self):
print("yes")
class test2(test):
def hw(self):
print("no")
a=test("ab",1)
b=test2("ba",0) #b的属性继承自a
a.hw()
b.hw()
#控制台输出:yes
#no
多态
Python实际上不支持多态,但是有super()函数进行使用。Python的super()函数只能在类的方法这中使用,用这个在子类方法中调用父类方法。
class test:
sha=1
def __init__(self,name,year):
self.name=name
self.year=year
def hw(self):
print("yes")
class test2(test):
def hw(self):
print("no")
super().hw() #super()函数的调用
a=test("ab",1)
b=test2("ba",0)
b.hw()
#控制台输出:no
#yes