元组 、字典、集合

元组

元组：用（）包含起来并用逗号分隔开的一系列数据的集合。

1. 能够存储多个值
2. 有序，可以用过元素位置进行索引
3. 不可变类型：即元组的值的改变，地址也会发生改变，可Hash（但是元组内存储的可变类型中存储的值发生改变，不会导致元组的地址发生改变。）
4. 可迭代类型：可以用For循环进行遍历

1、常用操作（索引、切片、元组化、成员运算、遍历、长度）

1. 索引与切片（等同于字符串与列表）

number=(1,2,3,2,1)
#元组的索引
print(number[0]) #返回第一个值》1
print(number[-1]) #返回最后一个值》1
#元组切片
print(number[0:5:1]) #返回一个元组。元组包括：第一个到第（5-1）个值，步长为1》(1, 2, 3, 2, 1)
print(number[-1:-5:-1])#反向取值，组成一个新元组

2. 成员运算与遍历（等同于字符串与列表）

#元组的遍历，同列表等，采用for
names=["alex","duke","fox","duke","fox","fox"]
name_count={}
for name in names:
    name_count.setdefault(name,names.count(name))
print(name_count)
#成员运算，（逻辑运算） in ,not in
number=("duke","ergou","erick","egon")
print("erick" in number)  #True
print("erick" not in number) #False

3. 长度len()>==retuen 元素个数
4. 元组化tuple()

#初始化元组
#tuple(可迭代类型)，返回一个元组，tuple()定义了一个空元组
tuple1=tuple("abcud as")
print(tuple1)
tuple1=tuple([1,22,3,4,5])
print(tuple1)
tuple1=tuple((1,2,3,4,5))
print(tuple1)
tuple1=tuple({1:1,2:2,3:3})
print(tuple1)
tuple1=tuple({1,2,3,4,5})
print(tuple1)
"""输出结果：
('a', 'b', 'c', 'u', 'd', ' ', 'a', 's')
(1, 22, 3, 4, 5)
(1, 2, 3, 4, 5)
(1, 2, 3)
(1, 2, 3, 4, 5)
"""
#定义知有一个元素的元组
tuple1=tuple()
tuple2=()
print(type(tuple1),type(tuple2))
tuple1=(2,)
tuple2=(2)
print(type(tuple1),type(tuple2))
"""输出结果：
<class 'tuple'> <class 'tuple'>
<class 'tuple'> <class 'int'>
"""

2、内置函数 index，count
index（）：返回第一个索引值，若不存在就报错
count（）：计算某一元素在元组中出现的次数

"""
index:查找，并返回该值所在可迭代类型中的位置，若未找到值，则报错
使用方法：T.index(value, [start, [stop]])
"""
print(number.index(2))
print(number.index(2,2))

number=("duke","ergou","erick","egon")
number.count("duke")

字典

字典：在{}中，用逗号隔开的“key:value”键值对的集合。

1. 能够存储多个值（键值对 ，键 与 值与一一对应，键必需为可hash类型（数字、字符串、元组、集合），值可以为任何类型。）。字典的key值不能重复，若重复的话，后面值会覆盖前面的值
2. 字典是无序的，但是可采用key去调用相对应的value值
3. 可变类型，内部存储的id地址的改变，并不会引起该字典对应id地址的改变，不可hash

一、常用操作

1. 索引、新增、键、值、键值对、循环、长度、成员运算、初始化

• [ ]索引：按照key值返回value，若key值不存在，则会报错

name_age={"alex":18,"liric":13,"duke":20,"alex":19}
name_age["alex"]   #>>>>= 18
name_age["duke"]   #>>>>= 20

• 新增：D[key]=value，若key存在，则覆盖，否则添加

name_age={"alex":18,"liric":13,"duke":20,"alex":19}
name_age["alex"]=25 #>>>={'alex': 25, 'liric': 13, 'duke': 20}
print(name_age)
name_age["zhang dadan"]=21
print(name_age)     #>>>={'alex': 25, 'liric': 13, 'duke': 20, 'zhang dadan': 21}

• 键：D.keys() 提出里面所有的key;值:D.values() 提出里面所有的value;键值对:D.items() 提出里面所有的key,value。

name_age={"alex":18,"liric":13,"duke":20,"alex":19}

print(name_age.keys())   #>===dict_keys(['alex', 'liric', 'duke']) 不会占用内存
print(name_age.values()) #>===dict_values([19, 13, 20])
print(name_age.items())  #>===dict_items([('alex', 19), ('liric', 13), ('duke', 20)])

• 循环：for item in D[.keys()\values\items()]:

"""字典循环"""
name_age={"alex":18,"liric":13,"duke":20}
for k in name_age.keys():
    print(k)
for k in name_age:
    print((k))
for v in name_age.values():
    print(v)
for item in name_age.items():
    k,v=item
    print(k,v)
for k,v in name_age.items():
    print(k,v)

• 长度：len()，返回字典中键值对的个数
• 成员运算：not in \in : if item in D[.keys()\values\items()]: 返回False\True
• 初始化：dict(object):将object转换为字典类型存储

"""dict()初始化：
(1):dict():创建一个空字典
(2):dict(mapping):从具有映射关系（目前所学：字典）（key,value）初始化一个新字典
(3):dict(iterable):从一个可迭代类型初始化一个新字典，可迭代类型（key,value）
(4):dict(**args):从key=vlaue中初始化一个新字典"""
dict1=dict()
print(dict1)
dict1=dict({"able":2,"ergou":123})
print(dict1)
# 集合、列表、元组的随意组合，内层每一个包含两个值，第一个值不能为可变类型
dict1=dict((["able",16],["ergou",123]))
print(dict1)
#key值会自动转为字符串
dict1=dict(able=18,ergou=18)
print(dict1)
"""输出结果：
{}
{'able': 2, 'ergou': 123}
{'able': 16, 'ergou': 123}
{'able': 18, 'ergou': 18}
"""

2. 内置函数：get ,setdefult,update,pop,popitem,fromkeys,del

• get(key)：item = D.get(key)
  if key in D:
  item=D(key)
  else:
  item = None

"""
get(),获取K值对应的Value值，若K存在，则返回value,否则什么也不做
"""
name_age={"erick":18,
          "duke":21,
          "ergou":22
          }
print(name_age.get('erick')) #>=18
print(name_age.get('ergu'))  #>=None

• setdefult(key,d) :f.setdefult(key,d)
  if key in f:
  D(key)=D(key)
  else:
  D(key)=d

name_age={"erick":18,
          "duke":21,
          "ergou":22
          }
"""
setdefault(self, k, d=None): 
使用方法：D.setdefault(k[,d]) 
-> if k in D.keys: if d: D[K]=d return d  else return D[k]
   if k not in D.keys: if d: D[k]=d return D[k] else: D[k]=None retuen None
        """
print(name_age.setdefault("duke",21))
print(name_age)
print(name_age.setdefault("lichengyu"))
print(name_age)
"""输出结果：
21
{'erick': 18, 'duke': 21, 'ergou': 22}
None
{'erick': 18, 'duke': 21, 'ergou': 22, 'lichengyu': None}
"""

• update(),更新

"""
update():更新一个D(字典)，从一个字典/可迭代类型E和F中
使用方法：D.update([E, ]**F) 
**F：1、若E存在且具有.keys的方法，则D(K)=F(K)，则E是一个字典
     2、若E存在且不具有.keys的方法，for k,v in E D[K]=V，则E为一个可迭代类型，且E的每一次循环的元素中都包含两个元素
     在这两种情况下，这都是：对于F:d[k]＝f[k]中的k
"""
# 0 默认E为空，则采用**模式将其转换字典进行更新
alpha.update(x=2,z=3)
print(alpha)
# 1 若E为一个字典
alpha.update({"x":5,"q":6},h=6,g=8)
print(alpha)
# 2 若E存在且不具有.keys的方法，for k,v in E D[K]=V
alpha.update((("x",1),("g","h")))
print(alpha)
alpha.update([["x",3],("g","qh")])
print(alpha)
"""输出结果：
{'x': 2, 'y': 2, 'z': 3}
{'x': 5, 'y': 2, 'z': 3, 'q': 6, 'h': 6, 'g': 8}
{'x': 1, 'y': 2, 'z': 3, 'q': 6, 'h': 6, 'g': 'h'}
{'x': 3, 'y': 2, 'z': 3, 'q': 6, 'h': 6, 'g': 'qh'}
"""

• pop,popitem,del

#pop():任意删除一对键值对，并且后续依旧可以使用该值
f=name_age.pop("alex")
print(id(name_age))  #>>==2017606815888
print(f,name_age)    #>>==19 {'duke': 20}
#popitem ():任意删除字典中的一对键值对，并让他们组成元组
name_age={"alex":18,"liric":13,"duke":20,"alex":19}
x=name_age.popitem()
print(x,name_age)   #>>==('duke', 20) {'alex': 19, 'liric': 13}
# del 删除一对键值对，而且不可再用
del name_age["liric"]
print(name_age) #>>{'alex': 19, 'duke': 20}

集合

集合：是由{}存储的一系列逗号，分隔开的值
集合：是无需的
集合：关系运算和去重

"""
集合：用{}包含起来的，并且用逗号分隔开的一系列不可变类型的值
        遵循三个原则：1、集合内元素是无序，不能索引
                      2、集合内元素必须是不可变类型（数字，字符串，元组）
                      3、集合内没有重复元素
        1、集合可以存多个值
        2、集合是可变类型，不可被hash，不能作为字典的key
        3、集合是无序的
作用：关系运算
      去重：去重的对象中不能包括可变类型
            去重后的结果是无序的
"""
#一、关系运算
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
#1 求并集
#1.1 符号方法
print(pythons | linuxs)
#1.2命令方法
print(pythons.union(linuxs))
"""输出结果：
{'egon', 'oldboy', 'biubiu', 'gangdan', 'alex', 'wupeiqi', 'yuanhao'}
{'egon', 'oldboy', 'biubiu', 'gangdan', 'alex', 'wupeiqi', 'yuanhao'}
"""
#2.求交集
#2.1符号方法
print(pythons & linuxs)
#2.2 用命令方法
# intersection:横断，横切;交叉，相交;交叉点，交叉线;[数]交集
print(pythons.intersection(linuxs))
"""输出结果：
{'gangdan', 'wupeiqi'}
{'gangdan', 'wupeiqi'}
"""
#3 求差集（求差级对顺序有关系，是前者求对于后者的差集）
#3.1 符号法
print(pythons - linuxs)
print(linuxs - pythons)
#3.2 用命令
#difference:差别，差异;[数]差数，差额;意见分歧;特色
print(pythons.difference(linuxs))
print(linuxs.difference(pythons))
"""输出结果：
{'biubiu', 'yuanhao', 'egon', 'alex'}
{'oldboy'}
{'biubiu', 'yuanhao', 'egon', 'alex'}
{'oldboy'}
"""
#4对称差集(和顺序无关)
#4.1 符号
print(pythons ^ linuxs)
#4.2 用命令
print(pythons.symmetric_difference(linuxs))
"""输出结果：
{'biubiu', 'alex', 'yuanhao', 'egon', 'oldboy'}
{'biubiu', 'alex', 'yuanhao', 'egon', 'oldboy'}
"""
#5父集（即属于   父集>子集 ）返回结果False\True
#5.1 符号  >
set1={1,2,3,4,5}
set2={1,2,3}
print(set1 > set2)
print(set1<set2)
#5.2 命令行
print (set1.issuperset(set2)) #判断set1是否是set2的父集
print(set2.issubset(set1))   #判断set2是否是set1的子集
set1={1,2,3}
set2={1,2,3}
 #若两个集合相等，则互为父子集
print (set1.issuperset(set2)) #判断set1是否是set2的父集
print(set2.issubset(set1))   #判断set2是否是set1的子集
"""输出结果：
True
False
True
True
True
True
"""
#二 去重
list1=[1,2,3,4,2,1,3]
set1=set(list1)
list1=list(set1)
print(list1)
"""输出结果：
[1, 2, 3, 4]
"""
#三 内置函数
set1={1,2,3,4,5,32,3,40}
"""
discard:如果该元素在几何中则移除这个元素集合中，
     如果这个元素不存在与集合中，则是什么也不做
方法：set1.dicard(1)
"""
set1.discard(1)#1这个元素存在于集合set1中，那就移除它
print(set1)
set1.discard(24)#24这个元素不存在于集合set1中，那就什么都不做
print(set1)
"""输出结果：
{32, 2, 3, 4, 5, 40}
{32, 2, 3, 4, 5, 40}
"""
"""
update:用一个集合与该集合的交集去更新这个集合
"""
set1.update({2,3,67,89,5,23})
print(set1) #>={32, 2, 3, 4, 5, 67, 40, 23, 89}
"""
pop():移除并且任意返回一个集合元素，若集合是空集，则会报错
"""
nuber=set1.pop()
print(nuber,set1,sep="  ") #>=2  {2, 3, 4, 5, 67, 40, 23, 89}
"""
remove(element):若集合中存在element,则移除该元素；若集合不存在element，则会报错
"""
set1.remove(3)
print(set1) #>={2, 4, 5, 67, 40, 23, 89}
#增加一个指定素
set1.add(6)
print(set1) #>={2, 4, 5, 67, 6, 40, 23, 89}
set2={1,9,8,34,5,2,4,5}
#用set1与set2的差集去更新set1
print(set1.difference(set2)) #>={2, 4, 5, 67, 40, 23, 89}
set1.difference_update(set2)
print(set1) #>={2, 4, 5, 67, 40, 23, 89}
#用set1与set2的对称差集去更新set1
print(set1.symmetric_difference(set2)) #>={1, 34, 2, 4, 5, 67, 6, 40, 8, 9, 23, 89}
set1.symmetric_difference_update(set2)
print(set1) #>={1, 34, 2, 4, 5, 67, 6, 40, 8, 9, 23, 89}
#用set1与set2的交集去更新set1
print(set1.intersection(set2)) #>={67, 6, 40, 23, 89}
set1.intersection_update(set2)
print(set1) #>={67, 6, 40, 23, 89}
"""
set1.isdisjoint(set2):如果两个集合的交集是空集的话,则返回True,否则返回False
"""
set1={1,2,3,4,5}
set2={56,7,8,9,10}
print(set1.isdisjoint(set2)) #>=True
set2={1,2,3}
print(set1.isdisjoint(set2)) #>=False
#四,定义一个空集合
set1={} #这种定义方式错误
print(type(set1))  #>= <class 'dict'>
set1=set({})
print(type(set1)) #>=<class 'set'>
"""D.add(element):增加一个元素到集合D中，若该元素已存在于D中，也没有什么影响"""
set1.add("5")