各类数据类型汇总：
1. 数字类型
⭐ 数字类型是不可变的
1.2 整数 int
-
与数学中整数概念一致：其**取值范围在理论上是没有限制的** （可能会受到计算机内存大小的影响）
-
整数可正可负：增加正负号表示整数，一般正数可以忽略正号
-
默认情况下，采用十进制。其他进制需要增加相应的引导符号
进制 前导符 示例 十进制 二进制： 0b 或 0B 0b10 2 八进制： 0o 或 0O 0o10 8 十六进制： 0x 或 0X 0x10 10
1.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.9
round函数能够用来解决浮点数运算存在不确定尾数，有误差的情况
>>> 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.1415
1.4 复数 complex
-
与数学中的复数概念一致
-
由实部和虚部组成，虚部由 j 表示。
-
例如：
2+3j：2为实部，3j为虚部 -
与复数相关的函数
- real属性
- imag属性
- complex函数
>>> a = complex(1,2) >>> a (1+2j) >>> a.real 1.0 >>> a.imag 2.0
1.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 #从左向右
True
3. 空值
空值是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')
True
not in：
>>> a=[1]
>>> print(1 not in a)
False
len(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\nasd
6.1.3 格式化字符串f"…"
格式化的字符串文字前缀为 ‘f’ 和接受的格式字符串相似str.format()。它们包含由花括号包围的替换区域。替换字段是表达式，在运行时进行评估，然后使用format()协议进行格式化。
简而言之，就是对format函数格式化字符串的简写。
举例：
ws = 1
print(f'max row:{ws:.2f}')
#result:
#max row:1.00
6.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，即“所有出现次数”。
- separator：可选。规定分割字符串时要使用的分隔符。默认的分割符号为空白符号（空格
-
作用：
- 将字符串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)) 0
ljust()，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.380
6.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 2054142488000
clear()，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) 0
7.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) 0 -
8.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 True
union()【|】，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 2
9.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 的真超集 True
9.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)获得字典的条目数量，详见 “各项数据类型”
- len() 函数：
-
检测 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) True
10.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: 4
10.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
-
31.00 4
/
0divided 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}
扫一扫
882
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
