Python入门速成：从 0 到会写题

本文适合：期末复习阶段的在校学生和 C 语言初学者；觉得不错的同学可以点个赞哦，对算法竞赛、OJ 刷题感兴趣的读者，可关注作者或者订阅专栏获取更多竞赛向内容。

一、基本结构

Python程序以缩进区分代码块（替代C语言的{}），核心组成包括注释、语句、函数/类，其中if __name__ == "__main__":是程序入口的常用写法。

# 单行注释：这是Python最小程序示例
'''
多行注释：
1. 引入无需显式导入标准输出库（区别于C的#include）
2. 语句末尾可省略分号（推荐风格）
'''
print("Hello World!")  # 打印函数，自带换行效果

# 程序入口：直接运行脚本时执行以下代码
if __name__ == "__main__":
    print("程序执行入口")
    

• 注释规范：单行用 #，多行用 ''' ''' 或 """ """，注释不参与程序执行。

• 缩进规范：用4个空格或1个Tab表示代码块层级（强制语法，缩进错误会报错）。

• print 函数：print 函数为标准输出函数，支持多参数、格式化输出。

• 程序入口：使用 if __name__ == "__main__": 确保代码仅在直接运行时执行，被导入时不执行。

二、数据类型

Python 是动态类型语言（无需声明变量类型，赋值时自动确定），核心数据类型分为基本类型和复合类型。

2.1 核心数据类型分类

类型类别	具体类型	说明	示例
基本类型	整数（int）	无大小限制，支持正负	10、-5、10000000000
基本类型	浮点数（float）	带小数的数值，支持科学计数法	3.14、-0.5、1.2e3（即1200）
基本类型	布尔值（bool）	表示真假，仅两个值：True（1）、False（0）	True、False
基本类型	NoneType	表示空值（区别于空字符串/0）	None
复合类型	字符串（str）	字符序列，单双引号均可包裹	“abc”、‘Python’
复合类型	列表（list）	有序、可变、可重复的元素集合	[1, 2, “a”]
复合类型	元组（tuple）	有序、不可变、可重复的元素集合	(1, 2, “a”)
复合类型	字典（dict）	无序（Python 3.7+ 保持插入顺序）的键值对集合，键唯一	{“name”: “Tom”, “age”: 20}

2.2 类型使用示例

# 基本类型使用
num1 = 100          # int类型
num2 = 3.14         # float类型
flag = True         # bool类型
empty_val = None    # NoneType

# 复合类型使用
str_val = "Python基础"               # str类型
list_val = [1, 2, 3, "hello"]        # list类型
tuple_val = (10, 20, "world")        # tuple类型
dict_val = {"name": "XiaoYu", "age": 18}  # dict类型

# 查看类型（type()函数）
print(type(num1))     # 输出：<class 'int'>
print(type(list_val)) # 输出：<class 'list'>
print(type(dict_val)) # 输出：<class 'dict'>

提示：Python 中一切皆对象，每个值都有对应的类型，可通过 type() 函数查看，通过 isinstance() 函数判断类型。

三、变量与常量

3.1 变量

变量是存储数据的容器，定义格式：变量名 = 值。Python 支持多变量赋值、序列解包等灵活方式。

3.1.1 变量命名规则

• 由字母、数字、下划线组成，不能以数字开头；
• 区分大小写（如 name 和 Name 是不同变量）；
• 不能使用 Python 关键字（如 if、for、class 等）；

3.1.2 变量使用示例

# 基础赋值
a = 10
b = "test"

# 多变量赋值（同一值）
x = y = z = 0
print(x, y, z)  # 输出：0 0 0

# 多变量赋值（不同值）
name, age, gender = "Bob", 22, "male"
print(name, age)  # 输出：Bob 22

# 序列解包（列表/元组赋值）
list1 = [100, 200]
m, n = list1
print(m, n)  # 输出：100 200

# 变量值修改（动态类型特性）
a = "I changed"  # 变量 a 从 int 类型改为 str 类型
print(a)  # 输出：I changed

提示：Python 中一切皆对象，每个值都有对应的类型，可通过 type() 函数查看，通过 isinstance() 函数判断类型。

3.2 常量

Python 没有真正的常量（无法强制禁止修改），约定俗成用全大写字母 + 下划线表示常量，通常定义在脚本顶部。

3.2.1 常量使用示例

# 约定常量（全大写）
PI = 3.14159
MAX_AGE = 120

# 实际可修改（不推荐）
PI = 3.14
print(PI)  # 输出：3.14

# 更严格的常量（通过类实现，入门阶段了解）
class Const:
    class ConstError(TypeError):
        pass

    def __setattr__(self, name, value):
        if name in self.__dict__:
            raise self.ConstError("常量不能修改")
        self.__dict__[name] = value

const = Const()
const.PI = 3.14159
# const.PI = 3.14  # 执行会报错：ConstError: 常量不能修改

四、运算符与表达式

运算符用于对操作数进行运算，组合后形成表达式，Python 支持常见运算符及特有的身份运算符、成员运算符。

4.1 算术运算符

用于数值计算，支持整数、浮点数运算，特有的整除、幂运算符号。

a = 10
b = 3

print(a + b)   # 加法：13
print(a - b)   # 减法：7
print(a * b)   # 乘法：30
print(a / b)   # 除法（结果为 float）：3.3333333333333335
print(a // b)  # 整除（取商的整数部分）：3
print(a % b)   # 取余：1
print(a ** b)  # 幂运算（a 的 b 次方）：1000

4.2 比较运算符

用于比较两个值的关系，结果为布尔值（True/False）。

x = 5
y = 5

print(x == y)  # 等于：True
print(x != y)  # 不等于：False
print(x > 3)   # 大于：True
print(x <= 5)  # 小于等于：True

4.3 逻辑运算符

用于逻辑判断，操作数为布尔值或可转换为布尔值的数据，支持短路求值。

p = True
q = False

print(p and q)  # 逻辑与（两者都真才真）：False
print(p or q)   # 逻辑或（任一为真则真）：True
print(not p)    # 逻辑非（取反）：False

# 短路求值示例
print(0 and 10)  # 0 为假，直接返回 0，不判断 10
print(10 or 0)   # 10 为真，直接返回 10，不判断 0

4.4 赋值运算符

用于赋值及复合赋值，复合赋值结合算术/位运算。

c = 10

c += 5   # 等价于 c = c + 5 → 15
c *= 2   # 等价于 c = c * 2 → 30
c %= 3   # 等价于 c = c % 3 → 0
print(c)  # 输出：0

4.5 特殊运算符

身份运算符：is（判断内存地址是否相同）、is not；
成员运算符：in（判断是否为成员）、not in。

# 身份运算符（注意：小整数有缓存，大整数通常不缓存）
a = 10
b = 10
print(a is b)  # 输出：True（内存地址相同，因小整数缓存）

c = 1000
d = 1000
print(c is d)  # 输出：False（内存地址不同）
print(c == d)  # 输出：True（值相同）

# 成员运算符
list2 = [1, 2, 3]
print(2 in list2)      # 输出：True
print(4 not in list2)  # 输出：True

五、控制语句

控制程序执行流程，分为选择结构（if-else、match-case）和循环结构（for、while），通过缩进区分代码块。

5.1 选择语句

5.1.1 if-else 语句

根据条件执行不同代码块，支持嵌套和多分支（elif）。

score = 88

# 单分支
if score >= 60:
    print("及格")

# 双分支
if score >= 90:
    print("优秀")
else:
    print("非优秀")

# 多分支（elif）
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 60:
    grade = "C"
else:
    grade = "D"
print(f"成绩等级：{grade}")  # 输出：成绩等级：B

# 嵌套 if
num = 15
if num > 10:
    if num % 2 == 0:
        print("大于10的偶数")
    else:
        print("大于10的奇数")  # 输出：大于10的奇数

5.1.2 match-case 语句

类似 C 语言的 switch-case，用于多值匹配，支持结构化/模式匹配。

day = 3

match day:
    case 1:
        print("星期一")
    case 2:
        print("星期二")
    case 3:
        print("星期三")
    case _:  # 通配符，类似 default
        print("其他星期")  # 若 day=5，输出：其他星期

# 模式匹配示例
point = (2, 0)
match point:
    case (0, 0):
        print("原点")
    case (x, 0):
        print(f"x轴上的点：({x}, 0)")  # 输出：x轴上的点：(2, 0)
    case (0, y):
        print(f"y轴上的点：(0, {y})")
    case _:
        print("其他点")

5.2 循环语句

5.2.1 for 循环

用于遍历可迭代对象（如列表、字符串、range 对象等），格式：for 变量 in 可迭代对象: 循环体。

# 遍历字符串
for char in "Python":
    print(char, end=" ")  # 输出：P y t h o n 

# 遍历列表
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(f"水果：{fruit}")

# 遍历 range 对象（生成整数序列）
# range(起始, 结束, 步长)，左闭右开
for i in range(1, 6):  # 1-5
    print(i, end=" ")  # 输出：1 2 3 4 5 

for i in range(0, 10, 2):  # 0-8，步长2
    print(i, end=" ")  # 输出：0 2 4 6 8 

# 结合 enumerate 获取索引和值
for index, fruit in enumerate(fruits):
    print(f"索引{index}：{fruit}")  # 输出：索引0：apple 索引1：banana 索引2：orange

5.2.2 while 循环

当条件为真时执行循环体，格式：while 条件: 循环体，需确保条件会变为假（避免死循环）。

# 基本 while 循环（打印1-5）
i = 1
while i <= 5:
    print(i, end=" ")
    i += 1  # 必须更新条件
# 输出：1 2 3 4 5 

# 死循环示例（需谨慎，可通过 Ctrl+C 终止）
# count = 0
# while True:
#     print(count)
#     count += 1

# 结合 break 的循环（找到 10 以内的第一个偶数）
num = 1
while num <= 10:
    if num % 2 == 0:
        print(f"10以内第一个偶数：{num}")  # 输出：10以内第一个偶数：2
        break  # 跳出循环
    num += 1

5.3 循环控制语句（break、continue、pass）

# break：跳出当前循环
print("break示例：")
for i in range(10):
    if i == 3:
        break
    print(i, end=" ")  # 输出：0 1 2 

# continue：跳过本次循环剩余部分，进入下一次
print("\ncontinue示例：")
for i in range(5):
    if i == 2:
        continue
    print(i, end=" ")  # 输出：0 1 3 4 

# pass：空语句，用于占位（语法需要但无逻辑）
print("\npass示例：")
for i in range(3):
    if i == 1:
        pass  # 此处暂不处理，后续可补充代码
    print(i, end=" ")  # 输出：0 1 2 

六、函数

函数是封装的可重复使用的代码块，定义格式：def 函数名(参数列表): 函数体 return 返回值。Python 支持多种参数类型、闭包、装饰器等高级特性。

6.1 函数基本使用

# 1. 无参数无返回值函数
def say_hello():
    print("Hello Python!")

# 调用函数
say_hello()  # 输出：Hello Python!

# 2. 有参数函数
def add(a, b):
    result = a + b
    return result  # 返回计算结果

# 调用并接收返回值
sum_val = add(10, 20)
print(sum_val)  # 输出：30

# 3. 有默认值参数（默认值参数放在参数列表后面）
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Tom")          # 输出：Hello, Tom!
greet("Jerry", "Hi")  # 输出：Hi, Jerry!

# 4. 不定长参数（*args 接收元组，**kwargs 接收字典）
def print_args(*args, **kwargs):
    print("位置参数：", args)
    print("关键字参数：", kwargs)

print_args(1, 2, 3, name="Alice", age=18)
# 输出：
# 位置参数： (1, 2, 3)
# 关键字参数： {'name': 'Alice', 'age': 18}

6.2 函数进阶特性

6.2.1 函数嵌套与闭包

# 函数嵌套
def outer():
    def inner():
        print("这是内部函数")
    inner()  # 调用内部函数

outer()  # 输出：这是内部函数

# 闭包（内部函数引用外部函数变量，外部函数返回内部函数）
def make_multiplier(factor):
    def multiplier(num):
        return num * factor
    return multiplier

double = make_multiplier(2)
print(double(5))  # 输出：10（5*2）
triple = make_multiplier(3)
print(triple(5))  # 输出：15（5*3）

6.2.2 匿名函数（lambda）

简洁的单行函数，格式：lambda 参数: 表达式，常用于 map()/filter()/sorted() 等场景。

# 定义匿名函数（计算两数之和）
add_lambda = lambda a, b: a + b
print(add_lambda(3, 5))  # 输出：8

# 结合 map() 使用（对列表元素平方）
nums = [1, 2, 3, 4]
squared_nums = list(map(lambda x: x**2, nums))
print(squared_nums)  # 输出：[1, 4, 9, 16]

# 结合 filter() 使用（筛选偶数）
even_nums = list(filter(lambda x: x % 2 == 0, nums))
print(even_nums)  # 输出：[2, 4]

七、列表与元组

列表（list）和元组（tuple）是 Python 中最常用的有序复合类型：列表可变，元组不可变。两者都支持索引、切片等操作。

7.1 列表（list）

用 [] 定义，支持增、删、改、查等操作。

# 定义列表
my_list = [1, 2, 3, "a", True]

# 1. 访问元素（索引从0开始，支持负索引）
print(my_list[0])   # 第一个元素：1
print(my_list[-1])  # 最后一个元素：True

# 2. 切片（获取子列表，左闭右开）
print(my_list[1:4])  # 索引1-3：[2, 3, "a"]
print(my_list[:3])   # 开头到索引2：[1, 2, 3]
print(my_list[2:])   # 索引2到结尾：[3, "a", True]

# 3. 修改元素
my_list[0] = 100
print(my_list)  # 输出：[100, 2, 3, "a", True]

# 4. 增加元素
my_list.append(4)        # 末尾添加：[100, 2, 3, "a", True, 4]
my_list.insert(1, 200)   # 索引1处插入：[100, 200, 2, 3, "a", True, 4]
my_list.extend([5, 6])   # 扩展列表：[100, 200, 2, 3, "a", True, 4, 5, 6]

# 5. 删除元素
my_list.remove(3)        # 删除指定值
del my_list[2]           # 删除指定索引
pop_val = my_list.pop()  # 删除末尾元素并返回

# 6. 其他常用操作
print(len(my_list))      # 长度
print(sorted(my_list, key=lambda x: str(x)))  # 排序（按字符串排序）
print(my_list.count(100))# 计数

7.2 元组（tuple）

用 () 定义，元素一旦定义无法修改（不可变），适合存放不需要修改的数据。

# 定义元组（括号可省略，但建议使用）
my_tuple = (1, 2, 3, "b")
simple_tuple = 4, 5, 6  # 省略括号

# 1. 访问元素（支持索引和切片）
print(my_tuple[1])      # 2
print(my_tuple[1:3])    # (2, 3)

# 2. 不可变特性（修改会报错）
# my_tuple[0] = 100  # TypeError

# 3. 单元素元组（必须加逗号）
single_tuple = (10,)  # 正确
# single_tuple = (10)  # 错误，会被识别为 int

# 4. 常用操作
print(len(my_tuple))        # 长度：4
print(my_tuple.count(2))    # 计数：1
print(my_tuple.index("b"))  # 查找索引：3

# 5. 元组转换为列表（修改后可再转回元组）
temp_list = list(my_tuple)
temp_list[0] = 100
new_tuple = tuple(temp_list)
print(new_tuple)  # 输出：(100, 2, 3, "b")

提示：列表与元组的核心区别是可变性。若数据不需要修改，优先使用元组（更安全、高效）；需要修改时使用列表。

八、字典与集合

字典（dict）是键值对集合，适合快速查找；集合（set）是无序且元素唯一的集合，适合去重与集合运算。

8.1 字典（dict）

用 {key: value} 定义，键必须为不可变类型（如 int、str、tuple），值可为任意类型。Python 3.7+ 保证插入顺序。

# 定义字典
student = {
    "name": "Alice",
    "age": 18,
    "gender": "female",
    "scores": [90, 85, 95]
}

# 1. 访问值（通过键访问，或用 get() 方法）
print(student["name"])      # Alice
print(student.get("age"))   # 18
print(student.get("address", "未知"))  # 键不存在时返回默认值：未知

# 2. 修改和添加键值对
student["age"] = 19  # 修改值
student["address"] = "Beijing"  # 添加新键值对

# 3. 删除键值对
del student["gender"]  # 删除指定键
pop_val = student.pop("scores")  # 删除并返回值
student.clear()  # 清空字典

# 4. 遍历字典
student = {"name": "Bob", "age": 20}
for key in student:
    print(f"键：{key}，值：{student[key]}")
for key, value in student.items():
    print(f"键：{key}，值：{value}")

# 5. 其他常用操作
print(student.keys())    # 所有键
print(student.values())  # 所有值
print(len(student))      # 长度

8.2 集合（set）

用 set() 或 {} 定义（空集合必须用 set()），元素唯一且无序。

# 定义集合（自动去重）
my_set = {1, 2, 3, 3, 4}
print(my_set)  # 输出：{1, 2, 3, 4}
empty_set = set()  # 空集合

# 1. 添加和删除元素
my_set.add(5)
my_set.update([6, 7])
my_set.remove(3)     # 删除指定元素（不存在则报错）
my_set.discard(8)    # 删除指定元素（不存在不报错）
pop_val = my_set.pop()  # 随机删除并返回一个元素

# 2. 集合运算（交并差对称差）
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1 & set2)   # 交集：{3, 4}
print(set1 | set2)   # 并集：{1,2,3,4,5,6}
print(set1 - set2)   # 差集：{1,2}
print(set1 ^ set2)   # 对称差集：{1,2,5,6}

# 3. 其他常用操作
print(len(my_set))
print(3 in set1)
print(set1.issubset(set2))  # 判断子集

# 4. 列表去重（常用场景）
list_with_duplicate = [1, 2, 2, 3, 3, 3]
unique_list = list(set(list_with_duplicate))
print(unique_list)  # 输出：[1,2,3]（顺序可能变化）

九、字符串操作

字符串（str）是字符的有序序列，用单引号、双引号或三引号包裹，支持切片、拼接、替换、格式化等丰富操作。

9.1 字符串基本操作

# 定义字符串
s1 = 'hello'
s2 = "world"
s3 = """Python
基础
语法"""  # 三引号支持多行字符串

# 1. 拼接与重复
print(s1 + " " + s2)  # 拼接：hello world
print(s1 * 3)         # 重复：hellohellohello

# 2. 索引与切片（左闭右开）
print(s1[0])          # 第一个字符：h
print(s1[-1])         # 最后一个字符：o
print(s1[1:4])        # 索引1-3：ell
print(s1[::2])        # 步长2：hlo（取偶数索引字符）

# 3. 不可变特性（修改会报错）
# s1[0] = "H"  # TypeError

# 4. 常用方法
print(len(s1))                # 长度：5
print(s1.upper())             # 转大写：HELLO
print(s1.lower())             # 转小写：hello
print(s1.capitalize())        # 首字母大写：Hello
print(s1.replace("l", "x"))   # 替换：hexxo
print(s1.split("l"))          # 分割：['he', '', 'o']
print(" ".join(["a", "b", "c"]))  # 连接：a b c
print(s1.startswith("he"))    # 判断前缀：True
print(s1.endswith("lo"))      # 判断后缀：True
print(s1.strip())             # 去除首尾空白

# 5. 格式化输出（三种方式）
name = "Tom"
age = 20
# 方式1：% 格式化
print("姓名：%s，年龄：%d" % (name, age))
# 方式2：format() 方法
print("姓名：{}，年龄：{}".format(name, age))
# 方式3：f-string（Python 3.6+，推荐）
print(f"姓名：{name}，年龄：{age}")  # 最简洁直观