Python（IT峰）笔记07-数据类型详解-元祖的定义与操作，元祖推导式，元祖生成器，yield关键字，字典及定义，字典所支持的操作，zip研所函数，dict转型，字典函数，集合，冰冻集合，集合推导

1、元祖的定义

一组有序数据的组合，元祖一旦定义不可修改，是不可变数据类型

定义空元祖

变量=（）
变量=tuple（）
变量=（内容1，内容2，内容3，……）直接赋值
特列：变量=内容1，内容2，内容3，……

元祖不可改变新，只能使用索引进行访问，不能改变，只读不写
元祖的操作
定义元祖是，如果只有一个元素也要使用逗号分割

mytuple=(1,)

元祖也可以使用切片来访问元祖元素，当列表处理就好

mytuple=(1,3,5,7,9,3,4,5,67,98,8)
print(len(mytuple))#11
res1=mytuple[1:5]
print(res1)#(3, 5, 7, 9)
res2=mytuple[1:10:2]
print(res2)#(3, 7, 3, 5, 98)

统计元素出现的次数，count（）

mytuple=(1,3,5,7,9,3,4,5,67,98,8)
res=mytuple.count(3)
print(res)#2

查找特定元素在元祖的索引值

mytuple=(1,3,5,7,9,3,4,5,67,98,8)
res=mytuple.index(98)
print(res)#9
res=mytuple.index(5,2,9)#从第三个到第10个元素查找元素5的位置
print(res)#2

元祖的加法运算（合并运算），乘法运算，赋值n次

mytuple1=(1,3,5,7,98)
mytuple2=(67,98)
res=mytuple1+mytuple2
print(res)#(1, 3, 5, 7, 98, 67, 98)
res=mytuple1*3
print(res)#(1, 3, 5, 7, 98, 1, 3, 5, 7, 98, 1, 3, 5, 7, 98)

in 运算

mytuple1=(1,3,5,7,98)
res=3 in mytuple1
print(res)#True

2、元祖的推导式

元祖推导式产生的是生成器（generate）
语法：
（变量运算 for item in 容器）：返回一个元祖生成器
生成器是一个特殊的迭代器，生成器可以自定义，也可以使用元祖推导式去定义。

生成器是按照某种算法去推算下一个数据或结构，只需要往内存中存储一个生成器
生成器语法：
1、里面是推导式，外面是一个（），结果就是一个生成器
2、自定义生成器，含有yield关键字的函数就是生成器，含有yield关键字的函数，返回的结果就是一个迭代器，换句话说，生成器函数就是一个返回迭代器的函数

mytuple1=(1,3,5,7,98)res=(item**2 for item in mytuple1)
print(res)#<generator object <genexpr> at 0x000001FD90722CF0>返回的是生成器
#生成器是迭代器的一种可以使用for循环来操作
# for item in res:
#   print(item)#也可以使用next来操作
# print(next(res))
# print(next(res))
# print(next(res))
# print(next(res))
# print(next(res))#还可以使用list来操作
print(list(res))#[1, 9, 25, 49, 9604]

3、元祖的生成器yield关键字

yield关键字使用在生成器函数中，
yield和函数中的return很像
yield函数和return一样，执行到这个关键字后，会把结果返回。
和return不一样，yield会返回结果，并记住当前代码的执行位置，下一次调用时会从上一次离开的位置继续向下执行。而return是重新执行

执行过程：
1、第一次调用迭代器
走到当前的生成器函数中，遇到了yield1，把1返回，并且记住当前的执行状态（位置），暂停执行，等待下一次的调用
2、第二次去调用迭代器
从上一次遇到的yield位置开始执行，遇到了yield2，把2返回，并记住状态，暂停执行，等待下一次调用
3、第三次去调用迭代器
从上一次遇到的yield位置开始执行，遇到yield3，把3返回，并记住了状态，暂停执行，等待下一次调用
如果在最后有调用了迭代器，会从上一次的yield位置开始，后面没有了，直接超出范围，报错

def myyield():print('hello')yield 1print('world')yield 2res=myyield()
print(list(res))for item in res:print(item)

4、字典及定义

键值对
键不能重复
字典中的键必须是不可变的数据类型，主要是字符串，整形
定义方法：
方法1：
vardict={‘a’：1，‘b’：2}
方法2：
vardict={name=‘zhangsan’， age=34，address=‘beijing’}

5、字典所支持的操作

list（d）
len（d）
d [key]:字典中的key
+操作：字典不可以做+操作
*操作：也不可以乘法复制操作

修改元素的复制操作

dict[‘key’]=value

删除元素

del dict[‘key’]

添加元素
dict[‘newkey’]=value
字典中的key重复了会被覆盖
成员检测
只能检测key不能检测value

vardict1=[1,2,3,4]
vardict2=['a','b','c','d']
vardict3=zip(vardict1,vardict2)
print(vardict3)#zip对象，需要使用dict来进行转换
vardict4=dict(vardict3)
print(vardict4)#{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
res=1 in vardict4
print(res)

获取当前字典的长度，只能检测有多少个键值对

res=len（vardict）

keys（）获取当前字典的所有key，返回列表
values()获取当前字典所有的value，返回列表
items()获取当前字典所有的键值对

vardict={'name':'zhangsan','age':23,'address':'beijing'}
res=vardict.keys()
print(res)#dict_keys(['name', 'age', 'address'])
res=vardict.values()
print(res)#dict_values(['zhangsan', 23, 'beijing'])
res=vardict.items()
print(res)#dict_items([('name', 'zhangsan'), ('age', 23), ('address', 'beijing')])

对字典的遍历，遍历出key，value

vardict={'name':'zhangsan','age':23,'address':'beijing'}
for key in vardict:print(key)#name age addressprint(vardict[key])#name zhangsan，age 23，address beijing
for key,value in vardict.items():print(key,value)#name zhangsan，age 23，address beijing

6、zip压缩函数，dict转类型

vardict1=[1,2,3,4]
vardict2=['a','b','c','d']
vardict3=zip(vardict1,vardict2)
print(vardict3)#zip对象，需要使用dict来进行转换
vardict4=dict(vardict3)
print(vardict4)#{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

7、字典相关函数

iter（d）：返回以字典的键为元素的迭代器，注意只能拿到键

vardict={'name':'zhangsan','age':23,'address':'beijing'}
res=iter(vardict)
print(list(res))#['name', 'age', 'address']

clear（）：移除字典算有元素
pop（‘key’）：如果key存在于字典中则将其元素移除并返回其值，否则返回default
popitem（）：从字典中移除最后一个元素（后进先出），如果字典为空则会报错

vardict={'name':'zhangsan','age':23,'address':'beijing'}
res=vardict.popitem()#默认删除最后一个元素
print(res)

获取字典元素

get（‘key’）获取字典的元素，存在则返回，不存在默认返回null

vardict={'name':'zhangsan','age':23,'address':'beijing'}
res=vardict.popitem()#默认删除最后一个元素
print(res)
print(vardict['name'])#zhangsan
print(vardict.get('name'))#zhangsan

update（otherdict）使用来自other字典的兼职更新字典，覆盖原有的键，返回none

vardict={'name':'zhangsan','age':23,'address':'beijing'}
vardict2={'name':'lisi','age':34}
vardict.update(vardict2)#{'name': 'lisi', 'age': 34, 'address': 'beijing'}
print(vardict)

vardict={'name':'zhangsan','age':23,'address':'beijing'}
vardict2={'name':'lisi','age':34,'address':'henan','gender':'female'}
vardict.update(vardict2)#{'name': 'lisi', 'age': 34, 'address': 'henan', 'gender': 'female'}
print(vardict)

setdefault（‘key’）设置默认值（实际也是添加值）

如果字典存在key，返回他的值，如果不存在，插入值为default的键key，并返回default，default默认值为none

vardict={'name':'zhangsan','age':23,'address':'beijing'}
res=vardict.setdefault('gender','female')
print(res)#female
print(vardict)#{'name': 'zhangsan', 'age': 23, 'address': 'beijing', 'gender': 'female'}

8、字典推导式

把字典的键、值交换
传统方法：

vardict={'name':'zhangsan','age':23,'address':'beijing'}
newdict={}
for k,v in vardict.items():newdict[v]=k
print(newdict)

推导式方法

vardict={'name':'zhangsan','age':23,'address':'beijing'}
newdict={v:k for k,v in vardict.items()}
print(newdict)

9、集合

确定的一组无序的数据的组合
确定指的是集合元素的值不能重复
有多个数据组合的复合型数据
集合中的数据没有顺序
功能：成员检测，从序列中去重，数学中的集合类计算，交，并，差对称差集等

10、集合的定义

使用{ }定义集合
使用set（）进行集合的定义和转换
使用集合推导式完成集合的定义
集合的元素不能重复，集合中存放的数据大多数是Number，String，tuple，冰冻集合(frozenset)(不可改变的集合）

11、集合的基本操作

len（）
遍历
add追加
pop删除
remove删除
discard删除
clear（）清除
update更新
copy（）浅拷贝

varset={12,'abc',True,0,3.1548}
print(varset)#{0, True, 3.1548, 12, 'abc'}无序打印
res1=len(varset)
print(res1)#5
for item in varset:print(item)#遍历
#追加元素
varset.add('zhangsan')
print(varset)#{0, True, 3.1548, 12, 'abc', 'zhangsan'}
#删除集合元素
print('---')
varset.pop()#随机删除集合元素
print(varset)#{True, 3.1548, 12, 'zhangsan', 'abc'}
#删除指定元素,remove了不存在的元素则报错
varset.remove('abc')
print(varset)#{True, 3.1548, 12, 'zhangsan'}
print('---')
#删除指定元素,discard了不存在的元素则也不报错
varset.discard(True)
varset.discard('lisi')
print(varset)#{3.1548, 12, 'zhangsan'}
#clear()清空所有元素
varset.clear()
print(varset)#set()
#update()更新集合元素,会去重
varset.update({9,34,5,'maba'})#{9, 34, 5, 'maba'}
print(varset)
print('---')
#copy()返回集合的浅拷贝
res=varset.copy()
print(res,id(res))#{9, 34, 'maba', 5} 2250146902080
print(varset,id(varset))#{9, 34, 'maba', 5} 2250146902304

12、冰冻集合

只能使用，一旦定义，不能修改
frozenset（）实质就是一个强制转换函数，可以将任何容器类型的数据转换为冰冻集合
可以做遍历等操作
冰冻集合可以和普通集合一样，进行结合的运算，交并补集等

#冰冻集合，冰冻集合
varset={12,'abc',True,0,3.1548}
res=frozenset(varset)
print(res)
#res.add('zhangsan')#报错

13、集合推导式

#一般集合推导式
varset={12,45,5,0,3.1548}
res=(item**2 for item in varset )
for item in res:print(item)
print('---')
#带判断条件的集合推导式
res=(item*5 for item in varset if item>5)
for item in res:print(item)

结果：

0
9.952763039999999
25
144
2025
---
60
225

多循环推导式

#多循环集合推导式
varset1={1,2,3}
varset2={5,6,7}
newset={i+j for i in varset1 for j in varset2}
print(newset)#{6, 7, 8, 9, 10}

多循环带条件推导式

#多循环带条件集合推导式
varset1={1,2,3,4}
varset2={5,6,7,8,9}
newset={i+j for i in varset1 for j in varset2 if i%2==0 and j%2==1}
print(newset)#{9, 11, 13, 7}

14、集合的运算符号

对称差集：对称的那个差集

超集，子集，就是包含与被包含的关系，父子集合的关系

&交
|并
-差
^对称差集

varset1={'张三','李四','王二','马八','赵倩','晓峰','扫地僧','四大恶人'}
varset2={'乔峰','马夫人','全冠清','段誉','王语嫣','慕容复','扫地僧','四大恶人'}
#求交集 &
res= varset1 & varset2
print(res)#{'四大恶人', '扫地僧'}，ps：set()是空集合的意思#求并集 | 会去重
res=varset1 | varset2
print(res)#{'赵倩', '马八', '王二', '张三', '马夫人', '全冠清', '段誉', '四大恶人', '乔峰', '王语嫣', '慕容复', '李四', '扫地僧', '晓峰'}#差集运算 -
res=varset1-varset2
print(res)#{'赵倩', '马八', '张三', '王二', '李四', '晓峰'}
res=varset2-varset1
print(res)#{'马夫人', '全冠清', '段誉', '乔峰', '王语嫣', '慕容复'}#对称差集使用 ^
res= varset1^varset2
print(res)#{'慕容复', '段誉', '马八', '乔峰', '王语嫣', '马夫人', '张三', '晓峰', '全冠清', '赵倩', '李四', '王二'}

15、集合的运算函数

交集：
setinteraction（）有返回值
intersection_update（）返回给第一个集合

varset1={'张三','李四','王二','马八','赵倩','晓峰','扫地僧','四大恶人'}
varset2={'乔峰','马夫人','全冠清','段誉','王语嫣','慕容复','扫地僧','四大恶人'}#交集运算函数 set.intersection()
res=varset1.intersection(varset2)
print(res)#{'四大恶人', '扫地僧'}
#相交运算并赋值给第一个集合intersection_update()
varset1.intersection_update(varset2)
print(varset1)

并集
union()返回新的集合
update()没有返回值，直接修改第一个集合

varset1={'张三','李四','王二','马八','赵倩','晓峰','扫地僧','四大恶人'}
varset2={'乔峰','马夫人','全冠清','段誉','王语嫣','慕容复','扫地僧','四大恶人'}#并集 union()返回新的集合 update()没有返回值，直接修改第一个集合
print('--')
res=varset1.union(varset2)
print(res)
print('--')
res=varset1.update(varset2)
print(varset1)

差集
difference（）返回一个集合
difference_update()返回给第一个集合

varset1={'张三','李四','王二','马八','赵倩','晓峰','扫地僧','四大恶人'}
varset2={'乔峰','马夫人','全冠清','段誉','王语嫣','慕容复','扫地僧','四大恶人'}res=varset1.difference(varset2)
print(res)#{'李四', '赵倩', '晓峰', '张三', '王二', '马八'}
res=varset1.difference_update(varset2)
print(varset1)#{'李四', '赵倩', '晓峰', '张三', '王二', '马八'}

对称差集
symmetric_difference（）返回一个集合
symmetric_difference_update()返回给第一个集合

varset1={'张三','李四','王二','马八','赵倩','晓峰','扫地僧','四大恶人'}
varset2={'乔峰','马夫人','全冠清','段誉','王语嫣','慕容复','扫地僧','四大恶人'}res=varset1.symmetric_difference(varset2)
print(res)#{'王二', '全冠清', '慕容复', '李四', '晓峰', '王语嫣', '马八', '段誉', '马夫人', '赵倩', '乔峰', '张三'}
res=varset1.symmetric_difference_update(varset2)
print(varset1)#{'王二', '全冠清', '慕容复', '李四', '晓峰', '王语嫣', '马八', '段誉', '马夫人', '赵倩', '乔峰', '张三'}

检测超级和子集
超集：issuperset()
子集：issubset()

varset1={1,2,3,4,5,6,7,8,9}
varset2={3,4,5,7}
#检测是否为超级
res=varset1.issuperset(varset2)
print(res)#True
#检测是否为子集
res=varset2.issubset(varset1)
print(res)#True

检测是否相交

varset1={1,2,3,4,5,6,7,8,9}
varset2={3,4,5,7}
#检测是否不相交
res=varset1.isdisjoint(varset2)
print(res)#False