Python基础全攻略：从入门到精通

基本语法

缩进：用缩进来表示代码块，通常用4个空格

注释：单行注释用#，多行注释用'''或"""

语句结束：通常每行一条语句，也可用分号分隔，但不推荐

变量和数据类型

变量：无需声明类型，直接赋值

常见数据类型：

数字：整数（int）、浮点数（float）、复数（complex）

字符串（str）：用单引号、双引号或三引号

布尔型（bool）：True和False

空值（None）

类型转换：int(), float(), str(), bool()等

运算符

算术运算符：+, -, *, /, //（整除）, %（取余）, **（幂）

比较运算符：==, !=, >, <, >=, <=

逻辑运算符：and, or, not

赋值运算符：=, +=, -=等

身份运算符：is, is  not

成员运算符：in, not in

数据结构

列表（list）：有序，可变，用[]定义

元组（tuple）：有序，不可变，用()定义

集合（set）：无序，不重复，用{}或set()定义

字典（dict）：键值对，无序，用{key: value}定义

流程控制

条件语句：if, elif, else

循环语句：

for循环：遍历序列（如列表、字符串）或可迭代对象

while循环：在条件为真时重复执行

循环控制：break（终止循环）、continue（跳过本次循环）

函数

定义：使用def关键字

参数：位置参数、默认参数、可变参数（*args）、关键字参数（**kwargs）

返回值：用return返回，可以返回多个值（实际上是一个元组）

作用域：局部变量和全局变量，使用global声明全局变量

匿名函数：lambda函数

模块和包

模块：一个.py文件，包含Python代码

导入模块：import module，from module import something

包：包含多个模块的目录，必须有__init__.py文件

常用标准库：os, sys, math, datetime, random, json等

文件操作

打开文件：open(file, mode)，模式有r（读）、w（写）、a（追加）等

读取文件：read(), readline(), readlines()

写入文件：write(), writelines()

关闭文件：close()，推荐使用with语句自动关闭

异常处理

使用try-except块捕获异常

可以指定异常类型，或用Exception捕获所有异常

可选的else（没有异常时执行）和finally（无论是否异常都执行）

面向对象编程（OOP）

类（class）：用class定义，类名通常首字母大写

属性：实例属性、类属性

方法：实例方法（第一个参数为self）、类方法（用@classmethod装饰，第一个参数为cls）、静态方法（用@staticmethod装饰，无特殊参数）

继承：子类继承父类，可以重写方法

多态：不同类的对象对同一消息做出响应

封装：将数据和方法包装在类中

常用内置函数

输入输出：input(), print()

数学：abs(), round(), min(), max(), sum()

迭代：range(), enumerate(), zip()

类型判断：type(), isinstance()

其他：len(), sorted(), reversed()等

列表推导式、字典推导式、集合推导式

快速生成数据结构的简洁语法

例如：[x**2 for x in range(10) if x%2==0]

迭代器和生成器

迭代器：实现了__iter__()和__next__()方法的对象

生成器：使用yield语句的函数，返回生成器对象，可以迭代

装饰器

用于修改或增强函数的功能，使用@语法

上下文管理器

用于管理资源，如文件打开关闭，使用with语句

常用标准库和第三方库

标准库：sys, os, re, math, datetime, json, csv, urllib等

第三方库：requests, numpy, pandas, matplotlib, django等（需安装）

虚拟环境

创建独立的Python环境，用于管理项目依赖

代码规范

PEP 8：Python代码风格指南

调试和测试

调试：使用print、logging、pdb等

测试：unittest、pytest等测试框架

以上是Python基础的主要知识点，每个知识点都可以展开很多内容

Python基础全面总结

1. Python
   解释型语言

变量类型在运行时确定

支持面向对象编程范式

语法简洁

2. 基本语法
   2.1 注释

单行注释

"""
多行注释（文档字符串）
可以写多行
"""

'''
这也是多行注释
'''
2.2 变量和命名规则

变量命名规则

变量名 = 值 # 使用字母、数字、下划线，不能以数字开头
my_variable = 10
myVariable = 20 # 驼峰命名法
MY_CONSTANT = 30 # 常量（约定大写）
2.3 关键字
Python的关键字
import keyword
print(keyword.kwlist)
['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']

3. 数据类型
   3.1 基本数据类型

数值类型
整数 = 10           int
浮点数 = 3.14       float
复数 = 1 + 2j       complex

布尔类型
真 = True           bool (首字母大写)
假 = False

字符串
字符串 = "Hello"    str
字符串2 = 'World'
多行字符串 = """多行
字符串"""

空值
空值 = None        NoneType

3.2 复合数据类型

列表（有序，可变）
列表 = [1, 2, 3, "hello", True]

元组（有序，不可变）
元组 = (1, 2, 3, "world")

字典（键值对，无序，键不可变）
字典 = {"name": "张三", "age": 20}

集合（无序，元素唯一）
集合 = {1, 2, 3, 3} # {1, 2, 3}
冻结集合 = frozenset([1, 2, 3])
4. 运算符

4.1 算术运算符

• 加

• 减

• 乘
  / 除法（返回浮点数）
  // 整除
  % 取余
  ** 幂运算
  4.2 比较运算符

== 等于
!= 不等于

大于
< 小于
= 大于等于
<= 小于等于
4.3 逻辑运算符

and 与
or 或
not 非
4.4 赋值运算符

= 赋值
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
//= 整除等于
%= 取余等于
**= 幂等于
4.5 位运算符

& 按位与
| 按位或
^ 按位异或
~ 按位取反
<< 左移

右移
4.6 成员运算符

in 在序列中
not in 不在序列中

4.7 身份运算符

is 是同一个对象
is not 不是同一个对象
5. 流程控制
5.1 条件语句

if语句

if 条件1:
代码块1
elif 条件2:
代码块2
else:
代码块3

示例
age = 18
if age < 18:
print("未成年")
elif age >= 18 and age < 60:
print("成年")
else:
print("老年")

三元表达式
结果 = 值1 if 条件 else 值2
5.2 循环语句

while循环

while 条件:
代码块
if 退出条件:
break # 跳出循环
if 跳过条件:
continue # 跳过本次循环

for循环

for 变量 in 序列:
代码块

range()函数

for i in range(5): # 0到4
print(i)

for i in range(2, 10): # 2到9
print(i)

for i in range(0, 10, 2): # 0到9，步长为2
print(i)

5.3 循环控制

break: 完全结束循环

continue: 跳过本次循环

else: 循环正常结束执行（没有被break中断）

for i in range(5):
if i == 3:
break
print(i)
else:
print("循环正常结束")
6. 数据结构操作

6.1 字符串操作

s = "Hello World"
索引和切片
print(s[0]) # H
print(s[-1]) # d
print(s[0:5]) # Hello
print(s[6:]) # World
print(s[::-1]) # dlroW olleH（反转）

常用方法

s.upper() # 转大写
s.lower() # 转小写
s.strip() # 去除两边空白
s.split() # 分割字符串
s.join(list) # 连接字符串
s.replace(old, new) # 替换
s.find(sub) # 查找子串
6.2 列表操作

my_list = [1, 2, 3, 4, 5]

增删改查

my_list.append(6) # 末尾添加
my_list.insert(0, 0) # 指定位置插入
my_list.extend([7, 8]) # 扩展列表
my_list.remove(3) # 删除元素
del my_list[0] # 删除索引位置元素
value = my_list.pop() # 弹出最后一个元素
value = my_list.pop(1) # 弹出指定位置元素

其他操作

my_list.sort() # 排序（原地）
sorted_list = sorted(my_list) # 返回新列表
my_list.reverse() # 反转
len(my_list) # 长度
6.3 字典操作

my_dict = {"name": "Tom", "age": 25}

增删改查

my_dict["gender"] = "male" # 添加/修改
del my_dict["age"] # 删除键
value = my_dict.get("name") # 获取值（键不存在返回None）
value = my_dict.get("key", "default") # 设置默认值

遍历

for key in my_dict: # 遍历键
print(key)

for value in my_dict.values(): # 遍历值
print(value)

for key, value in my_dict.items(): # 遍历键值对
print(key, value)

6.4 集合操作

set1 = {1, 2, 3}
set2 = {3, 4, 5}

集合运算

set1 | set2 # 并集 {1, 2, 3, 4, 5}
set1 & set2 # 交集 {3}
set1 - set2 # 差集 {1, 2}
set1 ^ set2 # 对称差集 {1, 2, 4, 5}
7. 函数

7.1 函数定义
def 函数名(参数1, 参数2=默认值):
"""函数文档字符串"""
代码块
return 返回值

示例

def greet(name, greeting="Hello"):
"""向某人问好"""
return f"{greeting}, {name}!"

result = greet("Alice") # Hello, Alice!
result2 = greet("Bob", "Hi") # Hi, Bob!
7.2 参数类型

位置参数

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

默认参数

def func(a, b=10):
return a + b

可变位置参数 (*args)

def func(*args):
return sum(args)

可变关键字参数 (**kwargs)

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

混合使用

def func(a, b=10, *args, **kwargs):
pass

7.3 作用域

局部变量 vs 全局变量

global_var = 10

def my_func():
local_var = 20 # 局部变量
global global_var # 声明使用全局变量
global_var = 30 # 修改全局变量

nonlocal关键字

def outer():
x = 10
def inner():
nonlocal x # 声明使用外层函数的变量
x = 20
inner()
print(x) # 20

7.4 匿名函数

lambda表达式

add = lambda x, y: x + y
result = add(3, 5) # 8

常用于高阶函数

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers)) # [1, 4, 9, 16, 25]
even = list(filter(lambda x: x % 2 == 0, numbers)) # [2, 4]
8. 面向对象编程
8.1 类和对象

class Person:
# 类属性
species = "人类"

# 构造方法
def __init__(self, name, age):# 实例属性self.name = nameself.age = age# 实例方法
def introduce(self):return f"我叫{self.name}，今年{self.age}岁"# 类方法
@classmethod
def get_species(cls):return cls.species# 静态方法
@staticmethod
def is_adult(age):return age >= 18

创建对象

p = Person("张三", 20)
print(p.introduce())
print(Person.get_species())
print(Person.is_adult(20))
8.2 继承

class Animal:
def init(self, name):
self.name = name

def speak(self):pass

class Dog(Animal):
def init(self, name, breed):
super().init(name) # 调用父类构造方法
self.breed = breed

def speak(self):  # 方法重写return "汪汪！"

多态

def animal_sound(animal):
print(animal.speak())

dog = Dog("旺财", "金毛")
animal_sound(dog) # 汪汪！
8.3 特殊方法（魔术方法）

class MyClass:
def init(self, value):
self.value = value

def __str__(self):  # 字符串表示return f"MyClass({self.value})"def __repr__(self):  # 解释器表示return f"MyClass({self.value})"def __len__(self):return len(self.value)def __add__(self, other):return MyClass(self.value + other.value)def __eq__(self, other):return self.value == other.value

9. 模块和包
   9.1 导入模块

导入整个模块

import math
print(math.pi)

导入特定函数

from math import sqrt, pow
print(sqrt(16))

导入并重命名

import numpy as np
from math import sqrt as 平方根

导入所有（不推荐）

from math import *
9.2 创建模块和包
text

项目结构

my_package/
init.py # 包初始化文件
module1.py # 模块1
module2.py # 模块2
subpackage/ # 子包
init.py
module3.py
10. 异常处理

try:
# 可能出错的代码
result = 10 / 0
except ZeroDivisionError as e:
# 处理特定异常
print(f"除零错误: {e}")
except (TypeError, ValueError) as e:
# 处理多个异常
print(f"类型或值错误: {e}")
except Exception as e:
# 处理所有其他异常
print(f"未知错误: {e}")
else:
# 没有异常时执行
print("执行成功")
finally:
# 无论是否异常都执行
print("清理工作")

抛出异常

def divide(a, b):
if b == 0:
raise ValueError("除数不能为零")
return a / b

自定义异常

class MyError(Exception):
def init(self, message):
self.message = message
11. 文件操作

打开文件

with open("file.txt", "r", encoding="utf-8") as f:
content = f.read() # 读取全部内容
# content = f.readline() # 读取一行
# lines = f.readlines() # 读取所有行（列表）

写入文件

with open("file.txt", "w", encoding="utf-8") as f:
f.write("Hello\n")
f.writelines(["Line1\n", "Line2\n"])

追加模式

with open("file.txt", "a", encoding="utf-8") as f:
f.write("追加内容\n")

二进制文件

with open("image.jpg", "rb") as f:
data = f.read()
12. 常用内置函数
12.1 类型转换

int("10") # 10
float("3.14") # 3.14
str(100) # "100"
list((1,2,3)) # [1, 2, 3]
tuple([1,2,3]) # (1, 2, 3)
dict([("a",1), ("b",2)]) # {"a":1, "b":2}
set([1,2,2,3]) # {1, 2, 3}
bool(0) # False
12.2 数学运算

abs(-5) # 5
round(3.14159, 2) # 3.14
max(1, 2, 3) # 3
min(1, 2, 3) # 1
sum([1, 2, 3]) # 6
pow(2, 3) # 8
divmod(10, 3) # (3, 1) 商和余数
12.3 序列操作

len([1,2,3]) # 3
sorted([3,1,2]) # [1, 2, 3]
reversed([1,2,3]) # 反向迭代器
enumerate(["a","b"]) # 枚举：[(0,'a'), (1,'b')]
zip([1,2], ["a","b"]) # 打包：[(1,'a'), (2,'b')]

all([True, True, False]) # False
any([False, False, True]) # True

range(5) # range(0, 5)
12.4 输入输出

name = input("请输入姓名: ") # 获取输入
print("Hello", name) # 输出
print("Hello", name, sep=", ", end="!\n") # 自定义分隔符和结束符

格式化输出

name = "Alice"
age = 20
print(f"{name}今年{age}岁") # f-string（推荐）
print("{}今年{}岁".format(name, age)) # format方法
print("%s今年%d岁" % (name, age)) # %格式化
13. 高级特性
13.1 列表推导式

基本形式

squares = [x**2 for x in range(10)]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

带条件

evens = [x for x in range(10) if x % 2 == 0]

[0, 2, 4, 6, 8]

多重循环

pairs = [(x, y) for x in range(3) for y in range(3)]

[(0,0), (0,1), (0,2), (1,0), ...]

字典推导式

square_dict = {x: x**2 for x in range(5)}

集合推导式

unique_lengths = {len(x) for x in ["apple", "banana", "cherry"]}

13.2 生成器

生成器表达式（惰性求值）

gen = (x**2 for x in range(10))
for val in gen:
print(val)

生成器函数

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

for num in fibonacci(100):
print(num)
13.3 装饰器

def timer(func):
"""计时装饰器"""
def wrapper(args, **kwargs):
import time
start = time.time()
result = func(args, **kwargs)
end = time.time()
print(f"{func.name}执行时间: {end-start:.4f}秒")
return result
return wrapper

@timer
def slow_function():
import time
time.sleep(1)
return "完成"

带参数的装饰器

def repeat(n):
def decorator(func):
def wrapper(args, **kwargs):
for _ in range(n):
result = func(args, **kwargs)
return result
return wrapper
return decorator

@repeat(3)
def say_hello():
print("Hello!")
13.4 上下文管理器

使用with语句

with open("file.txt", "r") as f:
content = f.read()

自定义上下文管理器

class MyContextManager:
def enter(self):
print("进入上下文")
return self

def __exit__(self, exc_type, exc_val, exc_tb):print("退出上下文")if exc_type:print(f"异常类型: {exc_type}")return True  # 抑制异常

with MyContextManager() as cm:
print("在上下文中执行")
# raise ValueError("测试异常")
14. 标准库常用模块
14.1 os模块（操作系统接口）

import os

os.getcwd() # 当前工作目录
os.listdir('.') # 列出目录内容
os.mkdir('new_dir') # 创建目录
os.path.exists('file.txt') # 检查路径是否存在
os.path.join('dir', 'file.txt') # 路径拼接
14.2 sys模块（系统参数）

import sys

sys.argv # 命令行参数
sys.path # Python搜索路径
sys.exit(0) # 退出程序
sys.version # Python版本
14.3 datetime模块（日期时间）

from datetime import datetime, date, timedelta

now = datetime.now() # 当前时间
today = date.today() # 今天日期
formatted = now.strftime("%Y-%m-%d %H:%M:%S") # 格式化
tomorrow = today + timedelta(days=1) # 明天
14.4 json模块（JSON处理）

import json

data = {"name": "Alice", "age": 20}
json_str = json.dumps(data) # 字典转JSON字符串
data2 = json.loads(json_str) # JSON字符串转字典

文件操作

with open("data.json", "w") as f:
json.dump(data, f) # 写入JSON文件

with open("data.json", "r") as f:
data3 = json.load(f) # 读取JSON文件
14.5 re模块（正则表达式）

import re

pattern = r'\d+' # 匹配数字
text = "abc123def456"
result = re.findall(pattern, text) # ['123', '456']

匹配对象

match = re.search(r'(\d+)-(\d+)', '电话: 010-12345678')
if match:
print(match.group()) # 010-12345678
print(match.group(1)) # 010
print(match.group(2)) # 12345678
15. Pythonic编程技巧
15.1 交换变量

a, b = 1, 2
a, b = b, a # a=2, b=1
15.2 链式比较

x = 5
if 0 < x < 10:
print("x在0和10之间")
15.3 序列解包
列表解包 first, *middle, last = [1, 2, 3, 4, 5]   first=1, middle=[2,3,4], last=5

字典解包 dict1 = {"a": 1, "b": 2} dict2 = {"c": 3, **dict1}   {"c":3, "a":1, "b":2}

15.4 条件表达式
传统写法 if score >= 60: result = "及格" else: result = "不及格"

Pythonic写法 result = "及格" if score >= 60 else "不及格"

15.5 遍历索引和值
传统写法 for i in range(len(items)): print(i, items[i])

Pythonic写法 for i, item in enumerate(items): print(i, item)

15.6 遍历字典
同时获取键和值 for key, value in my_dict.items(): print(key, value)

16. 最佳实践
    16.1 代码规范（PEP 8）
    缩进：4个空格

行长度：不超过79字符

空行：函数间2行，类方法间1行

导入：按标准库、第三方库、本地库分组

命名：

变量/函数：snake_case

类：CamelCase

常量：UPPER_CASE

16.2 文档字符串
def calculate_sum(a, b):
    计算两个数的和
    参数:
    a -- 第一个数
    b -- 第二个数
    返回:
    两个数的和
    return a + b

16.3 异常处理原则
只捕获你能处理的异常

使用具体的异常类型

不要过度使用try-except

记录异常信息