Python知识超级汇总

Python知识超级汇总

一、引言

Python 是一种高级、解释型、通用的编程语言，以其简洁、易读、易维护的代码风格和强大的功能而受到广泛欢迎。它拥有丰富的库和框架，可应用于多个领域，如 Web 开发、数据科学、人工智能、自动化脚本、游戏开发等。本汇总将全面介绍 Python 的基础知识、高级特性以及常用的库和框架，帮助读者全面掌握 Python 编程。

二、Python 基础

（一）安装与环境配置

1. 下载安装包：从 Python 官方网站https://www.python.org/downloads/下载适合自己操作系统的 Python 安装包。
2. 安装过程：运行安装包，按照提示进行安装。在安装过程中，建议勾选“Add Python to PATH”选项，以便在命令行中直接使用 Python 命令。
3. 环境变量检查：安装完成后，打开命令行，输入“python --version”，如果显示 Python 的版本号，则说明安装成功。

（二）基本语法

1. 注释
   • 单行注释：使用“#”符号，例如：

   # 这是一个单行注释
   

   • 多行注释：使用三个单引号（‘’'）或三个双引号（“”"），例如：

   '''
   这是一个
   多行注释
   '''
   """
   这也是一个
   多行注释
   """
   

2. 变量与数据类型
   • 变量命名规则：变量名由字母、数字和下划线组成，不能以数字开头，且区分大小写。例如：my_variable = 10。
   • 常见数据类型：
     • 整数（int）：表示整数，如10、-5。
     • 浮点数（float）：表示小数，如3.14、-2.5。
     • 字符串（str）：用单引号或双引号括起来的文本，如'Hello, World!'、"Python is great"。
     • 布尔值（bool）：只有两个值True和False。
     • 空值（None）：表示空对象。
3. 运算符
   • 算术运算符：+（加）、-（减）、*（乘）、/（除）、%（取模）、**（幂运算）、//（整除）。例如：

   result = 5 + 3  # 加法，结果为8
   result = 10 / 3  # 除法，结果为3.3333333333333335
   result = 10 % 3  # 取模，结果为1
   result = 2 ** 3  # 幂运算，结果为8
   result = 10 // 3  # 整除，结果为3
   

   • 比较运算符：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。例如：

   is_equal = 5 == 3  # 比较是否相等，结果为False
   is_greater = 5 > 3  # 比较大小，结果为True
   

   • 逻辑运算符：and（与）、or（或）、not（非）。例如：

   result = (5 > 3) and (2 < 4)  # 逻辑与，结果为True
   result = (5 > 3) or (2 > 4)  # 逻辑或，结果为True
   result = not (5 > 3)  # 逻辑非，结果为False
   

   • 赋值运算符：=（赋值）、+=（加等于）、-=（减等于）、*=（乘等于）、/=（除等于）、%=（取模等于）、**=（幂等于）、//=（整除等于）。例如：

   num = 5
   num += 3  # 相当于num = num + 3，结果num为8
   

（三）流程控制

1. 条件语句（if - elif - else）

age = 18
if age < 18:
    print("未成年人")
elif age == 18:
    print("刚成年")
else:
    print("成年人")

2. 循环语句
   • for 循环：用于遍历可迭代对象（如列表、字符串、元组等）。

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

• while 循环：只要条件为真，就会一直循环执行。

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

3. 循环控制语句
   • break：用于立即终止循环。

for i in range(10):
    if i == 5:
        break
    print(i)

• continue：用于跳过当前循环的剩余部分，继续下一次循环。

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

（四）数据结构

1. 列表（list）
   • 是一种有序的可变序列，可以包含不同类型的元素。
   • 创建列表：

my_list = [1, 2, 3, 'apple', 3.14]

• 访问列表元素：通过索引访问，索引从 0 开始。

my_list = [1, 2, 3, 'apple', 3.14]
print(my_list[0])  # 输出1
print(my_list[3])  # 输出'apple'

• 修改列表元素：

my_list = [1, 2, 3, 'apple', 3.14]
my_list[0] = 10
print(my_list)  # 输出[10, 2, 3, 'apple', 3.14]

• 列表常用方法：
  • append()：在列表末尾添加一个元素。

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出[1, 2, 3, 4]

 - `extend()`：将一个可迭代对象的元素添加到列表中。

my_list = [1, 2, 3]
new_list = [4, 5]
my_list.extend(new_list)
print(my_list)  # 输出[1, 2, 3, 4, 5]

 - `insert()`：在指定位置插入一个元素。

my_list = [1, 2, 3]
my_list.insert(1, 1.5)
print(my_list)  # 输出[1, 1.5, 2, 3]

 - `remove()`：移除列表中第一个匹配的元素。

my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # 输出[1, 3, 2]

 - `pop()`：移除并返回指定位置的元素，默认移除最后一个元素。

my_list = [1, 2, 3]
element = my_list.pop(1)
print(element)  # 输出2
print(my_list)  # 输出[1, 3]

2. 元组（tuple）
   • 是一种有序的不可变序列，通常用于存储一组相关的数据。
   • 创建元组：

my_tuple = (1, 2, 3, 'apple')
# 也可以省略括号
my_tuple = 1, 2, 3, 'apple'

• 访问元组元素：与列表类似，通过索引访问。

my_tuple = (1, 2, 3, 'apple')
print(my_tuple[0])  # 输出1
print(my_tuple[3])  # 输出'apple'

3. 集合（set）
   • 是一种无序的、不重复的数据集合，常用于去重和集合运算。
   • 创建集合：

my_set = {1, 2, 3, 3}  # 自动去重，实际集合为{1, 2, 3}
# 也可以使用set()函数创建
my_set = set([1, 2, 3, 3])

• 集合常用方法：
  • add()：添加一个元素。

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出{1, 2, 3, 4}

 - `remove()`：移除一个元素，如果元素不存在会报错。

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set)  # 输出{1, 3}

 - `discard()`：移除一个元素，如果元素不存在不会报错。

my_set = {1, 2, 3}
my_set.discard(4)
print(my_set)  # 输出{1, 2, 3}

 - `union()`：返回两个集合的并集。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
result = set1.union(set2)
print(result)  # 输出{1, 2, 3, 4, 5}

 - `intersection()`：返回两个集合的交集。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
result = set1.intersection(set2)
print(result)  # 输出{3}

4. 字典（dict）
   • 是一种无序的键值对集合，用于存储和查找数据。
   • 创建字典：

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

• 访问字典元素：通过键访问。

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
print(my_dict['name'])  # 输出'John'

• 修改字典元素：

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
my_dict['age'] = 26
print(my_dict)  # 输出{'name': 'John', 'age': 26, 'city': 'New York'}

• 字典常用方法：
  • keys()：返回字典的所有键。

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
keys = my_dict.keys()
print(keys)  # 输出dict_keys(['name', 'age', 'city'])

 - `values()`：返回字典的所有值。

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
values = my_dict.values()
print(values)  # 输出dict_values(['John', 25, 'New York'])

 - `items()`：返回字典的所有键值对。

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
items = my_dict.items()
print(items)  # 输出dict_items([('name', 'John'), ('age', 25), ('city', 'New York')])

 - `get()`：通过键获取值，如果键不存在返回默认值（默认为 None）。

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
value = my_dict.get('name')
print(value)  # 输出'John'
value = my_dict.get('gender', 'Unknown')
print(value)  # 输出'Unknown'

三、Python 高级特性

（一）函数

1. 定义函数

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

2. 函数参数
   • 位置参数：按顺序传递的参数。

def greet(name, message):
    print(f"{name}, {message}")


greet('John', 'Hello!')

• 默认参数：在定义函数时为参数设置默认值。

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


greet('John')
greet('John', 'How are you?')

• 可变参数（*args）：用于接收任意数量的位置参数，以元组形式传递。

def sum_numbers(*args):
    result = 0
    for num in args:
        result += num
    return result


print(sum_numbers(1, 2, 3))
print(sum_numbers(1, 2, 3, 4, 5))

• **关键字参数（kwargs）：用于接收任意数量的关键字参数，以字典形式传递。

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")


print_info(name='John', age=25, city='New York')

3. 匿名函数（lambda 函数）
   • 是一种没有名字的小函数，通常用于简单的表达式。

add = lambda a, b: a + b
print(add(3, 5))

（二）迭代器与生成器

1. 迭代器
   • 是一个可以被迭代（遍历）的对象，实现了__iter__()和__next__()方法。
   • 创建迭代器：

my_list = [1, 2, 3]
my_iterator = iter(my_list)
print(next(my_iterator))  # 输出1
print(next(my_iterator))  # 输出2
print(next(my_iterator))  # 输出3
# 当没有更多元素时，会抛出StopIteration异常
# print(next(my_iterator))

2. 生成器
   • 是一种特殊的迭代器，使用yield关键字来生成值，而不是使用return。
   • 生成器函数：

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b


fib = fibonacci()
print(next(fib))  # 输出0
print(next(fib))  # 输出1
print(next(fib))  # 输出1
print(next(fib))  # 输出2

• 生成器表达式：

squares = (i ** 2 for i in range(10))
print(next(squares))  # 输出0
print(next(squares))  # 输出1
print(next(squares))  # 输出4

（三）装饰器

1. 定义装饰器
   • 是一种特殊的函数，用于修改其他函数的行为，而不修改函数的源代码。

def my_decorator(func):
    def wrapper():
        print("Before function execution")
        func()
        print("After function execution")
    return wrapper

2. 使用装饰器

@my_decorator
def say_hello():
    print("Hello!")


say_hello()

（四）面向对象编程（OOP）

1. 类的定义

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

    def bark(self):
        print(f"{self.name} is barking!")

2. 对象的创建

my_dog = Dog('Buddy', 3)
my_dog.bark()

3. 继承

class GoldenRetriever(Dog):
    def __init__(self, name, age, color):
        super().__init__(name, age)
        self.color = color

    def fetch(self):
        print(f"{self.name} is fetching!")


my_golden = GoldenRetriever('Charlie', 2, 'Golden')
my_golden.bark()
my_golden.fetch()

4. 多态

class Animal:
    def speak(self):
        pass


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


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


def make_animal_speak(animal):
    animal.speak()


dog = Dog()
cat = Cat()

make_animal_speak(dog)  
make_animal_speak(cat)  

在这里，make_animal_speak函数接受一个Animal类型的对象，但是由于Dog和Cat类都继承自Animal并且重写了speak方法，所以根据传入对象的不同，speak方法会表现出不同的行为，这就是多态性的体现。

5. 封装
   • 封装是将数据和操作数据的方法绑定在一起，对外部隐藏内部实现细节。在Python中，通过约定来模拟私有属性和方法。

class BankAccount:
    def __init__(self, balance=0):
        self._balance = balance  

    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            print(f"Deposited {amount}. New balance: {self._balance}")
        else:
            print("Invalid deposit amount.")

    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            print(f"Withdrew {amount}. New balance: {self._balance}")
        else:
            print("Insufficient funds or invalid withdrawal amount.")


account = BankAccount(1000)
account.deposit(500)
account.withdraw(300)
# 虽然可以通过account._balance直接访问，但不建议这样做，破坏了封装性

在这个例子中，_balance前面的下划线表示它是一个“私有”属性，理论上不应该从类的外部直接访问，而应该通过类提供的deposit和withdraw方法来操作它。

6. 魔法方法
   • 魔法方法是Python中特殊的方法，它们的名字以双下划线开头和结尾，如__init__、__str__等。
   • __str__方法用于定义对象的字符串表示形式，当使用print函数输出对象时会调用这个方法。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Point({self.x}, {self.y})"


point = Point(3, 4)
print(point)  

• __len__方法用于定义对象的长度，当使用len函数时会调用这个方法。

class MyList:
    def __init__(self):
        self.data = []

    def append(self, item):
        self.data.append(item)

    def __len__(self):
        return len(self.data)


my_list = MyList()
my_list.append(1)
my_list.append(2)
print(len(my_list))  

（五）异常处理

1. 捕获异常
   • 使用try - except语句来捕获和处理异常。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Division by zero is not allowed.")

2. 捕获多个异常

try:
    my_list = [1, 2, 3]
    print(my_list[5])
    result = 10 / 0
except IndexError:
    print("Index out of range.")
except ZeroDivisionError:
    print("Division by zero is not allowed.")

3. else和finally子句
   • else子句在try块中没有发生异常时执行。
   • finally子句无论是否发生异常都会执行。

try:
    num = int("10")
except ValueError:
    print("Invalid number conversion.")
else:
    print(f"Converted number: {num}")
finally:
    print("This will always be printed.")

（六）模块与包

1. 模块
   • 模块是一个包含Python定义和语句的文件，扩展名为.py。通过导入模块，可以使用其中定义的函数、类和变量。
   • 创建一个my_module.py文件：

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


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

• 在另一个文件中导入并使用这个模块：

import my_module

result = my_module.add(3, 5)
print(result)  

result = my_module.multiply(4, 6)
print(result)  

• 也可以使用from...import语句导入模块中的特定内容：

from my_module import add, multiply

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

result = multiply(4, 6)
print(result)  

2. 包
   • 包是一个包含多个模块的目录，目录下必须有一个__init__.py文件（在Python 3.3+中，这个文件可以为空，但它仍然用于标识该目录是一个包）。
   • 假设目录结构如下：

my_package/
    __init__.py
    module1.py
    module2.py

• 在module1.py中定义一些内容：

# module1.py
def greet():
    print("Hello from module1!")

• 在module2.py中定义一些内容：

# module2.py
def farewell():
    print("Goodbye from module2!")

• 在其他文件中导入包中的模块：

import my_package.module1
import my_package.module2

my_package.module1.greet()
my_package.module2.farewell()

• 也可以使用from...import语句：

from my_package.module1 import greet
from my_package.module2 import farewell

greet()
farewell()

四、Python 常用库与框架

（一）NumPy

1. 数组创建
   • NumPy 是Python的核心科学计算支持库，提供了快速、灵活、明确的数组对象。

import numpy as np

# 创建一维数组
arr1d = np.array([1, 2, 3, 4, 5])
print(arr1d)

# 创建二维数组
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d)

# 创建全零数组
zeros_arr = np.zeros((3, 4))
print(zeros_arr)

# 创建全一数组
ones_arr = np.ones((2, 3))
print(ones_arr)

# 创建指定范围的数组
range_arr = np.arange(1, 10, 2)
print(range_arr)

2. 数组操作
   • 索引和切片：与Python列表类似，但更强大。

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(arr[3])  
print(arr[2:7])  
print(arr[::2])  

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2d[1, 2])  
print(arr2d[0:2, 1:])  

• 数学运算：对数组中的元素进行各种数学运算。

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

add_result = arr1 + arr2
print(add_result)  

multiply_result = arr1 * arr2
print(multiply_result)  

square_result = np.square(arr1)
print(square_result)  

sum_result = np.sum(arr1)
print(sum_result)  

（二）pandas

1. 数据读取与写入
   • pandas 是用于数据处理和分析的库，提供了快速、灵活、明确的数据结构。

import pandas as pd

# 读取CSV文件
data = pd.read_csv('data.csv')
print(data.head())

# 写入CSV文件
data.to_csv('new_data.csv', index=False)

2. 数据选择与过滤

import pandas as pd

data = pd.read_csv('data.csv')

# 选择列
column_data = data['column_name']
print(column_data)

# 选择行
row_data = data.iloc[0]
print(row_data)

# 过滤数据
filtered_data = data[data['age'] > 20]
print(filtered_data)

3. 数据清理与预处理
   • 处理缺失值：

import pandas as pd

data = pd.read_csv('data_with_missing.csv')

# 删除含有缺失值的行
cleaned_data = data.dropna()
print(cleaned_data)

# 使用指定值填充缺失值
data.fillna(0, inplace=True)
print(data)

• 处理重复值：

import pandas as pd

data = pd.read_csv('data_with_duplicates.csv')

# 删除重复行
unique_data = data.drop_duplicates()
print(unique_data)

（三）Matplotlib

1. 基本绘图
   • Matplotlib 是Python的绘图库，用于创建静态、动态和交互式可视化。

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Sine Wave')
plt.show()

2. 多子图绘制

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y1 = np.sin(x)
y2 = np.cos(x)

plt.subplot(2, 1, 1)
plt.plot(x, y1)
plt.title('Sine Wave')

plt.subplot(2, 1, 2)
plt.plot(x, y2)
plt.title('Cosine Wave')

plt.tight_layout()
plt.show()

（四）Flask

1. 基本应用创建
   • Flask 是一个轻量级的Web应用框架，用于快速开发Web应用。

from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello_world():
    return 'Hello, World!'


if __name__ == '__main__':
    app.run()

2. 路由与视图函数

from flask import Flask

app = Flask(__name__)


@app.route('/')
def index():
    return 'This is the index page.'


@app.route('/about')
def about():
    return 'This is the about page.'


if __name__ == '__main__':
    app.run()

（五）Django

1. 项目创建与基本配置
   • Django 是一个功能强大的Web应用框架，具有丰富的插件和工具。
   • 使用命令行创建Django项目：

django - admin startproject myproject

• 配置settings.py文件，如数据库配置、静态文件路径等。

2. 创建模型与数据库操作
   • 在models.py文件中定义模型类：

from django.db import models


class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    publication_date = models.DateField()

• 使用命令行迁移数据库：

python manage.py makemigrations
python manage.py migrate

3. 创建视图与URL配置
   • 在views.py文件中定义视图函数：

from django.http import HttpResponse
from.models import Book


def book_list(request):
    books = Book.objects.all()
    response = ""
    for book in books:
        response += f"{book.title} by {book.author} - {book.publication_date}
"
    return HttpResponse(response)

• 在urls.py文件中配置URL：

from django.contrib import admin
from django.urls import path
from. import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.book_list, name='book_list'),
]

五、总结

Python 作为一门功能强大且应用广泛的编程语言，其知识体系涵盖了从基础语法到高级特性，再到丰富的库和框架。通过掌握这些知识，开发者可以在多个领域进行高效的编程工作，如数据分析、Web 开发、人工智能等。希望本汇总能够帮助读者全面深入地理解和掌握 Python 编程，为实际项目开发打下坚实的基础。在学习过程中，建议读者多进行实践，通过实际项目来加深对知识的理解和运用。