牛客网python刷题查缺补漏(第二天)

python字符串中的replace方法

1.python字符串中的replace方法

在Python中，字符串的replace方法可以接受三个参数，用于替换字符串中的子字符串。

第一个参数：要被替换的子字符串（被搜索的目标字符串）。
第二个参数：用于替换第一个参数匹配到的子字符串的新字符串。
第三个参数（可选）：指定最多替换的次数。如果提供了这个参数，那么只会替换前几次出现的匹配项，而不是全部替换。如果省略这个参数，则默认替换所有匹配项。

original_string = "Hello, World! Hello, Universe! Hello, Galaxy!"

# 替换所有的"Hello"为"Hi"
new_string = original_string.replace("Hello", "Hi")
print(new_string)
# 输出: "Hi, World! Hi, Universe! Hi, Galaxy!"

# 替换前两个"Hello"为"Hi"
new_string = original_string.replace("Hello", "Hi", 2)
print(new_string)
# 输出: "Hi, World! Hi, Universe! Hello, Galaxy!"

如上所示，replace方法在第一个参数中搜索要替换的子字符串，然后将其替换为第二个参数中指定的新字符串，根据第三个参数的值来控制替换的次数。

python字符串中的endswith方法

2.python字符串中的endswith方法

在Python中，endswith方法是用于检查一个字符串是否以指定的后缀（结尾部分）结束的方法。它返回一个布尔值，指示字符串是否以指定的后缀结束

str.endswith(suffix[, start[, end]])

参数说明：
suffix：要检查的后缀字符串，可以是一个字符串或一个元组（元组中包含多个后缀字符串）。
start（可选）：搜索的起始位置，默认为0，表示从字符串的开头开始搜索。
end（可选）：搜索的结束位置，默认为字符串的末尾，表示搜索直到字符串的末尾。
返回值：如果字符串以指定的后缀或后缀元组结束，则返回True，否则返回False。

python中的内置函数sorted

3.python中的内置函数sorted

sorted() 方法是 Python 中用于对可迭代对象进行排序的内置函数。它可以对列表、元组、字符串等可迭代对象进行排序，并返回一个新的已排序的列表。sorted() 方法具有以下常用的语法：

sorted(iterable, key=None, reverse=False)

iterable：需要排序的可迭代对象，例如列表、元组、字符串等。
key（可选）：一个函数，用于指定排序的关键字，以自定义排序规则。默认值为 None，表示使用默认的排序规则。
reverse（可选）：一个布尔值，如果设置为 True，则表示降序排序；如果设置为 False（默认值），则表示升序排序。
sorted() 方法返回一个新的已排序列表，而不会修改原始可迭代对象。

sorted函数和sort函数的区别

sorted() 和 list.sort() 是两种不同的方法，都用于对列表进行排序，但它们之间有几个重要的区别：

返回值:
sorted() 返回一个新的已排序列表，原始列表不会被修改。
list.sort() 是列表对象的方法，它在原地修改列表，不返回新的列表。这意味着它不会创建新的列表对象，而是直接修改了原始列表。
用法:
sorted() 是一个内置函数，可以用于对任何可迭代对象（如列表、元组、字符串等）进行排序。
list.sort() 是列表对象的方法，只能用于对列表进行排序。它不适用于其他类型的可迭代对象。
返回类型:
sorted() 返回一个新的列表，因此可以将其赋值给一个新的变量，而不影响原始数据。
list.sort() 不返回新的列表，而是直接修改了原始列表。它返回 None，因此不能将其赋值给一个新的变量。

python中的内置函数id

4.python中的内置函数id

在Python中，id() 函数是一个内置函数，用于获取对象的唯一标识符（内存地址）。每个对象都有一个唯一的 id 值，用于标识该对象在内存中的位置。id() 函数的语法如下：

id(object)

object：要获取其唯一标识符的对象。
id() 函数返回一个整数，表示对象的唯一标识符。

需要注意的是，id() 返回的值是一个整数，通常是对象在内存中的地址，但具体的值和实现有关，不要依赖于它的具体数值。通常情况下，我们使用 id() 函数来比较两个对象是否是同一个对象，即它们是否具有相同的 id 值。如果两个对象具有相同的 id 值，则它们是同一个对象。

python中的内置函数map

5.python中的内置函数map

在Python中，map() 是一个内置函数，用于将一个函数应用于一个或多个可迭代对象（例如列表、元组等）的每个元素，并返回一个包含结果的迭代器。map() 的基本语法如下：

map(function, iterable, ...)	

function：要应用于每个元素的函数。
iterable：一个或多个可迭代对象，每个对象的元素都会传递给 function 进行处理。如果提供多个可迭代对象，map() 将按照迭代器的顺序将元素传递给函数。
map() 返回一个迭代器，可以使用 list() 或其他迭代方法来转换为列表或其他数据类型

python中的yield关键字

6.python中的yield关键字

在 Python 中，yield 是一个关键字，用于定义生成器函数。生成器函数用于生成一个可迭代的对象，它允许你按需生成值，而不是一次性生成所有值，从而节省内存和提高效率。

当一个函数包含 yield 关键字时，它将不再是一个常规函数，而是一个生成器函数。生成器函数在调用时不会立即执行，而是返回一个生成器对象，该对象可以用于逐个生成函数的返回值。每次调用生成器的 next() 方法（或使用 for 循环迭代生成器）时，函数会从上次 yield 语句的位置继续执行，直到再次遇到 yield 或函数结束。这样，函数可以在多次调用之间保持状态。

以下是一个简单的示例，演示了如何使用 yield 创建一个生成器函数：

def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1

# 创建一个生成器对象
counter = count_up_to(5)

# 逐个获取生成器的值
print(next(counter))  # 输出: 1
print(next(counter))  # 输出: 2
print(next(counter))  # 输出: 3

# 使用 for 循环迭代生成器
for num in counter:
    print(num)  # 输出: 4, 5

在上述示例中，count_up_to 函数是一个生成器函数，它逐个生成从1到n的整数，而不会一次性生成所有整数。

python中的@符号

7.在Python中，@ 符号通常用于装饰器（decorators）。装饰器是一种特殊的函数，用于修改或增强其他函数或方法的行为，而不需要修改它们的原始代码。装饰器可以在函数或方法定义之前使用 @ 符号来应用。

装饰器的一个关键特性是，它在被装饰函数定义后被立即执行
装饰器通常由函数编写，它们接受一个函数作为参数，并返回一个新的函数，通常在内部修改或扩展原始函数的功能。装饰器是 Python 中的一种强大工具，用于实现例如日志记录、性能测量、身份验证等功能的模块化和可重用的方式。

以下是一个简单的示例，演示如何定义和使用装饰器：

# 定义一个装饰器函数
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

# 使用装饰器
@my_decorator
def say_hello():
    print("Hello!")

# 调用被装饰的函数
say_hello()

在上述示例中，my_decorator 是一个装饰器函数，它接受一个函数 func 作为参数，然后返回一个新的函数 wrapper，该函数在调用 func 前后执行一些额外的操作。通过在 say_hello 函数定义之前使用 @my_decorator，我们将 say_hello 函数传递给 my_decorator 并应用了装饰器。

当我们调用 say_hello() 时，实际上是调用了 wrapper 函数，这使得我们可以在函数调用前后执行一些额外的操作，从而扩展了原始函数的功能。

Python 中有许多内置的装饰器，例如 @staticmethod、@classmethod 和 @property，它们用于修改类中的方法或属性行为。您也可以编写自己的装饰器来满足特定的需求。

python字符串中的find和index方法

8.关于python字符串中的find和index方法

find() 方法返回子字符串的索引或 -1（如果未找到）。
index() 方法返回子字符串的索引，但如果未找到会引发 ValueError 异常。
如果不确定是否会找到子字符串，可以使用 find() 来避免异常处理。如果需要处理未找到的情况，find() 更适合。
如果确定子字符串一定存在，可以使用 index() 来获取索引，但要注意可能引发的异常。

小笔记:若要表现像个序列，必须满足序列的两个方法：_ _ len _ _和 _ _ getitem _ _

python中的lambda关键字

9.python中的lambda关键字

在Python中，lambda 是一个关键字，用于创建匿名函数（也称为 lambda 函数或 lambda 表达式）。匿名函数是一种没有名称的小型函数，通常用于简单的操作，它可以接受任意数量的参数但只能包含一个表达式。

lambda 函数的基本语法如下：

lambda arguments: expression

arguments：函数的参数，可以有零个或多个，用逗号分隔。
expression：一个表达式，定义了函数的计算结果，该表达式的结果会被返回。

示例如下:

# 创建一个接受两个参数并返回它们的和的 lambda 函数
add = lambda x, y: x + y
result = add(3, 5)
print(result)  # 输出: 8

# 创建一个接受一个参数并返回其平方的 lambda 函数
square = lambda x: x**2
result = square(4)
print(result)  # 输出: 16

# 使用 lambda 函数进行排序
data = [(1, 'apple'), (3, 'banana'), (2, 'cherry')]
data.sort(key=lambda item: item[1])  # 根据元组的第二个元素排序
print(data)  # 输出: [(1, 'apple'), (3, 'banana'), (2, 'cherry')]

lambda 函数通常用于简单的、一次性的操作，例如在排序、过滤、映射等函数中作为参数传递。它们的优势在于简洁，但请注意不要过度使用它们，因为复杂的操作可能会使代码难以理解。对于较复杂的功能，最好使用常规的命名函数

python交换两个数的优雅写法

10.python中的x, y = y, x

x, y = y, x 是一行代码，用于交换两个变量 x 和 y 的值。它是Python中一种快速而简洁的方法来交换两个变量的值，不需要使用额外的中间变量。

这行代码的执行过程如下：
先创建一个包含 y 和 x 的元组，这个元组的顺序与变量交换前的顺序相反。
然后，将元组中的值分配给 x 和 y。这会导致 x 的值变为原来的 y 的值，而 y 的值变为原来的 x 的值。

这种方式利用了Python的元组解包和多重赋值的特性，使得变量交换变得非常简单和有效。这是Python中常用的一种技巧。

python中的_ _ name_ _ 关键字

11.python中的_ _ name _ _关键字

_ _ name _ _是Python中的一个特殊变量，用于确定一个Python脚本是以主程序运行还是作为模块导入到其他程序中。理解 _ _ name _ _的值对于组织可重用的Python代码非常有用

下面是一些关于 _ _ name _ _变量的常见用法和含义：

1.当一个Python脚本（.py文件）被直接执行时（作为主程序运行），_ _ name _ _ 的值会被设置为 ’ _ _ main _ _'。

例如，如果您有一个名为 my_script.py 的脚本，其中包含以下代码：

def main():
    # 主程序代码

if __name__ == '__main__':
    main()

当您直接运行 my_script.py 时，_ _ name _ 的值将是 ’ _ main _ _'，并且 main() 函数将被调用

2.当一个Python脚本被作为模块导入到其他程序中时，_ _ name _ _的值会被设置为该脚本的文件名（不包含扩展名）。

例如，如果您有一个名为 my_module.py 的脚本，其中包含以下代码：

def some_function():
    # 函数代码

当您在另一个Python脚本中导入 my_module 时，my_module.py 中的代码不会直接执行，_ _ name _ _的值将是 ‘my_module’。

通过使用 if _ _ name _ _== ’ _ _ main _ _': 来检查 _ _ name _ _的值，您可以编写具有可重用性的模块，以便它们可以被其他程序导入，同时还可以在需要时作为主程序运行。

这种结构允许您将模块的功能和执行代码分离开来，使代码更加模块化和可维护。如果模块中包含执行代码，但只在模块作为主程序运行时执行，这可以避免在导入时不必要的副作用。

附:python搜索模块的顺序为:内建模块>当前路径，即执行Python脚本文件所在的路径>环境变量中的PYTHONPATH>python安装路径

python变量的查找顺序

12.python变量的查找顺序

局部作用域>外部嵌套作用域>全局作用域>内置模块作用域

Python变量作用域查找遵循LEGB原则：
变量的查找顺序：Local 局部变量->Enclosing 外部嵌套作用域->Global 全局作用域->Built-in 内置模块作用域

L：Local，局部作用域，也就是我们在函数中定义的变量；

E：Enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

G：Globa，全局变量，就是模块级别定义的变量；

B：Built-in，系统内置模块里面的变量，比如int, bytearray等。

python中主要存在四种命名方式

13. python中主要存在四种命名方式

1、object #公用方法

2、_object #半保护

被看作是“protect”，意思是只有类对象和子类对象自己能访问到这些变量，
在模块或类外不可以使用，不能用’from module import *’导入。

__object 是为了避免与子类的方法名称冲突， 对于该标识符描述的方法，父

类的方法不能轻易地被子类的方法覆盖，他们的名字实际上是

_classname__methodname。

3、_ _ object #全私有，全保护

私有成员“private”，意思是只有类对象自己能访问，连子类对象也不能访

问到这个数据，不能用’from module import *’导入。

4、_ _ object_ _ #内建方法，用户不要这样定义

附:Python 中字符串的前导 r 代表原始字符串标识符，该字符串中的特殊符号不会被转义，适用于正则表达式中繁杂的特殊符号表示。

python中对于小整数对象有一个小整数对象池，范围在[-5,257）之间。对于在这个范围内的征数，不会新建对象，直接从小整数对象池中取就行。

关于python中的复数

14.关于python中的复数

1.表示复数的语法是real + image j

2.实部和虚部都是浮点数

3.虚部的后缀可以是 “j” 或者 “J”

4.复数的 conjugate 方法可以返回该复数的共轭复数

创建复数：可以使用 complex() 函数来创建复数
获取实部和虚部：可以通过调用 .real 和 .imag 属性获取复数的实部和虚部