2-18python元组&字典&集合

元组
定义：        （）
类型：tuple
元组是不可变的（定义好元组后不能够直接去修改元组中的元素）
t=()                         # 定义一个元组
print(t)              #()
print(type(t))   #     打印t的类型

如果元组中的元素只有1个的时候，一定要在后面加上一个逗号，
如果不加, 原始元素是什么类型它就是什么类型
t1=(1)
print(type(t1))        #
#加了,所以是元组
t2=(1,)
print(type(t2))         #

给元组中增加元素
t=(1,2,3,4,5,6)   #定义一个元组
print(type(t))   #
t1=list(t)       # 通过list把t元组转换成为列表t1
print(type(t1))   #
t1.append("hello")     # 往列表中插入一个hello 元素
print(t1)         #[1, 2, 3, 4, 5, 6, 'hello']
t2=tuple(t1)       # 通过tuple将列表t1转换为元组t2
print(type(t2))    #
print(t2)          #(1, 2, 3, 4, 5, 6, 'hello')

数据类型转换
字符串转换为列表
通过list把字符串转换为列表
a="12345"           # 定义一个字符串
a1=list(a)          #    通过list 将a 转换为列表a1
print(type(a1))     #
print(a1)            #['1', '2', '3', '4', '5']

字符串转换元组
通过tuple  把字符串转换为元组
a="12345"           # 定义一个字符串
a1=tuple(a)          #    通过tuple 将 字符串a 转换为列表a1
print(type(a1))     #
print(a1)           #('1', '2', '3', '4', '5')

元组转换为字符串
a1=(1,2,3)             #定义一个元组
a2=a1.str()         #通过_str_将元组a1转换为字符串a2
print(type(a2))         #
print(a2)               #(1, 2, 3)

python 中列表和元组的区别？
1.类型不同    一个list, 一个为tuple
2.定义不同， 列表通过[ ]中括号来定义，元组是通过()小括号来定义
3.列表定义后是可以随意的增删改（元素不受保护）
4.元组定义后是不能随意的增删改（元素受保护）
5.元组相对更安全（因为定义后不能直接进行修改，所以比列表安全）



想给元组中进行增删改操作如何实现？
可以把元组先转换为其他的数据类型，然后再调用其他类型中的方法来实现

元组也是支持切片操作
a3=("hello",1,2,3,4,5)    # 定义一个元组
print(a3[0])               #通过索引查询元组中的值，hello

字典
定义：{ }大括号， 也称为花括号
键值对，键是唯一的， 值可不唯一
键值对用冒号分割， "name": "zhangsan"(非整型数据要加引号）
存在多个键值对是用逗号 进行分割；
类型：dict
d={}                # 定义一个空字典
print(type(d))      #

字典中没有值的时候一定要加引号， 否则会显示异常
d={"name":""}            #定义一个字典， 里面的值为空
print(d)                 #{'name': ''}
d2={"name":"zhangsan","age":18}       #定义一个字典， 多个键值对， 用逗号隔开， 整型不用加"";
print(d2)                          #{'name': 'zhangsan', 'age': 18}
添加键值对（如果没有相同的键则会把键值添加到字典中，有相同则进行替换）
d2["score"]=100          # 设置添加一个键值对
print(d2)                #{'name': 'zhangsan', 'age': 18, 'score': 100}
d2["age"]=20             #如果原字典中有此键，则会执行替换
print(d2)                #{'name': 'zhangsan', 'age': 20, 'score': 100}

取出索引的键
键：keys 值：values       
d2={"name":"zhangsan","age":18}
ke =d2.keys()                       #取出当前字典中所有的键
print(ke)                           #dict_keys(['name', 'age'])
val=d2.values()                     #取出当前字典中的所有值
print(val)                          #dict_values(['zhangsan', 18])

获取键所对应的值
d2={"name":"zhangsan","age":18}         #定义一个字典， 多个键值对
d3=d2["name"]                                   #获取键字典里面这个键name 对应的值
print(d3)                                               #zhangsan

setdefault    设置键值对
注意：
d2={"name":"zhangsan","age":18}
d2.setdefault("scroe",100)                              #设置键值对
print(d2)                                                       #{'name': 'zhangsan', 'age': 18, 'scroe': 100}
d2.setdefault("age",20)                                 #设置已存在的键值
print(d2)                                                       #{'name': 'zhangsan', 'age': 18, 'scroe': 100}

删除字典中的键值
d2={"name":"zhangsan","age":18}
del d2                                  #删除整个字典
print(d2)                               # 抛异常， 提示字典不存在
del d2["name"]                          #删除对应键的值
print(d2)                                       #{'age': 18}

遍历字典
for... in...
当前变量i 获取的值为键， 值不显示
d2={"name":"zhangsan","age":18}
for i in d2:                        #当前变量i 获取的值为键
print(i)                                #name  age

d2={"name":"zhangsan","age":18}
for k,v in d2.items():              # 通过items  函数来实现变量获取键值对
print(k,v)                       # name zhangsan      age 18

pop方法删除键并返回对应键的值
d2={"name":"zhangsan","age":18}
方法①：#a=d2.pop("name")                        #删除name这个键返回对应键的值
#print(a)                                                   #zhangsan
方法②：print(d2.pop("name"))                      #zhangsan

d2={"name":"zhangsan","age":18}
d2.clear()                                  # 把d2这个字典中的所有键值清除掉（清空字典）
print(d2)                                   #{} 返回一个空字典


get()方法获取对应键的值
#当获取的键不存在时， 返回None
d2 = {"name": "zhangsan", "age": 18}
①
d3=d2.get("name")                                       #取指定存在name的键进行取值
print(d3)                                                       #zhangsan
②
d4=d2["name"]                                           #取指定存在name的键进行取值
print(d4)                                                       #zhangsan

①
d5=d2.get("score")                                      #取指定不存在的键取值
print(d5)                                                       #None
②
d6=d2["scroe"]                                          # 指定不存在的键进行取值
print(d6)                                                        #抛异常

给具体的键指定值
d2 = {"name": "zhangsan", "age": 18}
①d2={}.fromkeys(["name","age"])                                  #不指定值
print(d2)                                                                           #{'name': None, 'age': None}   默认为none
②d2={}.fromkeys(["name","age"],"xiaozhang")        #指定值
print(d2)                                                                   #{'name': 'xiaozhang', 'age': 'xiaozhang'}

python2: has_key 函数检查字典是否有指定的键， 返回布尔值
python3:        _contains_     函数检查字典是否有指定的键， 返回布尔值
python3中不使用has_key
d2 = {"name": "zhangsan", "age": 18}
print(d2._contains_("name"))                 #True
print(d2._contains_("score"))                #False

popitem 删除字典中的键值对，一般默认是删除末尾
d2 = {"name": "zhangsan", "age": 18}
d3=d2.popitem()
print(d3)                            #被删除的键对值('age', 18)
print(d2)                           #剩下的键对值{'name': 'zhangsan'}

update    更新把两个字典拼接起来形成一个新的字典
①创建新的表
d1 = {"name": "zhangsan", "age": 18}
d2={"score":100}
d1.update(d2)
print(d1)                           #{'name': 'zhangsan', 'age': 18, 'score': 100}
②有相同键存在时，会执行替代
d1={"name": "zhangsan", "age": 18}
d2={"age":100}
d1.update(d2)
print(d1)                           #{'name': 'zhangsan', 'age': 100}

字典转元组
通过tuple方法， 字典转换为元组之后，只会保留键
d1={"name": "zhangsan", "age": 18}
t1=tuple(d1)
print(type(t1))                     #
print(t1)                                  #('name', 'age')

字典转列表
注：转换为元组之后，只会保留键
d1={"name": "zhangsan", "age": 18}
t1=list(d1)
print(type(t1))                             #
print(t1)                                          #['name', 'age']

字符串转字典
用eval()方法，将字典格式的字符串转换为字典
a="{'name':'zhangsan','age':18}"
print(type(a))                      #
dc=eval(a)
print(type(dc))                     #
print(dc)                           #{'name': 'zhangsan', 'age': 18}

列表转字典
list1=["name","age"]
list2=["zhangsan",18]
a=zip(list1,list2)                  # 把两个列表进行链接，把索引值相同的为一个整体
for i in a
print(i)                                        #不能直接查看结果，需要遍历
print(type(i))
print(dict(a))                              # 通过字典的类型转换行程一个字典{'name': 'zhangsan', 'age': 18}
print(type(a))                      #

集合：没有切片操作
可变集合和不可变集合
可变集合：set
不可变集合： frozenset
相同点： 都能够进行去重
不同点：可变集合去重后可以实现增删改
不可变集合去重后不能进行增删改
可变集合
a=[1,2,3,4,1]                   # 定义一个列表
a1=set(a)                       # 可变集合去重
print(a1)                       # {1, 2, 3, 4}
a1.add("xiaozhang")             #添加字符
print(a1)                               #{1, 2, 3, 4, 'xiaozhang'}
a.clear()                               #清除集合中的内容
print(a)                                #[]
a1.pop()                          #随机移除一个元素
print(a1)                          #{2, 3, 4, 'xiaozhang'}
a1.remove("xiaozhang")               #指定元素进行删除
a2=a1.copy()                                #复制集合
print(a1)                                   #{1, 2, 3, 4}
print(a2)                                           #{1, 2, 3, 4}


不可变集合
a=[1,2,3,4,1]                   # 定义一个列表
a1=frozenset(a)                 #不可变集合去重
print(a1)                               #frozenset({1, 2, 3, 4})
#无法调用add进行添加字符