小白刷题笔记2024.12.

Python刷题笔记

12.23

range(n, i - 1, -1)#生成从 n 到 i 的逆序序列。
range(start, stop, step)
range(5)#0、1、2、3、4

list.extend(list)#在列表中添加列表

在Python中，// 是整数除法运算符。它执行除法运算并返回结果的整数部分，舍弃小数部分。

Collections

0. namedtuple

namedtuple 是一个工厂函数，用于创建具有命名字段的元组子类。它比普通元组更具可读性，因为你可以通过字段名访问元素，而不是通过索引。

from collections import namedtuple
​
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(p.x, p.y)  # 输出: 11 22

2. deque

deque（双端队列）是一个线程安全的双端队列，支持从两端高效地添加和删除元素。它比列表更适合实现队列和栈。

from collections import deque
​
d = deque([1, 2, 3])
d.append(4)  # 在右边添加元素
d.appendleft(0)  # 在左边添加元素
print(d)  # 输出: deque([0, 1, 2, 3, 4])

3. Counter

Counter 是一个字典子类，用于计数可哈希对象。它特别适合用于统计元素的出现次数。

from collections import Counter
​
c = Counter(['a', 'b', 'a', 'c', 'b', 'b'])
print(c)  # 输出: Counter({'b': 3, 'a': 2, 'c': 1})

4. defaultdict

defaultdict 是一个字典子类，它为不存在的键提供默认值。你可以指定一个工厂函数来生成默认值。

from collections import defaultdict
​
d = defaultdict(int)
d['key1'] += 1
print(d['key1'])  # 输出: 1
print(d['key2'])  # 输出: 0

5. OrderedDict

OrderedDict 是一个字典子类，它记住了键值对的插入顺序。在 Python 3.7 及更高版本中，普通字典也保持了插入顺序，但在早期版本中，OrderedDict 是唯一的选择。

from collections import OrderedDict
​
d = OrderedDict()
d['a'] = 1
d['b'] = 2
d['c'] = 3
print(d)  # 输出: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

6. ChainMap

ChainMap 是一个类，用于将多个字典或其他映射组合在一起，形成一个单一的、可更新的视图。

from collections import ChainMap
​
d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}
cm = ChainMap(d1, d2)
print(cm['a'])  # 输出: 1
print(cm['b'])  # 输出: 2（优先使用第一个字典中的值）
print(cm['c'])  # 输出: 4

12.24

range(n)#0、1、2、3、、、n-1

import sys

MAX_INT = sys.maxsize#python里面的最大整数

# 使用 ** 进行幂运算
result1 = 2 ** 3
print(result1)  # 输出: 8

# 使用 ^ 进行按位异或运算
result2 = 2 ^ 3
print(result2)  # 输出: 1

python的幂运算是**，^是异或运算

# 假设我们有一个字典
my_dict = {'c': 3, 'a': 1, 'b': 2}
# 按照值排序
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[1]))
print(sorted_dict_by_value)  # 输出: {'a': 1, 'b': 2, 'c': 3}

else if 是 elif

12.25

a, b = 1, 2
for _ in range(3, n + 1):
    a, b = b, a + b
    return b   #斐波那契数-列迭代法

在 Python 中，for _ in range() 中的 _ 是一个占位符变量，用于表示我们不关心循环变量的具体值。这种用法通常在以下情况下使用：

0. 循环次数已知：当我们只需要循环一定次数，而不需要使用循环变量的值时。
1. 忽略循环变量：当我们不需要在循环体内使用循环变量的值时。

# 假设你有一个列表
my_list = [1, 4, 2, 3]

# 你想查找值为 2 的元素的位置
position = my_list.index(2)

print(position)  # 输出: 2

在Python中，你可以使用列表的 index 方法来通过值查询位置。

index 方法会返回列表中第一个匹配元素的索引。

12.26

def solution(n: int) -> list:
    # 初始化一个 n x n 的矩阵，所有元素为 0
    matrix = [[0] * n for _ in range(n)] #[0] * n循环n次
    return matrix

矩阵的初始化，矩阵的索引从0开始，

python保留小数方法

方法一：使用字符串格式化

你可以使用字符串的 format() 方法或者 f-string 来格式化输出，保留两位小数。

# 使用 format() 方法
result = 3.5
formatted_result = "{:.2f}".format(result)
print(formatted_result)  # 输出: '3.50'

# 使用 f-string
result = 3.5
formatted_result = f"{result:.2f}"
print(formatted_result)  # 输出: '3.50'

方法二：使用 round() 函数

round() 函数可以用来四舍五入到指定的小数位数。

result = 3.5
rounded_result = round(result, 2)
print(rounded_result)  # 输出: 3.5

变量不要与函数重名

zip(s, t)：同时遍历两个字符串 s 和 t 的每个字符。

def solution(n: int, s: str, t: str) -> str:
    xor_map = {
        ('A', 'A'): '0',
        ('A', 'B'): '1',
        ('B', 'A'): '1',
        ('B', 'B'): '0'
    }  #定义异或映射
    result = []
    count_0 = 0
    count_1 = 0
    for char1, char2 in zip(s, t):  #同时遍历两个字符串
        xor_result = xor_map[(char1, char2)]
        result.append(xor_result)
    count_0 = result.count('0')     #统计结果列表中0和1的个数
    count_1 = result.count('1')
    if count_1 > count_0:
        return 'yes'
    elif count_1 < count_0:
        return 'no'
    else:
        return 'draw'

12.28

max()函数

可以用于多种数据结构，包括列表、元组、集合、字符串、字典、生成器以及实现了比较方法的自定义对象。它通过比较元素的大小来返回最大值。

1. 列表（List）

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
max_number = max(numbers)
print(max_number)  # 输出: 9

2. 元组（Tuple）

coordinates = (10, 20, 30, 40, 50)
max_coordinate = max(coordinates)
print(max_coordinate)  # 输出: 50

3. 集合（Set）

unique_numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
max_unique_number = max(unique_numbers)
print(max_unique_number)  # 输出: 9

4. 字符串（String）

text = "hello world"
max_char = max(text)
print(max_char)  # 输出: 'w'

5. 字典（Dictionary）

在字典中，max()函数默认比较字典的键（keys）：

scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78}
max_key = max(scores)
print(max_key)  # 输出: 'Charlie'

如果需要比较字典的值（values），可以使用max()函数的key参数：

max_value = max(scores, key=scores.get)
print(max_value)  # 输出: 'Bob'

6. 生成器（Generator）

squares = (x**2 for x in range(10))
max_square = max(squares)
print(max_square)  # 输出: 81

7. 自定义对象

如果自定义对象实现了__lt__（小于）、__gt__（大于）等比较方法，max()函数也可以用于这些对象：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __lt__(self, other):
        return self.age < other.age

people = [Person('Alice', 30), Person('Bob', 25), Person('Charlie', 35)]
max_person = max(people)
print(max_person.name)  # 输出: 'Charlie'

二维列表

• 行号和列号都是从 0 开始计数的。
• array[i][j] 表示第 i+1 行、第 j+1 列的元素。

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

# 查找元素 [1, 2] 的索引
target = [1, 2]

# 遍历二维列表
for i, sublist in enumerate(array):
    if sublist == target:
        print(f"元素 {target} 的索引是: {i}")
        break
else:
    print(f"元素 {target} 不在列表中")

12.30

比较字典键值

for key in d.keys():
​    if d[key] == key:  #循环比较字典的键值

列表添加是append 字符串添加是join

def solution(s: str, rules: List[int]) -> str:
    new_s=[]
    for i in range(len(rules)):
       new_s.append(s[rules.index(i)])
    res_s = ''.join(new_s)
    return res_s

字符串切片的基本语法

在Python中，字符串切片的基本语法是 s[start:stop:step]，其中：

• start是切片的起始索引（包含）。
• stop 是切片的结束索引（不包含）。
• step 是步长，表示每隔多少个字符取一个字符。

字符串是不可变对象

二进制数运算规则

| 按位或
^ 按位异或
~ 按位取反
&   按位与
<<  左移
>>  右移

bin()函数可以将一个十进制数转换为二进制表示形式，返回一个以0b开头的字符串

# 对二进制字符串进行反码操作
inverted_binary_str = ''.join('1' if bit == '0' else '0' for bit in binary_str)

12.31

itertools 是 Python 标准库中的一个模块，提供了许多用于操作迭代器的工具函数。这些函数可以帮助你高效地处理迭代器、生成器和可迭代对象，从而简化代码并提高性能。

主要功能

itertools 模块包含以下几类函数：

0. 无限迭代器：生成无限序列的迭代器。
1. 组合生成器：生成排列、组合等组合数学结构的迭代器。
2. 有限迭代器：生成有限序列的迭代器。
3. 迭代器操作：对迭代器进行操作的函数。

常用函数

1. 无限迭代器

• count(start=0, step=1) : 从 start 开始，以 step 为步长生成无限序列。

  import itertools
  
  for i in itertools.count(10, 2):
      print(i)
      if i > 20:
          break
  

  输出：

  10
  12
  14
  16
  18
  20
  22
  

• cycle(iterable) : 无限循环迭代 iterable 中的元素。

  import itertools
  
  for i in itertools.cycle('ABC'):
      print(i)
      if i == 'C':
          break
  

  输出：

  A
  B
  C
  

• repeat(elem, n=None) : 重复生成 elem，重复 n 次或无限次。

  import itertools
  
  for i in itertools.repeat(10, 3):
      print(i)
  

  输出：

  10
  10
  10
  

2. 组合生成器

• permutations(iterable, r=None) : 生成 iterable 中元素的所有排列，每个排列的长度为 r。

  import itertools
  
  for perm in itertools.permutations([1, 2, 3]):
      print(perm)
  

  输出：

  (1, 2, 3)
  (1, 3, 2)
  (2, 1, 3)
  (2, 3, 1)
  (3, 1, 2)
  (3, 2, 1)
  

• combinations(iterable, r) : 生成 iterable 中元素的所有组合，每个组合的长度为 r。

  import itertools
  
  for comb in itertools.combinations([1, 2, 3], 2):
      print(comb)
  

  输出：

  (1, 2)
  (1, 3)
  (2, 3)
  

• product(*iterables, repeat=1) : 生成 iterables 中元素的笛卡尔积。

  import itertools
  
  for prod in itertools.product([1, 2], [3, 4]):
      print(prod)
  

  输出：

  (1, 3)
  (1, 4)
  (2, 3)
  (2, 4)
  

3. 有限迭代器

• chain(*iterables) : 将多个 iterables 连接成一个迭代器。

  import itertools
  
  for i in itertools.chain([1, 2], [3, 4]):
      print(i)
  

  输出：

  1
  2
  3
  4
  

• islice(iterable, start, stop, step) : 对 iterable 进行切片操作，类似于列表切片。

  import itertools
  
  for i in itertools.islice([1, 2, 3, 4, 5], 1, 4, 2):
      print(i)
  

  输出：

  2
  4
  

4. 迭代器操作

• groupby(iterable, key=None) : 根据 key 函数对 iterable 中的元素进行分组。

  import itertools
  
  data = [('a', 1), ('a', 2), ('b', 3), ('b', 4)]
  for key, group in itertools.groupby(data, lambda x: x[0]):
      print(key, list(group))
  

  输出：

  a [('a', 1), ('a', 2)]
  b [('b', 3), ('b', 4)]
  

判断素数

只需要验证到 n**0.5

def is_prime(n):
        if n <= 1:
            return False
        if n== 2:
            return True
        if n % 2 == 0:
            return False
        for i in range(3, int(n**0.5) + 1, 2):
            if n % i == 0:
                return False
        return True

字符串填充

# 示例代码
s = "123"
length = 6
result = s.zfill(length)
print(result)  # 输出: "000123"

# 示例代码
s = "123"
length = 6
if len(s) < length:
    result = s + '0' * (length - len(s)) 
else:
    result = s
print(result)  # 输出: "123000"