【Python】数据类型 Number数字、String字符串、List列表、Tuple元组、Set集合、Dictionary字典

Python数据类型

2021/6/3 周四
学习内容: Python数据类型、Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

刚接触Python，主要是看菜鸟教程、w3school 网站，以及电子工业出版社出版的Python编程入门指南上册的教材，并根据自己的情况对重点内容做的笔记。

如有错误，欢迎在评论区指出，非常感谢！

一、数据类型

1. 标准数据类型

Python3中有六个标准数据类型：
Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

其中不可变数据（3个）：Number、String、Tuple；
可变数据（3个）：List、Dictionary、Set；

2. 构造函数

Python中的变量不需要声明类型，在为变量赋值时，就自动设置了数据类型。

x = 525
print(x+"123")

x默认是int，这样写是会报错的。

如果希望指定数据类型，可以使用以下构造函数：

x = str(525)
print(x+"123")

这样就不会报错了

3. 获取数据类型

可以使用 type() 函数获取任何对象的数据类型

x = 525
print(type(x))>>> 输出
>>> <class 'int'>

另外，还可以用 isinstance() 带上数据类型来判断是否是这个类型的，返回True或False：

x = 525
print(isinstance(x,str))>>> 输出
>>> False

区别在于，在判断对象的类型时，type() 不会认为子类是一种父类类型，而isinstance() 会认为子类是一种父类类型。

二、Number（数字）

数字类型包括int、float、complex三种数值和bool布尔值

1. 数值

int整数，是完整的数字，正数或负数，没有小数，长度不限。
float浮点数，是包含小数的正数或负数，也可以是带有“e”的科学数字，表示 10的幂。比如"15E2"、“-49.8e100”。
complex复数，与数学中的复数一样，都是由实部和虚部组成，用 “j” 作为虚部编写。比如"2+3j"、“-3j”。

类型转换
可以使用 int()、float() 和 complex() 构造函数，将数字从一种类型转换为另一种类型（但是复数无法转换为其他数字类型）。
比如：
int(6.3) 就是 向下取整，结果为6，
float(5) 是后面加个.0，结果为5.0，
complex(3.5) 就是加个+0j，结果为(3.5+0j)。

符合格式的字符串也可以与数值类型互相转换，比如：
int(“2”) 结果为整数2
float(“4.6”) 结果为浮点数4.6
complex(“2+3j”) 结果为复数(2+3j)
str(4.0) 结果为字符串"4.0"

2. 布尔值

Python布尔类型 bool 主要用来表示真或假的值。

比如比较两个值时，将对表达式求值，返回布尔值答案True或 False：
如 8>7 为True， 8<7 和 8==7 都为False。

布尔值可以转换为数值，True表示1， False表示0。

bool() 函数可评估任何值，只有一个参数，并根据这个参数的值返回 True或 False。

对数字使用 bool() 函数时，0返回False，任何其他值都返回True。
对字符串使用 bool() 函数时，对于没有值的字符串（None或""空字符串）返回False，否则返回True。
bool() 函数对于空的列表、字典和元组返回False，否则返回True。

总的来说，其实大多数值都是True的，被评估为False很少，比如：

bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

（0是指数值中的0，包括0、0.0和虚数0）

3. 随机数

Python没有 random() 函数来创建随机数，但有一个名为random的内置模块，可用于生成随机数：

导入 random 模块，并显示1到9之间的随机数：

import random
print(random.randrange(1,10))

randrange 左闭右开，不能取到10
另外还有一个 randint 左右都是闭区间，两边极限都可以取到

三、String（字符串）

1. 写法

python中的字符串字面量由单引号或双引号括起。

多行字符串：
也可以使用三个引号（单引号双引号都可以）将多行字符串赋值给变量：

a = """When your dreams come alive you're unstoppable
take a shot chase the sun, find the beautiful"""
b = '''We will glow in the dark turning dust to gold
And we'll dream it possible'''

在结果中，换行符插入与代码中相同的位置。

字符串拼接和复制：
使用 + 加号可以拼接字符串，使用 * 星号并带上需要复制的次数可以复制字符串：

print("Hello"+" World!")
print("Boom" * 5)>>> 输出：
>>> Hello World!
>>> BoomBoomBoomBoomBoom

转义特殊字符：
还可以使用反斜杠 \ 来转义特殊字符，比如 \n 表示换行：

print("使用\n换行")>>> 输出:
>>> 使用
>>> 换行

同时，如果必须用到转义格式，但又不希望被转义的话，可以在引号前加上字母r或R：

print(r"使用\n换行")>>> 输出:
>>> 使用\n换行

2. 访问字符串元素

Python中的字符串是表示unicode字符的字节数组。
但是，Python没有类似char的字符数据类型，单个字符就是长度为1的字符串。

可以用 [ ] 方括号来访问字符串的元素:

a = "Hello, World!"
print(a[1])

需注意，从前往后第一个字符的下标为 0，从后往前数第一个字符的下标为-1。

3. 字符串截取

指定开始索引和结束索引，以冒号分隔，可以截取字符串的一部分。
获取从下标2到下标 5（不包括）的字符:

a = "Hello, World!"
print(a[2:5])

如果使用负的索引，则是从字符串末尾开始切片：

a = "Hello, World!"
print(a[-5:-2])

结果是orl，也就是从下标 -5 到下标 -2（不包括）的字符。

也可以省略一个参数，表示从头开始截到指定位置，或者从指定位置截到底：

a = "Hello, World!"
print(a[:5])
print(a[7:])
print(a[:-1])
print(a[-6:])>>> 输出：
>>> Hello
>>> World!
>>> Hello, World
>>> World!

4. in / not in

如需检查字符串中是否存在特定短语或字符，可以使用 in 或 not in 关键字，返回True或False。

例如，检查以下文本中是否存在短语 “ina”：

txt = "China is a great country"
x = "ina" in txt
print(x)

结果是True。

5. 字符串常用方法

len() 返回字符串的长度
strip() 删除开头和结尾的空白字符
lower() 返回小写的字符串
upper() 返回大写的字符串
replace() 用另一段字符串来替换字符串：

a = "Hello, World!"
print(a.replace("World", "Kitty"))>>> 输出：
>>> Hello, Kitty!

split() 在找到分隔符的实例时将字符串拆分为子字符串：

a = "Hello, World!"
print(a.split(",")) >>> 输出：
>>> ['Hello', ' World!']

6. format()和占位符{}

如果用"+"号组合字符串和数字的话会报错，但format()方法，就可以组合字符串和数字。

它接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：

age = 25
txt = "My name is Bill, and I am {}"
print(txt.format(age))

可以使用多个占位符来接受多个参数：

quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))

然后参数的位置也可以不按顺序，这就需要在占位符中标明索引表示填入第几个参数，索引从0开始算

quantity = 3
itemno = 567
price = 49.95
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))

四、List（列表）

1. 写法

List（列表）是 Python中使用最频繁的数据类型，写在方括号 [ ] 之间，并用逗号分隔开多个元素。

Python 没有内置对数组的支持，但可以使用 List 列表代替。

列表可以存放数字、字符串、列表（所谓嵌套）、元组等类型的内容，而且同一个列表中元素的类型都可以不相同。

list = ['abcd', 321, 321, 5.25, 1+1j]

列表允许重复值。

列表是有序的，索引值从前往后第一个元素的索引为 0，从后往前第一个元素的索引为-1。

2. 截取

和字符串一样，列表也可以访问元素和截取，列表被截取后返回一个包含所需元素的新列表。

list = ["number",1,2,3,4,5]
print(list[0])
print(list[2:5])>>> 输出：
>>> number
>>> [2, 3, 4]

从上还可看出，输出列表单个元素时，如果是字符串，会自动去掉引号。

另外，列表的截取还可以接收第三个参数，参数作用是截取的步长(表示间隔几个数)：

list = [1,2,3,4,5,6,7,8,9,10]
print(list[0:9:2])>>> 输出：
>>> [1, 3, 5, 7, 9]

如果第三个参数为负数，表示逆向读取，可以用于翻转字符串语句：

list = ["he", "is", "Tony"]
print(list[-1::-1])>>> 输出：
>>> ['Tony', 'is', 'he']

3. 合并列表和重复输出

也同样可以用 + 加号合并多个列表组成新的包含所有元素的列表，
以及用 * 星号重复输出列表：

list1 = ['abcd', 123, 321]
list2 = [123, 456, 789]
list3 = ["ha"]
print(list1 + list2 + list3 * 3)>>> 输出：
>>> ['abcd', 123, 321, 123, 456, 789, 'ha', 'ha', 'ha']

4. 更改元素值

与字符串不一样的是，列表中的元素是可以改变的。

可以通过访问和截取来修改列表中的元素：

list = ["number",1,2,3,4,5]
list[0] = 0
print(list)
>>> [0, 1, 2, 3, 4, 5]list[1:5] = [-1,-2,-3,-4]
print(list)
>>> [0, -1, -2, -3, -4, 5]

如果修改的元素个数多于截取的位数，替换掉截取的部分后，剩下的部分依然会插入到列表：

list = [0,1,2,3,4,5]
list[1:3] = [-1,-2,-3,-4,-5]
print(list)
>>> 输出：
>>> [0, -1, -2, -3, -4, -5, 3, 4, 5]

5. 列表排序

当列表中的元素都是实数（int或float）或都是字符串时，可以用 sort() 方法对列表进行排序：

list1=[32,4,7,1,10,5.5]
list2.sort()
print(list1)
>>> [1, 4, 5.5, 7, 10, 32]list2=["a","bc","D"]
list2.sort()
print(list2)
>>> ['D', 'a', 'bc']list2.sort(key=str.lower)
print(list2)
>>> ['a', 'bc', 'D']

在Python中的字符串排序，默认都是先大写，再小写。

如果不想区分大小写，可以给sort方法加一个key参数，设置key=str.lower。

6. 列表常用方法

len() 返回列表的长度
in / not in 关键字，检验列表中是否存在指定的元素
copy() 复制列表（使用list2=list1这种写法不能复制列表，只是list2对 list1的引用，如果list1中有所更改，list2也会改变。）
append() 向列表的末尾添加元素
insert() 在指定的索引处添加元素
remove() 参数是列表里的元素，删除匹配的第一个元素
pop() 参数是索引，删除指定索引的元素（如果未指定索引，则删除最后一项）
del 关键字也可以删除指定索引的元素（如果未指定索引，则删除整个列表）
clear() 清空列表

以下是对这些方法的使用，用>>>代表输出：

list = [1,2,3,4,5,6,7,8,9,"number"]
print(len(list))
>>> 10print(5 in list)
print(10 in list)
>>> True
>>> Falsemylist = list.copy()
print(mylist)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 'number']list.append(10)
print(list)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 'number', 10]list.insert(0,"number")
print(list)
>>> ['number', 1, 2, 3, 4, 5, 6, 7, 8, 9, 'number', 10]list.remove("number")
print(list)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 'number', 10]list.pop(9)
print(list)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]del list[9]
print(list)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9]del list
print(list)
>>> <class 'list'>mylist.clear()
print(mylist)
>>> []

五、Tuple（元组）

1. 写法

元组写在小括号 ( ) 里，元素之间用逗号隔开。

tuple = ('abcd', 321, 321, 5.25, 1+1j)

需要特别注意的是，如果创建只含有一个元素的元组，必须在该元素后面加一个 “,” 逗号，否则Python会把它识别为数值、字符串等：

tuple = ('abcd')
print(type(tuple))
>>> <class 'str'>tuple = (50)
print(type(tuple))
>>> <class 'int'>tuple = (50,)
print(type(tuple))
>>> <class 'tuple'>

2. 元组的操作

元组的特点基本与列表类似，也是有序可重复的，同样可以有访问、截取、重复输出、合并、检验是否存在元素等操作：

tuple = ('abcd', 321, 321, 5.25, 1+1j)
print(tuple[0])
print(tuple[1:5])
print(tuple*2)
print(tuple + ('efg','higk','lmn'))
print(5.25 not in tuple)>>> 输出：
>>> abcd
>>> (321, 321, 5.25, (1+1j))
>>> ('abcd', 321, 321, 5.25, (1+1j), 'abcd', 321, 321, 5.25, (1+1j))
>>> ('abcd', 321, 321, 5.25, (1+1j), 'efg', 'higk', 'lmn')
>>> False

3. 修改元组元素

不同之处在于，元组的元素不能修改。

如果使用类似列表修改的语句，如 tuple[0] = “aaa” 去操作元组，会报错：
【TypeError: ‘tuple’ object does not support item assignment】

但是如果非要改变元组里的元素，也可以把元组先转换为List列表，更改完再转回Tuple元组：

tu = ('abcd', 321, 321, 5.25, 1+1j)
li = list(tu)
li[0] ='aaa'
tu = tuple(li)
print(tu)>>> 输出：
>>> ('aaa', 321, 321, 5.25, (1+1j))

也是由于元组不可改变，所以它没有排序方法。

4. 元组常用方法

len() 返回元组的长度
count() 返回元组中指定元素出现的次数
index() 在元组中搜索指定的元素，并返回匹配的第一个元素的下标
当元组里的元素全部是实数（int和float）时，可以使用 max()、min()、sum() 等数学方法，查找元素里的最大值最小值以及求和
由于元组不可改变，因此没有List那些添加、删除元素的方法，但还是可以用del关键字删除整个元组

tuple = ('abcd', 321, 321, 5.25, 1+1j)
print(len(tuple))
print(tuple.count(321))
print(tuple.index(321))
>>> 5
>>> 2
>>> 1tuple = (12,3.4,56,78,90,87,6.5,43,21)
print(max(tuple))
print(min(tuple))
print(sum(list))
>>> 90
>>> 3.4
>>> 396.9del tuple
print(tuple)
>>> <class 'tuple'>

（以上方法其实对于List列表也都适用）

六、Set（集合）

1. 创建集合

在Python中，Set是无序和无索引的集合，写在花括号 { } 里。

可以使用花括号 { } 或者 set() 构造函数来创建集合。

注意如果是多个元素的话，set()里面还要再用小括号括起来：

myset1 = {'abcd', 321, 321, 5.25, 1+1j}
print(myset1)
myset2 = set((1,3,5,7,9,8,6,4,2,0,1,1,1))
print(myset2)>>> 输出：
>>> {321, 'abcd', (1+1j), 5.25}
>>> {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

Set集合是无序的，不允许重复，所以如果有重复的元素，会被自动去掉。

这里第二个的结果看起来好像被排序了，这是因为set在去重时会有修改排序的操作，在set数据值过小时可能会有这种情况，如果数据值大一点就不会了：

myset2 = {3,4,2,123,87,328947,3263,124873,128595,7,9,8,6,4,2,0,1,1,1,8,6}
print(myset2)>>> 输出：
>>> {0, 1, 2, 3, 4, 6, 7, 8, 124873, 9, 328947, 128595, 87, 123, 3263}

这个输出只是其中一种情况，每次运行得到的顺序都可能不一样。
所以不应该认为Set集合中的元素存在顺序。

Set集合常用来进行成员关系测试（集合的&|-^运算）和删除重复元素，例如给list去重：

mylist = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]
print(list(set(mylist)))>>> 输出：
>>> [1, 2, 3, 4, 5]

2. { }和set()的区别

如果要创建只有一个字符串的集合，{ }和set()构造方法是有区别的：

myset1 = {'abcdefgg'}
print(myset1)
myset2 = set('hijklmnn')
print(myset2)>>> 输出：
>>> {'abcdefgg'}
>>> {'h', 'i', 'k', 'm', 'n', 'j', 'l'}

可发现set()会把字符串拆成单个单个字符的元素（并且去重）。

另外，如果要创建一个 空集合，则必须用 set( ) 而不是 { }，因为 { }是用来创建一个空字典的。

myset1 = {}
print(myset1)
print(type(myset1))myset2 = set()
print(myset2)
print(type(myset2))>>> 输出：
>>> {}
>>> <class 'dict'>
>>> set()
>>> <class 'set'>

3. 操作

因为Set集合是无序无索引的，所以无法像List和Tuple一样访问某个元素，但可以使用in和not in来查询集合中是否存在某元素：

myset = {1,2,3,4,5,"a","bb","CCC"}
print(1 in myset)
print("a" not in myset)>>> 输出：
>>> True
>>> False

另外学了流程控制语句后，还可以用for循环遍历集合，这里先跳过。

Set集合是可变的，但里面的元素是不可变的，因为无法访问到集合中的某个元素。

不过一定需要修改的话，可以先删除一个元素，然后再添加一个元素达到差不多的效果。

Set集合也不能使用 +、* 等符号进行合并、重复，但是有一个 union() 合并集合的方法：

myset1 = {1,2,3,4,5}
myset2 = {"a","bb","CCC"}
print(myset1.union(myset2))>>> 输出
>>> {1, 2, 3, 4, 5, 'a', 'bb', 'CCC'}

4. Set集合的运算

可以使用 & | - ^ 符号进行Set集合的 交集、并集、差集、对称差集（不同时存在的元素） 的运算:

myset1 = set('abcdhi')
myset2 = set('abhijk')
print(myset1)
print(myset2)
>>> {'a', 'i', 'h', 'b', 'd', 'c'}
>>> {'a', 'i', 'k', 'h', 'b', 'j'}print(myset1 & myset2)     # 交集
>>> {'h', 'b', 'a', 'i'}print(myset1 | myset2)     # 并集
>>> {'j', 'a', 'i', 'k', 'h', 'b', 'd', 'c'}print(myset1 - myset2)     # 差集
print(myset2 - myset1)     # 差集
>>> {'d', 'c'}
>>> {'k', 'j'}print(myset1 ^ myset2)     # 对称差集
>>> {'k', 'd', 'j', 'c'}

5. Set集合其他常用方法

len() 返回集合的长度
add() 向集合添加一个元素
update() 向集合添加多个元素，所有添加的元素需要是List或Tuple或Set(即必须用[]/()/{}括号括起来)
copy() 复制集合
remove() 删除匹配的元素，如果集合中没有该元素，会报错
discard() 删除匹配的元素，如果集合中没有该元素，不会报错
pop() 删除集合最后一项，由于集合是无序的，所以删除的元素是不确定的，但是方法会返回删除的值
clear() 清空集合
del 关键字删除整个集合

myset = {1,2,3,4,5}
myset.add(6)
print(myset)
>>> {1, 2, 3, 4, 5, 6}myset.update([7,8,9])
print(myset)
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}myset.remove(9)
print(myset)
>>> {1, 2, 3, 4, 5, 6, 7, 8}myset.remove(9)
print(myset)
>>> Traceback (most recent call last):
>>>   File "/usercode/file.py", line 11, in <module>
>>>     myset.remove(9)
>>> KeyError: 9myset.discard(9)
print(myset)
>>> {1, 2, 3, 4, 5, 6, 7, 8}myset.pop()
print(myset)
>>> {2, 3, 4, 5, 6, 7, 8}

其他方法与之前的List差不多，所以这里不再贴对应的代码了。

七、Dictionary（字典）

1. 创建字典

字典Dictionary是一种映射类型，类似Java中的Map，由 key:value 键值对组成。

字典是无序的，保存在字典中的项随机排序，这样可以提高查找效率。

字典在Python中用花括号 { } 来编写：

mydict = {"a":123,2:456,(7,8,9):789,'C':10}

其中键(key)是不可变类型（数字、字符串或元组）。

在同一个字典中，键(key)必须是唯一的。

如果创建字典时使用了重复的key，只会记录最后一个值：

mydict = {"01":"aa","02":"bb","01":"cc","02":"dd","02":"ee"}
print(mydict)>>> 输出：
>>> {'01': 'cc', '02': 'ee'}

如果一定要一个key对应多个value的话，可以把多个value存在list、tuple或set中，如:

mydict = {"01":["aa","cc"],"02":["bb","dd","ee"]}

也可以使用 dict()构造函数来创建字典：

mydict = dict(a=123,b=456,c=789,CC=10)
print(mydict)>>> 输出：
>>> {'a': 123, 'b': 456, 'c': 789, 'CC': 10}

这种方式需注意：

参数格式为key=value（不是冒号了），且key不能带引号。

所以key基本上只能用不带引号表示的字符串，否则都会报错
【SyntaxError: expression cannot contain assignment, perhaps you meant “==”?】

还可以通过dict()构造函数和 zip() 函数映射生成字典：

list1 = ['a','b','c','CC']
list2 = [123,456,789,10]
mydict = dict(zip(list1,list2))
print(mydict)>>> 输出：
>>> {'a': 123, 'b': 456, 'c': 789, 'CC': 10}

两个list分别作为键和值放进字典，如果list1和list2的长度不同，则与最短的list长度相同。

2. 输出键和值

可以使用keys()、values()方=，单独输出字典的key或者value：

mydict = {"a":123,2:456,(7,8,9):789,'C':10}
print(mydict)
print(mydict.keys())
print(mydict.values())>>> 输出：
>>> {'a': 123, 2: 456, (7, 8, 9): 789, 'C': 10}
>>> dict_keys(['a', 2, (7, 8, 9), 'C'])
>>> dict_values([123, 456, 789, 10])

3. 字典嵌套

字典里面还可以包含字典，也就是嵌套.

创建包含3个字典的字典：

mydict = {'A':{'01':'aa','02':'bb'},'B':{'03':'cc','04':'dd'},'C':{'05':'ee','06':'ff'}
}

或者也可以先创建3个字典，再把它们放进去：

A = {'01':'aa','02':'bb'}
B = {'03':'cc','04':'dd'}
C = {'05':'ee','06':'ff'}
mydict = {'A':A,'B':B,'C':C}
print(mydict)>>> 输出：
>>> {'A': {'01': 'aa', '02': 'bb'}, 'B': {'03': 'cc', '04': 'dd'}, 'C': {'05': 'ee', '06': 'ff'}}

4. 访问、修改和添加元素

可以使用在方括号内引用键名、或者用 get() 方法来访问字典的元素：

mydict = {"a":123,2:456,(7,8,9):789,'C':10}
x = mydict["a"]
y = mydict.get(2)
z = mydict.get(1)
print(x)
print(y)
print(z)>>> 输出：
>>> 123
>>> 456
>>> None

如果指定键的值不存在时，返回None。

字典是可变的，可以引用键名来修改元素的值：

mydict = {'01':'aa','02':'bb'}
mydict['02'] = 'AA'
print(mydict)>>> 输出
>>> {'01': 'aa', '02': 'AA'}

通过使用新的索引键并为其赋值，可以将元素添加到字典中：

mydict = {'01':'aa','02':'bb'}
mydict['03'] = 'cc'
print(mydict)>>> 输出：
>>> {'01': 'aa', '02': 'bb', '03': 'cc'}

5. 复制字典

可以使用 copy() 方法或者 dict() 构造函数复制字典：

mydict1 = {"a":123,2:456,(7,8,9):789,'C':10}
mydict2 = mydict1.copy()
mydict3 = dict(mydict1)
print(mydict2)
print(mydict3)>>> 输出：
>>> {'a': 123, 2: 456, (7, 8, 9): 789, 'C': 10}
>>> {'a': 123, 2: 456, (7, 8, 9): 789, 'C': 10}

6. 字典其他常用方法

len() 返回字典的长度
in/not in 关键字检查字典中是否存在指定的键
pop() 删除具有指定键名的元素，找不到会报错
popitem() 删除最后插入的项目（在Python3.7之前的版本中是删除随机项目），如果没有元素会报错
del 关键字删除具有指定键名的元素，找不到会报错
clear() 清空字典
del 关键字删除整个字典，删除后原来那个字典就不存在了

mydict = {'01':'aa','02':'bb','03':'cc','04':'dd','05':'ee','06':'ff'}
print(len(mydict))
>>> 6print('01' in mydict)
print('1' not in mydict)
>>> True
>>> Truemydict.pop('03')
print(mydict)
>>> {'01': 'aa', '02': 'bb', '04': 'dd', '05': 'ee', '06': 'ff'}mydict.popitem()
print(mydict)
>>> {'01': 'aa', '02': 'bb', '04': 'dd', '05': 'ee'}del mydict['05']
print(mydict)
>>> {'01': 'aa', '02': 'bb', '04': 'dd'}mydict.clear()
print(mydict)
>>> {}del mydict
print(mydict)
>>> Traceback (most recent call last):
>>>   File "/usercode/file.py", line 23, in <module>
>>>     print(mydict)
>>> NameError: name 'mydict' is not defined

八、List&Tuple&Set&Dictionary比较

	数据结构	定义符号	是否可变	是否有序	是否允许重复
List	列表	[ ]	可变	有序	允许重复
Tuple	元组	( )	不可变	有序	允许重复
Set	集合	{ }	可变（但元素不可变）	无序	不允许重复
Dictionary	字典	{key:value}	可变（但key不可变）	无序	key不允许重复

List & Tuple & Set & Dictionary 都可以在同一个里面存放不同类型的数据。