列表基本概念

# 列表的定义
# ---------------------------------------------------------------------------------------
# 列表（list）是Python中最常用的数据结构之一，是一个有序、可变、可重复的元素集合，使用方括号 [] 定义，元素之间用逗号分隔。
# 使用 list() 函数将其他可迭代对象转换为列表。
# 列表推导式（list comprehension）也是创建列表的一种常用方式。
# 列表的基本特征
# 1. 有序：元素按插入顺序排列
# 2. 可变：可以修改、添加、删除元素
# 3. 可包含任意类型：数字、字符串、列表、字典等
# 4. 可重复：允许相同元素多次出现

# 方法1：使用方括号定义
fruits =['apple','banana','orange']
numbers =[1,2,3,4,5]
mixed = [1,'hello',3.14,True,[1,2,3,4,5]]
travel =['sanya','guilin','lijiang','kunming','wulumuqi','chengdu']
animals = ['cat', 'dog', 'tigger', 'shizi', 'xingxing', 'pig']

# 方法2：使用list()函数
empty_list = list()
from_string = list('i love you')
# ['i', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u']
print(f"使用list()函数将字符串转化为列表：{from_string}")

# 方法3：使用range()函数创建数字列表
list(range(1,6))
print(f"使用range()函数创建数字列表：{list(range(1,6))}，其中列表中最大：{max(list(range(1,6)))},列表中最小值：{min(list(range(1,6)))}，列表中所有元素之和：{sum(list(range(1,6)))}")
even_numbers = list(range(2,110,2))
print(f"使用range()函数创建数字-偶数-列表：{even_numbers}")

# 方法4：使用列表推导式
squaress = [value **2 for value in range(1,11)]
print(f"使用列表推导式创建的列表：{squaress}")
# 使用列表推导式构建奇数列表
jishu = [js for  js in range(1,20,2)]
print(jishu)
# 使用列表推导式构建能被3整除的列表
zhengchu = [zc for zc in range(0,33,3)]
print(zhengchu)
# 使用列表推导式构建立方数列表
lifang = [lf ** 3 for lf in range(1,10)]
print(lifang)

# 对于列表推导式的理解，可以从以下进行理解
# 遍历列表
squares = []
for value in list(range(1,11)):
    square = value ** 2
    squares.append(square)
    print(squares)
print(squares)
# 对于列表推导式的理解2
squares = []
for value in range(1,11):
    square = value ** 2
    squares.append(square)
    print(squares)
print(squares)

#方法5：使用*运算符重复元素
repeated_list = [0] *5
print(f"使用*运算符重复元素构建列表：{repeated_list}")

# 空列表的定义
# 方法1：使用方括号定义空列表
empty_list_1 = []
print(f"使用方括号定义空列表：{empty_list_1},其类型为：{type(empty_list_1)}")

# 方法2：使用list()函数
empty_list_2 = list()
print(f"使用list()函数创建列表:{empty_list_2},其类型为：{type(empty_list_2)}")

# 访问列表的元素
# ------------------------------------------------------------------------------------------------------
# 方法1:正向索引（从0开始）
print(f"通过列表索引的方式访问列表：{fruits[0]}-------------{numbers[0]}-----------{travel[1]}---------{animals[1]}")

# 方法2：负向索引（从-1开始）
print(f"通过列表负向索引的方式访问列表：{fruits[-1]}---------{numbers[-1]}-----------{travel[-1]}---------{animals[-1]}")

# 方法3：访问嵌套列表
matrix = [[1,2,3],[4,5,6],[7,8,9]]
print(f"访问嵌套列表：{matrix[1][-1]}")

# 切片
# -----------------------------------------------------------------------------------------------------
# 基本切片语法：list[start:end:step]
players =['charles','martina','michael','florence','eli']
my_foods =['pizza','falafel','carrot cake']
# 索引从0，1，2，不包括3
print(players[0:3])
# 从开始到索引3，不包括4
print(players[:4])
# 从索引2到列表结束
print(players[2:])
#从索引倒数第3个到列表结束
print(players[-3:])
# 完整的列表浅拷贝
print(f"完整的列表浅拷贝：{players[:]}")
# 步长为2,结果：['charles', 'michael', 'eli']
print(f"步长为2：{players[::2]}")
# 反转列表,结果：['eli', 'florence', 'michael', 'martina', 'charles']
print(f"反转列表：{players[::-1]}")

# 负索引切片,列表最后3个元素
print(f"负向索引切片：{players[-3:]}")
# 除去最后3个元素外的其他元素
print(f"除去列表最后3个元素外的其他列表元素：{players[:-3]}")
# -------------------------------------------------------------
# 遍历切片
for player in players[:3]:
    print(player.title())

# 尝试将一个列表赋值给另一个变量，查看各自添加内容后是否一致
friend_foods = my_foods
print(f"将my_foods赋值给friend_foods后，分别得到两个列表内容：{my_foods},friend_foods:{friend_foods}")
my_foods.append('cannoll')
friend_foods.append('ice cream')
print(f"分别向my_foods及friend_foods,添加不同的元素内容，分别得到my_foods:{my_foods},friend_foods:{friend_foods}")

# 分别向原来的列表，以及切片添加内容
friend_foods = my_foods[:]
my_foods.append('cannoll')
friend_foods.append('ice cream')
print(f"查看切片与原来列表添加内容后是否一致：{my_foods}----------{friend_foods}")

# 检查元素是否存在
# ---------------------------------------------------------------
# 使用 in 关键字
print('martina' in players)
print('florence' in players)
print('score' in players)

# 检查多个元素是否存在
check_list = ['apple','grape','martina','florence']
# 检查是否check_list 中的元素是否都在players中存在
print(all(item in players for item in check_list))
# 检查是否check_list中的某元素在players中存在
print(any(item in players for item in check_list))
# 等价于以下：
for item in check_list:
    if item in players:
        print(True)
        break
    else:
        print(False)

#添加元素到列表  append()
# ----------------------------------------------------------------------------------
# append()在末尾添加单个元素
# 添加单个元素
players.append('qiaodan')
print(f"添加元素后列表内容的展示：{players}")

# 添加列表(整个列表作为一个元素)
players.append(['kebi','yaoming'])
print(f"添加整个列表后列表的内容更新：{players}")

# extend()----扩展列表(添加多个元素)

players_append =['Mayer','zhongmin']
players.extend(players_append)
print(f"players 通过append方法扩展列表后的列表展示内容：{players}")

# extend()   与append() 的区别
# 添加整个列表后列表的内容更新：['charles', 'martina', 'michael', 'florence', 'eli', 'qiaodan', ['kebi', 'yaoming']]
# players 通过append方法扩展列表后的列表展示内容：['charles', 'martina', 'michael', 'florence', 'eli', 'qiaodan', ['kebi', 'yaoming'], 'Mayer', 'zhongmin']

# insert()  在指定位置插入元素
players_1 =['charles','martina','michael','florence','eli']
my_foods_1 =['pizza','falafel','carrot cake']
# 在索引为1 的地方插入‘grape’
my_foods_1.insert(1,'grape')
print(f"在my_foods列表序号为1的地方插入：grape{my_foods_1}")
#在列表开头处插入
my_foods_1.insert(0,'orange')
print(f"在列表开头处插入orange后展示：{my_foods_1}")
# 在列表末尾处插入
my_foods_1.insert(len(my_foods_1),'mianbao')
print(f"在列表末尾处插入mianbao后：{my_foods_1}")

# 使用+运算符合并列表
list_1 = [1,2,3,4,5]
list_2 =[5,6,7,8,9,10]
combined  = list_1 +list_2
print(f"列表合并后的列表：{combined},列表1：{list_1},列表2：{list_2}")

list_1 +=list_2
print(f"此时list_1调整为：{list_1}")

# --------------------------------------------------------------------------------------
#
# --------------------------------------------------------------------------------------
#修改元素列表
# 通过索引直接修改

players_2 =['charles','martina','michael','florence','eli']
my_foods_2 =['pizza','falafel','carrot cake']
# 修改单个元素
players_2[0] ='charles2'
print(f"通过索引修改列表players_2:{players_2}")
# 修改切片
players_2[1:3] = ['yingjie','jiehao']
print(f"通过切片修改列表内容：{players_2}")
# 使用切片插入多个元素
my_foods_2[3:5] =['bingjiling','jidangtan','congbaoniurou']
print(f"使用切片插入多个元素到列表里边：{my_foods_2}")

# 使用列表推导式修改

numbers =[1,2,3,4,5,6,7,8,9]
# 将所有元素立方
lifang =[x **2 for x in numbers]
print(f"使用列表推导式将所有元素立方：{lifang}")
# 有条件的修改
even_lifang =[x ** 2 for x in numbers if x % 2 == 0]
print(f"使用列表推导式使偶数立方：{even_lifang}")

# 删除列表元素
# ---------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------
# 1.del 语句
players_3 =['charles','martina','michael','florence','eli']
my_foods_3 =['pizza','falafel','carrot cake']
# 1)方法1：删除指定索引的元素
del players_3[0]
print(f"通过索引删除players_3中索引为'0'的元素：{players_3}")
# 2)方法2：删除切片
del players_3[0:2]
print(f"通过删除切片的形式删除players_3列表中的切片：{players_3}")
# 3)方法3：删除整个列表
del players_3
# 执行print函数会报错，因为列表已经删除了
# print(f"删除整个列表：{players_3}")

# -----------------------------------------------------------------------------------
# 2.pop()方法删除并返回元素
players_4 =['charles','martina','michael','florence','eli']
my_foods_4 =['pizza','falafel','carrot cake']
# 删除最后一个元素并返回
last =players_4.pop()
print(f"使用pop()删除最后一个元素后列表变为：{players_4},返回的元素为：{last}")
# 删除指定索引的元素
second_element = players_4.pop(1)
print(f"使用pop()删除序号为1的元素后列表变为：{players_4},返回的元素为；{second_element}")
# -------------------------------------------------------------------------------------
# 3.remove()删除指定值的第一个匹配项
players_5 =['charles','martina','michael','florence','eli']
players_5.remove('michael')
print(f"使用remove()删除指定的元素'michael'后列表变成：{players_5}")
# 删除不存在的元素会报错
try:
    players_5.remove('jodan')
except ValueError as e:
    print(f"错误：{e}")
#  4.clear()清除列表
# ----------------------------------------------------------------------------------
players_6 =['charles','martina','michael','florence','eli']
players_6.clear()
print(f"clear()删除列表后变为：{players_6}")

#
# --------------------------------------------------------------------------------
#
# --------------------------------------------------------------------------------
# 列表排序与反转
# 1.sort() 原地排序
# -----------------------------------
numbers = [3, 1, 4, 1, 5, 9, 2]
players_7 =['charles','martina','michael','florence','eli']
# 升序排序
numbers.sort()
print(f"使用sort()方法升序排序：{numbers}")
# 降序排序
numbers.sort(reverse=True)
print(f"使用sort()方法降序排序：{numbers}")
# 按字符串长度排序
players_7.sort(key=len)
print(f"按照字符串长度排序：{players_7}")
# 复杂排序
students = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78}
]
students.sort(key=lambda x:x['score'],reverse=True)
print(students)
# lambda函数
# lambda x: x['score'] 是一个匿名函数
# 等价于
# def get_score(student):
#     return student['score']
#  key 参数的作用
# sort() 根据 key 函数返回的值进行排序,比较的是分数，而不是整个字典

# 2.sorted()-----------返回新的排序列表
#
# ----------------------------------------------
# sorted()返回新的排序列表，原列表不变
numbers_2 = [3, 1, 4, 1, 5, 9, 2]
sorted_numbers = sorted(numbers_2)
print(f"使用sorted()返回新的排序列表，原列表不变：{sorted_numbers}-------------原来的列表为：{numbers_2}")
# sorted()降序序排序
sorted_numbers_jiangxu = sorted(numbers_2,reverse=True)
print(f"使用sorted()降序排序返回新的列表：{sorted_numbers_jiangxu}")

#
# 3.reverse()-------反转列表
# ----------------------------------------------
# 原地反转
numbers_3 = [3, 1, 4, 1, 5, 9, 2]
numbers_3.reverse()
print(f"使用reverse()反转列表后为:{numbers_3}")

# 使用切片反转
reversed_numbers = numbers_3[::-1]
print(f"使用切片反转:{reversed_numbers}")

# 使用reversed()函数
reversed_liter = reversed(numbers_3)
# reversed() 是 Python 中的一个内置函数，用于返回一个反转的迭代器。它不会修改原序列，而是返回一个新的反向迭代器对象。
print(f"使用reversed()函数反转列表:{list(reversed_liter)}")

# 列表搜索与统计
# -------------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------------
# 1.index()查找元素索引
players_8 =['charles','martina','michael','florence','eli','michael','martina','jodan','michael']
# 查找元素的第一个出现位置
index = players_8.index('michael')
print(f"index()查找元素第一个出现的位置:{index}")

# 在指定范围内查找
index = players_8.index('michael',3)
print(f"从列表中元素序号为2开始执行查找:{index}")

# 查找不存在的元素会报错
try:
    index = players_8.index('mac')
except ValueError as e:
    print(f"错误:{e}")

# 统计列表中元素出现的次数
# ----------------------------------------------------------------------
# ---------------------------------------------------------------------
# 统计元素'michael'出现的次数
count = players_8.count('michael')
print(f"统计出现的次数:{count}")

# 统计不存在的元素
count_not_exist = players_8.count('Mayer')
print(f"统计不存在的元素:{count_not_exist}")


# 查找最大值最小值
# -------------------------------------------------------------
numbers_4 = [3, 1, 4, 1, 5, 9, 2]
print(f"查找列表中的最大值:{max(numbers_4)},查找列表中的最小值:{min(numbers_4)}")
# 比较字符串中的第一个字符的acsII码,逐个比较
players_9 =['charles','martina','michael','florence','eli','michael','martina','jodan','michael']
print(f"{max(players_9)}------------{min(players_9)}")
# -----------------------------------------------------------------
# 自定义规则查找
# --------------------------------------------------------------
students_2 = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78}
]
print(f"按照自定义规则查找:{max(students_2,key=lambda x:x['score'] )}")

# max()函数语法:
# max(iterable, *[, default=obj, key=func])
#
#   iterable：必选的位置参数，一个可迭代对象（如列表、元组、字符串等）
#   *[, ...]：特殊的语法表示
#   * 表示后面的参数必须使用关键字参数的形式传递
#   [, ...] 表示方括号内的参数是可选的
#   合起来就是：星号后面的参数必须用关键字指定，且都是可选的
#   default=obj：可选的关键字参数，当可迭代对象为空时返回的默认值
#   key=func：可选的关键字参数，用于指定比较规则的函数

# max(arg1, arg2, *args[, key=func])
#   arg1、arg2：至少需要两个位置参数
#   *args：可变数量的位置参数（0个或多个）
#   表示可以接受任意多个额外参数
#   [, key=func]：可选的关键字参数 key

# ----------------------------------------------------------------
# 列表复制
# ----------------------------------------------------------------
# 浅拷贝(只复制第一层)
original = [1,2,3,4,5,[6,7,8,9]]
# 方法1:   [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy = original.copy()
# 方法2:   [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy_2 = original[:]
# 方法3:   [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy_3 = list(original)
# 方法4;    [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy_4 = original * 1

# 修改浅拷贝  [1000000, 2, 3, 4, 5, [6, 7, 8, 9]]     original = [1,2,3,4,5,[6,7,8,9]]
shallow_copy[0] =1000000
# 修改嵌套列表  [1000000, 2, 3, 4, 5, [6000000000, 7, 8, 9]]    [1, 2, 3, 4, 5, [6000000000, 7, 8, 9]]
shallow_copy[5][0] =6000000000
print(f"浅拷贝:{shallow_copy}----------{original} ")

# -------------------------------------------------------------------------------------------------
# 深拷贝    [1000000, 2, 3, 4, 5, [6000000000, 7, 8, 9]]     [1, 2, 3, 4, 5, [6, 7, 8, 9]]  完全独立,不受影响
import copy
original_2 = [1,2,3,4,5,[6,7,8,9]]
deep_copy = copy.deepcopy(original_2)
deep_copy[5][0] = 6000000000
print(f"深拷贝:{shallow_copy}----------{original_2} ")

# 列表推导式高级用法
# ----------------------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------------------
# 1.基本列表推导式用法
numbers_5 = [3, 1, 4, 1, 5, 9, 2]
# 生成平方数列表  [9, 1, 16, 1, 25, 81, 4]
squres_2 = [x ** 2 for x in numbers_5]
# 生成偶数列表  [4, 2]
even_numbers_2 =[x for x in numbers_5 if x % 2 ==0]

# 2.嵌套列表推导式用法
# 矩阵转置
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
    print(row[0])
transpose = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transpose)
# 等价于
transpose = []
for i in range(len(matrix[0])):
    transpose.append([row[i] for row in matrix])

# 等价于   [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
transpose = []
for i in range(len(matrix[0])):
    result = []
    for row in matrix:
        result.append(row[i])
    transpose.append(result)

#复杂列表推导式
# ---------------------------------------------------
#
# ---------------------------------------------------------
# 生成可能的所有坐标对
points = [(x,y) for y in range(4) for  x in range(5)]
print(points)

# 条件表达式
numbers_6 = [3, 1, 4, 1, 5, 9, 2]
result_4 = ['even'if i % 2 == 0 else 'odd'   for i in numbers_6]
print(result_4)

# 嵌套循环带条件
result_5 = [(m,x) for x in numbers_6 if x % 2 == 0 for m in numbers_6 if m % 2 ==1]
print(result_5)

# 方法	描述	示例
# append(x)	在末尾添加元素	list.append(1)
# extend(iterable)	扩展列表	list.extend([1, 2])
# insert(i, x)	在位置i插入x	list.insert(0, 'first')
# remove(x)	删除第一个值为x的元素	list.remove('apple')
# pop([i])	删除并返回位置i的元素	item = list.pop(0)
# clear()	清空列表	list.clear()
# index(x[, start[, end]])	返回x的索引	idx = list.index('apple')
# count(x)	返回x出现的次数	cnt = list.count(1)
# sort(key=None, reverse=False)	排序	list.sort(reverse=True)
# reverse()	反转列表	list.reverse()
# copy()	浅拷贝列表	new_list = list.copy()