元组
元组简介
1.元组表现形式tuple
2.元组是⼀个不可变序列(⼀般当我们希望数据不改变时,我们使⽤元组, 其他
情况下基本都⽤列表)
3.使⽤()创建元素
4.元组不是空元组⾄少有⼀个 逗号(,) 当元组不是空元组时括号可以省略
5.元组解包指将元组当中的每⼀个元素都赋值给⼀个变量
字典
字典简介
字典的基本介绍
1.字典属于⼀种新的数据结构称为映射(mapping)
2.字典的作⽤和列表类似,都是⽤来存储对象的容器
3.列表存储数据的性能好,但是查询数据的性能差,字典正好与之相反
4.在字典中每⼀个元素都有唯⼀的名字,通过这个唯⼀的名字可以找到指 定的
元素
5.这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值
6.字典我们也称之为键值对(key-value)结构
7.每个字典中都可以有多个键值对,⽽每⼀个键值对我们称其为⼀项(item)
8.创建⼀个有数据的字典 语法 {key:value}
9.字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool
tuple....)
10.字典的键是不能重复的,如果出现重复的后⾯的会替换前⾯的
字典的使⽤
1.dict()函数来创建字典
2.get(key[,default]) 根据键来获取字典的值。第⼆个参数可以指定⼀个默认
值,当获取不到值的时候会返回默认值
3.update() 将其他字典的key-value添加到当前的字典当中
4.del 删除字典中的key-value
5.popitem() 删除字典最后的⼀个key-value 这个⽅法是有返回值的。删除之
后它会将删除的key-value作为返回值返回
6.pop(key[,default]) 根据key删除⾃定中的value。第⼆个参数可以指定⼀个
默认值,当获取不到值的时候会返回默认值
copy() ⽅法⽤来对字典进⾏潜复制
注意:潜复制只会复制字典本身,如果字典中还有个字典是不会进⾏复制的
遍历字典
我们主要可以通过3种⽅式对字典进⾏遍历
1.keys() 该⽅法返回字典所有的key
2.values() 该⽅法返回⼀个序列 序列中保存有字典的值
3.items() 该⽅法会返回字典中所有的项 它返回⼀个序列,序列中包含 有双值
⼦序列 双值分别是 字典中的key和value
集合
集合简介
1.集合表现形式set 集合和列表⾮常相似
2.不同点
(1).集合只能存储不可变对象
(2)集合中存储的对象是⽆序的
(3)集合不能出现重复元素
3.使⽤{}来创建集合
4.可以通过set()来将序列和字典转换成集合
5.len() 使⽤len()来获取集合中元素的数量
6.add()像集合中添加元素
7.update()将⼀个集合中的元素添加到另⼀个集合当中
8.pop()随机删除集合中的⼀个元素⼀般是删除最后⼀个元素
9.remove() 删除集合中指定的元素
10.clear() 清空集合
集合的运算
1.& 交集运算
2.| 并集运算
3.- 差集运算
4.^ 亦或集
5.<= 检查⼀个集合是否是另⼀个集合的⼦集
6.< 检查⼀个集合是否是另⼀个集合的真⼦集
7.>=检查⼀个集合是否是另⼀个集合的超集
8.>检查⼀个集合是否是另⼀个集合的真超集
课堂代码练习⼀遍
元组
# tuple ()
my_tuple = (1, 2, 3, 4)
print(my_tuple, type(my_tuple))
print(my_tuple[2])
# 如果元组不是空元组,那么它至少得有一个逗号
tuple1 = (10,)
print(tuple1, type(tuple1))
# len()
# max() , min()
# in not in
# count()
# index()
my_tuple = (1, 2, 3, 4, 5, 6)
# 元组的拆包
a, b, c, d, e = my_tuple 不可以
a, *b, *c, d = my_tuple
print('a', a)
print('b', b)
print('c', c)
print('d', d)
# 在对一个元组拆包的时候,变量的数量和元组中元素的数量要把持一致,
# 如果变量和元素不一致,就可以在变量前面加上一个*,这样会获取元组中剩余的元素,以列表的形式返回
# 字符串拆包
s = 'abcdef'
a, b, *c = s
print(a, b, c)
# 列表拆包
list1 = [1, 2, 3, 4]
a, b, *c = list1
print(a, b, c)
字典的简介和使用
# 列表 字典 [x, x, x,x x, x,x x,x ,x x,x x ]
# {key: value} 可以通过key查询到value这个值, 所以我们也称之为键值对, 每一个键值对我们称呼为一项(item)
# {} dict 字典
d = {}
print(d, type(d))
# 当字典中的key有重复的时候,后面的数据会替换前面的数据
d = {
'name': '刘亦菲',
'age': 18,
'gender': '女神',
'name': '周慧敏'
}
print(d['name'])
d1 = dict(name='刘亦菲', age=18)
print(d1)
# 双值子序列
# 双值序列 [1, 2], (1, 2), 'ab'
# 子序列 ['a'] 数据类型嵌套
# 双值子序列 [(1, 2), (3, 4)]
list1 = [(1, 2), (3, 4)]
d = dict(list1)
print(d)
字典的遍历
d = {
'name': '刘亦菲',
'age': 18,
'gender': '女神'
}
# print(d.keys())
# print(d.values())
# print(d.items())
# for k in d.keys():
# print(d[k])
for k, v in d.items():
print(k, '=', v)
字典的增删改查
d = {
'name': '刘亦菲',
'age': 18,
'gender': '女神'
}
# len()
# print(len(d))
# in not in
# print('刘亦菲' in d)
# print(d['age'])
# get(key, default)
# 如果是没有这个key,返回None,不会报错
# 也可以指定一个默认值,来作为第二个参数,这样获取不到key值的是偶可以返回默认值
# print(d.get('xec'), '你是谁')
# 修改字典
# d[key] = value
# d['age'] = 16
# print(d)
# 没有这个key-value就是添加
# d['height'] = 174
# print(d)
# 添加 setdefault(key, default)
# 如果这个key已经存在于字典中,则返回value值,不会对字典造成影响
# 如果不存在,则向字典中添加key-value
# res = d.setdefault('name', '周慧敏')
# res = d.setdefault('height', 170)
# print(res)
# print(d)
# 添加 update() 讲其他的字典当中的key-value添加到当前的字典中
# d1 = {1: '1', 2: '2'}
# d.update(d1)
# print(d)
# 删除
# del 删除字典中的key-value
# del d['age']
# print(d)
# pop(key, default)
# res = d.pop('height')
# print(res)
# print(d)
# popitem() 随机删除一个键值对,一般都是删除最后一个
# 他会将删除后的键值对作为返回值返回
# res = d.popitem()
# print(res)
# print(d)
# clear() 清空字典
集合的简介
# s = {}
# print(type(s))
# s = set()
# print(s, type(s))
# s = {6, 8}
# a, b = s
# print(a)
# print(b)
# print(s)
# 集合只能存储不可变对象
# 集合中存储的对象是无序的
# 集合不能出现重复元素 # 用集合去做去重的操作
# s = {1, 2, 3, 'sdfb', (1, 2), 1, 2, 3}
# print(s)
# list1 = [1, 2, 3, 4, 4, 3, 2, 1]
# print(list(set(list1)))
s = set()
# in not in len()
# add() 添加元素进集合
s.add(1)
print(s)
# update() 将一个集合中的元素添加到另一个集合中
# s1 = {2, 3, 4, (1, 2)}
# s.update(s1)
# print(s)
# pop() 随机删除
# s.pop()
# # print(s)
# remove() 指定删除元素
# s.remove((1, 2))
# print(s)
# clear()
浅拷贝和深拷贝
d = {
'name': '刘亦菲',
'age': 18,
'gender': '女神',
'friend': {
'name': '唐嫣',
'age': 32
}
}
# 浅拷贝: 第二层数据的id一样, 拷贝之后的对象和原对象id不一样 (第二层的数据只能引用)
# d1 = d.copy()
# print(id(d), id(d1))
# print(id(d['friend']), id(d1['friend']))
# 深拷贝 把所有层次的数据重新拷贝成为一个新的对象
import copy
# 浅拷贝
# d2 = copy.copy(d1)
# print(d2)
d2 = copy.deepcopy(d)
print(id(d), id(d2))
print(id(d['friend']), id(d2['friend']))
# 引用, 浅拷贝, 深拷贝
name = [1, 2, 3, 4, [1, 2, 3]]
b = copy.copy(name)
print(id(name), id(b))
print(id(name[4]), id(b[4]))
a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},
{“src”:“python2”},{“src”:“python3”}]}} 找到
python1/python2/python3
a = {
"name": "123",
"data": {
"result": [
{"src": "python1"},
{"src": "python2"},
{"src": "python3"}
]
}
}
print(a["data"]['result'][0]['src'])
print(a["data"]['result'][1]['src'])
print(a["data"]['result'][2]['src'])
#
有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有⼤于66的值保存
⾄字典的第⼀个key的值中,将⼩于66值保存⾄第⼆个key的值中。
li =[11,22,33,44,55,66,77,88,99,90]
dic={}
list_1 =[] #大于66
list_2 =[] #小于66
for i in li:
if i ==66: continue
if i > 66:
list_1.append(i)
else:
list_2.append(i)
dic.setdefault('k1',list_1)
dic.setdefault('k2',list_2)
print(dic)
s=[11,22,33,44,55,66,77,88,99,90]
# print(s,type(s))
# dic={}
d1=[]
d2= []
for i in s:
if i == 66: continue
if i > 66:
d1.append(i) #这个位置只能用append来添加
# print(list_1)
else:
d2.append(i) #这个位置只能用append来添加
print(d2)
print(d1)