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]
列表插入值
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
清空列表
# 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: '
# 默认从小到大排序
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') # 定义元组背后就是调用tuple()把值传进去
# 如果元组中只有一个元素, 那么一定要跟一个逗号, 否则会按照元素本身的类型存放
x = (10)
print(x,type(x))
>> 10
x = ('aa')
print(x,type(x))
>> aa
x = (10,)
print(x,type(x))
>> (10,)
x = ('aa',)
print(x,type(x))
>> ('aa',)
元组中的元素和列表一样, 存的都是索引位置和内存地址的对应关系
所以, 元组中的元素不可变指的是索引和内存地址的对应关系不可变
t = (1,1.3,'aa')
t[0] = 222 # 这里想要修改0号索引对应的数值1在内存中的地址, 所以不能改
>> 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))
>> {}
# 定义空字典时, 最好用dict(), 避免歧义
dict=dict()
print(dict,type(dict))
>> {}
# 利用dict()功能定义字典
dict=dict(x=1,y=2,z=3) # 变量名为字典的key, 变量值为key对应的value
print(dict,type(dict))
>> {'x': 1, 'y': 2, 'z': 3}
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}
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', 'age', 'gender']
清空字典
# 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
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)) >>
定义空集合
s=set()
print(s,type(s)) >>
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父集
print(s1.issuperset(s2))
print(s2.issubset(s1)) # s2 < s2 =>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) # 如果每次遍历出来的字典, 不在net_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访问的指定的值, 又称为映射类型
字典
按可变不可变区分
按可变不可变区分
可变类型
列表, 字典
不可变类型
数字, 字符串, 元组
2103
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
