PAT Python预备

1. 使用input()获取命令行的输入

input() 函数是 Python 中用于获取用户输入的一个内置函数。在 Python 3 中，input() 主要用于从控制台读取输入的数据，并将其作为字符串返回。

基本语法

1
input([prompt])

参数说明：

  • prompt: 提示信息

返回类型

input() 函数始终返回一个字符串类型，即使输入的是数字或其他类型的内容。如果需要处理输入为其他数据类型，需要手动进行转换。

1
2
3
number = input("请输入一个数字: ")
# number 是字符串类型
print(type(number))  # <class 'str'>

若要将输入转换为整数或浮点数，可以使用 int() 或 float()：

1
2
number = int(input("请输入一个数字: "))  # 转换为整数
print(type(number))  # <class 'int'>

提示信息

可以向 input() 函数传递一个字符串参数，该参数将在输入时作为提示显示，如：

1
2
3
4
5
6
7
8
9
10
11
# 示例 1：基本的提示信息
name = input("请输入您的名字: ")
print(f"Hello, {name}!")

# 示例 2：提示用户输入数字
age = input("请输入您的年龄: ")
print(f"您输入的年龄是 {age} 岁。")

# 示例 3：可以添加更多说明
email = input("请您输入电子邮件地址（例如：example@example.com）: ")
print(f"您输入的电子邮件地址是 {email}。")

阻塞行为

函数在输入数据并按下回车前会阻塞程序的执行，这意味着程序会在此处暂停，直到接收到输入。

兼容性

在 Python 2 中，input() 函数的行为与 Python 3 中的 eval(input()) 类似。为了读取字符串，Python 2 推荐使用 raw_input() 函数。在 Python 3 中，raw_input() 被重命名为 input() 并改善了用法。

错误处理

在使用 input() 函数时，尤其是进行类型转换时，可能会遇到输入不符合预期的情况（如输入字母而非数字）。可以通过异常处理来捕获这些错误：

1
2
3
4
try:
    age = int(input("请输入您的年龄: "))
except ValueError:
    print("请输入一个有效的整数！")

2. 使用 map() 函数对指定序列做映射

map() 函数是 Python 的一个内置函数，它用于对可迭代对象（如列表、元组等）中的每一个元素应用指定的函数，并返回一个新的可迭代对象（通常是迭代器）。map() 函数简化了对序列数据的处理。

基本语法

1
map(function, iterable, ...)

参数说明：

  • function：一个函数，将应用于 iterable 中的每个元素。这个函数可以是内置函数、自定义函数或 lambda 函数。
  • iterable：一个或多个可迭代对象，例如列表、元组或字符串等。每个可迭代对象中的元素都会被传递到 function 中进行处理。

返回值

  • map() 函数返回一个 map 对象，该对象是一个迭代器。你可以使用 list() 或 tuple() 函数将其转换为列表或元组，便于后续操作。

使用示例

以下是一些 map() 函数的常见用法示例：

示例 1：将列表中的每个元素加倍

1
2
3
numbers = [1, 2, 3, 4, 5]
doubled = map(lambda x: x * 2, numbers)
print(list(doubled))  # 输出: [2, 4, 6, 8, 10]

在这个例子中，使用 lambda 函数对 numbers 列表中的每个元素进行加倍操作。

示例 2：将字符串转为整数

1
2
3
string_numbers = ["1", "2", "3", "4", "5"]
int_numbers = map(int, string_numbers)
print(list(int_numbers))  # 输出: [1, 2, 3, 4, 5]

在这里，map() 函数将 string_numbers 列表中的每个字符串元素转换为整数。

示例 3：处理多个可迭代对象

1
2
3
4
5
list1 = [1, 2, 3]
list2 = [4, 5, 6]

summed = map(lambda x, y: x + y, list1, list2)
print(list(summed))  # 输出: [5, 7, 9]

在这个例子中，map() 函数同时处理两个列表 list1 和 list2，将对应的元素相加。

注意事项

  1. 惰性求值：map() 返回的是一个迭代器，只有在实际迭代或转化成其他数据结构时才会进行计算。
  2. 输入必须匹配：如果传入多个可迭代对象，它们的长度必须一致。否则，map() 在处理时会根据最短的可迭代对象进行处理，超出部分将被忽略。

3. 字符串操作

(1) 字符串切片: split()

split() 函数是 Python 字符串对象的方法之一，用于将字符串分割成多个部分，并将这些部分存储在一个列表中。它非常有用，可以根据特定的分隔符将长字符串分解为更小的子字符串。默认的切分符号是空格符。

基本语法

1
str.split(sep=None, maxsplit=-1)

参数：

  • sep（可选）：指定分隔符，字符串的每一个 sep 将被视为一个分隔点。默认为 None，这意味着字符串将会根据所有的空白字符（空格、制表符、换行符等）进行分割。
  • maxsplit（可选）：指定最大分割次数，默认为 -1，表示分割所有的分隔符。如果设置为一个非负整数，字符串在达到该次数后停止分割。

返回值

  • split() 方法返回一个列表，包含分割后的子字符串。

使用示例

以下是一些 split() 方法的常见用法示例：

示例 1：使用默认分隔符（空白字符）

1
2
3
python复制代码text = "Hello, world! Welcome to Python."
words = text.split()
print(words)  # 输出: ['Hello,', 'world!', 'Welcome', 'to', 'Python.']

在这个例子中，没有指定分隔符，split() 默认使用空白字符分割字符串。

示例 2：使用自定义分隔符

1
2
3
python复制代码csv_data = "name,age,location"
fields = csv_data.split(",")
print(fields)  # 输出: ['name', 'age', 'location']

这里，字符串通过逗号（,）作为分隔符被分割。

示例 3：使用 maxsplit 参数

1
2
3
python复制代码data = "one two three four five"
limited_split = data.split(" ", 2)
print(limited_split)  # 输出: ['one', 'two', 'three four five']

在这个例子中，maxsplit 设置为 2，因此字符串只在前两个空格处分割.

示例 4：处理多余的分隔符

1
2
3
python复制代码text_with_extra_spaces = "  Hello   world  "
words_with_extra_spaces = text_with_extra_spaces.split()
print(words_with_extra_spaces)  # 输出: ['Hello', 'world']

即使字符串中有多个连续的空白字符，split() 也会将其视为一个分隔符，并返回精简的结果。

注意事项

  • 不可逆：split() 方法是不可逆的，一旦字符串被分割，原始字符串的结构就丢失了，不能从分割后的结果恢复回原始字符串。
  • 分隔符的处理：如果字符串的开头或结尾有分隔符，split() 结果中不会包含空字符串部分。

(2) 格式化输出 f-string

在 Python 中，print(f"{...}") 是一种格式化字符串输出的方式，称为“f-string”（格式化字符串字面量）。它是在 Python 3.6 版本中引入的。f-string 使得字符串格式化更加简洁和易读。

基本语法

1
f"你的字符串内容 {表达式}"
  • 在字符串前加一个小写的 f 或 F，表示这是一个格式化字符串。
  • 在字符串中的花括号 {} 内部，可以放入 Python 表达式、变量或函数调用。这些内容将在字符串被处理时被求值并插入到字符串中。

使用示例

以下是一些 f-string 的使用示例：

示例 1：基本变量插入

1
2
3
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")

输出：

1
My name is Alice and I am 30 years old.

在这个例子中，变量 name 和 age 的值被插入到字符串中。

示例 2：表达式求值

1
2
3
x = 10
y = 5
print(f"The sum of {x} and {y} is {x + y}.")

输出：

1
The sum of 10 and 5 is 15.

这里，x + y 是一个表达式，其结果被直接插入到字符串中。

示例 3：格式化数字

f-string 还可以用于格式化数字，例如指定小数位数：

1
2
price = 19.99
print(f"The price is ${price:.2f}.")

输出：

1
The price is $19.99.

在这里，:.2f 表示将 price 格式化为两位小数。

示例 4：嵌套格式化

你可以在 f-string 中嵌套更复杂的表达式：

1
2
person = {"name": "Bob", "age": 25}
print(f"{person['name']} is {person['age']} years old.")

输出：

1
Bob is 25 years old.

示例 5：自定义格式化

1
2
3
4
import datetime

now = datetime.datetime.now()
print(f"Current date and time: {now:%Y-%m-%d %H:%M:%S}")

输出（示例）：

1
Current date and time: 2023-10-10 14:23:45

在这个例子中，使用了自定义日期时间格式。

优缺点

优点：
  1. 简洁易读：f-string 提供了一种直观的方式插入变量和表达式。
  2. 高效：f-string 在性能上比旧的 % 格式化和 str.format() 方法更快。
  3. 强大：支持表达式求值和格式化功能，非常灵活。
缺点：
  1. Python 版本限制：f-string 仅在 Python 3.6 及以后版本可用，对于早期版本的 Python，无法使用。
  2. 不支持多行字符串：虽然可以在使用 f'''...''' 的情况下使用多行字符串，但在多行情境下可能不如传统方法灵活。

4. sorted() 对可迭代对象排序

sorted() 是 Python 的一个内置函数，用于对可迭代对象进行排序，并返回一个新的已排序的列表。它可以对任何可迭代对象（如列表、元组、集合、字符串等）进行排序，具有灵活性和强大的功能。

基本语法

1
sorted(iterable, key=None, reverse=False)
  • iterable：要排序的可迭代对象，如列表、元组、字符串等。
  • key（可选）：一个函数，用于从每个元素中提取用于排序的值。如果未提供，默认使用元素本身进行排序。
  • reverse（可选）：一个布尔值，默认为 False。如果设置为 True，则按降序排序；如果为 False，则按升序排序。

返回值

  • sorted() 返回一个新的列表，是对输入可迭代对象排序后的结果。原始可迭代对象不会被修改。

使用示例

以下是一些常见的 sorted() 使用示例：

示例 1：对列表进行排序

1
2
3
numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 2, 5, 5, 6, 9]

在这个例子中，对列表 numbers 进行升序排序。

示例 2：按字母顺序排序字符串

1
2
3
fruits = ["banana", "apple", "orange"]
sorted_fruits = sorted(fruits)
print(sorted_fruits)  # 输出: ['apple', 'banana', 'orange']

这里，对字符串列表进行按照字母顺序的升序排序。

示例 3：使用 key 参数

1
2
3
words = ["Python", "is", "a", "great", "language"]
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出: ['a', 'is', 'Python', 'great', 'language']

在这个例子中，使用 key=len 按照每个单词的长度进行排序。

示例 4：按降序排序

1
2
3
numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出: [9, 5, 4, 3, 1, 1]

这里，通过设置 reverse=True，实现了对列表的降序排序。

示例 5：对字典进行排序

1
2
3
4
5
6
data = {'a': 3, 'b': 1, 'c': 2}
sorted_keys = sorted(data)  # 默认按键排序
print(sorted_keys)  # 输出: ['a', 'b', 'c']

sorted_items = sorted(data.items(), key=lambda item: item[1])  # 按值排序
print(sorted_items)  # 输出: [('b', 1), ('c', 2), ('a', 3)]

在这个例子中，使用 sorted() 对字典进行排序，默认按照键进行排序，也可以使用 key 参数按照值进行排序。

注意事项

  1. 返回新列表：sorted() 会返回一个新的已排序列表，原始列表不受影响。
  2. 稳定性：sorted() 是一个稳定的排序算法。即如果两个元素被认为是相等的，它们的相对顺序在排序后保持不变。
  3. 原地排序：如果您想就地对列表进行排序并修改原始对象，可以使用列表对象的 .sort() 方法。

5. lambda 表达式

在 Python 中，lambda 函数是一个简明的函数定义方式，通常用于创建小型的、匿名的（不具名的）函数。lambda 函数主要用于需要函数对象的地方，例如作为参数传递给其他函数时。

基本语法

lambda 函数的基本语法如下：

1
lambda 参数列表: 表达式
  • lambda：关键字，用于定义一个匿名函数。
  • 参数列表：可以是一个或多个参数，用逗号分隔。如果没有参数，则为空。
  • 表达式：这是该函数的返回值，lambda 函数只能包含一个表达式，不能包含多个语句。

使用示例

以下是一些 lambda 函数的常见示例：

示例 1：基础用法

1
2
3
4
5
6
# 定义一个简单的 lambda 函数
add = lambda x, y: x + y

# 调用 lambda 函数
result = add(5, 3)
print(result)  # 输出: 8

在这个例子中，add 是一个 lambda 函数，接受两个参数并返回它们的和。

示例 2：作为参数传递

lambda 函数经常用于作为其他函数的参数，特别是像 map()、filter() 和 sorted() 等内建函数。

1
2
3
4
# 使用 lambda 函数与 map()
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

在这个例子中，map() 函数应用了 lambda 函数，对列表中的每个元素进行平方运算。

示例 3：与 filter() 配合使用

1
2
3
# 使用 lambda 函数与 filter()
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4]

在这里，filter() 函数使用 lambda 函数筛选出偶数。

示例 4：与 sorted() 结合使用

1
2
3
4
# 排序列表，按照元组的第二个元素排序
data = [(1, 'one'), (2, 'two'), (3, 'three')]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)  # 输出: [(1, 'one'), (3, 'three'), (2, 'two')]

在这个例子中，sorted() 函数根据每个元组的第二个元素进行排序。

注意事项

  1. 单一表达式：lambda 函数只能包含单个表达式，不能使用多条语句或复杂的流程控制。
  2. 调试困难：由于 lambda 函数没有名称，当出现异常时，调试可能会比较困难，因此一般建议在复杂的情况下使用 def 定义普通函数。
  3. 可读性：过度使用 lambda 函数可能会使代码难以理解，因此在需要实现较复杂逻辑时，使用 def 定义函数会更清晰。

6. list 列表

在 Python 中，列表（list）是一个非常重要的数据结构。它是一种有序的、可变的集合，可以存储多个元素，并且支持多种操作。列表使用方括号 [] 来表示，可以包含任意类型的对象，包括数字、字符串、其他列表等。

列表的基本特性

  1. 有序性：列表中的元素是有序的，存储时的顺序就是元素的索引顺序。索引从 0 开始。
  2. 可变性：列表是可变的，你可以修改列表中的元素、增添元素或删除元素。
  3. 可重复性：列表可以包含重复的元素。
  4. 动态大小：列表的大小可以动态改变，随着元素的增加或删除而变化。

创建列表

你可以直接用方括号创建列表：

1
2
my_list = [1, 2, 3, 4, 5]
mixed_list = [1, "two", 3.0, [4, 5]]

列表的常用方法

1. 添加元素

  • append(item)：在列表末尾添加一个元素。

    1
    my_list.append(6)  # 结果: [1, 2, 3, 4, 5, 6]

  • extend(iterable)：在列表末尾添加多个元素。

    1
    my_list.extend([7, 8])  # 结果: [1, 2, 3, 4, 5, 6, 7, 8]

  • insert(index, item)：在指定位置插入一个元素。

    1
    my_list.insert(0, 0)  # 结果: [0, 1, 2, 3, 4, 5, 6, 7, 8]

2. 删除元素

  • remove(item)：删除列表中第一个匹配的元素。

    1
    my_list.remove(3)  # 结果: [0, 1, 2, 4, 5, 6, 7, 8]

  • pop(index)：删除并返回指定位置的元素。如果不指定索引，默认删除并返回最后一个元素。

    1
    last_item = my_list.pop()  # last_item = 8, 结果: [0, 1, 2, 4, 5, 6, 7]

  • clear()：清空列表，删除所有元素。

    1
    my_list.clear()  # 结果: []

3. 查找元素

  • index(item)：返回第一个匹配项的索引。如果元素不存在，则抛出 ValueError。

    1
    index_of_4 = my_list.index(4)  # 结果: 3

  • count(item)：返回列表中指定元素的出现次数。

    1
    count_of_2 = my_list.count(2)  # 结果: 1

4. 排序与反转

  • sort(reverse=False)：就地对列表进行排序，参数 reverse=True 可以实现降序排序。

    1
    my_list.sort()  # 结果: [0, 1, 2, 4, 5, 6, 7]

  • reverse()：就地反转列表的元素。

    1
    my_list.reverse()  # 结果: [7, 6, 5, 4, 2, 1, 0]

5. 其他方法

  • len(my_list)：返回列表的长度。

    1
    length = len(my_list)  # 获取列表长度

  • min(my_list)：返回列表中的最小值。

    1
    minimum = min(my_list)  # 获取最小值

  • max(my_list)：返回列表中的最大值。

    1
    maximum = max(my_list)  # 获取最大值

  • sum(my_list)：返回列表中所有元素的和（仅适用于数字）。

    1
    total = sum(my_list)  # 获取元素的和
#Python #PAT
PAT Python预备
https://excelius.xyz/pat-python预备/
作者
Excelius
发布于
2025年1月6日
许可协议