2020-11-27

元组

元组简介

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)