Some python grammar

这是一篇从C++算法代码的角度思考，如何速成python语法的文章，笔者由于之前需要通过一项python的算法测试，故编写了这篇文章，现在希望可以帮助大家

输入输出

# 题目描述:
# 第一行是一个整数 n，表示接下来有 n 行数据。
# 接下来的 n 行，每行一个整数。

n = int(input())            # 先读取数据量 n
for i in range(n):          # 循环 n 次
    data = int(input())     # 每次读取一个整数
    # 在这里处理 data...
    print(data * 2)         # 示例：输出两倍


# 读取一行中的两个整数 (用空格分隔)
line = input()              # 读取整行，例如 "5 10"
parts = line.split()        # 按空白字符分割，得到列表 ['5', '10']
a = int(parts[0])           # 转换第一个元素
b = int(parts[1])           # 转换第二个元素

# 更简洁的写法 (常用！)
a, b = map(int, input().split())
# 解释: 
#   input().split() -> ['5', '10'] (字符串列表)
#   map(int, ...) -> 将int函数应用到列表每个元素，得到一个map对象
#   a, b = ... -> 序列解包，把map对象的前两个值分别赋给a和b

# 读取一行k个整数
k = 3
x, y, z = map(int, input().split())  # 如果知道数量

# 或者，如果数量不确定，存入列表
numbers = list(map(int, input().split())) # 得到 [5, 10, 3, 8] 这样的列表

# 题目描述:
# 第一行包含两个整数 n 和 m。
# 接下来 n 行，每行 m 个整数，表示一个 n×m 的矩阵。

# 读取第一行
n, m = map(int, input().split())

# 初始化一个空列表来存储矩阵
matrix = []

# 读取 n 行
for i in range(n):
    # 读取一行，并分割成 m 个整数，存入列表
    row = list(map(int, input().split()))
    matrix.append(row)  # 将这一行添加到矩阵中

# 现在 matrix 是一个二维列表，可以像 C++ 二维数组一样访问
# 例如，matrix[0][0] 是左上角的元素
# matrix[i][j] 是第 i+1 行第 j+1 列的元素

# 示例：计算所有元素的和
total = 0
for i in range(n):
    for j in range(m):
        total += matrix[i][j]
print(total)

print(1, 2, 3)           # 输出: 1 2 3 (默认空格分隔，换行结束)

print(1, 2, 3, sep='-')  # 输出: 1-2-3

print(1, end=' ')        # 输出: 1 (不换行，以空格结束)
print(2)                 # 输出: 2 (换行)
# 最终效果: 1 2

Trick

mid=(l+r)//2 #python不声明类型，/可能出现浮点数，故//为整数除法
TreeNode(nums[mid])#__init__为构造函数，直接调用即可

# 1. 导入必要的模块（如果需要）
import sys
from collections import deque


# 4. 主函数：处理输入、调用算法、输出结果
def main():
    # 读取输入（根据题目要求）
    try:
        line = input().strip()
        # 假设输入是一行整数，如: [-10,-3,0,5,9]
        # 去掉括号，分割，转整数
        nums = list(map(int, line.strip('[]').split(','))) if line.strip('[]') else []
    except:
        print("Invalid input")
        return

    # 创建 Solution 实例并调用方法
    sol = Solution()
    root = sol.sortedArrayToBST(nums)

    # 输出结果（例如：层序遍历输出）
    result = level_order(root)


   print(result)


import sys

data = []
for line in sys.stdin:
    data.append(list(map(int, line.split())))


t = int(input())  # 测试用例数
for _ in range(t):
    n = int(input())
    nums = list(map(int, input().split()))
    # 处理每组数据


self.res = []  # 实例变量，在方法内初始化，可以在其他方法调用



#你将 ans 列表的引用添加到了 res 中。由于 ans 是一个可变对象，并且在整个递归过程中被反复修改（append 和 pop），
#最终 res 中的所有元素都会指向同一个 ans 对象，其值为空（因为最后都 pop() 了），或者状态混乱

res.append(ans[:])  # 使用切片复制列表
res.append(ans.copy())

        left=bisect.bisect_left(nums,target)
        right=bisect.bisect_right(nums,target)

#类似lower_bound和upper_bound

    indices = np.random.permutation(X.shape[0])
np.random.permutation(100)：生成一个从 0 到 99 的整数的随机排列（打乱顺序）
one_hot[np.arange(x.size), x] = 1


num,counts=np.unique(y,return_counts=True)

    # 生成索引,注意不是arrange
    indices = np.arange(n_samples)

    # 是否打乱
    if shuffle:
        np.random.shuffle(indices)

            sampled_indices = np.random.choice(indices, size=n_samples, replace=True)

train_indices = np.concatenate(folds[:i] + folds[i+1:])  # 其余合并为训练集
#类似extend

• input()：读取一行输入，返回字符串。
• split()：按空白字符（空格、制表符、换行）分割字符串。
• map(func, iterable)：对列表中的每个元素应用函数（如 int）。
• list()：将 map 对象转为列表
• n = int(input()) 假如第一行的数字代表数据组个数
• ```pyhton
  folds = np.array_split(indices, 5)
  folds[0] = array([0, 1]) # 第0折：2个样本
  folds[1] = array([2, 3]) # 第1折：2个样本
  folds[2] = array([4, 5]) # 第2折：2个样本
  folds[3] = array([6, 7]) # 第3折：2个样本
  folds[4] = array([8, 9]) # 第4折：2个样本

  
  ## DICT
  
  ```python
  d = {}
  d['key1'] = 100           # 方式1：直接赋值（推荐）
  del d['key1']             # 删除键，不存在会报错 KeyError
  d.pop('key2')             # 删除并返回值，不存在可设默认值 d.pop('key2', None)
  d['key1'] = 999           # 直接赋值修改
  d.update({'key1': 888})   # 批量更新
  value = d['key1']         # 获取值，key 不存在会报错
  value = d.get('key1', -1) # 获取值，不存在返回默认值（推荐）
  'key1' in d               # 检查 key 是否存在，返回 True/False
  d.keys()    # 所有键
  d.values()  # 所有值
  d.items()   # 所有键值对 (key, value)
  
  # 按 key 排序
  sorted_by_key = dict(sorted(d.items(), key=lambda x: x[0]))
  
  # 按 value 排序（从小到大）
  sorted_by_value = dict(sorted(d.items(), key=lambda x: x[1]))
  
  sorted_mp=sorted(mp.items(),key=lambda x:x[1],reverse=True)
  #不转换为dict，因为dict不支持切片，直接用sorted可以转为list
  
  # 从大到小排序
  sorted_by_value_desc = dict(sorted(d.items(), key=lambda x: x[1], reverse=True))

SET

s = set()           # 正确：创建空集合
s = {1, 2, 3}
s.add(4)                  # 添加单个元素
s.update([5, 6])          # 添加多个元素（可迭代对象）
s.remove(4)               # 删除元素，不存在会报错
s.discard(4)              # 删除元素，不存在也不报错
s.pop()                   # 随机删除并返回一个元素（无序！）
s.clear()                 #清空
3 in s                    # 检查元素是否存在，O(1)
s.issubset(other_set)     # 子集判断
s.issuperset(other_set)   # 超集判断
len(s)                    # 元素个数
sorted_list = sorted(s)           # 升序
sorted_list_desc = sorted(s, reverse=True)  # 降序

nums.sort(key=lambda x: (x[0], -x[1]))
#第一个升序，第二个降序

部分	说明
nums.sort()	对列表 nums 原地排序
key=	指定一个函数，告诉 Python 按什么规则排序
lambda x: ...	匿名函数，输入是列表中的每个元素 x，输出是一个“排序键”
(x[0], -x[1])	返回一个元组，作为排序的依据

LIST

dp = [0] * (k + 1)
#用list模拟数组
stack = []
stack.append(1)
stack.append(2)
lst.remove(5)
top = stack.pop()         # 弹出最后一个元素，LIFO
stack[-1] = 99            # 修改栈顶元素
top = stack[-1]           # 查看栈顶（不删除）
3 in stack                # 检查元素是否存在（O(n)）
stack.sort()              # 原地排序（升序）
stack.sort(reverse=True)  # 原地降序
sorted_stack = sorted(stack)  # 返回新列表，不改变原栈

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

# 查找索引
try:
    index = lst.index(2)    # 返回第一个 2 的索引：1
    lst.pop(index)          # 删除该位置
except ValueError:
    print("元素不存在")

lst = [1, 2, 3, 4]

# 删除最后一个
lst.pop()        # 返回 4

# 删除指定索引
lst.pop(0)       # 删除第一个，返回 1

# 或者用 del（不返回值）
del lst[1]       # 删除索引 1 的元素


nums[k:] = nums[k:][::-1]#倒序（reverse）
#使用nums[k:].reverse()会创建新数组，不改变原list，并且返回None
sorted_nums = sorted(nums, key=lambda x: (x[0], -x[1]))

QUEUE

from collections import deque
q = deque()
q.append(1)               # 从右边入队
q.appendleft(0)           # 从左边入队（双端队列特性）
front = q.popleft()       # 从左边出队，FIFO，O(1)
# q.pop()                 # 从右边出队，变成栈
q[0] = 99                 # 修改队首（支持索引访问）
q[-1] = 88                # 修改队尾
orted_list = sorted(q)   # 转为排序列表

操作	dict	set	list (栈)	deque (队列)
增	d[k]=v, d.update()	s.add(), s.update()	lst.append()	q.append(), q.appendleft()
删	del d[k], d.pop(k)	s.remove(), s.discard()	lst.pop()	q.popleft()
改	d[k] = new_v	先删后增	lst[-1] = new_val	q[0] = new_val
查	k in d, d.get(k)	x in s	lst[-1], x in lst	q[0], x in q
排序	dict(sorted(d.items()))	sorted(s)	lst.sort()	sorted(q)

方法	行为	示例
append(iterable)	把整个对象当作一个元素添加	q.append([1,2]) → deque([[1,2]])
extend(iterable)	把可迭代对象的每个元素逐个添加	q.extend([1,2]) → deque([1, 2])

FOR

for i, num in enumerate(nums):  # 更简洁地遍历索引和
for i, char in enumerate(s):
s = "abc"
for char in s:
    print(char)  # a, b, c

# 带索引遍历
for i, char in enumerate(s):
    print(f"{i}: {char}")

# 保留索引不在 `indices_to_remove` 中的元素
result = [value for index, value in enumerate(data) if index not in indices_to_remove]