python基础语法3 元组，字典，集合

元组：

========================元组基本方法===========================
用途:存储多个不同类型的值
定义方式:用过小括号存储数据，数据与数据之间通过逗号分隔,(值不能被改变)
        定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号*****
        在元组中如果不加，就是输入参数类型

t1 = ('a','b','c','a')  # t1 = tuple(('a','b'))

常用方法:

"""
1、索引取值（正取，反取）
2、索引切片
3、成员运算in ，not in
4、len()
"""

print(t1[0:2])
# ('a', 'b')
print(t1.count('a'))
#
print(t1.index('a',1))  # 从第2个元素开始查找
#

=========================类型总结==========================
有序or无序 : 有索引，有序
可变or不可变: 不可变
存一个值or存多个值：存多个值

字典：

========================字典(dict)基本方法===========================
用途:
定义方式:通过大括号来存储数据，通过key:value来定义键值对数据，每个键值对中间通过逗号分隔

key:一定是一个不可变类型
value：可以是任意类型

d1 = {(1,2):[1,2]}

"""
字典的三种定义方式·：
"""

# 1、*****
d1 = {'name':'egon','age':84}

# 2、*****
d2 = dict({'name':'egon'})

# 3、zip : 了解即可
l1 = ['name',"age"]
l2 = ['egon',18]
z1 = zip(l1,l2)
print(dict(z1))

常用方法:

"""
1、优先掌握的
1、按照key:value映射关系取值（可存可取）
2、成员运算in，not in # 默认判断key
3、len() # 获取当前字典中键值对的个数
"""

d1 = {'name':'egon', 'age': 73}
print(d1['name'])       #egon
print(d1['age'])        #
d1['name'] = 'tank'     #已存在，修改值
d1['gender'] = 'male'   #创建新的键值对
print(d1)
print('egon' in d1)     #False  默认判断key

内置方法：

get : 获取指定key的值，如果值不存在·，默认返回None,可以通过第二个参数修改默认返回的内容

print(d1['gender'])    #报错，没有gender
print(d1.get('gender'))  # 返回None
print(d1.get('gender','没有'))   # 返回'没有'

keys、values、items

d1 = {'name':'egon', 'age': 73}
print(d1.keys())    #返回所有的key
#dict_keys(['name', 'age'])
print(d1.values())  #返回所有的值
#dict_values(['egon', 73])
print(d1.items())   #返回所有键值对
#dict_items([('name', 'egon'), ('age', 73)])

for key in d1.keys():
    print(key)      # name,age
for value in d1.values():
    print(value)    # egon,73
for i in d1.items():
    print(i)        #('name', 'egon'),('age', 73)
for key,value in d1.items():
    print(key,value)#name egon,age 73

pop:删除 ： 指定key进行删除，有返回值，返回为对应的value

d1 = {'name': 'egon', 'age': 73}
a = d1.pop('name')
print(d1)   # {'age': 73}
print(a)    # egon

popitem() ,随机弹出一个键值对，有返回值，返回只是一个元组

d1 = {'name':'egon', 'age': 73,'gender':'male','a':""}
d1.popitem()    #没有参数
print(d1)   #{'name': 'egon', 'age': 73, 'gender': 'male'}

update : 用新字典替换旧字典

d1 = {'name':'egon', 'age': 73,'gender':'male','a':""}
d1.update({'b':''})    #无则添加
print(d1) #{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}
d1.update({'name':'tank'})  #有则修改
print(d1) #{'name': 'tank', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}

fromkeys : 生产一个新字典， 第一个参数（列表），它会以第一个参数中各个元素为key，以第二个参数为值，组成一个新字典

print(dict.fromkeys([1,2,3],['ke','k1'])) #{1: ['ke', 'k1'], 2: ['ke', 'k1'], 3: ['ke', 'k1']}
#print(d1.fromkeys([1,2,3],['ke','k1'])) 与上面语句效果相同

setdefault :key不存在新增键值对，有返回值，返回新增value，key存在返回对应的value

d1 = {'name':'egon', 'age': 73,'gender':'male','a':""}
print(d1.setdefault('name',1))      #返回egon，因为存在name的key
print(d1)   # {'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1'}
print(d1.setdefault('abc',233))      #返回233，新建键值对，返回定义的值
print(d1)   # {'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1', 'abc': 233}

=========================类型总结==========================
有序or无序 ： 无序
可变or不可变 ：可变类型
存一个值or存多个值 ： 存多个值

集合：

========================集合基本方法===========================

用途: 去重、关系运算
定义方式: 通过大括号存储数据，每个元素通过逗号分隔
定义空集合，必须使用set()来定义
d1 = {}　　#字典
ss1 = set()　　#定义集合
常用方法:

"""
合集：|
交集：&　　　　　　　　
差集：-
对称差集：^
"""

"""
1、集合中不可能出现两个相同的元素
"""

python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
linux_student = {'frank', 'alex', 'egon'}
go_student = {'egon'}
print(python_student | linux_student)
#{'frank', 'alex', 'tank', 'egon', 'owen', 'jason'}
print(python_student & linux_student)
#{'egon'}
print(python_student - linux_student)
#{'jason', 'tank', 'owen'}
print(linux_student - python_student)
#{'frank', 'alex'}
print(python_student ^ linux_student)
#{'alex', 'jason', 'owen', 'frank', 'tank'}
print(python_student > go_student)
#True
print(python_student < linux_student)
#False

l1 = [1, 2, 3, 1, 2, 9, 1, 5, 6, 7]
print(l1)
s1 = set(l1)
print(s1)   #{1, 2, 3, 5, 6, 7, 9}
print(type(s1)) #<class 'set'>
l2 = list(s1)   #[1, 2, 3, 5, 6, 7, 9]
print(l2)
print(type(l2)) #<class 'list'>

python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
for i in python_student:
    print(i)

add_slot = new_slot.difference(old_slot)    # 取差集

up_slot = new_slot.intersection(old_slot)   # 取交集

内置方法：

add()

remove()　　#值不在，报错

dicard()　　   #值不在，不报错

针对不可变类型，去重并保证顺序，则需要直接写代码

=========================类型总结==========================
有序or无序 : 无序
可变or不可变 : 可变（无法定位，不能修改，但是可以增删元素）
存一个值or存多个值 ： 存多个值

总结：

"""
存一个:整型、浮点型、字符串
存多个值：列表、元组、字典、集合

可变or不可变：
可变：列表，字典、集合
不可变：整型、浮点型、字符串、元组、集合 ( frozenset('tank')定义的集合）

有序or无序：
有序：字符串、列表、元组
无序：字典、集合

占用空间：
字典
列表
元组
集合
字符串
数字类型
"""