小杰python（five day）——世事无常，唯有心安，方能笑看风云变幻。

1.列表--list

(1)深拷贝和浅拷贝

（前者生成一份与原对象相同的内容，不随原对象改变，其内存消耗大，使用情况较小，常用于完全独立副本；

后者相当于引用原对象，随原对象改变，内存消耗小，使用较多）

3.元组--tuple

由（）包裹，元素不可修改

（1）访问

        下标访问

        切片访问

和列表--list无区别（昨天内容内）

（2）元组的加法和乘法

        加法：两个列表拼接

        乘法：乘以几就复制几次

t1 = (1, 2.56, "hi", [22, 88])
t2 = (22, 66)
print(t1 + t2)
print(t2 * 3)

# 输出：
(1, 2.56, 'hi', [22, 88], 22, 66)
(22, 66, 22, 66, 22, 66)

（3）元组相关函数

len	元素个数
max	最大值（类型得相同）
min	最小值（类型得相同）
in 关键字	判断某元素是否存在
not in	判断某元素是否不存在
del 关键字	删除元组

t1 = (1, 8, 3, 4.3)
print(len(t1))
print(max(t1))
print(1 in t1)
# 输出：
4
8
True

4.集合--set

无序，不重合，由{ }包裹

（1）可变集合

元素定义好了不可修改，集合本身可增加或删除，集合元素只能是数字、字符串、元组。

        元素增加

add（）：一次添加一个元素

update（）：可添加多个

        元素删除

remove（）：删除指定元素，无：会报错

discard（）：删除指定元素，无：不会报错

pop（）：删除第一个元素，集合为空，会报错

        元素查找

in                not in

（和tuple与list无区别）

        其他函数

set（）：生成一个集合

子集与父集

demo：

s1 = {34, 'we', 'dd'}
s2 = {34, 'we'}
s3 = {34, 57}
# 求s1与s3的交集
print(s1.intersection(s3))
# 求s1与s3的并集
print(s1.union(s3))
# s2是s1的子集
print(s2.issubset(s1))
# s1是s2的父集
print(s1.issuperset(s2))

# 输出：
{34}
{'dd', 34, 'we', 57}
True
True

其他函数与list、tuple无区别

demo：

set1 = {3, 3, '3', 3.8, (1, 'dsd'), 'ff'}
print(set1)
set1.add(('we', '23'))
print(set1)
set1.update(('erd', '34'))
print(set1)
set1.remove('34')
print(set1)
set1.discard('ff')
set1.pop()
print(set1)
s2 = set((1, 3, 5))
print(s2)

# 输出：
{3.8, 3, (1, 'dsd'), 'ff', '3'}
{3.8, 3, (1, 'dsd'), 'ff', '3', ('we', '23')}
{3.8, 3, 'erd', (1, 'dsd'), 'ff', '34', '3', ('we', '23')}
{3.8, 3, 'erd', (1, 'dsd'), 'ff', '3', ('we', '23')}
{3, 'erd', (1, 'dsd'), '3', ('we', '23')}
{1, 3, 5}

（2）不可变集合

元素不可变，元素个数也不可变

s1 = frozenset('hello')
print(s1)
s2 = frozenset([1, 3, 'dsds'])
print(s2)

# 输出：
frozenset({'o', 'l', 'h', 'e'})
frozenset({1, 3, 'dsds'})

5.字典

由{ }包裹，以键值对形式存储，键不可改，值可以改

键唯一，值可重复，键与值一一对应

d1 = {"name": "ws", "age": 20, "girlfriend": "none"}
print(d1)

# iterable 对应字典的键
# value 对应值，默认值为none
d2 = dict.fromkeys([1, "name", 3], (11, 22, 33))
print(d2)

# 输出：
{'name': 'ws', 'age': 20, 'girlfriend': 'none'}
{1: (11, 22, 33), 'name': (11, 22, 33), 3: (11, 22, 33)}

注意d2的输出

        字典的访问

字典名[键名]

若没有此键，则会报错，有就输出值

        键值对的添加

字典名[键名] = 值

update（）        字典的合并

d1 = {1: 4, 'w': 4, 'r': 'wes'}
d1[3] = 'wss'
print(d1)
d2 = {2: 'zz', 'z': 'wss'}
d2.update(d1)
print(d2)

# 输出：
{1: 4, 'w': 4, 'r': 'wes', 3: 'wss'}
{2: 'zz', 'z': 'wss', 1: 4, 'w': 4, 'r': 'wes', 3: 'wss'}

        字典的删除

pop(键名)        :指定键删除

clear()        ：内容全删

del        ：删除字典

popitem()        ：随机删除一键值对，python3.7后默认删除最后一键值对

d1 = {23: 23, 'aa': 'bb', 1: 6, 2: 6, 3: 9}
d1.pop(3)
print(d1)
d1.popitem()
print(d1)
d1.clear()
print(d1)
del d1

# 输出：
{23: 23, 'aa': 'bb', 1: 6, 2: 6}
{23: 23, 'aa': 'bb', 1: 6}
{}

        键值对的修改

修改单个：字典名[键名] = 新值

修改多个：update()

        若没有的键，则会添加

d1 = {23: 23, 'aa': 'bb', 1: 6, 2: 6, 3: 9}
d1[23] = 'cc'
d1.update({'aa': 33, 33: 55})
print(d1)

# 输出：
{23: 'cc', 'aa': 33, 1: 6, 2: 6, 3: 9, 33: 55}

        键值对的查询

直接通过键名

in或not in关键字

get()函数：如果键名不存在可以指定提示语

setdefault() 查询键值对，如果不存在，会创建该键值对，默认值为none

d1 = {23: 3, 'aa': 'bb', 1: 6, 2: 6, 3: 9}
print(d1[23])
print(d1.get('aa', '不存在则输出提示语，默认None'))
print(d1.setdefault('aa'))
print(d1.setdefault('jj'))
print(d1)
print(d1.setdefault('yy', 77))
print(d1)

# 输出：
3
bb
bb
None
{23: 3, 'aa': 'bb', 1: 6, 2: 6, 3: 9, 'jj': None}
77
{23: 3, 'aa': 'bb', 1: 6, 2: 6, 3: 9, 'jj': None, 'yy': 77}

        其他函数

len() 获取元素个数

copy() 浅拷贝

keys() 获取所有的key值

values() 获取所有的value

items() 获取所有键值对（把每个键值对用括号括起来输出）

demo：

d1 = {23: 3, 'aa': 'bb', 1: 6, 2: 6, 3: 9}
print(d1.keys())
print(d1.values())
print(d1.items())

# 输出：
dict_keys([23, 'aa', 1, 2, 3])
dict_values([3, 'bb', 6, 6, 9])
dict_items([(23, 3), ('aa', 'bb'), (1, 6), (2, 6), (3, 9)])

6.序列函数

len( ):计算长度或元素个数

max( ) 和 min( ) :求序列中最大值、最小值(元素数据类型相同)

sum( ):求序列元素和，start设置起始值（相当于元素和加上start）

t1 = (1, 2.56, 22, 88)
print(sum(t1))
print(sum(t1, start=20))

# 输出：
113.56
133.56

sorted( ):排序，返回新列表，原序列不变（副本进行操作，原数据不变）

t1 = (1, 2.56, 222, 88)
s1 = "afhjkgfdsa"
l1 = [[33, -1, 55], [2]]
l2 = ["qq", "aww", "ze"]
print(sorted(t1))
print(sorted(s1))
print(sorted(l1, reverse=True))
print(sorted(l2, key=len))
print(l2)

# 输出：
[1, 2.56, 88, 222]
['a', 'a', 'd', 'f', 'f', 'g', 'h', 'j', 'k', 's']
[[33, -1, 55], [2]]
['qq', 'ze', 'aww']
['qq', 'aww', 'ze']

reversed( ):反转，返回迭代器，需要强转或for循环遍历

t1 = (1, 2.56, 222, 88)
print(list(reversed(t1)))

for i in reversed(t1):
    print(i)
print(t1)

# 输出：
[88, 222, 2.56, 1]
88
222
2.56
1
(1, 2.56, 222, 88)

all( ) :判断序列元素是否都为真

any( )：判断序列某个元素是否为真

（返回Ture或者False）

zip()：内部为迭代对象，将其打包为元组，组成新对象，需要强转或for遍历

        元素个数不同，以最少为准

t1 = (1, 2.56, 0, 222, 88)
l1 = [33, 2]
l2 = ["qq", "aww", "ze"]
l3 = zip(t1, l1, l2)
print(list(l3))

# 输出：
[(1, 33, 'qq'), (2.56, 2, 'aww')]

map()：返回迭代器，对象需用指定函数修饰，需强转或for遍历

t1 = ("12", "34", "56")
t2 = map(int, t1)
l1 = ["ashty", "q3243", "dbj"]
l2 = map(sorted, l1)
print(list(t2))
print(tuple(l2))

# 输出：
[12, 34, 56]
(['a', 'h', 's', 't', 'y'], ['2', '3', '3', '4', 'q'], ['b', 'd', 'j'])

filter()：返回迭代器，对象需用判断函数修饰，需强转或for遍历

l1 = ["ash45ty", "q3 243", "dbj"]
l2 = filter(str.isalnum, l1)
print(tuple(l2))

# 输出：
('ashty', 'dbj')

enumerate()：返回迭代器，返回值为元素下标于元素组成的元组的一个集合体，需强转或for遍历

l1 = ["ashty", "q3 243", "dbj"]
l2 = enumerate(l1)
print(tuple(l2))

# 输出：
((0, 'ashty'), (1, 'q3 243'), (2, 'dbj'))