PAT部分题目相关知识点——python

python中的整除

在Python中，整除（也称为地板除）可以使用**//**运算符来实现。当使用//运算符时，结果将是一个整数，它表示除法运算的整数部分，舍去任何小数部分。
示例：

# 使用整除运算符 //  
print(7 // 2)  # 输出 3，因为 7 除以 2 的整数部分是 3  
print(-7 // 2)  # 输出 -4，注意负数的整除结果会向下取整  
print(7.0 // 2)  # 输出 3.0，如果操作数之一是浮点数，结果也是浮点数  
  
# 对比普通的除法运算符 /  
print(7 / 2)  # 输出 3.5，普通的除法会保留小数部分

需要注意的是，当使用整除运算符时，如果除数为0，Python会引发一个ZeroDivisionError异常。因此，在进行整除运算之前，最好先检查除数是否为零，以避免程序崩溃。

python删除最后指定字符串

在Python中，rstrip() 是一个字符串（string）方法，用于从字符串的末尾（即右侧）删除指定的字符。如果没有指定要删除的字符，那么它默认删除所有的空白字符（包括空格、制表符、换行符等）。

rstrip() 方法的基本语法：

str.rstrip([chars])

str：这是调用 rstrip() 方法的字符串。
chars（可选）：一个字符串，指定要从原始字符串末尾删除的字符。如果省略或为空，将删除所有的空白字符。

1. 删除末尾的空白字符

s = "   Hello, World!   "  
print(s.rstrip())  # 输出："   Hello, World!"（注意左侧空格未删除）

2. 删除指定的字符

s = "apple!!!"  
print(s.rstrip("!"))  # 输出："apple"（删除了所有的 '!'）

3. 删除多个指定的字符

s = "apple,;,,"  
print(s.rstrip(",;"))  # 输出："apple"（删除了所有的 ',' 和 ';'）

4. 如果没有要删除的字符，则返回原始字符串

s = "apple"  
print(s.rstrip("xyz"))  # 输出："apple"（因为字符串末尾没有 'x'、'y' 或 'z'）
rstrip() # 方法不会修改原始字符串，而是返回一个新的字符串。

5. 如果需要修改原始字符串，可以将结果赋值回原始变量：

s = "   apple   "  
s = s.rstrip()  # 现在 s 的值是 "   apple"（仅删除了末尾的空格）

python删除字符串中某个字符的方法

在Python中，删除字符串中的某个字符可以有多种方法。由于字符串在Python中是不可变的，不能直接修改字符串。但是，你可以通过创建新的字符串来达到删除特定字符的效果。

方法一：使用replace()方法

replace()方法可以用于替换字符串中的特定字符或子字符串。如果将替换内容设置为空字符串，那么就可以实现删除的效果。

例如，删除字符串中的所有"a"字符：

s = "banana"  
s = s.replace("a", "")  
print(s)  # 输出: "bnn"

方法二：使用列表推导式和join()方法

这种方法首先会将字符串转换为字符列表，然后使用列表推导式过滤掉不需要的字符，最后再将字符列表连接回字符串。

例如，删除字符串中的所有"a"字符：

s = "banana"  
s = "".join([c for c in s if c != "a"])  
print(s)  # 输出: "bnn"

方法三：使用str.translate()和str.maketrans()方法

str.translate()和str.maketrans()方法可以一起使用来删除字符串中的特定字符。首先，需要使用str.maketrans()创建一个转换表，然后在str.translate()中使用这个转换表来删除字符。

例如，删除字符串中的所有"a"字符：

s = "banana"  
trans = str.maketrans("", "", "a")  
s = s.translate(trans)  
print(s)  # 输出: "bnn"

注意：以上所有方法都会删除字符串中所有匹配的字符。如果你只想删除第一个匹配的字符或最后一个匹配的字符，那么你需要稍微修改一下这些方法。例如，你可以使用str.find()或str.rfind()来找到第一个或最后一个匹配字符的位置，然后使用字符串切片来删除它。

python字符串切片操作

在Python中，字符串切片是一种获取字符串子序列的方法。通过使用索引和冒号（:）操作符，可以提取字符串中的特定部分。

字符串切片的基本语法如下：

substring = string[start: end :step]

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

注意：索引是从0开始的，如果省略了start、end或step，则使用默认值。
示例：

s = "Hello, World!"  
# 提取从索引0到5的子字符串（不包括索引5）  
print(s[0:5])  # 输出: Hello  
# 提取从索引7到末尾的子字符串  
print(s[7:])  # 输出: World!  
# 提取从开头到索引5的子字符串（不包括索引5）  
print(s[:5])  # 输出: Hello  
# 提取从开头到末尾的所有字符，并每两个字符取一个  
print(s[::2])  # 输出: Hlo,Wrd!  
# 提取从末尾到开头的所有字符，并每一个字符取一个（步长为-1）  
print(s[::-1])  # 输出: !dlroW ,olleH  
# 提取从索引-5到末尾的所有字符（负数索引表示从字符串末尾开始计数）  
print(s[-5:])  # 输出: orld!

切片操作不会修改原始字符串，而是返回一个新的字符串。因为字符串在Python中是不可变的。

切片操作非常灵活，可以通过调整起始索引、结束索引和步长来获取字符串的不同部分。

python字典推导式

1. 字典按照键排序

sorted_dic.items(): 这个方法假设sorted_dic是一个字典，并返回该字典中的键值对列表。每个键值对都是一个元组，其中第一个元素是键，第二个元素是值。
for k, v in sorted_list.items(): 这部分遍历sorted_list.items()返回的键值对列表。在每次迭代中，键被赋值给变量k，值被赋值给变量v。
k: str(v): 对于每对键值，新的字典将有一个键k和一个值，该值是v的字符串表示形式（通过调用str(v)得到）。
代码创建了一个新的字典，其键与sorted_dic相同，但值被转换为字符串形式。

如果想要一个按键排序的字典，需要明确地进行排序：

{k: str(v) for k, v in sorted(sorted_list.items())}

这里，sorted(sorted_dic.items())将返回一个按键排序的键值对列表。然后，字典推导式将使用这个排序后的列表来创建新的字典。

将列表中的多个字典按照某个Key值进行排序

python将列表内的字典按照某个Key值对应的value排序

python中的enumerate()

在Python中，enumerate()是一个内置函数，用于在遍历集合（如列表、元组或字符串）时获取集合中每个元素的索引及其对应的值。

当使用for循环与enumerate()函数结合时，可以同时迭代集合的索引和值。

语法结构如下：

for index, value in enumerate(collection, start=0):  

# 在这里，'index' 是当前元素的索引，'value' 是当前元素的值  
# 'collection' 是要遍历的集合  
# 'start' 是索引的起始值，默认为0

例如，考虑以下代码：

words = ['apple', 'banana', 'cherry']  
for i, word in enumerate(words):  
    print(f"Index: {i}, Word: {word}")

输出将是：

Index: 0, Word: apple
Index: 1, Word: banana
Index: 2, Word: cherry

enumerate(words) 生成了索引和单词的配对，然后for循环依次迭代这些配对，将索引赋值给i，将单词赋值给word，然后在循环体内部进行处理（在这个例子中是打印出来）。

python多重赋值的用法

Python 允许同时给多个变量赋值，这被称为多重赋值。这种特性使得代码更加简洁和易读。

1. 基本的多重赋值

可以在一行内给多个变量赋予不同的值：

a, b, c = 1, 2, 3

变量 a 被赋值为 1，变量 b 被赋值为 2，变量 c 被赋值为 3。

2. 交换变量的值

多重赋值也常用于交换两个变量的值，而不需要使用临时变量：

x, y = y, x

x 和 y 的值被交换了。

3. 解包序列

多重赋值还可以用于解包序列（如列表或元组）中的值：

fruits = ['apple', 'banana', 'cherry']  
first, second, third = fruits

first 的值是 ‘apple’，second 的值是 ‘banana’，third 的值是 ‘cherry’。

解包可迭代对象并丢弃某些值

如果只对序列中的某些值感兴趣，可以使用 _（下划线）作为占位符来丢弃不需要的值：

x, _, y = (1, 2, 3)  # x 将被赋值为 1, y 将被赋值为 3, 中间的值 2 被丢弃

x 被赋值为 1，y 被赋值为 3，而中间的值 2 被丢弃了。下划线 _ 在这里用作一个“不关心这个值”的占位符。

注意事项
当使用多重赋值时，确保等号两边的元素数量相同，否则会引发 ValueError。
如果右侧是一个迭代器或生成器，它会被耗尽，因为多重赋值会立即解包所有的值。
如果右侧的值少于左侧的变量，会引发 ValueError。但是，如果右侧的值是一个可以迭代的对象（如列表或元组），并且你想要将剩余的值赋给最后一个变量，你可以使用 * 来收集剩余的值：

a, b, *rest = [1, 2, 3, 4, 5]  
# a=1, b=2, rest=[3, 4, 5]

这些特性使得 Python 代码在处理多个变量时更加灵活和高效。

应用：反转数组

def reverse(num_list, start, end):
    while start < end:
        num_list[start], num_list[end] = num_list[end], num_list[start]
        start += 1
        end -= 1
    return num_list

python中.join()函数的用法

· 在Python中，.join()是一个字符串（str）类型的方法，用于将序列（例如列表、元组等）中的元素连接成一个新的字符串。
· 需要指定一个分隔符，该分隔符将被插入到序列中每两个元素之间。
· .join()方法不会改变原始序列，而是返回一个新的字符串。

1. .join()方法的基本用法：

separator = ' '  # 指定分隔符，这里是一个空格  
sequence = ['apple', 'banana', 'cherry']  # 这是一个字符串序列（列表）  

# 使用.join()方法将序列中的字符串用分隔符连接起来  
new_string = separator.join(sequence)  
  
# 输出结果  
print(new_string)  # 输出：apple banana cherry

在这个例子中，separator是一个包含单个空格的字符串，它将被用作连接sequence列表中字符串的分隔符。
. join()方法被调用在separator字符串上，并传入sequence列表作为参数。结果是一个新的字符串，其中sequence中的每个元素都被一个空格分隔开。

需要注意的是，.join()方法要求序列中的元素都是字符串类型。如果序列中包含非字符串类型的元素，需要先将它们转换为字符串，然后再使用.join()方法。
例如，有一个包含整数的列表，需要先使用列表推导式或者map()函数将整数转换为字符串：

numbers = [1, 2, 3, 4, 5]  # 这是一个整数列表  
  
# 使用列表推导式将整数转换为字符串  
str_numbers = [str(num) for num in numbers]  
  
# 或者使用map()函数将整数转换为字符串（结果需要转换为列表）  
# str_numbers = list(map(str, numbers))  
  
# 现在可以使用.join()方法将字符串列表连接成一个新的字符串  
result = ' '.join(str_numbers)  
  
# 输出结果  
print(result)  # 输出：1 2 3 4 5

python列表推导式

Python 列表推导式（List Comprehension）是一种简洁而可读的方式，用于创建列表。它基于现有的列表或任何可迭代对象，通过一行代码生成新的列表。

列表推导式的基本语法是在一个方括号内包含一个表达式，后面跟随一个 for 语句，然后是 0 个或多个 for 或 if 语句。

基本的列表推导式的例子如下：

1. 简单的列表推导式：

将一个范围内的数字转换为列表。

squares = [x**2 for x in range(10)]  
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2. 带有条件的列表推导式：

只包含偶数的平方。

even_squares = [x**2 for x in range(10) if x % 2 == 0]  
print(even_squares)  # 输出: [0, 4, 16, 36, 64]

3. 嵌套循环的列表推导式：

生成一个列表，其中包含两个列表中所有可能的元素对。

list1 = [1, 2, 3]  
list2 = ['a', 'b', 'c']  
pairs = [(a, b) for a in list1 for b in list2]  
print(pairs)  # 输出: [(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]

4. 带有 if-else 条件的列表推导式：

根据条件选择不同的表达式结果。

numbers = [-1, 0, 1, 2, 3, 4, 5]  
signs = ['negative' if num < 0 else 'positive' if num > 0 else 'zero' for num in numbers]  
print(signs)  # 输出: ['negative', 'zero', 'positive', 'positive', 'positive', 'positive', 'positive']

5. 从现有列表中选择元素：

选择列表中所有大于 2 的元素。

numbers = [1, 2, 3, 4, 5]  
selected = [num for num in numbers if num > 2]  
print(selected)  # 输出: [3, 4, 5]

6. 矩阵转置：

假设有一个二维列表（矩阵），可以使用列表推导式进行转置。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]  
print(transposed)  # 输出: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

列表推导式提供了一种快速、简洁且可读的方式来创建和操作列表，而无需使用传统的循环和 .append() 方法。然而，对于更复杂的逻辑或更长的列表，使用传统的循环可能更加清晰。

python中的map函数

在Python中，map() 是一个内置的高阶函数，它接收一个函数和一个或多个可迭代对象作为输入，然后返回一个由该函数应用于每个输入项的结果构成的迭代器。

具体来说，map() 会将传入的函数依次作用到序列的每个元素，并把结果作为新的迭代器返回。

基本语法如下：

map(function, iterable, ...)

function：这是应用于每个输入项的函数。
iterable：这是一个或多个可迭代对象。函数将应用于这些对象的每个元素。

使用 map() 函数将一个列表中的每个元素都平方：

# 定义一个平方函数  
def square(x):  
    return x ** 2  
  
# 创建一个数字列表  
numbers = [1, 2, 3, 4, 5]  
  
# 使用map函数应用平方函数到列表的每个元素  
squared = map(square, numbers)  
  
# map对象转换为列表以查看结果  
squared_list = list(squared)  
  
print(squared_list)  # 输出: [1, 4, 9, 16, 25]

在上面的例子中，square 函数被应用到了 numbers 列表中的每个元素上，并且结果存储在了 squared 的迭代器中。
通过将迭代器转换为列表，可以看到应用函数后的结果。

另外，也可以使用 lambda 表达式与 map() 结合，以更简洁的方式完成同样的任务：

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

在这个例子中,使用了匿名函数 lambda x: x ** 2 来代替显式定义的 square 函数。

需要注意的是，map() 返回的是一个迭代器，如果需要立即看到所有结果，可以将它转换为列表或其他可迭代的数据类型。
如果只是想按需访问结果，可以直接使用返回的迭代器。

python中的lamaba表达式

在Python中，lambda表达式是一种创建匿名函数（即没有名字的函数）的方式。

lambda函数可以接受任意数量的参数，但只能有一个表达式。这种函数在需要一个小函数作为另一个函数的参数时特别有用，例如在map()、filter()或sorted()等内置函数中。

lambda表达式的基本语法如下：

lambda arguments: expression

arguments：是函数的参数，它们可以是多个，用逗号隔开。
expression：是一个单一的表达式，lambda函数返回这个表达式的结果。
lambda表达式的例子：

1. 一个简单的lambda函数

它接受一个参数并返回其平方：

square = lambda x: x ** 2  
print(square(5))  # 输出: 25

2. 使用lambda表达式对列表进行排序：

points = [(1, 2), (3, 4), (5, 0), (0, -1)]  
points_sorted_by_y = sorted(points, key=lambda point: point[1])  
print(points_sorted_by_y)  # 输出: [(0, -1), (1, 2), (3, 4), (5, 0)]

在这个例子中，sorted()函数使用了一个lambda表达式来指定排序的关键字（即按照每个点的y坐标进行排序）。

3. 使用lambda表达式和filter()函数过滤出列表中的偶数：

numbers = [1, 2, 3, 4, 5, 6]  
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))  
print(even_numbers)  # 输出: [2, 4, 6]

在这个例子中，filter()函数使用了一个lambda表达式来检查每个数字是否是偶数，并返回了一个由偶数构成的迭代器。然后，使用list()函数将这个迭代器转换为一个列表。

lambda表达式提供了一种快速定义简单函数的方法，但如果需要编写更复杂的函数，建议使用def关键字来定义一个具有名字和文档字符串的常规函数。