【Python】面试点总结（一）

1. Python 基础知识

• Python 是什么？

• • Python 是一种高级编程语言，以其可读性和简约的语法著称。它支持多种编程范式，包括面向对象、命令式和函数式编程。

• Python 的基本数据类型有哪些？

• • 数字：整型（int）、浮点型（float）、复数（complex）。
    示例：

a = 5        # int  
b = 5.0      # float  
c = 3 + 4j   # complex

• • 字符串（str）：文本数据，支持多种操作。
    示例：

s = "Hello"  
print(s[0])  # H

• • 列表（list）：有序可变的集合。
    示例：

nums = [1, 2, 3]  
nums.append(4)  # [1, 2, 3, 4]

• • 元组（tuple）：有序不可变的集合。
    示例：

point = (1, 2)

• • 字典（dict）：无序可变的键值对集合。
    示例：

student = {"name": "Alice", "age": 22}

• • 集合（set）：无序不重复的元素集合。
    示例：

unique_nums = {1, 2, 3, 1}  # {1, 2, 3}

• 判断一个变量的类型的常用方法：

type(variable)                   # 返回变量的类型  
isinstance(variable, expected_type)  # 判断是否是某种类型

2. 控制结构

• 流程控制语句：

• • 使用 if、elif 和 else 控制程序路径：

if condition:  
    # 执行代码  
    elif another_condition:  
# 执行其他代码  
        else:  
# 执行默认代码

• 循环中的异常处理：

for item in items:  
    try:  
        process_item(item)  
    except SomeException as e:  
        handle_exception(e)

3. 函数和模块

• 函数的定义与调用：

def greet(name):  
    return f"Hello, {name}!"  

print(greet("World"))  # Hello, World!

• Python 的 lambda 函数：

• • 使用场景示例：

# 用于排序  
pairs = [(1, 'one'), (2, 'two'), (3, 'three')]  
pairs.sort(key=lambda pair: pair[1])

• 装饰器的基本示例：

def decorator_function(original_function):  
    def wrapper_function():  
        print("Wrapper executed before {}".format(original_function.__name__))  
        return original_function()  
    return wrapper_function  

@decorator_function  
def display():  
    return "Display function executed"

4. 数据结构和算法

• 反转字符串的多种方法：

# 使用切片  
reversed_string = original_string[::-1]  

# 使用 reversed()  
reversed_string = ''.join(reversed(original_string))  

# 使用循环  
reversed_string = ''  
for char in original_string:  
    reversed_string = char + reversed_string

• 列表的常见操作：

• • 添加元素、删除元素、查找元素：

my_list = [1, 2, 3]  
my_list.append(4)  # [1, 2, 3, 4]  
my_list.remove(2)  # [1, 3, 4]  
index = my_list.index(3)  # 1

5. 文件和异常处理

• 文件操作的完整示例：

with open('example.txt', 'r') as file:  
    contents = file.read()  
    print(contents)  

with open('output.txt', 'w') as file:  
    file.write("Writing some text.")

• 异常处理示例：

try:  
    # 可能出错的代码  
    result = 10 / 0  
except ZeroDivisionError:  
    print("Cannot divide by zero!")  
except Exception as e:  
    print(f"An error occurred: {e}")  
finally:  
    print("This will always execute.")

6. 面向对象编程

• 类的定义和对象的创建：

class Animal:  
    def __init__(self, name):  
        self.name = name  

    def speak(self):  
        return f"{self.name} makes a sound."  

cat = Animal("Cat")  
print(cat.speak())  # Cat makes a sound.

• 方法重写和多态示例：

class Dog(Animal):  
    def speak(self):  
        return f"{self.name} barks."  

dog = Dog("Dog")  
print(dog.speak())  # Dog barks.

7. 常用库

• NumPy 基本操作：

import numpy as np  

arr = np.array([1, 2, 3])  
print(arr.mean())  # 2.0

• Pandas 数据处理示例：

import pandas as pd  

data = {'Name': ['Alice', 'Bob'], 'Age': [24, 30]}  
df = pd.DataFrame(data)  
print(df)

8. 其他重点

• 生成器的创建与使用：

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

for number in count_up_to(5):  
    print(number)  # 1 2 3 4 5

• GIL 的影响：

• • Python 的 GIL（全局解释器锁）限制了多线程程序在多核处理器上的并行性，因此在 CPU 密集型任务中，可能更有效的选择是使用多进程（multiprocessing 模块）。

• 单元测试的基本构造：

import unittest  

class TestMyFunction(unittest.TestCase):  
    def test_sum(self):  
        self.assertEqual(sum([1, 2, 3]), 6)  

if __name__ == '__main__':  
    unittest.main()

9. 进阶概念

1. 上下文管理器的使用示例：

上下文管理器是 Python 中的一种用于资源管理的结构，能够简化资源的分配和释放过程。上下文管理器确保在执行代码块之前正确地初始化资源，并在代码块执行后无论是否发生异常都能清理这些资源。这通常是通过 with 语句实现的。

主要特点

1. 简化代码：通过使用上下文管理器，你不再需要手动进行资源清理，比如打开文件后忘记关闭，使用数据库连接后没有释放等。
2. 自动处理异常：即使在代码块中发生异常，with 块会确保资源被正确释放，避免资源泄漏。
3. 支持自定义：你可以创建自己的上下文管理器，以便在特定场景下管理资源。

上下文管理器的基本用法

1. 使用内置上下文管理器

一个常见的例子是打开文件：

with open('example.txt', 'r') as file:  
    contents = file.read()  
    print(contents)

在这个示例中，open 函数返回一个上下文管理器，with 语句确保文件在使用后自动关闭。即使在读取文件的过程中出现异常，文件也会被安全地关闭。

2. 自定义上下文管理器

你可以通过定义一个类并实现 __enter__ 和 __exit__ 方法来创建自己的上下文管理器：

class MyContext:  
    def __enter__(self):  
        print("Entering the context")  
        return self  

    def __exit__(self, exc_type, exc_val, exc_tb):  
        print("Exiting the context")  

with MyContext() as context:  
    print("In the context")

在这个例子中：

• __enter__ 方法在 with 语句开始时被调用，可以进行资源的初始化（如打开连接）。
• __exit__ 方法在 with 块执行结束时被调用，用于执行清理操作（如关闭连接）。它接受三个参数，分别表示异常类型、值和追踪信息，可以用来处理异常。

3. 使用 contextlib 模块

如果你的上下文管理器只需要进行简单的资源管理，可以使用 Python 的 contextlib 模块中的 contextmanager 装饰器来简化创建过程：

from contextlib import contextmanager  

@contextmanager  
def simple_context():  
    print("Entering the context")  
    try:  
        yield  # 在这里可以返回任何需要传递的值  
    finally:  
        print("Exiting the context")  

# 使用简单的上下文管理器  
with simple_context():  
    print("In the context")

在这个例子中，yield 用于分隔上下文管理器的进入和退出。try-finally 确保在退出时执行清理代码。

2. 异步编程的基本概念（asyncio）：

异步编程是一种编程范式，允许程序在等待某些操作完成（如网络请求、文件读取等）时，不会阻塞整个程序的执行。这样可以提高程序的效率，特别是在涉及大量 I/O 操作时。Python 提供了内置的支持来实现异步编程，其中最重要的库是 asyncio。

基本概念

1. 同步与异步:

• • 同步编程：在执行代码时，代码会按顺序运行，一个操作完成后才能开始下一个操作。例如，读取文件的操作会阻塞，直到文件完全读取完毕。
  • 异步编程：操作可以在等待时执行其他任务，不需要阻塞。例如，如果你在等待网络响应，可以继续执行其他代码。

1. 事件循环:

• • Python 的异步编程依赖于事件循环（event loop）。事件循环是一个不断运行的循环，用于调度和处理任务（如 I/O 事件和回调）。你可以把事件循环想象成一个调度员，它负责执行多个任务（coroutines），并自动管理它们的状态。

1. 协程（Coroutines）:

• • 协程是异步编程的核心，是一种可以挂起和恢复的函数。与普通函数不同，协程可以在执行过程中暂停（使用 await 关键字），等到某个操作完成后再继续执行。
  • 协程通过 async def 关键字定义，例如：

async def my_coroutine():  
    print("Start")  
    await asyncio.sleep(1)  # 模拟 I/O 操作  
    print("End")

1. async 和 await 关键字:

• • async 用于定义协程，标记一个函数是异步的。
  • await 用于挂起协程的执行，等待某个异步操作完成，例如在协程内部调用另一个协程。

1. 任务（Tasks）:

• • 在事件循环中，协程通过任务（Task）来运行。任务是协程的包装器，使它们能够在事件循环中调度和执行。可以使用 asyncio.create_task() 创建任务。

基本示例

下面是一个简单的例子，演示了如何使用 asyncio 模块进行异步编程：

import asyncio  

async def greet(name):  
    print(f"Hello, {name}!")  
    await asyncio.sleep(1)  # 模拟 I/O 操作  
    print(f"Goodbye, {name}!")  

async def main():  
    # 创建多个协程任务并调度执行  
    await asyncio.gather(  
        greet("Alice"),  
        greet("Bob"),  
        greet("Charlie"),  
    )  

# 执行主协程  
asyncio.run(main())

解释：

• 定义协程：使用 async def 定义了 greet 协程。
• 挂起执行：在 greet 中，await asyncio.sleep(1) 模拟了延迟，代表在进行 I/O 操作的时间。
• 调度多个任务：在 main 协程中，asyncio.gather() 用于并行地调度多个 greet 调用。
• 运行主程序：通过 asyncio.run(main()) 来运行主协程。

适用场景

• I/O 密集型应用：例如网络请求、数据库操作、文件操作等，这些操作通常会等待外部资源完成，因此异步编程可以提高效率。
• 高并发场景：在需要处理大量并发连接时，异步编程能有效利用系统资源。

注意事项

• 不适合 CPU 密集型任务：由于 Python 的全局解释器锁（GIL），异步编程并不能提高 CPU 密集型操作的性能，此类任务更适合使用多线程或多进程。

import asyncio  

async def say_hello():  
    print("Hello!")  
    await asyncio.sleep(1)  
    print("World!")  

asyncio.run(say_hello())

原文地址：https://blog.csdn.net/qq_25699299/article/details/143798705

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！