Python是一种高级、解释型、面向对象的编程语言。由荷兰程序员Guido van Rossum于1991年首次发布。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或关键词）。相比于C++或Java，Python让开发者能够用更少的代码表达想法。不管是小型还是大型程序，该语言都试图让程序的结构清晰明了。
Python是一种广泛使用的解释型、高级和通用的编程语言。Python支持多种编程范式，包括结构化、过程式、反射式、面向对象和函数式编程。它拥有动态类型系统和垃圾回收功能，能够自动管理内存使用。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或关键词）。相比于C++或Java，Python让开发者能够用更少的代码表达想法。
| 特点 | 说明 |
|---|---|
| 简单易学 | 语法简洁优雅，入门容易 |
| 跨平台 | 可以在Windows、Linux、Mac OS等系统运行 |
| 丰富的库 | 拥有庞大的标准库和第三方库 |
| 动态类型 | 无需声明变量类型，自动类型推断 |
| 解释型 | 无需编译，直接运行源代码 |
| 面向对象 | 支持面向对象、过程式和函数式编程 |
| 可扩展性 | 可以使用C/C++编写扩展模块 |
| 可嵌入性 | 可以嵌入到其他应用程序中 |
Python的应用领域非常广泛，几乎涵盖了IT行业的各个方向：
目前Python主要有两个版本分支：
本书所有内容均基于Python 3.x版本，推荐使用Python 3.8或更高版本。
在Windows系统上安装Python的步骤如下：
python --version验证安装大多数Linux发行版已经预装了Python。可以通过以下命令检查和安装：
# 检查Python版本
python3 --version
# Ubuntu/Debian系统
sudo apt update
sudo apt install python3
# CentOS/RHEL系统
sudo yum install python3
macOS通常预装了Python 2.x，可以通过Homebrew安装Python 3：
# 安装Homebrew（如果没有）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# 安装Python 3
brew install python3
PyCharm是JetBrains公司开发的Python IDE，功能强大，适合大型项目开发。
| 版本 | 说明 |
|---|---|
| Community（社区版） | 免费开源，适合基础开发 |
| Professional（专业版） | 付费，功能全面，支持Web开发 |
Visual Studio Code是微软开发的轻量级代码编辑器，通过安装Python扩展可以支持Python开发。
推荐安装的扩展：
Jupyter Notebook是一个交互式编程环境，特别适合数据分析、机器学习和教学演示。
安装方式：
pip install jupyter
jupyter notebook
pip是Python的包管理工具，用于安装和管理Python包。
# 安装包
pip install package_name
# 卸载包
pip uninstall package_name
# 查看已安装的包
pip list
# 升级包
pip install --upgrade package_name
# 导出依赖列表
pip freeze > requirements.txt
# 从文件安装依赖
pip install -r requirements.txt
虚拟环境用于隔离不同项目的依赖，避免版本冲突。
# 创建虚拟环境
python -m venv myenv
# 激活虚拟环境
# Windows
myenv\Scripts\activate
# Linux/Mac
source myenv/bin/activate
# 退出虚拟环境
deactivate
Python最简单的程序就是打印Hello World：
print("Hello, World!")
运行方式：
python进入交互模式，直接输入代码.py文件，用python filename.py执行注释用于提高代码的可读性，Python解释器会忽略注释内容。
# 这是单行注释
"""
这是多行注释
可以跨越多行
"""
'''
也可以使用单引号
创建多行注释
'''
Python使用缩进来表示代码块，而不是使用大括号。缩进可以是空格或Tab，但通常使用4个空格。
if True:
print("True条件为真")
print("这属于if代码块")
else:
print("False条件为假")
注意：缩进必须保持一致，否则会导致SyntaxError错误。
标识符是给变量、函数、类等命名的名字。
命名规则：
Name和name是不同的标识符a-z、A-Z、0-9、_2name是无效的常用命名约定：
| 命名风格 | 说明 | 示例 |
|---|---|---|
| 蛇形命名 | 全小写，单词间用下划线 | my_variable |
| 帕斯卡命名 | 每个单词首字母大写 | MyVariable |
| 驼峰命名 | 第一个单词小写，其余大写 | myVariable |
关键字是Python保留的标识符，不能用作变量名、函数名或类名。
# Python关键字列表
False class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise
Python中有多种内置数据类型：
| 数据类型 | 说明 | 示例 |
|---|---|---|
| int | 整数 | 10, -5, 0 |
| float | 浮点数 | 3.14, -2.5 |
| str | 字符串 | "Hello", 'Python' |
| bool | 布尔值 | True, False |
| complex | 复数 | 3 + 4j |
变量是存储数据的容器，不需要声明类型，Python会自动推断类型。
# 变量赋值
name = "张三" # 字符串
age = 25 # 整数
height = 1.75 # 浮点数
is_student = True # 布尔值
# 多个变量赋值
x, y, z = 1, 2, 3
# 同一变量赋值
a = b = c = 0
字符串是Python中最常用的数据类型之一，可以使用单引号或双引号创建。
# 字符串创建
s1 = 'Hello'
s2 = "World"
s3 = '''多行
字符串'''
# 字符串操作
s = "Python"
print(s[0]) # P（索引访问）
print(s[0:3]) # Pyt（切片）
print(len(s)) # 6（长度）
print(s.upper()) # PYTHON（大写）
print(s.lower()) # python（小写）
print(s.replace("P", "J")) # Jython（替换）
# 字符串格式化
name = "张三"
age = 25
print(f"我叫{name}，今年{age}岁") # f-string格式化
print("我叫{}，今年{}岁".format(name, age)) # format方法
整数是没有小数部分的数值，Python中的整数没有大小限制（取决于计算机内存）。
a = 10
b = -5
c = 0
# 进制表示
binary = 0b1010 # 二进制：10
octal = 0o12 # 八进制：10
hexadecimal = 0xA # 十六进制：10
浮点数是带有小数部分的数值。
a = 3.14
b = -2.5
c = 1.23e5 # 科学计数法：123000.0
布尔类型只有两个值：True和False（注意首字母大写）。
is_active = True
is_deleted = False
# 布尔运算
print(True and False) # False
print(True or False) # True
print(not True) # False
Python提供类型转换函数：
# 转换为整数
int(3.14) # 3
int("10") # 10
# 转换为浮点数
float(10) # 10.0
float("3.14") # 3.14
# 转换为字符串
str(10) # "10"
str(3.14) # "3.14"
# 转换为布尔值
bool(0) # False
bool(1) # True
bool("") # False
bool("abc") # True
| 运算符 | 说明 | 示例 |
|---|---|---|
| + | 加法 | 5 + 3 = 8 |
| - | 减法 | 5 - 3 = 2 |
| * | 乘法 | 5 * 3 = 15 |
| / | 除法 | 5 / 2 = 2.5 |
| // | 整除 | 5 // 2 = 2 |
| % | 取余 | 5 % 2 = 1 |
| ** | 幂运算 | 5 ** 2 = 25 |
a, b = 10, 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.3333...
print(a // b) # 3
print(a % b) # 1
print(a ** b) # 1000
比较运算符返回布尔值。
| 运算符 | 说明 | 示例 |
|---|---|---|
| == | 等于 | 5 == 3 → False |
| != | 不等于 | 5 != 3 → True |
| > | 大于 | 5 > 3 → True |
| < | 小于 | 5 < 3 → False |
| >= | 大于等于 | 5 >= 3 → True |
| <= | 小于等于 | 5 <= 3 → False |
| 运算符 | 说明 | 示例 |
|---|---|---|
| = | 简单赋值 | a = 5 |
| += | 加法赋值 | a += 3 等价于 a = a + 3 |
| -= | 减法赋值 | a -= 3 等价于 a = a - 3 |
| *= | 乘法赋值 | a *= 3 等价于 a = a * 3 |
| /= | 除法赋值 | a /= 3 等价于 a = a / 3 |
| //= | 整除赋值 | a //= 3 等价于 a = a // 3 |
| %= | 取余赋值 | a %= 3 等价于 a = a % 3 |
| **= | 幂赋值 | a **= 3 等价于 a = a ** 3 |
| 运算符 | 说明 | 示例 |
|---|---|---|
| and | 逻辑与 | True and False → False |
| or | 逻辑或 | True or False → True |
| not | 逻辑非 | not True → False |
# 短路运算
a = 5
b = 3
print(a > 0 and b > 0) # True
print(a < 0 or b > 0) # True
print(not (a > 0)) # False
| 运算符 | 说明 |
|---|---|
| in | 如果在序列中找到返回True |
| not in | 如果在序列中未找到返回True |
s = "Python"
print("P" in s) # True
print("p" in s) # False（区分大小写）
print("th" in s) # True
| 运算符 | 说明 |
|---|---|
| is | 判断两个对象是否是同一个对象 |
| is not | 判断两个对象是否不是同一个对象 |
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is b) # True（同一个对象）
print(a is c) # False（不同对象，内容相同）
print(a == c) # True（值相等）
# 基本语法
age = 18
if age >= 18:
print("成年人")
age = 16
if age >= 18:
print("成年人")
else:
print("未成年")
score = 85
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
elif score >= 60:
grade = "D"
else:
grade = "F"
print(f"成绩等级：{grade}")
age = 25
has_license = True
if age >= 18:
if has_license:
print("可以开车")
else:
print("需要考驾照")
else:
print("年龄不够，不能开车")
for循环用于遍历序列（如列表、字符串、元组、字典等）中的元素。
# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
# 遍历字符串
for char in "Python":
print(char)
# 使用range函数
for i in range(5):
print(i) # 0, 1, 2, 3, 4
# range(start, stop, step)
for i in range(0, 10, 2):
print(i) # 0, 2, 4, 6, 8
while循环在条件为True时重复执行代码块。
# 基本while循环
count = 0
while count < 5:
print(count)
count += 1
# while-else结构
n = 0
while n < 3:
print(n)
n += 1
else:
print("循环结束")
| 语句 | 说明 |
|---|---|
| break | 终止循环 |
| continue | 跳过本次循环，继续下一次循环 |
| pass | 空操作，占位符 |
# break示例
for i in range(10):
if i == 5:
break
print(i) # 0, 1, 2, 3, 4
# continue示例
for i in range(5):
if i == 2:
continue
print(i) # 0, 1, 3, 4（跳过2）
# pass示例
for i in range(5):
pass # 暂时不执行任何操作
列表推导式是创建列表的简洁方式。
# 基本语法
squares = [x**2 for x in range(10)]
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 带条件过滤
evens = [x for x in range(10) if x % 2 == 0]
print(evens) # [0, 2, 4, 6, 8]
# 嵌套列表推导式
matrix = [[i*3+j for j in range(3)] for i in range(3)]
print(matrix) # [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
函数是组织代码的基本单元，可以提高代码的复用性和可读性。
# 定义函数
def greet(name):
"""这是一个问候函数"""
return f"Hello, {name}!"
# 调用函数
message = greet("张三")
print(message) # Hello, 张三!
def func(a, b, c):
print(f"a={a}, b={b}, c={c}")
# 位置参数
func(1, 2, 3) # a=1, b=2, c=3
# 关键字参数
func(a=1, b=2, c=3) # a=1, b=2, c=3
# 混合使用
func(1, b=2, c=3) # a=1, b=2, c=3
def greet(name, greeting="Hello"):
return f"{greeting}, {name}!"
print(greet("张三")) # Hello, 张三!
print(greet("李四", "Hi")) # Hi, 李四!
# *args - 接收任意数量的位置参数
def sum_numbers(*args):
total = 0
for num in args:
total += num
return total
print(sum_numbers(1, 2, 3)) # 6
print(sum_numbers(1, 2, 3, 4)) # 10
# **kwargs - 接收任意数量的关键字参数
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="张三", age=25)
# name: 张三
# age: 25
# 单个返回值
def add(a, b):
return a + b
# 多个返回值（返回元组）
def divide(a, b):
quotient = a // b
remainder = a % b
return quotient, remainder
q, r = divide(10, 3) # q=3, r=1
| 作用域 | 说明 |
|---|---|
| L（Local） | 局部作用域，函数内部 |
| E（Enclosing） | 闭包作用域 |
| G（Global） | 全局作用域，模块级别 |
| B（Built-in） | 内置作用域 |
# 全局变量
global_var = "全局"
def test():
# 局部变量
local_var = "局部"
print(global_var) # 可以访问全局变量
# 使用global声明修改全局变量
global global_var
global_var = "修改后的全局"
def test2():
print(global_var) # 仍然是原来的值
lambda函数是简短的匿名函数。
# 基本语法
square = lambda x: x ** 2
print(square(5)) # 25
# 多参数
add = lambda x, y: x + y
print(add(3, 4)) # 7
# 结合内置函数使用
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # [1, 4, 9, 16, 25]
# 排序使用
points = [(1, 2), (3, 1), (2, 3)]
points_sorted = sorted(points, key=lambda x: x[1])
print(points_sorted) # [(3, 1), (1, 2), (2, 3)]
# 导入整个模块
import math
print(math.pi)
print(math.sqrt(16))
# 导入特定函数/变量
from math import pi, sqrt
print(pi)
print(sqrt(16))
# 给导入的内容起别名
import numpy as np
from datetime import datetime as dt
| 模块 | 说明 |
|---|---|
| os | 操作系统接口 |
| sys | 系统参数和函数 |
| time | 时间相关功能 |
| datetime | 日期和时间处理 |
| json | JSON编解码 |
| re | 正则表达式 |
| collections | 容器数据类型 |
| itertools | 迭代器工具 |
| functools | 函数式编程工具 |
列表是最常用的可变序列，可以存储任意类型的元素。
# 创建列表
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", True, 3.14]
# 索引访问
print(fruits[0]) # apple
print(fruits[-1]) # cherry（最后一个元素）
# 切片操作
print(numbers[1:4]) # [2, 3, 4]
print(numbers[::2]) # [1, 3, 5]（步长为2）
# 修改列表
fruits[0] = "orange"
fruits.append("grape") # 末尾添加
fruits.insert(1, "mango") # 指定位置插入
fruits.remove("banana") # 删除指定元素
popped = fruits.pop() # 弹出并返回最后一个元素
# 列表操作
print(len(fruits)) # 长度
print("apple" in fruits) # 成员检查
fruits.sort() # 排序（原地修改）
fruits.reverse() # 反转（原地修改）
元组是不可变的列表，创建后不能修改。
# 创建元组
coordinates = (10, 20)
point = (1,) # 单元素元组需要逗号
empty = ()
# 索引和切片
print(coordinates[0]) # 10
print(coordinates[0:2]) # (10, 20)
# 元组解包
x, y = coordinates
print(f"x={x}, y={y}")
# 元组不可变性
# coordinates[0] = 15 # TypeError
字典是键值对的无序集合，键必须是不可变类型。
# 创建字典
person = {
"name": "张三",
"age": 25,
"city": "北京"
}
# 访问值
print(person["name"]) # 张三
print(person.get("gender", "未知")) # 未知（默认值）
# 修改字典
person["age"] = 26 # 修改值
person["gender"] = "男" # 添加新键值对
person.pop("city") # 删除键值对
# 遍历字典
for key in person:
print(f"{key}: {person[key]}")
for key, value in person.items():
print(f"{key}: {value}")
# 字典方法
print(person.keys()) # dict_keys(['name', 'age', 'gender'])
print(person.values()) # dict_values(['张三', 26, '男'])
print(person.items()) # dict_items([('name', '张三'), ...])
集合是无序且不重复的元素集合。
# 创建集合
fruits = {"apple", "banana", "cherry"}
numbers = set([1, 2, 3, 2, 1]) # {1, 2, 3}
# 添加元素
fruits.add("orange")
fruits.update(["grape", "melon"])
# 删除元素
fruits.remove("banana") # 移除指定元素，不存在会报错
fruits.discard("banana") # 移除指定元素，不存在不报错
fruits.pop() # 随机移除并返回一个元素
# 集合运算
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
print(set1 | set2) # 并集：{1, 2, 3, 4, 5, 6}
print(set1 & set2) # 交集：{3, 4}
print(set1 - set2) # 差集：{1, 2}
print(set1 ^ set2) # 对称差集：{1, 2, 5, 6}
| 数据结构 | 有序 | 可变 | 索引访问 | 用途 |
|---|---|---|---|---|
| list | 是 | 是 | 是 | 存储有序可变序列 |
| tuple | 是 | 否 | 是 | 存储有序不可变数据 |
| dict | 否（3.7+有序） | 是 | 键访问 | 键值映射 |
| set | 否 | 是 | 否 | 存储无序不重复元素 |
类是对一类事物的抽象描述，而对象是类的实例。
# 定义类
class Person:
"""人类"""
# 类属性
species = "Human"
# 初始化方法（构造函数）
def __init__(self, name, age):
# 实例属性
self.name = name
self.age = age
# 实例方法
def say_hello(self):
return f"Hello, I'm {self.name}"
def __str__(self):
return f"Person(name={self.name}, age={self.age})"
# 创建对象
person1 = Person("张三", 25)
person2 = Person("李四", 30)
# 访问属性和方法
print(person1.name) # 张三
print(person1.say_hello()) # Hello, I'm 张三
print(person1) # Person(name=张三, age=25)
继承允许创建基于现有类的新类。
# 父类
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
pass
# 子类
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow!"
# 创建子类对象
dog = Dog("旺财")
cat = Cat("咪咪")
print(dog.speak()) # Woof!
print(cat.speak()) # Meow!
多态允许不同类的对象对同一消息做出不同的响应。
class Shape:
def area(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
# 多态调用
shapes = [Rectangle(3, 4), Circle(5)]
for shape in shapes:
print(shape.area()) # 12, 78.5
封装是将数据和操作隐藏在类内部，只对外提供必要的接口。
class BankAccount:
def __init__(self, initial_balance=0):
# 私有属性（以双下划线开头）
self.__balance = initial_balance
# 公开方法
def deposit(self, amount):
if amount > 0:
self.__balance += amount
return True
return False
def withdraw(self, amount):
if 0 < amount <= self.__balance:
self.__balance -= amount
return True
return False
def get_balance(self):
return self.__balance
# 使用
account = BankAccount(1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance()) # 1300
# print(account.__balance) # 错误，无法直接访问私有属性
class MyClass:
class_attr = "类属性"
def __init__(self, value):
self.instance_attr = value
# 实例方法
def instance_method(self):
return f"实例方法，访问{self.instance_attr}"
# 类方法
@classmethod
def class_method(cls):
return f"类方法，访问{cls.class_attr}"
# 静态方法
@staticmethod
def static_method():
return "静态方法，不访问类或实例属性"
# 读取整个文件
with open("file.txt", "r", encoding="utf-8") as f:
content = f.read()
print(content)
# 逐行读取
with open("file.txt", "r", encoding="utf-8") as f:
for line in f:
print(line.strip())
# 读取所有行到列表
with open("file.txt", "r", encoding="utf-8") as f:
lines = f.readlines()
# 写入文件（覆盖）
with open("file.txt", "w", encoding="utf-8") as f:
f.write("Hello, World!\n")
f.write("第二行\n")
# 追加模式
with open("file.txt", "a", encoding="utf-8") as f:
f.write("追加的内容\n")
try:
result = 10 / 0
except ZeroDivisionError:
print("不能除以零")
except Exception as e:
print(f"发生错误：{e}")
try:
f = open("file.txt", "r")
content = f.read()
except FileNotFoundError:
print("文件不存在")
else:
print("文件读取成功")
finally:
try:
f.close()
except:
pass
def divide(a, b):
if b == 0:
raise ValueError("除数不能为零")
return a / b
try:
result = divide(10, 0)
except ValueError as e:
print(e) # 除数不能为零
import os
# 文件和目录操作
os.listdir(".") # 列出当前目录内容
os.getcwd() # 获取当前工作目录
os.chdir("path") # 改变当前目录
os.mkdir("dirname") # 创建目录
os.makedirs("a/b/c") # 创建多级目录
os.remove("filename") # 删除文件
os.rmdir("dirname") # 删除空目录
# 路径操作
os.path.join("dir", "file") # 拼接路径
os.path.exists("path") # 检查路径是否存在
os.path.isfile("path") # 检查是否为文件
os.path.isdir("path") # 检查是否为目录
from datetime import datetime, timedelta
# 获取当前时间
now = datetime.now()
print(now) # 2024-01-15 10:30:45.123456
# 格式化时间
print(now.strftime("%Y-%m-%d %H:%M:%S"))
print(now.strftime("%A, %B %d, %Y"))
# 解析时间字符串
dt = datetime.strptime("2024-01-15 10:30:00", "%Y-%m-%d %H:%M:%S")
# 时间加减
tomorrow = now + timedelta(days=1)
yesterday = now - timedelta(days=1)
import json
# Python对象转JSON
data = {"name": "张三", "age": 25}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
# JSON转Python对象
parsed = json.loads(json_str)
# 文件操作
with open("data.json", "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
with open("data.json", "r", encoding="utf-8") as f:
data = json.load(f)
import re
# 匹配
pattern = r"\d+" # 匹配数字
text = "我有3个苹果和5个橙子"
result = re.findall(pattern, text)
print(result) # ['3', '5']
# 替换
new_text = re.sub(r"\d+", "X", text)
print(new_text) # 我有X个苹果和X个橙子
# 分割
parts = re.split(r"\s+", "hello world python")
print(parts) # ['hello', 'world', 'python']
# 提取分组
pattern = r"(\d{4})-(\d{2})-(\d{2})"
date = "2024-01-15"
match = re.match(pattern, date)
if match:
print(match.group(1)) # 2024
print(match.group(2)) # 01
print(match.group(3)) # 15
本教程涵盖了Python编程的基础知识，从环境搭建到高级特性，包括：
掌握这些基础知识后，您可以继续学习Python的进阶主题，如装饰器、生成器、上下文管理器、并发编程等。Python的学习路径非常丰富，建议结合实际项目不断练习和深化理解。