目录
1. 列表 (list)
操作符(表达式) | 描述 | 重要程度 |
---|---|---|
+ | 合并 | ** |
* | 重复 | ** |
in | 成员资格 | **** |
for i in [1, 2, 3]:print(i) | 迭代 | ***** |
list[2] | 索引取值 | ***** |
list[start:stop:step]、list[::-1] | 切片(截取) | ***** |
方法 | 描述 | 重要程度 |
---|---|---|
list.append(obj) | 列表添加元素到末尾 | ***** |
list.insert(index,obj) | 列表添加元素到指定位置 | ***** |
list.pop(obj) | 删除列表元素 | ***** |
list.remove() | 删除列表元素 | ***** |
list.reverse() | 反转列表的元素 | **** |
list.sort() | 排序 | *** |
list(seq) | 将序列转换为列表 | ***** |
list.extend(seq) | 列表末尾追加多个值 | *** |
list.count(obj) | 统计某个字符在列表内出现的次数 | **** |
list.index(obj) | 找出指定元素的第一个匹配项的索引位置 | *** |
list.clear() | 清空列表 | |
list.copy | 复制列表 | |
list.sort(key=None,reverse=False) | 对原列表进行排序 | |
函数 | 描述 | 重要程度 |
---|---|---|
len(list) | 返回列表的元素个数 | ***** |
max(list) | 返回列表内最大的元素 | ** |
min(list) | 返回列表内最小的元素 | ** |
del obj1, obj2 | 删除列表的元素 | **** |
1.1 定义
city_list = ["北京", "上海", "深圳"]
number_list = [99, 99, 12, -1]
data_list = [1, True, "中国", "邵冲"]
city_list.append("黑龙江")
# 可变类型: 列表(内部数据元素可以修改),直接操作列表内部,不会创建一份新的数据
# 不可变类型: 字符串、布尔、整形(内部数据无法修改),只能根据其新创建一份新的数据
1.2 独有功能
- 追加
append
# 列表.append(值)
data_list = []
v1 = input("请输入姓名:")
v2 = input("请输入年龄:")
data_list.append(v1)
data_list.append(v2)
print(data_list)
# 案例1: 创建一个空列表,用户输入一个加入一个至列表,不限制输入个数,按q退出
user_list = []
while True:
user = input("请输入用户名(q/Q退出):")
if user.upper() == "Q":
break
user_list.append(user)
print(user_list)
# 案例2:
welcome = "欢迎进入游戏".center(20, "*")
print(welcome)
user_count =
while True:
count = input("请输入游戏人数:")
if not count.isdecimal():
print("输入错误,格式必须为数字")
else:
user_count = int(count)
print("{} 人参加了游戏".format(user_count))
break
user_list = []
for i in range(1, user_count + 1):
user = input(f"请输入玩家名称 ({i}/{user_count}):")
name = user
user_list.append(user)
print(user_list)
- 批量追加,将一个列表中的元素逐一追加到另一个列表
extend
# 因为列表是可变的,列表、元组、集合、字典...等都可以追加到列表
tools = ["斧头", "菜刀", "砖头"]
weapon = ["AK47", "98K"]
tools.extend(weapon) # 将weapon中的值逐一追加到tools中
print(tools)
# 等同于
tools = ["斧头", "菜刀", "砖头"]
weapon = ["AK47", "98K"]
for item in weapon:
tools.append(item)
print(tools)
- 插入,在原列表的指定索引位置插入值
insert
# 列表.insert(索引位置,"值")
tools = ["斧头", "菜刀", "砖头"]
tools.insert(0, "AK47") # 在第一个索引前面添加
tools.insert(-1, "98K") # 在最后一个索引前面添加
print(tools)
# 案例:
tools_list = []
while True:
tools = input("请输入武器(Q/q退出):")
if tools.upper() == "Q":
break
if tools.startswith("98"):
tools_list.insert(0, tools)
else:
tools_list.append(tools)
print(tools_list)
- 在列表中根据值删除 (从左到右找到第一个删除)
remove
[ 慎用,里面没有会报错 ]
# 列表.remove(值)
tools_list = ["斧头", "菜刀", "砖头"]
if "菜刀" in tools_list:
tools_list.remove("菜刀")
print(tools_list)
# 抽奖案例
import random
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
while tools_list:
name = input("自动抽奖程序,请输入姓名:")
value = random.choice(tools_list) # 随机从tools_list中抽取一个值出来
print(f"恭喜用户 {name} 抽中 {value}")
tools_list.remove(value)
- 在原列表中根据索引位置删除某个元素
pop
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
tools_list.pop(1) # 删除索引为1的值
# tools_list.pop() # 不加索引默认删除尾部的元素,即"98K"
del_tools = tools_list.pop() # 删除最后一个值,并将删除的值赋值给del_tools
# 案例: 排队买火车票
user_queue = []
while True:
name = input("北京-齐齐哈尔火车票,购买请输入姓名排队(Q/q)退出:")
if name.upper() == "Q":
break
user_queue.append(name)
ticket_count = 3
for i in range(ticket_count):
user_name = user_queue.pop(0)
msg = f"恭喜 {user_name} 买到火车票"
print(msg)
failed_user = "、".join(user_queue)
failed_msg = f"抱歉,票已售完,以下用户请选择其他出行方式,名单:{failed_user}"
print(failed_msg)
- 清空列表
clear
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
tools_list.clear()
- 在列表中根据值获取索引 (从左到右,如果重复取最左边的索引值)
index
[ 慎用,里面没有会报错 ]
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
if "98K" in tools_list:
index = tools_list.index("98K")
print(index)
- 列表元素排序
sort
- 排序时内部元素无法比较时程序会报错,尽量数据类型统一
# 整数排序
num_list = ["11", "222", "32", "0"]
num_list.sort() # 从小到大排序
num_list.sort(reverse=True) # 从大到小排序
# 字符串排序
v1 = ord("斧") # ord: 10进制表示
print(hex(v1)) # hex: 16进制表示
print(bin(v1)) # bin: 二进制表示
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
tools_list.sort() # 从小到大排序 # 根据转换成的unicode码点排序
tools_list.sort(reverse=True) # 从大到小排序 # 根据转换成的unicode码点排序
- 反转原列表
reverse
# 修改原列表
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
tools_list.reverse()
# 赋值给变量(不对原列表进行修改)
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
v1 = tools_list[::-1]
1.3 公共功能
- 相加:两个列表相加形成一个新的列表
- 与extend区别:
- extend会修改原列表
- 相加复制给一个变量,不修改原列表
tools = ["斧头", "菜刀", "砖头"]
weapon = ["AK47", "98K"]
v1 = tools + weapon
print(v1)
- 相乘,列表
*
整形:将列表的元素再创建N份并生成一个新的列表
tools = ["斧头", "菜刀", "砖头"]
v1 = tools * 2
- 运算符
in
包含,可通过in
判断元素是否在列表中
# 案例1:
tools = ["斧头", "刀", "砖头"]
if "菜刀" in tools:
tools.remove("菜刀")
else:
index = tools.index("斧头")
tools.pop(index)
# 案例2:敏感词替换
tools = ["斧头", "菜刀", "砖头"]
text = input("请输入文本内容:")
for item in tools:
text = text.replace(item, "**")
print(text)
- 获取长度
tools = ["斧头", "菜刀", "砖头"]
print(len(tools))
- 索引
- 超出索引范围会报错
tools = ["斧头", "菜刀", "砖头"]
print(tools[0]) # 读取索引位置0的值
tools[0] = "98K" # 修改索引位置0的值
del tools[1] # 删元素
del tools # 删列表
- 切片
tools = ["斧头", "菜刀", "砖头"]
# 读
print(tools[0:2]) # ['斧头', '菜刀']
print(tools[1:]) # ['菜刀', '砖头']
print(tools[:-1]) # ['斧头', '菜刀']
# 改
tools[0:2] = [11, 22, 33, 44] # [11, 22, 33, 44, '砖头']
tools[2:] = [11, 22, 33, 44] # ['斧头', '菜刀', 11, 22, 33, 44]
tools[300:] = [11, 22, 33, 44] # ['斧头', '菜刀', '砖头', 11, 22, 33, 44]
tools[-300:1] = [11, 22, 33, 44] # [11, 22, 33, 44, '菜刀', '砖头']
print(tools)
# 删
del tools[1:]
- 步长
# 步长同样前取后不取
tools = ["斧头","菜刀","砖头","111","22","333","44"]
# 0 1 2 3 4 5 6
# 步长不是负数向前取
print(tools[0::2]) # ['斧头', '砖头', '22', '44'] 0 1 ..-1,步长为2
# 步长是负数往回取
print(tools[6::-2]) # ['44', '22', '砖头', '斧头'] 6 5 .. 0,步长为2
print(tools[1:5:2]) # ["菜刀","111"]
print(tools[1::2]) # ["菜刀","111","333"]
print(tools[4::-1]) # ['22', '111', '砖头', '菜刀', '斧头']
# 案例: 实现列表的翻转
tools = ["斧头", "菜刀", "砖头", "111", "22", "333"]
# 翻转
new_tools = tools[::-1] # ['333', '22', '111', '砖头', '菜刀', '斧头']
# 注意: reverse只能在原列表修改,不能定义变量为新列表
# new2_tools = tools.reverse() # None
- for循环
tools = ["斧头", "菜刀", "砖头", "111", "22", "333"]
for item in tools:
print(item)
for index in range(0, len(tools)):
print(tools[index])
# 倒序输出
for index in range(len(tools) - 1, -1, -1):
print(tools[index])
1.4 转换
int
、bool
无法转换成列表str
# str转list
name = "python"
data = list(name) # ['p', 'y', 't', 'h', 'o', 'n']
# 整数可以转str再转list
v1 = 123
v2 = list(str(v1)) # ['1', '2', '3']
tuple
v1 = (11,22,33,44)
data = list(v1) # [11,22,33,44]
set
v1 = {11,22,33,44}
data = list(v1) # [11,22,33,44]
1.5 其他
嵌套
- 列表属于容器,内部可以存放各种数据,所以支持列表的嵌套:如:
data = ["谢广坤", ["海燕", "赵本山"], True, [11, 22, [999, 123], 33, 44], "宋小宝"]
data[0] # 谢广坤
data[1] # ["海燕","赵本山"]
data[0][2] # 坤
data[1][-1] # 赵本山
data.append(666) # ["谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝",666]
data[1].append(666) # ['谢广坤', ['海燕', '赵本山', 666], True, [11, 22, [999, 123], 33, 44], '宋小宝', 666]
del data[-3] # ['谢广坤', ['海燕', '赵本山', 666], True, '宋小宝', 666]
data[-4][0:2] = ["赵四", "尼古拉斯"] # ['谢广坤', ['赵四', '尼古拉斯', 666], True, '宋小宝', 666]
1.6 列表练习题
- 根据列表实现功能
msg_list = ["Hello", "world", "你好", "世界", "aaa"]
- 计算列表的长度
print(len(msg_list))
- 列表中追加元素
"seven"
msg_list.append("seven")
- 在列表的第一个索引位置插入元素
"Tony"
msg_list.insert(1,"Tony")
- 修改列表的第二个索引位置 元素为
Kelly
msg_list[2] = "Kelly"
- 将列表
data = [1,"a",3,4,"heart"]
的每个元素都加入到msg_list
列表中
msg_list.extend(data)
- 将字符串
s = "qwert"
的每一个元素加入到msg_list
列表中
for item in s:
msg_list.append(item)
# 或
msg_list.extend(s)
- 删除列表中的元素
"你好"
for item in msg_list:
if item == "你好":
msg_list.remove(item)
# 或
del msg_list[3]
# 或
msg_list.pop(3)
- 删除列表中的第二个索引位置元素
del msg_list[2]
# 或
msg_list.pop(2)
- 删除列表中的第2个至第4个元素
del msg_list[2:5]
- 如下列表利用切片实现每一个功能
msg_list = [1, 3, 2, "a", 4, "b", 5, "c"]
- 通过切片形成列表
[1,3,2]
v1 = msg_list[0:3]
- 通过切片形成列表
["a",4,"b"]
v1 = msg_list[3:6]
- 通过切片形成列表
[1,2,4,5]
v1 = msg_list[0:7:2]
# 或
v1 = msg_list[::2]
# 或
v1 = msg_list[:-1:2]
- 通过切片形成列表
[3,"a","b"]
v1 = msg_list[1:6:2]
# 或
v1 = msg_list[1:-1:2]
- 通过切片形成列表
[3,"a","b","c"]
v1 = msg_list[1::2]
- 通过切片形成列表
["c"]
v1 = msg_list[7:]
# 或
v1 = msg_list[-1:]
# 索引的方式
v1 = msg_list[-1]
v1 = msg_list[7]
- 通过切片形成列表
["b","a",3]
v1 = msg_list[5:0:-2]
# 或
v1 = msg_list[-3::-2]
- 如下列表,按要求实现每一个功能
msg_list = [2, 3, "k", ["qwe", 20, ["kl", ["tt", 3, "1"]], 89], "ab", "adv"]
- 将列表中第二个索引位置的值变成大写
# 赋值变量
data = msg_list[2].upper()
# 修改原列表
msg_list[2] = "K"
msg_list[2] = msg_list[2].upper()
- 将列表中的数字
3
变成字符串"100"
msg_list[1] = "100"
msg_list[3][2][1][1] = "100"
- 将列表中的字符串
"tt"
变成数字101
msg_list[3][2][1][0] = "101"
- 在
"qwe"
前面插入字符串"火车头"
msg_list[3].insert(0,"火车头")
- 用代码实现循环输出元素和值
city = ["北京", "上海", "广州"]
# 输出结果:
# 0 北京
# 1 上海
# 2 广州
for item in range(len(city)):
print(item, city[item])
"""
for index, name in enumerate(city, 0):
print(index, name)
"""
- 如有变量
city = ["北京","上海","广州"]
提示用户要选择的城市:
# 用户输入索引后,将指定的内容拼接打印,如: 用户输入1则打印 - 您选择的城市是北京
city = ["北京", "上海", "广州"]
for i in range(len(city)):
print(i + 1, city[i])
choice = input("请选择城市:")
msg = city[(int(choice)) - 1]
print("您选择的城市是{}".format(msg))
- 利用for循环和range找出 1~50以内能被3整除的数,并追加到一个列表
data_list = []
for num in range(51):
if num % 3 == 0 and num != 0:
data_list.append(num)
print(data_list)
- 利用for循环和range找出 1~50以内能被3整除的数,并插入到列表的第0个索引位置,最终结果如下:
# 48,45,42...
num_list = []
for num in range(0, 51):
if num % 3 == 0 and num != 0:
num_list.insert(0, num)
print(num_list)
- 查找列表中的元素,移除每个元素的空格,并找出
"a"
开头的元素,添加到一个新的列表中循环打印
msg_list = ["apple", "AbC", "egon", " riTiAn", "get", " aqc"]
data_list = []
for item in msg_list:
data = item.strip()
if data.startswith('a'):
data_list.append(item)
print(data_list)
- 将以下车牌中所有
京
的车牌放到一个列表里,并输出京牌车辆的数量
msg_list = ["京1231", "冀8889", "京11833", "晋989"]
new_list = []
for item in msg_list:
data = item.strip()
# if "京" not in data: # 判断是否不包含"京"
if not data.startswith("京"): # 判断是否不以"京"开头
continue
new_list.append(data)
print(len(new_list))
1.7 列表去重技巧
data_list = [11, 22, 'aa', 'bb', 22, 'aa']
# 使用集合的特性
data_set = set(data_list)
data_list = list(data_set)
2. 元组 (tuple)
-
列表:是一个有序且可变的容器,在里面可以存放多个不同类型的元素
-
元组:是一个有序且不可变的容器,在里面可以存放多个不同类型的元素
-
元组是可哈希的,但一旦元组中嵌套了列表等可变类型,元组便不可哈希了
元组套列表:元组内的元素不可修改,元组中的列表元素中的元素可以修改
列表套元组:列表内的元组可以删除,列表中的元组的元素无法修改
方法 | 功能 |
---|---|
len(tuple) | 计算元组元素个数。 |
max(tuple) | 返回元组中元素最大值。 |
min(tuple) | 返回元组中元素最小值。 |
tuple(iterable) | 将可迭代系列转换为元组。 |
2.1 定义
city_list = ("北京","上海","深圳")
number_list = (99,99,12,-1)
data_list = (1,True,"中国","邵冲",[11,22,33]) # 元组中的列表类型[11,22,33]可以增加和减少,但元组自身元素数量不可以增加和减少
# 建议在元组的最后多加一个逗号,用于标识它是一个元组
v1 = (11,22,"abc",)
1. 比较 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别
# 整数 # 整数 # 元组
2. 比较 v1 = ((1),(2),(3)) 和 v2 = ((1,),(2,),(3,),)
# 元组(1,2,3) # 元组((1,), (2,), (3,))
2.2 独有功能
无,元组是不可变的
2.3 公共功能
- 相加:两个列表相加形成一个新的元组
tools = ("斧头","菜刀","砖头")
weapon = ("AK47","98K")
v1 = tools + weapon
print(v1)
- 相乘,列表*整形:将列表的元素再创建N份并生成一个新的元组
tools = ("斧头","菜刀","砖头")
v1 = tools * 3
print(v1)
- 运算符
in
包含,可通过in
判断元素是否在元组中
tools = ("斧头","菜刀","砖头")
if "菜刀" in tools: # 如果菜刀在tools中
index = tools.index("斧头") # 取斧头的索引号
print(tools[index])
- 获取长度
tools = ("斧头","菜刀","砖头")
print(len(tools))
- 索引
- 超出索引范围会报错
tools = ("斧头","菜刀","砖头")
# 0 1 2
print(tools[0])
- 切片
tools = ("斧头","菜刀","砖头")
print(tools[0:2]) # ('斧头', '菜刀')
print(tools[1:]) # ('菜刀', '砖头')
print(tools[:-1]) # ('斧头', '菜刀')
- 步长
tools = ("斧头","菜刀","砖头","111","22","333")
# 0 1 2 3 4 5
print(tools[1:4:2]) # ("菜刀","111")
print(tools[0::2]) # ("斧头","砖头""22")
print(tools[1::2]) # ("菜刀","111","333")
print(tools[4::-1]) # ('22', '111', '砖头', '菜刀', '斧头')
# 翻转元组
tools = ("斧头","菜刀","砖头","111","22","333")
data = tools[::-1]
print(data)
- for循环
tools = ("斧头", "菜刀", "砖头", "111", "22", "333")
for item in tools:
print(item)
for index in range(0, len(tools)):
print(tools[index])
2.4 转换
- 其他类型转换为元组,使用
tuple(其他类型)
,整数
和布尔
无法转换
v1 = "a1c"
data1 = tuple(v1) # ("a",1,"c")
v2 = ["a",1,"c"]
data2 = tuple(v2) # ("a",1,"c")
2.5 其他
嵌套
由于元组和列表属于容器,内部可以存放各种数据,所以也支持元素内的嵌套:如:
data = ("谢广坤", ("海燕", "赵本山"), True, (11, 22, (999, 123), 33, 44), "宋小宝")
print(data[0]) # 谢广坤
print(data[1]) # ("海燕","赵本山")
print(data[0][2]) # 坤
print(data[1][-1]) # 赵本山
3. 练习题
# 练习题1:
my_list = ["hello", [11, 22, (88, 99, 100,), 33], "China", ("a", "b",), "world"]
# 0 1 2 3 4
# 1. 将"China" 修改成 "中国"
my_list[2] = "中国"
# 或
index = my_list.index("China")
my_list[index] = "中国"
# 2. 将 ("a", "b",) 修改为 ["a","b"] # 元组可以转换为列表
my_list[3] = ["a", "b"]
# 3. 将 88 修改为 77 (不能实现,元组不能直接修改)
# 4. 将 "world" 删除,然后再在列表第0个索引位置插入"世界"
my_list.remove("world") # 也可以使用list.pop(-1) 或 del list[-1]
my_list.insert(0, "世界")
---------------------------------------------
# 练习题2:
data = ("123", 666, [11, 22, 33], ("abc", "李姐"), [999, 666, (5, 6, 7)])
# 1. 将 "123" 替换成 9 # (不能实现,元组不能直接修改)
# 2. 将[11,22,33]改成"abc" # (不能实现,[11,22,33]整体属于元组不能直接修改替换为其他类型)
# 3. 将 11 换成 99
data[2][0] = 99
# 4. 在[11,22,33]中追加一个44
data[2].append(44)
---------------------------------------------
# 练习题3: 输入三个用户名和密码为元组,并添加到用户的列表中
user_list = []
for num in range(3):
user = input("请输入用户名:")
pwd = input("请输入密码:")
item = (user, pwd,)
user_list.append(item)
print(user_list)
---------------------------------------------
# 练习题4: 用户登陆案例
user_list = [('root', '123'), ('look', 'abc'), ('guest', 'abc123')]
is_success = False
print("登陆程序".center(20, "-"))
user = input("请输入用户名:")
pwd = input("请输入密码:")
for item in user_list:
if user == item[0] and pwd == item[1]:
is_success = True
break
if is_success:
print("登陆成功")
else:
print("登陆失败")
---------------------------------------------
# 练习题5: 根据规则生成扑克牌
# 花色列表
color_list = ["红桃", "黑桃", "梅花", "方片"]
# 牌值
num_list = []
for num in range(1, 15):
num_list.append(num)
result = []
# 补充代码将result的结果格式变为: [("红桃",1),("红桃,2")... ]
"""
for color in color_list:
for num2 in num_list:
item = (color, num2)
result.append(item)
print(result)
"""