Python 基础知识

发表于 | 分类于

本文系统地梳理了 Python 的基础知识，非常适合新手从零开始学习和查阅。文章涵盖了基本数据类型、流程控制、函数、面向对象、正则表达式、网络编程等核心内容。

1. Python 简介

Python 是一门先编译后解释的语言。

  • 编译型语言：在程序执行之前，先通过编译器将程序翻译成机器语言（例如 C 语言）。运行时不需要再次翻译，执行速度快。
  • 解释型语言：在程序运行时，通过解释器逐行对程序作出解释并直接运行（例如 Ruby）。
  • Python 的执行过程：Python 运行时，会先将代码编译为 PyCodeObject 保存在内存中。程序运行结束时，解释器会将这些内容写回到 .pyc 文件中，这就是 Python 的持久化保存方式。第二次运行时，如果找到 .pyc 文件，则直接载入。

执行 Python 程序的三种常见方式：

  1. 使用 Python 解释器
  2. 交互式运行 (REPL)
  3. 使用 IDE 运行（如 PyCharm, VSCode）

2. Python 基本数据类型

整数 (int) 与浮点数 (float)

  • 整数运算永远是精确的。
  • 浮点数运算可能会有精度问题（四舍五入）。
  • / 表示常规除法（结果为浮点数，如 2 / 2 结果为 1.0）。
  • // 表示整除（只保留整数部分，如 3 // 2 结果为 1）。
  • 科学计数法：1.23x10^9 就是 1.23e9，0.000012 写成 1.2e-5。

进制

Python 中默认为 10 进制。

  • 2 进制：用 0b 表示，例如 0b10 即为 2。
  • 8 进制：用 0o 表示，例如 0o10 即为 8。
  • 16 进制：用 0x 表示，例如 0x10 即为 16。
1
2
3
4
bin()  # 转化为 2 进制
oct()  # 转化为 8 进制
int()  # 转化为 10 进制
hex()  # 转化为 16 进制

布尔值 (bool)

布尔值用于表示真（True）和假（False）。
在 Python 中，非零数字、非空字符串/列表/字典通常被视为 True。
只有 bool(0) 和空数据（如 "", [], {}）以及 None 会被转换为 False。

1
2
3
4
5
6
bool(1)      # True
bool(0)      # False
bool('abc')  # True
bool('')     # False
bool([])     # False
bool(None)   # False

字符串 (str)

字符串可以用单引号 ''、双引号 "" 或三引号 ''' ''' 表示。三引号通常用于多行字符串或文档注释。
如果字符串内本身包含引号，可以使用另一种引号包裹，或者使用反斜杠 \ 转义。

1
2
3
# 换行与转义
print('hello \n world') # \n 会被转义为换行
print(r'hello \n world') # r 表示原始字符串，不进行转义

字符串的切片与操作：
字符串可以通过索引访问，并支持切片。

1
2
3
4
5
c = 'hello world'
c[0:5]    # 'hello'
c[0:-1]   # 'hello worl' (不包含最后一个字符)
c[6:]     # 'world'
c * 3     # 'hello worldhello worldhello world'

列表 (list) 和 元组 (tuple)

  • 列表 (list)：使用 [] 表示，是有序且可变的集合。
  • 元组 (tuple)：使用 () 表示，是有序但不可变的集合。
1
2
3
4
5
my_list = [1, 2, 'hello']
my_list[0] = 100 # 列表可以修改

my_tuple = (1, 2, 3)
# my_tuple[0] = 10 # 错误！元组不可修改

集合 (set) 和 字典 (dict)

  • 集合 (set)：使用 {} 表示，无序且不重复。空集合用 set() 表示。
  • 字典 (dict)：使用 {key: value} 表示，通过 key 访问 value。key 必须是不可变类型（如 int, str, tuple），且不能重复。
1
2
3
4
5
6
7
8
9
10
# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 - set2) # 差集: {1, 2}
print(set1 & set2) # 交集: {3}
print(set1 | set2) # 并集: {1, 2, 3, 4, 5}

# 字典操作
my_dict = {'name': 'WeiLai', 'age': 18}
print(my_dict['name']) # 'WeiLai'

3. 变量与运算符

变量命名规则

  1. 由字母、数字、下划线 _ 组成。
  2. 首字母不能为数字。
  3. 变量区分大小写。
  4. 不要使用 Python 的保留关键字作为变量名。

常用运算符

  • 算术运算符：+ (加), - (减), * (乘), / (除), // (整除), % (取模/余数), ** (幂运算)。
  • 比较运算符：==, !=, >, <, >=, <=。返回布尔值。
  • 赋值运算符：=, +=, -=, *=, /= 等。
  • 逻辑运算符：and (与), or (或), not (非)。
  • 成员运算符：in, not in。判断元素是否在序列中。
  • 身份运算符：is, is not。判断两个标识符是否引用同一个对象（即内存地址是否相同）。

注意 is 与 == 的区别：
is 用于判断两个变量是否引用同一个对象（比较内存地址）。
== 用于判断两个变量的值是否相等。

1
2
3
4
5
6
7
a = [1, 2, 3]
b = a
c = a[:] # 拷贝了 a 的值，但在内存中是新的对象

print(b is a) # True
print(c is a) # False
print(c == a) # True

4. 流程控制语句

条件语句 (if-elif-else)

Python 中使用缩进来划分代码块，没有花括号 {}。

1
2
3
4
5
6
7
8
9
10
grade = 85

if grade >= 90:
    print('优秀')
elif grade >= 80:
    print('良好')
elif grade >= 60:
    print('中等')
else:
    print('不及格')

说明：Python 没有内置的 switch/case 语法。如果遇到需要占位的情况，可以使用 pass 关键字。

1
2
3
# pass 的使用
if grade == 100:
    pass # 占位符，什么也不做

循环语句 (for 和 while)

1. for 循环
常用于遍历序列（如列表、字符串、字典等）或固定次数的循环。配合 range() 函数非常方便。

1
2
3
4
5
6
7
8
9
10
# 打印 0 到 4
for i in range(5):
    print(i)

# 打印 1 到 100 的偶数
sum_even = 0
for x in range(1, 101):
    if x % 2 == 0:
        sum_even += x
print("偶数和：", sum_even)

2. while 循环
常用于循环次数不确定，需要根据条件来结束的场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import random

# 猜数字小游戏
target = random.randint(1, 100)
count = 0

while True:
    guess = int(input("请输入你猜的数字(1-100)："))
    count += 1
    
    if guess > target:
        print("太大了！")
    elif guess < target:
        print("太小了！")
    else:
        print(f"恭喜你猜对了！一共猜了 {count} 次。")
        break # 猜对后退出循环

3. break 和 continue

  • break：立刻跳出整个循环。
  • continue：结束本次循环，直接进入下一次循环。
1
2
3
4
5
# 打印 1~10，但跳过 5
for i in range(1, 11):
    if i == 5:
        continue
    print(i)

5. 列表推导式与三元表达式

三元表达式：简化简单的 if-else。

1
2
3
4
5
x = 10
y = 20
# 如果 x > y，取 x；否则取 y
max_val = x if x > y else y 
print(max_val) # 20

列表推导式：用极其简洁的方式生成新的列表/集合/字典。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 原始写法：提取小于等于 5 的元素的立方
a = [1, 2, 3, 4, 5, 6, 7]
result = []
for i in a:
    if i <= 5:
        result.append(i ** 3)

# 列表推导式写法
b = [i ** 3 for i in a if i <= 5]
print(b) # [1, 8, 27, 64, 125]

# 字典推导式（例如交换字典的 key 和 value）
students = {'wei': 18, 'lai': 19}
reversed_dict = {value: key for key, value in students.items()}
print(reversed_dict) # {18: 'wei', 19: 'lai'}

6. 函数与高阶编程

定义函数

使用 def 关键字定义函数。

1
2
3
4
5
def add(x, y=10): # y 拥有默认值 10
    return x + y

print(add(5))    # 15
print(add(5, 5)) # 10

可变参数 (*args 和 **kwargs)

  • *args：接收任意多个位置参数，打包为元组。
  • **kwargs：接收任意多个关键字参数，打包为字典。
1
2
3
4
5
6
7
def demo(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

demo(1, 2, 3, name="WeiLai", age=18)
# args: (1, 2, 3)
# kwargs: {'name': 'WeiLai', 'age': 18}

匿名函数 (lambda)

对于只有一行的简单函数，可以使用 lambda 表达式。

1
2
add_func = lambda x, y: x + y
print(add_func(3, 4)) # 7

Map, Reduce, Filter

这些是函数式编程的核心工具。

  • map(func, iterable)：对序列的每个元素应用函数。
  • filter(func, iterable)：保留函数返回为 True 的元素。
  • reduce(func, iterable)：连续计算（需要从 functools 导入）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
from functools import reduce

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

# map: 所有数字平方
squares = list(map(lambda x: x*x, nums))

# filter: 过滤出偶数
evens = list(filter(lambda x: x%2 == 0, nums))

# reduce: 所有数字累加
total = reduce(lambda x, y: x+y, nums)

print(squares, evens, total)

7. 闭包与装饰器

闭包 (Closure)

闭包 = 函数 + 定义时的环境变量。它可以让函数记住其被创建时的环境。

1
2
3
4
5
6
7
8
9
10
def factory(pos):
    def go(step):
        nonlocal pos # 声明修改外部作用域的变量
        pos += step
        return pos
    return go

tourist = factory(0) # 初始位置为 0
print(tourist(2))    # 走 2 步，当前位置 2
print(tourist(3))    # 再走 3 步，当前位置 5

使用闭包可以避免使用全局变量，使数据更加安全且封装性更好。

装饰器 (Decorator)

装饰器是利用闭包原理，在不修改原有函数代码的情况下，为函数动态增加功能的设计模式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import time

# 定义一个计算执行时间的装饰器
def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        print(f"[{func.__name__}] 耗时: {time.time() - start_time:.4f} 秒")
        return result
    return wrapper

@timer_decorator
def heavy_computation():
    time.sleep(1) # 模拟耗时任务
    print("计算完成！")

heavy_computation()

8. 面向对象编程 (OOP)

类是模板，对象是根据模板创建出来的实体。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Student:
    school = "WeiTalk" # 类变量 (所有实例共享)

    def __init__(self, name, age):
        self.name = name # 实例变量 (归具体的对象所有)
        self.age = age

    def introduce(self): # 实例方法
        print(f"我是 {self.name}，今年 {self.age} 岁。")

    @classmethod
    def get_school(cls): # 类方法
        print(f"我们的学校是 {cls.school}")

    @staticmethod
    def is_adult(age): # 静态方法 (不需要 self 或 cls)
        return age >= 18

# 实例化
stu = Student("WeiLai", 18)
stu.introduce()
Student.get_school()
print(Student.is_adult(18))

9. 正则表达式 (re 模块)

正则表达式用于文本的高级搜索、匹配和替换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import re

text = "Python123 Java456 Go789"

# findall 查找所有符合条件的匹配项
numbers = re.findall(r'\d+', text)
print(numbers) # ['123', '456', '789']

# sub 替换
new_text = re.sub(r'\d+', '!!!', text)
print(new_text) # 'Python!!! Java!!! Go!!!'

# 高阶用法：将函数传入 sub 进行复杂替换
def double_number(match):
    val = int(match.group())
    return str(val * 2)

doubled_text = re.sub(r'\d+', double_number, text)
print(doubled_text) # 'Python246 Java912 Go1578'

10. 文件操作与异常处理

文件读写

套路：打开文件 -> 读/写 -> 关闭文件。建议使用 with 语句，可以自动管理文件的关闭。

1
2
3
4
5
6
7
8
# 写入文件
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("Hello Python!\n你好，世界！")

# 读取文件
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

异常处理

通过 try...except...finally 可以捕获代码中的错误，防止程序崩溃。

1
2
3
4
5
6
7
8
9
10
11
12
try:
    num = int(input("请输入一个数字作除数: "))
    result = 10 / num
    print(f"结果是: {result}")
except ValueError:
    print("错误：你输入的不是数字！")
except ZeroDivisionError:
    print("错误：除数不能为零！")
except Exception as e:
    print(f"发生了未知错误: {e}")
finally:
    print("程序执行完毕。") # 无论成功与否都会执行

如果需要，也可以主动抛出异常：raise Exception("自定义错误信息")。

11. 附录：网络编程基础 (TCP/UDP)

Python 的 socket 模块可以非常方便地建立网络连接。

TCP 客户端请求网页示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import socket

# 创建 TCP Socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 建立连接
s.connect(('www.baidu.com', 80))

# 发送 HTTP 请求
s.send(b'GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: close\r\n\r\n')

# 接收数据
buffer = []
while True:
    d = s.recv(1024)
    if d:
        buffer.append(d)
    else:
        break

data = b''.join(buffer)
s.close()

# 打印响应头
header, html = data.split(b'\r\n\r\n', 1)
print(header.decode('utf-8'))

结语：Python 的基础语法优雅且强大。熟练掌握上述内容，足以应付日常 80% 的脚本编写和后端逻辑开发任务。继续深入学习，你将能更好地利用 Python 庞大的生态圈！