【万字长文】回顾|Python中的数据结构-轻识

列表

列表的特点：
列表的创建方式
基本的列表操作
列表方法
列表生成式

元组
字符串

格式化字符串
宽度、精度和千位分隔符
对其和填充
字符串编码
字符串方法

字典

创建字典
基本的字典操作
将字符串格式设置功能用于字典
字典方法
字典生成式

集合

创建集合
集合方法
集合生成式

列表

变量可以存储一个元素，而列表是一个“大容器"可以存储N多个元素，程序可以方便地对这些数据进行整体操作
列表相当于其它语言中的数组
列表示意图

列表的特点：

列表元素按照顺序有序排列
索引映射唯一一个数据
列表可以重复存储数据
任意数据类型混存
根据需要动态分配和回收内存

列表的创建方式

使用中括号
使用内置函数list()

l_1 = ["hello","world"] 
l_2 = list(("hello","world") )
l_1
l_2

['hello', 'world']






['hello', 'world']

基本的列表操作

可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘，但列表的有趣之处在于它不同于元组是可以修改的。

修改列表：给元素赋值

修改列表很容易，只需使用索引表示法给特定位置的元素赋值即可。

x = [1, 1, 1]
x[1] = 2
x

[1, 2, 1]

删除元素

从列表中删除元素也很容易，只需使用del语句即可。

names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
del names[2]
names

['Alice', 'Beth', 'Dee-Dee', 'Earl']

切片

name = list('Perl')
name
name[2:] = list('ar')
name

['P', 'e', 'r', 'l']






['P', 'e', 'a', 'r']

使用切片赋值，可将切片替换为长度与其不同的序列

name = list('Perl')
name[1:] = list('ython')
name

['P', 'y', 't', 'h', 'o', 'n']

使用切片赋值还可在不替换原有元素的情况下插入新元素。

numbers = [1, 5]
numbers[1:1] = [2, 3, 4]
numbers

[1, 2, 3, 4, 5]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 如果切片结束于序列末尾，可省略第二个索引
numbers[-3:]
# 如果切片始于序列开头，可省略第一个索引
numbers[:3]
# 复制整个序列，可将两个索引都省略
numbers[:]

[8, 9, 10]






[1, 2, 3]






[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 numbers[0:10]

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 默认步长为1
numbers[0:10:2]
# 要从序列中每隔3个元素提取1个，只需提供步长4即可
numbers[::4]

[1, 3, 5, 7, 9]

# 步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素
numbers[8:3:-1]

numbers[10:0:-2]

numbers[0:10:-2]

numbers[::-2]

[9, 8, 7, 6, 5]






[10, 8, 6, 4, 2]






[]






[10, 8, 6, 4, 2]

numbers[5::-2]
numbers[:5:-2]

[6, 4, 2]






[10, 8]

列表方法

部分方法在《顺序表与单链表》那篇文章有涉及，这里复述下

append

方法append用于将一个对象附加到列表末尾。

lst = [1, 2, 3]
# append直接修改原有的列表
lst.append(4)
lst

[1, 2, 3, 4]

clear 方法clear就地清空列表的内容。

lst = [1, 2, 3]
lst.clear()
lst
# 等价于lst[:] = []

[]

copy 方法 copy 复制列表，常规复制只是将另一个名称关联到列表。

a = [1, 2, 3]
b = a
b[1] = 4
a

[1, 4, 3]

要让a和b指向不同的列表，就必须将b关联到a的副本

a = [1, 2, 3]
b = a.copy()
b[1] = 4
a
# 这类似于使用a[:]或list(a)，它们也都复制a

[1, 2, 3]

count

方法count计算指定的元素在列表中出现了多少次

['to', 'be', 'or', 'not', 'to', 'be'].count('to')

x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
x.count(1)
x.count([1, 2])

5. extend
方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提
供给方法extend。换而言之，你可使用一个列表来扩展另一个列表。

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
a

[1, 2, 3, 4, 5, 6]

这可能看起来类似于拼接，但存在一个重要差别，那就是将修改被扩展的序列（这里是a）。在常规拼接中，情况是返回一个全新的序列。

a = [1, 2, 3]
b = [4, 5, 6]
a + b
a

[1, 2, 3, 4, 5, 6]






[1, 2, 3]

拼接出来的列表与前一个示例扩展得到的列表完全相同，但在这里a并没有被修改。如果要获得类似于下面的效果，拼接的效率将比extend低

a = a + b

拼接操作不会修改原来的列表。要获得与extend相同的效果，可将列表赋给切片，

a = [1, 2, 3]
b = [4, 5, 6]
a[len(a):] = b
a

[1, 2, 3, 4, 5, 6]

index

方法index在列表中查找指定值第一次出现的索引。

knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
knights.index('who')

insert

方法insert用于将一个对象插入列表。

numbers = [1, 2, 3, 5, 6, 7]
numbers.insert(3, 'four')
numbers

[1, 2, 3, 'four', 5, 6, 7]

与extend一样，也可使用切片赋值来获得与insert一样的效果。

numbers = [1, 2, 3, 5, 6, 7]
numbers[3:3] = ['four']
numbers

[1, 2, 3, 'four', 5, 6, 7]

方法pop从列表中删除一个元素（末尾为最后一个元素），并返回这一元素。

# pop是唯一既修改列表又返回一个非None值的列表方法。
x = [1, 2, 3]
x.pop()
x
x.pop(0)
x

remove

方法remove用于删除第一个为指定值的元素。remove是就地修改且不返回值的方法之一。不同于pop的是，它修改列表，但不返回任何值。

x = ['to', 'be', 'or', 'not', 'to', 'be']
x.remove('be')
x

['to', 'or', 'not', 'to', 'be']

reverse

方法reverse按相反的顺序排列列表中的元素

x = [1, 2, 3]
x.reverse()
x

[3, 2, 1]

sort

方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

x = [4, 6, 2, 1, 7, 9]
x.sort()
x

[1, 2, 4, 6, 7, 9]

只改变副本，保留原始列表不变，使用以下方法：

# 方法一
x = [4, 6, 2, 1, 7, 9]
y = x.copy()
y.sort()
x

[4, 6, 2, 1, 7, 9]

# 方法二
x = [4, 6, 2, 1, 7, 9]
y = sorted(x)
# 不能用y = x.sort(),这样得到y的值为None
x
y

[4, 6, 2, 1, 7, 9]






[1, 2, 4, 6, 7, 9]

实际上，这个sorted()函数可用于任何序列，但总是返回一个列表

sorted('Python')

['P', 'h', 'n', 'o', 't', 'y']

高级排序

方法sort接受两个可选参数：key和reverse。参数key类似于参数cmp：你将其设置为一个用于排序的函数。然而，不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。

x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
x.sort(key=len)
x

['add', 'acme', 'aerate', 'abalone', 'aardvark']

对于另一个关键字参数reverse，只需将其指定为一个真值，以指出是否要按相反的顺序对列表进行排序。

x = [4, 6, 2, 1, 7, 9]
x.sort(reverse=True)
x

[9, 7, 6, 4, 2, 1]

函数sorted也接受参数key和reverse。在很多情况下，将参数key设置为一个自定义函数很有用。

列表生成式

简称“生成列表的公式”，通常含有自定义的变量

[x * x for x in range(10)]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[x*x for x in range(10) if x%3 == 0]

[0, 9, 36, 81]

还可添加更多的for部分。

[(x, y) for x in range(3) for y in range(3)]


# 等价于
result = []
for x in range(3):
    for y in range(3):
        result.append((x, y))
result

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]






[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

元组

与列表一样，元组也是序列，唯一的差别在于元组是不能修改的这一点和字符串一样的。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。

 1, 2, 3
    
# 也可以用圆括号创建
(1, 2, 3)

(1, 2, 3)






(1, 2, 3)

# 只包含一个值的元组
42,

(42,)

函数tuple的工作原理与list很像：它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。

tuple([1, 2, 3])

tuple('abc')

tuple((1, 2, 3))

(1, 2, 3)






('a', 'b', 'c')






(1, 2, 3)

元组的创建及其元素的访问方式与其他序列相同

x = 1, 2, 3
x[1]
x[0:2]

2






(1, 2)

元组是可以迭代的对象，所以可以用for...in进行遍历

tp = tuple('abc')
for i in tp:
    print(i,end=",")

a,b,c,

字符串

在python中字符串是基本的数据的类型，是一个不可变的字符序列

格式化字符串

格式化字符串的两种方法：

%做占位符
{}做占位符
f-string

name = 'J'
age = 20

"我叫%s，今年%d" %(name,age)
"我叫{0}，今年{1}".format(name,age)
f"我叫{name}，今年{age}"

'我叫J，今年20'






'我叫J，今年20'






'我叫J，今年20'

在format格式化时，可使用* 或者 ** 进行对list、tuple拆分

foods = ['fish', 'beef', 'fruit']
'i like eat {} and {} and {}'.format(*foods)

'i like eat fish and beef and fruit'

宽度、精度和千位分隔符

设置浮点数（或其他更具体的小数类型）的格式时，默认在小数点后面显示6位小数，并根据需要设置字段的宽度，而不进行任何形式的填充。

# 指定宽度，加：
"{num:10}".format(num=3)
"{name:10}".format(name="Bob")

'         3'






'Bob       '

# 精度也是使用整数指定的，但需要在它前面加上一个表示小数点的句点
"Pi is {pi:.2f}".format(pi=3.1415926)

'Pi is 3.14'

# 同时指定宽度和精度。
"{pi:10.2f}".format(pi=3.1415926)

'      3.14'

# 对于其他类型也可指定精度，但是这样做的情形不太常见
"{:.5}".format("Hello World")

'Hello'

# 使用逗号添加千位分隔符
'{:,}'.format(12345678900000)
'{:30,}'.format(12345678900000)
'{:,.2f}'.format(12345678900000)

'12,345,678,900,000'






'            12,345,678,900,000'






'12,345,678,900,000.00'

对其和填充

在一栏中同时包含字符串和数时，可以修改默认对齐方式。方法是在指定宽度和精度的数前面，添加一个标志，这个标志可以是零、加号、减号或空格

'{:010.2f}'.format(3.1415926)
'{:-10.2f}'.format(3.1415926)
'{:+10.2f}'.format(3.1415926)

'0000003.14'






'      3.14'






'     +3.14'

要指定左对齐、右对齐和居中，可分别使用<、 >和^

print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(3.1415926))

3.14      
   3.14   
      3.14

可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充

"{:￥^15}".format(" WIN BIG ")

'￥￥￥ WIN BIG ￥￥￥'

还有更具体的说明符=，它指定将填充字符放在符号和数字之间

print('{0:10.2f}\n{1:10.2f}'.format(3.1415926, -3.1415926))
print('{0:10.2f}\n{1:=10.2f}'.format(3.1415926, -3.1415926))

如果要给正数加上符号，可使用说明符+，默认是-

pi = 3.1415926
print('{0:-.2}\t{1:-.2}'.format(pi, -pi))
print('{0:.2}\t{1:.2}'.format(pi, -pi))
print('********************')
print('{0:+.2}\t{1:.2}'.format(pi, -pi))
# 如果将符号说明符指定为空格，会在正数前面加上空格
print('{0: .2}\t{1: .2}'.format(pi, -pi))

3.1	-3.1
3.1	-3.1
********************
+3.1	-3.1
 3.1	-3.1

字符串编码

将字符串转化为指定类型的数据格式

"The number is {num}".format(num=42)
# 二进制转换
"The number is {num:b}".format(num=42)
"The number is {num:#b}".format(num=42)

# 八进制转换
"The number is {num:o}".format(num=42)
"The number is {num:#o}".format(num=42)

# 十进制转换
"The number is {num:d}".format(num=42)

# 使用科学表示法来表示小数
"The number is {num:e}".format(num=pi)

# 将整数解读为Unicode码点
"The number is {num:c}".format(num=97)

'The number is 42'






'The number is 101010'






'The number is 0b101010'






'The number is 52'






'The number is 0o52'






'The number is 42'






'The number is 3.141593e+00'






'The number is a'

字符串方法

前面介绍了列表的方法，而字符串的方法要多得多，因为其很多方法都是从模块string那里继承而来的。有关模块string的详细内容见https://docs.python.org/3/library/string.html

1.center

方法center通过在两边添加填充字符（默认为空格）让字符串居中

"The Middle by Jimmy Eat World".center(39)

"The Middle by Jimmy Eat World".center(39, "*")

'     The Middle by Jimmy Eat World     '






'*****The Middle by Jimmy Eat World*****'

2.find

方法find在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回-1

 'With a moo-moo here, and a moo-moo there'.find('moo')

title = "Monty Python's Flying Circus"

title.find('Monty')
title.find('Python')
title.find('Flying')
title.find('Zirquss')

还可指定搜索的起点和终点

subject = '$$$ Get rich now!!! $$$'
subject.find('$$$')

subject.find('$$$', 1) # 只指定了起点

subject.find('!!!')

subject.find('!!!', 0, 16) # 同时指定了起点和终点

3.join和split

join是一个非常重要的字符串方法，其作用与split相反，用于合并序列的元素

seq = [1, 2, 3, 4, 5]
"+".join(seq) # 尝试合并一个数字列表

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-8-de9959aa34e6> in <module>()
      1 seq = [1, 2, 3, 4, 5]
----> 2 "+".join(seq) # 尝试合并一个数字列表


TypeError: sequence item 0: expected str instance, int found

seq = ['1', '2', '3', '4', '5']
"+".join(seq) # 合并一个字符串列表

'1+2+3+4+5'

'1+2+3+4+5'.split("+")

'1+2+3+4+5'.split("+",1) # 返回两个参数列表

['1', '2', '3', '4', '5']






['1', '2+3+4+5']

注意，如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符等）处进行拆分。

lower

方法lower返回字符串的小写版本。

'Trondheim Hammer Dance'.lower()

'trondheim hammer dance'

replace

方法replace将指定子串都替换为另一个字符串，并返回替换后的结果

'This is a test'.replace('is', 'eez')

'Theez eez a test'

5.strip

方法strip将字符串开头和末尾的空白（但不包括中间的空白）删除，并返回删除后的结果

' internal whitespace is kept '.strip()

'internal whitespace is kept'

还可在一个字符串参数中指定要删除哪些字符

'*** SPAM * for * everyone!!! ***'.strip(' *!')

'SPAM * for * everyone'

这个方法只删除开头或末尾的指定字符，因此中间的星号未被删除。

translate

方法translate与replace一样替换字符串的特定部分，但不同的是它只能进行单字符替换。这个方法的优势在于能够同时替换多个字符，因此效率比replace高。

使用translate前必须创建一个转换表。这个转换表指出了不同Unicode码点之间的转换关系。要创建转换表，可对字符串类型str调用方法maketrans，这个方法接受两个参数：两个长度相同的字符串，它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字符。

table = str.maketrans('cs', 'kz')

可查看转换表的内容，看到的只是Unicode码点之间的映射

table

{99: 107, 115: 122}

'this is an incredible test'.translate(table)

'thiz iz an inkredible tezt'

调用方法maketrans时，还可提供可选的第三个参数，指定要将哪些字母删除。

# 将所有空格删除
table = str.maketrans('cs', 'kz', ' ')
'this is an incredible test'.translate(table)

'thizizaninkredibletezt'

7.判断字符串是否满足特定的条件

很多字符串方法都以is打头，如isalnum、 isalpha、 isdecimal、 isdigit、 isidentifier、 islower、 isnumeric、 isprintable、 isspace、 istitle、 isupper，它们判断字符串是否具有特定的性质（如包含的字符全为空白、数字或大写）。如果字符串具备特定的性质，这些方法就返回 True，否则返回False。

"1234".isnumeric()

True

字典

与列表一样是一个可变序列
以键值对的方式存储数据，字典是一个无序的序列

创建字典

1.花括号创建字典

phonebook = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

phonebook

{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

2.函数 dict 可使用函数dict从其他映射（如其他字典）或键值对序列创建字典

items = [('name', 'Gumby'), ('age', 42)]
d = dict(items)
d

d['name']

{'name': 'Gumby', 'age': 42}






'Gumby'

还可使用关键字实参来调用这个函数

d = dict(name='Gumby', age=42)
d

{'name': 'Gumby', 'age': 42}

基本的字典操作

字典的基本行为在很多方面都类似于序列。

len(d)返回字典d包含的项（键值对）数。
d[k]返回与键k相关联的值。
d[k] = v将值v关联到键k。
del d[k]删除键为k的项。
k in d检查字典d是否包含键为k的项。

将字符串格式设置功能用于字典

可在字典中包含各种信息，这样只需在格式字符串中提取所需的信息即可。为此，必须使用format_map来指出你将通过一个映射来提供所需的信息。

phonebook

"Cecil's phone number is {Cecil}.".format_map(phonebook)

{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}






"Cecil's phone number is 3258."

字典方法

clear 方法clear删除所有的字典项，这种操作是就地执行的

d = {}
d['name'] = 'Gumby'
d['age'] = 42
d

returned_value = d.clear()
d

print(returned_value)

{'name': 'Gumby', 'age': 42}






{}



None

这为何很有用呢？我们来看两个场景。下面是第一个场景：

x = {}
y = x
x['key'] = 'value'
y

x = {}
x
y

{'key': 'value'}






{}






{'key': 'value'}

下面是第二个场景：

x = {}
y = x
x['key'] = 'value'
y

x.clear()
x
y

{'key': 'value'}






{}






{}

在这两个场景中， x和y最初都指向同一个字典。在第一个场景中，通过将一个空字典赋给x来“清空”它。这对y没有任何影响，它依然指向原来的字典。但要删除原来字典的所有元素，必须使用clear,这样做的话y也将是空的

copy

方法copy返回一个新字典，其包含的键值对与原来的字典相同（这个方法执行的是浅复制，因为值本身是原件，而非副本）。

x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
y = x.copy()
y['username'] = 'mlh'
y['machines'].remove('bar')
y

{'username': 'mlh', 'machines': ['foo', 'baz']}
x

{'username': 'mlh', 'machines': ['foo', 'baz']}






{'username': 'mlh', 'machines': ['foo', 'baz']}






{'username': 'admin', 'machines': ['foo', 'baz']}

可以看出，当替换副本中的值时，原件不受影响。然而，如果修改副本中的值（就地修改而不是替换），原件也将发生变化，因为原件指向的也是被修改的值

为避免这种问题，一种办法是执行深复制，即同时复制值及其包含的所有值。为此，可使用模块copy中的函数deepcopy。

from copy import deepcopy
d = {}
d['names'] = ['Alfred', 'Bertrand']
c = d.copy()
dc = deepcopy(d)
d['names'].append('Clive')

c
dc

{'names': ['Alfred', 'Bertrand', 'Clive']}






{'names': ['Alfred', 'Bertrand']}

fromkeys

方法fromkeys创建一个新字典，其中包含指定的键，且每个键对应的值都是None。

{}.fromkeys(['name', 'age'])

{'name': None, 'age': None}

这个示例首先创建了一个空字典，再对其调用方法fromkeys来创建另一个字典，这显得有点多余。可以不这样做，而是直接对dict调用方法fromkeys。

dict.fromkeys(['name', 'age'])

{'name': None, 'age': None}

如果不想使用默认值None，可提供特定的值

dict.fromkeys(['name', 'age'], '(unknown)')

{'name': '(unknown)', 'age': '(unknown)'}

方法get为访问字典项提供了更加灵活的方法。通常，如果你试图访问字典中没有的项，将引发错误。

d = {}
print(d['name'])

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-21-c92ea8278836> in <module>()
      1 d = {}
----> 2 print(d['name'])


KeyError: 'name'

而使用get不会这样：

print(d.get('name'))

None

使用get来访问不存在的键时，没有引发异常，而是返回None。还可指定“默认” 值，这样将返回指定的值而不是None。

d.get('name', 'N/A')

'N/A'

items

方法items返回一个包含所有字典项的列表，其中每个元素都为(key, value)的形式。字典项在列表中的排列顺序不确定。

d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0}
d.items()

dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])

返回值属于一种名为字典视图的特殊类型。字典视图可用于迭代，还可确定其长度以及对其执行成员资格检查。

it = d.items()
len(it)

('spam', 0) in it

3






True

d['spam'] = 1
it

d['spam'] = 0
it

dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 1)])






False






dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])






True

# 将字典项复制到列表中
list(d.items())

[('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)]

keys

方法keys返回一个字典视图，其中包含指定字典中的键。

d.keys()

dict_keys(['title', 'url', 'spam'])

方法pop可用于获取与指定键相关联的值，并将该键值对从字典中删除。

d = {'x': 1, 'y': 2}
d.pop('x')

d

1






{'y': 2}

popitem

方法popitem类似于list.pop，但list.pop弹出列表中的最后一个元素，而popitem随机地弹出一个字典项，因为字典项的顺序是不确定的，没有“最后一个元素”的概念。

d = {'url': 'http://www.python.org', 'spam': 0, 'title': 'Python Web Site'}

d.popitem()
d

('title', 'Python Web Site')






{'url': 'http://www.python.org', 'spam': 0}

setdefault

方法setdefault有点像get，因为它也获取与指定键相关联的值，但除此之外， setdefault 还在字典不包含指定的键时，在字典中添加指定的键值对。

d = {}
d.setdefault('name', 'N/A')
d

d['name'] = 'Gumby'
d.setdefault('name')
d

'N/A'






{'name': 'N/A'}






'Gumby'






{'name': 'Gumby'}

如上，指定的键不存在时， setdefault返回指定的值并相应地更新字典。如果指定的键存在，就返回其值，并保持字典不变。与get一样，值是可选的；如果没有指定，默认为None。

d = {}
print(d.setdefault('name'))

d

None





{'name': None}

update

方法update使用一个字典中的项来更新另一个字典

d = {
    'title': 'Python Web Site',
    'url': 'http://www.python.org',
    'changed': 'Mar 14 22:09:15 MET 2016'
    }

x = {'title': 'Python Language Website'}
d.update(x)
d

{'title': 'Python Language Website',
 'url': 'http://www.python.org',
 'changed': 'Mar 14 22:09:15 MET 2016'}

对于通过参数提供的字典，将其项添加到当前字典中。如果当前字典包含键相同的项，就替换它。可像函数dict那样调用方法update。这意味着调用 update时，可向它提供一个映射、一个由键值对组成的序列或关键字参数

values

方法values返回一个由字典中的值组成的字典视图。不同于方法keys，方法values返回的视图可能包含重复的值

d = {}
d[1] = 1
d[2] = 2
d[3] = 3
d[4] = 1
d.values()

dict_values([1, 2, 3, 1])

字典生成式

在列表生成式中， for前面只有一个表达式，而在字典生成式中， for前面有两个用冒号分隔的表达式,这两个表达式分别为键及其对应的值

items = ["fruits","books","others"]
prices = [96,78,88]

d = {item:price for item,price in zip(items,prices)}
d

{'fruits': 96, 'books': 78, 'others': 88}

squares = {i:"{} squared is {}".format(i, i**2) for i in range(10)}
squares

{0: '0 squared is 0',
 1: '1 squared is 1',
 2: '2 squared is 4',
 3: '3 squared is 9',
 4: '4 squared is 16',
 5: '5 squared is 25',
 6: '6 squared is 36',
 7: '7 squared is 49',
 8: '8 squared is 64',
 9: '9 squared is 81'}

集合

集合是python语言提供的内置数据结构，与列表,字典一样属于可变类型的数列，集合实际上是没有value的字典

创建集合

使用{}

s = {"python","hello","99"}

s

{'99', 'hello', 'python'}

使用内置函数set()

set(range(5))
# 集合中没有相同的元素
set([1,2,2,3])
# 集合中的元素时无序的
set("python")

{0, 1, 2, 3, 4}






{1, 2, 3}






{'h', 'n', 'o', 'p', 't', 'y'}

集合方法

in或者not in

用来判断元素是否在集合中

s = {10,20,30,123,1}

10 in s
10 not in s

True






False

add()

添加元素

s.add(80)

s

{1, 10, 20, 30, 80, 123}

3.update()

至少添加一个元素

s.update([1,2,3])
s
s.update((4,5,6))
s

{1, 2, 3, 10, 20, 30, 80, 123}






{1, 2, 3, 4, 5, 6, 10, 20, 30, 80, 123}

remove()

一次删除一个指定的元素

s.remove(1)

s

{2, 3, 4, 5, 6, 10, 20, 30, 80, 123}

s.remove(99)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-32-a73c41416d4a> in <module>()
----> 1 s.remove(99)


KeyError: 99

discard()

一次删除一个指定的元素，如果指定的元素不存在，不抛出异常

s.discard(99)
s

{2, 3, 4, 5, 6, 10, 20, 30, 80, 123}

pop()

一次只删除一个任意元素

s.pop()

s.pop()
s

3






{4, 5, 6, 10, 20, 30, 80, 123}

clear()

清空集合

s.clear()
s

set()

==或者!=

判断两个集合是否相等

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}

s1 == s2
s1 != s2

False






True

issubset()

一个集合是否是另一个集合的子集

s1 = {1,2,3,4,5}
s2 = {3,4,5}
s3 = {3,4,5,6}

s2.issubset(s1)
s3.issubset(s1)

True






False

issuperset

一个集合是否是另一个集合的超集

s1 = {1,2,3,4,5}
s2 = {3,4,5}
s3 = {3,4,5,6}

s1.issuperset(s2)
s1.issuperset(s3)

True






False

isdisjoint()

两个集合是否没有交集

s2 = {3,4,5}
s3 = {3,4,5,6}

s2.isdisjoint(s3)

False

intersection()

求两个集合的交集

s1 = {1,2,3,4}
s2 = {2,3,4,5,6}

s1.intersection(s2)
# &与intersection()等价
s1 & s2

{2, 3, 4}






{2, 3, 4}

union()

求两个集合的并集

s1 = {1,2,3,4}
s2 = {2,3,4,5,6}

s1.union(s2)
# |与union()等价
s1 | s2

{1, 2, 3, 4, 5, 6}






{1, 2, 3, 4, 5, 6}

difference()

求两个集合的差集

s1 = {1,2,3,4}
s2 = {2,3,4,5,6}

s1.difference(s2)
# -与difference()等价
s1 - s2

{1}






{1}

symmetric_difference()

求两个集合的对称差集

s1 = {1,2,3,4}
s2 = {2,3,4,5,6}

s1.symmetric_difference(s2)
# ^与symmetric_difference()等价
s1 ^ s2

{1, 5, 6}






{1, 5, 6}

集合生成式

将{}改为[]就是列表生成式
没有元组生成式

s = {i*i for i in range(6)}

print(s,type(s))

{0, 1, 4, 9, 16, 25} <class 'set'>


也可以加一下老胡的微信
围观朋友圈~~~

推荐阅读

（点击标题可跳转阅读）

深度学习的四个学习阶段！

2021年，机器学习研究风向要变了？

【机器学习】随机森林是我最喜欢的模型

Python之父：Python 4.0可能不会来了

【2021版】机器学习、深度学习调参手册

亚马逊首席科学家李沐博士：工作五年反思

【下载】80页笔记看遍机器学习基本概念、算法、模型

老铁，三连支持一下，好吗？↓↓