10个Python常见面试题，这些弄不明白不要说学过Python！("掌握这10个Python高频面试题，才算真正学会Python！")

1. Python中的列表和元组有什么区别？

列表是可变的（mutable），而元组是不可变的（immutable）。这意味着我们可以修改列表的元素，但不能修改元组的元素。下面是一个简洁的例子：

# 列表是可变的
my_list = [1, 2, 3]
my_list[0] = 100
print(my_list)  # 输出: [100, 2, 3]
# 元组是不可变的
my_tuple = (1, 2, 3)
my_tuple[0] = 100  # 抛出TypeError异常

2. 怎样在Python中实现单例模式？

单例模式是一种设计模式，用于确保一个类只有一个实例。以下是一个使用装饰器实现单例模式的例子：

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance
@singleton
class Database:
    def __init__(self):
        print("Loading database connection")
db1 = Database()
db2 = Database()
print(db1 == db2)  # 输出: True

3. 怎样交换两个变量的值？

在Python中，交换两个变量的值非常简洁，不需要使用临时变量：

a = 5
b = 10
a, b = b, a
print(a, b)  # 输出: 10 5

4. Python中的生成器是什么？

生成器是一种特殊的迭代器，它在每次迭代时计算下一个值。生成器使用关键字`yield`来生成值。以下是一个生成器的例子：

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b
for num in fibonacci(10):
    print(num)  # 输出: 0 1 1 2 3 5 8 13 21 34

5. 怎样在Python中实现异常处理？

异常处理在Python中使用`try`和`except`块来实现。以下是一个处理除法不正确的例子：

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
print("Execution continues after the exception.")

6. 怎样在Python中实现多线程？

Python提供了`threading`模块来拥护多线程。以下是一个简洁的多线程例子：

import threading
def print_numbers():
    for i in range(1, 6):
        print(i)
thread = threading.Thread(target=print_numbers)
thread.start()
for i in range(6, 11):
    print(i)
thread.join()  # 等待线程终止

7. 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()
# 输出:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

8. 怎样在Python中实现深拷贝和浅拷贝？

浅拷贝复制对象的顶层元素，而深拷贝复制对象的所有元素，包括嵌套的元素。以下是一个例子：

import copy
original = [[1, 2, 3], [4, 5, 6]]
shallow_copy = copy.copy(original)
deep_copy = copy.deepcopy(original)
original[0][0] = 100
print(original)  # 输出: [[100, 2, 3], [4, 5, 6]]
print(shallow_copy)  # 输出: [[100, 2, 3], [4, 5, 6]]
print(deep_copy)  # 输出: [[1, 2, 3], [4, 5, 6]]

9. 怎样在Python中实现链式调用？

链式调用是一种编程风格，允许对象方法的连续调用。以下是一个简洁的例子，通过在方法中返回`self`来实现链式调用：

class Chain:
    def __init__(self, value):
        self.value = value
    def add(self, amount):
        self.value += amount
        return self
    def display(self):
        print(self.value)
        return self
chain = Chain(5)
chain.add(10).display().add(15).display()
# 输出:
# 15
# 30

10. Python中的GIL是什么？

GIL是全局解释器锁（Global Interpreter Lock），它是Python核心的一部分。GIL确保同一时间只有一个线程执行Python字节码。这意味着即使在多核处理器上，Python的多线程也无法实现真正的并行执行。以下是一个展示GIL作用的例子：

import threading
import time
def count():
    global counter
    for _ in range(1000000):
        counter += 1
counter = 0
start_time = time.time()
# 创建两个线程
thread1 = threading.Thread(target=count)
thread2 = threading.Thread(target=count)
# 启动线程
thread1.start()
thread2.start()
# 等待线程终止
thread1.join()
thread2.join()
end_time = time.time()
print(f"Counter value: {counter}")
print(f"Time taken: {end_time - start_time}")
# 这通常会输出Counter value: 2000000，但大概不是，归因于GIL的存在

本文由IT视界版权所有,禁止未经同意的情况下转发