python基础-day8

一、元组

1、什么是元组

元组：使用()将多个元素括起来，多个元素之间用逗号隔开
a.
容器,可以同时存储多个数据，不可变，有序的
不可变 --> 不能增删改
有序 --->可以通过下标获取元素
b.
元素,可以是任何类型的数据

注意：如果元组的元素只有一个的时候，必须在元素后面加逗号

tuple2 = 10, 20, 'bc'
print(tuple2, type(tuple2))
结果为：(10, 20, 'bc') <class 'tuple'>

2、元组的查

元组的元素不支持增删改
列表获取元素的方式，元组都支持：元组[下标]，元组[:],元组[::]
补充：获取部分元素，可以通过相同的变量个数，来一一获取元组中的元素

tuple2 = ('星期一', '星期二', '星期三', '星期四')
print(tuple2[2:])
输出的结果为：('星期三', '星期四')

a.应用：交换两个值

a = 10
b = 20
a, b = b, a
print(a, b)
输出的结果 ：20 10

b.可以通过在变量前加*来获取部分元素(适用于列表)

tuple2 = ('小明', 90, 89, 67, 100)
name, *score = tuple2
print(name, score)
输出的结果：小明 [90, 89, 67, 100]

c.可以通过在列表或者元组前加*，来展开列表中的元素

tuple3 = (1, 2, 3, 4, 5)
print(*tuple3)
输出的结果为：1 2 3 4 5

3.元组的运算

+,*,==,is,in ,not in,--->和列表一样

4.tuple()

所有的序列都可以转换为元组，注意。字典只能讲key值作为元组元素

5.sorted()

可以通过sorted()方法，对元组进行排序，产生一个新的列表

二、认识字典

1.什么是字典

字典是一个容器类的数据类型，可以用来存储多个数据(以键值对的形式存储)，可变的，无序的
{key1:value1,key2:value2,key3:value3,.....}
可变 --->可以增删改
无序-->不能通过下标获取值
键(值)：用来定位值的，要求只能是不可变的数据类型(数字，字符串，元组...)，是唯一的
值(value):存储的数据，可以是任何类型的数据

2.

什么时候用容器类型的数据？ -->需要同时保存多个数据的时候
什么时候用列表？ -->保存的多个数据是同一类的数据(不需要区分)
什么时候用字典？ -->保存的多个数据是不同类的数据（需要区分）

三、字典的增删改

1.查(获取键值对的value)

获取字典的值，必须通过key来获取
语法：

a.字典[key] -->获取key对应的值

注意：key值必须是存在的，否则会包keyerror错

student = {'name': '小明', 'age': '18', 'study_id': 'py001', 'sex': 'boy'}
print(student['name'])

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

注意;key值不存在的时候不会报错，结果是None

print(student.get('age'), student.get('study_id'))

确定key一定存在就使用[]语法，key可能不存在1的时候用get()语法

c.遍历字典

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

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

d.其他遍历方式(不推荐使用)

直接遍历拿到值

for value in student.values():
    print(value)

直接拿到key和value

print(student.items())
for key, value in student.items():
    print(key, value)

增(增加键值对)

字典[key]=值(不存在) --->

car ={}
car['color'] = 'red'
print(car)

3.修改（修改值）

字典[key] = 新值（key存在）

car['color'] = 'yellow'
print(car)

4.删(删除键值对)

a.del 字典[key] --->通过key删除键值对

student = {'name': '小明', 'age': '18', 'study_id': 'py001', 'sex': 'boy'}
del student['age']
print(student)

b.pop(key) --->取出key对应的值(实质还是删除key对应的键值对)

name = student.pop('name')
print(student, name)

四、字典相关操作

1.字典相关运算

a.==:判断两个字典的值是否相等
b.is:判断两个字典的字典是否相等

in 和 not in: key in 字典/key not in 字典---> 判断key是否在/不在字典里

2.字典相关的函数方法

a.len（字典） --->获取键值对的个数
b.字典.clear() -->清空字典
c.字典.copy() --->将字典中的键值对复制一份产生一个新的字典
d.字典.fromkeys(序列，值) -->创建一个字典，将序列中的每个元素作为key，值作为value

dict3 = dict.fromkeys('xyz', 100)
print(dict3)
dict2 = dict.fromkeys(['aa', 'bb', 'cc'], 100)
print(dict2)
输出的结果为：
{'x': 100, 'y': 100, 'z': 100}
{'aa': 100, 'bb': 100, 'cc': 100}

e.
字典.get(key) -->key不存在取None
字典.get(key,默认值) -->key不存在取默认值

f.
字典.values() --->返回所有对应的序列
字典.keys() -->返回所有键对应的序列
字典.items() -->将键值对转换为元组，作为一个序列的元素

dict1 = {'a': 1, 'b': 2, 'c': 3}
items = list(dict1.items())
print(items)
输出的结果为：[('a', 1), ('b', 2), ('c', 3)]

g .
字典.setdefault(key) --->添加键值对，键是key，值是None
字典.setdefault(key,值) -->添加键值对，键是key，值是value
注意：key存在的时候，对字典不会有任何操作(不会修改key对应的值)

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict1.setdefault('aa', 100)
print(dict1)
输出的结果为：{'a': 1, 'b': 2, 'c': 3, 'aa': 100}

8.字典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，...}
元素：不可变的数据

set1 = {10, 20, 'abc', (10, 20), 10}
print(set1)      # 10, 20, (10, 20), 'abc'}
# set2 = { }   # 这个是空的字典

2.集合的增删改查

a.查(获取元素)

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

b.增（添加元素

1.集合.add(元素) --->在集合中添加一个元素

set1 = {1, 2, 3}
set1.add(4)
print(set1)
输出的结果为：{1, 2, 3, 4}

2.集合1.update(序列）--->将集合2中的元素添加到集合1中(字典只添加key)

set1.update({'a, b'})
print(set1)
输出的结果为：{1, 2, 3, 4, 'a, b'}

3.删（删除元素）

集合.remove(元素) --->删除指定的元素

六、集合相关的数学运算

集合相关的运算：是否包含，交集，并集，差集，补集

1.包含：>=

集合1 >= 集合2 --->判断集合1中是否包含集合2
集合2 >= 集合1 --->判断集合2中是否包含集合1

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}
print(set1 >= set2)
输出的结果为：True

2.交集 ： &

&:求两个集合公共的部分

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 10, 20}
print(set1 & set2)
输出的结果为：{1, 2, 3}

3.求并集：|

| -->求连个集合的和

4.求差集

集合1-集合2 -->求集合1中出来集合2意外的部分

5.求补集

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

七、类型转换

1.整型

int()
浮点数，布尔、部分字符串可以转换为整型。
只有去掉引号后本身就是一个整数的字符串才能转换为整型

2.浮点数

float()
整数，布尔，部分字符串可以转换为浮点数
只有去掉引号，本身就是一个数字的字符串才能转换为浮点数

3.布尔

bool()
所有的数据都可以转换为布尔值
为空为0的值转换为False,其他的数据都转换为True

4.字符串

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

5.列表

list()
序列才能转换成列表
将序列中的元素作为列表的元素。字典转换成列表，将字典的key作为列表的元素

print(list({'a': 100, 'b': 89}.items()))
输出的结果为：[('a', 100), ('b', 89)]

6.元组

tuple()
只能将序列转换成元组

7.字典

dict()
序列的每个元素有两个元素的数据才能转换成字典

list1 = [(1, 2), ['a', 10]]
print(dict(list1))
输出的结果为：1: 2, 'a': 10}
tuple1 = ((1, 8), {'a', 'b'})
print(dict(tuple1))
输出的结果为：{1: 8, 'b': 'a'}

7.集合

set()
序列可以转换成集合，有去重功能