数据类型_link管理

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

数据类型简介

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

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数值）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

另外你需要知道的：Python提供一些内置数据类型，特别是，dict、 list、set、frozenset、以及 tuple。str 这个类是用来存储Unicode字符串的，而 bytes 和 bytearray 这两个类是用来存储二进制数据的。

下面我们一一介绍这些数据类型的使用。

Number（数值）

Python3 支持 int、float、bool、complex（复数）。

数字类型是顾名思义是用来存储数值的，需要记住的是，有点和 Java 的字符串味道差不多，如果改变了数字数据类型的值，将重新分配内存空间。

Python 支持三种不同的数值类型：

整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

浮点型(float) - 浮点型由整数部分与小数部分组成，浮点类型不精确存储，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

复数( (complex)) - 复数由实数部分和虚数部分构成，数由实部（real）和虚部（imag）构成。在python 中，复数的虚部以j或者J作为后缀，具体格式为：a+ bj，或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。（注意数学中在虚部用i表示，python中用j或J表示）

注：值得一提的是，布尔类型bool以当做整数来对待，即 True 为真相当于整数值 1，False为假相当于整数值 0。注意True和False第一个字母要大写。例如：a =True+1 则为整形，值为2。

#!/usr/bin/python3 
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "test"     # 字符串 
print (counter)
print (miles)
print (name)
c1 = 12 + 0.2j
c2 = 6 - 1.2j
print("c1+c2: ", c1+c2)

数字类型转换（python常用系统函数）

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

额外说明：和别的语言一样，数字类型支持各种常见的运算，不过 Python 的运算比别的大多数常见语言都更加丰富，此外，还有大量丰富的方法，提供更高效的开发。

数值运算示例：

print (5 + 4)  # 加法   输出 9
print (4.3 - 2) # 减法   输出 2.3
print (3 * 7)  # 乘法  输出 21
print (2 / 4)  # 除法，得到一个浮点数    输出 0.5
print (2 // 4) # 除法，得到一个整数 输出 0
print (17 % 3) # 取余   输出 2
print (2 ** 5) # 乘方  输出 32

String（字符串）

创建字符串可以使用单引号、双引号、三单引号和三双引号，其中三引号可以多行定义字符串，Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用。

字符串运算

下表实例变量a值为字符串 "Hello"，b变量值为 "Python"：

原始字符串除在字符串的第一个引号前加上字母"r"（可以大
小写）以外，与普通字符串有着几乎完全相同的语法。 print r'\n' prints \n 和 print R'\n' prints \n 格式字符串请看下一节内容。

我们定义一个 s='python'语句，它在计算机中的执行顺序是先在内存中创建一个字符串 Python ，在程序栈寄存器中创建一个变量 s，最后把 Python 的地址赋给s 。

再来看看字符串的一些常见操作：

s = '学习Python'
# 字符串索引index取值范围：-len()到len()-1   越界会报错
s[0], s[-1], s[3:], s[::-1]	# '优', 'n', 'Python', 'nohtyP的雅优'
# 替换，还可以使用正则表达式替换
s.replace('Python', 'Java')	 # '学习Java'
# 查找，find()、index()、rfind()、rindex()
s.find('P')			# 3, 返回第一次出现的子串的下标
s.find('h', 2)			# 6, 设定下标2开始查找
s.find('23333')			# -1, 查找不到返回-1
s.index('y')			# 4, 返回第一次出现的子串的下标
s.index('P')		# 不同与find(), 查找不到会抛出异常
# 转大小写, upper()、lower()、swapcase()、capitalize()、istitle()、isupper()、islower()
s.upper()			# '学习PYTHON'
s.swapcase()	    # '学习pYTHON', 大小写互换
s.istitle()			# True
s.islower()			# False
# 去空格,strip()、lstrip()、rstrip()
# 格式化
s1 = '%s %s' % ('Windrivder', 21)	# 'Windrivder 21'
s2 = '{}, {}'.format(21, 'Windridver')	# 推荐使用format格式化字符串
s3 = '{0}, {1}, {0}'.format('Windrivder', 21)
s4 = '{name}: {age}'.format(age=21, name='Windrivder')
# 连接与分割，使用 + 连接字符串，每次操作会重新计算、开辟、释放内存，效率很低，所以推荐使用join
l = ['2017', '03', '29', '22:00']
s5 = '-'.join(l)			# '2017-03-29-22:00'
s6 = s5.split('-')			# ['2017', '03', '29', '22:00']

以上是一些常见的操作。

另外还有一点需要注意的是字符串编码，所有的 Python 字符串都是 Unicode 字符串，当需要将文件保存到外设或进行网络传输时，就要进行编码转换，将字符转换为字节，以提高效率。

# encode 将字符转换为字节
str = '学习Python'
print (str.encode())			# 默认编码是 UTF-8  输出：b'\xe5\xad\xa6\xe4\xb9\xa0Python'
print (str.encode('gbk'))      # 输出  b'\xd1\xa7\xcf\xb0Python'
# decode 将字节转换为字符
print (str.encode().decode('utf8'))   # 输出 '学习Python'
print (str.encode('gbk').decode('gbk'))             # 输出 '学习Python'

转义字符:在字符串中，基本上可以包含任何字符，但是有一些情况需要特殊处理

字符中的转义: 属于字符串的概念,作用于打印. 例如,要完成一个退格,一个制表符,一个换行,这个用字符串如何表示?

List（列表）

Python 中的数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字、字符、甚至可以是其他数据结构在 Python 中，最基本的数据结构是序列（列表和元组），序列中的每个元素都有一个序号（元素的具体位置），这个序号叫索引，索引下标从0开始，以此类推…

列表是写在方括号 [] 之间、用逗号分隔开的元素列表，列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套），列表中的元素是可以改变。

列表俗称是 Python 中的苦力，列表可变（可以改变列表的内容）

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

list1 = ['baidu', 'google', 12, 34];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday[0])   # 输出 Monday
#list 搜索
print(Weekday.index("Wednesday"))
#list 增加元素
Weekday.append("new")
print(Weekday)
# list 删除
Weekday.remove("Thursday")
print(Weekday)

列表的遍历

list = ["a","b","c"]
for i in list:
    print(i)
for index in range(0,3):
    print(list[index])
    list[index] = list[index]+'_new' # 每一个元素末尾加上 _new
    list.append('d')  # 在列表末尾添加'd'
print(list)

1. 应用于列表的内置函数函数

1.1 list 函数

如果对字符串赋值后想要改变字符串中的某个值，因为字符串不能像列表一样可更改，如果想改变这时候可以利用 list 函数，如下：

>>> ll=list('hello')
['h', 'e', 'l', 'l', 'o']
>>> ll[2]
>>> ll[2]='5'
['h', 'e', '5', 'l', 'o']

注意：list 函数适用于所有类型的序列，而不只是字符串

1.2 len 函数

len 函数返回列表中的元素个数

>>> list1 = ['baidu', 'google', 12, 23];
>>> len(list1)

1.3 max 函数

max 函数返回列表元素最大值

>>> list_num=[2,3,5,6,8,12]
>>> max(list_num)

1.4 min 函数

返回列表元素最小值

>>> list_num=[2,3,5,6,8,12]
>>> min(list_num)

1.5 sorted 函数

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

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

#对列表进行排序 >>> a = [5,3,4,2,1] >>> print(sorted(a)) #再次输出原来的列表 a >>> print(a) ------------------------------------------------------- [1, 2, 3, 4, 5] [5, 3, 4, 2, 1] #对列表进行排序, reverse 参数值改为 True，可实现降序排序 a = [5,3,4,2,1] print(sorted(a,reverse=True)) ------------------------------------------------------- [5, 4, 3, 2, 1] >>> L=[('b',2),('a',1),('c',3),('d',4)] >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] >>> sorted(L, key=lambda x:x[1]) # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

2 列表方法

列表提供了几个详细的方法，这些方法用于检查或者修改列表中的内容

2.1 append

append 方法用于在列表的末尾追加新的内容

list_append = [1,2,3,4]
list_append.append(5)
list_append
>>> [1, 2, 3, 4, 5]

2.2 count

count 方法用于统计某个元素在列表中出现的次数

num=[1, 2, 3, 4, 5, 5, 5, 5, 6]
# 统计num列表中5出现的次数
num.count(5)
# 统计字母a出现的次数
name=['a','a','abf','ark','nhk']
name.count('a')

2.3 extend

extend 方法表示追加内容，它可以在列表的末尾一次性追加另一个序列中的多个值，也就是用新列表扩展原有列表

a =[1,2,3]
b = [4,5,6]
# 将列表b追加在列表a后面
a.extend(b)
>>> [1, 2, 3, 4, 5, 6]

此操作和列表的相加操作，但是追加操作改变原有列表，而相加不改变原有列表，例如：

a = [1,2,3]
b = [4,5,6]
a + b
>>> [1, 2, 3, 4, 5, 6]
# 连接操作不改变原有列表
>>> [1, 2, 3]

2.4 index

index 方法用于从列表中找出某个元素第一次匹配的位置的索引位置

content = ['where','who','lisi','cntent','who']
content.index('who')

注意： 以上方法中有两个位置有‘who’,但是只找出了第一次匹配的索引位置元素

2.5 insert

insert 方法用于像列表中插入对象

num = [1,2,5,6,7]
num.insert(2,3)
>>> [1, 2, 3, 5, 6, 7]
num.insert(3,4)
>>> [1, 2, 3, 4, 5, 6, 7]

2.6 pop

pop 方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值

x = [1,2,3]
x.pop()
x[1, 2]
x.pop()
>>> [1]

**注意：**pop 方法是唯一一个既能修改列表又能返回元素值的方法（除了None）,pop 和 append 方法是 Python 中数据结构的出栈和入栈，如果追加（append）刚刚出栈（pop）的值，得到的还是原来的列表

x = [1,2,3]
x.append(x.pop())
>>> [1, 2, 3]

2.7 remove

remove 方法用于移除列表中第一个匹配的元素

content = ['where', 'who', 'lisi', 'cntent', 'who', 'who']
# 移除了第一个匹配的元素
content.remove('who')
content
>>> ['where', 'lisi', 'cntent', 'who', 'who']

2.8 reverse

reverse 方法是将列表中的元素进行反转操作

x=[1, 2, 3]
# 元素反向存储
x.reverse()
>>> [3, 2, 1]

2.9 sort

sort 方法用于在原位置排序，‘原位置排序’意味着改变原来的列表而让列表中的元素有顺序排列

x = [2,3,5,6,1,4,7]
x.sort()
>>> [1, 2, 3, 4, 5, 6, 7]

2.10 clear

clear 方法用于清空列表

list1=['baidu', 'google', 12, 23]
list1
>>> ['baidu', 'google', 12, 23]
#　清空列表内容
list1.clear()
list1

2.11 copy

copy 方法是复制列表

list1 = ['baidu', 'google', 12, 23]
list1.copy()
>>> ['baidu', 'google', 12, 23]
list2 = list1.copy()
list2
>>> ['baidu', 'google', 12, 23]

3. 列表基本操作

列表可以使用所有适用于序列的标准操作，比如第7天所学的索引、分片、连接和相乘，更有趣的是，列表是可以修改的，也就是定义的列表内容可以根据需求更改，本节介绍一些改变列表的方法：如元素赋值、元素删除、分片赋值以及列表方法（但是请注意，并不是所有的列表方法都能真正改变列表）

3.1 改变列表：元素赋值

在列表中要给指定的元素赋值时，我们需要指定特定的索引标记来为列表中某个特定的，位置明确的元素赋值，比如 x[3]=5

x=[1,2,3,4,5]
>>> [1, 2, 3, 4, 5]
# 改变列表第四个元素的内容
x[3]=5
>>> [1, 2, 3, 5, 5]

注意： 不能为一个位置不存在的元素赋值，如果列表长度为2，则不能为索引为10 的元素进行赋值，如果需要赋值则需要创建一个长度为11的列表。

3.2 删除列表元素

若要删除列表中的元素，直接利用del删除即可

# 定义长度为4的姓名列表
names=['zhangsan','lisi','wangwu','zhaoliu']
names
>>> ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
# 删除第三个元素
del names[2]
# 最后列表长度由4变为3
names
>>> ['zhangsan', 'lisi', 'zhaoliu']

del 语句还能用于删除其他元素，也可以用于变量的删除操作。

3.3 切片赋值

切片：变量的名字[start: end: step]

start的默认值是按照step方向上的第一个元素

end的默认值是按照step的方向上的最后一个元素

step的默认值是1

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> L[0:3]   # 取L前三个元素
['Michael', 'Sarah', 'Tracy']
# L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
# 如果第一个索引是0，还可以省略：
>>> L[:3]
['Michael', 'Sarah', 'Tracy']
>>> L[1:3]
['Sarah', 'Tracy']
# 支持倒数切片，L[-1]取倒数第一个元素
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']

在 Python 中对序列或者列表的切片操作是一个很强大的特性，切片赋值会显得更加强大，例如：

# 定义一个list
name = list('Pyther')
# 改变 list 中的最后两个值
name[4:]='on'
>>> ['P', 'y', 't', 'h', 'o', 'n']

从上可知，程序可以一次为多个元素赋值，在切片赋值时，可以使用与原序列不等长的序列将切片替换，例如：

name_re = list('perl')
name_re
>>> ['p', 'e', 'r', 'l']
# 切片替换
name_re[1:] = list('ython')
name_re
>>> ['p', 'y', 't', 'h', 'o', 'n']

切片赋值还可以在不需要更改原有列表任何内容的情况下进行新元素插入

num = [1,4,5]
# 在第一个元素后插入新的元素
num[1:1]=[2,3]
>>> [1, 2, 3, 4, 5]

同理也可以通过切片操作来删除列表中的元素，同样也支持负数切片操作

num=[1, 2, 3, 4, 5]
# 给第一个和第三个元素之间切片赋值一个空序列，即删除元素
num[1:3] = []
>>> [1, 4, 5]
# 负数切片操作
num[-1:-1] = [5,5,5]
>>> [1, 2, 3, 4, 5, 5, 5, 5, 6]

Tuple（元组）

元组（tuple）与列表类似（戴了枷锁的列表），不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开，组中的元素类型也可以不相同。

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号()，列表使用方括号[]。

letters = ('a','b','c','d','e','f','g')
print(letters[0])  # 输出 'a'
print(letters[0:3])  # 输出一组 ('a', 'b', 'c')

1. 元组基本操作

1.1 创建元组

元组创建很简单，只需要在括号中添加元素(不需要括号也可以)，并使用逗号隔开即可。

>>> tup1 = ('baidu', 'google', 12, 34); 
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";
# 创建空元组
>>> tup4 = ()
# 查看tup4和tup3的类型
>>> type(tup4)
<class 'tuple'>
>>> type(tup3)
<class 'tuple'>

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用，如下：

>>> TupNum = (34)   
>>> type(TupNum)   # 不加逗号是整型
<class 'int'>
>>> TupNum = (34,)
>>> type(TupNum)  # 加上逗号变元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以对元组进行截取，组合等操作。

1.2 访问元组

元组的访问和序列访问元素一样，都是通过下标索引进行访问操作

>>> tup1 = ('baidu', 'google',1,2)
>>> tup2 = (1, 2, 3, 4, 5, 6, 7)
>>> tup1[0:2]
('baidu', 'google')
>>> tup2[1:4]
(2, 3, 4)

1.3 修改元组

元组中的值一旦定义就不能修改，但是我们可以通过元组与元组之间的连接关系来对元组进行修改，例如：

>>> tup1 = ('baidu', 'google',1,2)
>>> tup2 = (1, 2, 3, 4, 5, 6, 7)
>>> tup1 + tup2
('baidu', 'google', 1, 2, 1, 2, 3, 4, 5, 6, 7)

以下修改元组属于非法操作，因为元组不支持通过索引列来修改，只能对元组进行复制和连接操作

tup1[0] = 100 （不能进行此操作）

1.4 删除元组

由于元组的不可修改性，所以元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组，如下实例:

#!/usr/bin/python3 
tup1 = ('baidu', 'google',1,2) 
print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)
# 报错信息如下，证明整个元组已经被删除
删除后的元组 tup1 : 
Traceback (most recent call last):  
  File "tupple.py", line 29, in <module>    
	print(tup1)
NameError: name 'tup1' is not defined

2 元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。总而言之对整个元组进行一些运算后就会生成一个新的元组。

2.1 元组求长度

元组求长度使用运算函数 len ，如下

# 求元组tup1的长度
>>> tup1 = ('baidu', 'google',1,2)
>>> len(tup1)

2.2 连接元组

两个甚至对个元组的连接使用 + 连接符，例如：

>>> tup1 = (1,2,3)
>>> tup2 = (4,5,6)
>>> tup3 = (7,8,9)
>>> tup1 + tup2 + tup3
(1, 2, 3, 4, 5, 6, 7, 8, 9)

2.3 复制元组

tup1 = ('abc')
# 元组复制需要加上分隔符后面复制的内容就按照分隔符分隔开
(tup1,) * 3
('abc', 'abc', 'abc')

2.4 判断元素

判断元组中元素是否存在使用关键字 in 进行判断，判断结果返回布尔值

'abc' >> > 'a' in tup1

2.5 元组中指定位置元素访问

和序列一样，元组中的元素同样可以使用索引号访问指定位置的元素，例如：

>>> content = ('hello','world','!')
>>> content
('hello', 'world', '!')
>>> content[1:]
('world', '!')
>>> content[:2]
('hello', 'world')
>>> content[-1]
>>> content[-2]
'world'

3 元组内置函数

和列表一样，元组同样也拥有一些内置函数，这些函数用于判元组中的元素大小以及将元组做相应的转换

#计算元组元素个数。
len(tuple)
#返回元组中元素最大值。
max(tuple)
#返回元组中元素最小值。	
min(tuple)	
#将列表转换为元组。	
tuple(list)

Set（集合）

Python也包含有集合类型。集合是由不重复元素组成的无序的集。它的基本用法包括成员检测和消除重复元素。集合对象也支持像并集，交集，差集，对称差分等数学运算。
集合：特殊的字典，相当于字典中的key

集合（set）是一个无序不重复元素的序列，使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 {} ，因为 {} 是用来创建一个空字典。

集合不能被切片也不能被索引，除了做集合运算之外，集合元素可以被添加还有删除：

集合结构如下：

set1 = {'hello', 'hello', 'word', 'word'}
#　输出结果实现自动去重
{'hello', 'word'}

a_set = {1,2,3,4}
a_set.add(5)
print(a_set)  # 输出{1, 2, 3, 4, 5}
a_set.discard(5)
print(a_set)  # 输出{1, 2, 3, 4}

# 可以用来去除重复
>>> list = [1,2,3,4,1,2,4,3,5,6]
>>> print(set(list))
[1,2,3,4,5,6]
# 如果使用流程控制解决重复问题
list = [1,2,3,4,1,2,4,3,5,6]
new_list = []
for i in list:
    if i not in new_list:
        new_list.append(i)

1、集合创建

可以使用大括号 { } 或者 set() 函数创建集合，

创建格式：

parame = {value01,value02,...}或者set(value)
            注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
          # 创建空集合
>>> empty_set = set()
>>> type(empty_set)  
<class 'set'>
# 创建空字典
>>> empty_dict = {}
>>> type(empty_dict)  
<class 'dict'>
1
2
3
4
5
6
7
8
          2、集合的基本操作

          2.1 添加元素

          语法格式：




    

          s.add(x)
          将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
          s = set(('hello','world'))
print(s)
# 向集合 s 中添加元素
s.add('!')
print('添加元素后的集合是：%s' % s)
# 输出结果是：
添加元素后的集合是：{'world', '!', 'hello'}
1
2
3
4
5
6
7
          除了 add() 方法可以添加元素外，还有一个方法，也可以添加元素，并且参数可以是列表，元组，字典等，语法格式如下：
          s.update( x )
          参数 x 可以是一个，也可以是多个，多个参数之间用逗号相隔
          #　1）添加列表
s.update([1,3],[2,4])
print('添加元素后的集合是：%s' % s)
# 2）添加元组
s.update(('h', 'j'))
print('添加元素后的集合是：%s' % s)
1
2
3
4
5
6
7
          2.2 移除元素

          语法格式：
          s.remove( x )
          将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
          # 将元素 2 从集合中移除
s.remove(2)
print('移除元素 2 后的集合是：%s' % s)
# 如果移除集合中不存在的元素会报异常
# 移除集合中不存在的集合
s.remove('hi')
print('移除元素后的集合是：%s' % s)
#　异常信息
Traceback (most recent call last):  
    File "test.py", line 20, in <module>  
    s.remove('hi')  KeyError: 'hi'
1
2
3
4
5
6
7
8
9
10
11
12
          此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
          s.discard( x )
          >>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  
# 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}
1
2
3
4
5
          我们也可以设置随机删除集合中的一个元素，语法格式如下：
          s.pop()
          # 随机删除集合中的一个元素
s = {1, 3, 4, 'world', '!', 'hello', 'h', 'j'}
print(s)
s.pop()
print('移除元素后的集合是：%s' % s)
# 输出结果：{1, 3, 4, 'world', '!', 'hello', 'h', 'j'}
# 移除元素后的集合是：{3, 4, 'world', '!', 'hello', 'h', 'j'}
1
2
3
4
5
6
7
          注意：在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。
          2.3 计算集合元素个数

          语法格式：
          len(s)
          计算集合 s 元素个数。
          print('集合 s 的长度是：%s' % len(s))
# 输出结果
集合 s 的长度是：7
1
2
3
          2.4 清空集合

          语法格式：
          s.clear()
          清空集合 s
          s.clear()
print('集合清空后的结果是：%s' % s)
# 输出结果：
集合清空后的结果是：set()
1
2
3
4
          2.5 判断元素是否存在

          语法格式：
          x in s
          判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
          # 判断元素是否存在
s = {'hello',  'word'}
# 判断元素 hello 是否在集合 s 中
print(hello' in s)
# 输出结果：True
1
2
3
4
5
          2.6 集合运算

          集合之间的运算符分别是‘-’、‘|’、‘&’、‘^’ ; 下面以两个集合之间的运算为例进行讲解：
            ‘-’：代表前者中包含后者中不包含的元素
            ‘|’：代表两者中全部元素聚在一起去重后的结果
            ‘&’：两者中都包含的元素
            ‘^’：不同时包含于两个集合中的元素
          >>> a = set('afqwbracadaagfgbrafg')
>>> b = set('rfgfgfalacazamddg')
{'r', 'q', 'd', 'b', 'w', 'g', 'f', 'c', 'a'}
{'r', 'd', 'g', 'f', 'l', 'z', 'c', 'm', 'a'}
# 集合a中包含而集合b中不包含的元素
>>> a - b                              
{'b', 'w', 'q'} 
# 集合a或b中包含的所有元素
>>> a | b                             
{'d', 'g', 'l', 'c', 'r', 'q', 'b', 'w', 'f', 'z', 'm', 'a'}
# 集合a和b中都包含了的元素
{'r', 'd', 'g', 'f', 'c', 'a'}
# 不同时包含于a和b的元素
>>> a ^ b                              
{'l', 'q', 'b', 'w', 'z', 'm'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
          3、集合推导式

          和列表一样，集合也支持推导式




    

          # 判断元素是否存在
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
{'r', 'd'}
1
2
3
4
          4、集合内置方法

          4.1 difference()

          difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中，返回一个新的集合。
          difference() 方法语法：
          set.difference(set)
          实例： 两个集合的差集返回一个集合，元素包含在集合 x ，但不在集合 y ：
          # 求两个集合的差集，元素在 x 中不在 y 中
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)
print('两个集合的差集是：%s' % z)
# 输出结果为：{'cherry', 'banana'}
1
2
3
4
5
6
          4.2 difference_update()

            difference_update() 方法用于移除两个集合中都存在的元素。
            difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。
          x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y)
print(x)
# 结果为：{'banana', 'cherry'}
x1 = {1,2,3,4}
y1 = {1,2,3}
x1.difference_update(y1)
print(x1)
# 结果为：{4}
1
2
3
4
5
6
7
8
9
10
11
          4.3 intersection()

          intersection() 方法用于返回两个或更多集合中都包含的元素，即交集，返回一个新的集合。
          intersection() 方法语法：
          set.intersection(set1, set2 ... etc)
# 参数：set1 -- 必需，要查找相同元素的集合
# set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开
1
2
3
          # 返回两个或者多个集合的交集
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.intersection(y)
print(z) # {"apple"}
#　返回三个集合的交集
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
result = x.intersection(y, z)
print('三个集合的交集是：%s' % result)
# 三个集合的交集是：{'c'}
1
2
3
4
5
6
7
8
9
10
11
12
13
          4.4 intersection_update()

            intersection_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集。
            intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。
          intersection_update() 方法语法：
          set.intersection_update(set1, set2 ... etc)
# 参数 set1 -- 必需，要查找相同元素的集合
# set2 -- 可选，其他要查找相同元素的集合，可以使用多个多个，多个使用逗号‘,’ 隔开
1
2
3
          # 返回一个无返回值的集合交集
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.intersection_update(y)
print(x) # {'apple'}
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
x.intersection_update(y, z)
print(x) # {'c'}
1
2
3
4
5
6
7
8
9
10
11
12
          4.5 union()

          union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次，返回值返回一个新的集合
          union() 方法语法：set.union(set1, set2...)
# 参数set1 -- 必需，合并的目标集合
# set2 -- 可选，其他要合并的集合，可以多个，多个使用逗号 , 隔开。
1
2
3
          # 合并两个集合，重复元素只会出现一次：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"} 
z = x.union(y)  
print(z)
# 输出结果为：{'cherry', 'runoob', 'google', 'banana', 'apple'}
# 合并多个集合：
x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"} 
result = x.union(y, z)  
print(result)
# 输出结果为：{'c', 'd', 'f', 'e', 'b', 'a'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
          4.6 isdisjoint()

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




    
isdisjoint() 方法语法：set.isdisjoint(set)
          x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
#　判断集合 y 中是否包含集合 x 中的元素，如果没有返回 True, 有则返回 False
z = x.isdisjoint(y)
print(z) # False
# 结果返回 False,说明集合 y 中有和 x 中相同的元素
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "baidu"}
#　判断集合 y 中是否包含集合 x 中的元素，如果没有返回 True, 有则返回 False
z = x.isdisjoint(y)
print(z) # True
# 结果返回 True,说明集合 y 中没有和 x 中相同的元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
          4.7 issubset()

          issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。
          issubset() 方法语法：set.issubset(set)
参数set -- 必需，要比查找的集合返回值返回布尔值，如果都包含返回 True，否则返回 False。
          # 判断集合 x 的所有元素是否都包含在集合 y 中：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"} 
z = x.issubset(y)  
print(z)  # True
# 说明 集合 x 中的元素都包含在 y 中
1
2
3
4
5
6
          注意：必须是集合中的元素都包含在内，否则结果为false
          #　集合 y 中只有元素 b 和 c ，执行结果为False 
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b","y"}
z = x.issubset(y)
print(z) # False
1
2
3
4
5
6
          4.8  issuperset()

          issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。
          set.issuperset(set)
          # 判断集合 y 的所有元素是否都包含在集合 x 中：
x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"} 
z = x.issuperset(y)  
print(z)  # 输出结果为：True
# 如果没有全部包含返回 False：
x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"} 
z = x.issuperset(y)  
print(z)  # 输出结果为：False
1
2
3
4
5
6
7
8
9
10
11
          4.9 symmetric_difference()

          symmetric_difference() 方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素，结果返回一个新的集合。
          set.symmetric_difference(set)
          # 返回两个集合组成的新集合，但会移除两个集合的重复元素：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.symmetric_difference(y)
print(z)
# 输出结果：{'banana', 'google', 'cherry', 'runoob'}
1
2
3
4
5
6
          4.10 symmetric_difference_update()

          symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
          set.symmetric_difference_update(set)
          # 在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.symmetric_difference_update(y)
print(x)
# 输出结果：{'runoob', 'cherry', 'banana', 'google'}
1
2
3
4
5
6
          Dictionary（字典）

          Python 中的字典提供了一种灵活的访问和组织数据的方式

            字典是一种映射类型，它的元素是键值对，字典的关键字必须为不可变类型，且不能重复。创建空字典使用 {} 。




    

            字典是由很多值组成的集合
            字典的索引可以是不同的数据类型，同样也不止是整数，也有字符串
            字典的索引被称为“键”，键及键所关联的值叫键值对（类似于Java中的Map集合）
            字典是另一种可变容器模型，且可存储任意类型对象。
            字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
          Logo_code = { 'BIDU':'Baidu', 'SINA':'Sina', 'YOKU':'Youku' }
print(Logo_code)
# 输出{'BIDU': 'Baidu', 'YOKU': 'Youku', 'SINA': 'Sina'}
print (Logo_code['SINA'])       # 输出键为 'one' 的值
print (Logo_code.keys())   # 输出所有键
print (Logo_code.values()) # 输出所有值
print (len(Logo_code))  # 输出字段长度
1
2
3
4
5
6
7
          字典的遍历
          # 可以使用keys() values() items()
d = {1:'a',2:'b',3:'c'}
for k,v in d.items():
    print(k,v)
1
2
3
4
          dictionary  = {'url1':'baidu', 'url':'google', 'num1':12, 'num2':34};
          键一般是唯一的，如果键重复，最后的一个键值对会替换前面的键值对，值没有唯一性要求，如下：
          dic1 ={'name':'zhangsan','age':23,'address':'BeiJing','name':'lisi'}
# 查看字典值发现重复的键值后面的替换前面的
{'name': 'lisi', 'age': 23, 'address': 'BeiJing'}
>>> dic1['name']
'lisi'
1
2
3
4
5
6
7
          值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组，如下：
          dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258',('a','b'):(12,43)}
          1. 访问字典数据

          创建一个字典，并访问数据字典内容，以下字典的键是‘size’,‘color’,‘character’,这些键对应的值是‘big’,‘white’,‘gentle’,访问字典的值通过方括号里面添加键就可以直接进行访问，例如：
          MyDog = {'size':'big','color':'white','character':'gentle'}
# 字典值通过[‘键’]来访问
print(MyDog['size']) 
big   #输出结果
print('My Dog has '+MyDog['color']+' fur.' + ' and it has a ' + MyDog['character']+' character')
My Dog has white fur. and it has a gentle character #输出结果
1
2
3
4
5
6
7
          同样的，字典也可以用整数作为键，和列表的索引类似，只是字典的值是任何整数类型都行，不必要从0开始，因为键值的数据类型是任意的，如下：
          MyCon = {12:'big',0:'white',354:'gentle',1:'good'}
# 访问键为 12 的字典值
>>> MyCon[12]
'big'
# 访问键为 0 的字典值
>>> MyCon[0]
'white'
1
2
3
4
5
6
7
8
          因为字典是不排序的，所以不能像列表那样切片。如果访问字典中不存在的键，将导致 KeyError 出错信息。这很像列表的“越界” IndexError 出错信息。在交互式环境中输入以下代码，并注意显示的出错信息，因 为没有’color’键：
          dic1 = {'name':'zhangsan','age':23,'address':'BeiJing'}
#找字典中键为 'color' 的值
dic1['color']
Traceback (most recent call last):  
    File "<input>", line 1, in <module>KeyError: 'color'
1
2
3
4
5
          2、修改字典元素

          2.1 添加和更新字典数据

          向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
          dict = {'Name': 'Fiona', 'Age': 10, 'Class': 'Three'}
dict['Age'] = 8 
dict['School'] = "Middle School" 
# 查看字典数据 
{'Name': 'Fiona', 'Age': 8, 'Class': 'Three', 'School': 'Middle School'}
1
2
3
4
5
6
7
8
          2.2 删除字典元素

          对字典元素的删除操作能单一删除也能将整个字典清空，显示的删除一个字典使用 del 命令“
          dict = {'Name': 'Fiona', 'Age': 10, 'Class': 'Three'}
# 删除键是'Name'的条目 
del dict['Name']  
# 清空字典所有条目
dict.clear()  
# 删除整个字典元素del dict           
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
1
2
3
4
5
6
7
8
          以上打印语句这会引发一个异常，因为用 del 后的字典不再存在：




    

          Traceback (most recent call last): 
    File "test.py", line 12, in <module>    
    print("dict['Age']: ", dict['Age'])
    TypeError: 'type' object is not subscriptable
1
2
3
4
          3、字典键的特性

          字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
          两个重要的点需要记住：
          1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
          dict = {'Name': 'Fiona', 'Age': 10, 'Name': 'Manni'}  
print ("dict['Name']: ", dict['Name'])
# 以上实例输出结果：dict['Name']:  Manni
1
2
3
          2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
          dict = {['Name']: 'Fiona', 'Age': 10}  
print ("dict['Name']: ", dict['Name'])
# 以上实例输出结果：
Traceback (most recent call last): 
    File "test.py", line 3, in <module>    
    dict = {['Name']: 'Zara', 'Age': 7} 
    TypeError: list objects are unhashable
1
2
3
4
5
6
7
          4、字典的函数

          4.1 len()

          len() 方法计算字典元素个数（键的总个数）
          >>> dict = {'Name': 'Fiona', 'Age': 10, 'class': 'Three'}  
>>> len(dict)     
1
2
3
          4.2 str()

          str() 方法输出字典中可以打印的字符串标识
          >>> dict = {'Name': 'Runoob', 'Age': 10, 'Class': 'Three'}
>>> str(dict)
"{'Name': 'Runoob', 'Age': 10, 'Class': 'Three'}"
1
2
3
          4.3 type()

          type() 方法返回输入的变量类型，如果变量是字典就返回字典类型
          >>> dict = {'Name': 'Runoob', 'Age': 10, 'Class': 'Three'}
>>> type(dict)
<class 'dict'>
1
2
3
          5、字典的方法

          5.1	dict.clear()

          删除字典内所有元素，clear() 方法没有任何返回值,实例如下：
          dict = {'Name': 'Fiona', 'Age': 10}
print ("字典长度 : %d" %  len(dict))
dict.clear()
print ("字典删除后长度 : %d" %  len(dict))
# 输出结果为：字典长度 : 2字典删除后长度 : 0
1
2
3
4
5
          5.2	dict.copy()

          copy() 方法对字典进行复制
          浅拷贝与深拷贝的区别
          dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict11 = dict.copy()
print("新复制的字典为 : ", dict11) # {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
# 浅拷贝: 引用对象  赋值
dict2 = dict1  
print("dict2",dict2)  # dict2 {'user': 'runoob', 'num': [1, 2, 3]}
# 深拷贝
dict3 = dict1.copy()  
print("dict3",dict3)  # dict3 {'user': 'runoob', 'num': [1, 2, 3]}
# 修改 data 数据
dict1['user'] = 'root'
dict1['num'].remove(1)
# 输出结果
print(dict1) # {'user': 'root', 'num': [2, 3]}
print(dict2)  # {'user': 'root', 'num': [2, 3]}
print(dict3)  # {'user': 'runoob', 'num': [2, 3]}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
          实例中 dict2 其实是 dict1 的引用，即别名，所以输出结果都是一致的，dict3 对父对象进行了深拷贝，深拷贝不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改，即赋值会随父对象的修改而修改，拷贝不会随父对象的修改而修改。
          5.3	dict.fromkeys()

          创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值，该方法返回一个新的字典
          fromkeys() 方法语法
          dict.fromkeys(seq[, value])
# 参数seq -- 字典键值列表。
# value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。
1
2
3
          # dict.fromkeys(seq[, value])
seq = ('name', 'age', 'class')
# 不指定值
dict = dict.fromkeys(seq)
print("新的字典为 : %s" % str(dict))
# 赋值 10
dict = dict.fromkeys(seq, 10)
print("新的字典为 : %s" % str(dict))
#　赋值一个元组
dict = dict.fromkeys(seq,('zs',8,'Two'))
print("新的字典为 : %s" % str(dict))
1
2
3
4
5
6
7
8
9
10
11
          执行结果返回一个新的字典，如果不指定值默认为None,以上结果输出结果为：




    

          新的字典为 : {'name': None, 'age': None, 'class': None}
新的字典为 : {'name': 10, 'age': 10, 'class': 10}
新的字典为 : {'name': ('zs', 8, 'Two'), 'age': ('zs', 8, 'Two'), 'class': ('zs', 8, 'Two')}
1
2
3
          5.4	dict.get()

          返回指定键的值，如果值不在字典中返回default值
          get() 方法语法
          dict.get(key, default=None)
# 参数key -- 字典中要查找的键。
# default -- 如果指定键的值不存在时，返回该默认值值。
1
2
3
          # get ()方法的应用举例
dict = {'Name': 'Mary', 'Age': 20}
print ("Age 值为 : %s" %  dict.get('Age'))
print ("Name 值为 : %s" %  dict.get('Name'))
print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))
1
2
3
4
5
          以上结果输出为：
          Age 值为 : 20
Name 值为 : Mary
Sex 值为 : NA
1
2
3
          5.5	key in dict

          如果键在字典dict里返回true，否则返回false
          dict = {'Name': 'Mary', 'Age': 20,'Address':'BeiJing'}
# 检测键 Age 是否存在
if 'Age' in dict:    
    print("键 Age 存在")
else:    
    print("键 Age 不存在")
# 检测键 Sex 是否存在
if 'Sex' in dict:    
    print("键 Sex 存在")
else:    
    print("键 Sex 不存在")
# not in
# 检测键 Name 是否存在
if 'Name' not in dict:    
    print("键 Name 不存在")
else:    
    print("键 Name 存在")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
          以上结果输出为：
          # 键 Age 存在
# 键 Sex 不存在
# 键 Name 存在
1
2
3
          5.6	dict.items()

          item() 方法以列表返回可遍历的(键, 值) 元组数组
          dict = {'Name': 'Mary', 'Age': 17} 
print ("Value : %s" %  dict.items())
# 输出结果为：Value : dict_items([('Age', 17), ('Name', 'Mary')])
1
2
3
          可遍历的元组数组举例：
          dict1 = {'老大':'25岁','老二':'20岁','老三':'12岁',        }
print(dict1.items())
for key,values in dict1.items():    
    print(key + '已经' + values + '了')
1
2
3
4
          以上结果输出为：
          # 老大已经25岁了
# 老二已经20岁了
# 老三已经12岁了
1
2
3
          5.7	dict.keys()

          返回一个迭代器，可以使用 list() 来转换为列表
          keys()方法语法：
          dict.keys()
          dict = {'Name': 'Mary', 'Age': 17}
print(dict.keys())
          以上结果输出为：




    

          dict_keys(['Name', 'Age'])
          由结果看出结果返回一个迭代对象，这时候我们可以使用 list 转换为列表：
          list1 = list(dict.keys())
print ("转换后的结果为 : %s" % list1)
# 输出结果为一个列表，后续可以对其进行相应操作：转换后的结果为 : ['Name', 'Age']
1
2
3
          5.8	dict…setdefault()

          Python 字典 setdefault() 方法和 get() 方法类似, 如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
          setdefault()方法语法：
          dict.setdefault(key, default=None)
# 参数key -- 查找的键值。
# default -- 键不存在时，设置的默认键值。
1
2
3
          dict = {'Name': 'Mary', 'Age': 17} 
print ("Age 键的值为 : %s" %  dict.setdefault('Age', None))
print ("Sex 键的值为 : %s" %  dict.setdefault('Sex', None))
print ("新字典为：", dict)
1
2
3
4
          以上结果输出为：
          Age 键的值为 : 17
Sex 键的值为 : None
新字典为：{'Age': 17, 'Name': 'Mary', 'Sex': None}
1
2
3
          5.9	dict.update(dict2)

          Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
          dict.update(dict2)
# 参数 dict2 -- 添加到指定字典dict里的字典。
          dict = {'Name': 'Mary', 'Age': 17}
dict2 = {'Sex': 'female' }
# 将 dict2 中的结果添加到字典 dict 中　
dict.update(dict2)
print ("更新字典 dict : ", dict)
1
2
3
4
5
          以上结果输出为：
          更新字典 dict :  {'Name': 'Mary', 'Age': 17, 'Sex': 'female'}
          5.10	dict.values()

          Python 字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
          dict = { 'Name': 'Mary','Sex': 'male', 'Age': 7}
print("字典所有值为 : ", list(dict.values()))
          以上结果输出为：
          字典所有值为 :  ['Mary', 'male', 7]
          5.11	dict.pop(key[,default])

          Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
          pop()方法语法：
          pop(key[,default])
#参数key: 要删除的键值default: 如果没有 key，返回 default 值
# 返回值返回被删除的值。
1
2
3
          dict = {'Name': 'Mary', 'Age': 17}
result = dict.pop('Age') # 删除
print(result)
1
2
3
4
5
          5.12	dict.popitem()

          Python 字典 popitem() 方法随机返回一个键值对(key,value)形式，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。如果字典已经为空，却调用了此方法，就报出KeyError异常。
          dict = {'Name': 'Mary', 'Age': 17}
pop_obj=dict.popitem()
print(pop_obj)
print(dict)
1
2
3
4
          以上结果输出为：
          ('Age', 17)
{'Name': 'Mary'}
          将字典清空：
          dict = {'Name': 'Mary', 'Age': 17}
del dict
print(dict.popitem())
1
2
3
          结果输出为：
          Traceback (most recent call last):  
    File "test.py", line 4, in <module>    
    print(dict.popitem())
    TypeError: descriptor 'popitem' of 'dict' object needs an argument
1
2
3
4
          6、字典和列表

          6.1 字典和列表差异

          列表中的元素表项由于元素通过序列从 0 开始递增存放，所以列表中的表项是排序的，而字典的内容的表项是不排序的，如下例子就很好的说明列表和字典的区别：
          list1 = ['zhangsan',23,'BeiJing']
list2 = ['BeiJing','zhangsan',23]
list1 == list2  # False
dic1 = {'name':'zhangsan','age':23,'address':'BeiJing'}
dic2 = { 'age':23,'name':'zhangsan','address':'BeiJing'}
dic1 == dic2  # True
1
2
3
4
5
6
7
8
          由以上实例可以看出，当列表元素内容一致，顺序不同再对比内容时匹配不成功，同理字典值匹配成功，说明字典中元素内容不按顺序存放。Python 中的字典提供了一种灵活的访问和组织数据的方式
            字典是由很多值组成的集合
            字典的索引可以是不同的数据类型，同样也不止是整数，也有字符串
            字典的索引被称为“键”，键及键所关联的值叫键值对（类似于Java中的Map集合）
            字典是另一种可变容器模型，且可存储任意类型对象。
            字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
          dictionary  = {'url1':'baidu', 'url':'google', 'num1':12, 'num2':34}
          键一般是唯一的，如果键重复，最后的一个键值对会替换前面的键值对，值没有唯一性要求，如下：
          dic1 = {'name':'zhangsan','age':23,'address':'BeiJing','name':'lisi'}
# 查看字典值发现重复的键值后面的替换前面的
dic1{'name': 'lisi', 'age': 23, 'address': 'BeiJing'}
dic1['name']
'lisi'
1
2
3
4
5
          值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组，如下：
          dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258',('a','b'):(12,43)}