Python3 的六个标准数据类型中：
- 不可变数据：Number（数字）、String（字符串）、Tuple（元组）
- 可变数据：List（列表）、Dictionary（字典）、Set（集合）
目录
类型查询
内置的 type() 函数可以用来查询变量所指的对象类型，与可以用 isinstance 来判断。
两者区别在于：
- type()不会认为子类是一种父类类型。
- isinstance()会认为子类是一种父类类型。
示例：
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> isinstance(A(), A)
True
>>> type(A()) == A
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False
Number（数字）
Python3 支持 int、float、bool、complex（复数），并且，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。bool是int的子类，True 和 False 可以和数字相加。在布尔类型中，数值中的零包括0、0.0、虚数0；空序列包括字符串、空元组、空列表、空字典。
数字类型转换
- int(x) 将x转换为一个整数。
- float(x) 将x转换到一个浮点数。
- complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
- complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
数字运算
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ；但 // 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。如：
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0相关函数
数学函数
| 函数 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。 |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1,x2,...) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1,x2,...) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| pow(x,y) | x**y 运算后的值。 |
| round(x,[,n]) | 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。 其实准确的说是保留值将保留到离上一位更近的一端。 |
| sqrt(x) | 返回数字x的平方根。 |
随机数函数
| 函数 | 描述 |
|---|---|
| choice(seq) | 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 |
| randrange([start,] stop [,step]) | 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1 |
| random() | 随机生成下一个实数，它在[0,1)范围内。 |
| seed([x]) | 改变随机数生成器的种子seed。由Python设定。 |
| shuffle(lst) | 将序列的所有元素随机排序 |
| uniform(x,y) | 随机生成下一个实数，它在[x,y]范围内。 |
三角函数
| 函数 | 描述 |
|---|---|
| acos(x) | 返回x的反余弦弧度值。 |
| asin(x) | 返回x的反正弦弧度值。 |
| atan(x) | 返回x的反正切弧度值。 |
| atan2(y,x) | 返回给定的 X 及 Y 坐标值的反正切值。 |
| cos(x) | 返回x的弧度的余弦值。 |
| hypot(x,y) | 返回欧几里德范数 sqrt(x*x + y*y)。 |
| sin(x) | 返回的x弧度的正弦值。 |
| tan(x) | 返回x弧度的正切值。 |
| degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 |
| radians(x) | 将角度转换为弧度 |
数学常量
| 常量 | 描述 |
|---|---|
| pi | 圆周率，一般以π来表示 |
| e | 自然常数 |
序列简介
- python中有5各常用序列结构：字符串、元组、列表、集合、字典。
- 序列是一块用于存放多个值的连续内存空间，并且按一定顺序排列，每一个值（称为元素）都分配一个数字，称为索引或位置。通过该索引可以取出相应的值。
- Python比较神奇，它的索引可以是负数。这个索引从右向左计数，也就是从最后一个元素开始计数，即最后一个元素的索引值是-1，倒数第二个元素的索引值为-2，依此类推。如图所示。
切片
切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素。通过切作可以生成一个新的序列。实现切片操作的语法格式如下：
sname[start : end : step]
【参数说明】
sname：表示序列的名称。
start：表示切片的开始位置（包括该位置），如果不指定，则默认为0。
end：表示切片的截止位置（不包括该位置），如果不指定则默认为序列的长度。
step：表示切片的步长，如果省略，则默认为1，当省略该步长时，最后一个也可以省略。
【注意】
在进行切片操作时，如果指定了步长，那么将按照该步长遍历序列的元素，否则将一个一个遍历序列。
print(nba[1:5]) # 获取第2个到第5个元素
print(nba[0:5:2]) # 获取第1个、第3个和第5个元素【说明】
如果想要复制整个序列，可以将start和end参数都省略，但是中间的冒号需要保留。例如，nba[:]就表示复制整个名称为nba的序列。
String（字符串）
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。可以使用 '...'、 "..."、 '''...''' 来将字符括起来，但必须成对使用。其中单、双引号中的字符序列必须在一行上编写，而三引号字符序列可以在连续多行上编写。在Python3中，所有的字符串都是Unicode字符串。
var1 = 'Hello World!'
var2 = "Runoob"
var3 = '''Our destiny offers not the cup of despair,
but the chance of opportunity.'''转移字符
在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符，例如： print("line1 \ ... line2 \ ... line3") |
| \\ | 反斜杠符号，例如：print("\\") |
| \' | 单引号，例如：print('\'') |
| \" | 双引号，例如：print("\"") |
| \a | 响铃（执行后电脑有响声），例如：print("\a") |
| \b | 退格(Backspace)， 例如：print("Hello \b World!") 输出：Hello World! |
| \000 | 空，例如：print("\000") |
| \n | 换行，例如：print("\n") |
| \v | 纵向制表符， 例如：print("Hello \v World!") 输出： Hello World! |
| \t | 横向制表符， 例如：print("Hello \t World!") 输出：Hello World! |
| \r | 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 例如：print("Hello\rWorld!") 输出：World! |
| \f | 换页， 例如：print("Hello \v World!") 输出： Hello World! |
| \yyy | 八进制数，y 代表 0~7 的字符，例如：print("\110\41") |
| \xyy | 十六进制数，以 \x 开头，y 代表的字符，例如：print("\x48\x21") |
使用 \r 实现百分比进度：
import time
for i in range(101):
print("\r{:3}%".format(i),end=' ')
time.sleep(0.05)字符串运算符
设a="Hello" ：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： ab |
| * | 重复输出字符串 | a*2 输出结果：aa |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果：a 字符串的第二个字符 |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果：a 字符串的第二到四个字符 |
| [ : : ] | 截取字符串中的一部分，[start : end : step] 分别是截取的第一个字符索引、截取的最后一个字符索引（不包含该字符）、表示切片步长（省略则默认是1，冒号也可省略） | a[ :5]输出结果：从左边开始截取5个字符。 |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | 'H' in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | 'M' not in a 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print( r'\n' ) print( R'\n' ) |
字符串格式化
语法格式：%[-][+][0][m][.n]exp
-：可选参数，指定左对齐，正数前方无符号，负数前方加负号；
+：可选参数，指定右对齐，正数前方加正号，负数前方加负号；
0：可选参数，表示右对齐，正数前方无符号，负数前方加负号，用0填充空白处；
m：表示占有宽度；
.n：表表示小数点后保留n位。
| 操作符 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |
| %p | 用十六进制数格式化变量的地址 |
- 推荐使用format()来格式化：
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它可以接受不限个参数，位置可以不按顺序。基本语法是通过 {} 和 : 来代替以前的 % 。
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'示例：
| 数字输入 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:-.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
| 13 | {:>10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
字符串内建函数
| 方法 | 描述 |
|---|---|
| str.split(sep,maxsplit) | str是进行分隔的字符串； sep 用于指定分隔符，可包含多个字符，默认为None，即所有空字符（空格、换行\n、制表符\t）； maxsplit 是可选参数，用于指定分隔次数，不指定或者为-1，则分割次数没有限制，否则返回结果列表元素个数最多为maxsplit + 1。 |
| join(seq) | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。 |
| strip([chars]) | 在字符串上执行 lstrip()和 rstrip()，用于去除字符串左、右两侧的空格和特殊字符。chars为可选参数，用于指定要去除的字符。 |
| replace(old, new, [, max]) | 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 |
| str.count(sub[, start[, end]]) | 检索指定字符串在另一个字符串中出现的次数。 str表示原字符串，sub是要检索的字符串； start是可选参数，表示检索范围起始索引 ，不指定则从头检索； end是可选参数，表示检索范围结束索引 ，不指定则检索到结尾； |
| str.find(sub[, start[, end]]) | 检查子字符串是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1。rfind()是从右边开始查找。 |
| str.index(sub[, start[, end]]) | 与find()类似，用于检索是否包含指定子字符串，不同的是，str不在字符串中会抛出异常。rindex()是从右边开始查找。 |
| startswith(substr, beg=0,end=len(string)) | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True，否则返回 False。 |
| lower() | 转换字符串中所有大写字符为小写。 |
| upper() | 转换字符串中的小写字母为大写。 |
| swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
| title() | 返回"标题化"的字符串，所有单词都是以大写开始，其余字母均为小写。 |
| capitalize() | 将字符串的第一个字符转换为大写 |
| isalnum() | 检查字符串是否由字母和数字组成，即字符串中的所有字符都是字母或数字。如果字符串至少有一个字符，并且所有字符都是字母或数字，则返回 True；否则返回 False。 |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| isdigit() | 如果字符串只包含数字则返回 True 否则返回 False.. |
| islower() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False. |
| istitle() | 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False。 |
| isdecimal() | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
| len(str) | 返回字符串长度 |
| max(str) | 返回字符串 str 中最大的字母。 |
| min(str) | 返回字符串 str 中最小的字母。 |
| center(width, fillchar) | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| zfill(width) | 返回长度为 width 的字符串，原字符串右对齐，前面填充0。 |
| ljust(width, [, fillchar]) | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| rjust(width, [, fillchar]) | 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串。 |
| maketrans() | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
Tuple（元组）
Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号 ( )，列表使用方括号 [ ]。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
tup0 = () #创建空元组
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d" #不需要括号也可以注意：元组中只包含一个元素时，需要在元素后面添加逗号“, ”，否则括号会被当作运算符使用。
访问元组
#使用下标访问元组
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0]) #读取第1个元素
print ("tup2[1:5]: ", tup2[1:5]) #读取从第2个元素开始到第5个（索引为4）的元素
print ("tup[-2]：", tup[-2]) #反向读取，读取倒数第二个元素输出结果：
tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)
tup[-2]： 6修改元组
#元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)输出结果：
(12, 34.56, 'abc', 'xyz')删除元组
#元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)输出结果：
删除后的元组 tup :
Traceback (most recent call last):
File "test.py", line 8, in <module>
print (tup)
NameError: name 'tup' is not defined
元组运算符
元组之间可以使用 +、+=和 * 号进行运算。
元组的内置函数
| 方法 | 描述 |
|---|---|
| len(tuple) | 计算元组元素个数 例如：tuple1 = ('Google', 'Runoob', 'Taobao') len(tuple1) 输出：3 |
| max(tuple) | 返回元组中元素最大值 例如：tuple2 = ('5', '4', '8') max(tuple2) 输出：'8' |
| min(tuple) | 返回元组中元素最小值 例如：tuple2 = ('5', '4', '8') min(tuple2) 输出：'4' |
| tuple(iterable) | 将可迭代系列转换为元组 例如：list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] tuple1=tuple(list1) 输出：tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu') |
元组是不可变的
指的是元组所指向的内存中的内容不可变。
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g' # 不支持修改元素
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup) # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800 # 内存地址不一样了List（列表）
列表可以进行的操作包括索引，切片，加，乘，检查成员；它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型，因为它们之间没有关系。创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。示例：
list = ['Google', 'Runoob', 1997, 2000]访问列表
与元组一样，可从默认顺序下标0开始，也可以从尾部开始。
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[1] ) #输出：green
print( list[-1] ) #输出：black
print( list[0:4] ) #输出：['red', 'green', 'blue', 'yellow']使用负数索引值截取：
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])
## 输出结果：
## list[1]: Runoob
## list[1:-2]: ['Runoob', 'Zhihu']更新列表
使用 append() 方法在列表末尾添加列表项：
语法：list.append(obj)
# obj -- 要添加到列表末尾的对象
list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
## 输出结果：
## 第三个元素为 : 1997
## 更新后的第三个元素为 : 2001
## 更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']想要将一个列表所有元素全部添加到另一个列表后面中可以使用列表对象的extend()方法实现。
语法：list.extend(seq)
# seq -- 要添加的列表
修改元素时，直接通过索引获取该元素，再为其重新赋值即可：
verse["德国队","西班牙队","巴西队"]
verse[2] = "日本队"
print(verse)
## 输出结果：
## ["德国队","西班牙队","日本队"]删除列表元素
使用 del 语句来删除列表中的元素：
list = ['Google', 'Runoob', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
## 输出结果：
## 原始列表 : ['Google', 'Runoob', 1997, 2000]
## 删除第三个元素 : ['Google', 'Runoob', 2000]列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
| 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
嵌套列表
使用嵌套列表即在列表里创建其它列表：
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'列表比较
列表比较需要引入 operator 模块的 eq 方法：
# 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
## 输出结果：
## operator.eq(a,b): False
## operator.eq(c,b): True列表函数和方法
| 函数 | 描述 |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元组转换为列表 |
| 方法 | 描述 |
| list.append(obj) | 在列表末尾添加新的对象 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| list.instert(index, obj) | 将对象插入列表 |
| list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| list.reverse() | 反向列表中元素 |
| list.sort(key = None, reverse = False) | 对原列表进行排序 |
| list.clear() | 清空列表 |
| list.copy() | 复制列表 |
Dictionary（字典）
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中：
d = {key1 : value1, key2 : value2, key3 : value3 }注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键必须是不可变、唯一的，但值可以取任何数据类型，如字符串，数字：
tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}创建字典
使用大括号 { } 创建空字典，也可以使用内建函数 dict() 创建字典：
# 创建空字典两种方式
emptyDict1 = {}
emptyDict2 = dict()访问字典
如果用字典里没有的键访问数据，会输出错误。
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
## 会报错：
## print ("tinydict['Alice']: ", tinydict['Alice'])修改字典
向字典添加新内容的方法是增加新的键/值对：
tinydict = {'Name': 'GZHU', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "庆" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
## 输出结果：
## tinydict['Age']: 8
## tinydict['School']: 庆删除字典元素
显式删除一个字典用del命令。能删单一的元素也能清空字典，清空只需一项操作。
tinydict = {'Name': 'GZHU', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典字典键的属性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，记住后一个值：
tinydict = {'Name': 'GZHU', 'Age': 7, 'Name': '庆'}
print ("tinydict['Name']: ", tinydict['Name']) # 输出结果：tinydict['Name']: 庆
2）键必须不可变，所以可以用数字、字符串或元组充当，但用列表不行：
tinydict = {['Name']: 'GZHU', 'Age': 7}
## print ("tinydict['Name']: ", tinydict['Name'])
## 报错：
## Traceback (most recent call last):
## File "test.py", line 3, in <module>
## tinydict = {['Name']: 'GZHU', 'Age': 7}
## TypeError: unhashable type: 'list'字典内置函数和方法
设 tinydict = {'Name': 'GZHU', 'Age': 7, 'Class': 'First'}；
| 函数 | 描述 |
|---|---|
| len(dict) | 计算字典元素个数，即键的总数。 例如：len(tinydict) 输出：3 |
| str(dict) | 输出字典，可以打印的字符串表示。 例如：str(tinydict) 输出："{'Name': 'GZHU', 'Class': 'First', 'Age': 7}" |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 例如：type(tinydict) 输出：<class 'dict'> |
| 方法 | 描述 |
| dict.clear() | 删除字典内所有元素 |
| dict.copy() | 返回一个字典的浅复制 |
| dict,fromkeys() | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| dict.get(key, defualt=None) | 返回指定键的值，如果键不在字典中返回 default 设置的默认值 |
| key in dict | 如果键在字典dict里返回true，否则返回false |
| dict.items() | 以列表返回一个视图对象 |
| dict.keys() | 返回一个视图对象 |
| dict.setdefualt(key, defualt=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| dict.uodate(dict2) | 把字典dict2的键/值对更新到dict里 |
| dict.values() | 返回一个视图对象 |
| pop(key[, defualt]) | 删除字典 key（键）所对应的值，返回被删除的值 |
| popitems() | 返回并删除字典中的最后一对键和值 |
Set（集合）
集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 创建集合，元素之间用逗号“ , ”分隔， 也可以使用 set() 函数创建集合。
parame = {value01,value02,...}
set(value)
set1 = {1, 2, 3, 4} # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合的基本操作
集合的交集、并集和差集运算
# 在命令行展示两个集合间的运算
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}添加元素
语法：s.add( x )
# 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作
thisset = set(("Google", "Taobao"))
thisset.add("Facebook")
print(thisset)
# 输出：{'Taobao', 'Facebook', 'Google'}另一个方法也可以添加元素，且参数可以是列表，元组，字典等：
语法：s.update( x )
# x 可以有多个，用逗号分开
thisset = set(("Google", "Taobao"))
thisset.update({1,3})
print(thisset)
# 输出：{1, 3, 'Google', 'Taobao'}
thisset.update([1,4],[5,6])
print(thisset)
# 输出：{1, 3, 4, 5, 6, 'Google', 'Taobao'}
移除元素
语法：
s.remove( x ) # 元素不存在会报错
s.discard( x ) # 元素不存在不会报错
s.pop() # 随机删除集合中的一个元素
# 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
thisset = set(("Google", "Taobao"))
thisset.remove("Taobao")
print(thisset)
# 输出：{'Google'}
# 不存在会发生错误
# thisset.remove("Facebook")
# 另一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误
thisset.discard("Facebook") # 不存在不会发生错误
print(thisset)
# 输出：{'Google'}
x = thisset.pop()
print(x)
# 输出：Google计算元素个数
语法：len(s)
清空元素
语法：s.clear()
判断元素是否在集合中存在
语法：x in s # 存在返回 True，不存在返回 False
集合其他内置方法
| 方法 | 描述 |
|---|---|
| copy() | 拷贝一个集合 |
| union() | 返回两个集合的并集 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
