Python 编程语言完整指南

概述

Python 是一种高级、解释型、面向对象的编程语言，由 Guido van Rossum 于 1991 年创建。Python 以其简洁清晰的语法、强大的标准库和丰富的第三方生态系统，成为最受欢迎的编程语言之一。

核心特性

• 易学易用: 语法简洁，接近自然语言
• 跨平台: 支持 Windows、macOS、Linux 等主流操作系统
• 解释型: 无需编译，即写即运行
• 动态类型: 运行时确定变量类型
• 丰富生态: 拥有庞大的第三方库生态
• 多领域应用: Web 开发、数据科学、人工智能、自动化等

版本对比

应用场景

💡 推荐: 新项目建议使用 Python 3.11+ 版本，具有更好的性能和功能特性。

环境准备

系统要求

Python 安装

Windows 安装

1. 下载 Python:

   • 访问 Python 官网
   • 下载最新版本的 Python 安装程序

2. 安装配置:

   # 验证安装
   python --version
   pip --version
   
   # 添加到环境变量（安装时勾选 "Add Python to PATH"）

macOS 安装

# 使用 Homebrew 安装（推荐）
brew install python

# 验证安装
python3 --version
pip3 --version

# 创建软链接（可选）
ln -s /usr/local/bin/python3 /usr/local/bin/python

Linux 安装

# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip python3-venv

# CentOS/RHEL
sudo yum install python3 python3-pip

# 验证安装
python3 --version
pip3 --version

开发环境配置

推荐 IDE 和编辑器

虚拟环境配置

# 创建虚拟环境
python -m venv myproject_env

# 激活虚拟环境
# Windows
myproject_env\Scripts\activate
# macOS/Linux
source myproject_env/bin/activate

# 退出虚拟环境
deactivate

# 删除虚拟环境
rm -rf myproject_env

包管理工具

pip 包管理器

pip 是 Python 的标准包管理工具，用于安装和管理 Python 包。

基本命令

# 安装包
pip install <包名>                # 安装最新版本
pip install <包名>==1.2.3         # 安装指定版本
pip install <包名>>=1.2.0         # 安装指定版本以上

# 卸载包
pip uninstall <包名>

# 查看已安装的包
pip list                          # 列出所有包
pip list --outdated               # 列出可更新的包
pip show <包名>                   # 显示包详细信息

# 包管理
pip freeze                        # 输出已安装包列表
pip freeze > requirements.txt     # 导出依赖列表
pip install -r requirements.txt   # 安装依赖列表

# 升级包
pip install --upgrade <包名>      # 升级指定包
pip install --upgrade pip         # 升级 pip 本身

配置国内镜像源

临时使用镜像源:

pip install <包名> -i https://pypi.tuna.tsinghua.edu.cn/simple/

永久配置镜像源:

1. 创建配置文件:

   # Windows
   %APPDATA%\pip\pip.ini
   
   # macOS/Linux
   ~/.pip/pip.conf

2. 配置内容:

   [global]
   index-url = https://pypi.tuna.tsinghua.edu.cn/simple/
   trusted-host = pypi.tuna.tsinghua.edu.cn

国内常用镜像源:

依赖管理最佳实践

# 创建项目目录
mkdir my_project && cd my_project

# 创建虚拟环境
python -m venv .venv

# 激活虚拟环境
source .venv/bin/activate  # macOS/Linux
# .venv\Scripts\activate   # Windows

# 安装项目依赖
pip install requests pandas numpy

# 导出依赖文件
pip freeze > requirements.txt

# 在其他环境安装相同依赖
pip install -r requirements.txt

其他包管理工具

Poetry（现代化包管理）

# 安装 Poetry
curl -sSL https://install.python-poetry.org | python3 -

# 创建新项目
poetry new my_project
cd my_project

# 添加依赖
poetry add requests
poetry add pytest --group dev

# 安装依赖
poetry install

# 运行命令
poetry run python main.py

Conda（科学计算环境）

# 创建环境
conda create -n myenv python=3.11
conda activate myenv

# 安装包
conda install numpy pandas matplotlib
conda install -c conda-forge scikit-learn

# 导出环境
conda env export > environment.yml

# 从文件创建环境
conda env create -f environment.yml

语法基础

Python 解释器

交互式模式

# 启动 Python 解释器
python
# 或
python3

# 退出解释器
exit()
# 或
quit()
# 或快捷键
# Ctrl+Z + Enter (Windows)
# Ctrl+D (macOS/Linux)

脚本模式

# hello.py
print("Hello, World!")

# 运行脚本
python hello.py

注释规范

单行注释

# 这是单行注释
print("Hello, World!")  # 行末注释（不推荐）

# 推荐：注释写在代码上方
# 计算圆的面积
radius = 5
area = 3.14159 * radius ** 2

多行注释

"""
这是多行注释
用于函数、类或模块的文档说明
也称为文档字符串（docstring）
"""

def calculate_area(radius):
    """
    计算圆的面积
    
    Args:
        radius (float): 圆的半径
    
    Returns:
        float: 圆的面积
    """
    return 3.14159 * radius ** 2

# 另一种多行注释方式（不推荐用于文档）
'''
这也是多行注释
但通常不用于正式文档
'''

注释最佳实践

# ✅ 好的注释
def calculate_tax(income, tax_rate):
    """根据收入和税率计算应缴税款"""
    return income * tax_rate

# ❌ 不好的注释
def calculate_tax(income, tax_rate):
    # 乘法运算
    return income * tax_rate  # 这个注释没有价值

# ✅ 解释复杂逻辑
def fibonacci(n):
    """计算斐波那契数列的第n项"""
    if n <= 1:
        return n
    
    # 使用动态规划避免重复计算
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    
    return b

变量和标识符

变量定义

变量是存储数据的标识符，Python 中的变量无需声明类型，直接赋值即可。

# 基本变量定义
message = "Hello, Python!"
print(message)

# 变量的优势：避免重复，便于维护
# ❌ 重复硬编码
print("欢迎使用Python编程")
print("欢迎使用Python编程")
print("欢迎使用Python编程")

# ✅ 使用变量
welcome_message = "欢迎使用Python编程"
print(welcome_message)
print(welcome_message)
print(welcome_message)

# 变量重新赋值
welcome_message = "Welcome to Python Programming"
print(welcome_message)  # 输出新值

标识符命名规则

命名规则（必须遵守）:

1. 只能包含字母、数字、下划线
2. 不能以数字开头
3. 不能使用Python关键字
4. 区分大小写

# ✅ 合法的标识符
user_name = "张三"
age2 = 25
_private_var = "私有变量"
CANSTANT_VALUE = 100

# ❌ 不合法的标识符
# 2age = 25        # 不能以数字开头
# user-name = "李四"  # 不能包含连字符
# class = "学生"     # 不能使用关键字

Python 关键字:

import keyword
print(keyword.kwlist)
# ['False', 'None', 'True', 'and', 'as', 'assert', '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']

命名约定（建议遵守）

# 🐍 Snake Case（Python 推荐）
user_name = "张三"
max_retry_count = 3
calculate_total_price = lambda x, y: x * y

# 📚 常量：全大写
PI = 3.14159
MAX_CONNECTIONS = 100
DATABASE_URL = "mysql://localhost:3306/mydb"

# 🏷️ 类名：Pascal Case
class UserManager:
    pass

class DatabaseConnection:
    pass

# 🔒 私有变量：单下划线开头
class MyClass:
    def __init__(self):
        self._private_var = "内部使用"
        self.__very_private = "强私有"
        self.public_var = "公开变量"

# ❌ 避免的命名方式
# userName = "驼峰命名"    # 不符合Python风格
# l = [1, 2, 3]          # 单字母变量名
# O = 0                  # 容易混淆的字母

2.2 数据类型

https://www.zhixi.com/view/125e9881

1.int

money = 5000
print(money)

2.float

money2 = 3.87
print(money2)

3.boolean

# 1.流程控制语句
# 2.性别的控制（在实际企业开发中使用的单词 sex gender）
#   基本开发中 True 是男，False是女
sex = True
sex2 = False
print(sex)
print(sex2)

4.string

# 字符串 使用的是 单引号 或者是 双引号 （英文的）
s = '你是我的宝贝'
s2 = "你不是的宝贝"
print(s)
print(s2)
# 不能单双混着写，屌丝写法
# 也不能 双双引号 或者 双单引号的嵌套
s3 = "'你是我的宝贝'"
s4 = '"你是我的宝贝"'
print(s3)
print(s4)

5.list

# 应用场景：当获取到很多数据时，可以存储到列表中，然后直接访问。
name_list = ['王','赵']
print(name_list)

6.tuple

age_tuple = (0,2,3)
print(age_tuple)

7.dict

# 应用场景：scrapy框架常用
# 格式：变量名字 = {key:value,key1:value2}
person = {'name':'红浪漫','age':18}
print(person)

2.3 数据类型的查询

在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要开发者主动的 去说明它的类型，系统会自动辨别。也就是说在使用的时候 变量没有类型，数据才有类型。

# 常用数据类型
# int
# float
# boolean
# string
# list
# tuple
# dict
a = 1
print(a)
print(type(a))

b = 2.12
print(b)
print(type(b))

c = True
print(c)
print(type(c))

d = '中国'
print(d)
print(type(d))

e = [1,2,3,4]
print(e)
print(type(e))

f = (1,2,3,4)
print(f)
print(type(f))

g = {'name':'张三','age':'18'}
print(g)
print(type(g))

3. 标识符和关键字

3.1命名规范

计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与 使用之间的关系。

1. 标识符由字母、下划线和数字组成，且数字不能开头。

2. 严格区分大小写。

3. 不能使用关键字。

关键字：
False None True and as assert 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

3.2 命名规范

​ 驼峰原则

​ 大驼峰：userName（常用） 第一个单词以小写字母开始；第二个单词的首字母大写

​ 小驼峰：UserName 每一个单字的首字母都采用大写字母

​ 下划线： user_name 用下划线将单词相连

4. 类型转换

1.转换为整型

# str --> int
a = '123'
print(type(a))

b = int(a)

# float --> int
# 如果我们将float转为整数 那么会返回的是小数点前面的数据
c = 1.63
d = int(c)

# boolean --> int
# 强制类型转换为谁 就写什么方法
# True ---> 1   False ---> 0
a = False
b = int(a)

2.转换为浮点型

# 在爬虫时获取的数据大部分是字符串类型,部分数据需要转换为浮点型，例如价格，数量等。
# string --> float
a = '12.34'
b = float(a)

#int -->float
c = 666
d = float(c)

3.转换为字符串型

#int -->string
a = 80
b = str(a)

# float --> string
a = 12.32
b = str(a)

# bool --> string
a = True
b = str(a)

4.转换为布尔类型

# int --> bool
# 非零整数转换为bool， 0为 False, 其他为True
a = 1
a = -1
a = 0

#float --> bool
# 非零数转换为bool， 0为 False, 其他为True
a = 0.0
a = -1.34
a = 1.54

#string --> bool
#非空（包括空格）返回True，空返回False
a = ''
a = ' '
a = '你是我宝贝'

#liat --> bool(列表)
#非空（包括空格）返回True，空返回False	(同string)

#tuple --> bool(元组)
#非空（包括空格）返回True，空返回False	(同string)

#dict --> bool(字典)
#非空（包括空格）返回True，空返回False	(同string)

5. 运算符

5.1 算数运算符

优先级 ** 高于 */ % // 高于 + -

#特殊类型
#在python中	+	两端只能是同种类型
#在python中	*	可以重复文本(文本*数量)

5.2 赋值运算符

# 单个变量赋值 
num = 10 

# 同时为多个变量赋值(使用等号连接) 
a = b = 4 

# 多个变量赋值(使用逗号分隔) 
num1, f1, str1 = 100, 3.14, "hello" 

5.3 复合赋值运算符

5.4 比较运算符

5.5 逻辑运算符

输入输出操作

输出函数 print()

基本语法:

print(value1, value2, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

基本输出

# 简单输出
print("Hello, World!")
print("Python编程语言")

# 多个值输出
print("姓名:", "张三", "年龄:", 25)
# 输出: 姓名: 张三 年龄: 25

# 自定义分隔符
print("苹果", "香蕉", "橙子", sep=", ")
# 输出: 苹果, 香蕉, 橙子

print("2023", "07", "10", sep="-")
# 输出: 2023-07-10

# 自定义结束符
print("正在处理", end="...")
print("完成!")
# 输出: 正在处理...完成!

# 输出到文件
with open("output.txt", "w") as f:
    print("这是输出到文件的内容", file=f)

格式化输出

% 格式化（传统方式）:

name = "李四"
age = 30
score = 95.67

# 基本格式化
print("姓名: %s, 年龄: %d" % (name, age))

# 浮点数格式化
print("成绩: %.2f" % score)  # 保留2位小数

# 格式化符号
print("二进制: %b, 八进制: %o, 十六进制: %x" % (255, 255, 255))
# 输出: 二进制: 11111111, 八进制: 377, 十六进制: ff

str.format() 方法:

name = "王五"
age = 35
salary = 8500.0

# 位置参数
print("姓名: {}, 年龄: {}".format(name, age))

# 索引参数
print("姓名: {0}, 年龄: {1}, 再次提及姓名: {0}".format(name, age))

# 关键字参数
print("姓名: {name}, 年龄: {age}".format(name=name, age=age))

# 格式化选项
print("薪资: {:.2f}".format(salary))          # 8500.00
print("薪资: {:,}".format(salary))            # 8,500.0
print("百分比: {:.1%}".format(0.87))          # 87.0%
print("科学计数法: {:e}".format(salary))       # 8.500000e+03

f-string (推荐，Python 3.6+):

name = "赵六"
age = 28
pi = 3.14159

# 基本用法
print(f"姓名: {name}, 年龄: {age}")

# 表达式
print(f"明年{name}将{age + 1}岁")

# 格式化
print(f"π 的值约为 {pi:.3f}")               # π 的值约为 3.142
print(f"十六进制: {255:x}")                 # 十六进制: ff
print(f"居中对齐: {name:^10}")              # 居中对齐:   赵六   

# 日期格式化
from datetime import datetime
now = datetime.now()
print(f"当前时间: {now:%Y-%m-%d %H:%M:%S}")

# 调试输出（Python 3.8+）
x = 42
print(f"{x=}")  # x=42

输入函数 input()

基本输入

# 基本输入
name = input("请输入您的姓名: ")
print(f"您好, {name}!")

# 输入始终是字符串类型
age_str = input("请输入您的年龄: ")
print(f"输入的类型: {type(age_str)}")  # <class 'str'>

# 类型转换
age = int(input("请输入您的年龄: "))
print(f"明年您将 {age + 1} 岁")

安全输入处理

def get_integer(prompt, min_val=None, max_val=None):
    """安全地获取整数输入"""
    while True:
        try:
            value = int(input(prompt))
            if min_val is not None and value < min_val:
                print(f"值必须大于等于 {min_val}")
                continue
            if max_val is not None and value > max_val:
                print(f"值必须小于等于 {max_val}")
                continue
            return value
        except ValueError:
            print("请输入有效的整数")

def get_float(prompt):
    """安全地获取浮点数输入"""
    while True:
        try:
            return float(input(prompt))
        except ValueError:
            print("请输入有效的数字")

def get_yes_no(prompt):
    """获取是/否输入"""
    while True:
        response = input(prompt + " (y/n): ").lower().strip()
        if response in ['y', 'yes', '是', '1']:
            return True
        elif response in ['n', 'no', '否', '0']:
            return False
        else:
            print("请输入 y/yes 或 n/no")

# 使用示例
age = get_integer("请输入年龄 (1-120): ", 1, 120)
height = get_float("请输入身高 (米): ")
is_student = get_yes_no("您是学生吗?")

print(f"年龄: {age}, 身高: {height:.2f}m, 学生: {is_student}")

多行输入

print("请输入多行文本，以空行结束:")
lines = []
while True:
    line = input()
    if not line:  # 空行
        break
    lines.append(line)

text = '\n'.join(lines)
print("您输入的文本:")
print(text)

隐藏输入（密码）

import getpass

# 隐藏密码输入
password = getpass.getpass("请输入密码: ")
print("密码输入完成")  # 不显示密码内容

# 验证密码
def verify_password():
    correct_password = "secret123"
    max_attempts = 3
    
    for attempt in range(max_attempts):
        password = getpass.getpass("请输入密码: ")
        if password == correct_password:
            print("密码正确！")
            return True
        else:
            remaining = max_attempts - attempt - 1
            if remaining > 0:
                print(f"密码错误，还有 {remaining} 次机会")
            else:
                print("密码错误次数过多，访问被拒绝")
    
    return False

# verify_password()

流程控制

Python 提供了丰富的流程控制语句，包括条件判断、循环和跳转语句。

条件判断

if 语句

基本语法:

if condition:
    # 当条件为真时执行的代码
    statement1
    statement2

基本示例:

age = 18
if age >= 18:
    print("您已成年，可以投票")

# 带变量的条件判断
score = 85
if score >= 60:
    print("考试及格")

# 复合条件
username = "admin"
password = "123456"
if username == "admin" and password == "123456":
    print("登录成功")

if-else 语句

age = 16
if age >= 18:
    print("您已成年")
else:
    print("您还未成年")

# 实际应用示例
def check_password(password):
    if len(password) >= 8:
        print("密码强度符合要求")
        return True
    else:
        print("密码长度至少8位")
        return False

# 三元运算符（条件表达式）
age = 20
status = "成年人" if age >= 18 else "未成年人"
print(f"您是{status}")

# 更复杂的示例
def get_grade(score):
    return "优秀" if score >= 90 else "良好" if score >= 80 else "及格" if score >= 60 else "不及格"

print(get_grade(95))  # 优秀
print(get_grade(75))  # 及格

elif 多分支判断

def get_grade_detailed(score):
    if score >= 90:
        grade = "A"
        description = "优秀"
    elif score >= 80:
        grade = "B" 
        description = "良好"
    elif score >= 70:
        grade = "C"
        description = "中等"
    elif score >= 60:
        grade = "D"
        description = "及格"
    else:
        grade = "F"
        description = "不及格"
    
    return grade, description

# 使用示例
scores = [95, 85, 75, 65, 55]
for score in scores:
    grade, desc = get_grade_detailed(score)
    print(f"分数: {score}, 等级: {grade} ({desc})")

# 实际应用：简单计算器
def calculator():
    num1 = float(input("请输入第一个数字: "))
    operator = input("请输入运算符 (+, -, *, /): ")
    num2 = float(input("请输入第二个数字: "))
    
    if operator == "+":
        result = num1 + num2
    elif operator == "-":
        result = num1 - num2
    elif operator == "*":
        result = num1 * num2
    elif operator == "/":
        if num2 != 0:
            result = num1 / num2
        else:
            print("错误：除数不能为零")
            return
    else:
        print("错误：不支持的运算符")
        return
    
    print(f"{num1} {operator} {num2} = {result}")

# calculator()  # 取消注释以运行

嵌套条件判断

def evaluate_student(score, attendance):
    """评估学生表现"""
    if score >= 60:  # 及格
        if attendance >= 80:
            if score >= 90:
                return "优秀学生"
            elif score >= 80:
                return "良好学生"
            else:
                return "合格学生"
        else:
            return "出勤不足，需要改进"
    else:  # 不及格
        if attendance >= 80:
            return "努力学习，但需要提高成绩"
        else:
            return "学习态度和成绩都需要改进"

# 测试不同情况
test_cases = [
    (95, 90),  # 优秀学生
    (85, 85),  # 良好学生
    (70, 85),  # 合格学生
    (75, 70),  # 出勤不足
    (50, 90),  # 努力但成绩不够
    (45, 60),  # 都需要改进
]

for score, attendance in test_cases:
    evaluation = evaluate_student(score, attendance)
    print(f"成绩: {score}, 出勤率: {attendance}% -> {evaluation}")

循环语句

for 循环

基本语法:

for variable in iterable:
    # 循环体
    statement1
    statement2

遍历不同类型的对象:

# 遍历字符串
text = "Python"
for char in text:
    print(f"字符: {char}")

# 遍历列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
for fruit in fruits:
    print(f"水果: {fruit}")

# 遍历字典
student = {"姓名": "张三", "年龄": 20, "专业": "计算机科学"}

# 遍历键
for key in student:
    print(f"键: {key}")

# 遍历值
for value in student.values():
    print(f"值: {value}")

# 遍历键值对
for key, value in student.items():
    print(f"{key}: {value}")

# 带索引的遍历
languages = ["Python", "Java", "C++", "JavaScript"]
for index, language in enumerate(languages):
    print(f"{index + 1}. {language}")

# 同时遍历多个序列
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
cities = ["北京", "上海", "深圳"]

for name, age, city in zip(names, ages, cities):
    print(f"{name}, {age}岁, 来自{city}")

range() 函数

# 基本用法
print("range(5):")
for i in range(5):
    print(i, end=" ")  # 0 1 2 3 4
print()

# 指定起始值
print("range(2, 8):")
for i in range(2, 8):
    print(i, end=" ")  # 2 3 4 5 6 7
print()

# 指定步长
print("range(0, 10, 2):")
for i in range(0, 10, 2):
    print(i, end=" ")  # 0 2 4 6 8
print()

# 倒序
print("range(10, 0, -1):")
for i in range(10, 0, -1):
    print(i, end=" ")  # 10 9 8 7 6 5 4 3 2 1
print()

# 实际应用：生成乘法表
def multiplication_table(n):
    """生成n阶乘法表"""
    for i in range(1, n + 1):
        for j in range(1, i + 1):
            print(f"{j}×{i}={i*j}", end="\t")
        print()  # 换行

print("九九乘法表:")
multiplication_table(9)

while 循环

基本语法:

while condition:
    # 循环体
    statement1
    statement2

基本示例:

# 基本计数
count = 0
while count < 5:
    print(f"当前计数: {count}")
    count += 1

# 用户输入验证
def get_valid_number():
    while True:
        try:
            number = float(input("请输入一个数字: "))
            return number
        except ValueError:
            print("输入无效，请输入数字")

# number = get_valid_number()
# print(f"您输入的数字是: {number}")

# 猜数字游戏
import random

def guess_number_game():
    """猜数字游戏"""
    target = random.randint(1, 100)
    attempts = 0
    max_attempts = 7
    
    print("我想了一个1到100之间的数字，你能猜中吗？")
    print(f"你有{max_attempts}次机会")
    
    while attempts < max_attempts:
        try:
            guess = int(input(f"第{attempts + 1}次猜测: "))
            attempts += 1
            
            if guess == target:
                print(f"🎉 恭喜！你用{attempts}次就猜中了！")
                break
            elif guess < target:
                print("太小了！")
            else:
                print("太大了！")
                
            remaining = max_attempts - attempts
            if remaining > 0:
                print(f"还有{remaining}次机会")
        
        except ValueError:
            print("请输入有效的数字")
            attempts -= 1  # 无效输入不算次数
    
    else:
        print(f"😢 游戏结束！正确答案是{target}")

# guess_number_game()  # 取消注释以运行游戏

循环控制语句

break - 跳出循环:

# break 在 for 循环中
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for num in numbers:
    if num > 5:
        print(f"找到大于5的数字: {num}")
        break
    print(f"处理数字: {num}")

# break 在 while 循环中
def find_first_prime():
    """找到第一个大于100的质数"""
    num = 101
    while True:
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        
        if is_prime:
            print(f"找到质数: {num}")
            break
        
        num += 1

find_first_prime()

continue - 跳过当前迭代:

# continue 在 for 循环中
print("1到10中的奇数:")
for i in range(1, 11):
    if i % 2 == 0:  # 偶数
        continue
    print(i, end=" ")
print()

# continue 在 while 循环中 - 处理用户输入
def process_commands():
    """处理用户命令"""
    print("输入命令 (输入 'quit' 退出):")
    
    while True:
        command = input(">>> ").strip().lower()
        
        if command == "quit":
            print("再见！")
            break
        
        if not command:  # 空命令
            continue
        
        if command == "help":
            print("可用命令: help, time, clear, quit")
            continue
        
        if command == "time":
            from datetime import datetime
            print(f"当前时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
            continue
        
        if command == "clear":
            import os
            os.system('cls' if os.name == 'nt' else 'clear')
            continue
        
        print(f"未知命令: {command}，输入 'help' 查看帮助")

# process_commands()  # 取消注释以运行

else 子句:

# for-else
def find_item(items, target):
    """在列表中查找目标项"""
    for item in items:
        if item == target:
            print(f"找到目标: {target}")
            break
    else:
        print(f"未找到目标: {target}")

# 测试
fruits = ["苹果", "香蕉", "橙子"]
find_item(fruits, "香蕉")  # 找到目标: 香蕉
find_item(fruits, "葡萄")  # 未找到目标: 葡萄

# while-else
def check_password_strength(password):
    """检查密码强度"""
    checks = [
        (len(password) >= 8, "长度至少8位"),
        (any(c.isupper() for c in password), "包含大写字母"),
        (any(c.islower() for c in password), "包含小写字母"),
        (any(c.isdigit() for c in password), "包含数字"),
        (any(c in "!@#$%^&*" for c in password), "包含特殊字符"),
    ]
    
    i = 0
    while i < len(checks):
        passed, description = checks[i]
        if not passed:
            print(f"密码不符合要求: {description}")
            break
        i += 1
    else:
        print("密码强度良好！")

# 测试
check_password_strength("abc123")      # 不符合要求
check_password_strength("Abc123!@")    # 密码强度良好

嵌套循环

# 生成图案
def print_triangle(rows):
    """打印三角形"""
    for i in range(1, rows + 1):
        # 打印空格
        for j in range(rows - i):
            print(" ", end="")
        # 打印星号
        for k in range(2 * i - 1):
            print("*", end="")
        print()  # 换行

print("三角形图案:")
print_triangle(5)

# 矩阵操作
def matrix_multiply(A, B):
    """矩阵乘法"""
    rows_A, cols_A = len(A), len(A[0])
    rows_B, cols_B = len(B), len(B[0])
    
    if cols_A != rows_B:
        raise ValueError("矩阵维度不匹配")
    
    # 初始化结果矩阵
    result = [[0 for _ in range(cols_B)] for _ in range(rows_A)]
    
    # 执行矩阵乘法
    for i in range(rows_A):
        for j in range(cols_B):
            for k in range(cols_A):
                result[i][j] += A[i][k] * B[k][j]
    
    return result

# 测试矩阵乘法
A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]
result = matrix_multiply(A, B)
print("矩阵乘法结果:")
for row in result:
    print(row)

# 查找数组中的重复元素
def find_duplicates(arr):
    """查找数组中的重复元素"""
    duplicates = []
    
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j] and arr[i] not in duplicates:
                duplicates.append(arr[i])
    
    return duplicates

# 测试
numbers = [1, 2, 3, 2, 4, 5, 3, 6]
duplicates = find_duplicates(numbers)
print(f"重复元素: {duplicates}")  # [2, 3]

相关文章

语言对比学习

• Java 编程语言 - 面向对象编程对比
• C++ 基础教程 - 系统编程语言对比

大数据和分布式

• Kafka Python客户端 - 消息队列集成
• Redis Python操作 - 缓存和 NoSQL 数据库
• Elasticsearch Python API - 搜索引擎集成
• MongoDB Python操作 - NoSQL数据库操作

DevOps 和自动化

• Docker 容器化 - Python 应用容器化
• Git版本控制 - 代码版本管理

总结

Python 作为一门易学易用的编程语言，为初学者和专业开发者提供了强大的编程能力：

🎯 核心优势

• 语法简洁: 接近自然语言的语法，降低学习门槛
• 功能强大: 丰富的标准库和第三方生态系统
• 应用广泛: 从 Web 开发到人工智能的全方位应用
• 社区活跃: 庞大的开发者社区和技术支持

🛠️ 技术要点

1. 环境配置: 虚拟环境管理和包依赖管理
2. 语法基础: 数据类型、运算符、流程控制
3. 函数编程: 函数定义、参数传递、作用域
4. 面向对象: 类、继承、封装、多态
5. 异常处理: try-except 错误处理机制
6. 文件操作: 文件读写和路径操作

🚀 应用方向

• Web 开发: Django、Flask、FastAPI 等框架
• 数据科学: NumPy、Pandas、Matplotlib 等工具
• 人工智能: TensorFlow、PyTorch、scikit-learn
• 自动化运维: 脚本编写、系统管理、DevOps
• 网络爬虫: requests、Scrapy、Beautiful Soup
• 桌面应用: Tkinter、PyQt、Kivy

📚 最佳实践建议

• 代码规范: 遵循 PEP 8 编码规范
• 注释文档: 编写清晰的注释和文档字符串
• 测试驱动: 编写单元测试保证代码质量
• 版本控制: 使用 Git 进行代码版本管理
• 持续学习: 关注 Python 社区和新技术发展

语言对比学习

• Java 编程语言 - 面向对象编程对比
• C++ 基础教程 - 系统编程语言对比

开发环境与工具

• Linux 基本命令 - Python 开发环境
• Git 版本控制 - 代码版本管理
• Docker 容器化 - Python 应用部署
• VS Code Python 开发 - 开发环境配置