Python进阶

目录

1. 面向对象编程（OOP）

2. 异常处理

3. 模块和包

4. 文件和目录操作

5. 网络编程

6. 数据库操作

7. 并发编程

8. 测试和调试

使用pdb进行调试

总结

---

1. 面向对象编程（OOP）

面向对象编程（OOP）是一种编程范式，强调将数据和操作数据的代码封装在对象中。Python支持OOP，允许你定义类和对象。

类和对象
类是对象的蓝图或模板。对象是类的实例。

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        return "Woof!"

my_dog = Dog("Buddy", 3)
print(my_dog.name)
print(my_dog.bark())

类的属性和方法

• 实例属性：每个对象独有的属性。
• 类属性：所有对象共享的属性。
• 实例方法：只能通过对象调用的方法。
• 类方法：可以通过类本身调用的方法，使用@classmethod装饰。

class Dog:
    species = "Canis familiaris"  # 类属性

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age
    
    def bark(self):  # 实例方法
        return "Woof!"
    
    @classmethod
    def get_species(cls):  # 类方法
        return cls.species

print(Dog.get_species())

继承
继承允许一个类从另一个类继承属性和方法。

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def speak(self):
        return "Meow"

my_cat = Cat("Whiskers")
print(my_cat.speak())

多态和封装

• 多态：不同对象可以以相同的方式调用相同的方法。
• 封装：通过限制访问来保护对象的内部状态。

class Animal:
    def __init__(self, name):
        self.__name = name  # 私有属性
    
    def get_name(self):
        return self.__name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

my_dog = Dog("Buddy")
print(my_dog.get_name())
print(my_dog.speak())

2. 异常处理

异常处理用于捕获和处理程序运行时的错误，确保程序的健壮性。

捕获异常
使用try, except, finally语句来捕获和处理异常。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("不能除以零")
finally:
    print("无论是否发生异常，这里都会执行")

自定义异常
你可以定义自己的异常类，从而更好地控制异常处理。

python

Copy

class CustomError(Exception):
    pass

try:
    raise CustomError("这是一个自定义错误")
except CustomError as e:
    print(e)

3. 模块和包

模块和包是Python组织代码和重用的基本单元。

模块的创建和导入
模块是一个包含Python代码的文件，可以通过import语句导入。

# my_module.py
def add(a, b):
    return a + b

# main.py
import my_module
print(my_module.add(5, 3))

包的创建和使用
包是一个包含多个模块的目录，必须包含一个__init__.py文件。

# my_package/__init__.py
# my_package/module1.py
def func1():
    return "Hello from module1"

# main.py
from my_package import module1
print(module1.func1())

使用Python标准库
Python标准库提供了大量的模块，涵盖了从文件操作到网络编程的各种功能。

import sys
import os
import json
import re

print(sys.version)
print(os.getcwd())
print(json.dumps({"name": "Alice", "age": 25}))
print(re.match(r'\d+', '123abc'))

4. 文件和目录操作

Python的os和shutil模块提供了丰富的文件和目录操作功能。

文件操作

# 创建、读取、写入和删除文件
with open("example.txt", "w") as file:
    file.write("Hello, Python!")

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

os.remove("example.txt")

目录操作

# 创建、删除目录
os.mkdir("test_dir")
os.rmdir("test_dir")

# 遍历目录
for root, dirs, files in os.walk("."):
    print("Root:", root)
    print("Dirs:", dirs)
    print("Files:", files)

shutil模块

import shutil

# 复制、移动和删除文件和目录
shutil.copy("source.txt", "destination.txt")
shutil.move("source.txt", "destination_dir")
shutil.rmtree("test_dir")

5. 网络编程

Python的requests库使得HTTP请求变得非常简单。

使用requests库进行HTTP请求

import requests

response = requests.get("https://api.github.com")
print(response.status_code)
print(response.json())

使用socket进行网络通信

import socket

# 创建服务器
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(("localhost", 8080))
server_socket.listen(5)
print("服务器已启动，等待连接...")

while True:
    client_socket, addr = server_socket.accept()
    print(f"连接来自{addr}")
    client_socket.sendall(b"Hello, Client!")
    client_socket.close()

# 创建客户端
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(("localhost", 8080))
data = client_socket.recv(1024)
print(f"收到数据: {data.decode()}")
client_socket.close()

6. 数据库操作

Python的sqlite3模块允许你轻松地操作SQLite数据库。

SQLite数据库

import sqlite3

# 连接到数据库
conn = sqlite3.connect('example.db')
c = conn.cursor()

# 创建表
c.execute('''CREATE TABLE IF NOT EXISTS students (id INTEGER PRIMARY KEY, name TEXT)''')

# 插入数据
c.execute("INSERT INTO students (name) VALUES ('Alice')")
conn.commit()

# 查询数据
c.execute("SELECT * FROM students")
print(c.fetchall())

# 更新和删除数据
c.execute("UPDATE students SET name = 'Bob' WHERE id = 1")
conn.commit()
c.execute("DELETE FROM students WHERE id = 1")
conn.commit()

# 关闭连接
conn.close()

使用SQLAlchemy进行ORM操作

from sqlalchemy import create_engine, Column, Integer, String, Sequence
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# 创建数据库连接
engine = create_engine('sqlite:///:memory:')
Base = declarative_base()

# 定义模型
class Student(Base):
    __tablename__ = 'students'
    id = Column(Integer, Sequence('student_id_seq'), primary_key=True)
    name = Column(String(50))

Base.metadata.create_all(engine)

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 插入数据
new_student = Student(name='Alice')
session.add(new_student)
session.commit()

# 查询数据
for student in session.query(Student).all():
    print(student.name)

7. 并发编程

并发编程允许你同时运行多个任务，提高程序的效率。

线程和进程

import threading
import multiprocessing

# 创建和管理线程
def thread_task(name):
    print(f"线程 {name} 正在运行")

thread = threading.Thread(target=thread_task, args=("Thread-1",))
thread.start()
thread.join()

# 创建和管理进程
def process_task(name):
    print(f"进程 {name} 正在运行")

process = multiprocessing.Process(target=process_task, args=("Process-1",))
process.start()
process.join()

异步编程

import asyncio

# 定义异步函数
async def async_task(name):
    print(f"异步任务 {name} 正在运行")
    await asyncio.sleep(1)
    print(f"异步任务 {name} 完成")

# 运行异步任务
async def main():
    await asyncio.gather(
        async_task("Task-1"),
        async_task("Task-2")
    )

asyncio.run(main())

8. 测试和调试

测试和调试是确保代码质量的重要步骤。

使用unittest进行单元测试

import unittest

def add(a, b):
    return a + b

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(1, 2), 3)
        self.assertEqual(add(-1, 1), 0)

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

使用pdb进行调试

pdb是Python内置的调试器，允许你逐步执行代码、设置断点和检查变量。

设置断点
你可以在代码中使用pdb.set_trace()设置断点，这样程序会在执行到断点时暂停，进入调试模式。

import pdb

def add(a, b):
    pdb.set_trace()  # 设置断点
    return a + b

result = add(2, 3)
print(result)

逐步执行代码
在调试模式下，你可以使用以下命令逐步执行代码：

• n（next）：执行下一行代码，不进入函数内部。
• s（step）：执行下一行代码，如果是函数调用，进入函数内部。
• c（continue）：继续执行代码，直到遇到下一个断点或程序结束。
• q（quit）：退出调试模式。

检查变量
在调试模式下，你可以直接输入变量名来检查其值。

import pdb

def add(a, b):
    pdb.set_trace()  # 设置断点
    sum = a + b
    return sum

result = add(2, 3)
print(result)

在调试模式下，输入sum可以查看变量sum的值。

总结

通过本文，你应该已经掌握了Python的一些进阶主题和实践，包括面向对象编程、异常处理、模块和包、文件和目录操作、网络编程、数据库操作、并发编程以及测试和调试。以下是一些关键点的回顾：

• 面向对象编程（OOP）：定义类和对象，使用继承、多态和封装来组织和管理代码。
• 异常处理：使用try, except, finally语句捕获和处理异常，确保程序的健壮性。
• 模块和包：创建和导入模块，组织和重用代码。
• 文件和目录操作：使用os和shutil模块进行文件和目录操作。
• 网络编程：使用requests库进行HTTP请求，使用socket进行网络通信。
• 数据库操作：使用sqlite3模块操作SQLite数据库，使用SQLAlchemy进行ORM操作。
• 并发编程：使用线程和进程提高程序的效率，使用asyncio进行异步编程。
• 测试和调试：使用unittest进行单元测试，使用pdb进行调试。