1 List

1.1 作用

用来存多个索引对应值， 并且多个值需要按照顺序存放， 并且按照位置取值
比如： 存多个人的名字， 年龄这些相同意义的值， 之后根据索引位置取值

1.2 定义

写在中括号【】内， 任意的数据类型，可以是字符串， 数字， 列表， 字典等
通过调用list()功能， 来存放数据

1.3 类型转换

但凡能够被for循环遍历的类型都可以当作参数传给list()进行转换， 转换成列表

• 字符串

res=list('hello')

print(res)
>> ['h', 'e', 'l', 'l', 'o']
# list()底层调用类似for循环, 遍历字符串中的每一个字符, 把每一个字符加入到列表中

• 字典

res=list({'k1':"value1",'k2':'value2','k3':'value3'})

print(res)
>> ['k1', 'k2', 'k3']
# for循环遍历字典, 取出的是字典的key, 并不会取值, 所以list()遍历一个字典类型会把每个key提取出来, 加入到列表
# 字典本身是无序的类型, 但是Python3做了优化, 让字典每次都是以有序的形式显示

1.4 内置方法

• 按照索引取,改值(正向取值,反向取值): 既可以取, 也可以改

l=[111,'admin','hello']
print(l[0])
>> 111

print(l[-1])
>> hello

l[0] = 222  # 当索引存在时, 则修改索引对应的值

print(l[0])
>> 222

l[3]=333 # 当索引不存在时, 则报错, 无论是取值还是赋值, 只要索引不存在则报错. 
>> IndexError: list assignment index out of range

• 列表追加值

l.append(333)  # append一次只能在列表末尾加一个值

print(l)
>> [222, 'admin', 'hello', 333]

# 如果.append()的是一个容器类型, 那么会把整个容器追加到列表的最后一个元素

list1 = [1,2,3,4,5]
list2 = [6,7]
list1.append(list2)
print(list1)
>> [1, 2, 3, 4, 5, [6, 7]]

# 如果想用.append()把容器类型的每个元素作为单独元素追加到列表, 需要配合循环取值

• 列表插入值

l.insert(1,'manager') # 1 代表的是索引位置, 想在第几个索引位置插入数据, 就写几
print(l)

>> [222, 'manager', 'admin', 'hello']

• 将一个列表内的值, 追加到另一个列表

l1 = [1,2,3]
l2 = [4,5,6]

l2.append(l1)  # 利用append()会把l1列表这个整体当做一个元素追加到l2后, 而不是追加列表里的数值,4,5,6.
print(l2)
>> [4, 5, 6, [1, 2, 3]]

# 利用for循环, 遍历l1列表中的数据, 依次追加到l2中
l1 = [1,2,3]
l2 = [4,5,6]

for i in l1:
    l2.append(i)
print(l2)
>> [4, 5, 6, 1, 2, 3]

# 利用extend(), extend()会类似于for循环一样工作, 遍历l1列表中的值, 追加到l2列表
l1 = [1,2,3]
l2 = [4,5,6]

l2.extend(l1)
print(l2)
>> [4, 5, 6, 1, 2, 3]

l1 = [1,2,3]
l2 = [4,5,6]

l2.extend('abcd')
print(l2)
>> [4, 5, 6, 'a', 'b', 'c', 'd']

• 列表删除值

# del 通用方式, 只是单纯的删除, 没有返回值, 不能把del (l[0])赋值给变量
l=[111,'admin','hello']
del (l[0])
print(l)

>> ['admin', 'hello']

# pop(), 列表删除值功能, 根据索引值删除, 默认删除最后一个值
l = [111, 'admin', 'hello']
l.pop(1)

print(l)
>> [111, 'hello']

# pop(), 删除列表中的值后, 会有返回值, 返回的就是被删除的值
l = [111, 'admin', 'hello']
x = l.pop(1)

print(x)
print(l)

>> admin
>> [111, 'hello']

# remove(), 根据列表中的元素去删除, 需要删除什么, 就在remove()里写什么. remove()的返回值是None, 相当于没有返回值
l = [111, 'admin', 'hello']
l.remove('admin')

print(l)
>> [111, 'hello']

l = [111, 'admin', 'hello', [1,2,3]]
l.remove([1,2,3])

print(l)
>> [111, 'admin', 'hello']

• 切片: 列表的切片是一种拷贝行为, 并不会修改源列表, 是浅拷贝

# l[m:n]: 从第m位索引, 取到第n-1位索引. 列表切片顾头不顾尾
l = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']

print(l[0:3])
>> [111, 'admin', 'hello']

# l[m:n:p]: 从第m位索引, 取到第n-1位索引, 步长为p
l = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']

print(l[0:7:2])  # 取0,2,4,6号位索引
>> [111, 'hello', 'aa', 'cc']

# l[:]: 相当于复制一份源列表出来

l = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']

print(l[:])
>> [111, 'admin', 'hello', [1, 2, 3], 'aa', 'bb', 'cc']

# l[0:len(l)]: len(l)表示的就是从开头取到结尾

l = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']

print(len(l)) # len(l)表示的是列表中元素的个数
>> 7

print(l[0:len(l)])
>> [111, 'admin', 'hello', [1, 2, 3], 'aa', 'bb', 'cc']

# 列表切片是浅拷贝

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']
l2 = l1[:]
print(l1)
print(l2)
print(id(l1))
print(id(l2))

>> [111, 'admin', 'hello', [1, 2, 3], 'aa', 'bb', 'cc']
>> [111, 'admin', 'hello', [1, 2, 3], 'aa', 'bb', 'cc']
>> 2680197396608
>> 2680197222656


l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']
l2 = l1[:]


l1[3][0] = 222
print(l1)
print(l2)
>> [111, 'admin', 'hello', [222, 2, 3], 'aa', 'bb', 'cc']
>> [111, 'admin', 'hello', [222, 2, 3], 'aa', 'bb', 'cc']

# 字符串的完全切片, 并不会开辟新的内存地址, 因为字符串是不能按索引去修改的, 只能读, 所以没必要去开辟新的内存地址; 而列表是可变类型, 完全切片后会产生新的内存地址, 因为列表里的元素是可变的

msg1 = "hello world"
msg2 = msg1[:]
print(id(msg1))
print(id(msg2))

>> 1397751807472
>> 1397751807472

# list[::-1]: 将列表中的元素倒过来显示

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']
print(l1[::-1])

>> ['cc', 'bb', 'aa', [1, 2, 3], 'hello', 'admin', 111]

• 统计列表元素个数

# len(列表名)

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']

print(len(l1))
>> 7

• 成员运算, in和not in

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']

print(111 in l1)
>> True
print('xxx' not in l1)
>> True

• for循环

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc']

for i in l1:
    print(i)

>> 
111
admin
hello
[1, 2, 3]
aa
bb
cc

• 统计列表中某个元素出现的次数

# count("元素"): 统计列表中某个元素出现的次数

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc','aa','aa']

print(l1.count("aa"))
>> 3

• 查找列表中某一个元素的索引值

# index("元素"): 查找列表中某一个元素的索引值, 默认显示第一次出现时的索引值

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc','aa','aa']

print(l1.index("aa"))
>> 4

# 列表没有find内置方法

• 清空列表

# clear(): 清空整个列表

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc','aa','aa']

l1.clear()
print(l1)
>> []

• 将列表中的元素倒过来显示

# reverse(): 将列表中的元素倒过来显示, 会修改源列表, 并不是排序. 和切片中的list[::-1]不同, reverse()会修改源列表

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc','aa','aa']

l1.reverse()
print(l1)
>> ['aa', 'aa', 'cc', 'bb', 'aa', [1, 2, 3], 'hello', 'admin', 111]

• 列表元素排序

# sort():
# 列表中的元素必须是可排序的才能sort, 否则报错. 都是数字, 或者都是字符串

l1 = [111, 'admin', 'hello', [1,2,3], 'aa','bb','cc','aa','aa']

l1.sort()
print(l1)
>> TypeError: '<' not supported between instances of 'str' and 'int'

# 默认从小到大排序
l = [1,3,2,4,6,5,7,10]
l.sort()

print(l)
>> [1, 2, 3, 4, 5, 6, 7, 10]

# sort(reverse=True): 按照降序排序
l = [1,3,2,4,6,5,7,10]
l.sort(reverse=True)
print(l)

>> [10, 7, 6, 5, 4, 3, 2, 1]

# 列表中如果都是字符串, 那么按照ASCII表顺序排序, ASCII表中, 大写字母在前, 小写在后, 排在后面的字符大
l = ['a', 'A' ,'c', 'C']
l.sort()
print(l)

>> ['A', 'C', 'a', 'c']

补充1: 字符串比较大小是按照对应位置的ASCII表中的顺序作为结果, 如果前一个位置有大小之分, 则后面的就不用比较了

print('m' > 'adasdasd')

>> True

print('ada' > 'adasdasd')

>> False

补充2: 列表之间也可以比大小, 原理和字符串比较大小一样, 比较相同索引位置的元素的大小, 对应位置必须是同种类型, 如果不是, 则报错, 无法比较

1.5 队列和堆栈

# 1、队列：FIFO,先进先出
l=[]
# 入队操作
l.append('first')
l.append('second')
l.append('third')

print(l)

# 出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

# 2、堆栈：LIFO,后进先出
l=[]
# 入栈操作
l.append('first')
l.append('second')
l.append('third')

print(l)

# 出栈操作
print(l.pop())
print(l.pop())
print(l.pop())

2 元组

2.1 作用

元祖就是一个不可变的列表, 只用来按照索引取值, 不能修改
如果不需要修改元素, 那么建议用元组, 因为所占的内存空间小, 不需要支持写的功能

2.2 定义

# 小括号()内用逗号分隔开的任意类型的元素

t = (1,1.3,'aa')
print(t,type(t))

>> (1, 1.3, 'aa') <class 'tuple'>  # 定义元组背后就是调用tuple()把值传进去

# 如果元组中只有一个元素, 那么一定要跟一个逗号, 否则会按照元素本身的类型存放

x = (10)
print(x,type(x))
>> 10 <class 'int'>
x = ('aa')
print(x,type(x))
>> aa <class 'str'>

x = (10,)
print(x,type(x))
>> (10,) <class 'tuple'>
x = ('aa',)
print(x,type(x))
>> ('aa',) <class 'tuple'>

元组中的元素和列表一样, 存的都是索引位置和内存地址的对应关系
所以, 元组中的元素不可变指的是索引和内存地址的对应关系不可变

t = (1,1.3,'aa')
t[0] = 222  # 这里想要修改0号索引对应元素的内存地址, 所以不能改

>> TypeError: 'tuple' object does not support item assignment

t = (1,2,[1,2])
t[2][0] = 111  
# 这里修改的是,元组中的列表内的元素, 而元组的索引2对应的列表的内存地址是没有发生变化的, 变化的是列表内的索引和内存地址的对应关系. 
# 所以, 元组里的可变类型中的元素是可以修改的.

print(t)

>> (1, 2, [111, 2])

2.3 类型转换

# 通过tuple()将能被for循环遍历的数据存放到元组

print(tuple('hello'))
>> ('h', 'e', 'l', 'l', 'o')
print(tuple([1,2,3]))
>> (1, 2, 3)
print(tuple({'k1':'v1','k2':'v2'}))
>> ('k1', 'k2')

2.4 内置方法

• 按索引取值(正向取, 反向取): 只能取值

t = (1,2,3,4,5)

print(t[0])
>> 1
print(t[-1])
>> 5

• 切片: 顾头不顾尾

t = (1,2,3,4,5)

print(t[0:3])
>> (1, 2, 3)
print(t[:])
>> (1, 2, 3, 4, 5)
print(t[::-1])
>> (5, 4, 3, 2, 1)

• 长度

t = (1,2,3,4,5)
print(len(t))

>>5

• 成员运算

t = (1,2,3,4,5)
print(5 in t)

>> True

• 循环元组

t = (1,2,3,4,5)

for i in t:
    print(i)

>>
1
2
3
4
5

• 查找元组中某一个元素的索引值

# index("元素"): 查找元组中某一个元素的索引值, 默认显示第一次出现时的索引值. 元组也没有find()

t = (1,2,3,4,5)
print(t.index(1))

>> 0

• 统计元组中某个元素出现的次数

# count("元素"): 统计元组中某个元素出现的次数

t = (1,2,3,4,5)
print(t.count(1))

>> 1

3 字典

3.1 作用

存key对应的value, 比如个人信息, 商品信息等

3.2 定义

在花括号内, 用逗号分开多个key:value
其中value可以是任意类型, key必须是不可变类型(字符串, 数字, 元组), 且key不能重复, 如果key重复了, 那么字典只会保留最后出现的key和value值. 
key通常是字符串, 因为字符串具有描述性功能

# 空的花括号, 默认定义的是空字典, 不是集合
dict={}
print(dict,type(dict))

>> {} <class 'dict'>

# 定义空字典时, 最好用dict(), 避免歧义
dict=dict()
print(dict,type(dict))

>> {} <class 'dict'>

# 利用dict()功能定义字典

dict=dict(x=1,y=2,z=3)  # 变量名为字典的key, 变量值为key对应的value
print(dict,type(dict))

>> {'x': 1, 'y': 2, 'z': 3} <class 'dict'>

3.3 类型转换

字典背后调用dict(), 把数据传到字典里

info = [
    ['name','admin'],
    ("age",20),
    ["gender","Male"]
]
---如何用dict()转换成字典类型---

d={}
for i in info:
    d[i[0]]=i[1]
print(d)

>> {'name': 'admin', 'age': 20, 'gender': 'Male'}

d={}
for k,v in info:  # 利用列表的解压操作: k,v = ['name','admin']
    d[k]=v
print(d)

>> {'name': 'admin', 'age': 20, 'gender': 'Male'}

# dict()具体的操作就是按照方法2, 把info变量中每一组的第一个值作为key, 第二个值作为value存到字典里
# dict()要求变量的每一组都包含两个值, 这样才能按照key, value取值
d=dict(info) 
print(d)
>> {'name': 'admin', 'age': 20, 'gender': 'Male'}

keys = ['name','age','gender']
values = None
---如何把列表中的每一个元素取出来, 作为一个字典的key, value默认用None---

d = {}
for i in keys:
    d[i]=None
print(d)

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

d = {}.fromkeys(keys,None)  # 和for循环取值原理一样, .fromkeys()会遍历keys变量中存的每一个元素, 作为字典的key, value默认是指定的None. 用于快速初始化字典
print(d)

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

# 使用此方法, 默认的value值应该是不可变类型, 这样后期修改一个key的value时, 才不会影响其他key的value
# 如果使用可变类型, 那么每个key的value都是指向同样的内存地址, 一旦修改了某个key的value内的值
# 比如默认是一个列表, 那么一旦修改了列表的元素, 那么所有key的value都会改变

d1 = {}.fromkeys(["k1","k2"],10)         
print(d1) # {'k1': 10, 'k2': 10}   # 修改k2的value不会影响k1       
d1["k2"] = 20                            
print(d1) # {'k1': 10, 'k2': 20}        

d2 = {}.fromkeys(["k1", "k2"],[1,2,3])         
print(d2) # {'k1': [1, 2, 3], 'k2': [1, 2, 3]} 
d2["k1"]=111   # 如果把整个value修改了, 那么对其余value是没有影响的, 因此内存地址变了                           
print(d2)   # {'k1': 111, 'k2': [1, 2, 3]}      

d3 = {}.fromkeys(["k1", "k2"], [1,2,3])                 
print(d3)     # {'k1': [1, 2, 3], 'k2': [1, 2, 3]}      
d3["k1"][0]=5      # 如果修改列表内的元素, 那么其他value也会被修改                                      
print(d3)   # {'k1': [5, 2, 3], 'k2': [5, 2, 3]}        

3.4 内置方法

• 按key取值和存值: 可存可取

dict = {'name':"admin",'age':10,'gender':'Male'}
print(dict['name'])

>> admin

# 针对赋值操作, 当key存在时, 会修改key对应的value

dict = {'name':"admin",'age':10,'gender':'Male'}
dict['age'] = 20

print(dict)
>> {'name': 'admin', 'age': 20, 'gender': 'Male'}

# 针对赋值操作, 当key不存在时, 会创建key和对应的value, 这里和列表不同, 列表中, 当索引不存在时, 赋值会报错

dict = {'name':"admin",'age':10,'gender':'Male'}
dict['job']='IT'

print(dict)
>> {'name': 'admin', 'age': 10, 'gender': 'Male', 'job': 'IT'}

• 统计字典中元素的个数

dict = {'name':"admin",'age':10,'gender':'Male'}

print(len(dict))
>> 3

# 如果字典中, key有重复的, 那么只会保留最后一次出现的key和value值, 并且len()计算的是最终字典中存的元素的个数

dict = {'name':"admin",'age':10,'gender':'Male','name':'manager'}

print(dict)
>> {'name': 'manager', 'age': 10, 'gender': 'Male'}
print(len(dict))
>> 3

• 成员运算: 针对字典的key, 不针对value

dict = {'name':"admin",'age':10,'gender':'Male'}

print('name' in dict)
>> True
print('admin' in dict)
>> False

• 删除

dict = {'name':"admin",'age':10,'gender':'Male'}

del (dict['name'])
print(dict)

>> {'age': 10, 'gender': 'Male'}

# pop(): 根据key删除

dict = {'name':"admin",'age':10,'gender':'Male'}
dict.pop('name')  # 必须指定key, 没有默认删除规则

print(dict)
>> {'age': 10, 'gender': 'Male'}

# pop()会返回被删除的key对应的value

dict = {'name':"admin",'age':10,'gender':'Male'}
value = dict.pop('name')

print(value)
>> admin

# popitem(): 随机删除, 会返回一个元组, 里面存放被删除的key和对应的value

dict = {'name':"admin",'age':10,'gender':'Male'}
dict.popitem()

print(dict)
>> {'name': 'admin', 'age': 10}

dict = {'name':"admin",'age':10,'gender':'Male'}
value = dict.popitem()

print(value)
>> ('gender', 'Male')  # 返回一个元组

• keys(), values(), items()

# 在Python2中
>>> d = {'k1':111, 'k2':222}
>>> d.keys()  # 返回字典的key, 以列表形式展示, 并且是无序的
['k2', 'k1']
>>> d.values()
[222, 111] # 返回字典的value, 以列表形式展示, 并且是无序的
>>> d.items() # 返回列表的每组key和value, 并且以元组的形式, 存在列表里, 并且是无序的
[('k2', 222), ('k1', 111)]


# 在Python3中
>>> d = {'k1':111, 'k2':222}
>>> d.keys()
dict_keys(['k1', 'k2'])
>>> d.values()
dict_values([111, 222])
>>> d.items()
dict_items([('k1', 111), ('k2', 222)])

# 在Python2中, 使用keys(), values(),items()会把字典的key, value或字典的元素全部拿出来, 再开辟内存空间存放, 很浪费内存空间
# 在Python3中, 只有需要用到了某个值, 才会给它开辟内存空间
# 两者的对比类似于range()在Python2和3的区别
# 在Python3中, 如果想让.keys(), .values(), .items()像在Python2中一样直接显示结果, 可以使用list()去转换, 都转成列表即可

# Python3中, 如何取keys(), values(), items()的结果

# for循环

dict = {'name':"admin",'age':10,'gender':'Male'}


for i in dict.keys():
    print (i)
>>
name
age
gender

# 因为for循环字典时, 默认就是取key, 所以也无需使用keys()

for i in dict:
    print(i)
>> 
name
age
gender

# for循环取字典的value

dict = {'name':"admin",'age':10,'gender':'Male'}
for i in dict.values():
    print (i)

>>
admin
10
Male

# for循环取字典的key和value

dict = {'name':"admin",'age':10,'gender':'Male'}

for i in dict.items():  # key和value会以元组的形式返回
    print (i)

>>
('name', 'admin')
('age', 10)
('gender', 'Male')

for k,v in dict.items():
    print (k,v)

>>
name admin
age 10
gender Male

补充:

dict = {'name':"admin",'age':10,'gender':'Male'}

print(list(dict.values()))
>> ['admin', 10, 'Male']
print(list(dict.keys()))
>> ['name', 'age', 'gender']
print(list(dict.items()))
>> [('name', 'admin'), ('age', 10), ('gender', 'Male')]

• 清空字典

# clear()

dict = {'name':"admin",'age':10,'gender':'Male'}

dict.clear()
print(dict)
>> {}

• 更新字典

# update(): 把update()包含的字典中, 在现有字典中不存在的key和value值添加到现有字典, 如果现有字典中存在了update中的key, 那么也会按照update里key对应的value更新现有字典

dict = {'name':"admin",'age':10,'gender':'Male'}

dict.update({'job':'IT','city':'BJ'})
print(dict)
>> {'name': 'admin', 'age': 10, 'gender': 'Male', 'job': 'IT', 'city': 'BJ'}

dict = {'name':"admin",'age':10,'gender':'Male'}

dict.update({'name':'manager'})
print(dict)
>> {'name': 'manager', 'age': 10, 'gender': 'Male'}

• get()

也是根据key取value, 但是当key不存在时会返回None; 而直接取key, 当key不存在时会报错.
当不确定程序中是否有不存在的key时, 可以用get(), 避免取不存在的key时, 程序报错

dict = {'name':"admin",'age':10,'gender':'Male'}

print(dict['k1'])
>> KeyError: 'k1'

print(dict.get('k1'))
>> None

# 可以对get指定返回值, 当key不存在时, 指定一个自定义的value. 默认是None

l1 = {"k1": 1, "k2": 2}         
print(l1.get("k3"))  # None     
print(l1.get("k3", 3))  # 3     

• setdefault()

# 如何实现, 字段中某个key不存在时, 就把指定的key和value添加进去?

dict = {'name':"admin"}

if 'age' in dict:
    pass
else:
    dict['age'] = 20
    
print(dict)
>> {'name': 'admin', 'age': 20}

# 利用setdefault()实现

dict = {'name':"admin",'age':99}
dict.setdefault("age",20)  # 因为age在源字典的key中存在, 所以不会发生更改
print(dict)
>> {'name':"admin",'age':99}

dict = {}
dict.setdefault("age",20) # age不存在, 所以会添加到字典
print(dict)
>> {'age': 20}

# setdefault()的返回值是其执行后, 字典中key的对应值

dict = {}

res = dict.setdefault("age",20)
print(res)  # 字典中没有age, 所以执行setdefault()会把"age":20,加入到字典, 执行完后字典就是{"age":20}, 其中key是"age",值是20
>> 20

4 总结

列表, 元组: 有序, 因为是索引对应值
字典: 无序

列表, 元组, 字典都可以存多个值, 是容器类

列表, 字典是可变类型
元组是不可变类型

5 集合

5.1 作用

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

5.1.1 去重

5.1.2 关系运算

案例: 1

friends1 = ["zero","kevin","jason","dave"] # 用户1的好友们 
friends2 = ["Jy","ricky","jason","dave"]   # 用户2的好友们

如何得出两个人的共同好友?

方法1:

friends1 = ["zero","kevin","jason","dave"]
friends2 = ["Jy","ricky","jason","dave"]

l = []
for i in friends1:
    if i in friends2:
        print("%s是共同好友"%(i))
        l.append(i)
print(l)
>>
jason是共同好友
dave是共同好友
['jason', 'dave']

5.2 定义

在{}内用逗号分隔开多个元素，多个元素满足以下三个条件
1. 集合内元素必须为不可变类型
2. 集合内元素无序
3. 集合内元素没有重复
4. 定义集合时, 调用的就是set()

l = {1,2,[1,2]}  # 集合内必须是不可变类型
print(l)
>> TypeError: unhashable type: 'list'

>>> l ={ 1,'a','z','b',4,7}
>>> print(l)
{1, 4, 7, 'a', 'z', 'b'}  # 集合内元素无序

l = {1,1,1,1,1,2,3,4,5}
print(l)
>> {1, 2, 3, 4, 5} # 集合内没有重复元素

s = {1,2} << s = set({1,2})

s={} # 默认是空字典
print(type(s)) >> <class 'dict'>
定义空集合
s=set()
print(s,type(s)) >> <class 'set'>

5.3 类型转换

res = set('hellooooll')
print(res)
>> {'e', 'l', 'h', 'o'}  # 无序, 不重复, 不可变类型

res = set([1,2,3,4,[5,6]])
print(set)  # 集合内的元素必须是不可变类型, 执行set()时, 会类似for循环, 把列表中的每个元素遍历出来, 加入到集合, 当遍历到[5,6]时, 发现是列表, 可变类型, 因此无法加入到集合
>> TypeError: unhashable type: 'list'

将字典转换成集合时, 取出来的是字典的key
res = set({'k1':1,'k2':2,'k3':3})
print(res)
>> {'k3', 'k1', 'k2'}

5.4 内置方法

5.4.1 关系运算

取交集

friends1 = {"zero","kevin","jason","dave"}
friends2 = {"Jy","ricky","jason","dave"}

res = friends1 & friends2
print(friends1.intersection(friends2))
print(res)
>> {'jason', 'dave'}

取并集

friends1 = {"zero","kevin","jason","dave"}
friends2 = {"Jy","ricky","jason","dave"}

res = friends1 | friends2
print(friends1.union(friends2))
print(res)
>> {'zero', 'Jy', 'dave', 'jason', 'kevin', 'ricky'}

取差集

取friends1独有的好友
print(friends1 - friends2) >> {'zero', 'kevin'}
print(friends1.difference(friends2))

取friends2独有的好友
print(friends2 - friends1) >> {'Jy', 'ricky'}
print(friends2.difference(friends1))

对称差集

求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2) >> {'zero', 'Jy', 'ricky', 'kevin'}
print(friends1.symmetric_difference(friends2))

父子集

包含的关系
s1={1,2,3}
s2={1,2,4}
两个集合必须是完全包含的关系, 否则是不能做判断的
不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)

s1={1,2,3}
s2={1,2}
print(s1 >= s2) >> True # 当s1大于或等于s2时，才能说是s1是s2父集, 反之小于或等于s2, 为s2的子集
print(s1.issuperset(s2)) # True
print(s2.issubset(s1)) # s2 < s1  =>True

s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))

5.4.2 去重

只能针对不可变类型去重, 而且去重后结果就是集合
print(set([1,1,1,1,2]))
>> {1, 2}

想要恢复成原来的属性, 是无法保证和原来的属性一致的, 因为转换成集合后会去重, 并且集合是无序的
l=[1,'a','b','z',1,1,1,2]
l=list(set(l))
print(l) >> [1, 2, 'a', 'b', 'z']

l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

# 列表中存的是字典, 可变类型, 不能用内置方法去重, 只能手写代码

new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic) # 如果每次遍历出来的字典, 不在new_l里, 则追加进去

5.4.3 其他操作

# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3

# 2.成员运算
>>> 'c' in s
True

# 3.循环
>>> for item in s:
        print(item)
c
a
b

s={1,2,3}

1：discard
s.discard(4) # 删除元素不存在则什么都不做
print(s)
s.remove(4) # 删除元素不存在则报错


2：update  # 不存在的就加到集合里
s.update({1,3,5})
print(s)

3：pop
res=s.pop() # 随机删
print(res)

4：add
s.add(4)
print(s)

5. 
res=s.isdisjoint({3,4,5,6}) # 两个集合完全独立、没有共同部分，返回True
print(res)

6. 
s.difference_update({3,4,5}) # s=s.difference({3,4,5}) 把差集重新赋值给源集合
print(s)

6 数据类型总结

• 按照存值个数区分

按存值个数区分
可以存放多个值: 成为容器类型	列表, 元组, 字典
只能存一个值: 可称为标量/原子类型	数字, 字符串

• 按照访问方式区分

按照访问方式区别
直接访问: 只能通过变量名访问整个值	数字
顺序访问: 可以用索引访问指定的值, 索引代表顺序, 又称为序列类型	字符串, 列表, 元组
key访问: 可以用key访问到指定的值, 又称为映射类型	字典

• 按可变不可变区分

按可变不可变区分
可变类型	列表, 字典
不可变类型	数字, 字符串, 元组