1 初识Python

1.1 Python概述

Python是一种高级、解释型、通用的编程语言，由Guido van Rossum于20世纪90年代初创立。Python以其简洁易读的语法和强大的功能而闻名，使其成为新手和经验丰富的开发人员的首选语言之一。
Python的设计初衷是为了强调代码的可读性和简洁性。Guido van Rossum在1989年的圣诞节期间开始编写Python，目的是为了创建一种既能处理系统管理任务又能进行大规模应用开发的语言。1991年，Python 0.9.0版本发布，自此Python逐步发展成为一门功能强大且灵活的编程语言。

TIOBE排行榜是一个反映编程语言热度的指标，通过统计互联网上有经验的程序员、课程和第三方厂商的数量，以及使用搜索引擎、Wikipedia等平台的数据，来评估各种编程语言的流行程度。Python TIOBE排名如下图所示。

1.2 Python应用

Python 是一种高级、通用、解释型的编程语言，凭借其简洁易读的语法、丰富的库和强大的生态系统，在众多领域都有广泛的应用。

1.2.1 数据科学

• 数据分析：Python 拥有丰富的数据分析库，如 Pandas、NumPy 等。Pandas 提供了高效的数据结构（如 DataFrame）和数据操作方法，可用于数据清洗、转换和分析；NumPy 提供了高性能的多维数组对象和计算工具，能方便地进行数值计算和统计分析。
• 数据可视化：Matplotlib、Seaborn 和 Plotly 等库可用于创建各种可视化图表，如折线图、柱状图、散点图、热力图等，帮助用户更直观地理解数据。
• 机器学习：Scikit - learn 是一个简单易用的机器学习库，提供了各种机器学习算法，如分类、回归、聚类等；TensorFlow 和 PyTorch 则是深度学习领域的主流框架，可用于构建和训练神经网络模型，应用于图像识别、自然语言处理等领域。

1.2.2 人工智能

• 自然语言处理（NLP）：Python 中有许多用于 NLP 的库，如 NLTK、SpaCy 和 Transformers。NLTK 提供了丰富的语料库和工具，可用于文本处理、词性标注、命名实体识别等；Transformers 库则提供了预训练的语言模型，如 BERT、GPT 等，可用于文本生成、情感分析、问答系统等任务。
• 计算机视觉：OpenCV 是一个强大的计算机视觉库，可用于图像和视频处理，如图像滤波、特征提取、目标检测等；结合深度学习框架，还可以实现更复杂的计算机视觉任务，如人脸识别、图像分割等。

1.2.3 Web 开发

• 后端开发：Python 有多个流行的 Web 框架，如 Django、Flask 和 FastAPI。Django 是一个功能强大的全栈 Web 框架，提供了内置的数据库管理、用户认证、表单处理等功能，适合开发大型的 Web 应用；Flask 是一个轻量级的 Web 框架，灵活性高，易于上手，适合快速开发小型 Web 应用；FastAPI 则是一个基于 Python 的高性能 Web 框架，利用 Python 的类型提示功能，提供快速的开发体验和高效的性能。
• 爬虫开发：Python 的 Requests 库可用于发送 HTTP 请求，获取网页内容；BeautifulSoup 和 Scrapy 则是常用的网页解析和爬虫框架，可用于提取网页中的数据。

1.2.4 自动化运维

• 系统管理：Python 可以用于编写脚本，实现系统的自动化管理任务，如文件操作、进程管理、系统监控等。通过 Paramiko 库，还可以实现远程服务器的自动化操作。
• 配置管理：Ansible、SaltStack 等自动化配置管理工具使用 Python 编写，可用于自动化服务器的配置部署和管理，提高运维效率。

1.2.5.游戏开发

• 简单游戏开发：Pygame 是一个专门用于开发 2D 游戏的 Python 库，提供了图形、声音、输入等功能，可用于快速开发简单的游戏，如街机游戏、益智游戏等。
• 游戏脚本开发：在一些大型游戏开发中，Python 也可以作为脚本语言，用于实现游戏中的逻辑控制、AI 行为等。

1.2.6.金融领域

• 量化交易：Python 可用于开发量化交易策略，通过获取金融市场数据，进行数据分析和模型构建，实现自动化交易。常见的金融数据接口库有 Pandas - Datareader、Tushare 等，可用于获取股票、期货等市场数据。
• 风险评估：利用 Python 进行金融数据建模和分析，评估投资风险，如计算风险价值（VaR）、信用风险评估等。

1.3 Python开发环境

Python 有多个版本，目前较常用的是 Python 3.x。你可以从 Python官网下载适合你操作系统的安装包。

• Windows 系统
  下载安装包后，运行安装程序。在安装过程中，勾选 “Add Python to PATH” 选项，这样可以将 Python 添加到系统环境变量中，方便在命令行中直接使用。
  按照安装向导的提示完成安装。安装完成后，打开命令提示符（CMD），输入 python –version 命令，如果能正确显示 Python 版本号，说明安装成功。
• macOS 系统
  macOS 系统通常自带 Python 2.x，但我们建议安装 Python 3.x。可以通过 Homebrew 包管理器进行安装，打开终端，输入以下命令：

brew install python3

安装完成后，在终端输入 python3 –version 命令，验证安装是否成功。

• Linux 系统
  不同的 Linux 发行版安装 Python 3 的方式略有不同。以 Ubuntu 为例，打开终端，输入以下命令进行安装：

sudo apt update
sudo apt install python3

安装完成后，输入 python3 –version 验证安装结果。

1.4 Python开发工具

除了Python自带的IDLE以外，还有很多能够进行Python编程的开发工具。下面对常用的第三方开发工具进行简要介绍。

• PyCharm：由 JetBrains 公司开发，有专业版和社区版。专业版功能丰富，适合企业级开发；社区版免费，适合个人开发者和初学者。它的智能代码提示、代码分析和调试功能都非常强大。
• Visual Studio Code（VS Code）：微软开发的开源代码编辑器，通过安装 Python 扩展可以变成一个强大的 Python IDE。它具有轻量级、跨平台、丰富的扩展生态系统等特点，深受开发者喜爱。

2 Python语言基础

Python 是一种计算机编程语言。计算机编程语言和我们日常使用的自然语言有所不同，最大的区别就是，自然语言在不同的语境下有不同的理解，而计算机要根据编程语言执行任务，就必须保证编程语言写出的程序决不能有歧义，所以，任何一种编程语言都有自己的一套语法，编译器或者解释器就是负责把符合语法的程序代码转换成CPU能够执行的机器码，然后执行。

2.1 数据类型和变量

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。

2.1.1 变量

变量是存储数据的容器，通过变量名可以引用存储在其中的数据。
变量的命名规则：

• 只能包含字母、数字和下划线：变量名可以以字母或下划线开头，但不能以数字开头。例如，my_variable 是合法的，而 123variable 是不合法的。
• 区分大小写：myVariable 和 myvariable 是两个不同的变量。
• 不能使用 Python 的关键字：如 if、else、for 等。

#定义一个整数类型的变量
age = 25
#定义一个字符串类型的变量
name = "Alice"

2.1.2 基本数据类型

整数（int）：表示整数，可正可负，没有小数部分。例如：

num1 = 10
num2 = -20

浮点数（float）：表示带有小数部分的数字。例如：

height = 1.75
weight = 65.2

布尔值（bool）：只有两个值，True 和 False，常用于条件判断。例如：

is\_student = True
has\_license = False

字符串（str）：表示文本数据，用单引号 ’ 或双引号 " 括起来。例如：

message = 'Hello, World!'
greeting = "Welcome to Python"

2.1.3 复合数据类型

列表（list）：是一种有序的、可变的数据集合，可以包含不同类型的元素。用方括号 [] 表示，元素之间用逗号分隔。例如：

fruits = \['apple', 'banana', 'cherry'\]
numbers = \[1, 2, 3, 4, 5\]
mixed\_list = \[1, 'hello', True\]

元组（tuple）：是一种有序的、不可变的数据集合，用圆括号 () 表示。一旦创建，元组的元素不能被修改。例如：

point = (3, 5)
colors = ('red', 'green', 'blue')

集合（set）：是一种无序的、唯一的数据集合，用花括号 {} 表示，或者使用 set() 函数创建。集合中的元素不能重复。例如：

numbers\_set = {1, 2, 3, 4, 5}
unique\_fruits = set(\['apple', 'banana', 'apple'\])  # 集合会自动去重

字典（dict）：是一种无序的键值对集合，用花括号 {} 表示，键和值之间用冒号 : 分隔，键必须是唯一的。(dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。) 例如：

person = {'name': 'Alice', 'age': 25, 'city': 'New York'}

2.1.4 数据类型的转换

在 Python 中，可以使用一些内置函数进行数据类型的转换。例如：

\# 将整数转换为字符串
num = 10
str\_num = str(num)
print(type(str\_num))  # 输出: # 将字符串转换为整数
str\_num = "20"
num = int(str\_num)
print(type(num))  # 输出: 

2.2 流程控制语句

2.2.1 条件语句（分支结构）

• if-elif-else：实现多条件判断，elif可简化多重分支逻辑。

score = 85
if score >= 90:
    print("优秀")
elif score >= 70:
    print("良好")
else:
    print("待提高")

• 嵌套条件：允许在条件块内嵌套其他条件语句，处理复杂逻辑。

x = 10
if x > 0:
    if x % 2 == 0:
        print("正偶数")

• 三元运算符
  简化单行条件判断，语法：值1 if 条件 else 值2。

age = 18
status = "成年" if age >= 18 else "未成年"

2.2.2 循环语句

2.2.2.1 while循环

基本语法：重复执行直到条件为假。

total = 0
i = 1
while i <= 100:
    total += i
    i += 1

2.2.2.2 for循环

• 遍历序列：处理列表、字符串等可迭代对象。

fruits = \["apple", "banana", "cherry"\]
for fruit in fruits:
    print(fruit)
复制

• 结合range()：生成数字序列，常用于固定次数循环。

for i in range(5):  # 输出0-4
    print(i)

2.2.3 跳转控制语句

• break与continue

break：立即终止当前循环，常用于满足条件时退出。
continue：跳过当前迭代，进入下一次循环。

for num in \[1, 2, 3, 4, 5\]:
    if num == 3:
        break  # 终止循环
    print(num)  # 输出1,2

• pass语句
  空操作占位符，保持代码结构完整性9。

if x > 0:
    pass  # 待后续补充逻辑

3 函数

3.1 函数定义与调用

3.1.1基本语法

• 使用def关键字定义函数，语法为：

def 函数名(参数列表):
    函数体 
    \[return 返回值\]

#示例：计算两数之和7
def add(a, b):
    return a + b 
result = add(3, 5)  # 输出8 

3.1.2 参数类型

• 必选参数：调用时必须传入，如add(3,5)
• 默认参数：简化调用，如def power(x, n=2): return x**n
• 可变参数：*args接收任意数量参数，自动组装为元组

def avg(\*nums):
    return sum(nums)/len(nums) if nums else 0 
avg(1, 2, 3)  # 输出2.0

• 关键字参数：**kwargs接收键值对，组装为字典34

3.2 函数返回值与作用域

3.2.1 返回值特性

• 可返回多个值（实质为元组），如：

def get\_coordinates():
    return 40.7128, -74.0060 
lat, lon = get\_coordinates()

• 无return语句时默认返回None

3.2.2 作用域规则

• 局部变量：函数内定义的变量仅内部可见
• 全局变量：函数外定义，需用global声明修改6

count = 0 
def increment():
    global count 
    count += 1 

3.3 高级函数特性

3.3.1 嵌套函数与闭包

• 函数内部可定义其他函数，形成闭包（保留外部变量状态）：

def multiplier(factor):
    def multiply(number):
        return number \* factor  # factor为外层自由变量 
    return multiply 
double = multiplier(2)
print(double(5))  # 输出10 

• 闭包常用于实现装饰器6

3.3.2 递归函数

• 函数调用自身，需设置终止条件：

def factorial(n):
    return 1 if n <= 1 else n \* factorial(n-1)
print(factorial(5))  # 输出120 
#注意栈溢出风险，复杂递归建议改用迭代

3.4 典型应用场景

3.4.1 数据处理

• 批量转换数据格式

def clean\_data(dirty\_list):
    return \[x.strip() for x in dirty\_list if x\]

• 实现算法逻辑（如斐波那契数列）

def fibonacci\_recursive(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci\_recursive(n - 1) + fibonacci\_recursive(n - 2)

# 测试递归实现
n = 10
print(f"递归实现：斐波那契数列的第 {n} 项是 {fibonacci\_recursive(n)}")

3.4.2 模块化开发

• 将功能拆分为独立函数，提升可维护性
• 跨文件调用：通过import导入模块函数

3.4.3 回调机制

• 函数作为参数传递，实现灵活控制：

def process\_data(data, callback):
    processed = \[x\*2 for x in data\]
    return callback(processed)

4 面向对象

面向对象编程（OOP）是一种编程范式，它使用 “对象” 来组织代码。对象是类的实例，类是对象的蓝图，它定义了对象的属性和方法。下面从几个方面详细介绍 Python 中的面向对象设计，并给出示例代码。

4.1 类和对象的基本定义

类是创建对象的模板，而对象是类的具体实例。以下是一个简单的类和对象的示例：

class Person:
    # 类属性
    species = "Homo sapiens"

    def \_\_init\_\_(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    def introduce(self):
        # 实例方法
        print(f"我叫 {self.name}，今年 {self.age} 岁。")
   
     # 创建对象
    person1 = Person("Alice", 25)
    person1.introduce()        

在上述代码中：

• Person 是一个类，它有一个类属性 species 和两个实例属性 name 和 age。
  

• \_\_init\_\_  是一个特殊的方法，称为构造函数，用于初始化对象的属性。
  

• introduce 是一个实例方法，用于打印对象的信息。
  

4.2 继承

继承允许一个类（子类）继承另一个类（父类）的属性和方法。以下是一个继承的示例：

class Student(Person):
    def \_\_init\_\_(self, name, age, student\_id):
        # 调用父类的构造函数
        super().\_\_init\_\_(name, age)
        self.student\_id = student\_id

    def study(self):
        print(f"{self.name}（学号：{self.student\_id}）正在学习。")

# 创建 Student 对象
student1 = Student("Bob", 20, "12345")
student1.introduce()
student1.study()

在上述代码中：

• Student 类继承自 Person 类，它可以使用 Person 类的属性和方法。
• super().init(name, age) 调用了父类的构造函数，用于初始化从父类继承的属性。
• study 是 Student 类自己的方法。

4.3 多态

多态是指不同类的对象可以对同一消息做出不同的响应。以下是一个多态的示例：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪！")

class Cat(Animal):
    def speak(self):
        print("喵喵喵！")

def make\_animal\_speak(animal):
    animal.speak()

# 创建不同的动物对象
dog = Dog()
cat = Cat()

# 调用多态函数
make\_animal\_speak(dog)
make\_animal\_speak(cat)

在上述代码中：

• Animal 是一个抽象基类，它定义了一个抽象方法 speak。
• Dog 和 Cat 类继承自 Animal 类，并实现了 speak 方法。
• make_animal_speak 函数接受一个 Animal 类型的对象，并调用其 speak 方法，不同的对象会有不同的响应。

4.4 封装

封装是指将数据和操作数据的方法绑定在一起，并隐藏对象的内部实现细节。以下是一个封装的示例：

class BankAccount:
    def \_\_init\_\_(self, account\_number, balance):
        # 私有属性
        self.\_\_account\_number = account\_number
        self.\_\_balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.\_\_balance += amount
            print(f"成功存入 {amount} 元，当前余额为 {self.\_\_balance} 元。")
        else:
            print("存款金额必须大于 0。")

    def withdraw(self, amount):
        if amount > 0 and amount <= self.\_\_balance:
            self.\_\_balance -= amount
            print(f"成功取出 {amount} 元，当前余额为 {self.\_\_balance} 元。")
        else:
            print("取款金额无效或余额不足。")

    def get\_balance(self):
        return self.\_\_balance

# 创建银行账户对象
account = BankAccount("123456789", 1000)
account.deposit(500)
account.withdraw(200)
print(f"当前余额：{account.get\_balance()} 元")

在上述代码中：

• __account_number 和 __balance 是私有属性，外部无法直接访问。
• deposit 和 withdraw 方法用于对账户余额进行操作，封装了具体的业务逻辑。
• get_balance 方法用于获取账户余额，提供了对私有属性的访问接口。

5 模块

在 Python 里，模块是一个包含 Python 定义和语句的文件，其文件名以 .py 结尾。模块能够让你把相关的代码组织在一起，实现代码的复用与管理，下面从模块的创建、导入、内置模块以及包的概念等方面详细介绍。

5.1 创建模块

创建模块非常简单，只需把相关的代码写在一个 .py 文件中即可。以下是一个名为 math_operations.py 的模块示例，其中包含了一些数学运算的函数：

\# math\_operations.py
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:
        raise ValueError("除数不能为零")
    return a / b

5.2. 导入模块

在 Python 中，有多种方式可以导入模块。

5.2.1 import 语句

使用 import 语句可以导入整个模块，之后通过模块名来访问其中的函数或变量。

import math\_operations

result\_add = math\_operations.add(3, 5)
print(result\_add)

result\_multiply = math\_operations.multiply(4, 6)
print(result\_multiply)

5.2.2 from…import 语句

使用 from…import 语句可以从模块中导入特定的函数或变量，这样在使用时就无需再加上模块名。

from math\_operations import add, multiply

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

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

5.2.3 from…import * 语句

使用 from…import * 语句可以导入模块中的所有函数和变量，但这种方式不建议大量使用，因为可能会导致命名冲突。

from math\_operations import \*

result\_subtract = subtract(8, 3)
print(result\_subtract)

result\_divide = divide(10, 2)
print(result\_divide)

5.2.4 为模块或导入的对象指定别名

使用 as 关键字可以为模块或导入的对象指定别名，方便在代码中使用。

import math\_operations as mo

result = mo.add(2, 7)
print(result)

from math\_operations import add as addition
result = addition(4, 9)
print(result)

5.3. 内置模块

Python 自带了许多内置模块，这些模块提供了丰富的功能，例如 math 模块用于数学运算，random 模块用于生成随机数等。

import math
import random

# 使用 math 模块
sqrt\_result = math.sqrt(25)
print(sqrt\_result)

# 使用 random 模块
random\_num = random.randint(1, 10)
print(random\_num)
4. \_\_name\_\_ 属性
在 Python 模块中，\_\_name\_\_ 是一个特殊的内置变量。当模块作为脚本直接运行时，\_\_name\_\_ 的值为 '\_\_main\_\_'；当模块被导入时，\_\_name\_\_ 的值为模块名。可以利用这个特性来编写测试代码。
python
# math\_operations.py
def add(a, b):
    return a + b

if \_\_name\_\_ == '\_\_main\_\_':
    result = add(2, 3)
    print(f"测试加法：{result}")

在上述代码中，if name == ‘main’: 块中的代码只有在该模块作为脚本直接运行时才会执行，当该模块被其他模块导入时，这部分代码不会执行。

5.5 包

包是一种管理 Python 模块命名空间的方式，它是一个包含多个模块的目录，并且该目录下必须有一个 init.py 文件（在 Python 3.3 及以后的版本中，init.py 文件不是必需的，但为了兼容性，通常还是会保留）。
假设我们有一个名为 my_package 的包，其目录结构如下：

plaintext
my\_package/
    \_\_init\_\_.py
    module1.py
    module2.py

module1.py 和 module2.py 是包中的模块，我们可以这样导入和使用它们：

from my\_package import module1, module2

result1 = module1.some\_function()
result2 = module2.another\_function()

参考文献

[ 1 ] 《python学习手册》 第5版