第五天

第一部分 元组

"""
元组：戴了枷锁的列表，对于不可变元素来说， 是不能改的。
元组存在的意义：为了保护数据不被更改
"""

一、创建元组
# 创建普通元组：
# 可以使用小括号，也不可以不使用
a=(1,2,3)
b=1,2,3,"abc"
print(a,b)
print(type(a),type(b))
# 创建一个元素的元组，创建0个元素的元组
c=("abc",)
d="abc",
print(c,type(c))
print(d,type(d))
# 创建0个元素的元组
e=()
# 虽然0个元素()，注意的是不能用不加括号的方式声明0个元组，可以声明一个元组变量
li=[]
print(e,type(e))

# 不能省略小括号
"""
1. 创建0个元组的时候不省略小括号
2. 元组有嵌套的时候
3. 元组作为表达式一部分，参与运算的时候，不能省略
"""

# f=((1,2,3),(1),33)
# f1=(1,2,3),(1),33
# f1=1,2,3,1,33
g=(1,2)+(3,5)
print(g)
g1=1,2+3,5
print(g1)


二、元组的操作
1. 运算符 +  *  in  not in  is  is not  <  >  ==
# print((1,2)+(4,5),"abc")
print((1,2)+(4,5),("abc",))
print((1,2)*3)
k=(1,2)
k1=(1,2)

# 跟列表类似，创建了两个对象，只不过对象中指定的是不可变类型元素
print(k is k1)
print((1,2) is (1,2))
# 原因是因为元组、列表，对象，占内存
i=0
i1=0
print(i is i1)
print("abc" is "abc")

print("a" in ('a','b','c',(1,2)))
print(1 in ('a','b','c',(1,2)))

2. 索引
t=(1,2,3,4,5)
print(t[0])
print(t[-1])
# print(t[-100])

3. 切片
print(t[1:3])
print(t[1:3:2])

4. 遍历
for i in t:
    print(t)
t=("1",2,(1,2))
for i in t:
    if type(i)==list or type(i)==tuple:
        for j in i:
            print(j)
    else:
        print(i)

# 列表可以被修改，元组是不能被修改的(元组的元素，不是可变类型元素中的元素）
t=("1",2,(1,2))
t1=("1",2,[1,2])
# t[0]="dd"
t1[2][0]="ddd"
print(t1)

# 如果真的希望修改元组，可以使用拼接+的方式
t=t[:2]+("ddd",)+t[2:]
print(t)

# 切片 整切片跟字符串是一样的。
t2=t[:]   #不会新建对象
t3 = t[:3]  # 才会新建一个对象
print(t is t2)
print(t is t3)


三、 支持的方法
1. count
t=(1,2,3,4,5,1,1)
print(t.count(1))
# 只有字符串的count有start和end

2. index：首次出的索引,index中的参数是内容
print(t.index((1)))
# start和end：包含start不包含end

四、 元组的推导式
b=(i+1 for i in t )
# 元组的推导式产生的生成器
print(b)
for i in b:
    print(i)



"""
总结 序列：字符串、字节、列表、元组
1. 序列的特点
   （1）使用索引
   （2）使用切片
   （3）都有共同的操作符
   （4）都可以是迭代对象
   （5）使用len获得长度
   
2. 序列的转换类别的相关方法：
   （1）list（序列）：将序列转换成列表
   （2）tuple（序列）：将序列转换成元组
   （3）str（序列）：将序列转换成字符串（用途有限）
   （4）bytes（序列）：转成字节：只能把字符串转换成字节，指定编码集，不能转换列表和元组
   （5）max（序列）：最大值
   （6）min（序列）：最小值
   （7）sum（序列）：求和
   （8）sort（序列）：排序，两种，就地排序list，sorted内置方法（可以对任何迭代对象进行排序）
"""
s="abc"
t=(1,7,2,3,4)
li=[1,3,3,4,"a"]
li1=["a","b"]
by=b"abcde"
print(list(s))
print(list(t))
print(list(by))

print(tuple(s))
print(tuple(li))
print(tuple(by))

print(str(li))
print(str(t))
print(str(by))

print(bytes(s,encoding="utf-8"))
# bytes使用时对列表只能转换数值类型元素
# print(bytes(["-",2]))
# print(bytes(t))

# max比较的时候，不能把不同类型元素放在一起求max，min
print(max(by))
print(max(li))
print(max(t))
print(max(s))

print(sum(by))
print(sum(li))
print(sum(t))
print(sum(s))

# 列表有排序，li类型下排序
# li.sort()

# sorted 内置方法可以对序列进行排序，不是就地排序，新建对象进行排序
# sorted的返回值是列表
# reverse，key使用方法跟list.sort()方法一致
li=[1,2,444,55,6]
li.sort()
print(li)
sorted(li)
print(li)
print(sorted(li))
print(sorted(li,reverse=True))
print(sorted(t))
print(sorted(by))
print(sorted(s))

# 所有的方法元素必须合理，才可以进行比较

第二部分 字典

"""
字典：键  值dict
说明：字典是无序的，key不能重复，key必须是不可变类型（必须是可hash的对象）

"""
names=["michael","kate",'bob']
scores=[100,88,60]
# 1. 先遍历names找的kate，获得kate的位置
# 2.遍历scores根据1的位置，返回score
# 存储两个列表互相有相关的数据时，浪费资源

一、字典的定义
# 格式：
# s={键:值，}
s={"machael":100,"kate":88,"bob":60}

# 字典根据key键可以快速的定位到值
# 字典的原理    页码----汉字
# [key---通过hash函数---hashcode]---汉字（值）
# 60%7=
# 对hashcode进行编码，遇到重复，一定会找到不同，唯一的hashcode
# s={"d":[1,2,3,4,5]}
print(s)
print(type(s))

# 其他的定义方式
s1=dict(michael=100,kate=80,bob=60)
print(s1)
print(type(s1))

# 字典key和value的访问和修改
# 字典因为无序，所以不能索引也没有切片
# 可以根据key获得value
print(s1["kate"])
s1["kate"]=88
print(s1)

# 如果key不存在，这个时候，不是获得，而是追加
# s1["bb"] #如果是以获取value为目的，不赋予值，如果key不存在，会报错
s1["aa"]=99
print(s1)

# 字典的存储结构
# 定义的时候，出现了相同key，会覆盖，只保留最后的value
s2={"tom":80,"tom":90,"jerry":100}
print(s2)


二、运算
1. 运算符   不支持+  *  <  >
#         支持 ==  is    in（key）
s={"michael":100,"kate":88,"bob":60}
s1={"michael":100,"kate":88,"bob":60}
s2=s
print("michael" in s)
print(s is s1)
print(s is s2)

三、 相关方法
1. 追加相关
 formkeys:创建同值，不同键的字典
d={}
# key只能放字符串、元组
# 不加值value会生成value都是None的字典(set的原理）
d1=d.fromkeys((1,2,3))
print(type(d1))
d2=d.fromkeys(('a','b'),"nu")
d2=d.fromkeys(('a','b'),["nu",1,2])
print(d2)

 setdefault(key,value)
# 如果key不存在，会追加一个value为none的键值对
print(d.setdefault((4)))
print(d)
# 如果设定了对于value，key-value键值对
print(d.setdefault(5,"aa"))
print(d)
#如果key已经存在了，什么都不会改变（重要）
d.setdefault(4,100)
print(d)
# 使用key访问的形式可以覆盖
d[4]="100"
print(d)

update方法：追加字典的key和value：优势在于一次可以加多个键值对
# 原地进行修改
a={1:"中",2:"b",3:122}
b={4:"中国的"}
a.update(b)
print(a)

2. 删除相关
pop删除指定的键值对，同时返回该键值对中的值
print(a.pop(1))
print(a)

popitem 随便删一个键值对，返回被删除的键值对
a.popitem()
print(a)

clear 清空字典
a.clear()
# del a
print(a)

3. 获取
get方法
a={1:"中",2:"b",3:122,5:[1,2]}
# print(a[4])  # 使用key value形式访问没有的键， 会报错
print(a.get(1))  #如果键不存在，不会报错，返回None


4. 复制
b=a.copy()
a[1]="new"
a[5][0]="dd"
print(a)
print(b)
print(id(a[5]))
print(id(b[5]))
print(id(a[1]))
print(id(b[1]))

5. 遍历
# keys：返回字典中的所有键
# values：返回字典中的所有值
# items：返回字典中的键值
for k in a.keys():
    print(k)
for v in a.values():
    print(v)
for k,v in a.items():
    print(k,v)
for kv in a.items():
    print(type(kv))
    print(kv[0],kv[1])


# 字典推导式，快速创建新字典
c=range(8)
d={i:i*2 for i in c}
print(d)

第三部分 集合

"""
集合set
都是字典的key
说明：set的元素不可重复，无序，不可变类型
"""
一、集合的定义：
s={1,2,3,4,5,5}
print(s,type(s))
s1=set([1,2,3,4,5,6])
print(s1,type(s1))
# 创建空的集合，不能使用{}，{}是空字典
a=set()
print(a,type(a))

# len获得长度
print(len(a))

二、集合的运算
1. 运算符  没有 +  *
# in  is
a={1,3,4,5}
b={1,3,4,5}
c=a
print(a is b)
print(a is c)

2. 差集、并集、交集
a={"a","b","c","d","e"}
b={"g","b","c","r","e","h"}
# 差集， a-b去掉a里面跟b重复的元素
print(a-b)
print(b-a)
# 并集 和并两个集合 | 去掉重复的元素
print(a|b)

# 交集，&
print(a&b)

# 与非 两个集合中不是同时出现的元素（除了交集以外的元素）
print(a^b)

三、集合的方法
1. 添加add
s={1,2,3,4}
s.add("444")
s.add("444")  #如果添加重复元素，则不再添加
print(s)

2. 删除 
remove删除，如果元素不存在会报错
s.remove(3)
print(s)
# s.remove(66)

s.discard()  用法跟remove类型，如果不存在不会报错
s.discard()

pop 随机删除，返回被删除的对象元素
print(s.pop())

clear：删除所有元素
s.clear()
print(s)

3. 复制
s={1,2,3,4}
s1=s.copy()
s2=s
print(s is s1)

# 方法也可以求差集、交集、并集
a={"a","b","c","d","e"}
b={"g","b","c","r","e","h"}
# 获得差集（新创建的集合）.difference()
print(a.difference(b))
print(a-b)
print(a,b)

# 差集会修改原来的集合 .difference_update()原地修改
a.difference_update(b)
print(a)

# sort原地  sorted新建列表进行修改

# 交集a.intersection()  新创建集合
a={"a","b","c","d","e"}
b={"g","b","c","r","e","h"}
print(a.intersection(b))
print(a&b)
a.difference_update(b)
print(a)

# 交集a.intersection_update() 原地修改
a={"a","b","c","d","e"}
b={"g","b","c","r","e","h"}
# 并集a.union()
# union合并集合，当前集合不发生改变，返回集合，跟|一样，去重复
print(a.union(b))
print(a|b)

# a.update()改变当前的集合，也是合并（跟字典的update）
a.update(b)
print(a)

# 与非 返回不同时在两个集合中存在的元素（除了交集以外的元素）
a={"a","b","c","d","e"}
b={"g","b","c","r","e","h"}
print(a.symmetric_difference(b))
print(a^b)
a.symmetric_difference_update(b)
print(a)

# 判断交集是否为空True  False
print(a.isdisjoint(b))
# 判断当前的集合是不是另外一个集合的子集
c={"a"}
print(c.issubset(a))

# 判断当前集合是不是另外一个集合的父集
print(a.issuperset(c))
四、集合的遍历
for i in a:
    print(i)

五、集合推导式
a={"a","b","c","d","e"}
print({i+"d" for i in a })

# 集合和字典之间的数据转换
# set(seq):转换一个集合
# dict（键值对形式的序列）：转换成字典
d=dict(a=1,b=2,c=3)