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中变量是不需要定义即可使用的，如果要使用一个变量，可以进行一个赋值操作，例如：

1
a=0

​ 在这之后，a就可以作为一个被编译器所知的变量进行使用了，不会出现变量未定义的错误。

​ Python的变量不被数据类型所限制，可以随时转换一个变量的数据类型，例如：

1
2
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注释分为单行注释和多行注释，注释并不会被编译器编译，用来进行说明。

​ 单行注释使用#标记开头，#后的内容将会被标记为注释，一直延伸到本行结束。

1
#这是一个单行注释，后面无论多长只要不换行都是注释，但是#前面的代码还是会被检测和编译

​ 多行注释使用三个单引号或者三个双引号作为其实或者结束的标签。

1
2
3
4
5
6
7
"""这里是多行注释的开始
此下是内容
只要没有遇到结束的标志
就可以一直换行
然后这段注释在标志前结束"""

'''你也可以用标签来在行内进行注释，同一行内标签外的内容依旧会被编译器检查和翻译'''

​ 单行注释常用作对某一行的说明，多行注释可以把不确定的代码括起来，让编译时这段代码不运行来查错。

数据类型的强制转换

​ Python库给了三个常用的数据转换函数：

​ int():将括号里的内容强制转换为int型，向下取整（去掉小数取整，而非舍入取整）。

​ float():强制转换成浮点型。

​ str():强制转换为字符串型。

1
2
3
4
5
a=12345
b=0.5
c=b+float(a)
d=str(c)
print(d)	#将计算结果打印出来

​ 字符和整型之间转换可以通过这两个函数进行转换：

​ ord():获取单个字符的ASCII码值。

​ chr():根据一个ASCII码值给出对应的字符。

1
2
3
a="M"
b=ord(a)	#a必须只能是单个字符，多个字符会报错
print("M在ascii码表上的位置是",b)

特别注意的是，如果数字和字符串同时输出时，需要将数字强制转换成字符串类型，否则系统会报错：

1
2
3
4
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

​ 逻辑运算符可以通过括号连接组成很长的比较式，用于处理复杂情况。

1
2
3
4
A=1,B=2
C=(A>B)and(A<B)
D=(not(A>B))or(A<B)
#逻辑运算符一般是在循环结构或者条件结构的条件框中出现

逻辑短路现象

​ 在类C语言的程序语言中，一切非零数字都可以代表True，而零代表False。所以你可以仅用逻辑运算符而不用关系运算符的情况下连接两个int数据，它们的计算结果是有效的，但是计算结果不是True或False而是int。

1
2
3
4
A=3
B=-1
C=A and B
#这样的计算结果是有效的，C是int型数据，真假与A和B的值有关

​ 这样的算术式，会出现逻辑短路现象。逻辑短路现象普遍的存在于各种编程语言中，用于减轻逻辑计算时的计算时长和资源消耗。

逻辑短路现象是指，编译器在处理含有and和or的表达式中，会偏向以最快度速度完成表达式计算，所以会出现以下现象：

A and B ：当A被检测到为False时，B不会被编译器检测，这段表达式被直接定义为False。这样做的原因是A已经确定为假，B的真假并不会改变这段表达式的计算结果，所以B不会被检测和运算。

A or B ：当A被检测到为True时，B不会被编译器检测，这段表达式直接定义为True，其原因和上一条相同。

​ 逻辑短路现象提高了程序的运行速率也同样带来了一些问题，例如在C语言中，如果B中含有赋值运算则这段运算也不会运行，相当于这段代码被跳过了。比如这样：

1
2
3
4
5
6
7
8
9
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类型数据时的计算。

1
2
3
4
5
6
7
8
9
10
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

​

运算符优先级顺序

1
算术运算符>关系运算符>not>and>or>赋值运算符

​ 通过合理的使用括号可以限制运算符的优先顺序。

第二章 · 数据的输入与输出

​ print函数可以用于输出各种变量，基本语法示例如下：

1
2
print("hello,wrold")
#控制台输出：hello,world

​ 事实上，对于print()来说"hello,wrold"相当于一个字符串变量，应当理解为print的输出是以变量为基本单位的。同理print()可以单个输出其他变量，示例如下：

1
2
3
4
5
6
7
8
9
10
11
A=True
print(A)
#控制台输出：True

B=3
print(B)
#控制台输出：3

C="goodbye"
print(C)
#控制台输出：goodbye

​ print()提供了,逗号分隔符，逗号分隔符会在控制台输出时生成一个空格占位符，逗号分隔符可以分隔多个变量让print()函数一次输出更多东西。

1
2
3
4
5
6
7
8
9
A=1
B="天"
print(A,B)
#控制台输出：1 天

A="hello"
B="world"
print(A,B)
#控制台输出：hello world

​ sep：自定义分隔符，写在print()括号内所有变量最后，语法为sep="~自定义分隔符号~"。默认值为一个空格。

​ end：自定义终止符，写在print()括号内所有变量最后，语法为end="~自定义终止符号~"。默认值为换行符\n。

1
2
3
4
5
6
7
print("hello","world",sep="and")
#控制台输出：helloandworld

print("hello","world",sep="and",end="\nthis is the end")
#控制台输出：
#helloandworld
#this is the end

转义符

​ 计算机中有一类特殊的字符通过键盘直接输出，或者进入代码中会影响当前程序，此时就需要用到转义符。这里将常用的分隔符加入了*号。

转义符 说明
\ 用在行尾，表示续行符
\\ 输出反斜杠
\' 输出单引号
\" 输出双引号
*****\n 输出换行符
*****\t 输出制表符

input()函数

​ 基础语法如下：

1
A=input()

​ 其中，input括号中可以加入一行提示字符，给用户在输入前输出一行提示。

1
2
3
4
5
6
7
A=input("请输入一个10以内的整数")
print("您输入的数字为",A)

#控制台：
#请输入一个10以内的整数
#[用户输入]:20
#您输入的数字为20

​ 特别注意，input并不能分清字符串与bool变量，所以如果输入True或者False将会储存”True”或”False”的字符串变量，并不是bool类型，所以想要通过用户输入来给bool赋值必须要通过条件语句才能实现，不能直接使用input()函数实现。

第三章 · 结构语句

条件语句

​ 条件语句常用来处理需要分条件来实现代码的情况，基本语法为：

1
2
if 条件 :#可以在条件前后加上括号，这样会更像其他高级语言的if结构
    <代码块>
  • Python中没有花括号限制if的域，所以if的作用空间通过缩进来限制。
  • [条件]可以用逻辑运算符连接很长的代码。
  • 比较其他高级语言的if，Python的if中条件的括号框是可选的，但是条件结束后无论有没有括号都需要在行末加上一个冒号:用于表示代码块的开始。

​ 条件语句存在双分支的情况，所以此时还可以写为：

1
2
3
4
if 条件 :
    <代码块1>
else :
    <代码块2>
  • else是可选的，但是一个if条件语句中，至多允许存在一个else。
  • else是没有[条件]的，其内的代码仅在if条件为假时才会运行。

​ 条件语句还存在更复杂的分支情况，所以还可以写为：

1
2
3
4
5
6
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循环是最基础的循环语句，基础语法如下：

1
2
while 循环条件 :
    <循环操作>
  • 循环一旦开始，在循环条件为假之前会一直运行
  • 可以在循环条件中填入True来构造一个无限循环。

​ while循环还可以继续扩展，这是Python独有的写法：

1
2
3
4
while 循环条件 :
    <循环操作>
else :
    <语句块>
  • 如果进入循环时检测条件为假（即从一开始循环条件就是假），else会直接运行。
  • while循环操作执行完成后，else会运行一遍，这是因为while循环执行完成的标志就是循环条件为假，而这是else的运行条件。
  • 综上，只要while不是无限循环，else总会并且只会运行一次。

for循环语句

​ for语句常用于快速遍历数组，其基本语法如下：

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

​ 其中遍历结构可以是字符串、range()函数、文件或者组合数据类型。下面是使用案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for A in range(3): #range(N)函数表示循环N次
    print("循环")
#控制台输出：
#循环
#循环
#循环

A="hello"
for B in A :
    print(B)
#控制台输出:
#h
#e
#l
#l
#o

​ for循环语句同样可以进行扩展，这也是Python独有的：

1
2
3
4
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语言定义数组的方式相似，但是使用的限制是中括号。

1
List=["元素1"，"元素2"，"元素3"]

​ 列表支持索引序列访问，所以可以用访问数组元素的方式访问它的各个元素，和类C语言一样，序列的第一位元素的索引值为0.

1
2
3
4
List=["元素1"，"元素2"，"元素3"]
A=List[0]
print(A)
#控制台输出：元素1

​ 列表索引下标也可以是负数，-1是列表的最后一个元素，以此类推可以用负数反向访问列表。

1
2
3
4
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循环构造一个遍历代码，方便操作。

1
2
3
4
5
6
7
8
9
10
11
12
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()函数可以生成一个新序列，将排序好的元素加入到新序列中。这样做的好处是原列表不会被修改。

1
2
3
4
list1=[3,2,1]
list2=sorted(list1)
print(list2)
#控制台输出:[1,2,3]

​ 当然如果原列表已经没有用了，可以用<list>.sort()方法直接进行修改，这样会更加节约空间。

1
2
3
4
list1=[3,2,1]
list1.sort()
print(list1)
#控制台输出:[1,2,3]

元组[枚举数组]

​ 元组类似于类C语言中的枚举数组，内容一旦确定后，元组内的元素不能再进行改变。

​ 元组的创建和列表类似，元组使用的是小括号(小括号是可选的)

1
2
3
4
tu1=("h","o")
tu2="l","l","o"
print(tu1,tu2)
#控制台输出:('h', 'o') ('l', 'l', 'o')

​ 元组的单个元素是禁止被修改的，但是可以使用del来删除整个元组。删除后的元组将会释放所有的空间，原本的变量名重新进入未定义状态。

1
2
3
4
5
6
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中，字符串的定义如下：

1
str="hellopython"

​ 字符串实际上是一种定长的列表，和列表一样可以使用索引访问单个字符。

1
2
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() 返回一个将字符串中所有小写转化为大写的新字符串

字典

​ 集合使用大括号进行赋值，可以在赋值前标加上键作为索引，键可以是数字或者其他类型的值（比如字符串）。集合用处和枚举变量相当，例如：

1
local={1:"食堂",2:"宿舍",3:"软件楼"}

​ 集合的访问和类的属性调用相当，需要前缀集合名加上键作为索引，键需要使用中括号。

1
2
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-2~all~top_click~default-2-103240861.pc_search_ecpm_flag&utm_term=JIEBA&spm=1018.2226.3001.4187]

​ Jieba库在联网的情况下可以直接使用命令行(CMD)进行下载：

​ 输入

​ >pip install jieba

​ 进行jieba库的下载，如果电脑上自带jieba但是没有更新，可以输入

​ >python -m pip install –upgrade pip

​ 显示

​ >Successfully installed pip-x.x.x(后面三个点是jieba的版本)

​ 表明jieba库正常加载

第五章 · 函数与模块

函数的定义

​ Python函数的基本定义与大多数第四代计算机语言相同：

1
2
3
def <函数名>(参数列表):
	函数体
	[return 返回参数列表]

​ 其中，return是否书写作为可选，如果不写表示return None。虽然Python没有主函数，但文件运行逻辑中相当于整个函数都包含在一个main函数中，所以可以在函数范围外直接写主函数内容，相当于定义的函数只是一个特殊变量，不需要缩进代码来表示主函数范围。

​

参数的传递

​ 和基础编程语言一样，一般的传参都是值传递，即传进函数的参数在参数列表完成一次复制产生虚参，虚参传入函数进行计算，而外部原本的实参不会因为函数内部的计算改变。

1
2
3
4
5
6
7
8
9
10
def sum(a,b):
    a=a+1
    b=b+1

a=1
b=2
sum(a,b)
print(a,b)

#控制台输出：1,2

​ 和C语言一样，Python也支持可变数量的参数。只要在参数前加一个*即表明这个参数是可变量参数，通常情况下可变参数会被编译器认定为一个元组。例如：

1
2
3
4
5
6
7
8
def test(a,*b):
    for i in b:
        print(a+i)
test(1,2,3,4)

#控制台输出：3
4
5

参数的返回

​ return语句和大部分语言一样用来退出函数，与其他语言不太相同的是，Python的return语句可以返回多个值,例如：

1
2
3
4
5
6
def test(a,b):
    return a+b,a-b
a=test(1,2)
print(a)

#控制台输出：(3, -1)

​ 在接收时，可以多个变量用逗号隔开进行接收返回值。例如：

1
2
3
4
5
6
7
8
9
10
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

​ 注意，这种返回机制可能会出现以下问题：

  • 如果返回值不止一个，但接收变量只有一个时，接收变量将会被定义为一个元组来接纳所有返回值。

  • 如果返回值变量数和接收值变量数不相等并且接收变量大于一个时，无论哪边多，系统会报告一个错误。

    以下是这种返回机制的实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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进行表示才能使用，否则使用的是局部变量。例如：

1
2
3
4
5
6
7
8
n=10
def test():
    global n
    n=n+1

print(n)

#控制台输出：10

第六章 · 面向对象编程

导言

什么是面向对象编程？

​ 如果你之前并没有了解过面向对象编程，不清楚类和对象，我在这里做一个简单的说明。

​ C语言编程和本章之前的编程都是面向过程的，意思就是你的程序每一步的运行都需要你一步一步来设计，面向整个程序的运行过程来设计你的代码。面向对象可以认为是高级抽象版的面向过程，他加入了类和对象这组概念。

​ 类是一种特殊的数据结构，包括属性（变量）和方法（函数）这两大元素。举例，如果将水杯看做成类，那么它的容量、底面积、高度、底面直径就是属性，水杯可以喝水、装水、倒水这些行为就是方法。如果你学过C语言，你应该知道struct(结构体)，类就是高级结构体，结构体只能包括变量，类比起结构体还能包括函数。

​ 对象是类的实现，对象和类的关系就是制造出的实物和模具。用整型数据举例： a=10 你可以认为整型数据（int）就是类，它的属性就是他带有的整型数的具体值，而它的方法就是可以进行加减乘除四则运算。a是实现后的整型数据，可以认为a是整型数据类的对象。

​ 为什么要用面向对象编程？

​ 利用面向对象，用户可以很容易将原本的过程代码抽象出类和对象来。比如实现复数加减运算，如果是面向过过程则需要写一个分步计算函数，先计算实数加减，再计算虚数部加减，最后再虚数部输出一个i完成一个拼接的假运算（显示）。

​ 如果用面向对象，你可以给复数类定义一个实数部的属性，定义一个虚数部的属性。定义一个加减法运算方法（实现过程其实和面向对象的那个函数一样）。因为例子简单，现在还看不出面向对象的先进性。

​ 但是如果此时需求需要程序可以进行复数乘除法运算呢?

​ 面向过程需要重新写一个实数部虚数部乘除法运算，并且还要在系统输入时增加提示。但是面向过程只需要加一个乘除法运算的方法就好了。如果用例有数十个属性和方法，面向过程就需要重写出很多函数和冗余的变量，但是面向对象只需要向类中加入方法就好了，这是面向对象的优点之一。

先看一个实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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。
1
2
3
4
5
6
7
8
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被隐藏了。

1
a=test("hi",13)

对象的使用

​ 对象使用方法和常规面向对象编程语言一样，都是用点来表示对象对类方法或者属性的引用。

1
2
print(a.name,a.year)	#a.name引用的是对象a的属性name
a.testfuc()			#a.testfuc()引用的是对象a的方法testfuc()

继承

​ 继承是面向对象编程共有的特点，意义在于定义一个从旧类出来的新类，新类选择性包含旧类中的属性和方法。新类被称为子类，旧类被称为父类。

​ 父类产生子类的过程称为派生，子类对于父类的过程称为继承。

​ 这样做的好处在于，大型工程中一个以前被定义的类如果需要更新，但是原本的类文件已经被定义了禁止修改（这很常见，核心文件一般都是只读的，因为简单的修改可能会出现很大的问题），可以使用继承一个子类替代父类，将新功能加进去在今后的代码中使用。

​ 继承方法是在定义类的时候在后面用括号将父类填入，例如：

1
2
class son(father):
	<类模块>

​ 注意：Python是支持多继承的（一个子类继承于两个以上的父类），这对面向对象来说是个不好的特性，虽然多继承对可以减少代码重写，但是多继承往往会出现属性方法混乱，所以尽量不要使用多继承。书写方法是将父类用逗号隔开。

1
2
class son(fa1,fa2):
	<类模块>

重写

​ 如果子类有和父类的同名函数，则会发生函数重写。重写会将子类定义的对象中所有同名的函数用子类的定义实现，父类的函数将会被隐藏。父类定义的对象不受影响。属性也会发生重写，但是Python的变量的类型本来就可以随意变化，所以Python中属性重写意义不大。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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()函数进行使用。和Java不同，Python的super()函数只能在类的方法这中使用，用这个在子类方法中调用父类方法。(Java的super()函数可以在对象上使用，灵活调用子类和父类的同名函数，Python没有实现这个功能)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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