三元表达式

以及其在字符串格式化中的运用

  • 基本语法:value_if_true if condition else value_if_false

    • 使用情况:
    • condition是一个布尔表达式,值为true或者false

  • 一句话说完怎么用:中间为true,返回左边,为false,返回右边

  • 比如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from PyPDF2 import PdfReader
import os

# 打开文档
pdf_path = os.path.abspath('text.pdf')

with open(pdf_path, 'rb') as f:
    pdf = PdfReader(f)
    # 获取文档信息，注意这里原来是.getDocumentInfo，现在直接使用属性访问
    information = pdf.metadata
    # 获取页数，原来的 getNumPages 已弃用，使用 len(pdf.pages)
    number_of_pages = len(pdf.pages)

    text = f'''
    Information of {pdf_path}:
    Author: {information.author if information.author else "N/A"}
    Creator: {information.creator if information.creator else "N/A"}
    Producer: {information.producer if information.producer else "N/A"}
    Subject: {information.subject if information.subject else "N/A"}
    Title: {information.title if information.title else "N/A"}
    Number of Pages: {number_of_pages}
    '''
    print(text)

这里面在输出文本的时候,如果中间的information.author有这个值的话,即为True,使用左边的值,如果不存在,即为False,那么返回右边的值

Python列表推导式

简单来说,它的作用就是简单生成一个列表

生成列表:

对于for i in range(1,10),这个简单的式子要生成列表:

1
2
result = [number_list for a in range(1,10)]
print(result)

这里的结果为:
[1,2,3,4,5,6,7,8,9]
而不是像for i in range(1,10)
单纯输出1,2,3…

举个例子:

1
2
3
4
5
from pprint import pprint

conversation_history = [("How's it going", "Good"),("Bob", "Nice to meet you")]
result = [f"User:{q}, Bot:{a}" for q, a in conversation_history]
print(result)

相当于for前面的就是for后面两个参数在每次迭代的时候,要赋值的位置,q,a就是对每次迭代的元组里的两个值进行了定义。

嵌套关系:

它的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是 0 个或多个 for 或者 if 语句。那个表达式可以是任意的，意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表，在这个以 if 和 for 语句为上下文的表达式运行完成之后产生。 列表推导式的执行顺序：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，左边第一条语句是最后一层。 [x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]
他的执行顺序是:

1
2
3
4
5
for x in range(1,5)
    if x > 2
        for y in range(1,4)
            if y < 3
                x*y

zip函数

zip 函数基础：zip 函数在Python中用于将多个可迭代对象（如列表、元组等）中的元素按顺序配对，返回一个可迭代的 zip 对象。例如： 

1
a = [1, 2, 3] b = ['a', 'b', 'c'] zipped = zip(a, b) print(list(zipped)) ``` 上述代码中，`zip(a, b)` 将 `a` 和 `b` 中的元素按顺序配对，输出 `[(1, 'a'), (2, 'b'), (3, 'c')]`。

* 解包操作符：* 在Python中可以用于解包可迭代对象。例如： python my_list = [1, 2, 3] print(*my_list) 这里的 *my_list 会将 my_list 解包，等同于 print(1, 2, 3)，输出 1 2 3。 3. texts, labels = zip(*train_data) 解释：假设 train_data 是一个列表，其中每个元素是一个包含两个元素的元组，

  • 例如 train_data = [('问题1', 0), ('问题2', 1), ('问题3', 0)]。这里的 *train_data 会将 train_data 解包，即把 [('问题1', 0), ('问题2', 1), ('问题3', 0)] 变成 ('问题1', 0), ('问题2', 1), ('问题3', 0)。

  • 然后 zip 函数作用于这些解包后的元组，将它们的第一个元素组合在一起，第二个元素组合在一起。也就是把所有问题文本组合成一个可迭代对象，所有标签组合成一个可迭代对象。

  • 最后，通过 texts, labels =... 将这两个可迭代对象分别赋值给 texts 和 labels。所以 texts 会是一个包含所有问题文本的可迭代对象（如 ('问题1', '问题2', '问题3')），labels 会是一个包含所有标签的可迭代对象（如 (0, 1, 0)）。

  • 在实际应用中，这一步常用于将训练数据集中的文本和对应的标签分开，以便后续分别用于特征提取（对 texts 操作）和模型训练（同时使用 texts 对应的特征和 labels）。例如在之前的朴素贝叶斯文本分类代码中，后续会对 texts 使用 CountVectorizer 进行特征提取，然后用提取的特征和 labels 来训练朴素贝叶斯分类器。

lambda匿名函数

1. 定义与基本概念

在 Python 中，lambda 函数也被称为匿名函数，它是一种轻量级、临时的、没有名称的函数。常规函数使用 def 关键字来定义，而 lambda 函数使用 lambda 关键字来创建。

2. 语法结构

lambda 函数的基本语法如下：

1
lambda 参数列表: 表达式
  • 参数列表：这部分用于定义函数接收的参数，可以包含零个、一个或多个参数。如果有多个参数，它们之间用逗号分隔。
  • 表达式：这是 lambda 函数的核心部分，函数会计算这个表达式的值并将其作为返回结果。需要注意的是，lambda 函数只能包含一个表达式，不能包含多条语句。

3. 简单示例

以下是几个不同形式的 lambda 函数示例：

  • 无参数的 lambda 函数：
1
2
get_five = lambda: 5
print(get_five())  # 输出: 5

在这个例子中，lambda 函数不接收任何参数，每次调用时都会返回数字 5。

  • 单参数的 lambda 函数：
1
2
square = lambda x: x ** 2
print(square(4))  # 输出: 16

这里的 lambda 函数接收一个参数 x，并返回 x 的平方。

  • 多参数的 lambda 函数：
1
2
add = lambda a, b: a + b
print(add(3, 7))  # 输出: 10

此 lambda 函数接收两个参数 a 和 b，并返回它们的和。

4. 应用场景

4.1 作为参数传递给高阶函数

lambda 函数常被用作高阶函数（如 map()、filter()、sorted() 等）的参数，用于定义简单的操作逻辑。

  • map() 函数示例：
1
2
3
numbers = [1, 2, 3, 4]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # 输出: [1, 4, 9, 16]

在这个例子中，map() 函数会将 lambda 函数应用到 numbers 列表的每个元素上，返回一个包含平方结果的迭代器，最后使用 list() 函数将其转换为列表。

  • filter() 函数示例：
1
2
3
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4, 6]

这里的 filter() 函数会根据 lambda 函数的条件过滤 numbers 列表中的元素，只保留能被 2 整除的元素。

  • sorted() 函数示例：
1
2
3
students = [('Alice', 25), ('Bob', 20), ('Charlie', 22)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students)  # 输出: [('Bob', 20), ('Charlie', 22), ('Alice', 25)]

在这个例子中，sorted() 函数根据 lambda 函数指定的规则对 students 列表进行排序，排序的依据是每个元组的第二个元素（年龄）。

4.2 临时使用的简单函数

当你只需要一个简单的函数，并且这个函数只在特定的代码片段中使用一次时，使用 lambda 函数可以避免定义一个完整的常规函数，使代码更加简洁。

5. 局限性

  • 功能受限：由于 lambda 函数只能包含一个表达式，它无法实现复杂的逻辑，如循环、条件判断语句块等。如果需要实现复杂的功能，还是应该使用常规的 def 函数。
  • 可读性问题：虽然 lambda 函数可以让代码更简洁，但如果表达式过于复杂，会降低代码的可读性，因此在使用时需要权衡简洁性和可读性

匿名函数闭包问题

  • 本质:闭包问题的根源在于匿名函数在定义时不会立即获取外部变量的值，而是在调用时才去获取。当外部变量的值在函数调用前发生了改变，就会导致所有函数获取到的是同一个最终值。使用默认参数可以在函数定义时就将当前变量的值保存下来，为每个函数创建独立的变量副本，从而避免闭包问题。

  • 错误代码:

  • functions = []
for k in range(3):
    functions.append(lambda: k)

for func in functions:
    print(func())

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    * 这里的输出为:`2,2,2`

      原因:

      `for`循环中`k`的值会依次取为`0,1,2`,但是每次循环就单纯把这个匿名函数添加到了列表中，没有其他操作，`k`最后的值为`2`。

    * 在第二个`for`循环中,`print()`函数的调用也是调用了`lamba`匿名函数，但是此时的`k`值为`2`,所以三个逐个调用都是输出`2`。

    * 正确代码:

    * ```python
      functions = []
      for k in range(3):
          functions.append(lambda x=k: x)#主要是这个地方进行了修改
      
      for func in functions:
          print(func())

  • 在这个修改后的代码中，使用了默认参数 x=k，这样每个匿名函数在定义时就把当前 k 的值保存下来了(相当于进行了调用)，调用时就能返回不同的值。

.key()方法

在 Python 中，.keys() 是字典（dict）、pandas 的 Series 和 DataFrame 等数据结构的常用方法，作用是获取数据结构中所有的键（key）。

  1. 字典（dict）的.keys() 方法：对于字典，.keys() 方法返回一个可迭代对象，包含字典中所有的键。这个可迭代对象可以直接用于循环遍历，也能转换为列表等其他数据类型。示例如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['name', 'age', 'city'])
# 转换为列表
keys_list = list(keys)
print(keys_list)  # 输出: ['name', 'age', 'city']
# 直接用于循环
for key in my_dict.keys():
    print(key)  
# 输出:
# name
# age
# city
  1. pandas 的 Series 的.keys() 方法：在 pandas 的 Series 中，.keys() 方法返回 Series 的索引（index）。Series 可以看作是带索引的一维数组，索引类似于字典中的键。示例如下：
1
2
3
4
import pandas as pd
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
keys = s.keys()
print(keys)  # 输出: Index(['a', 'b', 'c'], dtype='object')
  1. pandas 的 DataFrame 的.keys() 方法：对于 pandas 的 DataFrame，.keys() 方法返回 DataFrame 的列名。DataFrame 是二维表格结构，列名类似于字典中的键。示例如下：
1
2
3
4
5
import pandas as pd
data = {'name': ['Alice', 'Bob'], 'age': [25, 30]}
df = pd.DataFrame(data)
keys = df.keys()
print(keys)  # 输出: Index(['name', 'age'], dtype='object')