这篇博客旨在帮助 C++ 选手快速入门 Python（皮炎通红）。当然 python 的使用过于灵活，而且自带的方法太多，这篇博客尽我所能列举与算法竞赛有关的内容。

循环结构、选择结构与代码规范

python 只用 range_based_for 和 while 循环。比较特殊的是，python有 for else 语法，只是用处非常少。

python 的分支结构使用 if elif else。

python 使用 : 开始一段代码块，使用缩进区分附属关系。python 是强格式语言，与 C++ 不同。

输入输出

python 使用 input() 函数进行输入。input() 是按照行读入的，这意味着它会一直读到换行结束，返回一个从行首开始去掉 '\n' 的字符串。

input(prompt) # input 的函数原型

# 它会先输出字符串 prompt 然后读入一个字符串

# 如果省略了 prompt 参数，用户将不会看到任何提示信息

当 input() 读到 EOF 时，会抛出一个 EOF ERROR。

Traceback (most recent call last):

File "E:\coding\temp\test.py", line 2, in <module>

s = input()

EOFError: EOF when reading a line

还有一种方式是使用 sys.stdin 来读入。但是请注意，如果代码运行在 IDLE 或者其他没有终端的地方时，stdin 默认是 None，这时就不能使用它来读入了【参见 stackoverflow】。

import sys

# 逐行遍历标准输入

for line in sys.stdin:

# 处理每一行数据

line = line.strip() # 去除行末的换行符

print("你输入的行是:", line)

同样的，python 使用 print() 进行输出。 print() 支持不定长参数，它会用 ' ' 隔开每个参数，而且默认在结尾输出换行。 print() 的好处在于 py 中自带的类型都自带了 __str__() 或者 __repr__() 的魔术方法（Magic Methods），甚至如果这两种方法都没有定义， print() 也会直接输出对象的类型信息和内存地址。

我们来看 print() 的函数原型。其中的 * 表示了压缩，它会把输入的参数压缩成一个列表传入函数。注意：这里的 * 写在函数定义中，如果它出现在函数调用中，它就成了解压的操作（压缩的逆运算）。

1 2	print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

看一些示例：

# 输出一个字符串

print("Hello, world!") # Hello, world!

# 输出多个对象，以空格分隔

x = 10

y = 20

print("The value of x is", x, "and the value of y is", y) # The value of x is 10 and the value of y is 20

# 使用 sep 参数自定义分隔符

print("apple", "banana", "cherry", sep=", ") # apple, banana, cherry

# 使用 end 参数自定义结尾

print("Hello", end="")

print(", world!") # Hello, world!

# 输出到文件

with open("output.txt", "w") as f:

print("This is written to a file.", file=f)

# 立即刷新输出缓冲区

print("This message is flushed immediately.", flush=True) # This message is flushed immediately.

我们可以使用格式化字符串或者 f 字符串进行输出。

name = "Alice"

age = 30

# 使用 f 字符串格式化字符串

message = f"Hello, my name is {name} and I am {age} years old."

print(message)

name = "Alice"

age = 30

message = "Hello, my name is %s and I am %d years old." % (name, age)

print(message)

name = "Alice"

age = 30

message = "Hello, my name is {} and I am {} years old.".format(name, age)

print(message)

num = 3.141592653589793

formatted_num = "{:.2f}".format(num)

print(formatted_num) # 输出: 3.14

num = 3.141592653589793

formatted_num = f"{num:.2f}"

print(formatted_num) # 输出: 3.14

num = 3.141592653589793

formatted_num = "%.2f" % num

print(formatted_num) # 输出: 3.14

注释

python 使用 # 注释，等价于 C++ 中的 //。当然还可以使用三引号来进行多行注释，等价于 C++ 中的 /**/

# 这是一个单行注释

'''

这是一个多行注释

这个注释可以跨越多行

'''

"""

这也是一个多行注释

"""

类型

数字类型：（注意 python 自带高精）
- 整数（int）：表示整数值，如 -10、0、42 等。
- 浮点数（float）：表示带有小数点的数值，如 3.14、-0.001、2.0 等。
- 复数（complex）：表示具有实部和虚部的复数，如 3+4j、-2-5j 等。
布尔类型：
- 布尔值（bool）：表示逻辑值，只有两个取值：True 和 False。（注意首字母是大写的）
序列类型：（注意 python 无数组）
- 字符串（str）：表示文本序列，由单引号、双引号或三引号括起来的字符序列，如 'hello'、"world"、'''Python''' 等。（注意是 str 不是 string）
- 列表（list）：表示有序可变序列，由方括号括起来的一组值，值之间用逗号分隔，如 [1, 2, 3]、['a', 'b', 'c'] 等。
- 元组（tuple）：表示有序不可变序列，由圆括号括起来的一组值，值之间用逗号分隔，如 (1, 2, 3)、('a', 'b', 'c') 等。
映射类型：
- 字典（dict）：表示键值对的集合，由花括号括起来，键值对之间用冒号分隔，如 {'name': 'Alice', 'age': 30}。（注意这是哈希表不是平衡树）
集合类型：
- 集合（set）：表示无序不重复元素的集合，由花括号括起来，元素之间用逗号分隔，如 {1, 2, 3}、{'a', 'b', 'c'}。（注意这是哈希表不是平衡树，空集使用 set() 构造而非 {}，后者表示空字典）
NoneType 类型：
- NoneType：表示空值或空对象，只有一个取值：None。

变量与表达式

在 python 中变量无需声明类型，编译器会自动判断类型。而且 python 是一种动态类型语言，这意味着同一个变量的类型是可以改变的，当然，你最好不要这么做。变量名命名与 C++ 相同，不过注意 python 中类的名称必须是首字母大写。值得注意的是，python 支持中文作为变量名。

在 python 中赋值表达式的形式与 C++ 不同：

a, b, c = 1, 2, 3 # 等价于 C++ 中的 a=1,b=2,c=3 注意在 python 中这么写是错误的

# 在 python 中，会首先计算等号右边的表达式然后再赋值给左边

# 这意味着你可以直接实现交换

a, b = b, a # 等价于 C++ 中的 std::swap(a, b);

# 实际上等号在做的事情是将右边的序列依次赋值给左边

# 也就会它会先做一个压缩的操作，在做一个解压的操作

a = [1, 2, 3]

a, b, c = a # 这就是一个解压操作的示例

我们来看 C++ 中的表达式：

算数表达式：

# 加法（+）

result_addition = 10 + 5

print("加法结果：", result_addition)

# 减法（-）

result_subtraction = 10 - 5

print("减法结果：", result_subtraction)

# 乘法（*）

result_multiplication = 10 * 5

print("乘法结果：", result_multiplication)

# 除法（/）注意 int/int 的返回值为 float

result_division = 10 / 5

print("除法结果：", result_division)

# 整除（//）

# 请注意 python 中的整除是向下取整，而不是 C++ 中的向0取整

result_floor_division = 10 // 3

print("整除结果：", result_floor_division)

# 取模（%）

result_modulo = 10 % 3

print("取模结果：", result_modulo)

# 幂运算（**）O(N)

result_power = 10 ** 2

print("幂运算结果：", result_power)

# 使用括号改变运算顺序

result_with_parentheses = (10 + 5) * 2

print("使用括号改变运算顺序结果：", result_with_parentheses)

比较表达式

# 简单的比较表达式

x = 10

y = 5

# 大于（>）

result_greater_than = x > y

print("x 是否大于 y：", result_greater_than)

# 小于（<）

result_less_than = x < y

print("x 是否小于 y：", result_less_than)

# 等于（==）

result_equal_to = x == y

print("x 是否等于 y：", result_equal_to)

# 不等于（!=）

result_not_equal_to = x != y

print("x 是否不等于 y：", result_not_equal_to)

# 大于等于（>=）

result_greater_than_or_equal_to = x >= y

print("x 是否大于等于 y：", result_greater_than_or_equal_to)

# 小于等于（<=）

result_less_than_or_equal_to = x <= y

print("x 是否小于等于 y：", result_less_than_or_equal_to)

# 连续使用

z = 11

print(x <= y <= z) # 等价于 x <= y and y <= z

逻辑表达式

x = 10

y = 5

result = (x > 5) and (y < 10) # 注意优先级 not>and>or

# 注意没有 && || 这种东西

成员表达式：用于检查一个值是否属于某个集合的表达式，结果是布尔值 True 或 False。成员运算符包括 in 和 not in。例如：

x = 10

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

result = x in numbers # False

result = x not in numbers # True

# 注意时间复杂度

# 列表 O(N) 字典和集合 O(1)

身份表达式：用于检查两个对象是否引用同一个内存地址的表达式，结果是布尔值 True 或 False。身份运算符包括 is 和 is not。例如：

x = [1, 2, 3]

y = [1, 2, 3]

result = x is y

位运算表达式：用于对整数进行位运算的表达式，包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）等运算。例如：

x = 5

y = 3

result = x & y

列表表达式：支持多层嵌套

[expression for item in iterable if condition]

# 使用列表表达式过滤偶数

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_numbers = [x for x in numbers if x % 2 == 0]

print(even_numbers) # 输出: [2, 4, 6, 8, 10]

三目运算：这与 C++ 中的三目运算类似

1 2	expression1 if condition else expression2

函数和 lambda 表达式

python 中函数的定义需要写上 def 。定义可以写在任何位置，可以是循环体或者函数体中，不过要注意变量的作用域。

def greet(name):

"""这是一个简单的问候函数"""

print("Hello, " + name + "!")

# 调用函数

greet("Alice")

当然你可以加上类型修饰使得函数更加清晰。这样会使得代码更加安全。

from typing import List

def square_list(nums: List[int]) -> List[int]:

"""将输入列表中的每个元素平方，并返回结果列表"""

return [num ** 2 for num in nums]

# 调用函数

result = square_list([1, 2, 3, 4, 5])

print(result) # 输出: [1, 4, 9, 16, 25]

在函数定义中，你可以使用 * 和 ** 来压缩参数。* 表示压缩成列表，而 ** 表示压缩成字典。

def example_func(*args, **kwargs):

print("Positional arguments (*args):", args)

print("Keyword arguments (**kwargs):", kwargs)

# 调用函数

example_func(1, 2, 3, name='Alice', age=30)

而函数调用的过程中，* 和 ** 用来解压参数。* 用以解压列表，** 用以解压字典。

def example_func(a, b, c):

print("a:", a)

print("b:", b)

print("c:", c)

# 使用*解包列表

args_list = [1, 2, 3]

example_func(*args_list)

# 使用**解包字典

kwargs_dict = {'a': 1, 'b': 2, 'c': 3}

example_func(**kwargs_dict)

我们来看 lambda 表达式。lambda 表达式是一种用于创建匿名函数的特殊语法。它允许你在代码中创建简单的函数，而不需要使用 def 关键字定义一个常规函数。

lambda表达式的基本语法是：

1 2	f = lambda x: int(x + 0.5) # 这是一个四舍五入的lambda表达式示例

文件读写

python 使用 open() 函数打开一个文件。

1 2	open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

我们可以把文件存入一个变量，例如 f = open(file, 'w')。但是这样不够安全，我们可以使用 with 来打开一个文件。

# 逐行读取文件内容

with open('example.txt', 'r') as file:

for line in file:

print(line)

# 打开文件并写入内容

with open('example.txt', 'w') as file:

file.write('Hello, world!')

# 打开文件并读取内容

with open('example.txt', 'r') as file:

content = file.read()

print(content)

迭代器

与 C++ 中的迭代器相同。

迭代器（Iterator）是Python中一种用于遍历可迭代对象（Iterable）的对象。可迭代对象是可以返回一个迭代器的任何对象，包括列表、元组、字典、集合、字符串等。

迭代器提供了一种惰性计算的方式，它允许你逐个访问可迭代对象的元素，而不需要一次性将所有元素加载到内存中。这对于处理大型数据集或无限序列（如生成器）非常有用，因为它可以节省内存并提高效率。

迭代器对象必须实现两个方法：

__iter__() 方法：返回迭代器对象自身，通常直接返回 self。
__next__() 方法：返回可迭代对象的下一个元素，如果没有元素可以返回，则抛出 StopIteration 异常。

# 创建一个迭代器对象

my_iterator = iter([1, 2, 3, 4, 5])

# 使用 next() 函数获取下一个元素

print(next(my_iterator)) # 输出: 1

print(next(my_iterator)) # 输出: 2

print(next(my_iterator)) # 输出: 3

print(next(my_iterator)) # 输出: 4

print(next(my_iterator)) # 输出: 5

# 在迭代器耗尽时，next() 函数会抛出 StopIteration 异常

try:

print(next(my_iterator))

except StopIteration:

print("迭代器已经耗尽")

生成器

生成器（Generator）是一种特殊的迭代器，它以一种延迟计算的方式生成值，而不是一次性产生所有值并保存在内存中。生成器可以通过函数中的 yield 关键字来定义，也可以使用生成器表达式或生成器函数来创建。

生成器函数：通过在函数中使用 yield 关键字来定义生成器。

def my_generator():

yield 1

yield 2

yield 3

# 使用生成器函数创建生成器对象

gen = my_generator()

生成器表达式：类似于列表推导式，但使用圆括号而不是方括号。

# 使用生成器表达式创建生成器对象

gen = (x for x in range(3))

修饰器

修饰器（Decorator）是 Python 中一种强大的元编程特性，它允许修改或增强函数或类的行为，而无需修改它们的源代码。修饰器本质上是一个可调用的对象，它接受一个函数或类作为参数，并返回一个新的函数或类。通过将修饰器应用于函数或类，我们可以在不修改原始函数或类定义的情况下，实现一些额外的功能，如日志记录、性能分析、权限控制等。

修饰器的基本结构如下：

def decorator(func):

def wrapper(*args, **kwargs):

# 在函数调用之前可以执行一些操作

result = func(*args, **kwargs)

# 在函数调用之后可以执行一些操作

return result

return wrapper

# 使用 @ 符号将修饰器应用于函数

@decorator

def some_function():

# 函数的主体逻辑

pass

下面是一个统计函数运行时间的修饰器示例：

import time

def calculate_time(func):

def wrapper(*args, **kwargs):

start_time = time.time()

result = func(*args, **kwargs)

end_time = time.time()

print(f"函数 {func.__name__} 运行时间为: {end_time - start_time} 秒")

return result

return wrapper

# 使用 @ 符号将修饰器应用于函数

@calculate_time

def my_function():

# 模拟函数执行一些耗时操作

time.sleep(2)

print("函数执行完成")

# 调用被修饰的函数

my_function()

在这个示例中，我们定义了一个名为 calculate_time 的修饰器，它接受一个函数作为参数，并返回一个新的包装函数 wrapper。在 wrapper 函数中，我们记录了函数调用开始和结束的时间，并计算了函数的运行时间。最后，我们使用 @calculate_time 将修饰器应用于 my_function 函数，这样当我们调用 my_function() 时，修饰器就会自动记录函数的运行时间，并输出到控制台。

【快速入门】python 与 cp

循环结构、选择结构与代码规范

输入输出

注释

类型

变量与表达式

函数和 lambda 表达式

文件读写

迭代器

生成器

修饰器

面向对象和魔术方法

高级函数

数据结构

一些小 tricks

发表回复取消回复

【快速入门】python 与 cp

循环结构、选择结构与代码规范

输入输出

注释

类型

变量与表达式

函数和 lambda 表达式

文件读写

迭代器

生成器

修饰器

面向对象和魔术方法

高级函数

数据结构

一些小 tricks

发表回复 取消回复

发表回复取消回复