Python3 基础语法学习笔记
整理自：菜鸟教程 https://www.runoob.com/python3/python3-basic-syntax.html
整理日期：2026-02-02
目录
1. Python3 基本数据类型
核心概念
Python中变量无需声明类型，类型由赋值的对象决定。
“Python 中的变量就是变量，它没有类型，我们所说的’类型’是变量所指的内存中对象的类型。”
六大标准数据类型
不可变数据（3个）
-
Number（数字）
-
String（字符串）
-
Tuple（元组）
可变数据（3个）
-
List（列表）
-
Dictionary（字典）
-
Set（集合）
关键类型详解
Number 类型
支持 int、float、bool、complex，其中 bool 是 int 的子类（True==1，False==0）
String 类型
使用单/双引号，支持索引和切片，字符串不可修改
List（列表）
可修改的有序集合，支持多种数据类型混合
Tuple（元组）
不可修改的有序集合，需用逗号区分单元素元组：(42,)
Set（集合）
无序且无重复元素，自动去除重复项
Dictionary（字典）
键值对映射，键必须为不可变类型且唯一
核心区别对比表
| 类型 | 是否有序 | 能否修改 | 是否允许重复 | 典型用途 |
|---|---|---|---|---|
| list 列表 |  有序 |
可变 |
允许 |
存一组数据，常用 |
| tuple 元组 | 有序 |
 不可变 |
允许 |
固定数据、更安全 |
| set 集合 | 无序 |
可变 |
不允许 |
去重、集合运算 |
| dict 字典 | 有序* |
可变 |
键 值 |
键值映射、查找 |
类型检查工具
-
type()- 返回对象的确切类型 -
isinstance()- 检查对象是否属于某类型（包括子类）
# 示例
a = 111
print(isinstance(a, int)) # True
print(type(a)) # <class 'int'>
2. Python3 数据类型转换
核心概念
Python数据类型转换分为两类：
-
隐式类型转换 - Python 会自动将一种数据类型转换为另一种数据类型，无需手动干预
-
显式类型转换 - 使用内置函数主动转换数据类型
隐式转换示例
当不同数据类型进行运算时，较低精度的类型自动升级为较高精度类型。
# 整数与浮点数相加，整数自动转换为浮点数
num_int = 123
num_flo = 1.23
num_new = num_int + num_flo
print("num_new 的值:", num_new) # 124.23
print("num_new 的数据类型:", type(num_new)) # <class 'float'>
注意：整数与字符串相加会产生 TypeError 错误。
显式转换函数
常用的类型转换函数：
| 函数 | 功能 | 示例 |
|---|---|---|
int(x) |
转换为整数 | int("123") → 123 |
float(x) |
转换为浮点数 | float("1.23") → 1.23 |
str(x) |
转换为字符串 | str(123) → “123” |
list(x) |
转换为列表 | list((1,2,3)) → [1,2,3] |
tuple(x) |
转换为元组 | tuple([1,2,3]) → (1,2,3) |
set(x) |
转换为集合 | set([1,2,2,3]) → {1,2,3} |
chr(x) |
整数转字符 | chr(65) → ‘A’ |
ord(x) |
字符转整数 | ord('A') → 65 |
hex(x) |
转十六进制 | hex(255) → ‘0xff’ |
oct(x) |
转八进制 | oct(8) → ‘0o10’ |
关键注意事项
数据转换的可行性取决于源数据是否包含足够信息表示目标类型。
# 可以转换
int("123") # ✓ 成功
# 无法转换
int("Hello") # ✗ ValueError
3. Python3 解释器
环境配置
Linux/Unix 系统
Python3 通常安装在 /usr/local/python3 目录。设置环境变量：
$ PATH=$PATH:/usr/local/python3/bin/python3
$ python3 --version
Python 3.4.0
Windows 系统
set path=%path%;C:\python34
交互式编程
启动 Python 解释器：
$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
简单示例：
>>> print("Hello, Python!")
Hello, Python!
多行代码示例（if 语句）：
>>> flag = True
>>> if flag:
... print("flag 条件为 True!")
...
flag 条件为 True!
脚本式编程
将代码保存为 hello.py 文件后执行：
python3 hello.py
Linux/Unix 下的可执行脚本
在脚本顶部添加 shebang 行：
#!/usr/bin/env python3
print("Hello, Python!")
设置执行权限：
$ chmod +x hello.py
$ ./hello.py
输出：
Hello, Python!
4. Python3 注释
注释类型
1. 单行注释
使用 # 符号开头。
“# 符号后面的所有文本都被视为注释，不会被解释器执行。”
# 这是一个注释
print("Hello, World!")
2. 多行注释
使用三个单引号 ''' 或三个双引号 """ 包围。
使用单引号：
#!/usr/bin/python3
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, World!")
使用双引号：
#!/usr/bin/python3
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号
"""
print("Hello, World!")
重要提示
-
多行字符串虽然可用作注释，但实际上是字符串对象，不会影响程序执行
-
多行注释不能嵌套使用，会导致语法错误
-
文档字符串需放在函数定义的第一行才能被
__doc__属性正确识别
5. Python3 运算符
运算符类型
1. 算术运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
+ |
加法 | 10 + 20 = 30 |
- |
减法 | 20 - 10 = 10 |
* |
乘法 | 10 * 20 = 200 |
/ |
除法 | 20 / 10 = 2.0 |
% |
取模（余数） | 20 % 3 = 2 |
** |
幂运算 | 2 ** 3 = 8 |
// |
整除（向下取整） | 9 // 2 = 4 |
a = 21
b = 10
print(a + b) # 31
print(a - b) # 11
print(a * b) # 210
print(a / b) # 2.1
print(a % b) # 1
print(a ** b) # 21^10
print(a // b) # 2
2. 比较运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
== |
等于 | (a == b) 返回 False |
!= |
不等于 | (a != b) 返回 True |
> |
大于 | (a > b) 返回 True |
< |
小于 | (a < b) 返回 False |
>= |
大于等于 | (a >= b) 返回 True |
<= |
小于等于 | (a <= b) 返回 False |
3. 赋值运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
= |
简单赋值 | c = a + b |
+= |
加法赋值 | c += a 等效于 c = c + a |
-= |
减法赋值 | c -= a 等效于 c = c - a |
*= |
乘法赋值 | c *= a 等效于 c = c * a |
/= |
除法赋值 | c /= a 等效于 c = c / a |
%= |
取模赋值 | c %= a 等效于 c = c % a |
**= |
幂赋值 | c **= a 等效于 c = c ** a |
//= |
整除赋值 | c //= a 等效于 c = c // a |
海象运算符（:=）- Python 3.8+
允许在表达式中同时进行赋值和返回赋值的值。
# 传统方式
n = len([1, 2, 3])
if n > 2:
print(f"列表长度 {n} 大于2")
# 使用海象运算符
if (n := len([1, 2, 3])) > 2:
print(f"列表长度 {n} 大于2")
4. 位运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
& |
按位与 | a & b |
| ` | ` | 按位或 |
^ |
按位异或 | a ^ b |
~ |
按位取反 | ~a |
<< |
左移 | a << 2 |
>> |
右移 | a >> 2 |
a = 60 # 二进制：0011 1100
b = 13 # 二进制：0000 1101
print(a & b) # 12 = 0000 1100
print(a | b) # 61 = 0011 1101
print(a ^ b) # 49 = 0011 0001
print(~a) # -61 = 1100 0011
print(a << 2) # 240 = 1111 0000
print(a >> 2) # 15 = 0000 1111
5. 逻辑运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
and |
逻辑与 | x and y |
or |
逻辑或 | x or y |
not |
逻辑非 | not x |
优先级顺序：not > and > or
a = True
b = False
print(a and b) # False
print(a or b) # True
print(not a) # False
6. 成员运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
in |
在序列中存在 | x in list |
not in |
不在序列中 | x not in list |
a = 10
list = [1, 2, 3, 4, 5]
if a in list:
print("a 在列表中")
else:
print("a 不在列表中")
7. 身份运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
is |
判断是否为同一对象 | x is y |
is not |
判断是否不是同一对象 | x is not y |
is 与 == 的区别
“is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等”
a = [1, 2, 3]
b = a
c = a[:]
print(b is a) # True - 同一对象
print(c is a) # False - 不同对象
print(c == a) # True - 值相等
6. Python3 数字(Number)
数值类型
Python 支持三种数值类型：
1. 整型 (int)
正或负整数，不带小数点。Python3 中无大小限制。
a = 100
b = -100
c = 0
2. 浮点型 (float)
包含整数部分和小数部分，支持科学计数法。
f1 = 1.23
f2 = 3.14159
f3 = 2.5e2 # 250.0
3. 复数 (complex)
由实部和虚部组成，表示为 a + bj 或 complex(a, b)。
c1 = 1 + 2j
c2 = complex(3, 4)
数据类型转换
int(x) # 将 x 转换为整数
float(x) # 将 x 转换为浮点数
complex(x) # 将 x 转换为复数
进制表示
# 十六进制
hex_num = 0xFF # 255
# 八进制
oct_num = 0o10 # 8
基本运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
+ |
加法 | 5 + 3 = 8 |
- |
减法 | 5 - 3 = 2 |
* |
乘法 | 5 * 3 = 15 |
/ |
除法 | 5 / 2 = 2.5 |
// |
整数除法 | 5 // 2 = 2 |
% |
取余 | 5 % 2 = 1 |
** |
幂运算 | 2 ** 3 = 8 |
数学函数
常用函数
| 函数 | 描述 | 示例 |
|---|---|---|
abs(x) |
绝对值 | abs(-10) = 10 |
ceil(x) |
向上取整 | ceil(4.1) = 5 |
floor(x) |
向下取整 | floor(4.9) = 4 |
round(x [,n]) |
四舍五入 | round(4.5) = 4 |
sqrt(x) |
平方根 | sqrt(9) = 3.0 |
pow(x, y) |
x 的 y 次方 | pow(2, 3) = 8 |
max(x1, x2,...) |
最大值 | max(1, 5, 3) = 5 |
min(x1, x2,...) |
最小值 | min(1, 5, 3) = 1 |
随机数函数
import random
random.choice([1, 2, 3, 4]) # 随机选择元素
random.randrange(1, 100, 2) # 随机选择范围内的偶数
random.random() # 随机浮点数 [0,1)
random.shuffle(list) # 随机打乱列表
random.uniform(x, y) # 随机浮点数 [x,y]
注意事项：奇进偶舍
round() 函数遵循银行家舍入法（奇进偶舍）：
print(round(0.5)) # 0 - 舍
print(round(1.5)) # 2 - 进
print(round(2.5)) # 2 - 舍
print(round(3.5)) # 4 - 进
当小数恰好为 0.5 时，会舍入到最近的偶数。
7. Python3 字符串
创建字符串
Python 字符串通过单引号或双引号创建。
str1 = 'Hello'
str2 = "World"
str3 = """多行
字符串"""
字符串访问与索引
索引规则
“索引值以 0 为开始值，-1 为从末尾的开始位置”
str = "Hello World"
print(str[0]) # 'H'
print(str[-1]) # 'd'
切片操作
使用 [start:end:step] 格式，遵循"左闭右开"原则。
str = "Hello World"
print(str[0:5]) # 'Hello'
print(str[6:]) # 'World'
print(str[:5]) # 'Hello'
print(str[::2]) # 'HloWrd' - 每隔一个字符
print(str[::-1]) # 'dlroW olleH' - 反转字符串
转义字符
| 转义符 | 描述 |
|---|---|
\n |
换行符 |
\t |
制表符（Tab） |
\\ |
反斜杠 |
\' |
单引号 |
\" |
双引号 |
\r |
回车 |
\b |
退格 |
原始字符串
使用 r 或 R 前缀，让反斜杠不发生转义。
print('C:\name\new') # C:
# ame
# ew
print(r'C:\name\new') # C:\name\new
字符串运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
+ |
连接 | 'Hello' + 'World' → 'HelloWorld' |
* |
重复 | 'Hi' * 3 → 'HiHiHi' |
in |
成员检测 | 'H' in 'Hello' → True |
not in |
成员检测 | 'x' not in 'Hello' → True |
r/R |
原始字符串 | r'\n' → '\\n' |
字符串格式化
1. 百分号格式化
name = "小明"
age = 20
print("我叫 %s 今年 %d 岁!" % (name, age))
# 输出：我叫 小明 今年 20 岁!
常用格式符：
| 符号 | 描述 |
|---|---|
%s |
字符串 |
%d |
整数 |
%f |
浮点数 |
%x |
十六进制 |
%o |
八进制 |
2. f-string (Python 3.6+)
name = "小明"
age = 20
print(f'Hello {name}, 你今年 {age} 岁')
# 输出：Hello 小明, 你今年 20 岁
支持表达式：
x = 10
y = 20
print(f'{x} + {y} = {x+y}')
# 输出：10 + 20 = 30
3. str.format() (Python 2.6+)
print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))
# 输出：菜鸟教程网址： "www.runoob.com!"
print('{0} 和 {1}'.format('Google', 'Runoob'))
# 输出：Google 和 Runoob
print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
# 输出：菜鸟教程网址： www.runoob.com
常用字符串方法
| 方法 | 描述 | 示例 |
|---|---|---|
upper() |
转大写 | 'hello'.upper() → 'HELLO' |
lower() |
转小写 | 'HELLO'.lower() → 'hello' |
strip() |
去除首尾空白 | ' hello '.strip() → 'hello' |
split(sep) |
分割字符串 | 'a,b,c'.split(',') → ['a','b','c'] |
join(seq) |
连接序列 | ','.join(['a','b']) → 'a,b' |
replace(old, new) |
替换 | 'hello'.replace('l','L') → 'heLLo' |
find(str) |
查找位置 | 'hello'.find('l') → 2 |
count(str) |
统计出现次数 | 'hello'.count('l') → 2 |
startswith(str) |
是否以某字符串开头 | 'hello'.startswith('he') → True |
endswith(str) |
是否以某字符串结尾 | 'hello'.endswith('lo') → True |
isdigit() |
是否只包含数字 | '123'.isdigit() → True |
isalpha() |
是否只包含字母 | 'abc'.isalpha() → True |
isalnum() |
是否只包含字母和数字 | 'abc123'.isalnum() → True |
三引号字符串
用于多行文本，保留格式和特殊字符。
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)
重要特性
Python 3 中所有字符串都是 Unicode 字符串，支持国际化文本处理。
str = "你好，世界！"
print(str) # 直接支持中文
8. Python3 列表
核心概念
Python 列表是一种有序、可变的序列数据结构，使用方括号定义，元素可以是任何数据类型。
创建列表
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
empty_list = []
访问列表元素
索引访问
从 0 开始正向索引，或使用 -1、-2 等反向索引。
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list[0]) # 'red'
print(list[1]) # 'green'
print(list[-1]) # 'black'
print(list[-2]) # 'white'
切片操作
使用 [start:end:step] 格式提取子列表。
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list[0:4]) # ['red', 'green', 'blue', 'yellow']
print(list[1:-2]) # ['green', 'blue', 'yellow']
print(list[::2]) # ['red', 'blue', 'white'] - 隔一个取一个
print(list[::-1]) # 反转列表
更新列表
list = ['Google', 'Runoob', 1997, 2000]
print("原列表:", list)
list[2] = 2001
print("更新后:", list) # ['Google', 'Runoob', 2001, 2000]
删除列表元素
list = ['Google', 'Runoob', 1997, 2000]
print("原列表:", list)
del list[2]
print("删除后:", list) # ['Google', 'Runoob', 2000]
列表运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
+ |
连接 | [1, 2] + [3, 4] → [1, 2, 3, 4] |
* |
重复 | ['Hi!'] * 4 → ['Hi!', 'Hi!', 'Hi!', 'Hi!'] |
in |
成员检测 | 3 in [1, 2, 3] → True |
len([1, 2, 3]) # 3 - 长度
max([1, 5, 3]) # 5 - 最大值
min([1, 5, 3]) # 1 - 最小值
list((1, 2, 3)) # [1, 2, 3] - 元组转列表
列表方法
| 方法 | 描述 | 示例 |
|---|---|---|
append(obj) |
末尾添加元素 | list.append('item') |
extend(seq) |
批量添加元素 | list.extend([1, 2, 3]) |
insert(index, obj) |
指定位置插入 | list.insert(1, 'new') |
remove(obj) |
删除首个匹配值 | list.remove('item') |
pop([index]) |
移除并返回元素 | list.pop() 或 list.pop(0) |
clear() |
清空列表 | list.clear() |
index(obj) |
查找首次出现位置 | list.index('item') |
count(obj) |
统计出现次数 | list.count('item') |
sort() |
排序列表 | list.sort() |
reverse() |
反向排列 | list.reverse() |
copy() |
浅拷贝列表 | new_list = list.copy() |
列表复制注意事项
引用赋值（不是复制）
a = [1, 2, 3]
b = a # b 引用 a，指向同一对象
b[0] = 999
print(a) # [999, 2, 3] - a 也被修改了
独立复制
a = [1, 2, 3]
b = a[:] # 切片复制
# 或
b = a.copy() # copy() 方法
b[0] = 999
print(a) # [1, 2, 3] - a 不受影响
print(b) # [999, 2, 3]
列表推导式
# 创建 0-9 的平方列表
squares = [x**2 for x in range(10)]
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 带条件的列表推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares) # [0, 4, 16, 36, 64]
9. Python3 元组
什么是元组
元组是 Python 中的一种数据结构，类似于列表，但有一个关键区别：
“元组中的元素值是不允许修改的”
元组使用小括号 () 创建，元素间用逗号分隔。
创建元组
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)
tup3 = "a", "b", "c" # 不需要括号也可以
tup_empty = () # 空元组
tup_single = (50,) # 单元素必须加逗号
注意：单元素元组必须加逗号，否则被视为其他类型。
tup1 = (50)
print(type(tup1)) # <class 'int'>
tup2 = (50,)
print(type(tup2)) # <class 'tuple'>
访问元组
元组支持下标索引和切片操作，类似于字符串和列表。
tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
print(tup[0]) # 'Google'
print(tup[1]) # 'Runoob'
print(tup[-1]) # 'Weixin'
print(tup[-2]) # 'Weibo'
print(tup[1:]) # ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
print(tup[1:4]) # ('Runoob', 'Taobao', 'Wiki')
修改元组
元组中的元素值不允许修改，但可以连接组合。
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 错误示例
# tup1[0] = 100 # TypeError
# 正确做法：创建新元组
tup3 = tup1 + tup2
print(tup3) # (12, 34.56, 'abc', 'xyz')
删除元组
元组中的元素值不允许删除，但可以使用 del 语句删除整个元组。
tup = ('Google', 'Runoob', 1997, 2000)
print(tup)
del tup
# print(tup) # NameError: name 'tup' is not defined
元组运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
+ |
连接 | (1, 2) + (3, 4) → (1, 2, 3, 4) |
* |
复制 | ('Hi!',) * 4 → ('Hi!', 'Hi!', 'Hi!', 'Hi!') |
in |
成员检查 | 3 in (1, 2, 3) → True |
len() |
长度 | len((1, 2, 3)) → 3 |
max() |
最大值 | max((1, 5, 3)) → 5 |
min() |
最小值 | min((1, 5, 3)) → 1 |
# 连接
print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)
# 复制
print(('Hi!',) * 4) # ('Hi!', 'Hi!', 'Hi!', 'Hi!')
# 成员检查
print(3 in (1, 2, 3)) # True
# 迭代
for x in (1, 2, 3):
print(x, end=" ") # 1 2 3
元组内置函数
| 函数 | 描述 | 示例 |
|---|---|---|
len(tuple) |
计算元素个数 | len((1, 2, 3)) → 3 |
max(tuple) |
返回最大值 | max((1, 5, 3)) → 5 |
min(tuple) |
返回最小值 | min((1, 5, 3)) → 1 |
tuple(iterable) |
将可迭代对象转换为元组 | tuple([1, 2, 3]) → (1, 2, 3) |
# 转换列表为元组
list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1 = tuple(list1)
print(tuple1) # ('Google', 'Taobao', 'Runoob', 'Baidu')
元组解包
# 元组解包
tup = ('Google', 'Runoob', 1997, 2000)
(company1, company2, year1, year2) = tup
print(company1) # 'Google'
print(year1) # 1997
不可变性的真正含义
元组所指向的内存地址不能改变。如果元组包含可变对象（如列表），该对象内部仍可修改，但元组本身对该对象的引用不变。
tup = ('a', 'b', ['c', 'd'])
# 可以修改列表内容
tup[2][0] = 'X'
tup[2][1] = 'Y'
print(tup) # ('a', 'b', ['X', 'Y'])
# 但不能修改元组元素引用
# tup[2] = ['e', 'f'] # TypeError
10. Python3 字典
概述
字典是一个可变容器，存储键值对（key-value pairs）。
格式：{key1: value1, key2: value2}
关键特性
-
键必须唯一且不可变（字符串、数字、元组可以，列表不行）
-
值可以是任何数据类型，且不需要唯一
-
大小写敏感：‘Name’ 和 ‘name’ 是不同的键
创建字典
空字典
emptyDict = {}
# 或
emptyDict = dict()
带值字典
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 使用 dict() 构造器
dict1 = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
dict2 = dict(Runoob=1, Google=2, Taobao=3)
访问字典值
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(tinydict['Name']) # 'Runoob'
print(tinydict['Age']) # 7
# 如果键不存在会报错
# print(tinydict['School']) # KeyError
修改和添加
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 修改已存在的键
tinydict['Age'] = 8
# 添加新键值对
tinydict['School'] = "Tutorial"
print(tinydict)
# {'Name': 'Runoob', 'Age': 8, 'Class': 'First', 'School': 'Tutorial'}
删除字典元素
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 删除指定键
del tinydict['Name']
# 清空字典
tinydict.clear()
# 删除字典对象
del tinydict
字典方法
| 方法 | 描述 | 示例 |
|---|---|---|
len(dict) |
计算元素个数 | len(dict) |
str(dict) |
输出字典的字符串表示 | str(dict) |
type(variable) |
返回变量类型 | type(dict) |
dict.clear() |
删除所有元素 | dict.clear() |
dict.copy() |
浅拷贝 | dict2 = dict1.copy() |
dict.get(key, default=None) |
获取值，不存在返回默认值 | dict.get('Name', 'Unknown') |
dict.keys() |
返回所有键 | dict.keys() |
dict.values() |
返回所有值 | dict.values() |
dict.items() |
返回键值对元组 | dict.items() |
dict.pop(key) |
删除并返回指定键的值 | dict.pop('Name') |
dict.update(dict2) |
合并字典 | dict1.update(dict2) |
字典遍历
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 遍历键
for key in tinydict:
print(key)
# 遍历键值对
for key, value in tinydict.items():
print(f"{key}: {value}")
# 遍历值
for value in tinydict.values():
print(value)
字典推导式
# 创建平方字典
squares = {x: x**2 for x in range(1, 6)}
print(squares) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 带条件的字典推导式
even_squares = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(even_squares) # {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
11. Python3 集合
什么是集合
集合是一个无序的不重复元素序列。支持交集、并集、差集等常见集合操作。
创建集合
# 使用大括号
set1 = {1, 2, 3, 4}
# 使用 set() 函数
set2 = set([4, 5, 6, 7])
# 从字符串创建
set3 = set('hello')
print(set3) # {'h', 'e', 'l', 'o'} - 自动去重
注意：空集合必须用 set()，{} 创建的是空字典。
empty_set = set() # 正确
empty_dict = {} # 这是字典
添加元素
add() - 添加单个元素
s = {1, 2, 3}
s.add(4)
print(s) # {1, 2, 3, 4}
update() - 添加多个元素
s = {1, 2, 3}
s.update([4, 5, 6])
print(s) # {1, 2, 3, 4, 5, 6}
# 也可以添加元组、集合等
s.update({7, 8}, (9, 10))
print(s) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
移除元素
| 方法 | 描述 | 元素不存在时 |
|---|---|---|
remove(x) |
移除元素 | 报错 KeyError |
discard(x) |
移除元素 | 不报错 |
pop() |
随机删除一个元素并返回 | 集合为空时报错 |
s = {1, 2, 3, 4, 5}
# remove - 元素不存在会报错
s.remove(3)
print(s) # {1, 2, 4, 5}
# discard - 元素不存在不会报错
s.discard(10) # 没有错误
print(s) # {1, 2, 4, 5}
# pop - 随机删除
x = s.pop()
print(f"删除了: {x}")
print(s)
集合运算
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
| 运算符 | 方法 | 描述 | 示例结果 |
|---|---|---|---|
- |
difference() |
差集 | {1, 2} |
| ` | ` | union() |
并集 |
& |
intersection() |
交集 | {3, 4} |
^ |
symmetric_difference() |
对称差 | {1, 2, 5, 6} |
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
# 差集：a 中有但 b 中没有
print(a - b) # {1, 2}
# 并集：a 或 b 中的所有元素
print(a | b) # {1, 2, 3, 4, 5, 6}
# 交集：a 和 b 都有的元素
print(a & b) # {3, 4}
# 对称差：不同时包含于 a 和 b 的元素
print(a ^ b) # {1, 2, 5, 6}
其他操作
s = {1, 2, 3, 4, 5}
# 计算元素个数
print(len(s)) # 5
# 清空集合
s.clear()
print(s) # set()
# 判断元素是否存在
s = {1, 2, 3}
print(2 in s) # True
print(10 in s) # False
集合推导式
# 从字符串创建集合，排除某些字符
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a) # {'r', 'd'}
# 创建平方集合
squares = {x**2 for x in range(1, 6)}
print(squares) # {1, 4, 9, 16, 25}
集合方法总结
| 方法 | 描述 |
|---|---|
add(x) |
添加元素 |
update(x) |
添加多个元素 |
remove(x) |
删除元素（不存在则报错） |
discard(x) |
删除元素（不存在不报错） |
pop() |
随机删除并返回元素 |
clear() |
清空集合 |
union(set) |
返回并集 |
intersection(set) |
返回交集 |
difference(set) |
返回差集 |
symmetric_difference(set) |
返回对称差 |
issubset(set) |
判断是否为子集 |
issuperset(set) |
判断是否为超集 |
isdisjoint(set) |
判断是否没有交集 |
12. Python3 条件控制
核心概念
Python 使用 if、elif 和 else 关键字实现条件判断，根据条件的真假值决定执行的代码块。
基本语法
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
关键点：
-
每个条件后需要冒号
: -
使用缩进划分语句块（通常是 4 个空格）
-
Python 中没有
switch...case（Python 3.10+ 新增match...case）
简单条件判断
var1 = 100
if var1:
print("变量 var1 的值为:", var1)
# 输出：变量 var1 的值为: 100
if-else 语句
age = 18
if age >= 18:
print("你已经成年了")
else:
print("你还未成年")
if-elif-else 语句
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 70:
print("中等")
elif score >= 60:
print("及格")
else:
print("不及格")
嵌套 if 语句
num = int(input("输入一个数字："))
if num % 2 == 0:
if num % 3 == 0:
print("你输入的数字可以整除 2 和 3")
else:
print("你输入的数字可以整除 2，但不能整除 3")
else:
if num % 3 == 0:
print("你输入的数字可以整除 3，但不能整除 2")
else:
print("你输入的数字不能整除 2 和 3")
常用比较运算符
| 运算符 | 含义 | 示例 |
|---|---|---|
< |
小于 | x < y |
<= |
小于等于 | x <= y |
> |
大于 | x > y |
>= |
大于等于 | x >= y |
== |
等于 | x == y |
!= |
不等于 | x != y |
逻辑运算符
x = 10
y = 20
# and - 与
if x > 0 and y > 0:
print("x 和 y 都是正数")
# or - 或
if x > 0 or y > 0:
print("至少有一个是正数")
# not - 非
if not x > 20:
print("x 不大于 20")
三元运算符
Python 支持简洁的三元条件表达式：
# 语法：value_if_true if condition else value_if_false
age = 18
status = "成年" if age >= 18 else "未成年"
print(status) # 成年
# 示例
a = 10
b = 20
max_value = a if a > b else b
print(max_value) # 20
Python 3.10+ match-case 语句
Python 3.10 引入了 match...case 提供更现代的模式匹配方式。
def http_status(status):
match status:
case 400:
return "Bad request"
case 401:
return "Unauthorized"
case 403:
return "Forbidden"
case 404:
return "Not found"
case _:
return "Other error"
print(http_status(404)) # Not found
print(http_status(500)) # Other error
match-case 的高级用法：
# 匹配多个值
def day_type(day):
match day:
case "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday":
return "工作日"
case "Saturday" | "Sunday":
return "周末"
case _:
return "无效的日期"
# 模式匹配
def parse_point(point):
match point:
case (0, 0):
return "原点"
case (0, y):
return f"Y轴上的点: {y}"
case (x, 0):
return f"X轴上的点: {x}"
case (x, y):
return f"点: ({x}, {y})"
13. Python3 循环语句
主要循环类型
Python 提供两种主要循环结构：
-
while 循环 - 当条件为真时持续执行
-
for 循环 - 遍历序列（如列表、字符串）中的元素
while 循环
基本语法
while condition:
statements
示例
# 计数循环
count = 0
while count < 5:
print(count)
count += 1
# 输出：0 1 2 3 4
无限循环
# 注意：这会一直运行，慎用！
# while True:
# print("无限循环")
while-else
count = 0
while count < 5:
print(count)
count += 1
else:
print("循环正常结束")
# 输出：0 1 2 3 4
# 循环正常结束
for 循环
基本语法
for variable in sequence:
statements
遍历列表
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
print(fruit)
# 输出：apple
# banana
# orange
遍历字符串
for char in "Python":
print(char)
# 输出：P y t h o n
使用 range()
range() 函数生成数字序列。
# range(stop)
for i in range(5):
print(i)
# 输出：0 1 2 3 4
# range(start, stop)
for i in range(2, 6):
print(i)
# 输出：2 3 4 5
# range(start, stop, step)
for i in range(0, 10, 2):
print(i)
# 输出：0 2 4 6 8
for-else
for i in range(5):
print(i)
else:
print("循环正常结束")
# 输出：0 1 2 3 4
# 循环正常结束
循环控制语句
break - 终止循环
break 立即终止循环，跳过 else 子句。
for i in range(10):
if i == 5:
break
print(i)
# 输出：0 1 2 3 4
# 查找质数示例
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(f"{n} 等于 {x} * {n//x}")
break
else:
# 循环中没有找到因子
print(f"{n} 是质数")
continue - 跳过当前迭代
continue 跳过当前循环的剩余语句，进入下一次迭代。
for i in range(10):
if i % 2 == 0:
continue
print(i)
# 输出：1 3 5 7 9（只输出奇数）
pass - 空语句
pass 是一个空操作，用作占位符。
for i in range(5):
if i == 3:
pass # 什么都不做，继续执行
print(i)
# 输出：0 1 2 3 4
在定义空函数或类时很有用：
def my_function():
pass # TODO: 以后实现
class MyClass:
pass # TODO: 以后实现
嵌套循环
# 九九乘法表
for i in range(1, 10):
for j in range(1, i + 1):
print(f"{j}×{i}={i*j}", end="\t")
print()
实用示例
计算 1 到 100 的总和
total = 0
counter = 1
while counter <= 100:
total += counter
counter += 1
print(f"1 到 100 的总和为: {total}")
# 输出：1 到 100 的总和为: 5050
遍历字典
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
# 遍历键值对
for k, v in knights.items():
print(k, v)
# 输出：gallahad the pure
# robin the brave
同时遍历索引和值
fruits = ['apple', 'banana', 'orange']
for index, value in enumerate(fruits):
print(f"{index}: {value}")
# 输出：0: apple
# 1: banana
# 2: orange
同时遍历两个序列
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
print(f'What is your {q}? It is {a}.')
# 输出：What is your name? It is lancelot.
# What is your quest? It is the holy grail.
# What is your favorite color? It is blue.
总结
本笔记涵盖了 Python3 基础语法的核心内容，包括：
数据类型 - 6大标准数据类型及其转换
解释器 - 交互式与脚本式编程
注释 - 单行和多行注释规范
运算符 - 算术、比较、逻辑、位、成员、身份运算符
数字 - 整型、浮点型、复数及数学函数
字符串 - 索引、切片、格式化、常用方法
列表 - 创建、访问、修改、常用操作
元组 - 不可变序列的特性和应用
字典 - 键值对映射及常用方法
集合 - 无序不重复集合及集合运算
条件控制 - if-elif-else 和 match-case
循环语句 - while 和 for 循环及控制语句