Python学习6 之 【Lambda表达式、列表与元组、推导式】

目录

1.可迭代对象与序列、Lambda表达式

[（2）Lambda 表达式](#（2）Lambda 表达式)

2.元组

（2）创建

（3）元组的不可变性

[（4）count 与 index](#（4）count 与 index)

（5）元组的访问

多变量赋值

3.列表

（2）创建

（3）修改

del

（5）排序

sorted()

（6）反转

reversed()

（7）赋值

（8）复制

4.推导式

---

1.可迭代对象与序列、Lambda表达式

序列一定是可迭代对象，可迭代对象不一定是序列

• 可迭代对象可以"被遍历"，但不一定能按索引取值、不一定有长度
• 序列有顺序、有长度、可下标访问

特性	可迭代对象	序列
for i in obj:	可	可
obj[0] 按索引取值	大部分不行	可
len(obj)	不一定有	可
reversed(obj)	否	可
典型代表	生成器、字典、集合	列表、元组、字符串

（2）Lambda 表达式

• 基础语法

  普通函数

  def add(x, y):
  return x + y

  Lambda 写法

  lambda x, y: x + y

部分	含义	类比普通函数
lambda	关键字，表示"我要写一个匿名函数了"	相当于 def
x, y	参数列表，这里有两个参数	相当于 def add(x, y): 里的 (x, y)
:	分隔符，后面是函数体	相当于普通函数里的冒号 :
x + y	返回值 （自动返回，不用写 return）	相当于 return x + y

• 示例

  按字典某个字段排序

  users = [{"name": "A", "age": 20}, {"name": "B", "age": 15}]

  Lambda 提取 age 作为排序依据

  sorted_users = sorted(users, key=lambda u: u["age"])
  print(sorted_users) # B 在前

  nums = [1, 2, 3, 4, 5]

  用 lambda 过滤偶数（filter 返回迭代器，不是序列）

  evens = filter(lambda x: x % 2 == 0, nums)
  print(list(evens)) # [2, 4]

  用 lambda 做映射计算

  squared = map(lambda x: x**2, nums)
  print(list(squared)) # [1, 4, 9, 16, 25]

  data = ["10", "20", "invalid", "30"]

  过滤并转换，lambda 处理转换逻辑

  cleaned = map(lambda x: int(x) if x.isdigit() else 0, data)
  print(list(cleaned)) # [10, 20, 0, 30]

2.元组

（1）定义

元组是不可变的、有序的、可包含任意类型元素的序列

（2）创建

# 1. 小括号（最常用）
t1 = (1, 2, 3)

# 2. 省略括号（逗号是关键）
t2 = 1, 2, 3          # 这也是元组

# 3. 单元素元组（必须加逗号）
t3 = (1,)             # 不加逗号就是整数 1

# 4. 空元组
t4 = ()

# 5. 使用 tuple() 构造
t5 = tuple([1, 2, 3]) # 从列表转换
t6 = tuple("abc")     # ('a', 'b', 'c')

（2.2）tuple() 函数用法表

参数是可迭代对象

用法分类	代码示例	结果	说明
创建空元组	tuple()	()	创建一个空元组
列表转元组	tuple([1, 2, 3])	(1, 2, 3)	将列表转换为元组
字符串转元组	tuple("hello")	('h', 'e', 'l', 'l', 'o')	将字符串拆分为字符元组
范围转元组	tuple(range(3))	(0, 1, 2)	将 range 对象转换为元组
字典转元组	tuple({'a':1, 'b':2})	('a', 'b')	只转换字典的键
集合转元组	tuple({1, 2, 3})	(1, 2, 3)	将集合转换为元组

（3）元组的不可变性

• 直接修改会报错

操作类型	代码示例	结果
修改元素	t = (1, 2, 3); t[0] = 10	TypeError: 'tuple' object does not support item assignment
追加元素	t = (1, 2); t.append(3)	AttributeError: 'tuple' object has no attribute 'append'
删除元素	t = (1, 2, 3); del t[0]	TypeError: 'tuple' object doesn't support item deletion

• 间接修改的方法（创建新元组）

法	代码	结果	说明
拼接	t1 = (1, 2); t2 = t1 + (3, 4)	(1, 2, 3, 4)	创建新元组
重复	t = (1, 2); t * 2	(1, 2, 1, 2)	创建新元组
切片+拼接	t = (1, 2, 3, 4); t[:2] + (99,) + t[3:]	(1, 2, 99, 4)	替换中间元素
类型转换	t = (1, 2, 3); lst = list(t); lst[1]=99; t2 = tuple(lst)	(1, 99, 3)	转列表修改再转回

• 元组的元素是列表、字典或集合时，可以修改元素内的数据

元组的不可变性 指的是：不能改变元组中存储的引用（即不能改变元组指向哪个对象），但元组内的可变对象本身是可以被修改的

t = (1, [2, 3], 4)
print(t)  # (1, [2, 3], 4)

# 修改列表内容（允许）
t[1].append(99)
print(t)  # (1, [2, 3, 99], 4)

# 修改列表元素
t[1][0] = 100
print(t)  # (1, [100, 3, 99], 4)

# 替换整个列表（不允许）
t[1] = [5, 6]  # TypeError: 'tuple' object does not support item assignment

（4）count 与 index

t = (1, 2, 2, 3, 2, 4, 5)

print(t.count(2))   # 3（2 出现了 3 次）
print(t.count(9))   # 0（不存在的元素返回 0）
print(t.count('a')) # 0（类型不同也算不存在）

t = (10, 20, 30, 20, 40)

# 基本用法
print(t.index(20))      # 1（第一次出现的位置）

# 指定搜索范围（索引 2 到 结束）
print(t.index(20, 2))   # 3（从索引 2 开始找）

# 指定搜索范围（索引 2 到 4）
print(t.index(20, 2, 4)) # 3

# 元素不存在会报错
# t.index(99)  # ValueError: tuple.index(x): x not in tuple

# 安全写法
if 99 in t:
    print(t.index(99))
else:
    print("元素不存在")

（5）元组的访问

元组的访问方式与列表几乎完全相同，支持索引、切片、遍历、解包、成员判断等

访问方式	语法	说明	示例
正向索引	t[index]	从 0 开始	t[0] → 第一个元素
负向索引	t[-index]	从 -1 开始	t[-1] → 最后一个元素
切片	t[start:stop:step]	获取子元组	t[1:4]
遍历	for x in t	逐个访问	-
解包	a,b,c = t	拆分成变量	-
成员判断	x in t	是否存在	5 in t
内置函数	len(t), max(t) 等	统计/计算	-

多变量赋值

多变量赋值是值一次性给多个变量赋值，本质是解包操作

赋值方式	语法	示例	说明
平行赋值	a, b = 1, 2	x, y = 10, 20	最基础的多变量赋值
链式赋值	a = b = c = 1	x = y = z = 0	多个变量赋同一个值
交换变量	a, b = b, a	x, y = y, x	无需临时变量
解包赋值	a, b = (1, 2)	x, y = [10, 20]	从序列中解包
星号表达式	a, *b = (1,2,3)	x, *y = [10,20,30]	收集剩余元素
忽略变量	a, _, c = (1,2,3)	x, _, z = [1,2,3]	用 _ 忽略不需要的值

3.列表

（1）定义

列表是可变的、有序的、可包含任意类型元素的序列
原理：空列表 [] 在布尔上下文中被视为 False，非空列表被视为 True

（2）创建

方式	语法	示例
方括号	[元素1, 元素2, ...]	[1, 2, 3]
list() 构造	list(可迭代对象)	list("abc") → ['a','b','c']
列表推导式	[表达式 for 变量 in 可迭代对象]	[x*2 for x in range(5)]
空列表	[] 或 list()	[]

（3）修改

操作类型	方法/语法	说明
修改元素	lst[i] = x	替换指定位置的元素
切片赋值	lst[i:j] = iterable	替换/插入/删除切片
追加	lst.append(x)	末尾添加一个元素
扩展	lst.extend(iterable)	末尾添加多个元素
插入	lst.insert(i, x)	在指定位置插入
删除	lst.remove(x)（直接删，删不到就报错，pop也是 ）	删除第一个匹配元素
弹出	lst.pop(i)（i省略就弹出最后一个）	删除并返回元素
清空	lst.clear()	删除所有元素
排序	lst.sort()	原地排序
反转	lst.reverse()	原地反转

以上操作均原地修改

del

del 是 Python 的内置语句 ，用于删除对象。它可以删除变量、列表元素、字典键值对、对象属性等

• 特点

特性	说明
类型	语句（Statement），不是函数
语法	del 目标
返回值	无（不返回任何值）
作用	删除变量或容器中的元素
与 pop 区别	pop 返回被删除的值，del 不返回

• 常见用法

用法	语法	说明
删除变量	del var	删除变量本身
删除列表元素	del lst[i]	删除指定索引元素
删除列表切片	del lst[i:j]	删除一段连续元素
删除整个列表	del lst	删除列表对象
删除字典键值对	del d[key]	删除指定键
删除对象属性	del obj.attr	删除属性

Python 中的 del、pop、remove 都是**"逻辑删除"**------删除的是引用，不是物理擦除数据。真正的物理删除需要底层内存操作，Python 中几乎用不到

（5）排序

Python 中列表排序有两种方式：原地排序 和 返回新列表

对比项	list.sort()	sorted()
是否修改原列表	是	否
返回值	None	新列表
适用类型	仅列表	任何可迭代对象
链式调用	不可以	可以
内存占用	更低	更高（需复制）

• list.sort() 原地排序

参数	类型	默认值	说明
key	函数	None	指定排序依据
reverse	bool	False	True 表示降序

# 升序（默认）
lst = [3, 1, 4, 1, 5, 9, 2]
lst.sort()
print(lst)  # [1, 1, 2, 3, 4, 5, 9]

# 降序
lst = [3, 1, 4, 1, 5, 9, 2]
lst.sort(reverse=True)
print(lst)  # [9, 5, 4, 3, 2, 1, 1]

# 按绝对值排序
lst = [-5, 3, -2, 8, -1, 4]
lst.sort(key=abs)
print(lst)  # [-1, -2, 3, 4, -5, 8]

# 按字符串长度排序
words = ["banana", "apple", "cherry", "date"]
words.sort(key=len)
print(words)  # ['date', 'apple', 'banana', 'cherry']

# 按长度降序
words.sort(key=len, reverse=True)
print(words)  # ['banana', 'cherry', 'apple', 'date']

# 按最后一个字符排序
words = ["apple", "banana", "cherry"]
words.sort(key=lambda x: x[-1])
print(words)  # ['banana', 'apple', 'cherry']

sorted()

sorted(iterable, key=None, reverse=False)

参数	说明	默认值
iterable	可迭代对象（列表、元组、字符串、字典等）	必填
key	在排序之前，先拿这个函数把每个元素处理一下，然后按处理后的结果来排序	None
reverse	True=降序，False=升序	False

可迭代对象	原数据	sorted() 结果	原对象是否改变
列表	[3,1,4,1,5]	[1,1,3,4,5]	不变
元组	(3,1,4,1,5)	[1,1,3,4,5]	不变（返回列表）
字符串	"31415"	['1','1','3','4','5']	不变（返回字符列表）
字典	{'a':3,'b':1,'c':4}	['a','b','c']	不变（返回键列表）
集合	{3,1,4,1,5}	[1,3,4,5]	不变

（6）反转

• list.reverse()

项目	说明
语法	list.reverse()
参数	无
返回值	None
是否修改原列表	是（原地修改）
时间复杂度	O(n)
空间复杂度	O(1)（不创建新列表）

lst = [1, 2, 3, 4, 5]

# 原地反转
lst.reverse()
print(lst)  # [5, 4, 3, 2, 1]

# 再次反转恢复
lst.reverse()
print(lst)  # [1, 2, 3, 4, 5]

# 注意返回值
result = lst.reverse()
print(result)  # None

reversed()

reversed() 是 Python 的内置函数 ，用于返回一个反向迭代器

项目	说明
语法	reversed(seq)
参数	序列（列表、元组、字符串、range 等）
返回值	反向迭代器（reversed 对象）
是否修改原序列	= 否
时间复杂度	O(1)（惰性求值）
空间复杂度	O(1)（不创建新列表）

lst = [1, 2, 3, 4, 5]

# 返回迭代器
rev_iter = reversed(lst)
print(rev_iter)  # <list_reverseiterator object at 0x...>

# 转换为列表查看
print(list(rev_iter))  # [5, 4, 3, 2, 1]

# 原列表不变
print(lst)  # [1, 2, 3, 4, 5]

• 支持类型

类型	是否支持	示例
列表	是	reversed([1,2,3])
元组	是	reversed((1,2,3))
字符串	是	reversed("abc") → 'c','b','a'
range	是	reversed(range(5))
字典	否	reversed({'a':1}) 报错
集合	否	reversed({1,2,3}) 报错

（7）赋值

用 = 给列表赋值，不会创建新列表，只是给原对象增加了一个新的引用（别名）

a = [1, 2, 3]
b = a          # 赋值，b 和 a 指向内存中同一个列表

b.append(4)
print(a)       # [1, 2, 3, 4]  a 也被改变了
print(a is b)  # True，两者是同一个对象

（8）复制

复制会创建一个内容相同但内存独立的新列表

• 浅拷贝

只复制最外层容器，内部嵌套的可变对象依然共享引用

import copy

a = [1, 2, [3, 4]]

# 三种浅拷贝方式
b = a.copy()        # 方法1：list 内置方法
c = a[:]            # 方法2：切片全取
d = list(a)         # 方法3：工厂函数
e = copy.copy(a)    # 方法4：copy 模块

# 修改外层，互不影响
b.append(5)
print(a)  # [1, 2, [3, 4]]  不变

# 修改内层可变对象，会互相影响
b[2].append(5)
print(a)  # [1, 2, [3, 4, 5]]  内层列表被改变了！

• 深拷贝

递归复制所有层级，内外完全独立

import copy

a = [1, 2, [3, 4]]
b = copy.deepcopy(a)

b[2].append(5)
print(a)  # [1, 2, [3, 4]]  完全不受影响

操作	写法	外层修改影响原列表？	内层嵌套修改影响原列表？	对象是否相同
赋值	b = a	会	会	是
浅拷贝	a.copy() 等	不会	会	否
深拷贝	copy.deepcopy(a)	不会	不会	否

4.推导式

推导式是 Python 中一种简洁、高效的创建序列（列表、字典、集合）的语法

（1）列表推导式

列表推导式由1个表达式跟一个或多个for 从句、0个或多个if从句构成

列表推导式置于一对方括号之中

[表达式 for 变量 in 可迭代对象 if 条件]

# 1. 生成平方数
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 2. 带条件过滤
evens = [x for x in range(20) if x % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 3. 字符串处理
words = ["hello", "world", "python"]
upper_words = [word.upper() for word in words]
print(upper_words)  # ['HELLO', 'WORLD', 'PYTHON']

# 4. 嵌套循环
pairs = [(x, y) for x in range(3) for y in range(2)]
print(pairs)  # [(0,0), (0,1), (1,0), (1,1), (2,0), (2,1)]

# 5. 条件表达式（三目运算）
results = ["even" if x % 2 == 0 else "odd" for x in range(5)]
print(results)  # ['even', 'odd', 'even', 'odd', 'even']

（2）字典推导式

{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}

# 1. 列表转字典（值：索引）
lst = ['a', 'b', 'c', 'd']
d = {val: idx for idx, val in enumerate(lst)}
print(d)  # {'a': 0, 'b': 1, 'c': 2, 'd': 3}

# 2. 交换键值
original = {'a': 1, 'b': 2, 'c': 3}
swapped = {v: k for k, v in original.items()}
print(swapped)  # {1: 'a', 2: 'b', 3: 'c'}

# 3. 过滤字典
scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'David': 95}
high_scores = {name: score for name, score in scores.items() if score >= 90}
print(high_scores)  # {'Bob': 92, 'David': 95}

# 4. 对值进行运算
prices = {'apple': 5, 'banana': 3, 'orange': 4}
discounted = {item: price * 0.9 for item, price in prices.items()}
print(discounted)  # {'apple': 4.5, 'banana': 2.7, 'orange': 3.6}

（3）集合推导式

{表达式 for 变量 in 可迭代对象 if 条件}

# 1. 去重转换
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_squares = {x**2 for x in numbers}
print(unique_squares)  # {16, 1, 4, 9}

# 2. 过滤并去重
words = ["hello", "world", "hello", "python", "world"]
unique_len = {len(word) for word in words}
print(unique_len)  # {5, 6}

# 3. 条件过滤
even_squares = {x**2 for x in range(10) if x % 2 == 0}
print(even_squares)  # {0, 64, 4, 36, 16}

（4）生成器表达式

特性	列表推导式	生成器表达式
返回值	列表	生成器
内存	一次性分配	惰性求值
适用场景	小数据量	大数据量

(表达式 for 变量 in 可迭代对象 if 条件)

# 1. 基本用法
gen = (x**2 for x in range(10))
print(gen)  # <generator object <genexpr> at 0x...>

# 逐个取值
print(next(gen))  # 0
print(next(gen))  # 1

# 2. 求和（不创建列表）
total = sum(x**2 for x in range(1000000))  # 内存友好

# 3. 转换为列表（需要时）
lst = list(x**2 for x in range(5))
print(lst)  # [0, 1, 4, 9, 16]