3月14日复盘

挑战AI全栈第四天！（终于双休了）

容器

python 中默认有4种容器

1. 列表list

2. 字典 dict

3. 集合 set

4. 元组 tuple

一、Python列表（list)

Python 支持多种复合数据类型，可将不同值组合在一起。最常用的列表 ，是用方括号标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同

• 列表是一种可以存储任意个各种类型的序列容器

• 列表内的数据有先后顺序关系

• 列表是可变的容器

1.列表的创建

• 创建列表的字面值

>>> L = []     # 创建一个空的列表
>>> L = ['北京', '上海', '广州', '西安']  # 创建一个含有4个字符串的列表
>>> L = [1, 'Two', 3.14, True, False, None]
>>> L = [1, 2, [3.1, 3.2], 4]   #  含有四个元素的列表，第三个元素是列表
>>> L2 = [
	['姓名','语文成绩','数学成绩'],
	['小王', 90, 100],
	['牛犇', 59, 26]
]

注： python 中的 (), [], {} 和 三引号字符串都要成对出现, 可以换行

• 创建列表的构造函数 list

L = list()          # L = []
L = list("ABC")     # L = ['A', 'B', 'C']
L = list(range(5))  # L = [0, 1, 2, 3, 4]

• 列表的运算

列表list同字符串str都是序列, 他们的运算规则基本相同

• + 用于拼接列表

  >>> [1, 2, 3] + [4, 5, 6]   # [1, 2, 3, 4, 5, 6]

• += 追加

  语法 列表 += 可迭代对象

  >>> L = [1, 2, 3]
  >>> L += [4, 5]         # L = [1, 2, 3, 4, 5]
  >>> L = [1, 2, 3]
  >>> L += "ABC"          # L = [1, 2, 3, 'A', 'B', 'C']
  >>> L += range(2)

• • * 用于生产重复的列表

    >>> [1, 2] * 3    # [1, 2, 1, 2, 1, 2]
    >>> L = [5, 6]
    >>> L *= 3        # L = [5, 6, 5, 6, 5, 6]

  • == != 用于比较

    >>> [1, 2, 3] == [1, 2, 3]    # True
    >>> [1, 2, 3] != [3, 2, 1]    # True

  • in /not in 用于判断一个数据元素是否在列表中

    >>> "hello" in [1, "hello", 'world']
    True
    >>> '红楼梦'  in ['三国演义', '西游记']
    False

2.访问列表中的值

2.1索引

列表[整数表达式]
L = [1, 2, 3, 4, 5, 6]
print(L[0])    # 1
print(L[-1])   # 6

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

2.2 反向索引

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

2.3 切片

列表[(开始索引b):(终止索引e)(: (步长s))]

() 里的内容代表可以省略

x = [1, 2, 3, 4, 5, 6, 7, 8]
y1 = x[:4]     # y1 = [1, 2, 3, 4]
y2 = x[::2]    # y2 = [1, 3, 5, 7]
y3 = x[::-1]   # y3 = [8, 7, 6, 5, 4, 3, 2, 1]

列表是可变的容器(不同于字符串)

列表是可变的

字符串是不可变的

list = ['openAI', 'hqyj', "Zhihu", "Taobao", "Wiki"] 
# 读取第二位
print (list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print (list[1:-2])
# 从下标2开始(包含2)到最后一个
print (list[2:])
# 从下标0开始到下标3结束(左闭右开)
print (list[:3])

3.列表的数据操作

3.1 添加数据（增）

• 方法

方法名(L代表列表)	说明
L.append(x)	向列表的末尾追加单个数据
L.insert(index, obj)	将某个数据obj 插入到 index这个索引位置的数据之前
L.extend(可迭代对象)	等同于: L += 可迭代对象，如列表、元组、字符串、集合等

• 示例

mylist1 = [1, 3, 4]            # 目标是变成 [1, 2, 3, 4, 5]
mylist1.append(5)               # mylist1 = [1, 3, 4, 5]
mylist1.insert(1, 2)            # mylist1 = [1, 2, 3, 4, 5]
mylist1.extend(range(6, 10))    # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

3.2 修改数据 (改)

• 用索引赋值可以改变列表内的数据

列表[整数表达式] = 表达式

• 示例

mylist2 = [1, 1.99, 3]   # 把1.99 改为2
mylist2[1] = 2    # mylist2 = [1, 2, 3]

3.3 删除数据 (删)

• 方法

  方法	说明
  L.remove(x)	从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
  L.pop()	根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素
  L.clear()	清空列表

  • 示例

  L = [1, 2, 3, 4, 2, 2, 3, 4]
  L.remove(3)    #  L = [1, 2, 4, 2, 2, 3, 4]
  L.remove(3)    #  L = [1, 2, 4, 2, 2, 4]
  L.remove(3)    #  报错了
  L.clear()      #  L = []
  ​
  list1 = ['Google', 'Baidu', 'Taobao']
  list1.pop()
  print ("列表现在为 : ", list1) # 列表现在为 :  ['Google', 'Baidu']
  list1.pop(1)
  print ("列表现在为 : ", list1) # 列表现在为 :  ['Google']

• del 语句删除指定位置的数据元素

  • 语法

    del 变量名     # 删除变量，同时解除变量绑定的对象
    del 列表[整数表达式]

  • 示例

    L = ['张飞', '赵云', '鲁班7号', '孙悟空']
    del L[2]    
    print(L)    # L = ['张飞', '赵云', '孙悟空']
    del L       # 删除 L 变量
    print(L)    # NameError: name 'L' is not defined

3.4 查看(索引取值就是查看)

print(L[0])  # 取值

4.嵌套列表

即在列表里创建其它列表

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)#[['a', 'b', 'c'], [1, 2, 3]]
print(x[0])#['a', 'b', 'c']
print(x[0][1])#b

5.Python列表常用API

操作列表的函数

序号	函数
1	len(list)列表元素个数
2	max(list)返回列表元素最大值
3	min(list)返回列表元素最小值
4	list(seq)将元组转换为列表

列表的常用方法

运算	结果
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
s.count(x)	x 在 s 中出现的总次数
s.append(x)	将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])
s.clear()	从 s 中移除所有项 (等同于 del s[:])
s.copy()	创建 s 的浅拷贝 (等同于 s[:])
s.extend(t) 或 s += t	用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)
s.insert(i, x)	在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
s.pop([i])	提取在 i 位置上的项，并将其从 s 中移除
s.remove(x)	删除 s 中第一个 s[i] 等于 x 的项目。
s.reverse()	就地将列表中的元素逆序。
s.sort( key=None, *reverse=False*)	对列表内的数据进行排序, reverse=False 升序排序，否则是降序排序

示例:

s = [1, "二", 3]
value = s.pop(1)   # s= [1, 3]; value = '二'
>>> s = [1, 2, 3, 5]
>>> s.reverse()   # 反转
>>> s
[5, 3, 2, 1]
>>> s = [1, 2, 3, 4, 2, 2, 3, 4]
>>> s.index(3)  # 返回第一次出现的位置的索引
2
>>> s.index(3, 4)
6
>>> s.index(100)  # 触发异常，要用try 语句处理
Traceback (most recent call last):
  File "", line 1, in 
ValueError: 100 is not in list
>>> s.count(3)  # 在列表 s 中 找出所有值为3 的元素的个数，并返回
2
>>> s.count(2)
3
>>> L1 = [2, 4, 6, 8, 9, 1]
>>> L1.reverse()
>>> L1
[1, 9, 8, 6, 4, 2]
>>> s.sort()   # 排序，默认是升序排序
>>> s
[1, 2, 2, 2, 3, 3, 4, 4]
>>> s.sort(reverse=True)
>>> s
[4, 4, 3, 3, 2, 2, 2, 1]
​

二、Python元组(tuple)

• 元组是不可改变的列表

• 同列表list 一样，元组可以存放任意类型的数据

• 但是，一旦创建将不可修改，包括添加、删除或更改其中的元素

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

1.元组的创建

创建元组的字面值

用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组

t = ()         # 空元组
t = (100,)     # 含有一个数据元素的元组
t = 100,       # 含有一个数据元素的元组，元组中只包含一个元素时，需要在元素后面添加逗号 ，否则括号会被当作运算符使用
t = (1, 2, 3)  # 含有三个数据元素的元组
t = ( 'hqyj', 2004) # 存放不同类型的元组
t = 1, 2, 3    # 含有三个数据元素的元组

type(x) 函数用来返回数据x的类型

创建元组的函数 tuple

t = tuple()          # t = ()
t = tuple(range(5))  # t = (0, 1, 2, 3, 4)

2.元组的数据操作（删，查，运算）

2.1 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('openAI', 'hqyj', 100, 200) 
print (tup)
del tup
print (tup)#name 'tup' is not defined

2.2 查看元组

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

tup1 = ('python', 'hqyj', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print (tup1[0])#python
print (tup2[1:5])#(2, 3, 4, 5)
print (tup2[:4])#(1, 2, 3, 4)
print (tup2[2:])#(3, 4, 5, 6, 7)

2.3 元组的运算

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz') 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
​
>>> t = (1, 2, 3) + (4, 5, 6)
>>> t += (7, 8, 9)  # 等同于 t = t + (7, 8, 9)
>>> t = t * 2
>>> t *= 2
>>> 5 in t
True

3.元组不可变

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

tup = (1, 2, 3, 4, 5, 6, 7)
tup[1] = 100
print(tup)#报错'tuple' object does not support item assignment

4.元组常用API

Python元组包含了以下内置函数

序号	方法	描述
1	len(tuple)	返回元组中元素个数。
2	max(tuple)	返回元组中元素最大值。
3	min(tuple)	返回元组中元素最小值。
4	tuple(list)	将列表转换为元组。

元组常用的方法

运算	结果
s.index(x[, i[, j]])	元素x 在 s 中首次出现项的索引号，i（可选）：搜索的起始索引。如果省略，将从元组的开头开始搜索，j（可选）：搜索的结束索引。如果省略，将搜索到元组的末尾
s.count(x)	x 在 s 中出现的总次数

三、Python字典(dict)

• 字典是一种可变容器模型，且可存储任意类型对象。

• 字典的数据都是以键(key)-值(value)对的形式进行映射存储.

• 字典的每个键值对( key:value )用冒号分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中

• d = {key1 : value1, key2 : value2, key3 : value3 }

• 字典的数据在Python 3.7及更高版本中，字典是有序的；3.6之前的版本中，字典是无序的

• 字典的键不能重复，且只能用不可变类型作为字典的键

• 字典中的数据只能用"键"key 进行索引，不能用整数进行索引

1.字典的创建

• 创建字典的字面值:

字典的表示方式以 {} 括起来， 以英文的冒号 (:) 分隔键值对，各键值对之间用逗号(,)分隔

d = {}    # 创建空字典
d = {'name': "weimingze", "age": 35}
d = {'a': [1, 2, 3]}
d = {'b': {"bb": 222}}
d = {1:'壹', 2:'贰', 5:'伍'}
d = {(1, 2, 3):'壹贰伍'}

以下写法会存在问题

• 键必须是唯一的，但值则不必。

• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

d = {'a': 1, 'b': 2, 'a': 3}  # 字典的键不能重复 d = {'a': 3, 'b': 2}  
d = {[1, 2, 3]: 'a'}          # 不能用可变类型作为字典的键  # 报错

• 字典的创建函数 dict（）

d = dict()   # d = {}
d = dict([("name", "小王"), ("age", 35)])  # {'name': '小王', 'age': 35}
d = dict(a=1, b=2, c=3)    # {'a':1, 'b':2, 'c':3}
d = dict([1, 2, 3, 4])  # 错

2.字典的数据操作（增、删、改、查）

2.1 增加和修改字典

• 添加和修改字典的元素

  • 语法

    字典[键key] = 表达式

    键不存在, 会创建键并绑定键对应的值

    键存在, 会改变键对应的值

  • 示例:

    d = {}
    d['name'] = 'tarena'  # 添加键值对  d = {'name': 'tarena'}
    d['age'] = 18         # d = {'name': 'tarena', 'age': 18}
    d['age'] = 19         # 改变 'age' 键对应的值 d = {'name': 'tarena', 'age': 19}

2.2 访问字典里的值

• 字典的键索引

  • 语法

  字典[键key]

  用键索引可以查看字典中的数据

  • 示例:

    d = {'one': 1, 'two': 2}
    print(d['two'])

如果用字典里没有的键访问数据，会输出错误

mydic = {'Name': 'hqyj', 'Age': 7, 'Class': 'First'} 
print (mydic['Alice'])

• in / not in 运算符

用 in 可以判断一个键是否存在于字典中,如果存在返回 True, 否则返回 False

not in 与 in 相反

• 示例

>>> d = dict(a=1, b=2)   # d = {'a': 1, 'b': 2}
>>> 'a' in d
True
>>> 1 in d
False
>>> 'hello' not in d
True

2.3 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作

显式删除一个字典用del命令

• 语法

del 字典[键]

• 示例

dic = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
# 删除指定的键
del dic['a']
print(dic)
​
# 删除指定的键，并可选地返回其值
v1 = dic.pop('b')
print(v1)
print(dic)
​
# 删除并返回最后一个插入的键值对
key,value = dic.popitem()
print(key,value)
print(dic)
​
# 删除字典中的所有项
dic.clear()
print(dic)
​
# 删除字典
del dic
print(dic)      #NameError: name 'dic' is not defined
​

3.字典的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
print (mydic['Name'])

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表等就不行

mydic1 = {97:"a",98:"b"}
mydic2 = {"name":"karen","age":27}
mydic3 = {['Name']: 'karen', 'Age': 27}
print(mydic3[['Name']])#报错unhashable type: 'list'

注: python 中有四种可变类型

1. 列表 list

2. 字典dict

3. 集合 set

4. 字节数组 bytearray

字典是可迭代对象, 字典只能对所有的键进行迭代访问，默认访问键

d = {'name': 'tarena', 'age': 19}
 for k in d:
    print(k)
    
name
age
​
for k in d:
    print("key=", k, 'value=', d[k])
    
key= name value= tarena
key= age value= 19

可以使用 for 循环来遍历字典的键和值。可以使用 dict.keys() 方法遍历键，使用 dict.values() 方法遍历值，使用 dict.items() 方法同时遍历键和值。

1.遍历字典的键:
my_dict = {'a': 1, 'b': 2, 'c': 3}
​
for key in my_dict.keys():
    print(f"Key: {key}")
#输出：Key: a Key: b Key: c
​
2.遍历字典的值:
my_dict = {'a': 1, 'b': 2, 'c': 3}
​
for value in my_dict.values():
    print(f"Value: {value}")
# 输出：Value: 1 Value: 2 Value: 3
​
3.同时遍历字典的键和值:
my_dict = {'a': 1, 'b': 2, 'c': 3}
​
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")
# 输出：Key: a, Value: 1 Key: b, Value: 2 Key: c, Value: 3

4.字典常用API

操作字典的函数：

序号	函数	描述
1	len(dict)	计算字典元素个数，即键的总数。
2	str(dict)	输出字典，可以打印的字符串表示。
3	type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

字典的方法：

序号	函数及描述
1	dict.clear()删除字典内所有元素
2	dict.copy()返回一个字典的浅复制
3	dict.fromkeys(seq)创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值，如果未提供，则所有键的值将被设置为 None
4	dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict如果键在字典dict里返回true，否则返回false
6	dict.items()以列表返回一个视图对象
7	dict.keys()返回一个视图对象
8	dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)把字典dict2的键/值对更新到dict里
10	dict.values()返回一个视图对象
11	pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。
12	popitem()返回并删除字典中的最后一对键和值。

示例

original_dict = {'a': 1, 'b': [1, 2, 3]}
shallow_copied_dict = original_dict.copy()
​
# 修改原始字典中的可变对象
# 对于可变对象（如列表、字典），修改原始字典中的值会影响浅复制的字典，因为它们引用的是同一个对象
original_dict['b'].append(4)
# 对于不可变对象（如整数、字符串、元组），修改原始字典中的值不会影响浅复制的字典。
original_dict['a']=2
​
print(original_dict)        # 输出: {'a': 2, 'b': [1, 2, 3, 4]}
print(shallow_copied_dict)  # 输出: {'a': 1, 'b': [1, 2, 3, 4]}
# 创建一个新字典，键为列表中的元素，值为None
keys = ['a', 'b', 'c']
new_dict = dict.fromkeys(keys)
print(new_dict)  # 输出: {'a': None, 'b': None, 'c': None}
​
# 创建一个新字典，键为列表中的元素，值为指定的值
value = 0
new_dict = dict.fromkeys(keys, value)
print(new_dict)  # 输出: {'a': 0, 'b': 0, 'c': 0}
# 如果提供的 value 是不可变对象（如整数、字符串、元组等），每个键将有一个独立的值副本
new_dict['a'] = 1
print(new_dict)
​
# 如果提供的值是可变对象（如列表、字典等），那么所有键将共享同一个可变对象。这意味着对这个可变对象的任何修改都会反映在所有键的值上。
keys = ['a', 'b', 'c']
value = []
new_dict = dict.fromkeys(keys, value)
print(new_dict)  # 输出: {'a': [], 'b': [], 'c': []}
# 修改可变对象
new_dict['a'].append('x')
print(new_dict)  # 输出: {'a': ['x'], 'b': ['x'], 'c': ['x']}
# 返回指定键的值，如果键不在字典中返回 default 设置的默认值
dict = {'a': 1, 'b': 2}
print(dict.get('c'))
print(dict.get('c', 0))
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
​
# 使用 dict.update() 更新 dict1
# 如果 dict1 中已经存在 dict2 的键，则 dict1 中的值会被 dict2 中的值覆盖
dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

5.列表、元组、字典小结

1. 列表和元组是有序的，字典的存储在Python3.7以后是有序的

2. 列表、字典是可变的,元组是不可变的

3. 字典的键索引速度快，列表的索引速度也快

   d = {'a':1, 'b':2, .........}
   print(d['c'])  # 速度快
   L = [7, 5, 1, ........]
   print(L[10009])  # 速度快
   ​列表和元组是顺序存储的，字典是散列存储的

4. 字典的 in / not in 运算符快于列表的 in / not in 运算符

   L = ['孙悟空', '赵云', '吕布', ...]
   if '王昭君' in L:    # 速度慢
       pass
   D = {'孙悟空':'花果山', '赵云':'长山', '吕布':'石家庄', .....}
   if '王昭君' in D:  #  速度快
       pass

四、集合set/ 固定集合 frozenset

• 集合是可变的容器，固定集合是不可变的集合

• 集合相当于只有键没有值的字典

• 集合是无序的不重复元素的存储结构

• 集合内的数据都是唯一的，不可变的

1.集合的创建

• 创建集合的方式

  空集合 set()

  非空集合 用 {} 括起来，值用逗号分隔开

  s = set()            # 用函数空集合
  s = {1, 2, 3, 4}     # 创建非空集合的字面值
  s = set(range(5))    # 调用 set(可迭代对象) 来创建集合 s = {0, 1, 2, 3, 4}
  s = set("ABC")       # s = {'B', 'C', 'A'}
  s = set("ABCCCCCCC")  # s = {'B', 'C', 'A'}
  s = set(['ABC'])      # s = {'ABC'} 使用 set()函数从列表创建集合
  s = set((4, 5, 6, 7))# 使用 set()函数从元组创建集合

• 创建固定集合frozensets的方式

  fs = frozenset()              # 空固定集合 fs = frozenset()
  fs = frozenset([1, 2, 3])     # fs =  frozenset({1, 2, 3})

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

2.集合的数据操作（增、删）

2.1 添加元素

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.add( x ) 添加元素到集合

s.update( x ) 添加元素到集合，且参数可以是列表，元组，字典等 ,x 可以有多个，用逗号分开

s1 = set((4, 5, 6, 7))
s1.add(100)
print(s1)               # 输出：{100, 4, 5, 6, 7}
s1.update([200,300])
print(s1)               # 输出：{100, 4, 5, 6, 7, 200, 300}

2.2 删除元素

s.remove( x )：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.discard( x ))：将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。

s.pop())：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

s1 = {10, 20, 30}
s1.remove(20)
print(s1)
s1.remove(40)#报错
s1 = {10, 20, 30}
s1.discard(20)
print(s1)
s1.discard(40)
s1 = {10, 20, 30}
s1.pop()
print(s1)
​
del s1 # 也可以直接删除整个集合

注意：集合（set）没有索引查看的功能。集合是一种无序、不可重复的数据结构，用于存储唯一的元素。由于集合是无序的，所以不能通过索引来访问其中的元素。所以也没有对应的修改功能。

x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

s1 = {10, 20, 30}
print(20 in s1)

3.集合内置方法常用API

集合的方法

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集，返回一个新集合
difference_update()	移除集合中的元素，该元素在指定的集合也存在。直接修改第一个集合
discard()	删除集合中指定的元素
intersection()	返回集合的交集，返回一个新集合
intersection_update()	返回集合的交集。直接修改第一个集合
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数

示例：

# 1.len()
s1 = {10, 20, 30}
print(len(s1))
​
#2. clear()
s1 = {10, 20, 30}
s1.clear()
print(s1)
​
#3.union()
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = {5, 6, 7}
​
result = set1.union(set2, set3)
print(result)  # 输出：{1, 2, 3, 4, 5, 6, 7}

容器总结

• 容器总结

  • 类型

    • 列表 list

    • 元组 tuple

    • 字典 dict

    • 集合 set / 固定集合 frozenset

  • 可变和不可变

    • 可变的容器

    list   dict    set       

    • 不可变的容器

    tuple, frozenset

  • 有序和乱序

    • 有序

      list   tuple   

    • 无序

      dict    set    frozenset

Python推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

• 列表(list)推导式

• 字典(dict)推导式

• 集合(set)推导式

• 元组(tuple)推导式

一、列表推导式

• 作用

  用简单的表达式方式来创建列表

• 语法规则

  [ 表达式 for 自定义变量 in 可迭代对象 ]
  # 或
  [ 表达式 for 自定义变量 in 可迭代对象 if 真值表达式 ]

• 示例

  # 生成一个列表， 里面有 100 个数是[1, 4, 9, 16, 25, ...]
  # 用 for 语句实现
  L = []
  for x in range(1, 101):
      L.append(x ** 2)
  print(L)
  ​
  # 用列表推导式
  L2 = [ x ** 2 for x in range(1, 101)]
  print(L2)
  ​
  L3 = []
  for x in range(1, 101):
      if x % 2 == 0:
          L3.append(x ** 2)
  ​
  L3 = [ x ** 2 for x in range(1, 101) if x % 2 == 0]  # 取出所有的偶数
  # L3 = [4, 16, 36, ...]

二、字典推导式

字典推导基本格式：

• { 键表达式: 值表达式 for 元素 in 集合 }

• { 键表达式: 值表达式 for 元素 in 集合 if 条件 }

# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
listdemo = ['karen','jack', 'marry']
newdict = {key:len(key) for key in listdemo}
print(newdict)#{'karen': 5, 'jack': 4, 'marry': 5}
​
​
#提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：
dic = {x: x**2 for x in (2, 4, 6)}
print(dic)#{2: 4, 4: 16, 6: 36}

三、集合推导式

集合推导式基本格式：

• { 表达式 for 元素 in 序列 }

• { 表达式 for 元素 in 序列 if 条件 }

#计算数字 1,2,3 的平方数：
setnew = {i**2 for i in (1,2,3)}
print(setnew)#{1, 4, 9}
​
​
#判断不是 abc 的字母并输出：
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)#{'d', 'r'}

四、元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

元组推导式基本格式：

• （表达式 for 元素 in 序列 ）

• （表达式 for 元素 in 序列 if 条件 ）

#生成一个包含数字 1~9 的元组
a = (x for x in range(1,10))
print(a)#返回的是生成器对象
print(tuple(a))#使用 tuple() 函数，可以直接将生成器对象转换成元组