首页手记 Python编程入门指南

Python编程入门指南

标签：

Java 架构 Spring Cloud

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的步骤：

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

Python环境配置

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

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

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

开发工具与IDE

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

下载并安装PyCharm，访问PyCharm官网：https://www.jetbrains.com/pycharm/download/
运行安装程序，按照提示完成安装。
打开PyCharm，选择“File” -> "Settings"。
在“Project：项目名称”下选择"Python Interpreter"，点击"..."。
在弹出的窗口中，点击"+"按钮，选择"Add Local"，然后选择之前安装好的Python解释器。
点击“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"] = "bob@example.com"

print(dictionary["name"])  # 输出：Bob
print(dictionary)  # 输出：{'name': 'Bob', 'age': 25, 'email': 'bob@example.com'}

集合（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"] = "bob@example.com"

print(dictionary["name"])  # 输出：Bob
print(dictionary)  # 输出：{'name': 'Bob', 'age': 25, 'email': 'bob@example.com'}

集合（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编程，开启编程之旅。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

哈士奇WWW

手记
篇

粉丝

71

获赞与收藏

400

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340953 3155

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Python编程入门指南

变量

数据类型

整型（int）

浮点型（float）

字符串（str）

布尔型（bool）

列表（list）

元组（tuple）

字典（dict）

集合（set）

条件语句

if 语句

elif 语句

else 语句

循环结构

for 循环

while 循环

定义函数

调用函数

可选参数与默认值

返回值

读取文件

写入文件

使用 with 语句

基本使用

多个异常处理

使用 else 和 finally

导入模块

导入特定对象

包的使用

列表（List）

元组（Tuple）

字典（Dictionary）

集合（Set）

类和对象

继承

封装

多态

一个完整的项目实例

生成器

装饰器

协程

复杂的项目实例

常见数据结构

列表（List）

元组（Tuple）

字典（Dictionary）

集合（Set）

常见算法

排序算法

查找算法

图算法

复杂的项目实例

安装 SQLite

创建数据库

创建表

插入数据

查询数据

更新数据

删除数据

关闭连接

复杂的项目实例

TCP客户端

复杂的项目实例

使用 asyncio

使用 aiohttp

复杂的项目实例

使用 unittest

使用 pytest

复杂的项目实例

阅读免费教程

使用 `with` 语句

使用 `else` 和 `finally`