Python 入门在 Python 中，字典（dict）常被类比为其他语言中的对象，而列表（list）则类似于数组。 1

在 Python 中，字典（dict）常被类比为其他语言中的对象，而列表（list）则类似于数组。

1. "Hello World" - Python入门

print('hello world')

2. 变量

2.1. 变量定义

变量名 = 变量值

a = 1
b = 2
c = 3

2.2. 变量运算

可以对变量进行各种算术运算。

print(a + b)  # 加法
print(a - b)  # 减法
print(a * b)  # 乘法
print(a / b)  # 除法 (结果为浮点数)

2.3. 变量类型

Python 是动态类型语言，变量的类型是根据赋给它的值自动确定的。可以使用 type() 函数查看变量类型。

print(type(a))  # a 是整数 (int)
print(type(b))  # b 是整数 (int)
print(type(c))  # c 是整数 (int)

2.4. 变量类型转换

可以显式地转换变量的类型。

a_original = 1
b_original = "2" # 假设 b 的初始值是字符串 "2" 
c_original = "3.0" # 假设 c 的初始值是字符串 "3.0"

print(f"原始值: a={a_original}({type(a_original)}), b={b_original}({type(b_original)}), c={c_original}({type(c_original)})")

a_converted_to_str = str(a_original)
b_converted_to_int = int(b_original)
c_converted_to_float = float(c_original)

print(f"转换为字符串: a_converted_to_str = {a_converted_to_str} ({type(a_converted_to_str)})")
print(f"转换为整数: b_converted_to_int = {b_converted_to_int} ({type(b_converted_to_int)})")
print(f"转换为浮点数: c_converted_to_float = {c_converted_to_float} ({type(c_converted_to_float)})")

3. 字符串格式化

将变量的值嵌入到字符串中。

3.1. 使用 `%` 操作符 (旧式方法)

%s: 将值转换为字符串
%d: 格式化为整数

%f: 格式化为浮点数

class_num = 57
avg_score_total = 16781 # 假设这是总分，实际平均分应为 avg_score_total / class_num
# message_percent = '班级人数是%s,班级平均分是：%s' % (class_num, avg_score_total) # 此处 avg_score_total 若直接用，语义上不是平均分
actual_avg_score = avg_score_total / class_num if class_num > 0 else 0
message_percent = '班级人数是%d, 班级平均分是：%.2f' % (class_num, actual_avg_score) # 使用 %d 和 %.2f (保留两位小数) 更合适
print(message_percent)

3.2. 使用 f-string (格式化字符串字面值 - 推荐)

这是更现代且推荐的方式，代码更简洁易读。

class_num = 57
avg_score_value = 85.5 # 假设平均分是浮点数
message_fstring = f'班级人数是{class_num}, 班级平均分是：{avg_score_value}'
print(message_fstring)

4. 控制流

4.1. `if` 语句 (条件判断)

age = 18

if age >= 18:
    print('成年')
elif age >= 12: # 隐含了 age < 18
    print('上中学')  
elif age >= 5:   
    print('上小学或幼儿园') 
else: # age < 5
    print('其他 (年龄小于5岁)')

4.2. `while` 循环

只要条件为真，就重复执行代码块。

i = 0
while i < 10:
    print(i)
    i += 1  # 等同于 i = i + 1

4.3. `for` 循环

遍历序列（如列表、元组、字符串）或可迭代对象。

range(stop): 生成从 0 到 stop-1 的整数序列。例：range(10) -> 0, 1, ..., 9
range(start, stop): 生成从 start 到 stop-1 的整数序列。例：range(1, 4) -> 1, 2, 3
range(start, stop, step): 生成从 start 到 stop-1，步长为 step 的整数序列。例：range(1, 10, 2) -> 1, 3, 5, 7, 9

for i in range(1, 10, 2):
    print(i)

5. 函数

函数是可重用的代码块，用于执行特定任务。

5.1. 函数定义与调用

使用 def 关键字定义函数。

# 带有名称的函数
def add(a, b):
    return a + b, 2  
# 可以返回多个值，它们会组成一个元组


# 调用函数
result_sum, result_second_val = add(1, 2) # 解包元组返回值
print(f"加法结果: {result_sum}, 第二个返回值: {result_second_val}")

# 如果只需要部分返回值
results_tuple = add(3, 4)
print(f"返回的元组: {results_tuple}")
print(f"仅获取加法结果: {results_tuple[0]}")

5.2. 匿名函数 (`lambda`)

用于创建简单、单行的小函数。通常用在需要一个简单函数作为参数的地方。

multiply = lambda x, y: x * y
print(f"匿名函数计算 3 * 4 = {multiply(3, 4)}")

6. 数据结构

6.1. 列表 (`list`)

有序、可变（可以修改）的元素集合。允许重复元素。
*注意：不建议使用 list 作为变量名，因为它会覆盖 Python 内置的 list() 函数。

my_list_example = [1, 2, "3", 4, 5]
print(f"列表第三个元素 (索引2): {my_list_example[2]}") # 输出: "3"
print(f"列表第四个元素 (索引3): {my_list_example[3]}") # 输出: 4

# 列表的方法
# 1.查询某元素下标
    list.index("3")
# 2.在列表中插入新元素
    list.insert(0, "插入的内容")
# 3.在列表中追加元素
    list.append("追加的内容")
    list.extend(["追加的内容1", "追加的内容2"])
# 4.删除列表中的元素
    del list[0]
    list.pop(0)
    list.remove("3")
    list.clear()

6.2. 元组 (`tuple`)

有序、不可变（一旦创建不能修改）的元素集合。允许重复元素。

my_tuple_example = (1, 2, 3, 4, 5)
print(f"元组第四个元素 (索引3): {my_tuple_example[3]}")  # 输出: 4

# my_tuple_example[0] = 10 # 这行会报错 TypeError，因为元组不可修改
print(f"元组示例: {my_tuple_example}")

6.3. 集合 (`set`)

无序、不重复的元素集合。主要用于成员测试和消除重复项。

my_set_example = {1, 2, 3, 4, 5, 5, 4} # 重复的元素会自动去除
print(f"集合示例 (顺序可能不同): {my_set_example}")  # 输出可能是 {1, 2, 3, 4, 5}

6.4. 字典 (`dict`)

无序（Python 3.7+ 中保持插入顺序）的键值对（key-value pair）集合。键必须是唯一的且通常是不可变类型（如字符串、数字、元组）。

关于“不支持while循环”的说明：字典本身可以直接用于 for 循环遍历其键、值或项。虽然不能直接 while my_dict: 这样用字典本身作为 while 循环的条件来遍历元素，但可以在 while 循环内部操作字典或基于字典的某些条件进行循环。

my_dict_example = {'name': '张三', 'age': 18}
print(f"字典中 'name' 对应的值: {my_dict_example['name']}")  # 输出: 张三

# 字典的方法
# 1.新增元素
dict['gender'] = '男'
# 2.删除
del dict['name']
# 3.清空
dict.clear()
# 4.获取全部key
dict.keys()
# 5.获取全部value
dict.values()
# 6.获取全部key-value
dict.items()
# 7.统计字典中的元素数量
len(dict)

7. JSON 数据格式

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，常用于不同语言或系统之间传递数据。Python 的 json 模块提供了处理 JSON 数据的功能。

7.1. Python 数据 -> JSON 字符串 (`json.dumps`)

7.2. JSON 字符串 -> Python 数据 (`json.loads`)

8. 类 (面向对象编程)

8.1. 类的定义和实例化

class Person:
    # 类型提示 (可选，但有助于代码可读性和静态分析)
    name: str
    age: int
    gender: str

    # 初始化方法：创建对象时自动调用
    def __init__(self, name: str, age: int, gender: str):
        self.name = name    # self.name 是实例变量
        self.age = age
        self.gender = gender
        print(f"Person对象 '{self.name}' 已创建。")

    # 实例方法：对象可以调用的方法，第一个参数总是 self，代表实例本身
    def say(self, msg: str):
        print(f'我叫{self.name}, 我今年{self.age}岁, 我是{self.gender}生。我说：“{msg}”')

# 创建对象 (实例化类 Person)
person_instance_1 = Person('张三', 18, '男')
person_instance_2 = Person('王芳', 22, '女')

# 访问对象的属性
print(f"{person_instance_1.name}的年龄是: {person_instance_1.age}")

# 调用对象的方法
person_instance_1.say('你好，Python！')
person_instance_2.say('很高兴认识你。')

9.2. 类的内置方法 (特殊方法/魔术方法)

这些方法以双下划线开头和结尾（例如 __init__），它们在特定情况下由 Python 自动调用。

__str__(self): 把类的对象转换为字符串的形式

def __str__(self):
    return f'我叫{self.name},我今年{self.age}岁,我是{self.gender}生'

__lt__(self, other): 返回当前对象1和对象2的大小比较结果，return后面的是比较的依据
```
def __lt__(self, other):
    return self.age < other.age
```
__eq__(self, other): 返回当前对象1和对象2的相等比较结果，return后面的是比较的依据
```
def __eq__(self, other):
    return self.age == other.age
```

9.3. 私有成员 (名称修饰/Name Mangling)

在变量名或方法名前加双下划线 __会使其成为“伪私有”的。只有类能使用，对象不可以用。

class Person:
    __name = '张三'
    __age = 18
    __gender = '男'
    def __init__(self, name, age, gender):
        self.__name = name
        self.__age = age
        self.__gender = gender

9.4. 类的继承

继承允许一个类（子类/派生类）获取另一个类（父类/基类）的属性和方法，并可以添加新的或重写已有的。

单继承: 子类继承自一个父类。
```
   class Sun(Person):
    pass
```
多继承: 子类可以继承自多个父类。子类将拥有所有父类的属性和方法。
教程中的 class Sun(Person, Person): pass 是一个无效的多继承示例，因为同一个类被列出了两次。多继承时，父类的顺序很重要，因为它影响方法解析顺序 (MRO)。
```
class Sun(Person, Person):
pass
```
super(): 是一个内置函数，用于调用父类（或在多继承中，MRO 指定的下一个类）的方法。它使得代码更易于维护，特别是在复杂的继承结构中。

10. 类型注解 (Type Hinting)

类型注解为代码提供了关于变量、函数参数和返回值的类型信息。它们主要用于静态分析工具（如 MyPy）进行类型检查，以及提高代码的可读性和可维护性。Python 解释器本身在运行时通常不强制执行类型检查（但某些库可能会利用它们）。

变量注解: variable_name: type = value
函数参数注解: def func(param_name: type, ...)
函数返回值注解: def func(...) -> return_type:
Union[type1, type2]: 表示可以是多种类型之一 (需要 from typing import Union)
Optional[type]: 表示可以是 type 或 None (等价于 Union[type, None], 需要 from typing import Optional)

from typing import Union, Optional, List

var_annotated_1: int = 10
var_annotated_2: str = "你好"
var_annotated_3: Union[int, str] # 可以是整数或字符串
var_annotated_4: Optional[float] = None # 可以是浮点数或 None

def create_greeting(name: str, age: Optional[int] = None) -> str:
    greeting = f"你好, {name}!"
    if age is not None:
        greeting += f" 你今年 {age} 岁。"
    return greeting

def sum_list_of_numbers(numbers: List[Union[int, float]]) -> float:
    total: float = 0.0
    for num in numbers:
        total += num
    return total

print(create_greeting("小张"))
print(create_greeting("老王", 30))

my_numbers: List[Union[int, float]] = [1, 2.5, 3, 4.0]
print(f"数字列表的总和: {sum_list_of_numbers(my_numbers)}")

var_annotated_3 = 100
print(f"var_annotated_3 (int): {var_annotated_3}")
var_annotated_3 = "世界"
print(f"var_annotated_3 (str): {var_annotated_3}")

Python 入门