目录
元组（下）
5、元组操作
1.长度（计算元素个数 ）
# len() 计算元素个数
x = (10, 20, "hello", True, 3.14, -7.8)
print(len(x)) # 62.连接
# 连接
# 得到一个新的元组
x = 10, 20
x2 =30, 40
x3 = x + x2
print(x3) # (10, 20, 30, 40)3.复制
# 元组运算符
# 元组重复(复制)
x = (10, 20, 30)
print(x*3) # (10, 20, 30, 10, 20, 30, 10, 20, 30)4.元素是否存在于元组中
# 元素是否存在 in
x = (10, 20, 30)
a = 10
print(a in x) # True5.迭代
# 迭代
x = (10, 20, "hello", True, 3.14, -7.8)
for i in range(len(x)):
print(x[i])6、元组不可变
元组的不可变指的是元组所指向的内存中的内容不可变。
x = (1, 2, 3, 4, 5, 6, 7)
x[1] = 100
print(x) # 报错 'tuple' object does not support item assignment7、元组常用API
-
len(tuple) 返回元组中元素个数
-
max(tuple) 返回元组中元素最大值
-
min(tuple) 返回元组中元素最小值
# len() 返回元组中元素个数
# max() 返回元组中元素最大值
# min() 返回元组中元素最小值
x = 10, 30, 40, 20, 50
print(x) # (10, 30, 40, 20, 50)
print(len(x)) # 5
print(max(x)) # 50
print(min(x)) # 10- tuple(list) 将列表转换为元组
# 未来函数设计可能用到（得到的结果是列表，希望返回多个数据）
x = tuple([10, 20, 30 ])
print(x) # (10, 20, 30)字典（dict）
字典是一种可变容器模型，且可存储任意类型对象。
字典的每个键值对( key:value )用冒号分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中
d = {key1 : value1, key2 : value2, key3 : value3 }
1、创建字典
dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
# 创建字典
"""
dict 作为 Python 的关键字和内置函数，变量名不建议命名为 **dict**。
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字
"""
d1 = {} # 空字典
print(type(d1)) # <class 'dict'>
d2 = dict() # 内建函数dict()创建空字典
print(d1, d2) # {} {}
# 同一字典中键名不能相同
d3 = {"name":"gold",
"price":"10000"}
print(d3) # {'name': 'gold', 'price': '10000'}
print(len(d3)) # 2
print(type(d3)) # <class 'dict'>
# 字典中键值对的键名可以是不可变的数据类型 键值可以是任何数据类型
d5 = {(10, 20):100}
print(d5) # {(10, 20): 100}2、访问字典的值
将相应的键放入到方括号中，如果字典里没有的键访问数据，会输出错误
# 访问字典的值 把相应的键放入到方括号中
d7 = {"name":"小明",
"age":18,
"class":"ai11",
"gender":"male"}
print(d7["name"]) # 小明
print(d7["class"]) # ai11
print(d7.get('name')) # 小明注：和列表中的切片不同，字典的键无论是不是有顺序的数字，都不能切片，只能通过key取值
3、修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
# 修改字典
d9 = {"name":"小明",
"age":18,
"class":"ai11",
"gender":"male"}
d9["gender"] = "female" # 更新信息
d9["school"] = "huaqing" # 添加信息
print(d9["gender"]) # female
print(d9) # {'name': '小明', 'age': 18, 'class': 'ai11', 'gender': 'female', 'school': 'huaqing'}
print(d9["school"]) # huaqing
4、删除字典元素
能删单一的元素也能清空字典，清空只需一项操作
显式删除一个字典用del命令
# 删除字典元素
d10 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del d10['Name'] # 删除键 'Name'
print(d10) # {'Age': 7, 'Class': 'First'}
d10.clear() # 清空字典
print(d10) # {}
del d10
# print(d10) # NameError: name 'd10' is not defined
5、字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
# 字典键的特性
"""
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
"""
d11 = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
print (d11['Name'])
mydic1 = {97:"a",98:"b"}
mydic2 = {"name":"karen","age":27}
mydic3 = {['Name']: 'karen', 'Age': 27}
print(mydic3[['Name']]) # 报错 unhashable type: 'list'6、字典常用API
-
len(dict) 计算字典元素个数，即键的总数。
-
str(dict) 输出字典，可以打印的字符串表示。
x = {1:20,
9:20,
"name":"jack",
True:1234123}
print(x) # {1: 1234123, 9: 20, 'name': 'jack'}
print(len(x)) # 3
# str(dict) 输出字典，可以打印的字符串表示
q = str(x)
print(q, "111",type(q)) # {1: 1234123, 9: 20, 'name': 'jack'} 111 <class 'str'> # 网络传输时很有用
-
dict.copy()返回一个字典的浅复制
# dict.copy() 返回一个字典的浅复制
x = {1:20,
9:20,
"name":"jack",
True:1234123,
"vip":False,
"books":["book1", "book2"]}
x2 = x.copy()
x2[1] = 9999 # 通过索引访问
x2["books"][0] = 999 # 通过key访问
x2["books"] = [10, 20, 30]
print(x) # {1: 1234123, 9: 20, 'name': 'jack', 'vip': False, 'books': [999, 'book2']}
print(x2) # {1: 9999, 9: 20, 'name': 'jack', 'vip': False, 'books': [10, 20, 30]}
-
dict.fromkeys(seq)创建一个新字典
# dict.fromkeys(seq)创建一个新字典
# 以序列seq中元素做字典的键，val为字典所有键对应的初始值
keys = range(5)
x = dict.fromkeys(keys)
print(x) # {0: None, 1: None, 2: None, 3: None, 4: None}
x[0] = 100
print(x) # {0: 100, 1: None, 2: None, 3: None, 4: None}
-
dict.get(key, default=None)返回指定键的值，如果键不在字典中则返回 default 设置的默认值
# dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
x = {0: 100, 1: None, 2: None, 3: None, 4: None}
age = x.get(0, 100)
print(age) # 100-
dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
# dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
x.setdefault("name","jack")
print(x) # {0: 100, 1: None, 2: None, 3: None, 4: None, 'name': 'jack'}
# 推荐使用下面的方法修改和添加键值
x[1] = 999
x["name"] = "ross"
print(x) # {0: 100, 1: 999, 2: None, 3: None, 4: None, 'name': 'ross'}- dict.update(dict2) 把字典dict2的键/值对更新到dict里
x = {1:200, 2:300}
y = {3:123, 4:234, 1:321}
z = x.update(y)
print(z) # None
print(x) # {1: 321, 2: 300, 3: 123, 4: 234}-
key in dict如果键在字典dict里返回true，否则返回false
x = {1:100, 2:200, 3:300}
k = 1 # 键
k2 = 100 # 值
re = k in x
re2 = k2 in x
print("re:",re,"re2:",re2) # re: True re2: False
-
dict.keys()返回一个视图对象
x = {"name":"jack",
"age":20,
"vip":False}
print(x) # {'name': 'jack', 'age': 20, 'vip': False}
obj = x.keys() # dict_keys(['name', 'age', 'vip'])
print(obj)
for el in obj:
print(el) # name age vip-
dict.items()以列表返回一个视图对象
obj3 = x.items()
print(obj3) # dict_items([('name', 'jack'), ('age', 20), ('vip', False)]) # 元组形式
for el in obj3:
print(el) # ('name', 'jack') ('age', 20) ('vip', False)
for el in obj3:
k,v = el
print(k,v, "123321") # name jack 123321 age 20 123321 vip False 123321
-
pop(key,default)删除字典 key（键）所对应的值，返回被删除的值
x = {"name":"jack",
"age":20,
"vip":False}
d = x.pop("vip")
# 不能删除不存在的键名
print(x) # {'name': 'jack', 'age': 20}
print(d) # False-
popitem() 返回并删除字典中的最后一对键和值
# 若没有键值对了则不能调用
x.popitem()
print(x) # {'name': 'jack'}集合（set）
集合（set）是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
# 集合 集合（set）是一个无序的不重复元素序列。
s = {"hello", 3.14, (10, 20, 30)} # 集合中可以保存不可变数据
print(s) # {3.14, 'hello', (10, 20, 30)}
s3 = {10, 20, 10} # 可以写入多个相同的数据 但最后只会保存一次
print(s3) # {10, 20}1、创建集合
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
# 创建集合 set
# 集合可以去除列表中重复的元素 且集合中元素是无序的
s4 = set({10, 20, 30, 40})
print(s4) # {40, 10, 20, 30}
s5 = set([10, 20, 30, 40])
print(s5) # {40, 10, 20, 30}
s6 = set((10, 20, 30, 40))
print(s6) # {40, 10, 20, 30}
s7 = set([100, 200, 300, 100])
print(s7) # {200, 100, 300}
# 空字典
s8 = {}
print(s8,type(s8)) # {} <class 'dict'>
# 空集合
s9 = set()
print(s9, type(s9)) # set() <class 'set'>
2、添加元素
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
- s.add( x ) 添加元素到集合
# s.add( x ) 添加元素到集合
s10 = {10, 20, 30}
x = 40
# x = [10, 20, 30] # 列表不能直接添加到集合中
s10.add(x)
print(s10) # {40, 10, 20, 30}
s10.add("x")
print(s10) # {40, 'x', 10, 20, 30}
- s.update( x ) 添加元素到集合，且参数可以是列表，元组，字典等 ,x 可以有多个，用逗号分开
# s.update( x ) 添加元素到集合，且参数可以是列表，元组，字典等
# 可以有多个数据容器，用逗号分开
s11 = {10, 20, 30}
s11.update([10, 20, 30, 40])
print(s11) # {40, 10, 20, 30}
s11.update(("hello", "xixi"))
print(s11) # {40, 10, 'hello', 20, 'xixi', 30}
s11.update([50, 60], (8, 9))
print(s11) # {40, 8, 10, 9, 'xixi', 50, 20, 'hello', 60, 30}
3、移除元素
- s.remove( x ):将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
# s.remove(x):将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
s12 = {1, 2, 3, 4, 5}
s12.remove(3)
print(s12) # {1, 2, 4, 5}- s.discard( x ):将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。
# s.discard(x):将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误
s12.discard(1)
s12.discard(10)
print(s12) # {2, 4, 5}- s.pop():对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除
# s.pop():对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除
x = s12.pop()
print(x) # 1
print(s12) # {2, 3, 4, 5}
扫一扫
1835
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
