python期末复习笔记

python笔记

目录

python笔记

第一章

1. 编译&解释的区别和联系 p8~

2. Python 3.0无法向下兼容python 2.0的既有语法 p11

3. Python 语言的特点 p12

4. 启动&运行方式 p15

5. IPO程序编写方法概念 p22

第二章

1. Python程序语法元素分析 p36

2. Python蟒蛇绘制 p46

第三章 （较为琐碎，边动手边记）

1. 数字类型 p62

2. 数字类型的操作 p66

3. math库的使用 p70

4. 字符串类型及其操作 p78

5. 字符串类型的格式化 p85

第四章

1. if-else语句（二分支） p102

2. 遍历循环：for 语句 p107

3. 无限循环：while 语句 p108

4. 循环保留字：break和continue p109

5. 程序的异常处理 p116

第五章

1. 函数的基本使用 p124

2. 函数的参数传递 p128

3. 函数的递归 p134

4. Python的内置函数 p149

第六章 建议多动手

1. 组合数据类型概述p154

2. 序列类型 p155

3. 集合类型 p157

4. 映射类型 p159

第七章

1. 文件概述 p182

2.文件的打开关闭 p183

3. PIL库的使用 p187

---

第一章

1. 编译&解释的区别和联系 p8~

编译 是一次性翻译，运行速度快，目标代码不需要编译器就可以运行，在同类型操作系统上使用灵活

解释 执行时需要保留原代码，程序纠错维护方便，可移植性好

2. Python 3.0无法向下兼容python 2.0的既有语法 p11

3. Python 语言的特点 p12

• 语法简洁

• 与平台无关：脚本语言可移植性好

• 粘性拓展：可以集成C、C++、Java等语言编写的代码，将他们通过接口和函数库整合。此外，Python语言提供了良好的语法和执行拓展接口，能够整合各类程序代码

• 开源理念：有开源的解释器和函数库

• 通用灵活：应用领域广

• 强制可读：通过强制缩进来体现语句间的逻辑关系，提高了可读性和程序的可维护性

• 支持中文

• 模式多样：虽然Python解释器内部通过面向对象实现，但Python语法层面同时支持面向过程和面向对象

• 类库丰富：有大量内置类和函数库

4. 启动&运行方式 p15

1. 交互式

法一：启动cmd，在控制台中输入”Python“，在命令提示符>>>后输入：print("hello world") 按Enter键后显示结果

在>>>提示符后输入exit()或quit()来退出Python运行环境

法二：安装IDLE（Python软件包自带的集成开发环境）来启动Python运行环境

1. 文件式

法一：按Python语法格式编写代码，并保存为.py 形式的文件（如hello .py），然后打开cmd，进入hello .py文件所在目录，运行Python程序文件获得输出

法二（推荐使用）：打开IDLE，新建窗口（不是交互模式，而是一个具备Python语法高亮辅助的编辑器，可进行代码编辑），输入Python代码，按F5运行

5. IPO程序编写方法概念 p22

每个程序都有统一的运算模式，即输入数据，处理数据和输出数据，这种朴素运算模式形成了程序的基本编写方法，即 IPO 方法

Input（输入）方式： 文件输入、网络输入、控制台输入、交互界面输入、随机数据输入、内部参数输入

Output（输出）方式：文件输出、网络输出、控制台输出、图形输出、操作系统内部变量输出

Process（处理）：是程序对输入数据进行计算产生输出结果的过程。计算问题的处理方法统称”算法“

第二章

1. Python程序语法元素分析 p36

Python程序包括格式框架、注释、变量、表达式、分支语句、循环语句、函数等语法元素

• 框架：采用严格的”缩进“来表明程序的格式框架

• 注释：单行注释以#开头，多行注释以'''开头和结尾

• 命名与保留字：Python语言允许 大小写字母、数字、下划线和汉字等字符及其组合给变量命名，但名字的首字符不能是数字，中间不能出现空格，长度没有限制；保留字见书 p39 表2.1

• 字符串：Python字符串提供区间访问方式，采用 [N:M] 格式表示字符串中从N到M（不包含M的）的子字符串。其中，N和M为索引符号，可以混合使用正向递增序号和反向递减序号。见书 p39 图2.2

• 赋值语句：可用同步赋值语句：x,y=y,x

• input()函数：从控制台获得用户输入，input()函数都以字符串类型返回结果，若要计算，要用eval()函数将字符串变成数参与运算

• eval()函数：将输入的字符串转变为Python语句，并执行该语句。

• print()函数：当输出变量值是，需要采用格式化输出方式，通过format()方法（详见书 p85）将待输出变量整理成期望输出的格式

• 循环语句

• 函数：先用def定义函数，之后可直接引用这个函数（封装）

2. Python蟒蛇绘制 p46

供练习

---

---

第三章 （较为琐碎，边动手边记）

1. 数字类型 p62

• 整数类型

  整数类型的四种进制表示

  进制类型	引导符号	描述
  十进制	/	默认情况
  二进制	0b或0B	由字符0和1组成，如0b101，0B101
  八进制	0o或0O	由字符0~7组成，如0o711，0O711
  十六进制	0x或0X	由字符0~9、 a~f、 A~F组成，如0xABC

  pow函数：pow(x,y)=xy ，可用来测试计算机整数类型的取值范围（理论范围是无穷）

• 浮点数类型

十进制表示：0.0 ， -77. ， -2.17 ， 3.1416

科学计数法表示：96e4 , 4.3e-3 , 9.6E5

4.3e-3=0.0043

9.6E5 可表示为 9.6E+5 ，其值=960000.0

• 复数类型

表示为a+b （a+bJ)

对于复数z，可用z.real和z.imag分别获得它的实部和虚部

例：

 >>>(1.23e-4+5.67e+89j).real
 0.000123
 >>>(1.23e-4+5.67e+89j).imag
 5.67e+89

2. 数字类型的操作 p66

• 内置的数值运算操作符

操作符	描述
x+y	和
x-y	差
x*y	积
x/y	商
x//y	整数商，即不大于x与y之商的最大整数
x%y	余数（亦叫取模）
-x	负值
+x	本身
x**y	xy

• 内置的数值运算函数

函数	描述
abs(x)	x的绝对值
divmod(x,y)	(x//y,x%y)，输出为二元组形式（也成为元组类型）
pow(x,y[,z])	(x* *y)%z，[..]表示该参数可以省略，即pow(x,y)，它与x**y相同
round(x[,ndigits])	对x四舍五入，保留ndigits位小数，round(x)返回四舍五入的整数值
max(x1,x2,,...,xn)	x1,x2,,...,xn的最大值，n没有限定
min(x1,x2,,...,xn)	x1,x2,,...,xn的最小值，n没有限定

注：abs()可以计算复数的绝对值

• 内置的数字类型转换函数

函数	描述
int(x)	将x转换为整数，x可以是浮点数可字符串
float(x)	将整数和字符串转换成浮点数
complex(re[,im])	生成一个复数，实部为re，虚部为im，re可以是整数、浮点数或字符串，im可以是整数或浮点数，但不能是字符串

3. math库的使用 p70

• 库的引用

法一：import math

对math库中函数采用math.<函数名>()形式使用，例：

 >>>import math
 >>>math.ceil(10.2)
 11

法二：from math import<函数名>

对math库中函数可以直接采用<函数名>()形式使用，例：

 >>>from math import floor
 >>>floor(10.2)
 10

• math库解析

 

 

 

 

4. 字符串类型及其操作 p78

• 基本的字符串操作符

操作符	描述
x+y	连接两个字符串x,y
x*n 或 n *x	复制n次x
x in s	如果x是s的子串，返回True，否则返回False
str[i]	索引，返回第i个字符
str[N:M]	切片，返回索引第N到第M的子串（不包含M）

• 特殊的格式化控制字符

字符	效果
\a	蜂鸣，响铃
\b	回退，向后退一格
\f	换页
\n	换行，光标移动到下行行首
\r	回车，光标移动到本行行首
\t	水平制表
\v	垂直制表
\0	NULL，什么都不做

• 内置的字符串处理函数

函数	描述
len(x)	返回字符串x的长度，也可返回其他组合数据类型元素个数
str(x)	返回任意类型x所对应的字符串形式
cha(x)	返回Unicode编码x对应的单字符
ord(x)	返回单字符表示的Unicode编码
hex(x)	返回整数x对应十六进制数的小写形式字符串
oct(x)	返回整数x对应八进制数的小写形式字符串

• 常用的内置字符串处理方法 详见p83-p84

方法	描述
str.lower()	返回字符串str的副本，全部字符小写
str.upper()	返回字符串str的副本，全部字符大写
str.islower()	当str所有字符都是小写时，返回True，否则返回False
str.isprintable()	当str所有字符都是可打印的，返回True，否则返回False
str.isnumeric()	当str所有字符都是数字时，返回True，否则返回False

5. 字符串类型的格式化 p85

• format()方法

format()方法可以非常方便地连接不同类型的变量或内容，若要输出大括号，{{表示{，}}表示}

 >>>"{}{}{}".format("圆周率是",3.1415926,"...")
 '圆周率是3.1415926...'
 >>>"圆周率{{{1}{2}}}是{0}".format("无理数"，3.1415926，"...")
 '圆周率{3.1415926...}是无理数'
 >>>s="圆周率{{{1}{2}}}是{0}"                                   #大括号本身是字符串的一部分
 >>>s
 '圆周率{{{1}{2}}}是{0}'
 >>>s.format("无理数",3.1415926,"...")                          #当调用format()时解析大括号
 '圆周率{3.1415926...}是无理数'

• format()方法的格式控制

:	<填充>	<对齐>	<宽度>	<,>	< . 精度 >	<类型>
引导符号	用于填充的单个字符	<左对齐 >右对齐 ^居中对齐	槽的设定输出宽度	数字的千位分隔符 适用于整数和浮点数	浮点数小数部分的精度 或字符串的最大输出长度	整数类型 b,c,d,o,x,X 浮点数类型 e,E,f,%

 >>>s ="Python"
 >>>"{0:30}".format(s)
 'Python'                                   #默认左对齐
 >>>"{0:>30}".format(s)
 '                        Python'           #右对齐         
 >>>"{0:*^30}".format(s)
 '************Python************'           #居中并使用*填充
 >>>"{0：-^30}".format(s)
 '------------Python------------'           #居中并使用*填充
 >>>"{0:3}".format(s)
 'Python'                                   #参数长度比设定宽度大时，使用参数实际长度

• "," 用于显示数字类型中的千位分隔符

 >>>"{0:-^20,}".format(1234567890)
 '---1,234,567,890----'
 >>>"{0:-^20}".format(1234567890)
 '-----1234567890-----'
 >>>"{0:-^20,}".format(12345.67890)
 '----12,345.67890-----'                     #小数点"."不占位

• < . 精度 >:对于浮点数，表示小数部分有效位数（四舍五入）；对于字符串，表示输出的最大长度

 >>>"{0:.2f}".format(12345.67890)
 '12345.68'
 >>>"{0:H^20.3f}".format(12345.67890)
 'HHHHH12345.679HHHHHH'
 >>>"{0:.4}".format("PYTHON")
 'PYTH'

• <类型>

整数

1）b：输出整数的二进制方式

2）c：输出整数对应的Unicode字符

3）d：输出整数的十进制方式

4）o：输出整数的八进制方式

5）x：输出整数的小写十六进制方式

6）X：输出整数的大写十六进制方式

 "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
 '110101001,Ʃ,425,651,1a9,1A9'

浮点数

1）e：输出浮点数对应的小写字母e的指数形式

2）E：输出浮点数对应的大写字母E的指数形式

3） f：输出浮点数的标准浮点形式

4）%：输出浮点数的百分形式

注：输出浮点数时尽量使用< . 精度 >表示小数部分的宽度，有助于更好控制输出格式

>>>"{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'
>>>"{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14)
'3.14e+00,3.14E+00,3.14,314.00%'

第四章

1. if-else语句（二分支） p102

如果用户只关心空气质量是否污染两种情况，可以通过二分支语句完成

PM = eval(input("请输入PM2.5数值："))
if PM>= 75:
    print("空气存在污染，请小心！")
else:
    print("空气没有污染，可以开展户外活动！")

简洁表达式：<表达式1> if <条件> else <表达式2>

PM = eval(input("请输入PM2.5数值："))
print("空气{}污染！".format("存在" if PM>=75 else "没有"))

if-else的紧凑结构非常适合对特殊值的处理

>>>count=2
>>>count if count!=0 else "不存在"
2
>>>count=0
>>>count if count!=0 else "不存在"
"不存在"

2. 遍历循环：for 语句 p107

基本使用方法：

for <循环变量> in <遍历结构>：

<语句块>

遍历结构可以是字符串、文件、组合数据类型或range()函数等，常用使用方式如下：

循环N次 遍历文件fi的每一行 遍历字符串s 遍历列表ls

for i in range(N): for line in fi: for c in s: for item in ls:

拓展模式（执行完循环后执行else后的语句）：

for <循环变量> in <遍历结构>:

<语句块1>

else:

<语句块2>

例：

for s in "BIT":
    print("循环进行中："+s)
else:
    s="循环正常结束"
print(s)

执行结果如下：

循环进行中：B 循环进行中：I 循环进行中：T 循环正常结束

3. 无限循环：while 语句 p108

基本使用方法：

while <条件>:

<语句块>

拓展模式：

while <条件>：

<语句块1>

else:

<语句块2>

例：

s,idx="BIT",0
while idx < len(s):
    print("循环进行中："+s[idx])
    idx+=1
else:
    s="循环正常结束"
print(s)

执行结果如下：

循环进行中：B 循环进行中：I 循环进行中：T 循环正常结束

4. 循环保留字：break和continue p109

break用来跳出最内层循环，但仍继续执行外层循环。每个break语句只有能力跳出当前当前层次循环。

continue用来结束当前循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。对于while循环，继续求解循环条件；对于for循环，程序流程接着遍历循环列表。

对比如下：

for s in "PYTHON":
    if s=="T":
        continue
    print(s,end="")

执行结果如下：

PYHON

for s in "PYTHON":
    if s=="T":
        break
    print(s,end="")

执行结果为：

PY

5. 程序的异常处理 p116

语法格式：

try:

<语句块1>

except <异常类型1>:

<语句块2>

...

except <异常类型N>:

<语句块N+1>

except :

<语句块N+2>

其中，第一个到第N个except语句后面都指定了异常类型，说明这些except所包含的语句块只处理这些类型的异常。最后一个except语句没有指定任何类型，表示它对应的语句块可以处理其它所有异常。

例：

try:
    alp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    idx=eval(input("请输入一个整数："))
    print(alp[idx])
except NameError:
    print("输入错误，请输入一个整数")
except:
    print("其他错误")

执行结果如下：

请输入一个整数：NO 输入错误，请输入一个整数

请输入一个整数：100 其他错误

※采用try-except 语句会影响代码的可读性，增加代码维护难度。所以一般只在关键地方采用try-except类型语句处理可能发生的异常

第五章

1. 函数的基本使用 p124

定义函数语法如下：

def <函数名>(<参数列表>)：

<函数体>

return<返回值列表>

注：当需要返回值时，使用保留字return和返回值列表，否则函数可以没有return语句，在函数体结束位置将控制器返回给调用者。

2. 函数的参数传递 p128

• 可选参数

函数被调用时，如果没有输入对应参数值，则用函数定义时的默认值替代；由于函数调用时需要按顺序调用参数，可选参数必须定义在非可选参数的后面，即times必须定义在str后面。

>>>def dup(str,times=2):
    print(str*times)
>>>dup("knock~")
knock~knock~
>>>dup("knock~",4)
knock~knock~knock~knock~

• 可变数量参数

在参数前追加（星号）实现。带有星号的可变参数只能出现在参数列表最后。调用时，这些参数被当作元组类型传递到函数中

>>>def vfunc(a,*b):
    print(type(b))
    for n in b:
        a+=n
        return a
>>>vfunc(1,2,3,4,5)

15

• 参数的位置和名称传递

假设func()函数定义为：其参数分别表示两组三维坐标值。

func(x1,y1,z1,x2,y2,z2):

return

实际调用如下：

result=func(1,2,3,4,5,6)

因为仅看实际调用而不看函数定义，很难理解输入参数的含义，可读性低，所以Python提供了按照形参名称输入实参的方式，此时函数调用如下：

result=func(x2=4,y2=5,z2=6,x1=1,y1=2,z1=3)

• 函数的返回值

return语句用来退出函数并将程序返回到函数被调用的位置继续执行。return语句可以同时将0个、1个或多个函数运算后的结果返回给函数被调用处的变量，例：

>>>def func(a,b):
    return a*b
>>>s=func("knock~",2)
>>>print(S)
knock~knock~

函数可以没有return值，此时函数并不返回值。函数也可以用return返回多个值，多个值以元组类型保存，例：

>>>def func(a,b)
		return b,a
>>>s=func("konck~",2)
>>>print(s,type(s))
(2,'knock~')

• 函数对变量的作用（全局变量和局部变量）

全局变量：在函数外定义的变量，一般没有缩进，在程序执行全过程有效

局部变量：在函数内使用的变量，仅在函数内部有效，退出函数将不存在

>>>n=1								#n是全局变量
>>>def func(a,b):					
    n=b								#这个n是在函数内存中新生成的局部变量，不是全局变量
    return a*b
>>>s=func("knock~",2)
>>>print(s,n)						#测试一下n值是否改变
knock~konck~ 1						#n没有改变

如果希望让func()函数将n当作全局变量，需要在变量n前使用前显式声明该变量为全局变量（用保留字global）

>>>n=1								#n是全局变量
>>>def func(a,b):					
    global n
    n=b								#将局部变量b赋值给全局变量n
    return a*b
>>>s=func("kck~",2)
>>>print(s,n)						#测试一下n值是否改变
knock~konck~ 2						#n改变了

如果此时的全局变量不是整数n而是列表ls 要参考书6.2.1节

>>>1s=[]							#ls是全局列表变量
>>>def func(a,b):
    s.append(b)					#将局部变量b增加到全局列表变量ls中
    return a*b
>>>s=func("knock~",2)
>>>print(s,ls)						#测试一下ls值是否改变
knock~knock~ [2]					#发生了改变！

※与之前的整数变量不同，全局列表变量在函数func()调用后发生了改变

如果func()函数内部存在一个真实创建过且名称为ls的列表，则func()函数将操作该列表而不会修改全局变量

>>>ls=[]							#ls是全局列表变量
def func(a,b):
    ls=[]							#创建了名称为ls的局部列表变量
    ls.append(b)					#将局部变量b增加到局部列表变量ls中
    return a*b
>>>s=func("knock~",2)
>>>print(s,ls)						#测试一下ls值是否改变
knock~knock~ []						#未发生改变

总结：

1）简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用，函数退出后变量被释放，如有全局同名变量，其值不变

2）简单数据类型变量在用global保留字声明后，作为全局变量使用，函数退出后该变量保留且值被函数改变

3）对于组合数据类型的全局变量，如果在函数内部没有被真实创建的同名变量，则函数内部可以直接使用并修改全局变量的值

4）如果函数内部真实创建了组合数据类型变量，无论是否有同名全局变量，函数仅对局部变量进行操作，函数退出后局部变量被释放，全局变量值不变

拓展：指针和引用 p132

3. 函数的递归 p134

定义：函数作为代码封装，可以被其他程序调用。当函数定义中调用函数自身的方式称为递归。

例：根据用户输入的整数n，输出n的阶乘

def fact(n):
    if n==0:
        return 1
    else:
        return n*fact(n-1)
num=eval(input("请输入一个整数："))
print(fact(abs(int(num))))

注：fact()函数在其定义内部引用了自身，形成了递归过程。无限制的递归将耗尽计算机资源，因此，需要设计基例使得递归逐层返回，没有基例时递归无法返回将会报错。

例：字符串反转

def reverse(s):
    if s=="":
        return s
    else:
        return reverse(s[1:])+s[0]
str = input("请输入字符串：")
print(reverse(str))

4. Python的内置函数 p149

共68个，要求掌握前35个(前35个抽考)

abs()	id()	round()	compile()	locals()
all()	input()	set()	dir()	map()
any()	int()	sorted()	exec()	memoryview()
asci()	len()	str()	enumerate()	next()
bin()	list()	tuple()	filter()	object()
bool()	max()	type()	format()	property()
chr()	min()	zip()	frozenset()	repr()
complex()	oct()		getattr()	setattr()
dict()	open()		globals()	slice()
divmod()	ord()	bytes()	hasattr()	staticmethod()
eval()	pow()	delattr()	help()	sum()
float()	print()	bytearray()	isinstance()	super()
hash()	range()	callable()	issubclass()	vars()
hex()	reversed()	classmethod()	iter()	import()

第六章 建议多动手

1. 组合数据类型概述p154

序列类型：是一个元素向量，元素之间存在先后关系。通过序号访问，元素之间不排他

集合类型：是一个元素集合，元素之间无序，相同元素在集合中唯一存在（排他）

映射类型：是“键-值”数据项的组合，每个元素是一个键值对，表示为(key,value)

• 组合数据类型的分类和章节索引

———字符串(str) （3.5节）

|

|————序列类型——————元组(tuple) （6.1节）

| |

| ———列表(list) （6.2节）

|

组合数据类型—————————集合类型——————集合(set) （6.1节）

|

|

—————映射类型——————字典(dict) （6.4节）

2. 序列类型 p155

序列类型：支持成员关系操作符（in），长度计算函数（len()），分片（[]），元素本身也可以是序列类型。

字符串（str）：可以看成是单一字符的有序组合，属于序列类型。同时，由于字符串类型十分常用且单一字符串只表达一个含义，也被看作是基本数据类型。

元组（tuple）：是包含0个或多个数据项的不可变序列类型，元组生成后是固定的，其中任何数据线不能替换和删除。

列表（list）：是一个可以修改数据项的数据类型，使用也最灵活。

无论哪种具体数据类型，只要是序列类型，都可以使用相同的索引体系，即正向递增序号和反向递减序号

• 序列类型的通用操作符和函数

操作符	描述
x in s	如果x是s的元素，返回True，否则返回False
x not in s	如果x不是s的元素，返回True，否则返回False
s+t	连接s和t
s * n 或 n * s	将序列s复制n次
s[i]	索引，返回序列的第i个元素
s[i:j]	分片，返回包含序列s第i到j个元素的子序列（不包含第j个元素，左闭右开）
s[i:j:k]	步骤分片，返回包含序列s第i到j个元素以k为步数的子序列
len(s)	序列s的元素个数（长度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.index(x[,i[,j]])	从i开始到j位置中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

元组（tuple）

在表达固定数据项、函数多返回值、多变量同步赋值，循环遍历等情况下十分有用。Python中元组采用逗号和圆括号（可选）来表示，例：

>>>creature="cat","dog","tiger","human"
>>>creature
('cat','dog','tiger','human')
>>>color=("red",0x001100,"blue",creature)
>>>color
('red',4352,'blue',('cat','dog','tiger','human'))
>>>color[2]
'blue'
>>>color[-1][2]
'tiger'

生成元组只需使用逗号将元素隔离开即可，例如上例中的元组creature，也可以增加圆括号，但圆括号在不混淆语义的情况下不是必需的。

一个元组可以作为另一个元组的元素，可以采用多级索引获取信息。

元组除了用于表达固定数据项外，还常用于：函数多返回值、多变量同步赋值、循环遍历，例：

>>>def func(x):								#函数多返回值
    return x,x**3
>>>a,b='dog','tiger'						#多变量同步赋值
>>>a,b=(b,a)								#多变量同步赋值，括号可省略
>>>import math
>>>for x,y in ((1,0),(2,5),(3,8)):			#遍历循环
    print(math.hypot(x,y))					#求多个坐标值到原点的距离

列表（list）

概念

列表是包含0个或多个对象引用的有序序列，属于序列类型。列表的长度和内容都是可变的，可自由对列表中的数据项进行增加、删除或替换。列表没有长度限制，元素类型可以不同，使用非常灵活。

列表可以采用标准的比较操作符（<、<=、>、>=、==、!=）进行比较，列表的比较实际上是单个数据项的逐个比较。

列表用中括号[]表示，也可以通过list()将元组或字符串转化为列表，直接使用list()会返回一个空列表，例：

>>>ls = [425,"BIT",[10,"CS"],425]
>>>ls
[425,'BIT',[10,'CS'],425]
>>>ls[2][-1][0]
'C'
>>>list((425,"BIT",[10,"CS"],425))
[425,'BIT',[10,'CS'],425]
>>>list("中国是一个伟大的国家")
['中','国','是','一','个','伟','大','的','国','家']
>>>list()
[]

与整数和字符串不同，列表要处理一组数据，因此，列表必须通过显式的数据赋值才能生成，简单将一个列表赋值给另一个列表不会生成新的列表对象，例：

>>>ls = [425,"BIT",1024]
>>>lt = ls
>>>ls[0] = 0
>>>lt
[0,'BIT',1024]

解释：即 lt 和 ls 变量都是实际数据[425,"BIT",1024]的表示或引用，真实数据只存储一份，因此修改了 ls 的同时也修改了 lt。

操作

• 列表类型特有的函数或方法

函数或方法	描述
ls[i]=x	替换列表ls第i数据项为x
ls[i:j]=lt	用列表lt替换列表ls中第i到第j项数据（不含第j项，下同）
ls[i:j:k]=lt	用列表lt替换列表ls中第i到第j项以k为步数的数据
del ls[i:j]	删除列表ls第i到第j项数据，等价于ls[i:j]=[]
del ls[i:j:k]	删除列表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()	列表ls中的元素反转

上述操作符主要处理列表的增删改等功能，例：

>>>vlist = list(range(5))
>>>vlist
[0,1,2,3,4]
>>>len(vlist[2:])
3
>>>2 in vlist
True
>>>vlist[3]="python"
>>>vlist
[0,1,2,'python',4]
>>>vlist[1:3]=["bit","computer"]
>>>vlist
[0,'bit','computer','python',4]

注意，当使用一个列表改变另一个列表值时，python不要求两个列表长度一样，但遵循”多增少减“原则，例：

>>>vlist[1:3]=["new_bit","new_computer",123]
>>>vlist
[0,'new_bit','new_computer',123,'python',4]
>>>vlist[1:3]=["fewer"]
>>>vlist
[0,'fewer',123,'python',4]

与元组一样，列表可以通过for-in语句对其元素进行遍历，基本语法结构如下：

for <任意变量名> in <列表名>:

<语句块>

>>>for e in vlist:
    print(e,end=" ")
0 fewer 123 python 4 

3. 集合类型 p157

集合类型：与数学中集合的概念一致，即包含0个或多个数据项的无序组合。集合中的元素不可重复，元素类型只能是固定数据类型，如整数、浮点数、字符串、元组等。列表、字典和集合类型本身都是属于可变数据类型，不能作为集合的元素出现。

拓：哈希运算（hash）用来判断是否是固定数据类型，能够进行哈希运算的类型都可以作为集合元素。

哈希运算可以将任意长度的二进制值映射为较短的固定长度的二进制值（即为哈希值）。哈希值是对数据的一种有损且紧凑的表示方式，例：

>>>hash("PYTHON")
-5566760883880671655
>>>hash("IS")
197428563064205595
>>>hash("GOOD")
-8813885561642579426
>>>hash("PYTHON IS GOOD")
-3028346011679342834

哈希值与哈希前的内容无关，也和这些内容的组合无关，同一个数据的哈希值可不同。可以是，哈希值是数据在另一个数据维度的体现。

集合（set）

由于集合是无序组合，没有索引和位置的概念，不能分片，集合中的元素可以动态增加或删除。集合用大括号 {} 表示，可以用赋值语句生成一个集合，例：

>>>S={425,"BIT",(10,"CS"),424}
>>>S
{424,425,(10,'CS'),'BIT'}
>>>T=(425,"BIT",(10,"CS"),424,425,'BIT')
>>>T
{424,425,(10,'CS'),'BIT'}

由上例，由于集合元素是无序的，集合的打印效果和定义顺序可以不一致。由于集合元素独一无二，使用集合类型能够过滤掉重复元素。

set(x)函数可以用于生成集合，输入的参数可以是任何组合数据类型，返回结果是一个无重复且排序任意的集合，例：

>>>W=set("apple")
{'e','p','a','l'}
>>>V=set(("cat","dog","tiger","human"))
{'cat', 'human', 'dog', 'tiger'}

• 集合类型的操作符

操作符	描述
S-T 或 S.difference(T)	返回一个新集合，包含在集合S中但不在集合T中的元素
S-=T 或 S.difference_update(T)	更新集合S，包括在集合S中但不在集合T中的元素
S&T 或 S.intersection(T)	返回一个新集合，包括同时在集合S和T中的元素
S&=T 或 S.intersection_update(T)	更新集合S， 包括同时在集合S和T中的元素
S^T 或 s.symmetric_difference(T)	返回一个新集合，包括集合S和T中的元素，但不包括同时在其中的元素
S^=T 或 s.symmetric_difference_update(T)	更新集合S，包括集合S和T中的元素，但不包括同时在其中的元素
S|T 或 S.union(T)	返回一个新集合，包括集合S和T中的所有元素
S|=T 或 S.update(T)	更新集合S，包括集合S和T中的所有元素
S<=T 或 S.issubset(T)	如果S与T相同或S是T的子集，返回True，否则返回False，可以用 S
S>=T 或 S.issuperset(T)	如果S与T相同或S是T的超集，返回True，否则返回False，可以用 S>T 判断S是否是T的真超集

上表表达了集合类型的4中基本操作：交集（&）、并集（|）、差集（-）、补集（^），操作逻辑与数学定义相同。

• 集合类型的操作函数或方法

操作函数或方法	方法
S.add(x)	如果数据项不在集合S中，将x增加到S
S.clear()	移除S中的所有数据项
S.copy()	返回集合S的一个副本
S.pop()	随机返回集合S中的一个元素，如果S为空，产生KeyError异常
S.discard(x)	如果x在集合S中，移除该元素；如果x不在集合S中，不报错
S.remove(x)	如果x在集合S中，移除该元素，不在则产生KeyError异常
S.isdisjoint(T)	如果集合S与T没有相同的元素，返回True
len(S)	返回集合S的元素个数
x in S	如果x是S的元素，返回True，否则返回False
x not in S	如果x不是S的元素，返回True，否则返回False

集合类型主要用于：成员关系测试。元素去重和删除数据项，例：

>>>"BIT" in ("PYTHON","BIT",123,"GOOD")
True
>>>tup = ("PYTHON","BIT","123","GOOD",123)
>>>set(tup)
(123,'GOOD','BIT','PYTHON')
>>>newtup = tuple(set(tup)-{'PYTHON'})
('GOOD',123,'BIT')

注：集合类型与其他类型最大的不同在于它不包含重复元素，因此，当需要对一维数据进行去重或进行数据重复处理时，一般通过集合来完成。

4. 映射类型 p159

映射类型是”键-值“数据项的组合，每个元素是一个键值对，即元素是 (key,value) ，元素之间是无序的。键值对(key,value)是一种二元关系，源于属性和值的映射关系，例如（花的颜色，红色）

字典（dict）

字典是包含0个或多个键值对的集合，没有长度限制，可以根据键索引值的内容。

概念

字典通过大括号{}建立，模式如下：

{<键1>:<值1>,<键2>:<值2>,......,<键n>:<值n>}

例：

>>>Dcountry={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>>print (Dcountry)
{'中国': '北京', '法国': '巴黎', '美国': '华盛顿'}

打印顺序与创建顺序不同，是因为字典是集合类型的延续，各元素没有顺序之分

字典的主要用法是查找与特定键对应的值，通过索引符号实现，例：

>>>Dcountry["中国"]
'北京'

对某键值的修改，例：

>>>Dcountry['中国']='大北京'
>>>print(Dcountry)
{'中国': '大北京', '法国': '巴黎', '美国': '华盛顿'}

操作

使用大括号可以创建字典，并指定初始值，通过中括号可以增加新的元素，例：

>>>Dcountry={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>>Dcountry["英国"]="伦敦"
>>>print(Dcountry)
{'中国': '北京', '法国': '巴黎', '美国': '华盛顿','英国'：'伦敦'}

直接使用大括号{}可以创建一个空的字典，并通过中括号[]向其增加元素，例：

>>>Dp={}
>>>Dp['2^10']=1024
>>>print(Dp)
{'2^10':1024}

• 字典类型的函数和方法

函数和方法	描述
< d >.keys()	返回所有的键信息
< d >.values()	返回所有的值信息
< d >.items()	返回所有的键值对
< d >.get(< key >,< default >)	键存在则返回相应值，否则返回默认值
< d >.pop(< key >,< default >)	键存在则返回相应值，同时删除键值对，否则返回默认值
< d >.popitem()	随机从字典中取出一个键值对，以元组(key,value)形式返回
< d >.clear()	删除所有键值对
del < d >[< key >]	删除字典中某一个键值对
< key > in < d >	如果键在字典中则返回True，否则返回False

如果希望通过上述方法返回一个列表类型，可以采用list()函数将返回值转换成列表，例：

>>>Dcountry={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>>Dcountry.keys()
dict_keys(['中国','美国','法国'])
>>>list(Dcountry.values())
['北京','华盛顿','巴黎']
>>>Dcountry.items()
dict_items([('中国','北京'),('美国','华盛顿'),('法国','巴黎')])
>>>'中国' in Dcountry													#只对键进行判断                                            
True
>>>Dcountry.get('美国','悉尼')										   #'美国’在字典中存在
'华盛顿'
>>>Dcountry.get('澳大利亚','悉尼')									 #‘澳大利亚’在字典中不存在
'悉尼'

与其他数据类型一样，字典可以通过for-in语句对其元素进行遍历，语法结构如下：

for <变量名> in <字典名>:

<语句块>

由于键值对中的键相当于索引，因此，for循环返回的变量名是字典的索引值。如果需要获得键对应的值，可以在语句块中通过get()方法获得，例：

>>>for key in Dcountry:
    print(key)
中国
美国
法国

字典基本原则：

1. 字典是一个键值对的集合，该集合以键为索引，一个键信息只对应一个值信息。

2. 字典中元素以键信息为索引访问。

3. 字典长度是可变的，可以通过对键信息赋值实现增加或修改键值对。

第七章

1. 文件概述 p182

二进制文件和文本文件的最主要区别在于是否有统一的字符编码

2.文件的打开关闭 p183

python通过解释器内置的open()函数打开一个文件，并实现该文件与一个程序变量的关联，open()函数格式如下：

<变量名> = open(<文件名>,<打开模式>)

• 文件的打开模式

文件的打开模式	含义
'r'	只读模式，如果文件不存在，返回异常FileNotFoundError，默认值
'w'	覆盖写模式，文件不存在则创建，存在则完全覆盖
'x'	创建写模式，文件不存在则创建，存在则返回异常FileExistsError
'a'	追加写模式，文件不存在则创建，存在则文件最后追加内容
'b'	二进制文本模式
't'	文本文件模式，默认值
'+'	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

3. PIL库的使用 p187

安装pil库（第三方图像处理库，需下载）的方法（安装库的名字是pillow）如下：

:\>pip install pillow	#或者  pip3 install pillow