昨日内容回顾
【一】列表类型内置方法
（一）类型强制转换
- 字符串可以转换成列表 字符串中的每一个元素
- 字典 转换为列表以后是 字典的键
- 元组 转换为列表
- 集合 转换为列表 集合的去重性和无序性 ---> 一旦转换成功 这个列表就定死
（二）按照索引取值
- 正向： 从0开始
- 反向：从-1开始
- 可以取值并将取到的值位置的索引值替换掉
- 索引取值的情况下，如果没有索引的值就会报错
（三）切片
-
顾头不顾尾：range
-
[起始位置：截止位置：步长]
-
[：：-1] ：翻转
-
负索引取值的时候第一个起始位置要从右向左取
-
[：：-2]
name = 'gdyandhyt'
print(name[0:4:2]) # gy
- 从右向左开始
name = 'gdyandhyt'
print(name[-1:-4:-1]) # tyh
（四）计算长度
- 语法：len(变量名)
（五）成员运算
-
可以判读当前元素是否在当前列表
-
in
-
not in
-
可以将字典的键转换为列表 用成员运算判断当前输入的用户名是否存在于当前列表中
（六）操作方法
（1）增加
- extend(直接放列表)
- insert(索引位置，值)
- 插入到指定索引位置上
- append() 将元素默认追加到结尾
（2）查看
- 直接打印列表
- 索引取值
（3）删除
- pop() ：如果不写参数则默认删除最后位置的元素 可以将元素弹出可以用变量名接受
- pop(索引)： 直接弹出指定索引位置的元素
- remove(值) ：在列表中存在的值才能被remove
- del 列表[索引位置]： 将从列表中按照索引位置取出来的值删除掉
（4）修改
- 直接索引取值 = 修改的新值
（七）颠倒元素
-
列表.reverse(): 将列表中的所有元素翻转
-
list(reversed(列表))
（八）对列表中的元素进行排序
-
列表.sort() : 将原来的列表进行排序 ---> 影响到的是原来的列表
-
sorted(列表)：有返回值，返回值就是排序后的列表，并且原本的列表不受影响
-
有一个参数 reverse=True:将排序号的结果翻转
（九）遍历列表
- for 循环获取列表中每一个元素
- for + range 关键 ：可以放指定区间 ---> 根据索引坐标获取列表值
- while 列表的长度： 内部有count 根据索引指定索引对应的值
【二】字典类型内置方法
【1】定义风格
- 在一个{}里面放一个k:v键值对
【2】字典操作
（1）增加
- 有则修改，无则添加
- 字典[key] = value
- 字典.update({k:v}) ---> 更新原来的字典
- 字典.update(k=v) ---> 更新原来的字典
- setdefault(k,v) ---> 有返回值返回值是你设置进去的键值对的值
（2）查看
- 字典[key] 取值 ---> 拿到指定键对应的值，取不到会报错
- 字典.get(key) 取值 ---> 拿到指定键对应的值，取不到的话不会报错
- 查看字典的键对 字典.keys() dict.keys 支持成员运算
- 值对 字典.values()
- 键值对 字典.items() ：在列表中存在的一个个的元组 (key,value)
- for key,value in 字典.items(): 解压赋值
（3）修改
（4）删除
- pop() ---> 弹出最后的元素
- del 字典[key]：把查询的键和对应的值全部删除
- 清空字典 字典.clear()
- 删除键值对 字典.popitem()
【3】遍历循环
for key in user: 拿到的值就是键
今日内容
元组内置方法
【一】元组的定义
- 在元组的内部，只有一个元素的时候 + “，”
【二】类型强制转换
- 整数类型和布尔类型不可以
print(tuple([1,2,3]))
print(tuple('dream'))
print(tuple({1,2,2}))
print(tuple({'username':"dream"}))
【三】索引取值
num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(num_tuple[0])
- 切片：顾头不顾尾
- 不支持根据索引修改指定的索引值
num_tuple[0] = 999
【四】计算元素个数
print(len((1,2,3))) # 3
【五】成员运算
print(4 in (1,2,3)) # False
【六】支持遍历
for i in (1,2,3,4):
print(i) # 结果：将1234输出一遍
# for + range ---> 索引取值
【七】元组拼接
- 两个列表+起来 ，可以得到一个新列表，其中包括了两个列表的元素
print([1, 2, 3] + [4, 5, 6]) # [1, 2, 3, 4, 5, 6]
- 两个元组+起来，可以得到一个新元组，其中包括两个元组的的元素
print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)
【八】* 号运算
print((1, 2, 3) * 6) # (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
布尔类型的内置方法
【一】强制类型转换
- 强制将其他类型转换为布尔类型
print(bool(0)) # False
print(bool(1)) # True
print(bool(2)) # True
# 在python中结果为假的情况
# 布尔值false
# 空值
集合类型的内置方法
【一】集合的定义
- 集合是用{}的定义的，并且每一个元素但是单独的，区分与字典的是，字典中是键值对
- 集合内部的元素不能放可变数据类型
【二】集合的特性
-
无序性
- 相对于其他类型来说
-
数字类型的hash值是死的
print({1, 2, 3, 4, 5, 6, 999, 55, 'a', 77, 'c', 44})
- 去重性
- 在一个集合内不会出现重复的元素
【三】其他类型的数据强转
- 强转的时候会沿用集合的特性，无序且去重
name = 'hanyutong'
print(set(name)) # {'u', 'h', 'y', 'a', 'o', 'n', 't', 'g'}
print(set({'username': "hyt", 'password': "123"})) # {'username', 'password'}
【四】集合操作
【1】添加元素
num_set = {1, 2, 3}
num_set.add(999) # add的方法只能添加一个元素
print(num_set) # {1, 2, 3, 999}
num_set.update([1, 2, 3, 4])
num_set.update((4, 5, 6)) # 无论是列表还是元组添加进来之后都是以集合的形式存在
print(num_set) # {1, 2, 3, 4, 5, 6, 999}
-
把注册过的用户名全部扔到集合中
-
利用集合的去重性判断当前用户是否注册过
username_tuple = {'gdy', 'hyt'}
username = input(':>>>')
username_tuple.add(username)
【2】删除元素
- 删除已经存在的值
num_set = {1, 2, 3,999}
num_set.remove(999)
print(num_set) # {1, 2, 3}
- remove 删除集合中不存在的值是会报错
num_set.remove(999) #直接报错
print(num_set)
- discard 删除不存在的元素时不会报错，而是返回原来的集合
num_set.discard(999) #{1, 2, 3}
print(num_set)
- pop 在其他的数据类型可以指定参数，但是在集合中不能指定参数，默认删除左1
num_set = {1, 2, 3,999}
num_set.pop()
print(num_set) # {2, 3, 999}
【五】集合的运算
- 交集 ： 两个集合中共有的元素
set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2)
print(intersection_set) # 输出: {3}
- 并集：将两个集合中的元素合并到一起
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set) # 输出: {1, 2, 3, 4, 5}
- 差集：你有但是我没有的数据
set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2)
print(difference_set) # 输出: {1, 2}
- 判断两个集合是否相等
is_equal = set1 == set2
print(is_equal) # 输出: False
- 将列表转成了集合
list = ['a','b',1,'a']
num = set(list)
print(num) # {'a', 'b', 1}
l_new = list(s) # 再将集合转回列表
print(l_new) # 去除了重复，但是打乱了顺序 # ['b', 'a', 1]
- 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l_second = [
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'jack', 'age': 73, 'sex': 'male'},
{'name': 'tom', 'age': 20, 'sex': 'female'},
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'lili', 'age': 18, 'sex': 'male'},
]
new_l_second = []
for dic in l_second:
if dic not in new_l_second:
new_l_second.append(dic)
print(new_l_second)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
'''
[
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'jack', 'age': 73, 'sex': 'male'},
{'name': 'tom', 'age': 20, 'sex': 'female'}
]
'''