各类数据类型汇总：
1. 数字类型
⭐ 数字类型是不可变的
1.2 整数 int
- 与数学中整数概念一致：其**取值范围在理论上是没有限制的** （可能会受到计算机内存大小的影响）
- 整数可正可负：增加正负号表示整数，一般正数可以忽略正号
- 默认情况下，采用十进制。其他进制需要增加相应的引导符号
进制 前导符 示例 十进制
二进制： 0b 或 0B 0b10 2
八进制： 0o 或 0O 0o10 8
十六进制： 0x 或 0X 0x10 101.3 浮点数 float
- 与数学中的实数概念一致
- 取值范围与精度都有限制
- 表示方式：
- 小数：1.23，3.14，-9.01
- 科学计数法：
1.23x10**9(10的9次方)：1.23e9
0.000012：1.2e-5- 浮点数运算存在不确定尾数，有误差，从第15位开始会出现误差
>>> 0.1+0.2
0.30000000000000004 #小数点后有17位
>>> 2.1-2.0
0.10000000000000009
>>> a = 10.000000000000001 #小数点后有15位
>>> a
10.000000000000002
>>> a = 0.1+0.2
>>> a
0.30000000000000004
#默认情况下，超过15位小数位被省略，当然也有可能像上面的代码，没有省略且有误差
>>> a = 10.0000000000000001
>>> a
10.0
>>> a = 10.00000000000000001
>>> a
10.0造成这一原因：
a = 0.1+0.2： 0.30000000000000004
以上值是一个浮点的**近似值**。确切的存储值是 1351079888211149 / 4503599627370496 ，大约为 0.3000000000000000444089209850
整数与浮点数大小相同，指向的是同一个值
>>> 2 == 2.0 True
round函数
round(x[,n]) 四舍五入函数
# 默认不保留小数点
>>> round(1.923141231)
2
>>> round(1.99,1)
2.0
#当指定取舍的小数点位数的时候，一般情况也是使用四舍五入的规则，但是碰到.5的情况，如果要取舍的位数前的小数是奇数，则直接舍弃，如果是偶数则向上取舍。
>>> round(1.95,1)
1.9
>>> round(1.85,1)
1.9round函数能够用来解决浮点数运算存在不确定尾数，有误差的情况
>>> 0.1+0.2 == 0.3
False
>>> round(0.1+0.2,2) == 0.3 #设置仅保留两位小数
True小数点取舍相关
- 四舍五入规则：
当指定取舍的小数点位数的时候，一般情况也是使用四舍五入的规则，但是碰到.5的情况，如果要取舍的位数前的小数是奇数，则直接舍弃，如果是偶数则向上取舍。 - 整除的小数点取舍：
向左取舍。
>>> -3//2
-2
>>> 3//2
1- 不打算小数点进位或者取舍
>>> PI = 3.1415926
>>> print((int)(PI*10000)/10000) #乘10000后取整，丢弃了后面的小数，再除以10000，就实现了小数点不进位
3.14151.4 复数 complex
- 与数学中的复数概念一致
- 由实部和虚部组成，虚部由 j 表示。
- 例如：
2+3j：2为实部，3j为虚部 - 与复数相关的函数
- real属性
- imag属性
- complex函数
>>> a = complex(1,2)
>>> a
(1+2j)
>>> a.real
1.0
>>> a.imag
2.01.5 算数运算符
运算符 说明 示例 运算结果
+ 加法 5+10 15
- 减法 100-5 95
* 乘法 8*9 72
/ 浮点数除法 100/5 20.0
// 整数除法(想左取整) 100//5 20
% 模（求余）(支持浮点数) 9%4 1
** 幂 2**3 8- 除 与 整除(向左取整)
#除的结果 必定为 浮点数
>>> 3/2
1.5
>> 100/2
50.0 #注意了除的结果虽然是整数结果，但是输出必须是浮点数（带小数的）# 整数的整除 结果为 整数
>>> 3//2 #1.5 向左取整为 1
1
>>> -3//2 #-1.5 向左取整为 -2
-2
# 浮点数参与的整除 结果为 浮点数
>>> 3.0//2.0
1.0
>>> 3.0//2
1.0- 模
#浮点数a和b，a%b == a-n*b, n为不超过a/b的最大整数 ⭐⭐⭐
>>> 3%2
1
>>> 3.2%1.5 #3.2-2*1.5 = 0.2 ，只是尾数有点误差
0.20000000000000018- 幂
#幂
>>> 2**3
8混合运算：
- 整数 与 浮点数 混合运算，结果为 浮点数。
- 整数和浮点数 与 复数 混合运算，结果为 复数。
2. 布尔值
- 布尔值：True、False (开头大写)
- 逻辑运算 和 关系运算 的结果是 布尔值
- 各种数据类型对象作为布尔类型**“False”**使用：
- 数字类型： 0，0.0，0+0j
- 字符串类型：空字符串（ “” ）
- 布尔值： False
- 列表：空列表（ [] ）
- 元组：空元组（ () ）
- 字典：空字典（ {} ）
>>> a = not 2 #改结论同1.2中的情况
>>> b = 0
>>> a == b
True
>>> int(False)
0
>>> int(True)
1
>>> True == 1
True
>>> False == 0
True
>>> True+False #布尔值 通过数值运算，结果为int型结果
1
>>> a = True+False
>>> type(a)
<class 'int'>关系运算符
== ， != ， > ， >= ， < ， <=
关系运算符实例：
>>> 1<3<5 #等价于 1<3 and 3<5
True
>>> 3<5>2 #等价于 3<5 and 5>2
True
>>> 1>6<8 #等价于 1>6 and 6<8
False
>>> import math
>>> 1>6<math.sqrt(9) #等价于 1<6 and 6 < math.sqrt(9) = 3
False
>>> 'Hello'>'world' #ascii('H') = 72 < ascii('w') = 119
False
>>> 'Hello'>3 #字符串和数字不能比较
TypeError: '>' not supported between instances of 'str' and 'int'逻辑运算符
and ， or ， not
逻辑运算符实例：
>>> 3>5 and a>3 #注意，此时并没有定义变量a，因为 3>5 为False 且 为and运算，所以没有继续运算后面的就直接返回False
False
>>> 3>5 or a>3 #3>5 为False，所以还需要计算后面的表达式，但因为 a变量并没有定义，会直接报错
NameError: name 'a' is not defined
>>> 3<5 or a>3 #这个原因类似第一条实例
True
#最后一个计算的表达式的值 作为 整个表达式的值
>>> 3 and 5
5
>>> 0 and 2 #因为是and运算，算到0就结束了，输出最后一个计算的表达式的值 0
0
>>> 0 or False #因为是 or 运算，算到False才结束了，输出最后一个计算的表达式的值 False
False
>>> not 3 #非零 为 True
False
>>> not 0 #0 为 False
True运算符的优先级和结合性：
（越前优先级就越高）
结合性（多目运算符）：
乘方（幂）：从右向左；其余为从左向右
优先级和结合性实例：
>>> 3 + 5 * 4 #先乘后加
23
>>> 5 * 3 / 2 #从左向右
7.5
>>> 2 ** 3 ** 2 #从右向左
512
>>> 3<5 or a >3 #从左向右
True3. 空值
空值是Python里一个特殊的值，用None表示。None不能理解为0
>>> bool(None)
False
>>> None == 0
False
>>> str(None)
'None'
#int(None) float(None) ... 都是会报错的4. Python组合数据类型
Python语言最常用的组合数据类型有3大类
- 集合类型（元素类型不可重复，且是固定一种数据类型，例如整型，字符型）
集合类型是一个元素集合，元素之间无序，相同元素在集合中唯一存在。 集合是无序组合，用大括号（ { }）表示，他没有索引和位置的概念，集合中的元素可以动态的增加和删减。
集合类型是一个具体的数据类型，而序列类型和映射类型都是一类数据类型的总称。
Python语言中的集合类型与数学中的集合概念一致，即包含0个或多个数据项的无序组合。
- 序列类型（可变的，有序的）
序列类型的典型代表是字符串类型、列表类型和元组类型
序列类型是一个元素向量，元素之间存在先后关系，通过序列号访问，元素之间不排他。
- 字符串可以看成是一个单一字符的有序组合，也是一个基本数据类型
- 元组（不可变序列，不能删除，不能修改）
- 列表（灵活可变）
- 映射类型
映射类型是**“键-值”数据项的组合，每一个元素是一个键值对，表示为（key，value）。 映射类型的典型代表是字典**类型。
5. 序列
序列指的是包含多项数据的数据结构。这些数据按照一定的顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
常用的序列类型：列表（list），字符串（str），元组（tuple）
无序，可理解为不能通过索引访问的，如 字典、集合。
5.1 通用的序列操作(总)
操作 | 描述 |
X1+X2 | 联接序列X1和X2,生成新序列 |
X*n | 序列X重复n次，生成新序列 |
X[i] | 引用序列X中下标为i的成员 |
X[i：j] | 引用序列X中下标为i到j-1的子序列 |
X[i：j：k] | 引用序列X中下标为i到j-1的子序列，步长为k |
len(X) | 计算序列X中成员的个数 |
max(X) | 序列X中的最大值 |
min(X) | 序列X中的最小值 |
v in X | 检查v是否在序列X中，返回布尔值 |
v not in X | 检查v是否不在序列X中，返回布尔值 |
5.2 序列索引
可以理解为访问序列的单个元素，返回索引对应的元素。
序列中，每个元素都有属于自己的编号（索引）。从起始元素开始，索引值从 0 开始递增，如图所示。
除此之外，Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图所示。
>>> a = "hello"
>>> a[0]
'h'
>>> a[-1]
'o'5.3 序列切片
可以理解为访问序列的多个元素，返回的是序列。
X[i：j]
引用序列X中**下标为 i 到 j-1 **的子序列
>>> a
'hello'
>>> a[1:3]
'el'同样地，切片也可以使用负的下标
>>> a[0:-2]
'hel'切片省略第2个下标，表示从第1个下标的元素开始到最后一个元素的切片。
>>> a[1:]
'ello'第1个下标为0时，可以省略。
>>> a[:2]
'he'两个参数都可以省略，其实就和直接输出列表没有区别了。
X[i：j：k]
引用序列X中下标为 i 到 j-1 的子序列，步长为k
>>> a
'hello'
>>> a[0:5:2]
'hlo'同样地，使用负的下标。
>>> a[0:-1:2]
'hl'切片使用第3个参数为负数时，表示逆向取切片。
>>> a[-1:-6:-1] #使用逆向取切片的时候，最好使用负数的下标，更好理解
'olleh'切片省略第2个下标，表示从第1个下标的元素开始到最后一个元素的切片。
>>> a[1:]
'ello'第1个下标为0时，可以省略。
>>> a[:2]
'he'省略前两个参数，就是原序列，再根据步长取元素。
三个参数都可以省略，其实就和直接输出列表没有区别了。
看带有步长的切片的时候，先判断步长的正负：
为正：将前两个参数转为正索引进行理解
为负：将前两个参数转为负索引进行理解
复制序列
>>> a=[1,2,3]
>>> b=a
>>> b[0]=2
>>> a
[2, 2, 3]如上操作，a和b指向的都是同一个空间，如同1.2所说的：赋值操作并不会实际赋值值，它只是为数据对象取个相关的名字。
如果希望2个变量各自拥有独立的序列，可使用切片。
>>> a=[1,2,3]
>>> b=a[:]
>>> b[0]=2
>>> a
[1, 2, 3]
>>> b
[2, 2, 3]5.4 序列的运算符
+，*，in，not in，len() | __len__()，min()，max()
+：
>>> a=[1]
>>> b=[2]
>>> print(a+b)
[1, 2]*：
>>> a=[1]
>>> print(a*3)
[1, 1, 1]in：
>>> a=[1]
>>> print(1 in a)
True
>>> print([2,3] in [[2,3],5,7,11,13])
True
>>> print('he' in 'hello')
Truenot in：
>>> a=[1]
>>> print(1 not in a)
Falselen(x) | x._len_()：见 “Python内置函数”
min() 和 max()：见"Python内置函数"
6. 字符串
字符串是一连串的字符，用英文单引号（'） 或英文双引号（ " ）括起来（还可以是三引号，但是这三种不能混合使用，引号必须成对出现）
当字符串中需要使用双引号的时候，可以用单引号包住字符串内容；
反之，当字符串中需要使用单引号的时候，可以用双引号包住字符串内容；
当需要双引号和单引号的时候，就用三引号包住字符串内容即可。
6.1 各样的字符串
6.1.1 长字符串 ‘’'，“”"
用3个引号（“”"，‘’'）括起来的字符串可以包含多行字符串。
>>> print('''This is a test
for multiple lines
of text.''')
#长字符串跨行的时候，输出也是跨行的
This is a test
for multiple lines
of text.其可以表示为包含了2个换行符的字符串：'This is a test\nfor multiple lines\nof text.'
如果要在程序中用多行表示一个字符串，则可以在每行的结尾用反斜杠（\）结束。
'hello \
world'
结果是：'hello world'6.1.2 原始字符串 r"…"
在一个字符串前加一个字符r（raw），表示这个字符串是原始字符串，其中的 \ 不被当作是转义字符前缀。
>>> print('asn\nasd')
asn
asd
>>> print(r'asn\nasd')
asn\nasd6.1.3 格式化字符串f"…"
格式化的字符串文字前缀为 ‘f’ 和接受的格式字符串相似str.format()。它们包含由花括号包围的替换区域。替换字段是表达式，在运行时进行评估，然后使用format()协议进行格式化。
简而言之，就是对format函数格式化字符串的简写。
举例：
ws = 1
print(f'max row:{ws:.2f}')
#result:
#max row:1.006.1.4 u"…"
后面字符串以 Unicode 格式 进行编码，一般用在中文字符串前面，防止因为源码储存格式问题，导致再次使用时出现乱码。
>>> u"你好"
'你好'6.1.5 b"…"
b" "前缀表示：后面字符串是bytes 类型。
网络编程中，服务器和浏览器只认bytes 类型数据。如：send 函数的参数和 recv 函数的返回值都是 bytes 类型
在 Python3 中，bytes 和 str 的互相转换方式是
str.encode(‘utf-8’) bytes.decode(‘utf-8’)
6.2 字符串是不可修改的（不可变的）
字符串中的数据（字符）是不能修改的。
>>> s='hello'
>>> s[0]=k
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'k' is not defined可以通过用新的字符串对变量重新赋值，表示新的字符串。
>>> s='hello'
>>> s='bye'
>>> s
'bye'6.3 字符串运算符
- +：连接字符串
>>> '1'+'12'
'112'- *：复制字符串
>>> '1'*10
'1111111111'- 比较奇葩的运用：多个字符串直接贴在一起，相当于连接字符串
>>> a="asd""asd"'as'
>>> a
'asdasdas'6.4 字符串索引&切片
- 字符串是一个有序序列，可以是正向递增，也可以是反向递减：
0 1 2 3 4 5 6 7
字符串： a b c d e f g h
-8 -7 -6 -5 -4 -3 -2 -1- 索引：
- 正索引（下标）：在 [ ] 中给出序号（0 到 n-1） （n表示字符串的长度）
- 负索引：在 [ ] 中给出切片序号范围（-n 到 -1）
>>> a = 'abcdefgh'
>>> a[0]
'a'
>>> a[-8]
'a'切片运算从序列类型对象中选取一系列元素，得到新的对象。详细的使用键5.3
>>> "asdasd"[:-1]
'asdas'
>>> "asdasd"[2:-1]
'das'6.5 字符串常用方法或函数
title()，lower()，upper()
- title():
使用：S.title()作用：字符串S首字母大写
返回：字符串S首字母大写后的字符串
>>> s
'bye'
>>> s.title()
'Bye'- lower():
- 使用：
S.lower() - 作用：字符串S变小写
- 返回：字符串S变小写后的字符串
>>> s
'bye'
>>> s.lower()
'bye'- upper():
- 使用：
S.upper() - 作用：字符串S变大写
- 返回：字符串S变大写后的字符串
>>> s
'bye'
>>> s.upper()
'BYE'strip()，rstrip()，lstrip()
- strip():
使用：S.strip("....")作用：删除前后指定的字符（消除前后字符串中包含的字符），默认为空白符（空格 换行 回车 制表 ）
返回：删除前后指定字符后的字符串
>>> S=" s "
>>> S.strip()
's'
>>> var='abcd01234adfda'
>>> print(var.strip('bcdfa'))
01234- rstrip():
- 使用：
S.rstrip()指定字符的用法同strip() - 作用：删除右空白符
- 返回：删除右空白符后的字符串
>>> S=" s "
>>> S.rstrip()
' s'- lstrip():
- 使用：
S.lstrip()指定字符的用法同strip() - 作用：删除左空白符
- 返回：删除左空白符后的字符串
>>> S=" s "
>>> S.lstrip()
's 'find()，replace()，join()，split()，rsplit()，count()
- find():
使用：S.find(sub[,start[,end]])start 参数：可选，表示开始查找的下标（可正可负），默认0
end 参数：（前置现有start 才能考虑是否选择输入end参数），默认为len(S)，查找的范围 [start，end-1]
作用：在字符串S中查找sub子串首次出现的位置
返回：子串首次出现的位置（从左向右找）（位置即下标，正数的），找不到则返回 -1。
>>> s="heelo"
>>> s.find('h',-5)
0
>>> s.find('h',3)
-1
>>> s.find('o',0,5)
4- replace():
- 使用：
S.replace(old,new) - 作用：在字符串S中用new子串替换old子串
- 返回：返回替换后的字符串，如果字符串S中没有old字串，则不会替换且返回的也是原来的字符串。
>>> s.replace('a','sd')
'heelo'
>>> s.replace('ee','sd')
'hsdlo'- join():
使用：S.join(X)作用：用字符串S作为分隔符，将序列X合并成字符串 ⭐序列的元素必须都是字符串
返回：用字符串S作为分隔符，将序列X合并成字符串后的 字符串
>>> ' '.join(['1','2']) # ' '空格 作为分隔符，合并列表
'1 2'
>>> ' '.join(('1','2')) #合并 元组
'1 2'
>>> ' '.join({'1':'asd','2':'dsa'}) #合并 字典，只输出key，不输出value
'1 2'- split():
- 使用：
S.split(x)或者S.split(x,n) - 参数： str.split(separator, max)
- separator：可选。规定分割字符串时要使用的分隔符。默认的分割符号为空白符号（空格
' '、换行符\n、制表符\t、回车符\r）（空格可以是长空格，如：’ ’ ）。 - max：可选。指定要执行的拆分次数。默认值为 -1，即“所有出现次数”。
- 作用：
- 将字符串S从左开始拆分成列表（根据x为分隔符）
- 返回：字符串S拆分的列表
>>> "a\n\ns\ts\raa sa".split()
['a', 's', 's', 'aa', 'sa']
>>> "a-s".split("-")
['a', 's']
>>> "a,a,s".split(',',1)
['a', 'a,s']- rsplit():
- 使用：
S.rsplit(x)或者S.rsplit(x,n) - 参数： str.rsplit(separator, max)
- separator：可选。规定分割字符串时要使用的分隔符。，默认的分割符号为空白符号（见split）。
- max：可选。指定要执行的拆分次数。默认值为 -1，即“所有出现次数”。
- 作用：
- 将字符串S从右开始拆分成列表（根据x为分隔符）
- 返回：字符串S拆分的列表
>>> "a,a,s".rsplit(',',1)
['a,a', 's']- count():
使用：S.count(sub[,start[,end]])或者str.count(S,sub[,start[,end]])str为字符串类
start 参数：可选，表示开始查找的下标（可正可负），默认0
end 参数：（前置现有start 才能考虑是否选择输入end参数），默认为len(S)，查找的范围 [start，end-1]
作用：计算sub子串在字符串S中出现的次数
返回：sub子串在字符串S中出现的次数，找不到返回 0。
>>> s.count('o',0,5)
1
>>> s.count('o',0,4)
0
>>> s = 'This is a test.'
>>> print(str.count(s,'is'))
2
>>> print(str.count(s,'is',4,5))
0ljust()，rjust()，zfill()
- str.ljust(width[, fillchar])
- width：最小宽度
- fillchar：可选，用于填充的指定字符，默认为空格
按照指定的字符串宽度和特定字符来调整字符串宽度，若字符串不足指定的宽度就用指定的字符来填充剩余的宽度。
返回新的字符串
原字符串左对齐
- str.rjust(width[, fillchar])
原字符串右对齐，其余和ljust()一样 - str.zfill(width)
- width：最小宽度
返回指定长度的字符串（新的字符串），原字符串右对齐，前面填充0。
6.6 转义字符
\ #反斜杠符号
\' #单引号
\" #双引号
\a #响铃，就是让你电脑的操作系统发出提示音
\b #退格（Backspace）
\n #换行
\v #纵向制表符
\t #横向制表符
\r #回车
\f #换页
\ooo #最多三位 八进制，例如：\12 代表换行
\xyy #十六进制，yy代表的字符，例如:\x0a 代表换行>>> '\10'
'\x08'
>>> '\x0f'
'\x0f'6.7 字符串格式化
字符串格式化运算符 %
<带有转换说明符%的 字符串> % (<需要转换的值>[,<需要转换的值>])
%的使用格式： %[(name)][flags][width].[precision]typecode
- name：命名
- flags：+ 表示右对齐；- 表示左对齐；’ ’ 为空格，表示在整数的左侧填充一个空格，从而与负数对齐；0 表示用0填充
- width：显示最小宽度
- precision：小数点后位数
- typecode：类型码
>>> 'Happy Birthday %d!' % (23)
'Happy Birthday 23!'
也可以有多个转换的值:
>>> 'Happy Birthday %d, %s!' % (23, 'John Johnson')
'Happy Birthday 23, John Johnson!'
# 小数点等用法照样可以使用，同时四舍五入也和{}(format函数)等方法一样
>>> 'Happy Birthday %.1f, %s!' % (23.95, 'John Johnson')
'Happy Birthday 23.9, John Johnson!'Python字符串的格式占位符
占位符 | 含义 |
%c | 单个字符，替换成只有一个字符的字符串，或将Unicode码转成一个字符 替换进来 |
%s | 字符串 |
%d | 整数 |
%u | 无符号整数 |
%o | 八进制数 |
%x | 十六进制数 |
%X | 字母大写的十六进制数 |
%f | 浮点数 |
%e | 科学计数法表示的浮点数 |
%E | 大写的E表示的科学计数法 |
%g | 综合的%f和%e，系统自动决定是否使用科学计数法 |
%G | 大写表示的%g |
format函数
format()函数可以指定填充、对齐和宽度，以及精度和进制。它的一般格式是：
{<索引>:<填充字符><对齐方式><宽度.精度><格式>}
相当于用 “{}” 和 “:” 来代替之前的百分号进行格式化的输出。举例：
'{0:*>10}'.format(10) #右对齐
'{0:*<10}'.format(10) #左对齐,也是默认的选项
'{0:*^10}'.format(10) #居中对齐
'{0:.2f}'.format(1/3) #浮点数保留小数位，2位
'{0:.2e}'.format(1/3) #使用科学计数法，浮点数保留小数位，2位
'{:.2%}'.format(0.2) #使用百分数格式，保留两位小数
'{0:b}'.format(10) #二进制
'{0:o}'.format(10) #八进制
'{0:x}'.format(10) #16进制
'{:,}'.format(12345678901) #千分位格式化
Result：
'********10'
'10********'
'****10****'
'0.33'
'3.33e-01'
'20.00%'
'1010'
'12'
'a'
'12,345,678,901'一旦要求使用填充字符、对齐方式、宽度或者精度，都需要加上 “:”
- 四舍五入的规则：
当指定取舍的小数点位数的时候，一般情况也是使用四舍五入的规则，但是碰到.5的情况，如果要取舍的位数前的小数是奇数，则直接舍弃，如果是偶数则向上取舍。
- 使用方式一
str.format()
返回自己格式化后的字符串
例：
>>> x=3.14159
>>> y=2*x*3
>>> z=1
>>> print("{0:.2f} {1:.2f} {2}".format(x,y,z))
3.14 18.85 1- 0、1、2 表示format函数中的第一、二、三个参数（还能更多，但是必须存在对应序号的参数）
- .2f 表示小数部分保留两位，⭐**四舍五入**⭐
可以不用指定参数，默认按照左到右的顺序填入参数
>>> 'my name is {} ,age {}'.format('Mary',18,20) 'my name is Mary ,age 18'
参数数量 多余 {} 的数量是没有问题的
- 使用方式二
format(数字或字符串，格式) 函数 返回自己格式化后的字符串
格式："<填充字符><最小宽度><分隔符><.精度><格式d f e % >"
>>> print(format(57.467657,".3f"))
57.468
>>> print(format(57.467657,"10.3f"))
57.468
>>>print(format(573456751.467657,"10.2f"))
57345675.47 #超过规定宽度
#10 表示输出总共占10字符（输出字符小于10字符时有效果，靠右排序）不同进制格式化：字符位置默认靠右
>>> print(format(45623,"10d")) #d 表示十进制
45623
>>> print(format(45623,"<10d")) #< 表示靠左输出
45623
>>> print(format(45623,"<10x")) #x 或 X,表示十六进制
b237
>>> print(format(45623,"<10X"))
B237
>>> print(format(45,"<10o")) #o 表示八进制
55
>>> print(format(45,"<10b")) #b 表示二进制
101101科学计数法格式化：字符位置默认靠右
>>> print(format(53.2345,"10.2e")) #10 表示总共10字符； .2 表示保留两位小数； e 表示使用科学计数法
5.32e+01
>>> print(format(0.000532345,"10.2e"))
5.32e-04
>>> print(format(532345,".2e"))
5.32e+05格式化字符串：字符位置默认靠左
>>> print(format("hello world","20s"))
hello world
>>> print(format("hello world",">20s")) # > 表示字符靠右
hello world
>>> print(format("hello world","^20s")) # ^ 表示字符靠中
hello world
>>> print(format("hello world","<20s")) # ^ 表示字符靠左
hello world习题测试：
求叫错序列前N项和，输入正整数N，输出序列和，结果保留三位小数
1-2/3+3/5-4/7+5/9-6/11+… 前N项
n = int(input())
re = sum([(1+i)/(1+2*i) if i%2==0 else -(1+i)/(1+2*i) for i in range(0,n)])
print("{0:.3f}".format(re))
10
0.3806.8 字符串的另类应用
- 可以将字符串作为多行注释（在脚本式编辑时适用，当然不能后语句放在一起）（因为字符串单独占行的时候，没有任何意义，所以可以作为多行注释）
"ass"
'asda'
"""as
d"""
'''as
d'''7. 列表
- ⭐类似数组
- 由一系列按照指定顺序排列的元素组成。列表中的元素可以是不同类型且任意。
- 列表的表示用方括号[ ]将元素括起来，元素之间用逗号,分隔。
[10, 20, 30, 40] #整数
['crunchy frog', 'ram bladder', 'lark vomit'] #字符串
['spam', 2.0, 5, [10, 20]] #字符串 浮点数 整数 列表
[['file1', 200,7], ['file2', 260,9]]列表的最大容量：
32位python的限制是 536870912 个元素；64位python的限制是 1152921504606846975 个元素，最大容量得看你机器的性能指标。你也可以看看源码，源码PyList_New中，list并非无穷大，在Python源码中规定了list的最大容量PY_SSIZE_T_MAX。
#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
(size_t)-1在c语言中表示0xFFFFFFFF。用来表示全1
7.1 列表的创建
使用“=”
使用“=”直接将一个列表赋值给变量。
>>> a = [] #创建了一个空列表
>>> a = [2,3,5,7,11,13]
>>> a
[2, 3, 5, 7, 11, 13]list()函数
使用list()将其他数据类型转换成一个列表。
>>> a = list('hello')
>>> a
['h', 'e', 'l', 'l', 'o']
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]列表的元素类型可以是任何类型，也包括列表类型。当列表的元素是列表时，可以构成**多维列表**，如同一个矩阵。
matrix = [ [1, 2, 3, 4, 5], [3, 0, 8,11,14], [5, 6, 9,12,16], [7, 0, 0, 0, 0], [9,11,17, 0,15] ]
- 用**matrix[0][0]**访问其中第一行第一列的元素
- 矩阵的每一行都是一个列表。
7.2 基本的列表操作
⭐ 列表是可变的
加法 +
>>> [1,2,3]+["c","java","python"]
[1, 2, 3, 'c', 'java', 'python']乘法 *
>>> [1]*10
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]比较
>>> [1,2,3] < [2,3,4]
True
>>> [1,2,3] < [1,3,4]
True
>>> [1,2,3] < [0,3,4]
False
>>> [1,2] < [2]
True
>>> [1] < [1,1]
True比较：
- 只能是 纯数字列表之间的比较，或者 纯字符串列表之间的比较（混合比较会报错的）；
- 比较的顺序是根据元素的下标从小到大对应比较，当相等时就继续比较下一个元素，直到有一方比较大；
- 当一直相等到有一方的元素用完，则还有元素剩余的一方比较大；
- 数字类型比较数字的大小，字符串类型比较字符串（字符串的比较规则也是第二条，用Unicode码比较）。
索引
（类似字符串，其实字符串也可以看作是列表）
- 在 [ ] 中给出序号（0 到 n-1） （n表示字符串的长度）
- 在 [ ] 中给出切片序号范围（-n 到 -1）
>>> a = [1,2,3]
>>> print(a[0],a[-3])
1 1列表元素的赋值
和字符串不同，列表中的元素可以被修改。
>>> a = [1]
>>> a[0] = 2
>>> a
[2]删除元素：del语句
用del语句删除列表中的元素。
>>> name = ['Perry','Bob','Cherry']
>>> del name[2]
>>> name
['Perry', 'Bob']切片赋值
切片表示列表的一部分，可以被赋值，即被替换成别的列表的元素。
>>> name=list('Perl')
>>> name[2:]=list('ar')
>>> name
['P', 'e', 'a', 'r']7.3 列表的常用方法或函数
append()，extend()，insert()
- L.append(x)
- 在列表L尾部追加x，x作为元素追加
>>> a=[1,2]
>>> a.append('s')
>>> a
[1, 2, 's']
>>> a.append([1])
>>> a
[1, 2, 's', [1]]- L.extend(x)
- 将列表x扩充到列表L中，将x列表中的元素加到L列表中，所以x必须是列表
>>> a
[1, 2]
>>> a.extend([1])
>>> a
[1, 2, 1]- L.insert(index,x)
- 将一个数据插入到列表的指定位置。index 从0开始。
>>> a = [1]
>>> a.insert(0,'2') #正常插入到指定的位置
>>> a.insert(6,'s') #向右超过范围，则加到最后
>>> a.insert(-5,'c') #向左超过范围，则加到最前
>>> a
['c', '2', 1, 's']使用乘法来扩展列表：
将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。
>>> a=[3,5,7]
>>> b=a
>>> a=a*3
>>> a
[3, 5, 7, 3, 5, 7, 3, 5, 7]
>>> b
[3, 5, 7]
>>> print(id(a),id(b))
2054141997568 2054142488000clear()，remove()，pop()
- L.clear()
- 移除列表L的所有元素
>>> a
[1, 2, 's']
>>> a.clear()
>>> a
[]- L.remove(value)
- 删除首次出现（从左向右）的指定元素value。如果要删除的数据不在列表中，则会发生错误。
>>> a=[1,2,3,2]
>>> a.remove(2)
>>> a
[1, 3, 2]- L.pop(index)
- 删除并返回指定（默认为最后一个）位置上的元素。若给定的索引超出范围，则报错。
>>> a=[1,2,3]
>>> print(a.pop(),a.pop(1))
3 2
>>> a
[1]注意：
- 元素的增加与删除应尽量从列表尾部进行。
- insert()可在任意位置插入元素，这会涉及到插入位置之后所有元素的移动，从而影响处理速度。remove()方法类似。
- pop()弹出列表非尾部元素，情况也如此。
- 除非有必要，否则应尽量避免在列表中间位置插入和删除元素的操作。
reverse()，sort() | sorted()，copy()
- L.reverse()
- 倒置列表L
>>> a=[1,2]
>>> a.reverse()
>>> a
[2, 1]
>>> a=[1,2,[3,4],5,6]
>>> a.reverse()
>>> a
[6, 5, [3, 4], 2, 1]- L.sort() | sorted(L)
- 对列表元素排序，不返回任何值
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> x.sort()
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]- sorted()，会返回一个排序列表，不改变原有序列
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> y=sorted(x)
>>> x
[8, 9, 0, 7, 4, 5, 1, 2, 3, 6]
>>> y
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]- 函数sort() 默认是升序排序，如何降序排序，需要用到函数reverse()
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> x.sort()
>>> x.reverse()
>>> x
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]- 函数sort() 排序的高级用法
方法sort（）可以接受两个参数sort（key,reverse）
- key参数
key接受的是 只有一个形参的函数，此函数的返回值表示此元素的权值，sort将按照权值大小进行升序排序
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> def size(a):
x=10-int(a)
return x
>>> x.sort(key=size)
>>> x
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]- reverse参数
reverse接受的是 bool类型的值 ，表示是否颠倒排列顺序，默认False
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> x.sort(reverse=True)
>>> x
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> x.sort(reverse=False)
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]- L.copy()
- 列表L的备份，返回与L内容相同的列表，但是不是同一个。
>>> x=[1,2]
>>> y=x.copy()
>>> print(id(x),id(y))
2065512929792 2065512802368
>>> print(x,y)
[1, 2] [1, 2]index()，count()
- L.index(value[,start[,stop]])
- 在列表中查找某个数据第一出现的位置（下标）。如果查找的数据在列表中不存在，则会发生错误。
start 参数：可选，表示开始查找的下标（可正可负），默认0
end 参数：（前置现有start 才能考虑是否选择输入end参数），默认为len(L)，查找的范围 [start，end-1]
>>> a=[1,2,3,2]
>>> a.index(2)
1
>>> a.index(2,2)
3- L.count(x)
- 计算列表L中x出现的次数
>>> a=[1,2]
>>> a.count(1)
1
>>> a.count(3)
07.4 列表常见应用
列表的复制
- copy函数
a=[1,2,3,4]
c=a.copy()
print(id(a),id(c))
c[2]=6
print(a)
# Result:
# 1947110573440 1947118862016
# [1, 2, 3, 4]- 切片
a=[1,2,3,4]
d=a[:]
print(id(a),id(d))
d[2]=7
print(a)
# Result：
# 2089897854336 2089906139328
# [1, 2, 3, 4]列表其他注意点
- 如何判断一个列表lst为空？
>>> lst = []
>>> len(lst)==0
True
>>> not lst == True # 先not，后==
True- 如何将列表lst切成相同长度n的序列？
[lst[i:i+n] for i in range(0, len(lst), n)]8. 元组
元组（tuple）
元组是不可修改的任何类型的数据序列。元组像列表一样可以表达任何类型、任意数量的数据的有序序列。
元组的字面量用圆括号()
例子：
(1, 3.2, 5, 7.0, 9)
('not', 'and', 'or')8.1 创建元组
用元组的字面量
>>> d = (100,20)
>>> d
(100, 20)
>>> b = 1,2,3,4 #算是元组的一种简写方式
>>> b
(1, 2, 3, 4)当创建单个元素的元组的时候，需要特别注意⭐
>>> b = (1) >>> b 1 >>> type(b) <class 'int'> # 上面的方式，只能获得int型的数据；需要用下面的方式，在元素最后再加上逗号 >>> b = (1,) >>> b (1,) >>> type(b) <class 'tuple'>
tuple()方法
把**其他序列类型 ** 转换成元组
>>> a=tuple([1,2,3])
>>> a
(1, 2, 3)8.2 元组不可修改（不可变的）
- 元组是不可修改的，即不能对元组中的元素进行增加，删除，修改或排序。
- 列表中的修改函数append()、insert()、remove()以及del语句都不能用于元组。
因为元组是不可修改的，而列表是可变的，所以在一些同样的运算上，元组要比列表来的更快
8.3 元组常用方法和函数
count()，index()
- T.count(x)
- 计算x元素出现的次数
>>> a
(1, 2, 3)
>>> a.count(1)
1
>>> a.count(0)
0- T.index(value[,start[,stop]])
- 在列表中查找某个数据第一出现的位置（下标）。如果查找的数据在列表中不存在，则会发生错误。
start 参数：可选，表示开始查找的下标（可正可负），默认 0
end 参数：（前置现有start 才能考虑是否选择输入end参数），默认为len(T)，查找的范围 [start，end-1]
>>> a
(1, 2, 3)
>>> a.index(1,0,2)
08.4 列表加元组表示二维表
students=[(123132123,"小王"),
(123124123,"放噶"),
(986912418,"骄傲")]
for row in students: #按行存取
print(row[0],row[1])
print()
for id,name in students: #按行拆包存取,需要确保 给的参数数量 对应 元组的元素数量
print(id,name)
print()
for index in range(len(students)): #按索引存取
print(students[index][0],students[index][1])9. 集合
集合（set）是一类容器，元素没有先后顺序（无序，区别于序列），并且元素的值不重复。
集合的字面量用花括号{}
{1,5,7}
{"apple","orange","pear","banana"}⭐ 集合的元素类型必须是不可变的，如数值类型、布尔类型、字符串、元组，而列表则不行
9.1 创建集合
- 直接给变量赋值一个集合字面量
fruit = {"apple","orange","pear","banana"}不能通过{} 直接赋值一个空的集合，因为这样的类型其实是字典
>>> students={} >>> type(students) <class 'dict'>
- 使用set()函数创建一个空集合
>>> s = set()
>>> type(s)
<class 'set'>
>>> s
set()- 使用set()函数将列表、元组、字符串转换成集合
>>> set("asd")
{'a', 's', 'd'}
>>> set(["22",22])
{'22', 22}
>>> set((1,2))
{1, 2}- 集合的值不重复
创建集合的时候，python会消除重复的值。
>>> fruit={"apple","orange","apple","pear","orange","banana"}
>>> fruit
{'apple', 'orange', 'pear', 'banana'}9.2 集合相关的函数与运算
len()，min()，max()，sum()，add()，remove()，in，not in
- **len(s)**见 “各项数据类型”
- min(s)和max(s) 见 “各项数据类型”
- **sum(s)**见 “各项数据类型”
- s.add(x)
将一个元素加入集合中，不返回。
>>> a = {1,2,3}
>>> a.add("asd")
>>> a
{1, 2, 3, 'asd'}- s.remove(x)
从集合中删除一个元素，不返回。如果这个元素在集合中不存在，则抛出KeyError异常。
>>> a = {1, 2, 3, 'asd'}
>>> a.remove("asd")
>>> a
{1, 2, 3}
>>> a.remove("asd")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'asd'- in | not in
判断元素是否在集合中，返回布尔型
>>> a={1,3}
>>> 2 in a
False
>>> 1 in a
Trueunion()【|】，intersection()【&】，difference()【-】，symmetric_difference()【^】
样例：s1 = {2,3,5,7,11}，s2 = {2,3,4,5,6,7}
- union()【运算符：|】 并集
s1.union(s2) 或 s1|s2返回：包含两个集合中所有元素的新集合
>>> s1.union(s2)
{2, 3, 4, 5, 6, 7, 11}
>>> s1 | s2
{2, 3, 4, 5, 6, 7, 11}- **intersection()【运算符：&】 ** 交集
s1.intersection(s2) 或 s1&s2返回：只包含两个集合中都有的元素的新集合
>>> s1.intersection(s2)
{2, 3, 5, 7}
>>> s1&s2
{2, 3, 5, 7}- difference()【运算符：-】 差集
s1.difference(s2) 或 s1-s2（使用的时候注意集合的前后位置）
返回：出现在 s1 但是不出现在 s2 的元素的新集合
>>> s1.difference(s2)
{11}
>>> s1 - s2
{11}- symmetric_difference()【运算符：^】 对称差
s1.symmetric_difference(s2) 或 s1^s2返回：除了共同元素之外的所有元素
>>> s1.symmetric_difference(s2)
{4, 6, 11}
>>> s1^s2
{4, 6, 11}集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现
9.3 访问集合元素
- 用循环实现遍历集合中的各个元素
>>> for i in {"1","2"}:
print(i)
1
29.4 子集、超集和相等的判断
相关定义：
- 子集和超集
如果集合 s2 中的元素，同样都在集合 s1 中，则称 s2 为 s1 的子集，s1 为 s2 的超集。
- 真子集和真超集
- s1 是 s2 的真子集：s1 是 s2 的子集，但是 s2 中至少有一个 s1 中不存在的元素
- s1 是 s2 的真超集：s1 是 s2 的超集，但是 s1 中至少有一个 s2 中不存在的元素
子集和超集的判断
issubset() | issuperset()
- s2.issubset(s1)：判断 s2 是否是 s1 的子集
- s1.issuperset(s2)：判断 s1 是否是 s2 的超集
>>> s1={1,2,3,4,5,6,7}
>>> s2={2,3,5,7}
>>> s2.issubset(s1)
True
>>> s1.isuperset(s2)
>>> s1.issuperset(s2)
True集合的关系运算
- == 和 !=
用于两个集合是否包含完全相同的元素。
>>> {1,2,3} == {1,2,3}
True
>>> {1,2,3} != {1,2,3}
False- <，<=，>，>=
>>> s1 = {1,2}
>>> s2 = {1,2}
>>> s3 = {1,2,3}
>>> s1 < s3 #s1 是 s2 的真子集
True
>>> s1 <= s2 #s1 是 s2 的子集
True
>>> s3 > s2 #s3 是 s2 的真超集
True
>>> s2 >= s1 #s2 是 s1 的真超集
True9.5 集合的应用
- 列表去重，并保持原有顺序
mailto=['cc','bbbb','afa','sss','bbbb','cc','shafa']
addr_to = list(set(mailto))
print(addr_to)
addr_to.sort(key=mailto.index)
print(addr_to)
#result:
#['sss', 'shafa', 'cc', 'bbbb', 'afa']
#['cc', 'bbbb', 'afa', 'sss', 'shafa']10. 字典
字典是一个用**"键"做索引来存储数据的集合。一个键和它所对应的数据形成字典中的一个条目**。
⭐键是不能重复的
10.1 创建字典
用花括号 {} 来表示，每个元素用冒号分隔键和数据。
- 直接给变量赋值一个字典
>>> students={3180101:'张三',3180102:'李四',3180105:'王五',3180110:'赵六'}
>>> students
{3180101: '张三', 3180102: '李四', 3180105: '王五', 3180110: '赵六'}
>>> score={1:1,1:3} #键不重复，重复了会自动去掉，留下最后出现的相同键的条目
>>> score
{1: 3}- 使用dict()函数或者**{}创建一个空字典**
>>> students={}
>>> type(students)
<class 'dict'>
>>> s = dict()
>>> s
{}- 使用dict()函数创建有值的字典
创建格式 | 注意事项 |
a = dict(x1=value1, x2=value2, x3=value3,…) | x1,x2,… 表示字典条目的键，必须是不可变的类型（数值,字符串,元组）；value表示键对应的值（可以是任意类型） |
#方式1 demo = [(‘two’,2), (‘one’,1), (‘three’,3)] #方式2 demo1 = [[‘two’,2], [‘one’,1], [‘three’,3]] #方式3 demo2 = ((‘two’,2), (‘one’,1), (‘three’,3)) #方式4 demo3 = ([‘two’,2], [‘one’,1], [‘three’,3]) print(dict(demo)) print(dict(demo1)) print(dict(demo2)) print(dict(demo3)) | 向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组， 其中第一个元素作为键，第二个元素作为值。 |
keys = [‘one’, ‘two’, ‘three’] #还可以是字符串或元组 values = [[1], [2], [3]] a = dict( zip(keys, values) ) print(a) | 通过应用 dict() 函数和 zip() 函数(见2.4)，可将前两个列表转换为对应的字典。 |
# 下面的方法需要用到变量，所以需要提前定义好
>>> a,b,c="abc"
>>> fac = dict(a=1,b=2,c=3)
>>> fac
{'a': 1, 'b': 2, 'c': 3}- 通过 fromkeys() 方法创建字典
dictname = dict.fromkeys(list，value=None)其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。
>>> knowledge = ['语文', '数学', '英语']
>>> scores = dict.fromkeys(knowledge, 60)
>>> print(scores)
{'语文': 60, '数学': 60, '英语': 60}⭐注意：
键必须是不可变的类型（数值,字符串,元组），像可变类型就不行（列表,字典）；
value表示键对应的值（可以是任意类型）
10.2 字典的基本运算
- 访问和修改条目
直接用 [] 运算符，用**<字典>[键]** 的形式，访问键所对应的数据。
>>> score={1:1,2:2,3:3}
>>> print(score[1])
1
# 如果不存在，则抛出异常
>>> print(score[4])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 4
#存在对应键，= 表示赋值
>>> score[1] = 5
>>> print(score[1])
5
#不存在对应键，= 表示增加一项条目
>>> score[4] = 4
>>> print(score)
{1: 5, 2: 2, 3: 3, 4: 4}- 删除条目
- del语句，删除指定的字典条目；如果指定键不存在，则会抛出KeyError异常
>>> score={1:1,2:2,3:3}
>>> del score[1]
>>> score
{2: 2, 3: 3}
#不存在指定的键，抛出异常
>>> del score[1]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 1- 遍历字典
- 使用循环语句实现
>>> score={1:1,2:2,3:3}
>>> for i in score: # 循环变量 为字典的 键
print(i,":",score[i],sep="")
1:1
2:2
3:3
>>> score={1:1,2:2,3:3}
>>> for key,value in score.items():
print(key,":",value,sep="")
1:1
2:2
3:3- 字典的大小
- len() 函数：
len(dict)获得字典的条目数量，详见 “各项数据类型”
- 检测 in，not in
- 用 in，not in 运算符检测一个键是否在字典中存在
>>> score={1:1,2:2,3:3}
>>> 1 in score
True
>>> 5 not in score
True- == 和 != 的字典比较
- 比较两个字典是否相同（键和值都相同）
>>> score={1:1,2:2,3:3}
>>> score1={1:1,2:2,3:3}
>>> print(score == score1)
True
>>> score1={1:1,2:2,3:4}
>>> print(score != score1)
True10.3 字典的方法或函数
keys()，values()，items()，clear()，get(key)，pop(key)
- dict.keys()
返回由全部的键组成的一个序列对象，需要通过list()，set()，tuple()方法进行展示。
>>> score={1:1,2:2,3:3}
>>> score.keys()
dict_keys([1, 2, 3])
>>> list(score.keys())
[1, 2, 3]
>>> tuple(score.keys())
(1, 2, 3)
>>> set(score.keys())
{1, 2, 3}- dict.values()
返回由全部的值组成的一个序列对象，需要通过list()，set()，tuple()方法进行展示。
>>> score={1:1,2:2,3:3}
>>> score.values()
dict_values([1, 2, 3])
>>> list(score.values())
[1, 2, 3]- dict.items()
返回一个序列对象（展示方法同上），其中的每一项是一个元组，每个元组由键和它对应的值组成。
>>> score={1:1,2:2,3:3}
>>> score.items()
dict_items([(1, 1), (2, 2), (3, 3)])
>>> list(score.items())
[(1, 1), (2, 2), (3, 3)]
>>> set(score.items())
{(1, 1), (3, 3), (2, 2)}- dict.clear()
删除所有条目。
>>> score={1:1,2:2,3:3}
>>> score.clear()
>>> score
{}- dict.get(key)
返回这个键所对应的值；没有找到对应的键，返回空 None
>>> score={1:1,2:2,3:3}
>>> score.get(2)
2
>>> print(score.get(4))
Nonedict.get(key,default_return)：
default_return ：当key在字典中不存在时，返回default_return
- dict.pop(key)
返回这个键所对应的值，同时删除这个条目；如果对应的键不存在，则抛出KeyError异常
>>> score={1:1,2:2,3:3}
>>> score.pop(1)
1
>>> score
{2: 2, 3: 3}
>>> score.pop(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 410.4 字典的应用
- 用字典代替分支语句
- 输入一个1到7的整数，输出对应的星期名的缩写
days={1:"Mon",2:"Tue",3:"Wed",4:"Thu",5:"Fri",6:"Sat",7:"Sun"}
num = int(input())
print(days[num])
5
Fri- 四则运算
result={"+":"x+y","-":"x-y","*":"x*y","/":'''x/y if y!=0 else "divided by zero" '''}
x = int(input())
z = input().strip()
y = int(input())
r = eval（result.get(z))
if type(r)!=str:
print(f"{r:.2f}")
else:
print(r)input | output |
4 - 3 | 1.00 |
4 / 0 | divided by zero |
- 用字典计数
- 输入一行字符，求字符’a’，‘b’，'c’出现的次数
diccount={char:0 for char in "abc"} #字典初始化
s=input()
lst=[char for char in s if 'a'<=char<='c']
for char in lst:
diccount[char]+=1
print(diccount)
#input: oahfgoasd
#output: {'a': 2, 'b': 0, 'c': 0}- 输入一行字符，求每个字符出现的次数
str=input()
countchar={}
for c in str:
countchar[c]=countchar.get(c,0)+1
print(countchar)
#input: qowifhbclahdfpqiw123102./'.'.
#output:
'''
{'q': 2, 'o': 1, 'w': 2, 'i': 2, 'f': 2, 'h': 2, 'b': 1, 'c': 1, 'l': 1, 'a': 1, 'd': 1, 'p': 1, '1': 2, '2': 2, '3': 1, '0': 1, '.': 3, '/': 1, "'": 2}
'''10.5 字典的注意点
- 字典直接打印出来的顺序与创建之初的顺序可能不同
但是Thonny在测试这个案例，很难出现这种情况。
字典打印出来的顺序与创建之初的顺序不同，因为字典是集合类型的延续，各个元素并没有顺序之分。
11. 推导式（解析式）
11.1 什么是推导式？
推导式也是解析式，是python的独有特性，推导式可以从一个组合数据类型中（map() range() list tuple str set dict）推导出一个新的数据序列。
三种推导：列表推导式，字典推导式，集合推导式
11.2 列表推导式
- 列表推导式（又称列表解析式）提供了一种简明扼要的方法来创建列表。
- 它可以将循环和条件判断结合，从而避免语法冗长的代码，同时提高程序性能
基本格式：
[expression for item in iterable]
例子：
>>> n1 = [2*number for number in [1,2,3,4,5]]
>>> n1
[2, 4, 6, 8, 10] => [2*1,2*2,2*3,2*4,2*5]例子：求1+1/2+…+1/20之和
>>> a=sum([1/i for i in range(1,21)])
>>> print(a)
3.597739657143682例子：求1-1/2+1/3-1/4+…之前n项和（n>=10）
n=int(input())
#1/i 为列表值，当i%2==1（为奇数）时取前面的表达式，else 取-1/i为列表值
a=sum([1/i if i%2==1 else -1/i for i in range(1,n+1)])
print(a)
10
0.6456349206349207例子：求6+66+666+…+666…666
n=int(input())
print(sum([int('6'*i) for i in range(1,n+1)]))
3
738测试例题：华氏-摄氏温度转换表
输入2个正整数lower和upper（lower<upper<100），输出一张取值范围为[lower，upper]、且每次增加2华氏度的华氏-摄氏温度转换表，结果小数部分保留一位。温度转换的计算方式：
C = 5 × ( F - 32 ) / 9 （其中：C表示摄氏温度，F表示华氏温度）
lower,upper = [int(i) for i in input("请输入lower和upper，用空格分割：").split()]
for i in range(lower,upper+1,2):
print(i,"{:.1f}".format(5*(i-32)/9))
请输入lower和upper，用空格分割：10 20
10 -12.2
12 -11.1
14 -10.0
16 -8.9
18 -7.8
20 -6.7带条件的列表推导式
[expression for item in iterable if condition]此处if主要起条件判断作用，data数据中只有满足if条件的才会被留下，最终生成一个数据列表。
>>> n1 = [number for number in range(1,8) if number%2==1]
>>> n1
[1, 3, 5, 7][exp1 if condition else exp2 for x in data]此处if…else主要起赋值作用。当data中的数据满足if条件时，将其做exp1处理，否则按照exp2处理，最终生成一个数据列表。
result = ["偶" if i % 2 == 0 else "奇" for i in range(1, 10+1) ]
print(result)
# 输出结果：['奇', '偶', '奇', '偶', '奇', '偶', '奇', '偶', '奇', '偶']嵌套的列表推导式
举例：
请注意下面语句 i 是外层循环，j是内层循环（可以坐标看出，j先变化，i后变化）
>>> [(i,j) for i in range(3) for j in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]等价于
>>> combs = []
>>> for i in range(3):
for j in range(3):
combs.append((i, j))
>>> combs
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]请注意上面语句 i 是内层循环，j是外层循环
>>> [[i+j for i in range(3)] for j in range(3)]
[[0, 1, 2], [1, 2, 3], [2, 3, 4]]应用：
矩阵的转置：
>>> matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
]
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]11.3 集合推导式
具体格式与列表推导式相似
>>> {x for x in "asd"}
{'a', 'd', 's'}
>>> {x for x in ["a",1]}
{'a', 1}
>>> {x for x in ("a",1)}
{'a', 1}
#加if condition
>>> {x for x in (1,2) if x==1 }
{1}
#加 if-else
>>> {x if x==1 else -x for x in (1,2)}
{1, -2}11.4 字典推导式
具体格式与列表推导式相似
# 只获取键
>>> a = {x:0 for x in "asd"}
>>> a
{'a': 0, 's': 0, 'd': 0}
# 多变量，获取键和值
>>> l = [[1,2],[3,4]]
>>> a = {x:y for x,y in l}
>>> a
{1: 2, 3: 4}
# [key:value for item in iterable if condition]
>>> a = {x:0 for x in "asd" if x!='a'}
>>> a
{'s': 0, 'd': 0}
# [key:value1 if condition else value2 for key in data]
>>> a = {x:0 if x!='a' else 1 for x in "asd" }
>>> a
{'a': 1, 's': 0, 'd': 0}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
