python面试题大全（二）

内存管理与垃圾回收机制

41. 哪些操作会导致Python内存溢出，怎么处理？

在Python中，以下操作可能导致内存溢出（Memory Overflow）：

无限循环：如果程序中存在无限循环，且每次迭代都会产生大量的内存占用，那么内存使用量将不断增长，最终导致内存溢出。
大数据结构：创建大型数据结构（如大型列表、字典、集合等），如果数据量过大超出了系统内存的限制，就会导致内存溢出。
递归调用：递归函数在每一层的调用过程中会创建新的函数栈帧，如果递归的深度过大，就会导致函数栈溢出，进而导致内存溢出。
文件处理：处理大型文件时，如果一次性将整个文件内容加载到内存中，可能会超出可用内存的限制。尤其是对于特别大的文件，应该使用逐行或逐块读取的方式进行处理。
内存泄漏：如果程序中存在内存泄漏，即无法访问到不再需要的对象，但它们仍然占用着内存，随着时间的推移，内存占用不断增加，最终导致内存溢出。

处理内存溢出的方法包括：

优化算法和数据结构：考虑使用更高效的算法和数据结构来减少内存占用，例如使用生成器（generator）来逐步生成数据，而不是一次性生成所有数据。
分批处理数据：对于大型数据集，可以将数据分成较小的批次进行处理，每次处理一部分数据，避免一次性加载整个数据集到内存中。
使用生成器和迭代器：利用生成器和迭代器可以在需要时逐个生成数据，而不是一次性生成全部数据，从而减少内存压力。
显式释放内存：对于不再需要的大型数据结构，可以使用del关键字或del语句显式地将其从内存中删除，以释放内存空间。
垃圾回收：Python的垃圾回收机制会自动回收不再使用的对象，但是对于一些特殊情况，可能需要手动调用gc.collect()进行垃圾回收。
使用内存管理工具：Python提供了一些内存管理工具，例如memory_profiler、objgraph等，可以帮助定位和分析内存使用问题。
使用外部存储：对于处理大型文件或数据集的情况，可以考虑使用外部存储（如数据库）来存储和处理数据，减轻内存压力。

总之，处理内存溢出的关键是优化代码，尽量减少内存占用量，并合理管理内存资源。

42. 关于Python内存管理，下列说法错误的是 B

A,变量不必事先声明     B,变量无须先创建和赋值而直接使用
C,变量无须指定类型     D,可以使用del释放资源

43. Python的内存管理机制及调优手段？

内存管理是编程语言中非常重要的一部分，包括引用计数、垃圾回收和内存池等机制。下面对这三个机制进行详细说明：

引用计数（Reference Counting）：引用计数是一种简单而高效的内存管理机制。每个对象都有一个引用计数器，当有新的引用指向对象时，计数器加1，当引用失效时，计数器减1。当计数器为0时，对象被认为是不再被使用，可以被回收内存。引用计数的优势在于实时性和简单性，对象的回收可以立即发生。然而，它无法解决循环引用的问题，即两个或多个对象相互引用，但无法被外部访问到，导致引用计数无法降为0。为了解决这个问题，Python引入了垃圾回收机制。
垃圾回收（Garbage Collection）：垃圾回收是一种自动管理内存的机制，用于解决循环引用和无法通过引用计数回收的对象。Python的垃圾回收器使用分代垃圾回收算法。它将对象分为不同的代，根据对象的存活时间进行回收。通常情况下，大部分对象在短时间内就会被回收，只有部分对象存活更久。垃圾回收器会根据不同的策略，如标记-清除（mark and sweep）、分代回收等来回收不再使用的对象。垃圾回收器定期运行，扫描内存中的对象，找出不可达（unreachable）的对象，并释放它们的内存。
内存池（Memory Pool）：内存池是一种内存分配和管理的机制，用于提高内存分配的效率。Python中的内存池机制主要是为了减少内存碎片和系统调用的开销。当使用频繁的小对象时，Python会为这些对象维护内存池，避免频繁的申请和释放内存。内存池分配的是固定大小的内存块，对象的创建和销毁都是在内存块中进行，从而减少了系统调用的次数。这种机制在一定程度上提高了内存分配的效率。

在Python中，引用计数、垃圾回收和内存池是相互配合的机制，共同管理内存资源。引用计数负责实时回收不再被引用的对象，垃圾回收器负责处理循环引用和无法通过引用计数回收的对象，内存池提高了内存分配的效率。这些机制共同工作，确保了Python程序的内存管理和性能表现。

Python内存管理调优的手段有很多，以下是一些常见的方法和技术：

减少对象创建和销毁：避免频繁创建和销毁大量对象，尽量复用对象或使用对象池来减少内存分配和回收的开销。
使用生成器和迭代器：生成器和迭代器可以逐个生成数据，而不是一次性生成全部数据。这样可以减少内存占用，并在处理大量数据时提高效率。
分批处理数据：对于大型数据集，可以将数据分成较小的批次进行处理，每次处理一部分数据。这样可以减少内存占用，并允许程序逐步处理数据，而不是一次性加载整个数据集到内存中。
使用内存视图（memory views）：内存视图允许直接操作内存缓冲区，而不需要创建额外的对象。它可以提高内存访问效率，尤其对于大型数据结构和数值计算非常有用。
避免不必要的拷贝：在处理大型数据时，尽量避免不必要的数据拷贝操作，例如使用切片（slicing）或视图（view）来共享数据，而不是创建新的副本。
使用内存管理工具：Python提供了一些内存管理工具，如gc模块和第三方库pympler等，可以帮助定位和分析内存使用问题。通过使用这些工具，可以识别出内存占用较高的部分，并进行优化。
使用合适的数据结构和算法：选择合适的数据结构和算法可以显著影响内存使用和性能。了解不同数据结构和算法的特点和复杂度，并选择最适合的选项。
使用编译扩展：对于性能敏感的部分，可以考虑使用C或C++编写的扩展模块。这样可以利用底层语言的性能优势，并提高程序的执行速度和内存效率。
优化循环和迭代：循环和迭代是Python中常见的操作，通过优化循环和迭代的逻辑，可以减少内存占用和提高执行效率。例如，使用列表推导式或生成器表达式代替显式的循环，或者使用NumPy等优化库进行向量化操作。
使用内存管理框架：一些开源框架和库，如Dask和PyTorch等，提供了高效的内存管理和分布式计算功能，可以帮助优化Python程序的内存使用。

以上是一些常见的Python内存管理调优手段，具体的优化方法取决于程序的特点和需求。在进行优化时，应该进行测试和性能分析，以确定瓶颈所在，并有针对性地进行优化。

44. 内存泄露是什么？如何避免？

内存泄露指的是程序在运行过程中无法释放不再使用的内存，导致内存占用不断增加，最终耗尽可用内存的情况。内存泄露可能会导致程序性能下降、崩溃或系统崩溃。

内存泄露通常是由于以下情况之一造成的：

对象被错误地保持引用：当对象不再需要时，但仍然被其他对象保持引用，导致垃圾回收器无法回收该对象的内存。
循环引用：两个或多个对象相互引用形成循环，导致垃圾回收器无法识别并回收这些对象。

为了避免内存泄露，可以采取以下措施：

显式释放资源：对于涉及底层资源（如文件、数据库连接、网络连接）的对象，在使用完毕后，应该显式地关闭或释放这些资源，以确保内存得到正确释放。
小心使用全局变量和缓存：全局变量和缓存可能会持有对象的引用，导致对象无法被垃圾回收。确保在不需要时及时清理全局变量和缓存，或者使用弱引用来引用这些对象。
避免循环引用：避免对象之间形成循环引用。当两个对象之间的引用关系不再需要时，可以手动解除引用，或者使用弱引用来代替普通引用。
使用上下文管理器（Context Manager）：对于需要手动释放资源的对象，可以使用上下文管理器来确保资源得到适时释放。上下文管理器使用with语句来包装代码块，可以在代码块执行完毕后自动调用资源的释放操作。
注意迭代器和生成器：在使用迭代器和生成器时，确保及时释放迭代器生成的对象，在不需要时不要保持对迭代器的引用。
使用内存管理工具：使用Python提供的内存管理工具，如gc模块和第三方库objgraph等，来检测和分析内存泄露问题。这些工具可以帮助定位引起内存泄露的对象和引用关系。
定期进行内存分析和测试：定期进行内存分析和测试，以发现潜在的内存泄露问题。使用内存分析工具来检查内存使用情况，并进行性能测试和压力测试，确保程序在长时间运行和大规模数据处理时没有内存泄露问题。

通过以上措施，可以有效避免内存泄露问题，并确保程序的内存管理健康和高效。

函数

45. python常见的列表推导式？

列表推导式是一种简洁的语法，用于快速创建新的列表。以下是Python中常见的列表推导式形式：

基本形式：[expression for item in iterable]

这是最基本的列表推导式形式，expression是对item的操作或表达式，item是可迭代对象中的每个元素。

例如：创建一个包含1到10的平方数的列表
```
squares = [x**2 for x in range(1, 11)]
```
带有条件的列表推导式：[expression for item in iterable if condition]

在列表推导式中加入条件表达式，只有满足条件的元素才会被包含在结果列表中。

例如：创建一个包含1到10的奇数的列表
```
odd_numbers = [x for x in range(1, 11) if x % 2 != 0]
```
嵌套的列表推导式：[expression for item in iterable1 for item2 in iterable2]

利用嵌套的循环迭代多个可迭代对象，生成组合的元素列表。

例如：创建一个包含两个列表中所有元素的组合列表
```
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
combinations = [(x, y) for x in list1 for y in list2]
```
带有表达式的列表推导式：[expression1 if condition else expression2 for item in iterable]

在列表推导式中使用三元表达式，根据条件选择不同的表达式进行操作。

例如：创建一个包含1到10的奇数和偶数的标识字符串列表
```
numbers = [str(x) + ' odd' if x % 2 != 0 else str(x) + ' even' for x in range(1, 11)]
```

这些是Python中常见的列表推导式形式，可以根据具体的需求和场景选择合适的形式来快速生成新的列表。列表推导式提供了一种简洁、清晰的方式来操作和转换列表数据。

46. 简述read、readline、readlines的区别？

read(), readline(), 和 readlines() 是 Python 文件对象的三种常用方法，用于读取文件内容。

read() 方法：
- 语法：file.read([size])
- 功能：读取文件中的全部内容，或者指定大小的内容。
- 返回值：返回一个字符串，包含文件中的内容。
- 示例：
```
with open('file.txt', 'r') as file:
    content = file.read()  # 读取整个文件的内容
```
readline() 方法：
- 语法：file.readline([size])
- 功能：读取文件中的一行内容。
- 返回值：返回一个字符串，包含文件中的一行内容。
- 示例：
```
with open('file.txt', 'r') as file:
    line = file.readline()  # 读取文件的第一行内容
```
readlines() 方法：
- 语法：file.readlines()
- 功能：读取文件中的所有行，并将其存储为列表。
- 返回值：返回一个包含文件中每行内容的列表，每行作为列表中的一个元素。
- 示例：
```
with open('file.txt', 'r') as file:
    lines = file.readlines()  # 读取文件的所有行，存储为列表
```

总结：

read() 用于一次性读取整个文件内容，并返回一个字符串。
readline() 用于逐行读取文件内容，并返回一个字符串。
readlines() 用于将文件内容按行读取，并返回一个包含每行内容的列表。

这些方法在文件读取时提供了不同的灵活性和功能，可以根据具体的需求选择适当的方法来读取文件。

47. 什么是Hash（散列函数）？

散列函数（Hash函数）是一种将输入数据映射为固定长度散列值（哈希值）的函数。它将任意长度的数据（消息）转换为固定长度的散列值，通常是一个较小的数字或固定长度的字节数组。

散列函数的特点是：

固定输出长度：无论输入的数据有多长，散列函数生成的散列值的长度是固定的。这使得散列函数适用于存储和比较散列值的场景。
独特性：不同的输入数据经过散列函数计算后将产生不同的散列值。即使输入数据的微小变化，也会导致生成完全不同的散列值。
不可逆性：散列函数是单向函数，即从散列值无法还原出原始输入数据。这是散列函数的重要特性之一，使得散列函数在密码学和数据完整性验证等领域有广泛应用。
高效性：散列函数的计算速度通常很快，对于给定的输入数据，散列函数能够迅速生成对应的散列值。

散列函数在计算机科学和密码学中有广泛的应用，包括但不限于以下领域：

数据完整性验证：通过比较原始数据的散列值和接收到的数据的散列值，可以验证数据是否在传输过程中被篡改。
密码存储与验证：在用户身份验证过程中，通常会将用户的密码进行散列处理，并将散列值存储在数据库中。在验证用户密码时，比较输入密码的散列值与数据库中存储的散列值是否匹配。
数据唯一标识：散列值可以用作数据的唯一标识符，用于快速查找和比较数据。
安全哈希算法：用于生成密码学安全性较高的散列值，如MD5、SHA-1、SHA-256等，常用于数字签名、消息认证码等领域。

需要注意的是，虽然散列函数具有高度的唯一性和不可逆性，但并不意味着它是绝对安全的。一些常见的攻击技术，如碰撞攻击和彩虹表攻击，可能会影响散列函数的安全性。因此，在选择和使用散列函数时，需要考虑具体的安全要求和算法的可靠性。

48. python函数重载机制？

Python 不支持传统意义上的函数重载（function overloading）机制，即在同一个作用域中定义多个同名函数但参数不同的情况。在 Python 中，函数重载是指通过函数的默认参数和可变参数来实现类似的功能。

Python 的函数定义允许为参数设置默认值，这使得函数可以在不同的调用中接受不同数量的参数。例如：

def add(x, y=0):
    return x + y

result1 = add(2)     # 结果为 2，y 默认为 0
result2 = add(2, 3)  # 结果为 5，y 为传入的值 3

另外，Python 还支持可变参数的定义，即可以接受任意数量的参数。这些参数可以使用星号 (*) 表示为元组（tuple）形式，或者使用双星号 (**) 表示为字典（dict）形式。例如：

def add(*args):
    result = 0
    for num in args:
        result += num
    return result

total = add(2, 3, 4)  # 结果为 9，接受任意数量的参数

通过使用默认参数和可变参数，可以实现不同参数的函数重载效果。根据传入参数的不同，函数可以根据需要执行不同的逻辑。

需要注意的是，Python 中的函数重载并不是通过函数名和参数列表的方式来区分不同的函数，而是通过传入参数的类型和数量来确定调用的函数。因此，如果在同一个作用域中定义了多个同名函数，只有最后定义的函数会生效。

49. 手写一个判断时间的装饰器

import datetime
from functools import wraps


class TimeException(Exception):
    def __init__(self, exception_info):
        super().__init__()
        self.info = exception_info

    def __str__(self):
        return self.info


def timecheck(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 获取当前时间
        current_time = datetime.datetime.now()

        # 设置允许调用函数的起始时间和结束时间
        start_time = datetime.datetime(2024, 1, 1, 0, 0, 0)  # 设置起始时间
        end_time = datetime.datetime(2024, 12, 31, 23, 59, 59)  # 设置结束时间

        # 检查当前时间是否在允许的范围内
        if start_time <= current_time <= end_time:
            return func(*args, **kwargs)
        else:
            raise TimeException("函数调用时间不在允许范围内")

    return wrapper


@timecheck
def test(name):
    print("Hello {}, 2019 Happy".format(name))


if __name__ == "__main__":
    test("backbp")

50. 使用Python内置的filter()方法来过滤？

使用filter()函数过滤出列表中的偶数：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def is_even(num):
    return num % 2 == 0

filtered_numbers = list(filter(is_even, numbers))
print(filtered_numbers)  # [2, 4, 6, 8, 10]

51. 编写函数的4个原则

编写函数时，有四个关键原则可以指导你设计出高质量的函数。这些原则被称为 SOLID 原则，是面向对象设计和编程的基本原则之一：

单一职责原则 (Single Responsibility Principle, SRP)：一个函数应该只负责一项具体的任务或功能。它应该专注于完成单一的职责，这样可以提高函数的可读性、可维护性和可测试性。
开放封闭原则 (Open-Closed Principle, OCP)：函数应该对扩展开放，对修改封闭。这意味着函数的设计应该允许通过添加新的功能来扩展其行为，而不需要修改已有的代码。这可以通过使用抽象、接口、多态等技术实现。
里氏替换原则 (Liskov Substitution Principle, LSP)：子类对象应该能够替换父类对象，并且不会引起意外的行为变化。这意味着在编写函数时，应该保持对抽象的依赖，而不是对具体实现的依赖。
接口隔离原则 (Interface Segregation Principle, ISP)：客户端不应该依赖于它不需要的接口。函数应该只提供客户端需要的方法和功能，避免提供冗余或无关的接口。这样可以减少对外部变化的影响，并提高代码的灵活性和可维护性。

遵循这些原则可以帮助你编写更加灵活、可扩展和易于维护的函数。它们有助于提高代码的质量、可读性和可测试性，并促使你设计出更好的软件架构。

52. 函数调用参数的传递方式是值传递还是引用传递？

在Python中，函数调用的参数传递方式是按对象引用传递（pass-by-object-reference），也可以理解为按值传递（pass-by-value）。

当你调用一个函数并传递参数时，实际上是将对象的引用（内存地址）传递给函数。在函数内部，这个引用被用来访问原始对象。

当你对传递的可变对象进行修改时，会影响到原始对象。
但是，当你对传递的不可变对象进行修改时，会创建一个新的对象，原始对象不会受到影响。

为了更好地理解这个概念，看下面的例子：

def modify_list(lst, num):
    lst.append(num)
    num = num + 1

my_list = [1, 2, 3]
my_num = 10

modify_list(my_list, my_num)

print(my_list)  # 输出: [1, 2, 3, 10]
print(my_num)   # 输出: 10

在这个例子中，我们定义了一个函数modify_list，它接受一个列表和一个整数作为参数。在函数内部，我们通过引用修改了列表，并将整数加1。在函数调用之后，我们打印了原始的列表和整数，可以看到列表被成功修改了，但整数没有改变。

因此，可以说在Python中，函数调用时参数的传递方式是按对象引用传递。如果参数是可变对象（如列表、字典等），函数内部的修改会影响原始对象。如果参数是不可变对象（如数值、字符串等），函数内部的修改会创建一个新的对象，原始对象不会受到影响。

53. 对缺省参数的理解

缺省参数（默认参数）是在定义函数时给参数指定的默认值。当函数被调用时，如果没有为这个参数提供值，那么将使用默认值作为参数的值。

缺省参数的使用有以下几个优点：

灵活性：默认参数允许函数在不同的情况下接受不同的参数值，使函数调用更加灵活。
简化函数调用：当函数有多个参数时，通过设置一些参数的默认值，可以简化函数调用，只需为必要的参数提供值，而不需要为所有参数都提供值。
可读性：通过给默认参数赋予有意义的值，可以提高代码的可读性，使函数的功能和用法更加清晰明了。

下面是一个例子，演示了如何使用默认参数：

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

# 调用函数时只提供必需的参数
greet("Alice")  # 输出: Hello, Alice!

# 调用函数时提供了默认参数的值
greet("Bob", "Hi")  # 输出: Hi, Bob!

在这个例子中，我们定义了一个名为greet的函数，它接受一个必需参数name，并有一个默认参数greeting，默认值为"Hello"。当我们调用greet函数时，可以只提供必需参数name的值，而不提供greeting参数的值，这样函数就会使用默认值。或者，我们也可以为greeting参数提供自定义的值，这样函数将使用我们提供的值。

需要注意的是，当函数的参数有默认值时，如果在函数调用时提供了参数的值，那么默认值将被覆盖。而且，Python中的默认参数是在函数定义时计算的，所以如果默认参数是可变对象（如列表、字典等），则应该特别小心，以避免意外的行为。

总之，缺省参数是一种方便的特性，可以增加函数的灵活性和可读性，但在使用时需要注意一些细节。

54. 带参数的装饰器?

带定长参数的装饰器

def new_func(func):
    def wrappedfun(username, passwd):
        if username == 'root' and passwd == '123456789':
            print('通过认证')
            print('开始执行附加功能')
            return func()
        else:
            print('用户名或密码错误')
            return
    return wrappedfun

@new_func
def origin():
    print('开始执行函数')

origin('root', '123456789')

带不定长参数的装饰器

def authentication_decorator(username, password):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if username == 'admin' and password == 'password':
                print("认证通过")
                return func(*args, **kwargs)
            else:
                print("认证失败")
        return wrapper
    return decorator
    

@authentication_decorator(username='admin', password='password')
def protected_function():
    print("这是一个需要认证的函数")

55. 为什么函数名字可以当做参数用?

在Python中，函数名是一个可调用的对象，并且可以作为参数传递给其他函数。这是因为在Python中，函数被视为"一等公民"（first-class citizens）。

函数作为一等公民意味着函数具有与其他对象相同的地位和能力。它们可以被赋值给变量，可以作为参数传递给其他函数，可以作为其他函数的返回值，还可以存储在数据结构中。

函数名作为参数传递给其他函数时，实际上是将函数对象本身作为值进行传递。这意味着你可以在接收函数作为参数的函数内部调用传递进来的函数，就像调用其他对象的方法一样。

这种能力使得函数可以更灵活地组织和复用代码。通过将函数作为参数传递，你可以实现更高阶的函数，例如装饰器、回调函数和函数式编程的概念。

56. Python中pass语句的作用是什么？

在编写代码时只写框架思路，具体实现还未编写就可以用pass进行占位，是程序不报错，不会进行任何操作。

57. 有这样一段代码，print©会输出什么，为什么？

a = 10
b = 20
c = [a]
a = 15

print(c)  # [10]

58. 交换两个变量的值？

a, b = b, a

59. map函数和reduce函数？

from functools import reduce

print(map(lambda x: x * x, [1, 2, 3, 4]))  # <map object at 0x0000022F24594A00>
print(list(map(lambda x: x * x, [1, 2, 3, 4])))  # [1, 4, 9, 16]

print(reduce(lambda x, y: x * y, [1, 2, 3, 4]))  # 相当于 ((1 * 2) * 3) * 4

60. 回调函数，如何通信的?

回调函数是指在某个特定事件或条件发生时被调用的函数。通常，回调函数用于在异步操作、事件驱动的编程或特定条件满足时执行相应的操作。

通信是通过参数传递来实现的。回调函数可以接受参数，并且这些参数可以用于与调用方进行通信。

在回调函数被调用时，通常会将一些信息作为参数传递给回调函数。这些信息可以是任何类型的数据，例如状态信息、结果数据、错误信息等。通过这些参数，回调函数可以访问和处理相关的数据，以便根据需要进行操作。

下面是一个简单的示例来说明回调函数如何进行通信：

def process_data(data, callback):
    # 处理数据的逻辑
    result = perform_some_processing(data)
    
    # 调用回调函数，并传递处理结果作为参数
    callback(result)

def callback_function(result):
    # 在回调函数内部处理结果
    print("处理结果为:", result)

# 调用函数，并传递回调函数
data = get_data_from_source()
process_data(data, callback_function)

在这个示例中，我们定义了一个process_data函数，它接受数据和一个回调函数作为参数。在函数内部，我们对数据进行处理，并得到一个结果。然后，我们调用回调函数，并将处理结果作为参数传递给它。

同时，我们定义了callback_function作为回调函数。在回调函数内部，我们打印处理结果。

最后，我们从某个数据源获取数据，然后调用process_data函数，并传递数据和回调函数作为参数。在process_data函数内部，数据被处理后，回调函数被调用，并将处理结果传递给它。这样，回调函数可以获取和处理处理结果。

通过这种方式，回调函数和调用方之间可以进行双向通信。调用方可以通过传递参数给回调函数来提供信息，而回调函数可以通过返回值、修改共享变量或其他方式来向调用方传递信息。

需要注意的是，回调函数的执行时机和方式取决于具体的编程模型和框架。在不同的上下文中，回调函数可能具有不同的规则和约定。因此，在使用回调函数时，需要根据具体情况了解相关的规范和文档。

61. hasattr() getattr() setattr() 函数使用详解？

hasattr(), getattr(), 和 setattr() 是 Python 内置的用于操作对象属性的函数。它们可以用于检查对象是否具有某个属性、获取属性的值以及设置属性的值。下面是对这三个函数的详细说明：

hasattr(object, attribute): hasattr() 函数用于检查一个对象是否具有指定的属性。它接受两个参数，object 表示要检查的对象，attribute 表示要检查的属性名。如果对象具有指定的属性，则返回 True；否则返回 False。示例用法如下：
```
class Person:
    name = "John"

person = Person()

print(hasattr(person, 'name'))  # 输出 True
print(hasattr(person, 'age'))   # 输出 False
```
getattr(object, attribute[, default]): getattr() 函数用于获取对象的属性值。它接受三个参数，object 表示要获取属性值的对象，attribute 表示要获取的属性名，default 是可选参数，表示当对象没有指定的属性时返回的默认值。如果对象具有指定的属性，则返回属性的值；如果对象没有指定的属性，并且提供了默认值，则返回默认值；如果既没有指定的属性，也没有提供默认值，则会触发 AttributeError 异常。示例用法如下：
```
class Person:
    name = "John"

person = Person()

print(getattr(person, 'name'))        # 输出 "John"
print(getattr(person, 'age', 30))     # 输出 30
print(getattr(person, 'address'))     # 触发 AttributeError 异常
```
setattr(object, attribute, value): setattr() 函数用于设置对象的属性值。它接受三个参数，object 表示要设置属性值的对象，attribute 表示要设置的属性名，value 表示要设置的属性值。如果对象已经具有指定的属性，那么该属性的值将会被替换为新的值；如果对象没有指定的属性，那么将会创建一个新的属性，并设置其值为指定的值。示例用法如下：
```
class Person:
    name = "John"

person = Person()

setattr(person, 'name', 'Mike')
setattr(person, 'age', 25)

print(person.name)       # 输出 "Mike"
print(person.age)        # 输出 25
```

综上所述，hasattr() 用于检查对象是否具有指定的属性，getattr() 用于获取对象的属性值，setattr() 用于设置对象的属性值。这些函数在操作对象属性时非常实用，可以在运行时动态地检查和修改对象的属性。

62. 一句话解决阶乘函数？

from functools import reduce

reduce(lambda x,y : x*y,range(1,n+1))

63. 什么是lambda函数？有什么好处？

Lambda函数是一种匿名函数，也称为"lambda表达式"。它是一种简洁的函数定义方式，可以在需要函数的地方定义并使用，而无需使用def关键字来创建函数。

Lambda函数的语法如下：

lambda arguments: expression

其中，arguments表示函数的参数，expression表示函数的返回值表达式。Lambda函数可以有多个参数，用逗号分隔。返回值是表达式的结果。

Lambda函数的主要好处包括：

简洁性: Lambda函数的定义非常简洁，可以在一行代码内完成函数的定义，不需要使用def关键字和函数名。这使得Lambda函数在编写简单的、无需重复使用的函数时非常方便。
匿名性: Lambda函数是匿名的，它没有函数名。这在某些情况下很有用，特别是当你只需要一个简单的函数用于传递给其他函数、作为回调函数或作为参数进行计算时。
函数式编程: Lambda函数在函数式编程中非常有用。函数式编程强调使用函数作为一等公民，将函数作为数据进行操作和传递。Lambda函数提供了一种简洁的方式来定义和使用这样的函数，使得函数式编程思想更易于实现。
减少命名冲突: 由于Lambda函数是匿名的，它们不会引入新的函数名，从而减少了命名冲突的可能性。这在编写简单的、局部性的函数时非常有用。

虽然Lambda函数具有简洁性和匿名性的优点，但也有一些限制。Lambda函数只能包含单个表达式，不能包含多个语句或复杂的逻辑。此外，Lambda函数通常用于编写简单和短小的函数，而不是复杂的函数逻辑。

综上所述，Lambda函数是一种匿名函数，具有简洁性和匿名性的优点。它适用于编写简单的、无需重复使用的函数，并在函数式编程中发挥作用。

64. 递归函数停止的条件？

递归函数停止的条件通常称为递归基（Base Case）或终止条件（Termination Condition）。递归函数通过在函数内部调用自身来解决问题，但为了避免无限递归，必须定义一个或多个终止条件，使得递归在某个条件满足时停止。

在设计递归函数时，通常需要考虑以下几个因素来确定递归的终止条件：

问题规模的减小: 递归函数应该通过每次调用递归函数来减小问题的规模。在最终达到一个小规模问题时，递归应该停止。
边界条件: 边界条件是指递归函数可以直接解决而无需进一步递归的情况。这是递归的基本情况，也是递归的终止条件。
合理性: 终止条件必须是合理的，能够确保递归函数的正确性并避免无限递归。终止条件应该能够最终得到问题的解答或期望的结果。

递归函数的终止条件是根据具体问题而定的，因此在设计递归函数时需要仔细考虑问题的特性和要求。下面是一个简单的示例来说明递归函数的终止条件：

def factorial(n):
    if n == 0:  # 终止条件：当 n 等于 0 时，递归停止
        return 1
    else:
        return n * factorial(n-1)  # 递归调用函数，并减小问题规模

result = factorial(5)
print(result)  # 输出 120

在这个示例中，我们定义了一个计算阶乘的递归函数factorial。终止条件是当输入 n 等于 0 时，函数直接返回 1。在递归调用中，我们将问题规模减小，通过 n * factorial(n-1) 的方式递归计算阶乘。当 n 达到终止条件时，递归停止，返回最终结果。

需要注意的是，如果递归函数没有适当的终止条件或终止条件设计不当，可能会导致无限递归，消耗大量的内存和计算资源，甚至导致程序崩溃。因此，在编写递归函数时，务必确保终止条件的合理性和正确性。

65. 下面这段代码的输出结果将是什么？请解释。

def multipliers():
    return [lambda x: i * x for i in range(4)]


print([m(2) for m in multipliers()])

执行上述代码后，输出结果将是 [6, 6, 6, 6]。

这是因为在 multipliers() 函数中，我们创建了一个包含四个 lambda 函数的列表，并且每个 lambda 函数都接受一个参数 x，并返回 i * x，其中 i 是在循环中生成的值。这些 lambda 函数都共享了同一个变量 i。

当我们调用 multipliers() 函数并对结果列表进行迭代时，每个 lambda 函数都会引用最后一次循环迭代中的 i 值，而不是它们创建时的值。因此，无论我们传入什么参数 x，每个 lambda 函数都会返回 3 * x，即最后一次迭代的 i 值。

简单来说，由于 lambda 函数在循环结束后才被调用，它们都引用了相同的变量 i，而最后一次迭代时的 i 值是 3，所以无论我们传入什么参数，每个 lambda 函数都会返回 3 * x。因此，结果列表为 [6, 6, 6, 6]。

要解决这个问题，我们可以在 lambda 函数内部使用默认参数来捕获当前循环的 i 值，从而避免共享相同的变量。下面是修正后的代码示例：

def multipliers():
    return [lambda x, i=i: i * x for i in range(4)]
    
print([m(2) for m in multipliers()])  # 输出 [0, 2, 4, 6]

在修正后的代码中，我们在 lambda 函数的参数列表中添加了 i=i，将当前循环的 i 值作为默认参数的初始值。这样每个 lambda 函数都会捕获到不同的 i 值，从而得到正确的结果。

或者使用生成器函数

def multipliers():
    for i in range(4):
        yield lambda x: i * x


print([m(2) for m in multipliers()])

执行上述代码后，输出结果将是 [0, 2, 4, 6]。

在这个修正后的代码中，我们使用了生成器函数（generator function）multipliers()，它使用 yield 语句生成了四个 lambda 函数。每个 lambda 函数都接受参数 x，并返回 i * x，其中 i 是在循环中生成的值。

当我们调用 multipliers() 并对结果列表进行迭代时，每次迭代都会生成一个新的 lambda 函数，并将当前循环的 i 值绑定到该 lambda 函数中。这意味着每个 lambda 函数都有自己独立的 i 值，而不是共享相同的变量。

因此，当我们传入参数 2 时，第一个 lambda 函数返回 0 * 2，第二个 lambda 函数返回 1 * 2，第三个 lambda 函数返回 2 * 2，第四个 lambda 函数返回 3 * 2，得到最终的结果列表 [0, 2, 4, 6]。

与前面的代码示例相比，使用生成器函数生成 lambda 函数可以避免共享变量的问题。每个 lambda 函数都在生成时绑定了相应的 i 值，使得它们能够正确地计算结果。这种方式更符合我们通常期望的行为，并且能够产生预期的输出。

海哥python