Python 简介与入门

解释型语言：
无需编译，通过解释器逐行执行，支持交互式编程（如 Jupyter Notebook）。
动态类型：
变量类型在运行时自动推断，无需显式声明，提升编码速度。
```
name = "Alice"  # 自动识别为字符串  
age = 30        # 自动识别为整数  
```
面向对象 & 函数式编程：
支持多种编程范式，灵活应对不同场景需求。
自动内存管理：
垃圾回收机制自动释放未使用的内存，减少内存泄漏风险。
可扩展性：
可通过 C/C++ 编写扩展模块，提升关键代码性能（如 Cython）。
优势原因：高数据结构可以使在一条语句中表达复杂的操作；语句组可用缩进代替开始和结束大括号来组织；变量或参数无需声明。

3. Python 的应用领域

领域	典型应用	常用库/框架
Web 开发	构建网站后端、API 服务（如 Instagram、豆瓣）	Django、Flask、FastAPI
数据分析	数据清洗、统计分析、可视化（金融、科研领域）	Pandas、NumPy、Matplotlib
人工智能	机器学习、深度学习、自然语言处理（如 ChatGPT 模型训练）	TensorFlow、PyTorch、scikit-learn
自动化运维	批量部署、日志分析、监控告警	Ansible、Paramiko、Fabric
科学计算	物理模拟、工程计算（如 NASA 航天器轨迹分析）	SciPy、SymPy
游戏开发	快速原型开发、游戏脚本（如《文明 IV》AI 逻辑）	Pygame、Panda3D
网络爬虫	抓取网页数据（如电商价格监控）	Scrapy、BeautifulSoup、Requests
教育领域	编程入门教学、算法演示	Turtle、PySimpleGUI

二、Linux 环境中安装 Python

1. 下载 Python 源码包

通过 Python 的官网下载，网址是 http://www.python.org

2. 安装依赖包

1.设置yum仓库
2.安装依赖包
yum -y install gcc zlib zlib-devel libffi libffi-devel
#安装源码编译需要的编译环境

yum -y install readline-devel
#可以避免解决后期出现的方向键、删除键乱码问题 

yum -y install openssl-devel openssl11 openssl11-devel
export CFLAGS=$(pkg-config --cflags openssl11)
export LDFLAGS=$(pkg-config --libs openssl11)
#设置编译FLAG，以便使用最新的openssl库

3. 解压安装 Python

tar xvf Python-3.11.6.tar.xz
cd Python-3.11.6/
./configure --prefix=/usr/local/python3

4. 编译安装并建立软链接

make && make install  #编译安装

#软链接
ln -s /usr/local/python3/bin/python3 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3

5. 测试运行

python3

6. 设置国内 pip 更新源

#案例为阿里的更新源
方法1:
cat <<EOF> /root/.config/pip/pip.conf

[global]
index-url = http://mirrors.aliyun.com/pypi/simple/

[install]
trusted-host=mirrors.aliyun.com

方法2:
pip3 config set global.index-url http://mirrors.aliyun.com/pypi/simple
pip3 config set install.trusted-host mirrors.aliyun.com

7. 更新 pip

pip3 install --upgrade pip

三、Windows 系统中安装 Python

1. 安装 Python 程序

双击安装python

2. 安装 vscode 编译器

python提供的IDLE编译器，使用起来不太友好，需要安装一个编译器更方便使用。（如vscode、pycharm）

设置路径

3. 安装 vscode 插件

4. 设置国内更新源

pip config set global.index-url http://mirrors.aliyun.com/pypi/simple
pip config set install.trusted-host mirrors.aliyun.com
pip install --upgrade pip (或python -m pip install --upgrade pip)

四、Python 的语法基础

1. 标识符

定义：
标识符是用于标识变量、函数、类、模块等对象的名称。

命名规则：

合法字符：字母（A-Z, a-z）、数字（0-9）、下划线（_）。
开头限制：不能以数字开头。
区分大小写：Name 和 name 是不同的标识符。
禁止保留字：不能使用 Python 关键字（如 if、for）。

示例：

合法标识符：age_3、_count、MyClass、PI  
非法标识符：3name（以数字开头）、if（保留字）、my-name（包含连字符）

2. Python 保留字

保留字（关键字）是 Python 语言中具有特殊功能的专用标识符，不能用作任何自定义标识符名称。

import keyword  
print(keyword.kwlist)  
# 输出（Python 3.11）：  
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',  
 'break', 'class', 'continue', 'def', 'del', 'elif', 'else',  
 'except', 'finally', 'for', 'from', 'global', 'if', 'import',  
 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',  
 'return', 'try', 'while', 'with', 'yield']

常见关键字用途：

if/elif/else：条件分支
for/while：循环控制
def/class：定义函数或类
try/except：异常处理

3. 注释

注释用于解释代码逻辑，不会被解释器执行。

单行注释：以 # 开头

语法： #单行注释

多行注释：用三引号 ''' 或 """ 包裹（实际是字符串，但习惯用作注释）

语法： #第一行注释

#第二行注释

#第三行注释
'''
这是一个多行注释，
可以跨越多行，
常用于函数或类的文档说明。
'''

4. 语句与缩进

（1）语句

一行代码表示一个独立的操作，如赋值、条件判断、循环、函数调用等。

# 赋值语句
name = "Alice"  
age = 30  

# 条件语句
if age >= 18:  
    print("成年人")  

# 循环语句
for i in range(5):  
    print(i)

（2）代码块

由一组逻辑相关的语句组成，通过缩进（而非大括号）定义范围。

缩进规则：
- 同一代码块内的语句必须保持相同的缩进量（通常为 4 个空格或 1 个 Tab 键，推荐使用空格）。
- 缩进错误会导致语法错误（如 IndentationError）。

# 正确缩进（4 个空格）
if condition:  
    statement1  # 属于 if 代码块  
    statement2  # 属于 if 代码块  
statement3  # 不属于 if 代码块（与 if 语句同缩进）

# 错误缩进（混合 Tab 和空格）
if condition:  
    statement1  
  statement2  # 缩进不一致，报错！

（3）多行语句

当语句过长时，可通过以下方式换行：

反斜杠（\）：在行末加 \，表示语句延续到下一行。

long_sentence = "这是一个非常长的句子，" \  
                "需要分成多行书写。"

括号包裹：利用圆括号 ()、方括号 []、花括号 {} 内的内容可直接换行。

numbers = [1, 2, 3, 4, 5,  
           6, 7, 8, 9, 10]  

result = (x + y + z  
          for x in range(3)  
          for y in range(3)  
          for z in range(3))

5. pass 语句

pass 是空操作语句，用于保持语法完整性（占位符、占位语句）。

作用：作为占位符，用于保持代码结构完整（避免语法错误），不执行任何操作。
常见场景：

定义空函数或空类时（后续再补充代码）。
条件语句或循环中无需执行具体逻辑时。

示例

# 示例 1：空函数
def empty_function():  
    pass  # 不做任何事，但函数语法完整

# 示例 2：条件语句占位
if age < 18:  
    pass  # 暂不处理未成年人逻辑
else:  
    print("成年人")

# 示例 3：空类
class EmptyClass:  
    pass  # 类体为空，但语法正确

五、Python 常用的数据类型

1. 数字

定义：用于表示数值的类型，包括整数、浮点数、复数和布尔值。
分类：

int（整数）：没有小数部分的数值，支持无限精度（受限于内存）。

a = 10
b = -5
c = 0b1010  # 二进制，对应十进制 10
d = 0o12    # 八进制，对应十进制 10
e = 0x0A    # 十六进制，对应十进制 10

float（浮点数）：带小数部分的数值，支持科学计数法。

f = 3.14
g = -2.5
h = 1e3     # 科学计数法，对应 1000.0
i = 3.14e-2  # 对应 0.0314

complex（复数）：由实部和虚部组成，形式为 a + bj。
```
j = 2 + 3j
k = complex(1, -4)  # 实部 1，虚部 -4
```
bool（布尔型）：表示逻辑真（True）或假（False），本质是 int 的子类（True=1，False=0）。
```
is_valid = True
is_empty = False
```

特性：

不可变类型：修改数字变量会创建新对象。
支持算术运算（+、-、*、/、//、%、**）和类型转换（如 int(3.9)=3，float(5)=5.0）。

Python 运算符：由+、-、*、/ (加、减、乘、除)和小括号组成，运算顺序也是先乘除后加减、小括号优先。

2. 字符串

定义：由字符（字母、数字、符号等）组成的有序序列，用单引号、双引号或三引号（多行字符串）表示。

>>> name = 'aaa'
>>> address = 'sss'
>>> content = '''cccc'''
 
>>> print (name)
>>> print (address)
>>> print (content)

特点：

不可变：修改会生成新字符串。
支持索引和切片：str[0] 获取首个字符，str[2:5] 截取子串。
转义字符：如 \n（换行）、\t（制表符）、\\（反斜杠）、\ (在行尾时，续行符)、\v(纵向制表符) 、\r (回车)。

3. 列表

定义：有序、可变的集合，用方括号 [] 表示，元素可以是任意数据类型（支持嵌套）。

特点：

可变：支持增删改元素。
异构元素：可混合不同类型（如 [1, "a", True]）。
支持嵌套：列表中的元素可以是列表（多维列表）。

（1）列表的定义

语法：列表名 = [ 元素1，元素2，...

（2）列表的取值

语法：列表名 [索引位置]

通过索引取值（有序序列，索引从 0 开始，负数表示从末尾反向索引）：

fruits = ['apple', 'banana', 'orange', 'grape']
print(fruits[0])     # 'apple'（第一个元素）
print(fruits[-1])    # 'grape'（最后一个元素）
print(fruits[2])     # 'orange'（索引 2 的元素）

语法：列表名 [起始位置：终止位置]

通过切片取值（语法：列表[start:end:step]，左闭右开，返回新列表）：

print(fruits[1:3])   # ['banana', 'orange']（取索引 1~2 的元素）
print(fruits[:2])    # ['apple', 'banana']（从开头到索引 1）
print(fruits[2:])    # ['orange', 'grape']（从索引 2 到末尾）
print(fruits[::2])   # ['apple', 'orange']（步长为 2，隔一个取一个）
print(fruits[::-1])  # ['grape', 'orange', 'banana', 'apple']（反转列表）

（3）修改列表元素值

语法：列表名 [索引位置] = 值

num = ['1','2','3']
num[0] = '4'  #修改
print （num）
['4','2','3']

（4）添加列表元素

语法：

列表名.append(元素值) #在列表末尾添加单个元素。

fruits.append('grape')  # 末尾添加 'grape'
print(fruits)          # ['apple', 'mango', 'pear', 'kiwi', 'grape']

列表名.insert(索引位置，元素值) #在指定索引处插入元素。

fruits.insert(1, 'banana')  # 在索引 1 处插入 'banana'
print(fruits)               # ['apple', 'banana', 'mango', 'pear', 'kiwi', 'grape']

（5）删除列表元素

语法： del 列表名[索引位置]

del fruits[0]           # 删除第一个元素 'apple'
print(fruits)           # ['banana', 'mango', 'pear', 'kiwi', 'grape', 'orange', 'pineapple']

del fruits[2:4]         # 删除索引 2~3 的元素（'pear', 'kiwi'）
print(fruits)           # ['banana', 'mango', 'grape', 'orange', 'pineapple']

（6）查找列表元素

语法：元素值 in 列表名（返回布尔值）

print('orange' in fruits)  # True
print('apple' in fruits)   # False

（7）合并列表

+ 运算符：创建新列表，合并两个列表（原列表不变）。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged = list1 + list2  # [1, 2, 3, 4, 5, 6]

（8）重复列表

使用 * 运算符重复列表元素（生成新列表）：

zeros = [0] * 5       # [0, 0, 0, 0, 0]
words = ['hello'] * 3  # ['hello', 'hello', 'hello']

（9）列表常见问题

示例：索引越界

（1）索引越界

问题描述：当使用超过列表长度的正索引或绝对值超过列表长度的负索引时，会抛出 IndexError 异常。
示例：

numbers = [1, 2, 3, 4, 5]
print(numbers[5])     # 报错：IndexError: list index out of range（正索引越界，最大索引为 4）
print(numbers[-6])    # 报错：IndexError: list index out of range（负索引越界，最小索引为 -5）

解决方法：

用 len(列表) 检查索引范围：if index < len(numbers) and index >= -len(numbers): ...

使用 try-except 捕获异常：

try:
    print(numbers[10])
except IndexError:
    print("索引越界，列表长度为", len(numbers))

（2）负值索引

特性：Python 支持负值索引，-1 表示最后一个元素，-2 表示倒数第二个，依此类推（需满足 abs(index) <= len(列表)）。
示例：

fruits = ['apple', 'banana', 'orange', 'grape']
print(fruits[-1])   # 'grape'（最后一个元素）
print(fruits[-2])   # 'orange'（倒数第二个元素）

（3）当获取列表指定范围的一组元素时，不存在列表索引越界的问题（切片时无索引越界问题）

特性：切片操作（列表[start:end:step]）即使 start 或 end 超出列表范围，也不会报错，而是返回合理的子集（空列表或部分元素）。
示例：

nums = [1, 2, 3]
print(nums[5:10])   # []（start 超出列表长度，返回空列表）
print(nums[-10:5])  # [1, 2, 3]（start 为负且超出范围，默认从列表开头开始）
print(nums[1:100])  # [2, 3]（end 超出范围，取到列表末尾）

原理：切片的 start 和 end 会自动被限制在合法范围内（小于 len(列表) 或大于 -len(列表)），无需手动处理越界。

（4）获取列表指定范围时可以同时使用正数和负数索引（切片支持混合正负索引）

用法：切片的 start 和 end 可以同时使用正数和负数索引，实现灵活的范围选取。
示例：

words = ['a', 'b', 'c', 'd', 'e']
# 正数 start + 负数 end：取索引 1 到倒数第一个元素（不包含 end）
print(words[1:-1])   # ['b', 'c', 'd']  
# 负数 start + 正数 end：取倒数第 3 个元素到索引 3（不包含 end）
print(words[-3:4])   # ['c', 'd']  
# 负数 start + 负数 end：取倒数第 2 个元素到倒数第 1 个元素（不包含 end）
print(words[-2:-1])  # ['d']

表示获取由索引位置0元素开始，到-1元素之前的所有元素。

注意：当 step 为正时，start 需小于等于 end（否则返回空列表）；当 step 为负时，start 需大于等于 end。

（5）列表元素也可以是列表

每个元素也是一个列表，使用num[0]表示取到的第一个元素值，对应的是一个列表。

使用num[0][0] 表示取到第一个元素列表的第一个值，使用print num[2][1] 表示取到第三个列表的第二个元素值。

4. 元组

定义：有序、不可变的集合，用圆括号 () 表示，常用于保存不可修改的数据。

（1）元组的创建

语法：元组名 = （元素 1，元素 2， ...）

元组是写保护的，一旦创建不能修改

（2）元组的操作

与列表的取值操作完全相同，不可修改但可删除

语法： del 元组名

元组和列表可以互相转换操作

元组转换为列表

语法：list (列表名)

num = ('1','2','3')
listNum = list(num)  #转换为列表
print (listNum)
['1','2','3']

listNum[0]='4'   #修改列表
print (listNum)
['4','2','3']

print (type(num))  #输出元组类型
<class 'tuple'>

print (type(listNum))  #输出列表类型
<class 'list'>

列表转换元组

语法：tuple(列表名)

num = ['1','2','3']
tupleNum = tuple(num)
print (type(num))
<class 'list'>

print (type(tupleNum))
<class 'tuple'>

5. 字典

定义：无序的键值对（key-value）集合，用花括号 {} 表示，键必须唯一且不可变（通常为字符串、数字或元组），值可以是任意类型。

（1）字典的创建

语法：字典名 = {键1：值1，键2：值2，...}

mobile = {'Tom':1111，'Alice':2222,'Bob':3333}
print (mobile)
{'Tom':1111，'Alice':2222,'Bob':3333 }

print (type(mobile))
<class 'dict'>

（2）字典的取值操作

通过键获取值，和元组与列表不同。

注意：键是唯一的，而不同的键的值却可以相同，当定义多个键相同时，字典中只会保留最后一个定义的键值对

（3）字典的添加、修改、删除操作

添加 / 修改键值对：

注意：字典值对的键名是必须区分大小写

若键不存在，视为添加新键值对；若键存在，视为修改值。

person['job'] = 'engineer'  # 添加新键值对
person['age'] = 31          # 修改已有键的值

删除键值对：

del 字典[key]：删除指定键（键不存在时抛出 KeyError）。
pop(key, default=None)：删除并返回指定键的值（可指定默认值避免报错）。
popitem()：随机删除并返回一个键值对（Python 3.7+ 按插入顺序删除最后一个）。
clear()：清空字典所有键值对。

del person['hobbies']       # 删除 'hobbies' 键
age = person.pop('age')     # 删除 'age' 键并返回值 31
last_item = person.popitem() # 删除最后一个键值对（如 ('job', 'engineer')）
person.clear()              # 字典变为空 {}