Python基础入门(一)

Python基础入门

一、Python 概述

1.1 Python 简介

Python 是一种高级、通用、解释型的编程语言。

语言特性

1. 简洁易读 ：Python 使用缩进来表示代码块，避免了像其他语言那样使用大量的括号，语法简洁，代码可读性高。例如打印“Hello, World!”：

print("Hello, World!")

2. 动态类型 ：在 Python 中，变量类型不需要预先声明，解释器会根据赋值自动确定变量类型。

x = 10  # 整数类型
x = "Hello"  # 字符串类型

3. 面向对象 ：支持面向对象编程，具备类、对象、继承等面向对象的特性。

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

    def speak(self):
        print(f"{self.name} makes a sound.")

dog = Animal("Dog")
dog.speak()

• 解释执行 ：Python 是解释型语言，代码无需编译，逐行解释执行，方便调试和快速开发。

1.2 应用领域

• 数据科学与人工智能：在数据分析、机器学习、深度学习等领域广泛应用，相关库如 NumPy、Pandas、Scikit - learn、TensorFlow 等。
  数据分析‌：通过Pandas、NumPy进行数据清洗与建模。
  ‌机器学习/深度学习‌：借助TensorFlow、PyTorch开发AI模型，应用于图像识别、自然语言处理等领域。
  科学计算‌：SciPy和Matplotlib支持复杂数学运算与可视化。
• 自动化脚本‌：可用于系统管理、文件处理、网络爬虫等自动化任务。
• Web开发‌：可通过Django、Flask 等Web 框架，开发网站和 Web 应用。
• 游戏开发：使用 Pygame 等库可以开发2D游戏。

二、基础语法

2.1 变量与数据类型

2.1.1 变量定义与命名规则

变量用于存储数据，在 Python 里无需声明类型，直接赋值即可。例如：text = "Hello, World!"。
变量使用遵循规则

• 变量名只能包含字母、数字和下划线，不能以数字开头
• 不能使用 Python 关键字和函数名
• 变量名不能包含空格

text = "Hello, World!"
print(text)

结果为:Hello, World!

msg_1 = "变量1"
print(msg_1)

结果为：变量1

多个变量，可同时赋值。变量名之间使用逗号分开，值也使用逗号分开

v1, v2, v3 = 1, 2, 3.1
print(v1)
print(v2)
print(v3)

结果为：
1
2
3.1

反例1

1 = "变量2"
print(1)

报错

反例2

1_msg = "变量3"
print(1_msg)

报错

2.1.2 基本数据类型

• 整数（int）：可表示任意大小的整数，如 10、-5。
• 浮点数（float）：表示小数，如 3.14、-0.5。
• 布尔值（bool）：只有 True 和 False 两个值，常用于条件判断。
• 字符串（str）：一系列的字符。用单引号、双引号或三引号包裹的文本，如 'hello'、"world"。

1. 整数

可对整数进行加（+）减（-）乘（*）除（/）运算，乘方运算(两个乘号**)。

整数运算

s1 = 1
s2 = 2
s3 = s1 + s2
print(s3)

结果为：3

乘方运算

s4 = 2 ** 3
print(s4)

结果为：8

使用下划线将数的位进行分组，结果是整数

print(1_000_0000_00000)

结果为：1000000000000

2. 浮点数

带小数点的数称为浮点数。

f1 = 0.2 + 0.2
print(f1)
f2 = 0.3 * 0.1
print(f2)

结果为：
0.4
0.03

整数和浮点数运算，结果为浮点数

# 整数和浮点数运算
print(2.0 ** 3)
print(2 * 3.1)
print(2 + 3.1)
print(2 - 3.1)

结果为：
8.0
6.2
5.1
-1.1

可以使用下划线将数的位进行分组，结果是浮点数

print(1_000_0000_00.000)

结果为：1000000000.0

3. 布尔值

布尔类型：表示逻辑上的“真”或“假”，布尔类型有两个固定的值：True和False，首字母大写。

x = True
y = False
print(x)
print(y)
print(x and y)
print(x or y)
print(not x)
print(not y)
print(x == y)

结果为：
True
False
False
True
False
True
False

4. 字符串

• 4.1 字符串大小写转换

msg = "test String operate"
# 转换小写
print(msg.lower())
# 转换大写
print(msg.upper())

结果为：
test string operate
TEST STRING OPERATE

• 4.2 字符串使用变量
  f 字符串( format的简写)，Python 通过把花括号内的变量替换为其值来设置字符串的格式。
  在字符串中插入变量的值，可先在左引号前加上字母 f。

msg = "test String operate"
msg_2 = "test format"
result = f"{msg} {msg_2}"
print(result)

结果为：
test String operate test format

2.1.3 数据类型转换

• 1.自动类型转换。Python会自动地将不同类型的数据转换为同类型数据进行计算。
• 2.强制类型转换。需要显式的将一个数据类型转换为另一个数据类型。

1 自动类型转换

• 整数与浮点数进行算术运算，整数会自动转换为浮点数然后再进行运算。

a1 = 100
a2 = 10.1
result_add = a1 + a2
print(result_add)
print(type(a1))
print(type(a2))
print(type(result_add))

结果为：
110.1
<class 'int'>
<class 'float'>
<class 'float'>

• 布尔值算术运算。True会当作1，False会当作0进行运算。

bo1 = True
print(type(bo1))
bo2 = 22
print(type(bo2))
bo3 = bo1 + bo2 + False
print(bo3)
print(type(bo1 + bo2))
print(type(bo3))

结果为：
<class 'bool'>
<class 'int'>
23
<class 'int'>
<class 'int'>

2 强制类型转换

可使用函数将一个类型转换成另一个类型。

• int( )：转成整数类型
• str( )：转成字符串类型
• float( )：转成浮点型
• bool( )：转成布尔类型
• tuple( )：转成元组类型
• dict( )：转成字典类型
• set( )：转成集合类型
• list( )：转成列表类型

f1 = 10.1 
int_f1 = int(f1) # 浮点型转成整数类型,结果截取整数部分
print("浮点型转成整数类型: ", int_f1, type(int_f1)) 
a1 = 100
print("整数类型: ", a1, type(a1))
conv_str = str(a1) # 整数类型转成字符串类型
print("整型转成字符串类型: ", conv_str, type(conv_str))
conv_int = int(conv_str) # 字符串转成整数类型
print("字符串转成整数类型: ", conv_int, type(conv_int))
conv_flat = float(conv_str) # c
print("字符串转成整数类型: ", conv_flat, type(conv_flat))
str_num = "1" # 字符串转成布尔类型
conv_boo = bool(str_num)
print("字符串转成布尔类型: ", conv_boo, type(conv_boo))
boo_value = True
int_boo = int(boo_value) # 布尔类型转成整数类型
print("布尔类型转成整数类型: ", int_boo, type(int_boo))
str_boo = str(boo_value) # 布尔类型转成字符串类型
print("布尔类型转成字符串类型: ", str_boo, type(str_boo))

结果为：
浮点型转成整数类型:  10 <class 'int'>
整数类型:  100 <class 'int'>
整型转成字符串类型:  100 <class 'str'>
字符串转成整数类型:  100 <class 'int'>
字符串转成整数类型:  100.0 <class 'float'>
字符串转成布尔类型:  True <class 'bool'>
布尔类型转成整数类型:  1 <class 'int'>
布尔类型转成字符串类型:  True <class 'str'>

v_str = "Hello"
v_lista = list(v_str)  # 字符串转成列表,每个元素放入列表中
print("字符串转成列表: ", v_lista, type(v_lista))
v_listb = ["a", "b", "c"]  # 列表转成字符串
v_strb = "".join(v_listb)  # 列表转成字符串,每个元素拼接成字符串
print("列表转成字符串: ", v_strb, type(v_strb))
# 元组转成列表
v_tuple = (1, 2, 3)  # 元组转成列表
v_listc = list(v_tuple)
print("元组转成列表: ", v_listc, type(v_listc))
#列表转成元组
v_listd = [1, 2, 3]  # 列表转成元组
v_tupleb = tuple(v_listd)
print("列表转成元组: ", v_tupleb, type(v_tupleb))
# 字符串转成元组
v_strc = "Hello"  # 字符串转成元组
v_tuplec = tuple(v_strc)
print("字符串转成元组: ", v_tuplec, type(v_tuplec))
#集合转换为列表
v_set = {1, 2, 3}  # 集合转成列表
v_liste = list(v_set)
print("集合转成列表: ", v_liste, type(v_liste))
# 列表转成集合
v_listf = [1, 2, 3]  # 列表转成集合
v_setb = set(v_listf)  # 列表转成集合,去重
print("列表转成集合: ", v_setb, type(v_setb))
# 字典转成列表
v_dict = {"a": 1, "b": 2, "c": 3}  # 字典转成列表
v_listg = list(v_dict)  # 字典转成列表,只保留键
print("字典转成列表: ", v_listg, type(v_listg))
# 列表转成字典
v_listh = [("a", 1), ("b", 2), ("c", 3)]  # 列表转成字典,每个元素是元组,元组的第一个元素作为键,第二个元素作为值
v_dictb = dict(v_listh)
print("列表转成字典: ", v_dictb, type(v_dictb))

结果为：
字符串转成列表:  ['H', 'e', 'l', 'l', 'o'] <class 'list'>
列表转成字符串:  abc <class 'str'>
元组转成列表:  [1, 2, 3] <class 'list'>
列表转成元组:  (1, 2, 3) <class 'tuple'>
字符串转成元组:  ('H', 'e', 'l', 'l', 'o') <class 'tuple'>
集合转成列表:  [1, 2, 3] <class 'list'>
列表转成集合:  {1, 2, 3} <class 'set'>
字典转成列表:  ['a', 'b', 'c'] <class 'list'>
列表转成字典:  {'a': 1, 'b': 2, 'c': 3} <class 'dict'>

2.2 运算符

2.2.1 算术运算符

• 包括 +（加）、-（减）、*（乘）、/（除）、//（整除）、%（取余）、**（幂运算）。

v1 = 10
v2 = 20
print("v1 = ", v1)
print("v2 = ", v2)
print("加法: v1 + v2 = ", v1 + v2)  # 加法
print("减法: v1 - v2 = ", v1 - v2)  # 减法
print("乘法: v1 * v2 =", v1 * v2)  # 乘法
print("除法: v1 / v2 = ", v1 / v2)  # 除法
print("取整: v1 // v2 = ", v1 // v2)  # 取整
print("取余: v1 % v2 = ", v1 % v2)  # 取余
print("幂运算: v1 ** v2 = ", v1 ** v2)  # 幂运算

结果为：
v1 =  10
v2 =  20
加法: v1 + v2 =  30
减法: v1 - v2 =  -10
乘法: v1 * v2 = 200
除法: v1 / v2 =  0.5
取整: v1 // v2 =  0
取余: v1 % v2 =  10
幂运算: v1 ** v2 =  100000000000000000000

2.2.2 比较运算符

• 如 ==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于），返回布尔值。

v1 = 10
v2 = 20
print("v1 = ", v1)
print("v2 = ", v2)
print("等于 v1 == v2: ", v1 == v2)  # 等于
print("不等于 v1 != v2: ", v1 != v2)  # 不等于
print("大于 v1 > v2: ", v1 > v2)  # 大于
print("小于 v1 < v2: ", v1 < v2)  # 小于
print("大于等于 v1 >= v2: ", v1 >= v2)  # 大于等于
print("小于等于 v1 <= v2: ", v1 <= v2)  # 小于等于

结果为：
v1 =  10
v2 =  20
等于 v1 == v2:  False
不等于 v1 != v2:  True
大于 v1 > v2:  False
小于 v1 < v2:  True
大于等于 v1 >= v2:  False
小于等于 v1 <= v2:  True

2.2.3 逻辑运算符

• and（与）、or（或）、not（非），用于组合条件判断。

v1 = True
v2 = False
print("v1 = ", v1)
print("v2 = ", v2)
print("逻辑与 v1 and v2: ", v1 and v2)  # 逻辑与
print("逻辑或 v1 or v2: ", v1 or v2)  # 逻辑或
print("逻辑非 not v1: ", not v1)  # 逻辑非
print("逻辑非 not v2: ", not v2)  # 逻辑非

结果为：
v1 =  True
v2 =  False
逻辑与 v1 and v2:  False
逻辑或 v1 or v2:  True
逻辑非 not v1:  False
逻辑非 not v2:  True

2.2.4 赋值运算符

• =（赋值）
• +=（加后赋值）
• -=（减后赋值）
• *=（乘后赋值）
• /=（除后赋值）
• %=（取余后赋值）
• **=（幂运算后赋值）
• //= （取整后赋值）

v1 = 5
v2 = 2
print("v1 = ", v1)
print("v2 = ", v2)
v1 += v2  # 加法赋值
print("加法赋值 v1 += v2: ", v1)
v1 -= v2  # 减法赋值
print("减法赋值 v1 -= v2: ", v1)
v1 *= v2  # 乘法赋值
print("乘法赋值 v1 *= v2: ", v1)
v1 /= v2  # 除法赋值
print("除法赋值 v1 /= v2: ", v1)
v1 %= v2  # 取余赋值
print("取余赋值 v1 %= v2: ", v1)
v1 **= v2  # 幂运算赋值
print("幂运算赋值 v1 **= v2: ", v1)
v1 //= v2  # 取整赋值
print("取整赋值 v1 //= v2: ", v1)

结果为：
赋值运算符
v1 =  5
v2 =  2
加法赋值 v1 += v2:  7
减法赋值 v1 -= v2:  5
乘法赋值 v1 *= v2:  10
除法赋值 v1 /= v2:  5.0
取余赋值 v1 %= v2:  1.0
幂运算赋值 v1 **= v2:  1.0
取整赋值 v1 //= v2:  0.0

2.2.5 位运算符

• 对二进制数进行操作，如 &（按位与）、|（按位或）、^(按位异或)、~(按位取反)等。

v1 = 10  # 二进制  1010
v2 = 20  # 二进制 10100
print("v1 = ", v1)
print("v2 = ", v2)
print("按位与 v1 & v2: ", v1 & v2)  # 按位与
print("按位或 v1 | v2: ", v1 | v2)  # 按位或
print("按位异或 v1 ^ v2: ", v1 ^ v2)  # 按位异或
print("按位取反 ~v1: ", ~v1)  # 按位取反
print("左移 v1 << 2: ", v1 << 2)  # 左移
print("右移 v1 >> 2: ", v1 >> 2)  # 右移

结果为：
v1 =  10
v2 =  20
按位与 v1 & v2:  0
按位或 v1 | v2:  30
按位异或 v1 ^ v2:  30
按位取反 ~v1:  -11
左移 v1 << 2:  40
右移 v1 >> 2:  2

2.2.6 成员运算符

• in 和 not in，用于判断元素是否在序列中。

v1 = 10
v2 = 20
v3 = [10, 20, 30]
print("v1 = ", v1)
print("v2 = ", v2)
print("v3 = ", v3)
print("in 运算符 v1 in v3: ", v1 in v3)  # in 运算符
print("not in 运算符 v1 not in v3: ", v1 not in v3)  # not in 运算符
print("in 运算符 v2 in v3: ", v2 in v3)  # in 运算符
print("not in 运算符 v2 not in v3: ", v2 not in v3)  # not in 运算符

结果为：
v1 =  10
v2 =  20
v3 =  [10, 20, 30]
in 运算符 v1 in v3:  True
not in 运算符 v1 not in v3:  False
in 运算符 v2 in v3:  True
not in 运算符 v2 not in v3:  False

2.2.7 身份运算符

• is 和 is not，用于判断两个对象是否为同一个对象。

v1 = 10
v2 = 20
v3 = [10, 20, 30]
print("v1 = ", v1)
print("v2 = ", v2)
print("v3 = ", v3)
print("is 运算符 v1 is v2: ", v1 is v2)  # is 运算符
print("is not 运算符 v1 is not v2: ", v1 is not v2)  # is not 运算符
print("is 运算符 v1 is v3: ", v1 is v3)  # is 运算符
print("is not 运算符 v1 is not v3: ", v1 is not v3)  # is not 运算符
print("is 运算符 v2 is v3: ", v2 is v3)  # is 运算符
print("is not 运算符 v2 is not v3: ", v2 is not v3)  # is not 运算符

结果为：
v1 =  10
v2 =  20
v3 =  [10, 20, 30]
is 运算符 v1 is v2:  False
is not 运算符 v1 is not v2:  True
is 运算符 v1 is v3:  False
is not 运算符 v1 is not v3:  True
is 运算符 v2 is v3:  False
is not 运算符 v2 is not v3:  True

2.3 控制结构

控制结构主要分为条件语句、循环语句和跳转语句

2.3.1 条件语句

表达式可以是布尔值、变量、比较表达式、逻辑表达式等。

# 单分支
if 条件表达式:
    代码块

# 双分支
if 条件表达式:
    代码块1
else:
    代码块2

# 多分支
if 条件表达式1:
    代码块1
elif 条件表达式2:
    代码块2
...
else:
    代码块n

# 多分支条件语句示例
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

结果为：
良好

2.3.2 循环语句

• for 循环：常用于遍历序列。for 循环用于针对集合中的每个元素执行一个代码块。

for 变量 in 可迭代对象:
    循环体

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

结果为：
apple
banana
cherry

• while 循环：当条件为真时持续执行。while 循环不断地运行，直到指定的条件不再满足为止。

while 条件表达式:
    循环体

count = 0
while count < 5:
    print(count)
    count += 1

结果为：
0
1
2
3
4

2.3.3 跳转语句

1. break 用于跳出循环。

while 条件表达式:
    # 循环体代码
    if 特定条件:
        break
    # 其他循环体代码

for 变量 in 可迭代对象:
    # 循环体代码
    if 特定条件:
        break
    # 其他循环体代码

# while 循环中的 break
count = 0
while count < 10:
    if count == 3:
        break
    print(count)
    count += 1

# for 循环中的 break
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        break
    print(num)

结果为：
0
1
2

1
2

2. continue 用于跳过当前循环的剩余部分，直接进入下一次循环的判断。

while 条件表达式:
    # 循环体代码
    if 特定条件:
        continue
    # 其他循环体代码

for 变量 in 可迭代对象:
    # 循环体代码
    if 特定条件:
        continue
    # 其他循环体代码

# while 循环中的 continue
count = 0
while count < 5:
    count += 1
    if count == 3:
        continue
    print(count)

# for 循环中的 continue
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        continue
    print(num)

结果为：
1
2
4
5

1
3
5

3. pass 是一个空语句，不执行任何操作，通常作为占位符使用，保持代码结构的完整性。

while 条件表达式:
    # 循环体代码
    if 特定条件:
        pass
    # 其他循环体代码

for 变量 in 可迭代对象:
    # 循环体代码
    if 特定条件:
        pass
    # 其他循环体代码

# for 循环中的 pass
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        pass  # 占位，后续可添加具体逻辑
    print(num)

结果为：
1
2
3
4
5

三、数据结构

3.1 列表（List）

列表（list）由一系列按特定顺序排列的元素组成，通常用于存储一组相关的值。

• 列表的元素可以是不同类型的，但通常用于存储相同类型的数据。
• 列表的元素可以通过索引、切片、循环访问和修改。
• 列表的元素可以通过解包赋值给多个变量，但不能修改。
• 列表的元素可以通过比较运算符比较，但不能修改。
• 列表的元素可以通过成员运算符 in 或 not in 检查，但不能修改。

3.1.1 列表创建与访问

要访问列表元素，可指出列表的名称，再指出元素的索引，并将后者放在方括号内，索引从0开始。

my_list = [1, 2, 3, "hello"]
print(my_list[0])  # 访问第一个元素

结果为：
1

3.1.2 列表常用操作

• 增删改查：append() 末尾追加元素，remove() 删除指定元素，直接赋值修改元素。

my_list = [1, 2, 3, "hello"]
print(my_list[0])  # 访问第一个元素
print(my_list[-1])  # 访问最后一个元素
my_list.append(4) # 在末尾添加元素
print("添加元素后的列表：", my_list)  # 在末尾添加元素后的列表

my_list.remove(2) # 删除元素2
print("删除元素后的列表: ", my_list)  # 删除元素2后的列表
my_list[0] = 10 # 修改第一个元素的值为10
print("修改后的列表: ", my_list)  # 修改后的列表

结果为：
1
hello
添加元素后的列表： [1, 2, 3, 'hello', 4]
删除元素后的列表:  [1, 3, 'hello', 4]
修改后的列表:  [10, 3, 'hello', 4]

• 删除列表
  对于已经创建的列表，不使用时候可使用del进行删除。

del 列表名称

fruits = ["apple", "banana", "cherry"]
del fruits[0]  # 删除索引为 0 的元素
print(fruits)  # 输出: ['banana', 'cherry']

结果为：
['banana', 'cherry']

• 排序与反转：sort() 排序，reverse() 反转。

num_list = [10, 3, 4]
# 使用 sort() 方法进行升序排序
num_list.sort()
print("升序排序后的列表: ", num_list)

# 使用 sort() 方法进行降序排序
num_list.sort(reverse=True)
print("降序排序后的列表: ", num_list)

# 使用 sorted() 函数进行排序，原列表不会改变
new_sorted_list = sorted(num_list)
print("使用 sorted() 函数升序排序后的新列表: ", new_sorted_list)
print("原列表: ", num_list)

# 使用 reverse() 方法反转列表
num_list.reverse()
print("反转后的列表: ", num_list)

# 使用切片反转列表，原列表不会改变
reversed_slice_list = num_list[::-1]
print("使用切片反转后的新列表: ", reversed_slice_list)
print("原列表: ", num_list)

结果为：
升序排序后的列表:  [3, 4, 10]
降序排序后的列表:  [10, 4, 3]
使用 sorted() 函数升序排序后的新列表:  [3, 4, 10]
原列表:  [10, 4, 3]
反转后的列表:  [3, 4, 10]
使用切片反转后的新列表:  [10, 4, 3]
原列表:  [3, 4, 10]

• 列表推导式：

列表推导式是 Python 中一种简洁创建列表的方式，它可以用一行代码替代多行 for 循环和 if 语句，让代码更加简洁易读。

1. 基本形式
   遍历可迭代对象中的每个元素，将其代入表达式计算结果，最终组成一个新的列表。

[表达式 for 变量 in 可迭代对象]

2. 带条件判断的形式
   在遍历可迭代对象时，会先判断元素是否满足 if 后的条件表达式，只有满足条件的元素才会代入表达式计算结果并添加到新列表中。

[表达式 for 变量 in 可迭代对象 if 条件表达式]

3. 多重循环形式
   进行嵌套循环，先遍历 可迭代对象1 ，对于其中每个元素，再遍历 可迭代对象2 ，将每次循环的结果代入表达式计算并组成新列表。

[表达式 for 变量1 in 可迭代对象1 for 变量2 in 可迭代对象2]

# 1. 基本推导式：生成0到9的平方列表
squares = [ x ** 2 for x in range(10)]
print("0到9的平方列表: ", squares)
# 2. 带有条件的推导式，生成0到9的平方列表，只保留偶数
squares_2 = [ x ** 2 for x in range(10) if x%2 == 0 ]
print("0到9的平方列表，只保留偶数:", squares_2)
# 3. 多重循环嵌套推导式，将二维列表展平为一维列表
squares_3 = [ [1, 2, 3], [ 4, 5, 6], [7, 8, 9] ]
calculate_squares = [ i for row in squares_3 for i in row ]
print("将二维列表展平为一维列表: ", calculate_squares)
# 4. 带有if-else条件的推导式，生成0到9的平方列表，奇数为其平方，偶数为其立方
squares_4 = [ 1, 2, 3 , 4, 5]
new_squares_4 = [ x ** 2 if x% 2 == 0 else x ** 3 for x in squares_4 ]
print("0到9的平方列表，奇数为其平方，偶数为其立方: ", new_squares_4)

结果为：
0到9的平方列表:  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
0到9的平方列表，只保留偶数: [0, 4, 16, 36, 64]
将二维列表展平为一维列表:  [1, 2, 3, 4, 5, 6, 7, 8, 9]
0到9的平方列表，奇数为其平方，偶数为其立方:  [1, 4, 27, 16, 125]

3.2 元组（Tuple）

不能修改的值称作为不可变的，不可变的列表称作为元组(Tuple)。

• 元组是不可变的序列，通常用于存储一组相关的值。
• 元组的元素可以是不同类型的，但通常用于存储相同类型的数据。
• 元组的元素可以通过索引、切片、循环访问，但不能修改。
• 元组的元素可以通过解包赋值给多个变量，但不能修改。
• 元组的元素可以通过比较运算符比较，但不能修改。
• 元组的元素可以通过成员运算符 in 或 not in 检查，但不能修改。

3.2.1 元组创建与访问

• 创建元组

my_tuple = (1, 2, 3)
print(my_tuple[0])

结果为：
1

或者使用tuple()函数创建

tuple(obj)
# 此处的obj 需要是可以转换成元组的数据，可以是元组、字符串、列表、range对象等可以迭代的类型

• 访问元组

# 通过索引访问
my_tuple = (1, 2, 3, 4)
print("访问第一个元素: ", my_tuple[0])  # 输出：1
print("访问最后一个元素:", my_tuple[-1]) # 输出：4
# 通过切片访问，包含左边索引的元素，不包含右边索引的元素
print("通过切片访问: ", my_tuple[1:3]) # 从索引1到索引3
# 循环访问
for item in my_tuple:
    print("通过循环访问元组元素: ", item)
# 解包赋值
a, b, c, d = my_tuple
print("解包赋值: ", a, b, c, d)
# 比较运算符
print("比较运算符: ", my_tuple == (1, 2, 3, 4))  # 输出：True
print("比较运算符: ", my_tuple != (1, 2, 3, 5))  # 输出：True
# 成员运算符
print("成员运算符: ", 3 in my_tuple)  # 输出：True
print("成员运算符: ", 6 not in my_tuple)  # 输出：True

结果为：
访问第一个元素:  1
访问最后一个元素: 4
通过切片访问:  (2, 3)
通过循环访问元组元素:  1
通过循环访问元组元素:  2
通过循环访问元组元素:  3
通过循环访问元组元素:  4
解包赋值:  1 2 3 4
比较运算符:  True
比较运算符:  True
成员运算符:  True
成员运算符:  True

3.2.2 元组不可变性

• 元组创建后元素不可修改，但可进行索引访问。

my_tuple = (1, 2, 3)
print(my_tuple[0])  # 输出：1
my_tuple[0] = 4
print("修改元组数据: ", my_tuple)

结果为：
1
Traceback (most recent call last):
  File "e:\space\python\base\tuple_demo.py", line 19, in <module>
    my_tuple[0] = 4
TypeError: 'tuple' object does not support item assignment

3.2.3 元组应用场景

• 用于存储不可变的数据。

3.3 集合（Set）

• 集合是可变的无序集合，通常用于存储唯一的值。
• 集合的元素必须是不可变的类型，如字符串、数字或元组。
• 集合的元素可以通过循环访问和修改。
• 集合的元素可以通过解包赋值给多个变量，但不能修改。
• 集合的元素可以通过比较运算符比较，但不能修改。
• 集合的元素可以通过成员运算符 in 或 not in 检查，但不能修改。
• 集合的元素可以通过集合运算符进行并集、交集、差集等操作，但不能修改。
• 集合的元素可以通过集合方法进行添加、删除、清空等操作，但不能修改。

3.3.1 集合创建

• 创建集合
  使用{} 或者set()函数

my_set = {1, 2, 3, 3}  # 重复元素会被自动去重
print("创建集合: ", my_set)  # 输出：{1, 2, 3}

结果为：
创建集合:  {1, 2, 3}

# 使用 set() 函数创建空集合
empty_set = set()
print("空集合: ", empty_set)
# 将列表转换为集合
list_data = [1, 2, 2, 3, 4, 4, 5]
set_from_list = set(list_data)
print("由列表转换而来的集合: ", set_from_list)
# 将元组转换为集合
tuple_data = (10, 20, 20, 30)
set_from_tuple = set(tuple_data)
print("由元组转换而来的集合: ", set_from_tuple)
# 将字符串转换为集合
str_data = "hello"
set_from_str = set(str_data)
print("由字符串转换而来的集合: ", set_from_str)

结果为：
空集合:  set()
由列表转换而来的集合:  {1, 2, 3, 4, 5}
由元组转换而来的集合:  {10, 20, 30}
由字符串转换而来的集合:  {'o', 'e', 'h', 'l'}

3.3.2 集合常用操作

• 并集、交集、差集、对称差：union()、intersection()、difference()、symmetric_difference()。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print("并集: ", set1.union(set2))  # 输出：{1, 2, 3, 4, 5}
print("交集: ", set1.intersection(set2))  # 输出：{3}
print("差集: ", set1.difference(set2))  # 输出：{1, 2}
print("对称差集: ", set1.symmetric_difference(set2))  # 输出：{1, 2, 4, 5}

结果为：
并集:  {1, 2, 3, 4, 5}
交集:  {3}
差集:  {1, 2}
对称差集:  {1, 2, 4, 5}

• 集合增删：add() 添加元素，remove() 删除元素、clear()清空集合。

my_set = {1, 2, 3, 3}  # 重复元素会被自动去重
print("创建集合: ", my_set)  # 输出：{1, 2, 3}
# 添加元素
my_set.add(4)
print("添加元素: ", my_set)  # 输出：{1, 2, 3, 4}
# 删除元素
my_set.remove(2)
print("删除元素: ", my_set)  # 输出：{1, 3, 4}
# pop() 方法用于移除并返回集合中的一个随机元素
removed_element = my_set.pop()
print("移除并返回一个随机元素: ", removed_element)  # 输出 ：1
# 清空集合
my_set.clear()
print("清空集合: ", my_set)  # 输出：set()
# delete 集合
del my_set
# print("删除集合: ", my_set)  # 报错：NameError: name 'my_set' is not defined

结果为：
创建集合:  {1, 2, 3}
添加元素:  {1, 2, 3, 4}
删除元素:  {1, 3, 4}
移除并返回一个随机元素:  1
清空集合:  set()

3.4 字典（Dictionary）

• 字典是可变的映射类型，通常用于存储键值对。
• 字典的键必须是不可变的类型，如字符串、数字或元组。
• 字典的值可以是任意类型的对象。
• 字典的元素可以通过键、循环访问和修改。
• 字典的元素可以通过解包赋值给多个变量，但不能修改。
• 字典的元素可以通过比较运算符比较，但不能修改。
• 字典的元素可以通过成员运算符 in 或 not in 检查，但不能修改。

3.4.1 字典创建

字典每个元素包含"键"和"值"两部分，"键"和"值"通过冒号分隔，相邻的两个元素使用逗号分隔。

• 创建字典
  使用花括号{}或 dict() 函数创建字典。

# 使用花括号 {} 或 dict() 函数创建字典
empty_dict = {}  # 空字典
print("空字典: ", empty_dict)
dict_from_list = dict([('a', 1), ('b', 2)])  # 从列表创建字典
print("从列表创建字典: ", dict_from_list)
dict_from_tuple = dict((('a', 1), ('b', 2)))  # 从元组创建字典
print("从元组创建字典: ", dict_from_tuple)
dict_from_str = dict(a="1", b="2")  # 从字符串创建字典
print("从字符串创建字典: ", dict_from_str)

结果为：
空字典:  {}
从列表创建字典:  {'a': 1, 'b': 2}
从元组创建字典:  {'a': 1, 'b': 2}
从字符串创建字典:  {'a': '1', 'b': '2'}

3.4.2 字典常用操作

• 增删改查：直接赋值添加或修改元素，pop() 删除元素。

# 访问字典元素
my_dict = {'name': '张三', 'age': 25}
print("访问字典元素: ", my_dict['name'])  # 输出：'张三'
# 修改字典元素
my_dict['age'] = 26  # 修改字典中的值
print("修改字典元素: ", my_dict)  # 输出：{'name': '张三', 'age': 26}
# 添加新的键值对
my_dict['city'] = 'S'  # 添加新的键值对
print("添加新的键值对: ", my_dict)  # 输出：{'name': '张三', 'age': 26}
# 删除键值对
del my_dict['age']  # 删除键值对
print("删除键值对: ", my_dict)  # 输出：{'name': '张三'}
# 检查键是否存在
print("检查键是否存在: ", 'name' in my_dict)  # 输出：True
# 遍历字典
for key, value in my_dict.items():  # 遍历字典的键值对
    print("遍历字典: ", key, value)  # 输出：'name' '张三'
# 字典方法
print("获取所有键: ", my_dict.keys())  # 输出：dict_keys(['name', 'age'])
print("获取所有值: ", my_dict.values())  # 输出：dict_values(['张三', 25])
print("获取所有键值对: ", my_dict.items())  # 输出：dict_items([('name', '张三'), ('age', 25)])
# pop() 方法用于移除并返回指定键的值
removed_value = my_dict.pop('city')  # 移除并返回指定键的值
print("移除并返回指定键的值: ", removed_value)  # 输出：'S'
# popitem() 方法用于移除并返回字典中的一个键值对
removed_item = my_dict.popitem()  # 移除并返回字典中的一个键值对
print("移除并返回字典中的一个键值对: ", removed_item)  # 输出：('name', '张三')
# 清空字典
my_dict.clear()  # 清空字典
print("清空字典: ", my_dict)  # 输出：{}
# 删除字典
del my_dict  # 删除字典
# print("删除字典: ", my_dict)  # 报错：NameError: name'my_dict' is not defined

结果为：
访问字典元素:  张三
修改字典元素:  {'name': '张三', 'age': 26}
添加新的键值对:  {'name': '张三', 'age': 26, 'city': 'S'}
删除键值对:  {'name': '张三', 'city': 'S'}
检查键是否存在:  True
遍历字典:  name 张三
遍历字典:  city S
获取所有键:  dict_keys(['name', 'city'])
获取所有值:  dict_values(['张三', 'S'])
获取所有键值对:  dict_items([('name', '张三'), ('city', 'S')])
移除并返回指定键的值:  S
移除并返回字典中的一个键值对:  ('name', '张三')
清空字典:  {}

• 字典推导式：new_dict = {k: v * 2 for k, v in my_dict.items()}。

1. 基本形式

{键表达式: 值表达式 for 变量 in 可迭代对象}

2. 带有if条件的推导

{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件表达式}

dict_base = { "key1" : 1, "key2" : 2, "key3" : 3 , "key4" : 4, "key5" : 5 }
# 1. 基本推导式，生成一个新字典，键值对互换
dict_1 = { value: key for key, value in dict_base.items()}
print("键值对互换后的字典: ", dict_1)
# 2. 带有条件的推导式，生成一个新字典，只保留键值对中值为偶数的项
dict_2 = { key: value for key, value in dict_base.items() if value % 2 == 0 }
print("只保留键值对中值为偶数的项: ", dict_2)

结果为：
键值对互换后的字典:  {1: 'key1', 2: 'key2', 3: 'key3', 4: 'key4', 5: 'key5'}
只保留键值对中值为偶数的项:  {'key2': 2, 'key4': 4}

四、函数

4.1 函数基础

4.1.1 函数定义与调用

使用def关键字创建

# 函数定义与调用
def function_demo(name):
    """简单的函数"""
    return f"你好, {name}!"

# 调用函数
message = function_demo("张三")
print(message)

# 带默认参数的函数
def calculate_area(length, width=10):
    """计算矩形面积"""
    return length * width

# 调用函数
print("面积:", calculate_area(5))  # 使用默认宽度
print("面积:", calculate_area(5, 20))  # 自定义宽度

msg = " 函数调用 测试 "
print(msg.rstrip()) # 移除字符串末尾的空格
print(msg.lstrip()) # 移除字符串开头的空格
print(msg.removeprefix(' ')) # 移除字符串开头的空格

结果为：
你好, 张三!
面积: 50
面积: 100
 函数调用 测试
函数调用 测试
函数调用 测试

4.1.2 参数传递

• 位置参数：按顺序传递参数。
• 关键字参数：通过参数名传递参数。
• 默认参数：定义函数时为参数设置默认值。
• 可变参数：*args 接收任意数量的位置参数，**kwargs 接收任意数量的关键字参数。

# 1. 位置参数
def power(base, exponent):
    """计算幂"""
    return base ** exponent

# 2. 关键字参数
def greet(name, greeting="你好"):
    """带关键字参数的问候"""
    return f"{greeting}, {name}!"

# 3. 可变位置参数(*args)
def sum_numbers(*numbers):
    """计算任意数量数字的和"""
    return sum(numbers)

# 4. 可变关键字参数(**kwargs)
def print_info(**info):
    """打印任意关键字参数"""
    for key, value in info.items():
        print(f"{key}: {value}")

# 调用示例
print("幂运算:", power(2, 3))  # 位置参数
print(greet(name="李四", greeting="欢迎"))  # 关键字参数
print("求和:", sum_numbers(1, 2, 3, 4))  # 可变位置参数
print_info(name="王五", age=25, city="北京")  # 可变关键字参数

结果为：
幂运算: 8
欢迎, 李四!
求和: 10
name: 王五
age: 25
city: 北京

4.1.3 返回值

• 使用 return 语句返回值，函数可返回多个值（以元组形式）。

# 1. 返回单个值
def square(n):
    """返回平方值"""
    return n * n

# 2. 返回多个值(元组形式)
def get_circle_info(radius):
    """返回圆的面积和周长"""
    area = 3.14 * radius * radius
    circumference = 2 * 3.14 * radius
    return area, circumference  # 实际上是返回一个元组

# 3. 返回字典
def build_person(name, age):
    """返回包含个人信息的字典"""
    return {'name': name, 'age': age}

# 4. 返回函数(高阶函数)
def make_adder(x):
    """返回一个加法函数"""
    def adder(y):
        return x + y
    return adder

# 调用
print("平方:", square(5))  # 返回单个值
a, c = get_circle_info(3)  # 解包返回的元组
print(f"圆面积: {a}, 周长: {c}")
print("个人信息:", build_person("赵六", 20))  # 返回字典
add5 = make_adder(5)  # 返回函数
print("5 + 3 =", add5(3))  # 调用返回的函数

结果为：
平方: 25
圆面积: 28.259999999999998, 周长: 18.84
个人信息: {'name': '赵六', 'age': 20}
5 + 3 = 8

4.2 函数进阶

4.2.1 递归函数

• 函数调用自身，如计算阶乘：

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

# 调用示例
print("阶乘:", factorial(3))  # 输出 6

结果为：
阶乘: 6

4.2.2 匿名函数（lambda）

• 用于创建简单的函数，如 add = lambda x, y: x + y。

# 1. 基本lambda函数
double = lambda x: x * 2
print("双倍:", double(5))  # 输出 10

# 2. 带多个参数的lambda
add = lambda a, b: a + b
print("相加:", add(3, 7))  # 输出 10

# 3. 在列表排序中使用lambda
students = [{'name': '张三', 'score': 85},
            {'name': '李四', 'score': 72},
            {'name': '王五', 'score': 90}]
# 按分数排序
students_sorted = sorted(students, key=lambda x: x['score'], reverse=True)
print("按分数排序:", students_sorted)

结果为：
双倍: 10
相加: 10
按分数排序: [{'name': '王五', 'score': 90}, {'name': '张三', 'score': 85}, {'name': '李四', 'score': 72}]

4.2.3 高阶函数

• map()：对序列中每个元素应用函数。

# 在map函数中使用lambda
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))
print("平方列表:", squared)  # 输出 [1, 4, 9, 16]

结果为：
平方列表: [1, 4, 9, 16]

• filter()：过滤序列中满足条件的元素。

# 在filter函数中使用lambda
numbers = [1, 2, 3, 4]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print("偶数:", even_numbers)  # 输出 [2, 4]

结果为：
偶数: [2, 4]

• reduce()：对序列元素进行累积操作。

from functools import reduce
numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)
print("乘积:", product)  # 输出 24

结果为：
乘积: 24

4.3 作用域与闭包

4.3.1 全局变量与局部变量

• 全局变量在函数外部定义，局部变量在函数内部定义。

def scope_demo():
    """作用域演示"""
    outer_var = "外部变量"
    
    def inner_func():
        inner_var = "内部变量"
        print("内部访问外部变量:", outer_var)  # 可以访问外部变量
    
    inner_func()
    # print(inner_var)  # 这里会报错，无法访问内部变量

scope_demo()

结果为：
内部访问外部变量: 外部变量

4.3.2 闭包

• 函数内部定义的函数，可访问外部函数的局部变量。

常用于：保持状态、创建工厂函数、实现装饰器、延迟计算等场景

def make_counter():
    """闭包计数器"""
    count = 0
    
    def counter():
        nonlocal count  # 声明使用外部变量
        count += 1
        return count
    
    return counter

# 使用闭包
counter1 = make_counter()
print("计数器1:", counter1())  # 1
print("计数器1:", counter1())  # 2
counter2 = make_counter()
print("计数器2:", counter2())  # 1 (独立的计数器)

def make_multiplier(factor):
    """创建乘法器闭包"""
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print("双倍5:", double(5))  # 10
print("三倍5:", triple(5))  # 15

结果为：
计数器1: 1
计数器1: 2
计数器2: 1
双倍5: 10
三倍5: 15

五、面向对象编程（OOP）

5.1 类与对象

5.1.1 类定义与实例化

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, I'm {self.name}, {self.age} years old.")

p = Person("Zhangsan", 26)
p.greet()

结果为：
Hello, I'm Zhangsan, 26 years old.

5.1.2 构造函数（__init__）

• 用于初始化对象的属性。

5.1.3 实例属性与方法

• 实例属性属于对象，实例方法可访问实例属性。

5.1.4 类的定义遵循特定的语法规范

# 类定义基本语法
class ClassName:
    """类的文档字符串"""
    
    # 类属性（所有实例共享）
    class_attribute = "类属性值"
    
    def __init__(self, param1, param2):
        """构造方法（初始化实例）"""
        # 实例属性（每个实例独有）
        self.param1 = param1
        self.param2 = param2
    
    def instance_method(self):
        """实例方法"""
        print(f"实例方法调用: {self.param1}")
    
    @classmethod
    def class_method(cls):
        """类方法"""
        print(f"类方法调用: {cls.class_attribute}")
    
    @staticmethod
    def static_method():
        """静态方法"""
        print("静态方法调用")

# 继承语法
class ChildClass(ParentClass):
    def __init__(self, param1, param2, param3):
        super().__init__(param1, param2)  # 调用父类构造方法
        self.param3 = param3

• 类名使用大驼峰命名法（如 ClassName ）
• __init__ 是构造方法，用于初始化实例
• 实例方法的第一个参数必须是 self
• 类方法使用 @classmethod 装饰器，第一个参数是 cls
• 静态方法使用 @staticmethod 装饰器，不需要 self 或 cls 参数
• 继承通过在类名后加括号指定父类

对象的主要特点：

1. 每个对象都是独立的实例，拥有自己的属性值
2. 对象可以调用类中定义的实例方法
3. 可以动态添加/修改对象的属性
4. 通过类方法可以创建特殊类型的对象
5. 静态方法不依赖于特定对象实例

5.2 继承与多态

5.2.1 单继承与多继承

# 单继承
class Book(Product):
    """书籍类继承自商品"""
    def __init__(self, name, price, version):
        super().__init__(name, price)
        self.version = version
    
    def display(self):
        super().display()
        print(f"版本: {self.version}")

# 多继承
# 定义第二个父类
class Discountable:
    """可打折商品"""
    def __init__(self, discount_rate=0.9):
        self.discount_rate = discount_rate
    
    def apply_discount(self):
        return self.price * self.discount_rate

# 多继承示例
class DiscountedBook(Book, Discountable):
    """可打折书籍"""
    def __init__(self, name, price, version, discount_rate=0.8):
        Book.__init__(self, name, price, version)
        Discountable.__init__(self, discount_rate)
    
    def show_discounted_price(self):
        print(f"折后价: {self.apply_discount()}")

# 使用
normal_book = Book("Python编程", 99.0, "第3版")
normal_book.display()

discount_book = DiscountedBook("机器学习", 120.0, "第2版", 0.7)
discount_book.display()
discount_book.show_discounted_price()

结果为：
商品: Python编程, 价格: 99.0
版本: 第3版
商品: 机器学习, 价格: 120.0
版本: 第2版
折后价: 84.0

5.2.2 方法重写

• 子类可重写父类的方法。

class Product:
    """商品基类"""
    def __init__(self, name, price):
        self.name = name
        self.price = price
    
    def get_info(self):  # 父类方法
        return f"商品: {self.name}, 价格: {self.price}"

class Book(Product):
    """书籍类继承自商品"""
    def __init__(self, name, price, version):
        super().__init__(name, price)
        self.version = version
    
    # 方法重写示例
    def get_info(self):  # 重写父类方法
        base_info = super().get_info()  # 调用父类方法
        return f"{base_info}, 版本: {self.version}"

# 使用示例
book = Book("Python编程", 99.0, "第3版")
print(book.get_info())  # 调用重写后的方法

结果为：
商品: Python编程, 价格: 99.0, 版本: 第3版

5.2.3 多态的实现

• 不同对象对同一方法有不同的实现。

class Product:
    """商品基类"""
    def __init__(self, name):
        self.name = name
    
    def show_details(self):
        """展示商品详情（多态方法）"""
        raise NotImplementedError("子类必须实现此方法")

class Book(Product):
    """书籍类"""
    def __init__(self, name, version):
        super().__init__(name)
        self.version = version
    
    def show_details(self):
        """实现多态方法"""
        print(f"书籍《{self.name}》- 版本: {self.version}")

class Electronic(Product):
    """电子产品类"""
    def __init__(self, name, brand):
        super().__init__(name)
        self.brand = brand
    
    def show_details(self):
        """实现多态方法"""
        print(f"电子产品: {self.name} - 品牌: {self.brand}")

# 多态使用示例
def display_product_info(product: Product):
    """统一处理所有Product子类"""
    product.show_details()

# 创建不同商品实例
book = Book("Python编程", "第3版")
electronic = Electronic("智能手机", "XX")

# 调用相同方法，不同表现
display_product_info(book)      # 输出: 书籍《Python编程》- 版本: 第3版
display_product_info(electronic) # 输出: 电子产品: 智能手机 - 品牌: XX

结果为：
书籍《Python编程》- 版本: 第3版
电子产品: 智能手机 - 品牌: XX

5.3 特殊方法与属性

5.3.1 魔法方法

• __str__ : 用于返回对象的字符串表示。
• __repr__ : 用于返回对象的官方字符串表示。
• __eq__ : 用于返回对象相等比较。
• __len__ : 用于返回对象的长度。

class Product:
    """商品基类"""
    def __init__(self, name):
        self.name = name
    
    def show_details(self):
        """展示商品详情（多态方法）"""
        raise NotImplementedError("子类必须实现此方法")
    
    # 新增魔法方法
    def __str__(self):
        """字符串表示，用于print()等"""
        return f"Product: {self.name}"
    
    def __repr__(self):
        """解释器表示，用于调试"""
        return f"<Product name='{self.name}'>"
    
    def __eq__(self, other):
        """相等比较"""
        if not isinstance(other, Product):
            return False
        return self.name == other.name
    
    def __len__(self):
        """定义长度，这里返回商品名长度"""
        return len(self.name)

class Book(Product):
    """书籍类"""
    def __init__(self, name, version):
        super().__init__(name)
        self.version = version
    
    def show_details(self):
        """实现多态方法"""
        print(f"书籍《{self.name}》- 版本: {self.version}")
    
    # 重写魔法方法
    def __str__(self):
        return f"Book: {self.name} (v{self.version})"
    
    def __repr__(self):
        return f"<Book name='{self.name}' version='{self.version}'>"

# 使用示例
p = Product("测试商品")
print(str(p))
print(repr(p))

b = Book("Python编程", "3.9")
print(str(b))
print(len(b))
print(b == Book("Python编程", "3.10"))  # 只比较name

结果为：
Product: 测试商品
<Product name='测试商品'>
Book: Python编程 (v3.9)
8
True

5.3.2 类属性与实例属性的区别

• 类属性为所有对象共享，实例属性每个对象独有。

类属性 ：适合存储类级别的常量或默认值

• 属于类本身，所有实例共享
• 定义在类内部但在方法外部
• 通过类名或实例均可访问
• 修改会影响所有实例

实例属性 ：适合存储对象特有的状态数据

• 属于各个实例独有
• 通常在 __init__ 方法中定义
• 只能通过实例访问
• 修改只影响当前实例

注意：
当实例和类有同名属性时，实例访问优先使用实例属性。

5.4 访问控制

• 公有属性 ：公有属性和方法可直接访问。普通命名(如 name ) - 可自由访问
• 受保护的属性和方法 ：单下划线开头(如 _name ) 。 提示"不要直接访问"，但语法上仍可访问
• 私有属性和方法 ：双下划线开头(如 __name ) 。会触发名称修饰(name mangling)，外部无法直接访问