grammar

基本语法

Walrus 操作符（海象操作符）

:=

赋值表达式。在 Python 3.8 中引入的新特性。这个操作符允许你在表达式中进行赋值，而不仅仅是语句中。

if (t := sum ^ value) in cnt:
    ans += cnt[t] * key - total[t]

切片操作

用于截取子字符串，子列表也可可以，只要数据类型为 list。

test = 'hello world

# 截取前 7 个字符：hello w
substring = test[:7]
substring = test[0:7]

# 截取第 1 个到第 5 个字符（不包含）：ello
substring = test[1:5]

# 截取后 3 个字符：rld
substring = test[-3:]

# 从第 1 个到第 6 个字符，步长为3（每隔 2 个取一个）：eo
substring = test[1:6:3]
substring = test[::3] # 对整个字符串每隔步长为 3 进行取
substring = test[::-1] # 反转字符串

# 截取到第 1 个空格：hello
substring = test[:test.find(' ')]

nonlocal

用于在嵌套函数中声明一个变量不是局部变量。如果不申明的话，就会将同名变量当作嵌套作用域内部自己的局部变量。

def wrappedFunc() -> None:
    ans = 0
    def insideFunc() -> None:
        nonlocal ans # 声明为非局部变量
        ans += 1

内置方法

join()

用于将一个字符串列表连接成一个单一的字符串。

separator.join(iterable)

count()

获取一个字符串中某个字符的数量。

print('1jjjjj0'.count('j')) # 5

sort()

原地排序。默认从小到大。

arr = [1,4,6,2,4,9]
people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]

# 根据第一项从大到小排序后根据第二项从小到大
people.sort(key = lambda x : (-x[0], x[1])) # [[7, 0], [7, 1], [6, 1], [5, 0], [5, 2], [4, 4]]

split

拆分字符串。

text = "hello world"
words = text.split() # 默认以空格为分隔符 ['hello', 'world']

items()

用于返回字典（dict、Counter）的键值对列表。

Counter 继承于字典。

arr = [1,1,1,2,2,3]
cnt = Counter(arr)
for c in cnt.items():
  print(c)

二进制操作

bit()

返回一个数字的二进制。

但是在 python 中该二进制的数字是以 0b 开头，所以需要进行拆分。

bit(3)[2:] # 11

bit_count()

返回一个数字的二进制形式的 1 的数量。

库函数

Counter()

计数器。专门用于计数元素的频率，默认值是一个整形（0），是一个特殊的字典类。

可以实现类似 js map 的数据结构。

defaultdict(list)

创建一个字典类，当你访问一个不存在的键时，它会自动返回一个默认值（这个是空列表）。

可以实现类似 js map 的数据结构。

idx = {} # {} 被认为是一个空的字典

enumerate()

迭代函数。

对于遍历的数组来说，可以遍历获取它的索引和值。第二个参数可以控制遍历的开始的索引值。

for i, h in enumerate(hours, 1):
  print(i) # 1...

accumulate()

累加函数。

可遍历累加后的值。

sum()

累加函数。

累加遍历的值。

arr = [1, 2, 3, 4, 5]
total1 = sum(arr)
total2 = sum(-(-x // 2) for x in arr)

遍历累加符合的值（找到符合的值将其映射为 1）

max_count = sum(1 for v in cnt.values() if v == max_exec)

max()

遍历元素获取最大值。

• 获取二维数组中的最大值：

# intervals = [[1, 8], [2, 3], [3, 4]]
len = max(max(x) for x in intervals)

list()

动态数组类型，它可以存储任何类型的元素，并且支持动态扩展。

range(start, end, step)

创建一个整数序列，从 start 到 end，步长为 step。

ord()

获取一个字符对应的 Unicode 编码。

all()

用于检测一个可迭代对象（如列表、元组、集合等）中的所有元素是否都为 True 或者是否都满足某个条件。

# all(iterable)
if all(i > 0 for i in [1, 2, 3]):

zip()

将多个可迭代对象（如列表、元组等）中的元素按位置配对，返回一个迭代器。如果可迭代对象的长度不一致，则返回的迭代器长度与最短的可迭代对象相同。

# 将两个列表的元素配对
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)

# 将zip对象转换为列表
zipped_list = list(zipped)
print(zipped_list)  # [(1, 'a'), (2, 'b'), (3, 'c')]

# 直接遍历 zip 对象
for x, y in zipped:
  print(x, y)

# 解码 zip （in place）
a, b = zip(*zipped)
print(a, b) # (1, 2, 3) ('a', 'b', 'c')
print(list(zipped)) # []

set()

将可迭代对象转换为集合。

s = set([2, 3, 3]) # {2, 3}

s1 = s - {2} # {3}

print(s) # {2, 3}

注意：python 可以使用-{}直接减去 set 中的某个值，并且会生成一个新的 set，而不会修改原 set！！！

哇哦！真是方便呢（js 没有，叽叽叽）

permutations

对迭代器进行排列组合。

nums = [1, 2, 3]
for p in permutations(nums):
  print(p)

heapq

使用 heapq 库创建一个小根堆，如果想用大根堆可以将里面的数值变为负数然后再处理。

heapify

初始化堆。

heap = [4,5,7,2,3,9]
heapq.heapify(heap)

heappop

弹出堆顶。

heappush

入堆顶。

heapreplace

弹出堆的最小元素，并将给定的新元素插入到堆中。这个操作是一个原子操作，即在单次操作中完成弹出和插入的过程。

新元素也会根据按照堆进行排序。

itertools

为高效循环创建迭代器的函数。

chain.from_iterable

可用于扁平化数组。

函数定义

函数定义的语法：

使用def来定义一个函数。

• self 是类方法中的第一个参数，它代表类的实例本身。具体来说，在类的方法定义中，self 参数是用来访问类的属性和其他方法的。

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        self.getStr('ert')
    def getStr(self, s: str):
        print(self)

比较

=

python 中的数组其实是一个 list（列表），它是可以直接进行比较的。== 操作符可以用来比较两个列表是否相等，它会逐元素地比较两个列表的内容和顺序是否完全相同。如果两个列表的内容和顺序都相同，则返回 True；否则返回 False。

js 中是不能直接进行数组比较的，数组是引用数据类型，比较的永远是内存地址，永远是 false。

time

该模块提供了各种与时间相关的函数。

此模块中定义的大多数函数的实现都是调用其所在平台的 C 语言库的同名函数。因为这些函数的语义可能因平台而异，所以使用时最好查阅对应平台的相关文档。

下面是一些术语和惯例的解释.

time()

返回以浮点数表示的从 epoch 开始的秒数形式的时间。

epoch 是起始的时间点，即 time.gmtime(0) 的返回值。 这在所有平台上都是 1970-01-01, 00:00:00 (UTC)。

匿名函数（lambda）

lambda arguments: expression

# 定义一个加法的 lambda 函数
add = lambda x, y: x + y
print(add(2, 3))  # 输出: 5

points = [(2, 3), (1, 2), (4, 1)]
# 根据 y 坐标排序
sorted_points = sorted(points, key=lambda p: p[1])
print(sorted_points)

bisect

bisect 是 Python 内置的二分查找模块，用于在已排序的列表中查找元素。

bisect_left

查找元素在列表中的插入位置，如果元素在列表中，则返回该元素左边插入的索引。

arr = [1, 2, 5, 9, 12]
print(bisect.bisect_left(arr, 3)) # 2
print(bisect.bisect_left(arr, 2)) # 1

可以相当于找的是大于等于 target 的第一个元素的索引值。

bisect_right

查找元素在列表中的插入位置，如果元素在列表中，则返回该元素右边插入的索引。

arr = [1, 2, 5, 9, 12]
print(bisect.bisect_right(arr, 3)) # 2
print(bisect.bisect_right(arr, 2)) # 2

可以相当于找的是大于 target 的第一个元素的索引值。

自定义函数（key）

使用二分时可以通过自定义目标值（目标值可以是任何类型）和函数来控制二分的结果和方向。

def check(size: int) -> bool:
    if size < 11:
        return True
    return False
ans = bisect_left(range(20), True, key = check) # 找到 key=True 的值后往左二分，如果找不到则一直往右二分
ans2 = bisect_right(range(20), True, key = check) # 找到 key=True 的值后往右二分，如果找不到则一直往左二分

操作符技巧

//

做除法，向下取整。

# 向下取整
print(5 // 2) # 2

# 向上取整
print(-(-5 // 2)) # 3

math

lcm

找到两个数的最小公倍数。

num = math.lcm(2, 3) # 6

gcd

找到两个数的最大公约数。

num = math.gcd(2, 3) # 1

isqrt

返回一个整数，它是给定整数的平方根。如果给定整数不是平方数，则返回一个小于给定整数的平方数的整数。

num = math.isqrt(9) # 3
num2 = math.isqrt(8) # 2