Python基础[上]

基础[上]"/>

Python基础[上]

注释

①单行注释——以＃开头，直到换行结束

②多行注释——一对三引号代码 多行注释

③中文编码声明注释——在文件开头 以指定源码文件的编码格式

变量

变量命名规则

1.标识符是由字符（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字,而且不能包含空格、@、% 以及 $ 等特殊字符。

2.标识符不能和 Python 中的保留字相同。

内存地址

1.整数、字符串是真正意义上的值，而内存只有一份指的是较小的值。对于(-5~256)之间的整数，会在内存中进行缓存，两个相同的整数只开辟一份内存，当地址引用为0时，内存自动删除

2.对于元组、字典、列表、集合以及range、map等容器类对象，这些的值看起来一样，但内存却不是保存一份

3.同一个列表或者元组中，大的整数在内存中会保存同一个地址

4.对于实数(有理数、无理数)来说(不包括-5~256)，地址是不同的

常用数据类型

• 整数类型—int
• 浮点数类型——float
• 布尔类型——bool
• 字符串类型——str

整数类型

可以表示正数、负数和零

整数不同进制的表示方式

• 十进制——默认
• 二进制——以0b开头
• 八进制——以0o开头

浮点数类型

浮点数由整数部分和小数部分组成

浮点数储存具有不精确性质

n1=1.1
n2=2.2
n3=2.1
print(n1+n2)
print(n1+n3)

3.3000000000000003
3.2

解决方案导入模块decimal

from decimal import Decimal
print（Decimal(‘1.1’) +Decimal(‘2.2’)） 

布尔类型 

用来表示真或假的值

Ture是真 False是假

布尔值可以转化为整数

Ture——1 False——0 
f1=True
f2=False
print（f1，type（f1））
print（f2，type（f2））
print("*"*10)
print（f1+1）
print（f2+1）

True <class ‘bool’>
False <class ‘bool’>
**********
2

字符串类型

①不可变的字符序列

②可以使用单引号，双引号，三引号（‘’‘或者“”“）来定义

③单引号和双引号定义的字符串必须在同一行

④三引号定义的字符串，可以分布在连续的多行

注：转义字符

• r'*********'==打回原形

运算符

• 算术运算符
• 赋值运算符
• 比较运算符
• 布尔运算符
• 位运算符

算术运算符

标准算术运算符+取余运算符+幂运算符

(+、-、*、/ 整除//） % **

赋值运算符

支持参数赋值

+=、-=、*=、/=、//=、%=

支持系列解包赋值

a,b,c=20,30,40

比较运算符

①>, <,>=,<=,!=

②== 对象value的比较

③is,is not 对象id的比较

布尔运算符

and/or/not/in/not in

位运算符号

将数据转成二进制进行计算

位与&（对应数位都是1，结果数位才是1，否则为0）

4的二进制 00000100

8的二进制 00001000

4&8 00000000 —— 0

位或 |（对应数位都是0，结果数位才是0，否则为1）

4的二进制 00000100

8的二进制 00001000

4|8 00001100 —12

左移位运算符<< （高位溢出舍弃，低位补0)

4的二进制 00000100

左移位 000001000 —8（向左移动以为相等于*2）

右移位运算符<< （低位截断，高位补0)

4的二进制 00000100

右移位 000001000 — 2（向右移动以为相等于/2）

运算符的顺序

①**

②*、/、//、% A 赋值运算符

③+、-

④<<、>>

⑤& B 位运算符

⑥|

⑦>、< 、>=、<=、==、！= C 比较运算符

⑧and

⑨or D 布尔运算符

⑩= E 赋值运算符

组合数据类型

（1）序列存储一组排列有序的元素，每个元素的类型可以不同，通过索引可以锁定序列中的指定元素。

（2）集合同样存储一组数据，它要求其中的数据必须唯一，但不要求数据间有序。

（3）映射类型的数据中存储的每个元素都是一个键值对，通过键值对的键可以迅速获得对应的值。

列表（List）

• 一个有序可变序列。其数据类型可以不同（基本类型组合数据类型或者自定义数据类型）

创建列表

1.直接赋值

list1=[]

2.使用list函数创建

list1=list([....])

访问列表元素

列表名[索引][索引][索引]

list1=[['小公主'],['狗子'],['自爆卡车'],['十六鸽'],['喇叭']]
'狗子'=list1[1][0]

 注意：

       列表切片（增删）列表是可变的，可以在列表中指定下标的值对元素进行修改

       该操作可以截取列表中的任意部分，得到新列表

列表[开始索引：结束索引：步长]

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list2=list1[::]
list2=list1

 注意：

       切片操作不会因为越界而抛出异常，而是提取所有包含的列表元素或者返回一个空列表

添加列表元素（生成新列表）

对象名.方法名（参数列表）

append（obj）

用于在列表末尾末尾追加一个元素

list1=['小公主','狗子','自爆卡车','十六鸽']
list1.append('喇叭')

insert（index, obj）

用于在列表任意指定位置插入一个元素

list1=['小公主','狗子','自爆卡车','十六鸽']
list1.insert(0,'喇叭')

extend（obj）

用于另一个列表中的所有元素追加到当前列表的末尾

list1=['小公主','狗子','自爆卡车','十六鸽']
list2=['喇叭']
list1.extend(list2)

注意：

原地修改列表，也就是直接修改原列表，不生成新列表。

删除列表元素（改变原列表）

del（）

del命令可以删除列表中指定位置的元素或者整个列表

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
del(list1)

 注意：

删除整个列表后将无法访问

 pop(obj)

用于删除列表指定位置的一个元素（默认为最后一个）并返回该元素

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list1.pop()

注意：

唯一一个既修改列表又返回一个非空值的列表方法

remove（obj）

用于删除列表中第一个与指定值相等的元素

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list1.remove('小公主')

 注意：

删除前需确认要删除的元素是否在列表中,否则会发生报错

clear()

用于清空整个列表

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list1.clear()

检索列表元素

index（obj）

用于返回指定元素在列表中首次出现的索引，若不在则抛出异常

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
print(list1.index('小公主'))

统计列表元素

count（obj）

用于计算指定元素在列表中出现的次数

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
print(list1.count('小公主'))

列表元素排序

sort（...）

用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

list.sort(cmp=None, key=None, reverse=False)

参数

• cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list1.sort(reverse=False)
print(list1)

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted(iterable, cmp=None, key=None, reverse=False)

参数说明：

• iterable -- 可迭代对象。
• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
print(sorted(list1,reverse=False))

reverse()

用于反向列表中元素，返回一个反转的迭代器。

list.reverse()

参数

• seq -- 要转换的序列，可以是 tuple, string, list 或 range。

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list1.reverse()
print(list1)

注：无返回值，在原有的序列进行操作

len（obj）

返回列表中元素的个数

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
print(len(list1))

max(obj)和min(obj)

返回列表中的最大或者最小元素

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
print(max(list1))
print(min(list1))

注意：要求所有元素之间能够进行大小比较（数值类型——数值的大小，字符串类型——ASCII码），否则抛出异常

sum(obj)：

对数值型列表进行求和运算，对非数值型列表运算则抛出异常

list1=[1,2,3,4,5]
print(sum(list1))

列表推导式

[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

• 实现嵌套列表的平铺
• 过滤不符合条件的元素
• 同时遍历多个序列

data = [(x**2,y) for x in range(-5, 5) for y in range(0,10) if x >= -2 and y>=3]
print(data)

元组（tuple）

（a）如果元组中对象本身是不可变对象，则不能再引用其它对象

（b）如果元组中的对象是可变对象的，则可变对象的引用不允许改变，但数据可以改变

（c）元组和列表类似，但元组是一个不可变序列，不能修改，也不能添加或删除元素

创建元组

1.直接赋值

tuple1=('小公主','狗子','自爆卡车','十六鸽','喇叭')

2.使用tuple函数创建

list1=('小公主','狗子','自爆卡车','十六鸽','喇叭')
tuple1=tuple(list1)

tuple1=(1)则定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义。因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有一个元素的tuple定义时必须加一个逗号“,”来消除歧义，即：

tuple1=('小公主',)

基本操作

除了能修改原式的都能在元组使用，相当于元组基本上都是不可改变的列表。其他序列（列表和字符串）的操作都可用于元组，除了那些会违反不变性的列表运算符。“+”和“*”运算符同样适用于元组。成员操作（in）和for循环同样适用于元组长度（len）、最大（max）和最小（min）同样适用于元组。没有任何的操作能更改元组。例如append、extend、insert、remove、pop、reverse和sort不能用于元组。

但是注意：当元组中存在列表元素项时，就可以使用上述如append等方法修改list中的元素，达到间接修改元组元素的目的。(即元组中的列表可以修改)

元组推导式生成器推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组迭代器。

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

使用生成器的__next__()进行遍历，或者使用for循环遍历其中的元素

data = ((x**2,y) for x in range(-5, 5) for y in range(0,10) if x >= -2 and y>=3)
print(data)
print(data.__next__())

注意：

• 元组比列表访问速度快
• 元组作为不可变序列，与整数，字符串一样，可以作为字典的键，也可以作为集合的元素

字典

• 字典（Dict）是python中唯一的映射类型，包含键（Key）和值（Value）,是无序可变序列。
• Key 是任意不可变类型（整数，实数，附属，字符串和元组），键不能相同，否则会覆盖
• Value 不唯一，多个键可以相同值

创建字典

使用{}定义列表

dict1={'M4A1':'小公主','M4 SOPMODⅡ':'狗子','AR15':'自爆卡车','M16A1':'十六鸽','RO635':"喇叭"}

使用dict（）方法

将键值对形式的列表或元组创建为字典（每一个只包含两个元素）

list1=['M4A1','小公主']
dict1=dict(list1)

通过指定关键字参数创建字典

dict1=dict('M4A1'='小公主')

zip([iterable, ...])

使用zip（）将多个序列作为参数，返回由元组构成的列表

zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

参数

• iterabl -- 一个或多个迭代器;

返回值

返回元组列表。

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list2=['M4A1','M4 SOPMODⅡ','AR15','M16A1','RO635']
obj2=zip(list1,list2)
print(obj2.__next__())

dict.fromkeys(seq[, value])

Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

参数

• seq -- 字典键值列表。
• value -- 可选参数, 设置键序列（seq）的值，默认为 None。

dict1=dict()
list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list2=['M4A1','M4 SOPMODⅡ','AR15','M16A1','RO635']
dict2=dict1.fromkeys(list1,'AR小队')
print(dict2)

返回值

该方法返回一个新字典。fromkeys 方法只用来创建新字典，不负责保存。

访问字典元素

通过字典的键查看值

dict1={'M4A1':'小公主','M4 SOPMODⅡ':'狗子','AR15':'自爆卡车','M16A1':'十六鸽','RO635':"喇叭"}
print(dict1['M4A1'])

dict.get(key[, value])

返回指定键的值。

参数

• key -- 字典中要查找的键。
• value -- 可选，如果指定键的值不存在时，返回该默认值。

返回值

返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。

tinydict = {'Name': 'Runoob', 'Age': 27}
print ("Age : %s" %  tinydict.get('Age'))
# 没有设置 Sex，也没有设置默认的值，输出 None
print ("Sex : %s" %  tinydict.get('Sex'))  
# 没有设置 Salary，输出默认的值  0.0
print ('Salary: %s' % tinydict.get('Salary', 0.0))

get() 方法 Vs dict[key] 访问元素区别

get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。

dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。

嵌套字典使用

get() 方法对嵌套字典的使用方法如下：

tinydict = {'RUNOOB' : {'url' : 'www.runoob'}}
res = tinydict.get('RUNOOB', {}).get('url')
# 输出结果
print("RUNOOB url 为 :  %s" % str(res))

list1=[]

list1=[]

list1=[]

字典元素的添加与修改

dict[key]=value

存在则修改值，不存在则添加新键值对

dict1=dict()
dict1=['小公主']='M4A1'

 update(dict)

Python 字典(Dictionary) update() 函数把字典 dict2 的键/值对更新到 dict 里。

参数

• dict -- 添加到指定字典dict里的字典。

返回值

dict1={'M4A1':'小公主','M4 SOPMODⅡ':'狗子','AR15':'自爆卡车','M16A1':'十六鸽'}
dict2={'RO635':"喇叭"}
dict1.update(dict2)
print(dict1)

注：用 update 更新字典 a，会有两种情况：

•  （1）有相同的键时：会使用最新的字典 b 中 该 key 对应的 value 值。
•  （2）有新的键时：会直接把字典 b 中的 key、value 加入到 a 中。

dict.setdefault(key, default=None)

和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

参数

• key -- 查找的键值。
• default -- 键不存在时，设置的默认键值。

dict1=dict()
list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
list2=['M4A1','M4 SOPMODⅡ','AR15','M16A1','RO635']
dict2=dict1.fromkeys(list1,'AR小队')
dict2.setdefault('HK416')
print(dict2)

setdefault 和 get 还是有不同的:

setdefault 如果不存在会在原字典里添加一个 key:default_value 并返回 default_value。

get 找不到 key 的时候不会修改原字典，只返回 default_value。

若要修改字典 dic.setdefault(key,default_value) 等同于 dic[key] = dic.get(key,default_value)。

字典元素及字典的删除

del()

dict1={'M4A1':'小公主','M4 SOPMODⅡ':'狗子','AR15':'自爆卡车','M16A1':'十六鸽','RO635':"喇叭"}
del(dict1)
print(dict1)

pop（Key）

dict1={'M4A1':'小公主','M4 SOPMODⅡ':'狗子','AR15':'自爆卡车','M16A1':'十六鸽','RO635':"喇叭"}
dict1.pop('RO635')
print(dict1)

注：键不存在则报错

popitem()

Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。

如果字典已经为空，却调用了此方法，就报出 KeyError 异常。

返回值

返回最后插入键值对(key, value 形式)，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。

dict1={'M4A1':'小公主','M4 SOPMODⅡ':'狗子','AR15':'自爆卡车','M16A1':'十六鸽','RO635':"喇叭"}
dict1.popitem()
print(dict1)

注意：在 Python3.7 之前，popitem() 方法删除并返回任意插入字典的键值对。

max,min,sum,lenD等函数同样适用于字典，与列表的用法相同，但需要注意的是默认用键去比对

字典的复制

copy()

返回一个字典的浅复制。

dict1={'M4A1':'小公主','M4 SOPMODⅡ':'狗子','AR15':'自爆卡车','M16A1':'十六鸽','RO635':"喇叭"}
dict2=dict1.copy()
print(dict1)
print(dict2)dict1.popitem()
print(dict1)
print(dict2)

 注意：

一、深浅拷贝不同

深拷贝：对原对象的地址的拷贝，新拷贝了一份与原对象不同的地址的对象，修改对象中的任何值，都不会改变深拷贝的对象的值。

浅拷贝：对原对象的值的拷贝，地址仍是一个指针指向原对象的地址，浅拷贝或者原对象的值发生变化，那原对象和浅拷贝对象的值都会随着被改变。

浅拷贝（影子克隆）：只复制对象的基本类型，对象类型，仍属于原来的引用

深拷贝（深度克隆）：不仅复制对象的基本类，同时也复制原对象的对象，完全是新对象产生的

1.copy.copy 浅拷贝——只拷贝对象，不会拷贝对象的引用对象，不会拷贝原始对象的内部的

2.copy.deepcopy   深拷贝——拷贝对象的值类型，还拷贝了原始对象，而产生了一个新的对象，不仅仅只拷贝了原始对象的引用

二、补充概念：可变对象，不可变对象

可变对象：一个对象在不改变其所指向的地址前提下，可以修改其所执行的地址中的值

不可变对象：一个对象所指向的地址上的值是不能修改的，如果修改了就是它执行的地址就改变了，相当于将这个对象指向的值复制出来一份，然后做了修改后存到另一个地址上了。

不可变元素包含：int,float,complex,long,str,unicode,tuple

可变原生：list

import copya = [1, 2, 3, 4, ['a', 'b']]
b = a  # 赋值，传对象的引用
c = copy.copy(a)  # 浅拷贝，对象拷贝
d = copy.deepcopy(a)  # 深拷贝，对象拷贝a.append(5)  # 修改对象a,列表末尾添加数字5
a[4].append('c')  # 修改对象a中的列表['a', 'b']print('a= ', a)
print('b= ', b)
print('c= ', c)
print('d= ', d)

字典推导式

{ key_expr: value_expr for value in collection }
或{ key_expr: value_expr for value in collection if condition }

dict1={'a':'Ammy','t':'Tom','u':'Ursula','n':'Niklause'}
dict2={k:v for v,k in dict1.items()}
print("更换键、值之前：",dict1)
print("更换键、值之后：",dict2)#运行结果
更换键、值之前： {'a': 'Ammy', 't': 'Tom', 'u': 'Ursula', 'n': 'Niklause'}
更换键、值之后： {'Ammy': 'a', 'Tom': 't', 'Ursula': 'u', 'Niklause': 'n'}

字符串

• 是一个不可变的有序序列，其字符按照一定顺序排列的，支持双向索引。

字符串驻留机制

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新的空间，而是把该字符串的地址赋给新创建的变量。

驻留机制的几种情况(交互模式)
1、字符串的长度为0或1时
2、符合标识符的字符串
3、 字符串只在编译时候进行驻留，而非运行时
4、[-5,256]之间的整数数字
5、sys中的intern方法强制2个字符串指向同一个对象
6、PyCharm对字符串进行了优化处理

优缺点
1、 当需要值相同的字符串时，可以直接从字符串池拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是比较影响性能的。
2、在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率比“+”效率高。

元素读取

列表[开始索引：结束索引：步长]

通过索引访问字符串的元素或者截取字符串的任意部分得到一个新的字符串

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
x=''
for i in list1:x+=i+','
print(x)

字符串的运算

“+”拼接

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
x=''
for i in list1:x+=i+','
print(x)

注：对象类型必须相同，否则报错 

“*”重复输出

str1='失败了'
str2=str1*10
print(str2)

获取长度

len()

str1=‘未来的事情，谁也不知道。正因为如此，就如同再次相见本身，未来才有无限的可能’
len1=len(str1)
print(len1)

注意：数字，英文，汉字和字符（包括空格）均为一个字符串长度

in/not in

判断一个字符串是否属于另一个字符串

str1="a"
str2="A"
print(str1 in str2)

字符串的查找

rfind(str, beg,end)

Python rfind() 返回字符串最后一次出现的位置的首字符开头位置，如果没有匹配项则返回 -1。

参数

• str -- 查找的字符串
• beg -- 开始查找的位置，默认为 0
• end -- 结束查找位置，默认为字符串的长度。

返回值

返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

str1="那你又能做什么呢？只能整天在垃圾桶里找电池为自己充电！"
str2="垃圾"
print(str1.rfind(str2,0,len(str1)))

index(str, beg, end)

Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

参数

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则抛出异常。

str1="那你又能做什么呢？只能整天在垃圾桶里找电池为自己充电！"
str2="瑰宝"
print(str1.index(str2,0,len(str1)))

注意：（使用区别）

如下，find找不到会返回-1，index找不到会抛出异常。x = "apple pear peach banana watermelon lemon pineapple"
print("字符串： ", x)
print("find(),找出'apple'第一个下标： ", x.find("apple"))
print("rfind(),找出'apple'最后一个下标： ", x.rfind("apple"))
print("find(),找不到就返回-1： ", x.find("xxx"))
print("index(),找出'apple'第一个下标： ", x.index("apple"))
print("rindex(),找出'apple'最后一个下标： ", x.rindex("apple"))
print("index(),找不到就抛出异常： ", x.index("xxx"))

index()查找下标要用在异常处理中使用

x = "apple pear peach banana watermelon lemon pineapple"
print("字符串： ", x)
try:print("index(),找不到就抛出异常： ", x.index("xxx"))
except:print("未找到该字符！")

count(sub, start,end)

Python count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。

参数

• sub -- 搜索的子字符串
• start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

str1="那你又能做什么呢？只能整天在垃圾桶里找电池为自己充电！"
str2="瑰宝"
print(str1.count(str2,0,len(str1)))

字符串的替换

replace(old, new[, max])

把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

参数

• old -- 将被替换的子字符串。
• new -- 新字符串，用于替换old子字符串。
• max -- 可选字符串, 替换不超过 max 次

返回值

str1="那你又能做什么呢？只能整天在垃圾桶里找电池为自己充电！"
str2="瑰宝"
print(str1.replace('垃圾',str2,len(str1)))

maketrans(intab, outtab)/(dict)

用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

注：两个字符串的长度必须相同，为一一对应的关系。

参数

• intab -- 字符串中要替代的字符组成的字符串。
• outtab -- 相应的映射字符的字符串。

返回值

输出一个字典， 其中 x 中每个字符将被映射到 y 中相同位置的字符,输出字典中，key 是 x 中字符的 Unicode 码位序号， value 是 y 中字符的 Unicode 码位序号。

dict0 = {'a': 1, 'b': 2, 'c': 3}  # key 为字符 (长度为1的 string)
table=str.maketrans(dict0)  # ord('a')=97, ord('b')=98, ord('c')=99
print(table)

translate(table)

ranslate() 方法根据参数 table 给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。

参数

• table -- 翻译表，翻译表是通过maketrans（）方法转换而来。
• deletechars -- 字符串中要过滤的字符列表。

返回值

返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射 。

import string
text = """g fmnc wms bgblr rpylqjyrc gr zw fylb."""
def solution2(text):table = str.maketrans(string.ascii_lowercase,  # 26 个小写字母 a-zstring.ascii_lowercase[2:] + string.ascii_lowercase[:2])  # c-z 接上 a-bprint(table)print(text.translate(table))solution2(text)

split(str="", num)

Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

参数

• str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num -- 分割次数。默认为 -1, 即分隔所有。

返回值

返回分割后的字符串列表。

str1='STEINS GATE'
print(str1.split())

partition(str)

根据指定的分隔符将字符串进行分割，如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

返回值

str1='STEINS GATE'
print(str1.partition(' '))

join(sequence)

用于将序列中的元素以指定的字符连接生成一个新的字符串。

参数

• sequence -- 要连接的元素序列。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

str1='STEINS GATE'.split()
str2='+'
print(str2.join(str1))

注意：

str表示字符串（字符），item表示一个成员，注意括号里必须只能有一个成员，比如','.join('a','b')这种写法是行不通的

大小写转换

str1='STEINS GATE'print(str1.upper())          # 把所有字符中的小写字母转换成大写字母
print(str1.lower())          # 把所有字符中的大写字母转换成小写字母
print(str1.capitalize())     # 把第一个字母转化为大写字母，其余小写
print(str1.title())          # 把每个单词的第一个字母转化为大写，其余小写 

删除字符串的指定字符

strip([chars])

用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

参数

• chars -- 移除字符串头尾指定的字符序列，默认是空格。

返回值

返回移除字符串头尾指定的字符生成的新字符串。

str1=' STEINS GATE'.strip()
print(str1)

注：

• str.strip()  ： 去除字符串两边的空格
• str.lstrip() ： 去除字符串左边的空格
• str.rstrip() ： 去除字符串右边的空格

ljust(width[, fillchar])

返回一个原字符串向中对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

参数

• width -- 指定字符串长度。
• fillchar -- 填充字符，默认为空格。

返回值

返回一个原字符串向中对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

str1='STEINS GATE'
print(str1.center(20))

注：

• str.center()  ： 向字符串的两侧填充指定字符，从而达到向中文本的目的
• str.ljust()  ： 向字符串的右侧填充指定字符，从而达到向向左对齐本的目的
• str.rjust()  ： 向字符串的左侧填充指定字符，从而达到向向右对齐文本的目的

以指定字符开始或结束

startswith(str, beg=0,end=len(string))

用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

参数

• str -- 检测的字符串。
• strbeg -- 可选参数用于设置字符串检测的起始位置，默认为0。
• strend -- 可选参数用于设置字符串检测的结束位置，默认为字符串长度。

返回值

如果检测到字符串则返回True，否则返回False。

str1='STEINS GATE'
print(str1.startswith('S'))

字符串类型判断

• str.isalnum()：是否全为字母或数字
• str.isalpha():是否全为字母
• str.isdecimal():是否只含十进制数字符号
• str.isdigit()：是否全为数字（0~9）
• str.isidentifier()：是否为合法标识
• str.islower()：是否全为小写
• str.isupper()：是否全为大写
• str.isnumeric()：是否只包含数字字符
• str.isprintable()：是否只包含可打印字符
• str.isspace()：是否只包含空白字符
• str.istitle()：是否为标题，即各单词首字母大写

集合

• 具有“无序性”，是一个无序可变序列
• 具有“互异性”，同一个集合中的元素都是唯一的，不允许重复
• 具有“确定性。集合元素类型只能是数字，字符串，元组等不可变类型，不能是列表，字典，集合等可变类型

集合的创建和删除

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

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set2=set(list1)
print(set1)
print(set2)

 注：

• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
• 集合是无序的数据结构，因此它不保留插入顺序，有序的序列变为集合，元素顺序会不一致

forzenset（[iterable]）

返回一个不可变集合，冻结后集合不能再添加或删除任何元素，前者set是可变集合

参数

• iterable -- 可迭代的对象，比如列表、字典、元组等等。

返回值

返回新的 frozenset 不可变对象，如果不提供任何参数，默认会生成空集合。

list1=['小公主','狗子','自爆卡车','十六鸽','喇叭']
set3=frozenset(list1)
print(set3)

添加集合元素

update(set)

用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

参数

• set -- 必需，可以是元素或集合

返回值

set1={'小公主','狗子','十六鸽'}
set1.update('喇叭')
print(set1)

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果

set1={'小公主','狗子','十六鸽'}
set1.add('自爆卡车')
print(set1)

 注：

• update() 自动将元素变为集合再加入集合之中，例：加入字符串先切分再添加
• add(）直接添加元素

删除集合元素

discard(value)

方法用于移除指定的集合元素。

参数

• value -- 必需，要移除的元素

返回值

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set1.discard('45号钢板')
print(set1)

 注：

• remove(),pop(),clear(),pop()方法与列表使用方式相同
• 该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
• 当集合是由列表和元组组成时、set.pop() 是从左边删除元素的

集合之间的关系 
1.两个集合是否相等（集合A,B具有相同的元素）
        可以使用运算符 == 或者 ！= 进行判断
2.一个集合是否是另一个集合的（真）子集                                                                                       集合A中的元素都是元素B的元素（且A不等于B）
        可以使用issubset（）or<or>来判断
3.一个集合是否是另一个集合的（真）超集（与子集相反的说法）
        可以调用方法issuperset（）进行判断
4.两个集合是否有交集：
        可以调用方法isdisjoint进行判断

isdisjoint(set)

用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

参数

• set -- 必需，要比较的集合

返回值

返回布尔值，如果不包含返回 True，否则返回 False。

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set2={'M4A1','M4 SOPMODⅡ','AR15','M16A1','RO635'}
print(set1.isdisjoint(set2))

issubset(set)

用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。

参数

• set -- 必需，查找的指定集合（大）

返回值

返回布尔值，如果都包含返回 True，否则返回 False。

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set2={'狗子','自爆卡车'}
print(set2.issubset(set1))

issuperset(set)

用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。

参数

• set -- 必需，查找的判断集合（小）

返回值

返回布尔值，如果都包含返回 True，否则返回 False。

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set2={'狗子','自爆卡车'}
print(set1.issuperset(set2))

intersection(set1, set2 ... etc)

用于返回两个或更多集合中都包含的元素，即交集。

参数

• set1 -- 必需，要查找相同元素的集合
• set2 -- 可选，其他要查找相同元素的集合，可以多个同时比较，多个使用逗号隔开

返回值

返回一个新的集合。

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set3={'狗子','自爆卡车'}
print(set1.intersection(set3))

intersection_update(set1, set2 ... etc)

用于获取两个或更多集合中都重叠的元素，即计算交集。

注：intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。

参数

• set1 -- 必需，要查找相同元素的集合
• set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开

返回值

无返回值

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set3={'狗子','自爆卡车'}
print(set1.intersection_update(set3))
print(set1)

union(set1, set2...)

返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。

参数

• set1 -- 必需，合并的目标集合
• set2 -- 可选，其他要合并的集合，可以多个，多个使用逗号 , 隔开。

返回值

返回一个新集合。

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set2={'M4A1','M4 SOPMODⅡ','AR15','M16A1','RO635'}
print(set1.union(set2))

difference(set)

 #差集

用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。

参数

• set -- 必需，用于计算差集的集合

返回值

返回一个新的集合。

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set2={'M4A1','M4 SOPMODⅡ','AR15','M16A1','RO635'}
print(set1.difference(set2))

symmetric_difference(set)

返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。

参数

• set -- 集合

返回值

返回一个新的集合，但会移除两个集合的重复元素。

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set3={'狗子','自爆卡车'}
print(set1.symmetric_difference(set3))

symmetric_difference_update(set)

 #补集

移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

参数

• set -- 要检测的集合

返回值

set1={'小公主','狗子','自爆卡车','十六鸽','喇叭'}
set2={'M4A1','M4 SOPMODⅡ','AR15','M16A1','RO635'}
print(set1.symmetric_difference_update(set2))

集合运算符

• a = t | s          # t 和 s的并集  
• b = t & s          # t 和 s的交集  
• c = t – s          # 求差集（项在t中，但不在s中）  
• d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  

集合的复制

PS：和列表一样

集合推导式

集合推导式基本格式：

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

顺序结构

输入

input（）

str=input("可输入输出内容提示信息")    返回字符串类型数据

Servant=input()
print(type(Servant))

少女前线
<class 'str'>进程已结束,退出代码0

注意：

        不能在一行赋值语句中同时给多个变量赋值

        x=10,y=12(x)

输出

print（）

print(value,sep='',end='' ,file=sys.stdout,flush=)

参数

• objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep -- 用来间隔多个对象，默认值是一个空格。
• end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file -- 要写入的文件对象，默认代表系统标准输出，即屏幕
• flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

sep可选关键字参数

sep参数可以在值之间插入字符串，默认值为空格。

import time
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading",end = "")
for i in range(20):print(".")

---RUNOOB EXAMPLE ： Loading 效果---
Loading.
.
.
.
进程已结束,退出代码0

file参数

默认值为sys.stdout，代表系统标准输出，即屏幕。我们可以通过改变该参数使print()函数输出到特定的文件中。

import time
f = open(r"text.txt",'w') # 打开文件，以便写入
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading",end = "",file=f)
for i in range(20):print(".",file=f)
f.close()

​

end可选关键字参数

end参数默认为"\n"(换行符)，如果想在print()函数输出之后输出别的字符串，可以重设end参数。

import time
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading",end = "")
for i in range(20):print(".",end = '')

---RUNOOB EXAMPLE ： Loading 效果---
Loading....................
进程已结束,退出代码0

flush可选关键字参数

flush参数用于控制输出缓存，默认不清除，一般为了可以获得较好的性能，保持为False即可。

import time
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading",end = "")
for i in range(20):print(".",end = '',flush = True)time.sleep(0.5)

---RUNOOB EXAMPLE ： Loading 效果---
Loading....
Loading........
Loading...........
Loading..............
Loading....................（动态过程，不是重复输出）
进程已结束,退出代码0

格式化输出

• s : 获取传入对象的__str__方法的返回值，并将其格式化到指定位置
• r : 获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
• c : 整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
• o : 将整数转换成 八  进制表示，并将其格式化到指定位置
• x : 将整数转换成十六进制表示，并将其格式化到指定位置
• d : 将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
• e (E): 将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e/大写E）
• f（F） :  将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
• g : 自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
• G : 自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
• % : 当字符串中存在格式化标志时，需要用 %%表示一个百分号;
• +       右对齐；正数前加正好，负数前加负号；
• -       左对齐；正数前无符号，负数前加负号；
• '空格'     右对齐；正数前加空格，负数前加负号；
• 0       右对齐；正数前无符号，负数前加负号；用0填充空白处

%

"... %[key][flags][width][.precision][length type][conversion type] ..." % values

• %: 必须要有的符号，它标记占位符的开始。
• key: 选填。映射的键，由带括号的字符序列组成，一般用于后面的values是是字典的场景。
• flags: 选填。转换标志(Conversion flags), 会影响某些转换类型的结果。
• width: 选填。最小字段宽度。如果指定为“*”（星号），则实际宽度从值中元组的下一个元素读取，要转换的对象位于最小字段宽度和可选精度之后。
• precision: 选填。精度，写法为.precision（点+精度）。如果指定为“*”（星号），则实际宽度从值中元组的下一个元素读取，要转换的值位于精度之后。
• length type: 选填。长度修改器。
• Conversion type: 必须要有的符号。转换类型，也标记占位符的开始。

Conversion type
由于这个字段是必选字段，所以最先介绍（%写法是固定的，Conversion type则必须要选择一个转换类型）

x=input("强大的战斗力、冷静的思维、丰富的经验与酒鬼妹控的形象以及叛变后所展现出更恐怖的战斗力,那么她是谁：")
print("拖尸王:%s"%x)

强大的战斗力、冷静的思维、丰富的经验与酒鬼妹控的形象以及叛变后所展现出更恐怖的战斗力,那么她是谁：M16
拖尸王:M16进程已结束,退出代码0

key （不常用）
选填字段是搭配{字典格式的values使用的

x=input("少女前线是一款怎样的游戏：")
print("羽中曾曰：“少女前线是一个充满%(爱与希望)s的游戏”"% {"爱与希望":x})

少女前线是一款怎样的游戏：充斥着各种现实主义且十分悲痛的情节
羽中曾曰：“少女前线是一个充满充斥着各种现实主义且十分悲痛的情节的游戏”进程已结束,退出代码0

flags （不常用）

• 0    数值的转换将被零填充，需搭配width使用(示例见下面的width中的)。
• -    转化结果左对齐，需搭配width使用(示例见下面的width中的)， 该标志符会覆盖0标志符。
• 空格 在带符号的转换产生的正数（或空字符串）, 之前留一个空格(方便正负数最后对齐)。
• +    转换数字后，数字前面将会展示其正负号（“+”或“-”）, 如果原输出数字存在正负号则该标志符会被覆盖。

x="少女前线"
for i in x:y=ord(i)print("%+d"%y,end="")

+23569+22899+21069+32447
进程已结束,退出代码0

[width][.precision]

【宽度】.【精度】

• 设置字段的最小占位宽度，默认右对齐，内容不够时使用空格填充
• 转换标志：

1. -表示左对齐；
2. +表示在转换值之前显示正负号；
3. “（空格）”表示正数之前保留空格（对负数貌似没用）；
4. 0表示转换值若位数不够则用0填空。

• 最小字段宽度：转换后的字符串至少应该具有该值指定的宽度。如果是*，则宽度会从后边元组中读出
• （.）后是精度值：如果转换的是实数，精度值就表示出现在小数点后的位数，如果*，那么精度将从后边元组中读出。如果转换的是字符串，那么该数字就表示最大字符串宽度。

x="少女前线"
list1=[]
for i in x:y=ord(i)print(type(y))list1.append(y)
list1.append(1001.0)
list1=tuple(list1)
print("%15.5f,%f,%-015.5f,%-15.5f,%015.5f"%list1)
print("\t%*.*f"%(5,5,100))

    23569.00000,22899.000000,21069.00000    ,32447.00000    ,000001001.00000100.00000

注意： 

1. 如果有“-”标志将覆盖“0”标志
2. 当前字符宽度超过限定宽度按实际输出
3. 不可以将可变列表作为变量填入

length type (使用方式未知)

format

"... {[field_name][!conversion][:format_spec]} ...".format(arguments)
arguments
位置参数（Positional Arguments）

print("AR小队成员：{},{}，{},{},{}".format("M4A1","M4 SOPMODⅡ",'AR15',"M16A1","RO635"))

print("AR小队成员：{4},{3}，{2},{1},{0}".format("M4A1","M4 SOPMODⅡ",'AR15',"M16A1","RO635"))

AR小队成员：M4A1,M4 SOPMODⅡ，AR15,M16A1,RO635
AR小队成员：RO635,M16A1，AR15,M4 SOPMODⅡ,M4A1
进程已结束,退出代码0

注意： 

        对于位置参数，arg_name必须为序号（此时该字段可不填，不填则默认第一个为0，从前往后依次+1），两者效果一样。

关键字参数（Keyword Arguments）

print("AR小队成员:{小公主},{狗子},{自爆卡车},{十六鸽},{喇叭}".format(小公主='M4A1',狗子='M4 SOPMODⅡ',自爆卡车='AR15',十六鸽='M16A1',喇叭='RO635'))

AR小队成员:M4A1,M4 SOPMODⅡ,AR15,M16A1,RO635

注意：

1. 其实位置参数和关键字参数可以混用，但是混合使用时，必须将 位置参数 写到前面，关键字参数 不用按照顺序来指定。
2. {}里面不能填中文，差评，好评，记得中文不要加引号，计算机会自动加
3. 对于关键词参数，arg_name必须为其中的关键字，（此时该字段是必填项）

拓展：

该字段完整语法格式为arg_name(.attribute_name | [element_index])*，是在arg_name对应的值为对象、列表或字典时使用，获取其进一步的属性值或者内部值。

print("AR小队成员:{0[小公主]},{0[狗子]},{0[自爆卡车]},{0[十六鸽]},{0[喇叭]}".format({'小公主':'M4A1','狗子':'M4 SOPMODⅡ','自爆卡车':'AR15','十六鸽':'M16A1','喇叭':'RO635'}))

（更多总结，日后再更）

！conversion  

指定时要用!来开头，指定后会在格式化之前将arguments中对应的值进行类型变换。

1name='M4 SOPMOD II'
print(f"格里芬战犬 is {name!s}.")

1name='M4 SOPMOD II'
print(f"格里芬战犬 is {name!r}.")

name='åM4 SOPMOD IIå'
print(f"格里芬战犬 is {name!a}.")

（暂时不清楚有什么用，以后开发）

[format_spec]

[[fill]：align][sign][#][0][width][grouping_option][.precision][type]

• fill: 填充内容，如果指定了宽度，但变量长度不够，会使用该字段值进行填充。（设置了fill，后面必须显式设置align。）
• align: 

1. <    强制左对齐（绝大多数对象默认使用）
2. >    强制右对齐（数字类型默认使用）
3. =    强制将填充内容放在符号(如果有)之后但数字之前，比如输出成+000000120这样的格式。此对齐选项仅对数字类型有效。(当’0’紧接在字段宽度width之前时，它将成为默认值。)
4. ^    强制居中对齐

• sign: 符号展现格式（仅对数字类型有效）

1. +    正数负数都展现符号，正数用+，负数用-。
2. -    （默认值），仅负数展现符号。
3. ‘（空格）’负数展现符号，正数前面使用一个空格来占位对齐。

print("404小队成员:{0[钢板]:-d},{0[莱娜]:<d},{0[小怪兽]:>+d},{0[家里蹲]: d}".format({'钢板':-1,'莱娜':2,'小怪兽':-3,'家里蹲':4}))

404小队成员:-1,2,-3, 4

•  precision: 精度

1. 指定时要用.来开头,是一个十进制数，指定用’f’和’f’格式化的浮点值在小数点后应该显示多少位,即保留几位小数。

• width: 最小字段宽度，不设置则字段宽度将始终与填充它的数据长度相同（此时对齐方式align没有意义）。 fill, align只有设置了width才能生效。
• type: 类型，决定数据应该如何显示。(上面类似)

print("404小队成员:{0[钢板]:10s},{0[莱娜]:<10s},{0[小怪兽]:>10s},{0[家里蹲]:^10s}".format({'钢板':"UMP45 ",'莱娜':'UMP9','小怪兽':'HK416','家里蹲':'G11'}))

404小队成员:UMP45     ,UMP9      ,     HK416,   G11 

• #: 复杂生僻，基本不使用，不介绍，有需要的可查阅官方文档（见本部分开头）
• 0: 当没有设置对齐方式align时, 在宽度字段前面加一个零(‘0’)字符，将等价于填充字符fill为0且对齐方式align为<。

print("404小队成员:{0[钢板]:+05d},{0[莱娜]:w<-5d},{0[小怪兽]: d},{0[家里蹲]: d}".format({'钢板':-1,'莱娜':2,'小怪兽':-3,'家里蹲':4}))

404小队成员:-0001,2wwww,-3, 4

• grouping_option: 分组选择

1. ,    表示使用逗号作为千位分隔符。
2. _    复杂生僻，基本不使用，不介绍.

print("404小队成员:{0[钢板]:+05,d},{0[莱娜]:w<-5,d},{0[小怪兽]: ,d},{0[家里蹲]: ,d}".format({'钢板':-1000,'莱娜':2000,'小怪兽':-3000,'家里蹲':4000}))

404小队成员:-1,000,2,000,-3,000, 4,000

 f 表达式

{f_expression[=][!conversion][:format_spec]}

• f_expression:

必填内容，常规Python表达式，一般要被圆括号包围

注意事项：

1. 不允许使用空表达式。
2. lambda和赋值表达式:=必须用显式括号括起来。
3. =: 选填(3.8新版功能), 在表达式后添加等号’=’, 可以显示表达式文本及其求值后的值(在调试中很有用)，。

• ！conversion:

（跟之前一模一样）

• format_spec:

嵌套使用replacement_field指定其中的值。

value=644.751113151
width=12
precision=5
print(f"result: {value:{width}.{precision}}")

选择结构

条件表达式

注意：

在条件表达式的值只要不是False、0（或0.0、0j等）、空值None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象，Python解释器均认为与True等价。
 

关系运算符

renxin=input()
if renxin+"兵蚁"=="RO635兵蚁":print("我死了算了")

RO635
我死了算了进程已结束,退出代码0

注意：

条件表达式中不允许使用赋值运算符“=”，避免了误将关系运算符“==”写作赋值运算符“=”带来的麻烦。在条件表达式中使用赋值运算符“=”将抛出异常，提示语法错误。

逻辑运算符

逻辑运算符and、or、not分别表示逻辑与、逻辑或、逻辑非。对于and而言，必须两侧的表达式都等价于True，整个表达式才等价于True。

game=input().split()
if game==["少女前线","药丸"]:print("正解")
少女前线 药丸
正解

少女前线 药丸
正解

注意：

逻辑运算符and和or具有短路求值或惰性求值的特点，可能不会对所有表达式进行求值，而是只计算必须计算的表达式的值。

单分支选择结构

if Ture:print("坚持少前药丸方针不动摇")

P三元运算符，并且在三元运算符构成的表达式中还可以嵌套三元运算符，可以实现与选择结构相似的效果。

语法：

当条件表达式condition的值与True等价时，表达式的值为value1，否则表达式的值为value2。

value1 if condition else value2

print("少前药丸" if '地球都是圆的'else'少前要火')

少前药丸

多分支选择结构

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

循环结构

for…in…

格式：for 参数 in 循环体：pass

x="找·到·你·了·哦!"
for i in x:print(i,end="")
找·到·你·了·哦!

找·到·你·了·哦!

while

while要先将循环变量初始化或者直接使用while True 这种死循环形式。

格式：while True:pass

y='蹦！蹦！蹦——！全部破坏掉！哈哈哈哈哈！'
while y:if len(y)==1:print(y)y=list(y)y.clear()else:print(y[0],end="")y=y[1:]

蹦！蹦！蹦——！全部破坏掉！哈哈哈哈哈！

range()

range(start,stop,step) （结尾的参数为stop-1）

z="诶哈哈哈，狂欢节开始啦开始啦！"
for i in range(0,len(z)):print(z[i],end="")

诶哈哈哈，狂欢节开始啦开始啦！

 else

（一）上述格式中，如果if后面的条件成立（即为Ture）则运行pass1语句。条件不成立（即为flase）,则运行else后面的pass2语句。

格式：if 条件:pass1else:pass2

（二）While正常结束（表达式为False）或for正常循环结束时跳为执行else：

p="少女前线"
list1=[]
T=True
while T:for i in p:list1.append(ord(i))else:print(list1)T=False
else:list2=[chr(i) for i in list1]print(list2)

[23569, 22899, 21069, 32447]
['少', '女', '前', '线']

 elif

当出现的判断条件较多，我们需要进行较为精准的判断时，我们就需要使用elif来实现了。#并列（拥有先后顺序）

格式：if 条件判断1:<执行1>elif 条件判断2:<执行2>elif 条件判断3:<执行3>else:<执行4>

上述判断条件的执行顺序是：那个条件判断成立就执行那个后面的执行语句。若均不成立，这执行else后面的执行语句。

if gailu<0.01:print('您获得的人形是：IDW喵哒')
elif gailu<0.6:print('您获得的人形是：MP5')
elif gailu>0.2:print('无')
elif gailu<0.99:print('啥都没有')
else:print("您获得的人形是：P90")

重建
0.17958336080892
您获得的人形是：MP5

break、contiune

        break
        break的意思是：结束当前循环。

        continue
        意思为结束当前循环进入下一个循环

异常处理

try....except...（else）... (finally)

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

​

try:
可能产生异常的代码块
except [ (Error1, Error2, … ) [as e] ]:
处理异常的代码块1
except [ (Error3, Error4, … ) [as e] ]:
处理异常的代码块2
except [Exception]:
处理其它异常
finally:
资源回收处理

• 如果在try子句执行时没有发生异常，将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。
• 如果当try后的语句执行时发生异常，就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

获取特定异常信息

• args：返回异常的错误编号和描述字符串；
• str(e)：返回异常信息，但不包括异常信息的类型；
• repr(e)：返回较全的异常信息，包括异常信息的类型。

try 1/0 except Exception as e:
# 访问异常的错误编号和详细信息print(e.args)
print(str(e))
print(repr(e))输出结果为：
(‘division by zero’,)
division by zero
ZeroDivisionError(‘division by zero’,)

异常类型

​

在 Python 中，所有异常必须为一个派生自 BaseException 的类的实例。

BaseException： BaseException是所有异常的基类

主要包括以下四类：

SystemExit、KeyboardInterrupt、GeneratorExit、Exception是BaseException基类的实例化对象，但是Exception不同，其作为基类又衍生出更多常规异常子类。

Exception基类：

无子类的实例化对象：

有子类的实例化对象：

ArithmeticError：所有数值计算错误的基类

ImportError：导入失败

LookupError：无效数据查询的基类

NameError：未声明、初始化对象

OSError：操作系统错误

ConnectionError：与连接相关的异常的基类

RuntimeError：一般的运行时错误

SyntaxError：Python 语法错误

IndentationError：缩进错误

ValueError：传入无效的参数

UnicodeError：Unicode 相关的错误

Warning：警告的基类

BaseException       所有异常的基类     +-- SystemExit       解释器请求退出+-- KeyboardInterrupt     用户中断执行(通常是输入^C)+-- GeneratorExit      生成器(generator)发生异常来通知退出+-- Exception        常规错误的基类+-- StopIteration       迭代器没有更多值 +-- StopAsyncIteration       必须通过异步迭代器对象的__anext__()方法引发以停止迭代+-- ArithmeticError         所有数值计算错误的基类|  +-- FloatingPointError       浮点计算错误|  +-- OverflowError         数值运算超出最大限制|  +-- ZeroDivisionError       除(或取模)零 (所有数据类型+-- AssertionError         断言语句失败+-- AttributeError         对象没有这个属性+-- BufferError          与缓冲区相关的操作时引发+-- EOFError            没有内建输入,到达EOF 标记+-- ImportError           导入失败|  +-- ModuleNotFoundError    找不到模块+-- LookupError           无效数据查询的基类|  +-- IndexError           序列中没有此索引(index)|  +-- KeyError            映射中没有这个键+-- MemoryError           内存溢出错误+-- NameError            未声明、初始化对象|  +-- UnboundLocalError       访问未初始化的本地变量+-- OSError             操作系统错误，|  +-- BlockingIOError        操作将阻塞对象设置为非阻塞操作|  +-- ChildProcessError       子进程上的操作失败|  +-- ConnectionError        与连接相关的异常的基类|  |  +-- BrokenPipeError       在已关闭写入的套接字上写入|  |  +-- ConnectionAbortedError   连接尝试被对等方中止|  |  +-- ConnectionRefusedError   连接尝试被对等方拒绝|  |  +-- ConnectionResetError    连接由对等方重置|  +-- FileExistsError        创建已存在的文件或目录|  +-- FileNotFoundError       请求不存在的文件或目录|  +-- InterruptedError       系统调用被输入信号中断|  +-- IsADirectoryError       在目录上请求文件操作|  +-- NotADirectoryError      在不是目录的事物上请求目录操作|  +-- PermissionError       在没有访问权限的情况下运行操作|  +-- ProcessLookupError      进程不存在|  +-- TimeoutError         系统函数在系统级别超时+-- ReferenceError        弱引用试图访问已经垃圾回收了的对象+-- RuntimeError         一般的运行时错误|  +-- NotImplementedError   尚未实现的方法|  +-- RecursionError      解释器检测到超出最大递归深度+-- SyntaxError          Python 语法错误|  +-- IndentationError     缩进错误|     +-- TabError     Tab 和空格混用+-- SystemError       一般的解释器系统错误+-- TypeError        对类型无效的操作+-- ValueError       传入无效的参数|  +-- UnicodeError       Unicode 相关的错误|     +-- UnicodeDecodeError   Unicode 解码时的错误|     +-- UnicodeEncodeError   Unicode 编码时错误|     +-- UnicodeTranslateError Unicode 转换时错误+-- Warning            警告的基类+-- DeprecationWarning     关于被弃用的特征的警告+-- PendingDeprecationWarning  关于构造将来语义会有改变的警告+-- RuntimeWarning      可疑的运行行为的警告+-- SyntaxWarning      可疑的语法的警告+-- UserWarning       用户代码生成的警告+-- FutureWarning      有关已弃用功能的警告的基类+-- ImportWarning      模块导入时可能出错的警告的基类+-- UnicodeWarning      与Unicode相关的警告的基类+-- BytesWarning       bytes和bytearray相关的警告的基类+-- ResourceWarning      与资源使用相关的警告的基类