文章目录
1.元组简介
1.1.元组基本介绍
- 元组表现形式tuple
- 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
1.2.元组的创建
- 使用()创建元素
- 元组不是空元组时,至少有一个 逗号(,) 当元组不是空元组时，括号可以省略
1.3.元组的解包
- 元组解包指 将元组当中的每一个元素都赋值给一个变量，序列都适用
- 解包时，变量个数必须与序列中元素数量相对应，否则就必须用*指定一个且仅有一个变量接收其余元素，并组成一个列表，变量值与变量位置有关
tup=() #空元组
tup=(10) # class int, tup=10
tup=(10,) # class tuple,元组(10,)
tup=(1,2,3,4,5) #元组(1,2,3,4,5)
tup= 1,2,3,4,5 #等同于(1,2,3,4,5)
a,b,c,d,e=tup #元组解包，a=1,b=2,c=3,d=4,e=5
#a,b=tup # ValueError: too many values to unpack (expected 2)
a,b,*c=tup #a=1,b=2,c=[3,4,5]
a,*b,c=tup #a=1,b=[2,3,4].c=5
*a,b,c=tup #a=[1,2,3],b=4,c=5
a,b,*c=[1,2,3,4,5,6] #a=1,b=2,c=[3,4,5,6]
a,b,*c="python" #a="p",b="y",c=["t","h","o","n"]
2.字典
2.1.字典的基本介绍
- 字典属于一种新的数据结构称为映射(mapping) ，不是序列
- 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
- 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
- 这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
- 字典我们也称之为键值对(key-value)结构
- 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
2.2. 字典创建
- 创建一个有数据的字典 语法 {key:value,key:value,…}
- 字典的值可以是任意对象
- 字典的键可以是任意的不可变对象(int str bool tuple…)
- 字典的键是不能重复的，如果出现重复的后面的会替换前面的值
dict1={} # 空字典
dict1={"name":"葫芦娃"} # 字典{"name":"老萝卜"}
dict1={"name":"葫芦娃",} # 字典{"name":"老萝卜"}
dict1={"name":"葫芦娃","sex":"男","age":20} # 字典{"name":"老萝卜","sex":"男","age":20}
dict1={
"name":"葫芦娃",
"sex":"男",
"age":20
}
# dict1={"name":"葫芦娃","sex":"男",age:20} # NameError: name 'age' is not defined
# dict1={"name":"葫芦娃","sex":"男","age"=20} # SyntaxError: invalid syntax
print(dict1["name"],dict1["sex"],dict1["age"]) # 葫芦娃 男 20
- dict()函数创建字典，
- dict(key=value,key=value,…)
- dict(双值子序列）
- 双值序列：序列中有两个值，如 [2,3]、“mn”、(“w”,8)
- 子序列：如果序列中的元素也是序列，那么就称这个元素为子序列
dict1=dict()
dict1=dict(name="葫芦娃",sex="男",age=20)
dict1=dict([("name","葫芦娃"),("sex","男"),("age",20)])
2.3.字典的使用
2.3.1 根据键来获取字典的值,语法： 字典对象[key]
- 如果key是本身key值就需要加引号，如果将key值赋值给变量，就不用加引号
d1={"name":"葫芦娃","sex":"男","age":20}
n="name"
print(d1[n],d1["sex"],d1["age"]) # 葫芦娃 男 20
# print(d1[age] # NameError: name 'age' is not defined
2.3.2. 根据键来获取字典的值,语法：get(key[,default])
- 如果key 不存在，返回None
- 可以指定第二个参数，当key不存在时，返回默认值
d1={"name":"葫芦娃","sex":"男","age":20}
print(d1["name"],d1.get("n"),d1.get("kkk","key不存在")) # 葫芦娃 None key不存在
2.3.3 修改字典: 字典对象[key]=value
- 当key存在时，修改key对应的value值
- 当key不存时，向字典中添加元素
d1={"name":"葫芦娃","sex":"男","age":20}
d1["name"]="钢铁"
d1["phone"]="1890865XXXX"
print(d1) # {"name":"钢铁侠","sex":"男","age":20,"phone": "1890865XXXX"}
2.3.4 修改字典: 字典对象.setdefault(key[,default])
- 如果字典中存在key,返回key的值,不会对字典做任何操作
- 如要字典中不存在key，则向字典中添加key,并设置value
d1={"name":"葫芦娃","sex":"男","age":20}
r=d1.setdefault("name","钢铁侠")
print(r,d1) # 葫芦娃 {"name":"葫芦娃","sex":"男","age":20}
r=d1.setdefault("phone","钢铁侠")
print(r,d1) # 钢铁侠 {"name":"葫芦娃","sex":"男","age":20,"phone":"钢铁侠"}
2.3.5 修改字典: 字典对象.update(字典对象)
- 将其他字典的key-value添加到当前的字典当中
- 如果有重复的key,后面的key的value将前面key的value替换掉
d1={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6}
d1.update(d2)
print(d1,d2) #{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6} {"d":4,"e":5,"f":6}
d1={"a":1,"b":2,"c":3}
d2={"d":4,"e":5,"f":6,"a":8}
d1.update(d2)
print(d1,d2) # {"a":8,"b":2,"c":3,"d":4,"e":5,"f":6} {"d":4,"e":5,"f":6,"a":8}
2.3.5.删除字典: del 字典对象[key]
- 删除字典中的key-value
- 如果key不存在，会报错
d1={"a":1,"b":2,"c":3}
del d1["a"]
del d1["b"]
# del d1["d"] # KeyError: 'd'
print(d1) # {"c":3}
2.3.5.删除字典:字典对象.popitem()
- 随机删除字典中的一个key-value,一般都是删除最一个
- 有返回值的。删除之后它会将删除的元素以元组形式返回
d1={"a":1,"b":2,"c":3}
print(d1.popitem(),d1) # ('c', 3) {'a': 1, 'b': 2}
2.3.5.删除字典:字典对象.pop(key[,default])
- 根据key删除字典中的key-value
- 将删除的value返回
- 可以指定第二个参数，当key不存在时，返回默认值
d1={"a":1,"b":2,"c":3}
print(d1.pop("a"),d1) # 1 {'b': 2, 'c': 3}
# d1.pop("d") # KeyError: 'd'
d1={"a":1,"b":2,"c":3}
print(d1.pop("d","key不存在"),d1) # key不存在 {'a': 1, 'b': 2, 'c': 3}
2.4. 潜复制
- 字典对象.copy() 方法用来对字典进行潜复制
- 复制以后的对象，与原对象是对象独立，修改一个不会影响另一个
- 注意:
- 潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的
- 如果这个值可以是一个可变对象，这个可变对象不会被复制
d1={"a":1,"b":2,"c":3}
d2=d1
d1["b"]=5
print(d1,d2) # {"a":1,"b":5,"c":3} {"a":1,"b":5,"c":3}
print(id(d1),id(d2)) # 39365728 39365728
d1={"a":1,"b":2,"c":3}
d2=d1.copy()
d1["b"]=5
print(d1,d2) # {"a":1,"b":2,"c":3} {"a":1,"b":5,"c":3}
print(id(d1),id(d2)) # 39365728 39366160
d={"a":{"name":"葫芦娃","sex":"男","age":20},"b":2,"c":3}
d2=d.copy()
print(d) # {'a': {'name': '葫芦娃', 'sex': '男', 'age': 20}, 'b': 2, 'c': 3}
print(d2) #{'a': {'name': '葫芦娃', 'sex': '男', 'age': 20}, 'b': 2, 'c': 3}
d2["b"]=200
d2["a"]["name"]="钢铁侠"
print(d) # {'a': {'name': '钢铁侠', 'sex': '男', 'age': 20}, 'b': 2, 'c': 3}
print(d2) #{'a': {'name': '钢铁侠', 'sex': '男', 'age': 20}, 'b': 200, 'c': 3}
print(id(d),id(d2)) # 39365656 39308888
d={"a":[1,2,3,4],"b":2,"c":3}
d2=d.copy()
print(d) # {'a': [1, 2, 3, 4], 'b': 2, 'c': 3}
print(d2) # {'a': [1, 2, 3, 4], 'b': 2, 'c': 3}
print(id(d),id(d2)) # 39366160 39365656
d2["b"]=200
d2["a"][1]="钢铁侠"
print(d) # {'a': [1, '钢铁侠', 3, 4], 'b': 2, 'c': 3}
print(d2) # {'a': [1, '钢铁侠', 3, 4], 'b': 200, 'c': 3}
print(id(d),id(d2)) # 39366160 39365656
d={"a":(1,2,3,4),"b":2,"c":3}
d2=d.copy()
print(d) # {'a': (1, 2, 3, 4), 'b': 2, 'c': 3}
print(d2) # {'a': (1, 2, 3, 4), 'b': 2, 'c': 3}
print(id(d),id(d2)) # 39308888 39366160
d2["b"]=200
d2["a"]="钢铁侠",
print(d) # {'a': (1, 2, 3, 4), 'b': 2, 'c': 3}
print(d2) # {'a': ('钢铁侠',), 'b': 200, 'c': 3}
2.5 遍历字典
- 我们主要可以通过3种方式对字典进行遍历
- keys() 该方法返回字典所有的key
- values() 该方法返回一个序列，序列中保存有字典的值
- items() 该方法会返回字典中所有的项，它返回一个序列，序列中包含有双值子序列，双值分别是 字典中的key和value
d1={"name":"葫芦娃","sex":"男","age":20}
# keys()
print(d1.keys(),type(d1.keys())) # dict_keys(['name', 'sex', 'age']) <class 'dict_keys'>
for k in d1.keys():
print(d1[k])
# values() 该方法返回一个序列，序列中保存所有字典的值
print(d1.values(),type(d1.values())) # dict_values(['葫芦娃', '男', 20]) <class 'dict_values'>
for v in d1.values():
print(v)
# items() 该方法会返回字典中所有的项
print(d1.itmes(),type(d1.itmes())) # dict_values(['葫芦娃', '男', 20]) <class 'dict_values'>
for k,v in d1.itmes():
print(k,"=",v)
3.集合
3.1. 集合简介
- 集合表现形式set 集合和列表⾮常相似
- 不同点
- 集合只能存储不可变对象
- 集合中存储的对象是无序的,即插入时的顺序，与存储的位置无关
- 集合不能出现重复元素
s = {}
print(type(s)) # <class 'dict'>
s = {1,2,3,4}
print(type(s)) # <class 'set'>
s= {6,3,5,2,1,1,1,1,1,1,1}
print(s,type(s)) # {1, 2, 3, 5, 6} <class 'set'>
# s={[1,2,3],[4,5,6]} # TypeError: unhashable type: 'list'
s= {"java","pthon",(1,2,3)}
3.1. 集合创建
3.1.1.使用{元素,元素,…}来创建集合
- {} 这是字典不是集合
3.1.2. set()来将序列和字典转换成集合
- 只能将序列和字典转换成集合
- 将字典转换在集合时，只保留key
# s = set(1,2,3,4) # TypeError: set expected at most 1 arguments, got 4
s = set([1,2,3,4,4,3,2,1) # {1, 2, 3, 4}
s = set([1,2,3,4,]) # {1, 2, 3, 4}
s= set("python") # {'p', 'y', 'h', 'n', 't', 'o'}
s= set({"a":1,"b":2}) #{'b', 'a'}
3.2. 集合的使用
3.2.1 访问集合的值
- 不能通过序号访问集合的值，需要转换后来访问
- 可以通过for 循环来遍历集合
s = {1,3,4,5,6,6,6,1,1,1,2,}
l1= list(s)
print(l1[1])
for i in range(len(s)):
print(l1[i])
for item in s:
print(item)
3.2.2 集合值的数量：len(对象)
s = {1,3,4,5,6,6,6,1,1,1,2,}
print(s,len(s)) # {1, 2, 3, 4, 5, 6} 6
3.2.2 in 和 not in
- 判断元素是否在集合中
s = {1,3,4,5,6,6,6,1,1,1,2,}
print(6 in s,"a" not in s) # True True
3.2.3 集合.add(元素)
- 向字典中增加元素,一次只能添加一个
s = {1,3,4,5,6,6,6,1,1,1,2,}
s.add(50)
s.add(100)
print(s) #{1, 2, 3, 4, 5, 6, 100, 50}
# s.add(101,102) # TypeError: add() takes exactly one argument (2 given)
3.2.3 集合.update(集合)
将一个集合添加到另一个集合中,并会自动排重
s = {1,3,4,5,6,6,6,1,1,1,2,}
prints(s) # {1, 2, 3, 4, 5, 6}
s1 =set("java")
s.update(s1)
print(s,s1) # {1, 2, 3, 4, 5, 6, 'v', 'j', 'a'} {'j', 'a', 'v'}
s=set("python adn js ")
print(s) # {'p', 'y', 'h', ' ', 's', 'n', 'j', 't', 'a', 'o', 'd'}
s1 = set("java")
s.update(s1)
print(s,s1) # {'p', 'y', 'h', ' ', 's', 'v', 'n', 'j', 't', 'a', 'o', 'd'} {'j', 'a', 'v'}
3.2.4 集合.pop()
- 随机删除集合中的一个元素,一般是删除最后一个元素
- 返回被删除元素的值
3.2.4 集合.remove(元素)
- 删除集合中指定的元素,没有返回值
- 元素不存在时，会报错
3.2.4 集合.clear()
- 清空集合
s= set("python")
print(s)
r=s.pop()
print(r,s) # p {'y', 'h', 'n', 't', 'o'}
# s.remove("j") # KeyError: 'j'
r=s.remove("o")
print(r,s) # None {'y', 'h', 'n', 'o'}
s.clear()
print(s) # set()
3.3. 集合的运算
3.3.1 & 交集运算
- 由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集（intersection），记作A∩B。
a = {1, 2, 3, 4}
b = {2, 3, 4, 5}
c = {7, 8, 9}
d = a & b # {2, 3, 4}
e = a & c # set()
3.3.2 | 并集运算
- A和B并集是有所有A的元素和所有B的元素，而没有其他元素的集合。A和B的并集通常写作 "A∪B
a = {1, 2, 3, 4}
b = {2, 3, 4, 5}
c = {7, 8, 9}
d = a | b # {1, 2, 3, 4, 5}
e = a | c # {1, 2, 3, 4, 7, 8, 9}
3.3.3 - 差集运算
a = {1, 2, 3, 4}
b = {2, 3, 4, 5}
c = {7, 8, 9}
d = a - b # {1}
e = a - c # {1, 2, 3, 4}
3.3.4 ^ 异或运算
a = {1, 2, 3, 4}
b = {2, 3, 4, 5}
c = {7, 8, 9}
d = a ^ b # {1, 5}
e = a ^ c # {1, 2, 3, 4, 7, 8, 9}
3.3.5 <= 检查一个集合是否是另一个集合的子集
a = {1, 2, 3, 4}
b = {1, 2, 3, 4}
c = {1, 2, 3}
d = {4, 5, 6, 7}
e = {6, 7, 8}
g = a <= b # True
h = c <= a # True
i = e <= a # False
3.3.6 < 检查一个集合是否是另一个集合的真子集
a = {1, 2, 3, 4}
b = {1, 2, 3, 4}
c = {1, 2, 3}
d = {4, 5, 6, 7}
e = {6, 7, 8}
j = a < b # False
k = c < a # True
l = e < a # False
3.3.7 >=检查一个集合是否是另一个集合的超集
如果一个集合S2中的每一个元素都在集合S1中，且集合S1中可能包含S2中没有的元素，则集合S1就是S2的一个超集，反过来，S2是S1的子集。 S1是S2的超集，若S1中一定有S2中没有的元素，则S1是S2的真超集，反过来S2是S1的真子集。
a = {1, 2, 3, 4}
b = {1, 2, 3, 4}
c = {1, 2, 3}
d = {4, 5, 6, 7}
e = {6, 7, 8}
g = a >= b # True
h = a >= c # True
i = e <= a # False
3.3.8 >检查一个集合是否是另一个集合的真超集
a = {1, 2, 3, 4}
b = {1, 2, 3, 4}
c = {1, 2, 3}
d = {4, 5, 6, 7}
e = {6, 7, 8}
j = a < b # False
k = c < a # True
l = e < a # False
1273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
