Python编程入门指南

Python简介

Python是一种高级编程语言，由Guido van Rossum于1989年底发明，并于1991年首次发布。它具有简单易学、可读性强、语法简洁等特性，使得Python成为初学者和专业开发者都喜欢使用的语言。同时，Python拥有庞大的标准库和第三方库支持，可以方便地应用于Web开发、数据科学、机器学习、网络爬虫、自动化脚本等多种场景。

Python有两种主要的版本：Python 2和Python 3。Python 2已经停止更新，但仍然广泛用于一些旧项目中。Python 3是当前的活跃版本，推荐初学者从Python 3开始学习。

安装Python

Python可以通过官方网站下载安装包进行安装，也可以通过pip工具来安装Python环境。以下是安装Python的步骤：

1. 访问官方网站：https://www.python.org/downloads/
2. 选择适合您操作系统的版本进行下载。
3. 运行下载好的安装程序，根据提示完成安装。
4. 安装完成后，可通过命令行验证Python是否安装成功，输入 python --version 或 python3 --version，显示的是Python版本号，说明安装成功。

Python环境配置

安装Python后，需要配置环境变量以便在命令行中直接使用Python命令。以下是配置环境变量的步骤：

1. 打开系统环境变量设置窗口。
2. 在“系统变量”部分找到名为“Path”的变量，点击“编辑”。
3. 点击“新建”，添加Python的安装路径，例如：C:\Python39\。
4. 点击“确定”，完成环境变量的设置。

完成以上步骤后，您可以在命令行中输入 python --version 或 python3 --version 来验证Python是否已成功配置到环境变量中。

开发工具与IDE

Python开发可以使用文本编辑器或集成开发环境（IDE）进行。文本编辑器如Sublime Text、Visual Studio Code等，或IDE如PyCharm、Jupyter Notebook等，都是有效的开发工具。下面以PyCharm为例，介绍如何配置Python开发环境。

1. 下载并安装PyCharm，访问PyCharm官网：https://www.jetbrains.com/pycharm/download/
2. 运行安装程序，按照提示完成安装。
3. 打开PyCharm，选择“File” -> "Settings"。
4. 在“Project：项目名称”下选择"Python Interpreter"，点击"..."。
5. 在弹出的窗口中，点击"+"按钮，选择"Add Local"，然后选择之前安装好的Python解释器。
6. 点击“OK”，完成配置。

变量与类型

变量

在Python中，变量是一种存储数据的容器。变量的定义不需要指定类型，Python会根据赋值自动推断类型。下面是一些变量定义的示例：

# 定义整型变量
integer_variable = 10

# 定义浮点型变量
float_variable = 3.14

# 定义字符串变量
string_variable = "Hello, Python!"

# 定义布尔型变量
boolean_variable = True

# 定义列表变量
list_variable = [1, 2, 3, 4]

# 定义字典变量
dictionary_variable = {"name": "Alice", "age": 25}

# 定义元组变量
tuple_variable = (10, 20)

# 定义集合变量
set_variable = {1, 2, 3, 4}

数据类型

Python中有几种主要的数据类型，包括整型、浮点型、字符串、布尔型、列表、元组、字典和集合。

整型（int）

整型用于表示整数，如10、-2等。Python中的整型没有大小限制，由内存决定。

integer_variable = 10
print(type(integer_variable))  # 输出：<class 'int'>

浮点型（float）

浮点型用于表示带有小数点的数字，如3.14、0.001等。

float_variable = 3.14
print(type(float_variable))  # 输出：<class 'float'>

字符串（str）

字符串用于表示文本数据，用单引号或双引号包围。

string_variable = "Hello, Python!"
print(type(string_variable))  # 输出：<class 'str'>

布尔型（bool）

布尔型用于表示真（True）或假（False），通常用于逻辑判断。

boolean_variable = True
print(type(boolean_variable))  # 输出：<class 'bool'>

列表（list）

列表是一种有序的、可变的数据结构，可以存储多个元素。

list_variable = [1, 2, 3, 4]
print(type(list_variable))  # 输出：<class 'list'>

元组（tuple）

元组与列表相似，但是元组是不可变的，一旦创建后无法修改。

tuple_variable = (10, 20)
print(type(tuple_variable))  # 输出：<class 'tuple'>

字典（dict）

字典是一种键值对的数据结构，用于存储关联数据。

dictionary_variable = {"name": "Alice", "age": 25}
print(type(dictionary_variable))  # 输出：<class 'dict'>

集合（set）

集合是一种无序且不重复的数据结构，用于存储唯一的值。

set_variable = {1, 2, 3, 4}
print(type(set_variable))  # 输出：<class 'set'>

控制结构

控制结构是程序执行流程的关键，包括条件语句和循环语句。

条件语句

条件语句用于根据条件执行不同的代码块。Python中常用的条件语句包括 if、elif 和 else。

if 语句

if 语句用于检查一个条件是否为真，如果条件为真，则执行代码块。

x = 10
if x > 5:
    print("x is greater than 5")

elif 语句

elif 语句用于检查多个条件，当满足某一条件时执行对应代码块。

x = 15
if x > 20:
    print("x is greater than 20")
elif x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5")

else 语句

else 语句用于在所有条件都不满足时执行代码块。

x = 3
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5")
else:
    print("x is less than or equal to 5")

循环结构

循环结构用于重复执行一段代码，直到满足某个条件为止。常用的循环结构包括 for 循环和 while 循环。

for 循环

for 循环用于遍历一个序列（如列表、元组、字符串等），执行循环体内的代码。

for i in range(5):
    print(i)

while 循环

while 循环用于在条件为真时执行代码块，直到条件变为假。

count = 0
while count < 5:
    print(count)
    count += 1

函数

函数是组织代码和重用代码的重要工具，它将一组代码封装在一个名字下，可以通过调用函数来执行这段代码。

定义函数

使用 def 关键字定义一个函数。函数的定义包含函数名、参数列表、函数体和返回值。

def add_numbers(a, b):
    result = a + b
    return result

调用函数

定义好函数后，可以通过函数名和参数调用该函数。

sum = add_numbers(3, 4)
print(sum)  # 输出：7

可选参数与默认值

Python函数支持可选参数和默认值，可以通过指定默认值来为函数参数赋默认值。

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

greet("Alice")  # 输出：Hello, Alice!
greet("Bob", "Hi")  # 输出：Hi, Bob!

返回值

函数可以返回一个或多个值，使用 return 语句返回。

def calculate(a, b):
    sum = a + b
    product = a * b
    return sum, product

result_sum, result_product = calculate(3, 4)
print(result_sum, result_product)  # 输出：7 12

文件操作

Python提供了丰富的文件操作函数，可以读写各种格式的文件。下面是一些常见的文件操作示例。

读取文件

使用 open 函数打开文件，然后使用 read 方法读取文件内容。

file = open("example.txt", "r")
content = file.read()
print(content)
file.close()

写入文件

使用 open 函数打开文件，然后使用 write 方法写入内容。

file = open("example.txt", "w")
file.write("Hello, World!")
file.close()

使用 with 语句

with 语句可以自动管理文件的打开和关闭操作，确保资源被正确释放。

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

异常处理

异常处理用于捕获和处理程序运行时出现的错误，以保持程序的稳定性和健壮性。Python提供了 try、except、else 和 finally 语句来实现异常处理。

基本使用

使用 try 语句尝试执行代码块，如果发生异常，则执行 except 语句块。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

多个异常处理

可以捕获多个异常类型，如果某个异常被捕获，则不会执行后续的异常捕获。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
except TypeError:
    print("Invalid operation")

使用 else 和 finally

else 语句块用于在没有异常发生时执行代码块，finally 语句块用于无论是否发生异常都会执行的代码块。

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print("Operation successful")
finally:
    print("This code is always executed")

模块与包

Python中的模块和包用于组织代码，模块是一个包含Python代码的文件，通常以.py为扩展名。包是一组模块的集合，可以使用__init__.py文件来标记。

导入模块

使用 import 语句导入模块中的函数、类或变量。

import math

result = math.sqrt(16)
print(result)  # 输出：4.0

导入特定对象

使用 from ... import 语句导入模块中的特定对象。

from math import sqrt

result = sqrt(16)
print(result)  # 输出：4.0

包的使用

创建一个包时，通常在包的目录下创建一个 __init__.py 文件，该文件可以为空，也可以包含包的初始化代码。

# 文件结构
# my_package/
# ├── __init__.py
# └── my_module.py

在 my_module.py 文件中编写模块代码：

def hello():
    print("Hello from my_module")

使用包中的模块：

from my_package import my_module

my_module.hello()  # 输出：Hello from my_module

数据结构

Python提供了多种内置的数据结构，如列表、元组、字典和集合，可以满足不同的存储需求。

列表（List）

列表是一种有序的、可变的序列，可以存储不同类型的数据。

list1 = [1, 2, 3, 4]
list2 = ["a", "b", "c"]
list3 = [1, "two", 3.0]

list1.append(5)
print(list1)  # 输出：[1, 2, 3, 4, 5]

元组（Tuple）

元组是一种有序的、不可变的序列，与列表类似，但元素不能修改。

tuple1 = (1, 2, 3, 4)
tuple2 = ("a", "b", "c")

print(tuple1[0])  # 输出：1

字典（Dictionary）

字典是一种键值对结构，用于存储关联数据。

dictionary = {"name": "Alice", "age": 25}

dictionary["name"] = "Bob"
dictionary["email"] = "[e-mail]"

print(dictionary["name"])  # 输出：Bob
print(dictionary)  # 输出：{'name': 'Bob', 'age': 25, 'email': '[e-mail]'}

集合（Set）

集合是一种无序且不重复的数据结构，用于存储唯一的值。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

set1.add(5)
set1.remove(1)

print(set1)  # 输出：{2, 3, 4, 5}
print(set1.union(set2))  # 输出：{2, 3, 4, 5, 6}
print(set1.intersection(set2))  # 输出：{3, 4, 5}

面向对象编程

面向对象编程（OOP）是一种编程范式，它将数据和操作数据的方法封装在一起。

类和对象

类是对象的蓝图，定义了对象的属性和方法。对象是类的实例。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"My name is {self.name} and I am {self.age} years old.")

alice = Person("Alice", 25)
alice.introduce()  # 输出：My name is Alice and I am 25 years old.

继承

继承允许一个类（子类）继承另一个类（父类）的属性和方法。

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id

    def introduce(self):
        super().introduce()
        print(f"My student ID is {self.student_id}.")

bob = Student("Bob", 20, "12345")
bob.introduce()  # 输出：My name is Bob and I am 20 years old. My student ID is 12345.

封装

封装是限制直接访问对象成员的一种机制，通过属性和方法的私有化来实现。

class Car:
    def __init__(self, make, model, year):
        self.__make = make
        self.__model = model
        self.__year = year

    def get_make(self):
        return self.__make

    def get_model(self):
        return self.__model

    def get_year(self):
        return self.__year

my_car = Car("Toyota", "Corolla", 2020)
print(my_car.get_make())  # 输出：Toyota
print(my_car.get_model())  # 输出：Corolla
print(my_car.get_year())  # 输出：2020

多态

多态允许不同类的对象通过相同的接口执行不同的行为。

class Animal:
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        print("Woof!")

class Cat(Animal):
    def sound(self):
        print("Meow!")

def make_sound(animal):
    animal.sound()

dog = Dog()
cat = Cat()

make_sound(dog)  # 输出：Woof!
make_sound(cat)  # 输出：Meow!

一个完整的项目实例

class Employee:
    def __init__(self, name, position, salary):
        self.name = name
        self.position = position
        self.salary = salary

    def show_details(self):
        print(f"Name: {self.name}, Position: {self.position}, Salary: {self.salary}")

class Manager(Employee):
    def __init__(self, name, position, salary, department):
        super().__init__(name, position, salary)
        self.department = department

    def show_details(self):
        super().show_details()
        print(f"Department: {self.department}")

manager = Manager("John Doe", "Manager", 60000, "Sales")
manager.show_details()

高级特性

生成器

生成器是一种特殊类型的函数，可以生成一系列值，每次调用时返回一个值。

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

for number in count_up_to(5):
    print(number)

装饰器

装饰器是一种修改函数行为的高级机制，可以用于添加功能或包装函数。

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()

协程

协程是一种特殊的函数，可以异步执行并发任务，通常用于高并发场景。

def coroutine_example():
    print("Coroutine started")
    while True:
        received = yield
        print(f"Received: {received}")

coroutine = coroutine_example()
next(coroutine)  # 启动协程
coroutine.send("Hello")  # 发送数据
coroutine.send("World")

复杂的项目实例

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"Executed in {elapsed:0.2f} seconds")

数据结构与算法

常见数据结构

Python提供了多种内置的数据结构，如列表、元组、字典和集合，可以满足不同的存储需求。

列表（List）

列表是一种有序的、可变的序列，可以存储不同类型的数据。

list1 = [1, 2, 3, 4]
list2 = ["a", "b", "c"]
list3 = [1, "two", 3.0]

list1.append(5)
print(list1)  # 输出：[1, 2, 3, 4, 5]

元组（Tuple）

元组是一种有序的、不可变的序列，与列表类似，但元素不能修改。

tuple1 = (1, 2, 3, 4)
tuple2 = ("a", "b", "c")

print(tuple1[0])  # 输出：1

字典（Dictionary）

字典是一种键值对结构，用于存储关联数据。

dictionary = {"name": "Alice", "age": 25}

dictionary["name"] = "Bob"
dictionary["email"] = "[e-mail]"

print(dictionary["name"])  # 输出：Bob
print(dictionary)  # 输出：{'name': 'Bob', 'age': 25, 'email': '[e-mail]'}

集合（Set）

集合是一种无序且不重复的数据结构，用于存储唯一的值。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

set1.add(5)
set1.remove(1)

print(set1)  # 输出：{2, 3, 4, 5}
print(set1.union(set2))  # 输出：{2, 3, 4, 5, 6}
print(set1.intersection(set2))  # 输出：{3, 4, 5}

常见算法

排序算法

排序算法是一种将元素按照特定顺序排列的方法。常见的排序算法包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print(sorted_arr)  # 输出：[11, 12, 22, 25, 34, 64, 90]

查找算法

查找算法是一种在数据结构中查找特定元素的方法。常见的查找算法包括线性查找和二分查找。

def linear_search(arr, target):
    for i, value in enumerate(arr):
        if value == target:
            return i
    return -1

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

arr = [1, 3, 5, 7, 9]
print(linear_search(arr, 7))  # 输出：3
print(binary_search(arr, 7))  # 输出：3

图算法

图算法是一种在图结构中执行操作的方法，常见的图算法包括广度优先搜索（BFS）和深度优先搜索（DFS）。

def bfs(graph, start):
    visited = []
    queue = [start]

    while queue:
        vertex = queue.pop(0)
        if vertex not in visited:
            visited.append(vertex)
            queue.extend(graph[vertex] - set(visited))
    return visited

def dfs(graph, start):
    visited = []
    stack = [start]

    while stack:
        vertex = stack.pop()
        if vertex not in visited:
            visited.append(vertex)
            stack.extend(graph[vertex] - set(visited))
    return visited

graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}

print(bfs(graph, 'A'))  # 输出：['A', 'B', 'C', 'D', 'E', 'F']
print(dfs(graph, 'A'))  # 输出：['A', 'C', 'F', 'E', 'B', 'D']

复杂的项目实例

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = quick_sort(arr)
print(sorted_arr)  # 输出：[11, 12, 22, 25, 34, 64, 90]

数据库操作

Python提供了多种数据库操作库，如SQLite、MySQL、PostgreSQL等。下面以SQLite为例，介绍如何进行数据库操作。

安装 SQLite

首先，确保安装了 sqlite3 库。通常情况下，Python标准库中已经包含 sqlite3，不需要额外安装。

import sqlite3

创建数据库

使用 sqlite3.connect 方法连接到数据库，如果数据库不存在，则会自动创建。

conn = sqlite3.connect('example.db')

创建表

使用 execute 方法执行SQL语句，创建数据库表。

cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER
)
''')
conn.commit()

插入数据

使用 execute 方法执行SQL语句，插入数据到表中。

cursor.execute('INSERT INTO users (name, age) VALUES (?, ?)', ('Alice', 25))
conn.commit()

查询数据

使用 execute 方法执行SQL语句，查询数据。

cursor.execute('SELECT * FROM users')
rows = cursor.fetchall()
for row in rows:
    print(row)

更新数据

使用 execute 方法执行SQL语句，更新表中的数据。

cursor.execute('UPDATE users SET age = 26 WHERE name = ?', ('Alice',))
conn.commit()

删除数据

使用 execute 方法执行SQL语句，删除表中的数据。

cursor.execute('DELETE FROM users WHERE name = ?', ('Alice',))
conn.commit()

关闭连接

完成数据库操作后，记得关闭连接。

conn.close()

复杂的项目实例

import sqlite3

def create_database():
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        age INTEGER
    )
    ''')
    conn.commit()
    conn.close()

def insert_data(name, age):
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('INSERT INTO users (name, age) VALUES (?, ?)', (name, age))
    conn.commit()
    conn.close()

def fetch_data():
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users')
    rows = cursor.fetchall()
    for row in rows:
        print(row)
    conn.close()

create_database()
insert_data('Alice', 25)
fetch_data()

网络编程

Python提供了多种网络编程库，如socket、requests等。下面介绍如何使用socket库进行TCP客户端和服务器编程。

TCP客户端

服务器端代码示例：

import socket

def start_server(host, port):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((host, port))
    server_socket.listen(1)
    print(f"Server listening on {host}:{port}")
    client_socket, client_address = server_socket.accept()
    print(f"Connection from {client_address}")
    while True:
        data = client_socket.recv(1024)
        if not data:
            break
        print(f"Received: {data.decode()}")
        client_socket.send(data)
    client_socket.close()
    server_socket.close()

start_server("localhost", 12345)

客户端代码示例：

import socket

def start_client(host, port):
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect((host, port))
    print(f"Connected to {host}:{port}")
    while True:
        message = input("Enter message: ")
        client_socket.send(message.encode())
        data = client_socket.recv(1024)
        print(f"Received: {data.decode()}")
    client_socket.close()

start_client("localhost", 12345)

复杂的项目实例

import socket

def start_server(host, port):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((host, port))
    server_socket.listen(1)
    print(f"Server listening on {host}:{port}")
    client_socket, client_address = server_socket.accept()
    print(f"Connection from {client_address}")
    while True:
        data = client_socket.recv(1024)
        if not data:
            break
        print(f"Received: {data.decode()}")
        client_socket.send(data)
    client_socket.close()
    server_socket.close()

def start_client(host, port):
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect((host, port))
    print(f"Connected to {host}:{port}")
    while True:
        message = input("Enter message: ")
        client_socket.send(message.encode())
        data = client_socket.recv(1024)
        print(f"Received: {data.decode()}")
    client_socket.close()

if __name__ == "__main__":
    import threading
    server_thread = threading.Thread(target=start_server, args=("localhost", 12345))
    server_thread.start()
    start_client("localhost", 12345)

异步编程

Python提供了多种异步编程库，如asyncio、aiohttp等。下面介绍如何使用asyncio进行异步操作。

使用 asyncio

asyncio 是Python的标准库，用于编写异步程序。下面是一个简单的异步任务示例：

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"Executed in {elapsed:0.2f} seconds")

使用 aiohttp

aiohttp 是一个基于asyncio的异步HTTP客户端，下面是一个简单的HTTP GET请求示例：

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'http://example.com')
        print(html)

if __name__ == "__main__":
    asyncio.run(main())

复杂的项目实例

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main(url):
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, url)
        print(html)

async def multiple_fetch(urls):
    tasks = []
    async with aiohttp.ClientSession() as session:
        for url in urls:
            tasks.append(asyncio.create_task(fetch(session, url)))
        await asyncio.gather(*tasks)

if __name__ == "__main__":
    urls = [
        'http://example.com',
        'http://example.org',
        'http://example.net'
    ]
    asyncio.run(multiple_fetch(urls))

单元测试

单元测试是一种验证代码单元（函数或方法）是否按照预期工作的技术。Python提供了unittest模块，用于编写和运行单元测试。

使用 unittest

下面是一个简单的单元测试示例：

import unittest

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

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

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

使用 pytest

pytest 是一个第三方的单元测试框架，使用起来更简单。下面是一个简单的pytest示例：

def test_add():
    assert add(1, 2) == 3
    assert add(-1, -1) == -2

def test_subtract():
    assert subtract(1, 2) == -1

复杂的项目实例

import unittest

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

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "Cannot divide by zero"

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

    def test_subtract(self):
        self.assertEqual(subtract(1, 2), -1)
        self.assertEqual(subtract(-1, -1), 0)

    def test_multiply(self):
        self.assertEqual(multiply(1, 2), 2)
        self.assertEqual(multiply(-1, -2), 2)

    def test_divide(self):
        self.assertEqual(divide(1, 2), 0.5)
        self.assertEqual(divide(-1, 2), -0.5)
        self.assertEqual(divide(10, 0), "Cannot divide by zero")

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

总结

本指南涵盖了Python编程的基础知识，从安装配置、数据类型和控制结构，到模块、面向对象编程、高级特性、数据结构与算法、数据库操作、网络编程和异步编程。通过学习这些内容，您可以掌握Python编程的基本技能，并为更深入的学习打下基础。希望本指南能帮助您快速入门Python编程，开启编程之旅。