Python复习笔记———超详细

这是哪托针对老师的课件整理的复习笔记，基础入门，希望能对广大基础小白受用。内容如有错误的地方，劳请留言指正。

笔记所有代码使用Microsoft VS Code的 Python、Jupyter 插件编译。

标识符可以包括英文、数字以及下划线，并且：

​ 开头必须是字母或下划线；

​ 不能以数字开头开头；

​ 区分大小写的；

​ 不能出现分隔符、标点符号或者运算符；

​ 不能使用关键字：def if for while class等

​ 最好不要使用内置模块名、类型名、函数名、已经导入的模块 及其成员名

合法的标识符：A、ABC、aBc、a1b2、ab_123、__（连续两个下画线）、_123 等 非法的标识符：6a2b、abc-123、hello world（中间用了空格）、for（关键字）等

关键字None

• None是一个特殊的Python对象，不是False，不是0，也不是空字符串、空列表等。
• None有自己的数据类型NoneType，None和任何其他数据类型进行是否相等比较永远返回False。
• 可以将None赋值给任何变量，但是不能创建其他NoneType对象。

变量： 与 C与Java语言相比

相同点：

• 用于储存计算结果或能表示值
• 可以通过变量名访问，变量值通常是可变的。
• 变量具有名字，不同变量是通过名字相互区分的。

不同点：

• 变量的数据类型：不需要声明
• 变量的数据类型：可以变化（Python是动态类型语言）。
• 变量使用之前：必须赋值。

常量：Python没有常量，即没有语法规则限制改变一个常量的值。

怎么办呢？ 使用人为约定。通常用全大写字母表示常量，编程时不要修改它的值。

# 常量示例
TAX_RATE = 0.17
PI = 3.14
CUMTXHC = "你喜欢我吗"

整数：没有小数部分的数值，分为正整数、0和负整数。

100、0、 -100

100			#十进制
ob101		#二进制
0o11		#八进制
0x2F		#十六进制

浮点数：包含小数点的数。

​ 15.0、0.37、-11.2、2.3e2、3.14e-2

15.0
2.3e2		#科学计数法
3.14e-2

复数由两部分组成：实部和虚部。复数的形式为：实部+虚部j。

​ 2+3j、0.5-0.9j都是复数。

2+3j
z=0.5-0.9j
z.real		#复数的实部
z.imag		#复数的虚部

两个注意点：

• Python支持任意大的数字，仅受内存大小的限制（所以在使用时，不用考虑int、float的范围）
• 为了提高可读性，在数值中可以使用下画线

4.布尔bool

布尔类型是用来表示逻辑“是”、“非”的一种类型，它只有两个值，True和False （首字母T和F是大写的）

Python将布尔值True实现为1（int类型），False实现为0，所以可以参与整型运算，但不建议这么做

Python语言中的字符串是一种序列。字符串用单引号、双引号、三引号作为定界符。

“Python”、’ Hello,World ‘、“123”、’’'abcd8 ^ ‘’'等。

列表也是一种序列类型。列表用方括号“［”和“］”将列表中的元素括起来。元素之间以逗号进行分隔。

［1,2,3,True］、［“one”,“two”,“three”,“four”］和［3,4.5, “abc”］

元组也是一种序列。元组用“(”和“)”作为边界将元素括起来。元素之间以逗号分隔。

(1,2,3,True)、(“one”,“two”,“three”,“four”)和(3,4.5, “abc”)。

字典是唯一内建的映射类型，可用来实现通过数据查找关联数据的功能。字典是键值对的无序集合。字典中的每一个元素都包含两部分：键和值。字典用大括号“{”和“}”来表示，每个元素的键和值用冒号分隔，元素之间用逗号分隔。

{‘1801’:‘张三’, ‘1802’:‘徐虎’, ‘1803’:‘张林’}

集合是由各种不可变类型的元素组成，但元素之间无序，并且元素都不重复。

{‘car’, ‘ship’, ‘train’, ‘bus’}。

<变量>=<表达式>

#常规：同java
#特殊：多变量赋值
x,y=1,2
a = b = 3
#两变量的交换
x,y=1,2
x,y=y,x

在Python中，算术运算符有：+（加）、-（减）、*（乘）、/（真除法）、//（求整商）、%（取模）、**（幂）。

需要说明的几点：

（1） + 运算符不支持不同类型的对象之间的连接

3+"ab"			#错误：不同类型
str(3)+"ab"		#正确：通过类型转换函数str()将数字3转换成字符串'3'

（2） * 运算符可以用于列表、元组或字符串与整数的相乘，用于将这些序列重复整数所指定的次数。它不适用于字典和集合与整数的相乘。

[1,3,5] * 2         # 列表list
#[1, 3, 5, 1, 3, 5]
('a','b','c') * 2   # 元组tuple
#('a', 'b', 'c', 'a', 'b', 'c')
'Hello' * 2         # 字符串str
#'HelloHello'
{ 
        1801:'Lily'} * 2   # 字典dict：不可以。因为字典的键key不能重复。

（3）** 运算符：幂运算，与内置函数pow()相同

（4）/ 真除法 与 //整数除法

5/3         # 真除 1.6666666666666667
5//3        # 取商的整数部分 1
7.4//3      # 操作数为实数时，则取实数形式的整数（即*.0） 2.0

六个：<（小于）、<=（小于等于）、>（大于）、>=（大于等于）、==（等于）、!=（不等于）。

结果：布尔值True或False

所有的字符串都是Unicode字符串；

• 单个字符：可以通过ord()函数获取该字符的Unicode码，
• 通过chr()函数把编码转换为对应的字符。

ord('a')   #97
chr(97)  #得到对应的字符 a
ord('我')  #25105
chr(25105)  #我

注意：字符串和数字属于不可比较大小的

列表比较大小：也是从左到右逐个元素的依次比较，类似 字符串之间的比较

列表中：字符串与数值也是不能比较的

[1,2,3]>['a','b']          # 出错
['ab','c',6]>['ab',3,'a']  # 出错

（5）关系运算符可以连用，等价于某几个用and连接起来的表达式。注意：C语言和Java语言均不可这么用。

3<5>2         #与 下式 含义相同 True
3<5 and 5>3		#True
3<5==5        #与 下式 含义相同 True
3<5 and 5==5  #True

（6）因为精度问题可能导致实数运算有一定的误差

• 要尽可能地避免在实数之间进行相等性判断

0.4-0.3          # 有误差了
#0.10000000000000003
0.1==0.4-0.3     # 误差 导致 不相等
#Flase
#解决方法：使用实数之间的差值的绝对值是否小于某一个很小的数来作为实数之间是否相等的判断。
abs(0.1-(0.4-0.3))<0.00000000001    # True，表示 0.1 和 0.4-0.3是相等的
#True

四个：in、not in、is、is not。 结果：返回布尔值True或False

2 in [2,3,4]        # 列表 True
a = 3
a in [2,3,4]        #True

b="abcedfg"        # 测试 字符串str
"ab" in b           #True

a = (1,2,3)
b = (1,2,3)
a is b              # False: 虽然a、b内容一样，但不是同一个对象。
a is not b          # True

（7）同一性测试运算符is和is not测试是否为同一个对象或内存地址是否相同，返回布尔值True和False。

x=[1,3,5]
y=[1,3,5]
x is y      #测试x、y是否为同一个对象：x，y相等，但不是同一个对象 Flase
x is not y  #True
x==y        #测试x、y是否相等 True

注意：

• 是否相等==：只是测试值是否相同，
• 是否为同一个对象is：指的是是否指向同一个对象（如果指向同一个对象，则内存地址应该相同，当然也相等）

内置函数id()返回对象的标识（内存地址）

id(x)       # 每个人运行得到的内存地址可能会不一样 3055563066432
z=x         # 赋值语句z=x，则z和x不仅值相等而且指向同一个对象，z、x的内存地址相同。
z is x  #True

在Python中，逻辑运算符有：and（与）、or（或）、not（非）。通过逻辑运算符可以将任意表达式连接在一起。

哪些是False：False、None、数值类型中的0、空字符串’’、空元组()、空列表[]、空字典{}、空集合{}等

not False  #True
not True   #Flase
not 3           # 非零值为True Flase
not 0           # 零值为false True

（10）逻辑操作符and和or也称作短路操作符，具有惰性求值的特点：

• 短路运算：表达式从左向右解析，一旦结果可以确定就停止。
• 注意：逻辑运算符and、or不一定会返回布尔值True和False。

and(与运算)：结果不一定为True或False

当计算表达式exp1 and exp2时， ①先计算exp1的值，当exp1的值为True或非空值（非0、非None、值非空的其他数据类型），才计算并输出exp2的值； ②当exp1的值为False或空值（0、None、值为空的其他数据类型），直接输出exp1的值，不再计算exp2。

True and 3     # 第一个为True，则输出第二个的值（结果与第二个值有关）：下同 3
4 and False  #Flase
3<4 and 4>5           # 3<4的值为True，则计算并输出4>5的值False
False and 4    # 第一个为False，则不再计算第二个的值，直接输出第一个的值：下同
0 and 'c'             # 直接输出0
() and 'c'            # 直接输出()

or或运算：结果不一定为True或False

当计算表达式exp1 or exp2时： ①先计算exp1的值，当exp1的值为True或非空值（非0、非None、值非空的其他数据类型），直接输出exp1的值，不再计算exp2； ②当exp1的值为False或空值（0、None、值为空的其他数据类型），才计算并输出exp2的值。

True or 3    #第一个为True，则不再计算第二个的值，直接输出第一个的值：下同
3<4 or 4>5                   #3<4的值为True，则直接输出True
False or 4    #第一个为False，则继续计算第二个的值，输出第二个的值：下同
0 or 'c'

（11）赋值运算符（=）、复合赋值运算符（+=、-=、*=、/=、//=、%=、**=）、位运算符（&、|、^等）等。 此处基本同C语言。

(12)特别注意： Python没有自加++与自减--

（13）优先级小括号（）最高

用于输入数据，无论用户输入什么内容，该函数都返回字符串类型。

其格式如下：

input(prompt=None) # prompt=None，表示提示语默认为空

x = input("请输入x值：")    # 请输入x值：100
type(x)                     # 查看x的类型，为<class 'str'> #str

格式1：int([x]) 功能：截取数字的整数部分或将字符串转换成一个整数；如果不给定参数则返回0。

int()           #1、没有参数时：0
int(23.74)      #2、浮点数：直接截取整数部分（不进行四舍五入）
int(-3.52)
int('4')        #3、整数字符串
int('45.6')     #4、浮点数字符串：错误 。 

注意：int()函数不接受带小数的数字字符串

格式2 ：int(x, base=10) 功能：把base进制的字符串x转换为十进制，base为基数(进制)，默认为十进制 base的有效值范围为0和2-36

int('1001001',2)     #1、二进制的数1001001转换为十进制数 73
int('2ef',16)        #2、十六进制的数2ef转换为十进制数 751
int('27',8)          #3、八进制的数27转换为十进制数 23
int('101.001',2)     #4、不允许二进制的小数（不接受带小数的数字）
int('0b110', base=0) #5、二进制的数110转换为十进制数 6

格式：float(x=0, /) 功能：将一个数字或字符串转换成浮点数

float()         # 默认参数x为0
float('inf')  #无穷大，inf不区分大小写
int("3+5")      # 错误
float("3.5*2")  # 错误
#int()、float()不能转换表达式字符串，所以引入eval()函数

• 格式 ：eval(source, globals=None, locals=None, /)
• 功能：将 source 字符串 当做一个python 表达式 进行解析和计算，返回计算结果。
• 参数说明：

source是一个字符串，这个字符串能表示成Python表达式，或者是能够通过编译的代码； globals是可选的参数，默认为None，如果设置属性不为None的话，就必须是dictionary对象； locals也是可选的参数，默认为None，如果设置属性不为None的话，可以是任何map对象。

• 字符串中是表达式：返回表达式的值；
• 字符串中是列表、元组或字典：得到真正的列表、元组或字典；
• 字符串中是能够通过编译的代码：执行代码。

x=3
eval('x+1')            # 表达式：x+1
eval('3+5')            #8
eval('[1,2,3]')        # 返回列表[1,2,3]
eval('{1:23,2:32}')    # 返回字典{1:23,2:32}
eval('print(3**2)')     # 执行print(3**2)语句 9
eval("__import__('os').getcwd()") # 执行语句：获取当前目录
#####组合使用： int()、float()、eval()函数和input（）
x=eval(input("请输入x值："))    #输入列表格式：[1,2,3]
x                              #获得列表
x=eval(input("请输入x值："))    #输入字典格式：{'a':1,'b':2}
x                              #获得字典

print()函数 格式如下:

print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

各参数的解释如下:

value：需要输出的对象，一次可以输出一个或者多个对象(其中…表示任意多个对象)，对象之间要用逗号(,)分隔 sep：对象之间的间隔符，默认用一个空格分隔； end：以何字符结尾，默认值是换行符； file：表示输出位置，可将输出到文件，file指定的对象要有“写”的方法，默认值是sys.stdout(标准输出，即控制台屏幕)； flush：将缓存里面的内容是否强制刷新输出，默认值是False（一般不需要）。

print('1.hello','world','!')          #一次输出三个对象，中间默认用空格隔开
print('2.hello','world','!',sep='*')  #一次输出三个对象，中间用*隔开
print('3.hello','world','!',sep='')   #一次输出三个对象，中间无分隔，因为sep参数值被设置为空字符串了
print('4.hello','world','!',end='!')  #一次输出三个对象，以!结尾（不换行）
print('5.hello','world','!',sep=',', end='!')  #一次输出三个对象，以，分隔，以！结尾

可以看出：print函数默认输出是换行的。如果要实现不换行，需要在变量末尾设置 end参数

• 单分支if语句

• 双分支if/else语句

• 多分支if/elif/else语句

• 选择结构的‘嵌套’

• 选择结构的三元运算

  【注意】：Python没有switch语句

语法类似于java此处省略

定义：

• 给定的判断条件为真（包括非零、非空）时，重复执行某些操作；
• 判断条件为假（包括零、空）时，结束循环。

循环分类：

• while语句
• for语句

循环中断:

• break
• continue

带else的循环语句（Python特有）

与java类似相关内容请参考java

for语句通过遍历一个序列（字符串、列表、元组）或迭代器等可迭代对象中的每个元素来建立循环。 for语句的语法形式如下所示：

for  变量   in   序列或迭代器等可迭代对象:  
    循环体

补充 range（）函数：返回可迭代对象。

语法格式如下： range(start, stop[, step])

功能： 产生一个从start开始（包括start,默认为0），到stop结束（不包括stop），两个整数对象之间间隔step（默认为1）的可迭代对象。

可以用for循环直接遍历range函数产生的可迭代对象

for i in range(0,10):   # 默认step：1
    print(i,end=' ')
for i in range(3,15):
    print(i,end=' ')

range对象可以被转换成列表或元组，例如：

y=list(x)   # range对象转换为list列表对象
z=tuple(x)  # range对象转换为tuple元组对象

详细解释：

• break语句：可以用在while和for循环中。在循环进行过程中，如果某个条件被满足（一般通过if语句判断是否满足执行break语句的条件），则可以通过break语句立即终止本层循环。如果break语句在具有两层循环嵌套的内层循环中，则只终止内层循环，进入到外层循环的下一条语句继续执行。
• continue语句：可以用在while和for循环中。在循环体执行过程中，如果遇到continue语句，程序会跳过本次循环的循环体剩余语句，回到循环开始的地方重新判断是否进入下一次循环。

精简：

• break语句终止整个当前循环；
• continue语句的执行不会终止整个当前循环，只是提前结束本次循环，跳过循环体