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 独有功能

  1. 追加 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)
  1. 批量追加,将一个列表中的元素逐一追加到另一个列表 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)
  1. 插入,在原列表的指定索引位置插入值 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)
  1. 在列表中根据值删除 (从左到右找到第一个删除) 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)
  1. 在原列表中根据索引位置删除某个元素 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)
  1. 清空列表 clear
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
tools_list.clear()
  1. 在列表中根据值获取索引 (从左到右,如果重复取最左边的索引值) index  [ 慎用,里面没有会报错 ]
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
if "98K" in tools_list:
    index = tools_list.index("98K")
    print(index)
  1. 列表元素排序 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码点排序
  1. 反转原列表 reverse
# 修改原列表
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
tools_list.reverse()

# 赋值给变量(不对原列表进行修改)
tools_list = ["斧头", "菜刀", "砖头", "AK47", "98K"]
v1 = tools_list[::-1]

1.3 公共功能

  1. 相加:两个列表相加形成一个新的列表
  • 与extend区别:
    • extend会修改原列表
    • 相加复制给一个变量,不修改原列表
tools = ["斧头", "菜刀", "砖头"]
weapon = ["AK47", "98K"]
v1 = tools + weapon
print(v1)
  1. 相乘,列表*整形:将列表的元素再创建N份并生成一个新的列表
tools = ["斧头", "菜刀", "砖头"]
v1 = tools * 2
  1. 运算符 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)
  1. 获取长度
tools = ["斧头", "菜刀", "砖头"]
print(len(tools))
  1. 索引
  • 超出索引范围会报错
tools = ["斧头", "菜刀", "砖头"]

print(tools[0])  # 读取索引位置0的值

tools[0] = "98K"  # 修改索引位置0的值

del tools[1]  # 删元素
del tools  # 删列表
  1. 切片
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:]
  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
  1. 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 转换

  • intbool 无法转换成列表
  • 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 列表练习题

  1. 根据列表实现功能
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]
  1. 如下列表利用切片实现每一个功能
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]
  1. 如下列表,按要求实现每一个功能
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,"火车头")
  1. 用代码实现循环输出元素和值
city = ["北京", "上海", "广州"]
# 输出结果:
# 0 北京
# 1 上海
# 2 广州
for item in range(len(city)):
    print(item, city[item])
"""
for index, name in enumerate(city, 0):
    print(index, name)
"""
  1. 如有变量 city = ["北京","上海","广州"] 提示用户要选择的城市:
# 用户输入索引后,将指定的内容拼接打印,如: 用户输入1则打印 - 您选择的城市是北京

city = ["北京", "上海", "广州"]
for i in range(len(city)):
    print(i + 1, city[i])

choice = input("请选择城市:")
msg = city[(int(choice)) - 1]
print("您选择的城市是{}".format(msg))
  1. 利用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)
  1. 利用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)
  1. 查找列表中的元素,移除每个元素的空格,并找出 "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)
  1. 将以下车牌中所有 的车牌放到一个列表里,并输出京牌车辆的数量
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 公共功能

  1. 相加:两个列表相加形成一个新的元组
tools = ("斧头","菜刀","砖头")
weapon = ("AK47","98K")
v1 = tools + weapon
print(v1)
  1. 相乘,列表*整形:将列表的元素再创建N份并生成一个新的元组
tools = ("斧头","菜刀","砖头")
v1 = tools * 3
print(v1)
  1. 运算符 in 包含,可通过 in 判断元素是否在元组中
tools = ("斧头","菜刀","砖头")
if "菜刀" in tools:                # 如果菜刀在tools中
    index = tools.index("斧头")    # 取斧头的索引号
    print(tools[index])
  1. 获取长度
tools = ("斧头","菜刀","砖头")
print(len(tools))
  1. 索引
  • 超出索引范围会报错
tools = ("斧头","菜刀","砖头")
#          0     1     2
print(tools[0])
  1. 切片
tools = ("斧头","菜刀","砖头")
print(tools[0:2])  # ('斧头', '菜刀')
print(tools[1:])   # ('菜刀', '砖头')
print(tools[:-1])  # ('斧头', '菜刀')
  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)
  1. 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)
"""
posted on 2023-10-20 16:44  龙泉寺老方丈  阅读(39)  评论(0)    收藏  举报