一、元祖tuple

1、什么元祖

使用小括号（）将多个元素括起来，多个元素用逗号隔开
（元素1，元素2，..........）

a、也是容器，可以同时存储多个数据，不可变的，有序的；

不可变——>元祖不能增删改,支持查找
有序——>可以通过下标获取元素

b、元素可以是任何类型的数据

tuple1=(1,'yue',True,[1,2])
print(tuple1)

注意：（1）元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用；

tup1 = (50)
type(tup1)
print(type(tup1)) # 不加逗号，类型为整型<class 'int'>

tup1 = (50,)
type(tup1)
print(type(tup1))# 加上逗号，类型为元组<class 'tuple'>

（2）多个数据用逗号隔开，也可以表示元祖；

tuple1=12,34,'abc'
print(type(tuple1))         #<class 'tuple'>

2、元素的查

元祖的元素不支持增删改；

列表获取元素的方式，元祖都支持，元祖[下标]，元祖[:],元祖[::]

tuple1=('monday','tuesday','wensday','thusday')
print(tuple1[2],tuple1[:3],tuple1[::2])

补充：a、获取部分元素可以通过相同个数的变量，来一一获取元祖的元素；

x,y=10,30
 x,y,z=10,20  #ValueError: not enough values to unpack (expected 3, got 2)
print(x,type(x),y,type(y),sep=' ')

b、可以通过在变量前加*来获取部分元素(列表也可以)；

tuple1=('小明','boy','2010',98,78,87)
name,sex,year,*grade=tuple1
print(name,sex,year,grade)   #小明 boy 2010 [98, 78, 87]
tuple2 = ['boy', 15300022673, 90, 89, 67, 100, '小明']
sex, tel, *score, name = tuple2
print(sex, name, score)    #boy 小明 [90, 89, 67, 100]

c、可以通过在列表或者元祖前加*，来展开其中的元素(相当于破坏掉容器，只展现元素)；

print(tuple1)   #('小明', 'boy', '2010', 98, 78, 87)
print(*tuple1)  #小明 boy 2010 98 78 87

3、元祖的运算

+、*、==、is、in、not in ——>运算符号和功能跟列表一样

4、len(),max(),min()

5、tuple（序列）-->将序列转换成元祖（同转换列表的函数 list（序列）用法）

注意：字典只能将key值作为元祖元素,value值无法取出；

6、sorted

可以通过函数 sorted（）方法，对元祖进行排序，产生一个新的列表（非元祖）

tuple3 = 10, 230, 100, 78, 34
new = sorted(tuple3)
print(new, tuple3,sep='===')  #[10, 34, 78, 100, 230] ===(10, 230, 100, 78, 34)

二、字典dict

（一）认识字典

1、什么是字典

字典是一个可变容器类的数据类型，可以用来存储多个数据，以键值对的形式存储；
可变——>可以增删改
无序——>不能用过下标获取值
字典的每个键值(key：value)对用冒号(:)分割，每个对之间用逗号,分割，整个字典包括在花括号{}中,格式如下所示：
d = {key1 : value1, key2 : value2 }
键（key）：用来定位值。键必须是唯一的，如果同一个键被赋值两次，后一个值会被记住；
键是不可变的，所以可以用数字，字符串或元组充当，而用列表就不行。
值（value）：值可以取任何数据类型，可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的。

比较：什么时候用容器类型的数据？——>需要同时保存多个数据的时候

什么时候用列表？——>保存多个数据是同一类的数据（不需要区分）

什么时候用字典？——>保存的多个数据是不同类的数据（需要区分）

可变：元素及其位置均可改变，即支持对元素进行增删改；
不可变：元素及其位置均不可改变，不支持对元素进行增删改，只能对其元素进行查询；
有序：可以通过下标查询、获取、访问元素；
无序：不能通过下标查询、获取、访问元素；

2、查询

由于字典是无序的，故要获取字典的值，必须通过key来获取；
####### a、字典[key]——》获取key值对应的值

注意：key值必须是存在的，否则会报KeyError

student={'name':'alice','age':12,'sex':'boy'}
print(student['name'])  #alice
print(student['sex'])   #boy
print(student['score'])   #KeyError: 'score'

b、字典.get(key)——>通过key获取值

注意：key值不存在的不会报错，结果是none

某个key值肯定存在的时候用a型，key值可能不存在的时候用b型；
print(student.get('score')) #None

c、直接遍历字典（推荐使用）

通过for-in遍历字典拿到的是key值

for x in student:
    print(student[x])

d、其他遍历字典

3、增（增加键值对）

语法:字典[key]=值 key必须是在字典中不存在的

student['score']=98
print(student)   #{'name': 'alice', 'age': 12, 'sex': 'boy', 'score': 98}

4、改（修改值，非key）

语法：字典[key]=值 key必须是在字典中存在的

student['name']='harry'
print(student)   #{'name': 'harry', 'age': 12, 'sex': 'boy', 'score': 98}

5、删（删除键值对）

a、语法： del 字典[key] 删除字典中某个键值对

del student['sex']
print(student)   #{'name': 'harry', 'age': 12, 'score': 98}

b、语法：字典.pop(key) 实质是从字典中取走某个键值对，非删除

new_age=student.pop('age')
print(student,new_age)  #{'name': 'harry', 'score': 98} 12  age键值对从字典中已取走，但还存在，故能获取

（二）字典相关操作

1、字典相关运算

== 判断两个字典的值是否相等

is 判断两个字典的地址是否相等

in 和 not in 判断字典中是否包含某个键值（key），非值（value）

dic1 = {'a': 1, 'b': 2}
aa = dic1
print(dic1 is aa)  #True
print({'a': 100, 'b': 200} == {'b': 200, 'a': 100})   #True
print({'a': 100, 'b': 200} is {'b': 200, 'a': 100})  #False
print('abc' in {'abc': 100, 'a': 200})  # True
print('abc' in {'100': 'abc', 'a': 200})  # False

（三）字典的函数和方法

1、 len(字典)--> 获取键值对的个数

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(len(dict1))#4

2、字典.clear()--> 清空字典

dict1.clear()
print(dict1)#{}

3、字典.copy()--> 将字典中的键值对复制一份产生一个新的字典

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict2 = dict1.copy()
print(dict2, dict1 is dict2)#{'a': 1, 'b': 2, 'c': 3, 'd': 4} False

####### 值相同，地址不同

4、dict.fromkeys(序列,值)--> 创建一个字典，将序列中的每个元素作为key，值作为value

Python 字典 fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，值value为字典所有键对应的初始值。

dict3 = dict.fromkeys('xyz', 100)
print(dict3)#{'x': 100, 'y': 100, 'z': 100}
dict3 = dict.fromkeys(['aa', 'bb', 'cc'], (1, 2))
print(dict3)#{'aa': (1, 2), 'bb': (1, 2), 'cc': (1, 2)}

5、get方法

字典.get(key)

字典.get(key,默认值)

返回指定键key的值，如果值不在字典中则返回None

student = {}
student.get('name','xm')  #字典.get()是访问、获取、查询某个键，而非创建
print(student,type(student))  #{} <class 'dict'>
print(student.get('name','xm'))#xm   字典.get()是访问、获取、查询某个键，返回指定键key的值
student.setdefault('sex','boy')#字典.setdefault()是创建新键
print(student,type(student))   #{'sex': 'boy'} <class 'dict'>
print(student.get('name'))#None
print(student.get('name', '无名'))#无名

6、key、value、items方法

字典.keys() -->返回所有键对应的序列

字典.values()-->返回所有值对应的序列

字典.items()-->将每个键值对转换成元祖，作为一个序列的元素

注意：返回的都不是列表，是其他类型的序列

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict1.keys(),dict1.values(),sep='====')#dict_keys(['a', 'b', 'c', 'd'])====dict_values([1, 2, 3, 4])
items = list(dict1.items())
print(items, type(items))   #[('a', 1), ('b', 2), ('c', 3), ('d', 4)] <class 'list'>
print(dict1.items(), type(dict1.items())) #dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)]) <class 'dict_items'>

7、setdefault方法

字典.setdefault(key)

字典.setdefault(key,value)

和get()类似, 如果键不存在于字典中，将会添加键key并将值设为None或者value；

如果键存在，不会对字典进行任何操作（key和value均不改变）；

注意:语法-字典.get()是访问字典某键，语法-字典.setdefault()是创建某键；

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict1.setdefault('aa')
print(dict1)#{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None}

8、update方法

字典1.update(字典2)——》把字典2的键值对更新到字典1里，不存在的键值对则进行添加；

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 200, 'c': 100}
dict1.update(dict2)
print(dict1) #{'a': 1, 'b': 200, 'c': 100}

三、集合

1、什么是集合set

是一个容器类的数类型，可以用来存储多个数据，可变，无序；元素是唯一的；

可变——》可对元素进行增删改

无序——》不能通过下标获取元素

唯一——》自带去重功能

{元素1，元素2，元素3，元素4} 元素只能是不可变的数据，即不能是列表、字典；

set1={12,'dfe',(2,4)}
set2={}# 只有空字典，没有空集合

2、集合的增删改查

a、查（获取元素）

集合不能单独的获取某个元素，也不能切片，只能通过for—in 来遍历；

for x in set1:
    print(x)

b、增

集合.add(元素)——》在集合中添加元素；

set1={1,2,3}
set1.add('abc')
print(set1)  #{1, 2, 3, 'abc'}

集合1.update(集合2)——》把集合2的元素更新到集合1里，并自动去重；

集合.update(序列)——》把序列的元素(不可变)更新到集合里，并自动去重；

set2={0,3,4,'abc'}
set1.update(set2)
print(set1)  #{0, 1, 2, 3, 4, 'abc'}
set2.update('wasd')
print(set2)  #{0, 'd', 3, 4, 'abc', 's', 'w', 'a'}
set2.update(['rt',6,True])
print(set2)  #{0, 'abc', True, 'w', 3, 4, 'a', 6, 's', 'd', 'rt'}

c、删

集合.remove(元素)

set2.remove(True)
print(set2)  #{0, 'abc', 3, 4, 's', 6, 'rt', 'a', 'w', 'd'}

d、改无法修改

3、集合的相关运算

包含（不是比较大小）、交集、并集、差集、补集

a、包含 >= <=

集合1>=集合2——》判断集合1是否包含集合2

集合1<=集合2——》判断集合2是否包含集合1

set1={1,2,3,4,10}
set2={1,2,3}
set3={1,2,3,6}
print(set1>=set2)  #True
print(set1>=set3)  #False

b、交集 &

求两个集合公共的部分

print(set1 & set2) #{1, 2, 3}

c、并集 |

求两个集合的和

print(set1 | set3) #{1, 2, 3, 4, 6, 10}

d、差集 -

集合1-集合2——》求集合1中除了与集合2公共以外的部分

print(set1-set2) #{10, 4}

e、补集 ^

求两个集合除了公共部分以外的部分

print(set1^set3) #{4, 6, 10}

四、

1、整型int

int（）

浮点数、布尔值、整数数字型字符串可以转化成整型；

print(int(23.4))  #23
print(int(False)) #0
print(int('123')) #123
print(int('12.3')) #ValueError

2、浮点数float

float()

整数、布尔值、数字型字符串可以转换成浮点数；

print(float(23.4))  #23.4
print(float(False)) #0.0
print(float('123')) #123.0
print(float('12.3')) #12.3

3、布尔bool

bool()

所有数据都可以转换成布尔值，数据为空、False或者为零的值转换成Flase，其他转换成True；

print(bool(),bool({}),bool(()),bool([]),bool(''),bool(0),bool(0.0),bool(False)) #全为False；

4、字符串str

str（）

所有数据都可以转换成字符串，数据转换成字符串就是在数据最外面加引号

print(str([1,3,'abc'])) #[1, 3, 'abc']

5、列表

list（）

序列才能转换成列表，将序列中的元素作为列表的元素

print(list('abc'))#['a', 'b', 'c']
print(list((1,2,'er')))#[1, 2, 'er']
print(list({3,5,(2,4,9)}))#[(2, 4, 9), 3, 5]
print(list({'q':1,'w':2}))#['q', 'w']

6、元祖tuple

tuple（）

只能将序列转变成元祖，且元素不可变

print(tuple([1,3,5]))#(1, 3, 5)
print(tuple('abc'))#('a', 'b', 'c')
print(tuple({'abc':1,'qwe':2}))#('abc', 'qwe')  取键不取值

7、字典dict

dict（）

序列的每个元素有两个子元素的数据才能转换字典

list1=[1,3] #该列表每个元素只有一个子元素，无法转换成字典

list2=[[1,2],{'abc':1,'qwe':2}]
tuple1=({'e','r'},(11,22))
print(dict(list2)) #{1: 2, 'abc': 'qwe'}
print(dict(tuple1))#{'e': 'r', 11: 22}

8、集合

set()

序列可以转换成集合，且有去重功能；

print(set([1,2,3,'abc',3,5,5,(1,3,5)]))#{1, 2, 3, 5, (1, 3, 5), 'abc'}
print(set({'abc':1,'qwe':2}))#{'abc', 'qwe'} 取键不取值

一阶段day8-01元祖、字典、集合及相互转换