「Python」第一阶段第六章笔记
列表 - list
列表的定义
"""
list 列表
以[]为标识,元素逗号隔开
支持在一个列表写不同类型的数据,且支持嵌套
"""
# 定义空列表
listnone1 = []
listnone2 = list()
# 定义列表
list = ["张三","李四","王麻子"]
print(list)
print(type(list))
list2 = [
["张三","男",18],
["李四","男",18],
["王麻子","男同",19]
]
print(list2)
列表的下标索引
"""
列表的下标索引
"""
list = [
["张三","男",18],
["李四","男",18],
["王麻子","男同",19]
]
# 正序取出
print("----------------")
for x in range(3):
for y in range(3):
print(list[x][y])
print("----------------")
# 倒序取出
for x in range(1,4):
for y in range(3):
print(list[-x][y])
print("----------------")
列表的常用操作
"""
操作列表
"""
list = [1,1,4,6,4]
# 下标查询(第一个出现的)
print(list.index(4))
# 修改特定下标索引的值
print(list)
list[3] = 5;
print(list)
# 插入元素
list.insert(4,1)
print(list)
# 追加元素
list.append(1)
list.append(9)
list.append(1)
list.append(9)
print(list)
# 追加一堆元素
tail = [8,1,0]
list.extend(tail)
print(list)
# 通过下标删除元素 - del
del list[0]
print(f"删除了0号位置上的数字,删除后的结果为 {list}")
# 通过下标删除元素 - pop方法
delnum = list.pop(0)
print(f"删除了0号位置上的数字 {delnum} ,删除后的结果为 {list}")
# 通过值删除元素 - remove方法
list.remove(4)
print(f"通过remove删除了第一个出现的4,删除后的结果为 {list}")
# 清空列表 - clear方法
list.clear()
print(f"通过clear清空了列表,清空后的结果为 {list}")
# 统计某值出现次数 - count方法
list = [1, 1, 4, 5, 1, 4, 1, 9, 1, 9, 8, 1, 0]
cnt = list.count(9)
print(f"数字9在列表{list}中出现了{cnt}次")
# 列表长度 - len函数
print(f"{list}列表有{len(list)}个元素")
列表的遍历
"""
遍历列表
"""
def list_while(list):
"""
while循环遍历列表
:param list: 需要遍历的列表
:return: 无
"""
print("while循环遍历列表")
i = 0
while i < len(list):
print(f"[while] {list[i]}")
i+=1
print("================")
def list_for(list):
"""
for循环遍历列表
:param list: 需要遍历的列表
:return: 无
"""
print("for循环遍历列表")
for x in list:
print(f"[for] {x}")
print("================")
list = [1, 1, 4, 5, 1, 4, 1, 9, 1, 9, 8, 1, 0]
print("================")
list_while(list)
list_for(list)
元组 - tuple
元组就是常量列表
元组的定义
"""
tuple 元组
以()为标识,元素逗号隔开
支持在一个元组写不同类型的数据,且支持嵌套
但不支持修改
"""
# 定义空元组
tnone1 = ()
tnone2 = tuple()
# 定义列表
t1 = ("张三", "李四", "王麻子")
print(t1)
print(type(t1))
t2 = (
("张三","男",18),
("李四","男",18),
("王麻子","男同",19)
)
print(t2)
# 只有一个元素的元组
t3 = ("Hello") # 字符串
print(type(t3))
t3 = ("Hello", ) # 元组
print(type(t3))
元组的下标索引
"""
元组的下标索引
"""
tupe = (
("张三","男",18),
("李四","男",18),
("王麻子","男同",19)
)
# 正序取出
print("----------------")
for x in range(3):
for y in range(3):
print(tupe[x][y])
print("----------------")
# 倒序取出
for x in range(1,4):
for y in range(3):
print(tupe[-x][y])
print("----------------")
元组的常用操作
由于元组不可修改的特性,他的操作很少
"""
操作元组
index方法,count方法,len函数
"""
tupe = (1,2,"Hello",514,"fuck","Hello")
print(f"在长度为{len(tupe)}的元组{tupe}中,\"Hello\"出现了{tupe.count('Hello')}次,第一次在{tupe.index('Hello')}号位置出现")
元组的遍历
"""
遍历元组
"""
def list_while(tupe):
"""
while循环遍历元组
:param list: 需要遍历的元组
:return: 无
"""
print("while循环遍历元组")
i = 0
while i < len(tupe):
print(f"[while] {tupe[i]}")
i+=1
print("================")
def list_for(tupe):
"""
for循环遍历元组
:param list: 需要遍历的元组
:return: 无
"""
print("for循环遍历元组")
for x in tupe:
print(f"[for] {x}")
print("================")
tupe = [1, 1, 4, 5, 1, 4, 1, 9, 1, 9, 8, 1, 0]
print("================")
list_while(tupe)
list_for(tupe)
字符串 - str
"""
字符串 - str
字符串是字符的容器,字符串定义后无法修改
"""
str = "Hello World"
# 下标索引
print(f"str的2号位置是{str[2]}")
print(f"str的-1号位置是{str[-1]}")
# index方法
print(f"\"World出现在str的\"{str.index('World')}号位置")
# replace方法(替换)
str.replace("World","World!!!")
print(str) # 老字符串并没有修改
str2 = str.replace("World","World!!!") # 替换后的字符串作为返回值返回
print(str2) # 新字符串
# split方法(分割) 返回一个列表
str2 = str.split(" ")
print(type(str2),str2)
# strip方法
str2 = " $%Hello World$%$$%"
print(str2.strip()) # 不传入参数默认清除前后空格
print(str2.strip("$% ")) # 传入参数就清除参数里的字符
# count方法 和 len函数 就跳过了,都能用
序列的切片
"""
序列: 连续有序的可以使用下标访问的容器
列表,元组,字符串都算是序列
切片: 从一个序列中取出一个子序列
"""
# 语法: [起始:终止:步长]
# [start,end)
str = "I love u!"
print(str[2:9]) # 步长默认为1
tuple = (0,1,2,3,4,5)
print(tuple[1:5:2])
# 反转
str2 = str[::-1]
print(str2)
# 从头开始
print(str[:-1])
# 到尾结束
print(str[2:])
集合 - set
集合的定义
"""
集合 - set
元素不能重复,内部无序
以{}为标识,元素逗号隔开
"""
# 定义集合
# 空集合
my_set1 = set()
my_set1 = {} # 这个不是空集合,是空字典
# 非空集合
my_set = {"Hello","World","1919810","114514","Hello"}
print(my_set) # 自动去重,无序
集合的常用方法
"""
集合的常用方法
"""
my_set = {"Hello", "World"}
print(my_set)
# add - 添加
my_set.add("114514")
print(my_set)
# remove - 删除
my_set.remove("Hello")
my_set.remove("World")
print(my_set)
# pop - 随即取出
my_set = {"Hello", "World", 114514, 1919810}
print(f"集合{my_set}被取出了{my_set.pop()},变成了{my_set}")
# clear - 清空元素
my_set.clear()
print(f"集合被清空了,变成了{my_set}")
# difference - 差集
# 集合1有集合2没有的元素组成的集合
my_set = {"Hello", "World", 114514, 1919810}
my_set2 = {114,514,1919810,"Hello","world"}
print(f"{my_set.difference(my_set2)}是{my_set}和{my_set2}的差集")
print(f"{my_set2.difference(my_set)}是{my_set2}和{my_set}的差集")
# difference_update - 差集且消除相同
# 集合1变成集合1和集合2的差集
my_set.difference_update(my_set2)
print(my_set)
# union - 并集
my_set = {"Hello", "World", 114514, 1919810}
my_set2 = {114,514,1919810,"Hello","world"}
print(f"{my_set}和{my_set2}的并集是{my_set.union(my_set2)}")
# 集合中不重复,所以没有count方法
print(f"集合{my_set}的长度为{len(my_set)}")
集合的遍历
"""
集合的遍历
因为集合是乱序,不能下标访问
因此不能用while循环
"""
def list_for(my_set):
"""
for循环遍历集合
:param list: 需要遍历的集合
:return: 无
"""
print("for循环遍历集合")
for x in my_set:
print(f"[for] {x}")
print("================")
my_set = {"Hello", "World", 114514, 1919810}
list_for(my_set)
字典- dict
字典的定义
"""
字典 - dict
以{}为标识,元素逗号隔开,每个元素为一个键值对
"""
# 定义空字典
my_dict_none1 = {}
my_dict_none2 = dict()
# 定义非空字典
my_dict = {
"张三": 18,
"李四": 19,
"王麻子": 20
}
字典的key索引
"""
字典的key索引
"""
my_dict = {
"张三": 18,
"李四": 19,
"王麻子": 20
}
# 通过key取出
print(f"张三的年龄: {my_dict['张三']}岁")
字典的常用方法
"""
字典的常用操作方法
"""
my_dict = {
"张三": 18,
"李四": 19,
"王麻子": 20
}
# 新增元素
my_dict["田所赵二"] = 118
# 更新元素
my_dict["田所赵二"] = 114514
# pop方法 - 删除
my_dict.pop("张三")
print(my_dict)
# clear方法 - 清除
my_dict.clear()
print(my_dict)
# keys方法 - 获取所有key
my_dict = {
"张三": 18,
"李四": 19,
"王麻子": 20
}
print(my_dict.keys())
# len函数
字典的遍历
"""
字典的遍历
"""
my_dict = {
"张三": 18,
"李四": 19,
"王麻子": 20
}
keys = my_dict.keys()
# 第一种方法
for k in keys:
print(f"[for|way1]: {k}的年龄是{my_dict[k]}")
# 第二种方法
for k in my_dict:
print(f"[for|way2]: {k}的年龄是{my_dict[k]}")
通用操作
"""
通用操作
"""
my_list = [1,2,3,4,5]
my_tuple = (6,7,8,9,10)
my_set = {11,12,13,14,15}
my_dict = {1:16,2:17,3:18,4:19,5:20}
# len函数
print(
len(my_list),
len(my_tuple),
len(my_set),
len(my_dict),
)
# max函数
print(
max(my_list),
max(my_tuple),
max(my_set),
max(my_dict), # 下标
)
# min函数
print(
min(my_list),
min(my_tuple),
min(my_set),
min(my_dict), # 下标
)
"""
容器转换函数
list(),tuple(),set(),str()
dict()不行,没value
"""
# sorted函数,默认升序
# 传入revers = True可以降序
my_list = [1,1,4,5,1,4]
my_list = sorted(my_list)
print(my_list)
print(sorted(my_list,reverse=True))