Python 编程基础：从零开始掌握核心概念

• 命名规则：
  • 由字母、数字和下划线 _ 组成。
  • 不能以数字开头。
  • 区分大小写（age 和 Age 是不同的变量）。
  • 不能使用 Python 关键字（如 if, for, while 等）。
  • 建议使用描述性的名字（如 student_name 而不是 sn）。

赋值： 使用等号 =

age = 25  # 将整数 25 赋值给变量
name = "Alice"  # 将字符串 "Alice" 赋值给变量
is_student = True  # 将布尔值 True 赋值给变量

2.2 基本数据类型

空值 (NoneType): 表示一个空值或没有值。None 是一个特殊的常量。

result = None  # 通常表示函数没有返回有效值或变量尚未初始化

布尔值 (bool): 表示真 (True) 或假 (False)。常用于条件判断。

is_raining = True
has_permission = False

字符串 (str): 表示文本数据，用单引号 ' 或双引号 " 包裹。例如："Hello", 'Python'。

greeting = "Bonjour!"
message = 'Learning Python is fun.'
# 多行字符串
paragraph = """This is a long string that spans multiple lines."""

浮点数 (float): 表示带有小数部分的数值。例如：3.14, -0.5, 2.0。

pi = 3.14159
price = 9.99

整数 (int): 表示整数值，没有小数部分。例如：10, -5, 0。

count = 10
temperature = -5

2.3 查看数据类型
使用内置函数 type() 可以查看变量的数据类型：

print(type(10))      # 输出：<class 'int'>
print(type(3.14))    # 输出：<class 'float'>
print(type("Text"))  # 输出：<class 'str'>
print(type(True))    # 输出：<class 'bool'>
print(type(None))    # 输出：<class 'NoneType'>

2.4 类型转换
有时需要将数据从一种类型转换为另一种类型：

bool(): 转换为布尔值。空值、零、空字符串等通常为 False，其他为 True。

print(bool(0))       # False
print(bool(10))      # True
print(bool(""))      # False
print(bool("Hi"))    # True
print(bool(None))    # False

str(): 转换为字符串。几乎任何类型都可以转成字符串。

num = 10
text = str(num)      # "10"
boolean = str(True)  # "True"

float(): 转换为浮点数。

num_int = 5
num_float = float(num_int)   # 5.0
num_str = float("4.2")       # 4.2

int(): 转换为整数。浮点数会去掉小数部分，字符串必须包含有效整数。

num_str = "123"
num_int = int(num_str)   # 123
num_float = int(3.9)     # 3 (截断)

第三章：控制程序的流程 - 运算符与流程控制

程序需要根据条件或重复执行某些任务。这就需要运算符和控制结构。

3.1 运算符

赋值运算符： =（基本赋值）, +=, -=, *=, /=, //=, %=, **=（复合赋值）。

total = 10
total += 5   # 等同于 total = total + 5; 现在 total = 15
total *= 2   # 等同于 total = total * 2; 现在 total = 30

逻辑运算符： and（与）, or（或）, not（非）。用于组合布尔表达式。

age = 20
has_license = True
# 年龄大于等于 18 并且 有驾照
can_drive = age >= 18 and has_license  # True
# 年龄小于 18 或者 没有驾照
cannot_drive = age < 18 or not has_license  # False (因为 age=20>=18)
# 对布尔值取反
is_false = not True  # False

比较运算符： ==（等于）, !=（不等于）, >（大于）, <（小于）, >=（大于等于）, <=（小于等于）。返回布尔值。

x = 5
y = 10
print(x == y)  # False
print(x != y)  # True
print(x < y)   # True
print(x >= 5)  # True

算术运算符： +（加）, -（减）, *（乘）, /（除）, //（整除）, %（取模/余数）, **（幂运算）。

a = 10
b = 3
print(a + b)   # 13
print(a - b)   # 7
print(a * b)   # 30
print(a / b)   # 3.333... (浮点数结果)
print(a // b)  # 3 (整除)
print(a % b)   # 1 (余数)
print(a ** b)  # 1000 (10 的 3 次方)

3.2 条件语句 (if, elif, else)
根据条件决定执行哪部分代码。

score = 85
if score >= 90:
    print("成绩优秀！")
elif score >= 80:  # 如果上面的条件不满足，检查这个条件
    print("成绩良好！")
elif score >= 60:
    print("成绩及格。")
else:  # 如果以上条件都不满足
    print("不及格，需要努力。")

注意： Python 使用缩进（通常是 4 个空格）来标识代码块。缩进必须一致。

3.3 循环语句

for 循环： 用于遍历一个序列（如列表、字符串、元组等）或其他可迭代对象。

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

# 遍历数字范围 (range)
for i in range(5):  # range(5) 生成 0, 1, 2, 3, 4
    print(i)

for i in range(2, 6):  # 2, 3, 4, 5
    print(i)

for i in range(0, 10, 2):  # 0, 2, 4, 6, 8 (步长为 2)
    print(i)

while 循环： 当条件为真时，重复执行代码块。

count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # 非常重要：改变条件变量，避免死循环
# 输出:
# Count is: 1
# Count is: 2
# ...
# Count is: 5

3.4 循环控制

continue: 跳过当前循环的剩余语句，进入下一次迭代。

for i in range(10):
    if i % 2 == 0:  # 如果是偶数
        continue  # 跳过本次循环的剩余代码
    print(i)  # 只会打印奇数：1, 3, 5, 7, 9

break: 立即终止当前循环。

num = 1
while True:  # 无限循环
    print(num)
    num += 1
    if num > 5:
        break  # 当 num > 5 时跳出循环

第四章：代码的模块化 - 函数

函数是将一段完成特定功能的代码封装起来，以便重复使用。这提高了代码的可读性、可维护性和复用性。

4.1 定义函数
使用 def 关键字定义函数：

def greet(name):  # name 是参数
    """这是一个简单的问候函数 (文档字符串)"""
    print(f"Hello, {name}!")

• def: 定义函数的关键字。
• greet: 函数名。
• (name): 参数列表。函数可以有零个或多个参数。
• """...""": 文档字符串（docstring），用于描述函数功能，可选但推荐使用。
• 函数体：缩进的代码块，包含函数要执行的操作。

4.2 调用函数
使用函数名后加括号 () 来调用函数，括号内传入参数（如果有）：

greet("Alice")  # 输出：Hello, Alice!
greet("Bob")    # 输出：Hello, Bob!

4.3 返回值
函数可以使用 return 语句返回一个值（或一组值）。如果函数没有 return 语句或 return 后面没有值，则返回 None。

def add(a, b):
    """计算两个数的和并返回"""
    result = a + b
    return result  # 将计算结果返回给调用者

sum_val = add(3, 5)  # 调用函数，并将返回值赋给 sum_val
print(sum_val)       # 输出：8

def no_return():
    print("This function does something...")  # 没有 return 语句

result = no_return()
print(result)  # 输出：None

4.4 参数传递

• *args: 接收任意数量的位置参数，将它们收集到一个元组中。
• **kwargs: 接收任意数量的关键字参数，将它们收集到一个字典中。

可变参数：

def make_pizza(*toppings):
    print("Making a pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza("pepperoni")
make_pizza("mushrooms", "green peppers", "extra cheese")

def build_profile(first, last, **user_info):
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile

user_profile = build_profile("albert", "einstein", location="princeton", field="physics")
print(user_profile)  # 输出类似：{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}

默认参数： 在定义函数时为参数指定默认值。调用时可以不提供该参数。

def describe_pet(pet_name, animal_type="dog"):  # animal_type 默认为 'dog'
    print(f"I have a {animal_type} named {pet_name}.")

describe_pet("Willie")           # 输出：I have a dog named Willie.
describe_pet("Harry", "cat")     # 输出：I have a cat named Harry.

关键字参数： 在调用时指定参数名，可以不按顺序。

describe_pet(pet_name="Harry", animal_type="hamster")  # 顺序无关紧要

位置参数： 按照定义时的顺序传递参数。

def describe_pet(animal_type, pet_name):
    print(f"I have a {animal_type} named {pet_name}.")

describe_pet("hamster", "Harry")  # 正确顺序
describe_pet("Harry", "hamster")  # 错误顺序，输出会混乱

4.5 变量的作用域

• 局部变量： 在函数内部定义的变量。只在函数内部有效。
• 全局变量： 在函数外部定义的变量。可以在整个程序（包括函数内部）访问。

在函数内修改全局变量： 需要使用 global 关键字声明。

global_var = 10  # 全局变量

def modify_global():
    global global_var  # 声明要修改的是全局变量
    global_var = 20    # 修改全局变量的值

def local_var():
    local_var = 30  # 局部变量，只在函数内部有效
    print(local_var)  # 输出：30

print(global_var)  # 输出：10
modify_global()
print(global_var)  # 输出：20 (全局变量被修改)
local_var()
print(global_var)  # 报错：NameError: name 'local_var' is not defined (局部变量在外部不可访问)

最佳实践： 尽量避免在函数内修改全局变量，优先使用参数传递和返回值。这可以使代码逻辑更清晰，减少出错。

第五章：数据的集合 - 列表、元组、字典、集合

Python 提供了几种强大的内置数据结构，用于存储和操作数据集合。

5.1 列表 (list)
列表是有序、可变的元素集合。用方括号 [] 表示。

fruits = ["apple", "banana", "cherry"]  # 创建一个列表
print(fruits[0])  # 输出：apple (索引从 0 开始)
print(fruits[-1]) # 输出：cherry (负索引表示倒数)

fruits[1] = "orange"  # 修改元素：将索引 1 处的 "banana" 改为 "orange"
print(fruits)         # 输出：['apple', 'orange', 'cherry']

# 常用操作
fruits.append("mango")          # 在末尾添加元素
fruits.insert(1, "grape")       # 在索引 1 处插入 "grape"
removed_fruit = fruits.pop()    # 移除并返回末尾元素 ("mango")
fruits.remove("cherry")         # 移除第一个值为 "cherry" 的元素
length = len(fruits)            # 获取列表长度
sliced = fruits[1:3]            # 切片：获取索引 1 到 2 的元素 (不包括 3) ['grape', 'orange']
sorted_fruits = sorted(fruits)  # 返回排序后的新列表 (不改变原列表)
fruits.sort()                   # 原地排序列表 (改变原列表)

5.2 元组 (tuple)
元组是有序、不可变的元素集合。用圆括号 () 表示。一旦创建，其元素不能修改。

coordinates = (10, 20)  # 创建一个元组
print(coordinates[0])   # 输出：10
# coordinates[0] = 15  # 报错：元组不可变

# 单元素元组需要在元素后加逗号
single_element = (42,)
print(type(single_element))  # <class 'tuple'>

# 元组常用于表示一组不可变的值，如函数返回多个值
def get_name_and_age():
    return "Alice", 30  # 实际返回一个元组 ("Alice", 30)

name, age = get_name_and_age()  # 元组解包

5.3 字典 (dict)
字典是键值对的无序集合。键必须是不可变类型（如字符串、数字、元组），值可以是任意类型。用花括号 {} 表示。

student = {"name": "Alice", "age": 20, "major": "Computer Science"}
print(student["name"])  # 输出：Alice (通过键访问值)

# 常用操作
student["gpa"] = 3.8             # 添加新的键值对
student["age"] = 21              # 修改现有键的值
del student["major"]             # 删除键值对
major = student.get("major", "Undeclared")  # 安全获取，如果键不存在返回默认值 "Undeclared"
keys = student.keys()            # 获取所有键的视图
values = student.values()        # 获取所有值的视图
items = student.items()          # 获取所有键值对的视图

# 遍历字典
for key, value in student.items():
    print(f"{key}: {value}")

5.4 集合 (set)
集合是无序、元素唯一的集合。主要用于成员关系测试和消除重复元素。用花括号 {} 表示（与字典区别：没有冒号分隔的键值对）。

unique_numbers = {1, 2, 2, 3, 3, 3}  # 创建集合，自动去重
print(unique_numbers)                # 输出：{1, 2, 3} (顺序可能不同)

# 常用操作
unique_numbers.add(4)                # 添加元素
unique_numbers.remove(3)             # 移除元素 (如果不存在会报错)
unique_numbers.discard(5)            # 安全移除 (不存在不报错)
print(2 in unique_numbers)           # 成员测试：True

# 集合运算
setA = {1, 2, 3}
setB = {3, 4, 5}
print(setA | setB)   # 并集：{1, 2, 3, 4, 5}
print(setA & setB)   # 交集：{3}
print(setA - setB)   # 差集 (在 A 中但不在 B 中)：{1, 2}

第六章：综合案例 - 温度转换器

让我们将学到的知识组合起来，编写一个简单的命令行温度转换程序，实现摄氏度和华氏度的相互转换。

def celsius_to_fahrenheit(celsius):
    """将摄氏度转换为华氏度"""
    fahrenheit = (celsius * 9 / 5) + 32
    return fahrenheit

def fahrenheit_to_celsius(fahrenheit):
    """将华氏度转换为摄氏度"""
    celsius = (fahrenheit - 32) * 5 / 9
    return celsius

def main():
    print("温度转换器")
    print("1. 摄氏度 -> 华氏度")
    print("2. 华氏度 -> 摄氏度")
    choice = input("请选择转换类型 (1 或 2): ")
    if choice == '1':
        try:
            c_temp = float(input("请输入摄氏温度："))
            f_temp = celsius_to_fahrenheit(c_temp)
            print(f"{c_temp} 摄氏度 = {f_temp:.2f} 华氏度")  # :.2f 表示保留两位小数
        except ValueError:
            print("输入错误，请输入数字！")
    elif choice == '2':
        try:
            f_temp = float(input("请输入华氏温度："))
            c_temp = fahrenheit_to_celsius(f_temp)
            print(f"{f_temp} 华氏度 = {c_temp:.2f} 摄氏度")
        except ValueError:
            print("输入错误，请输入数字！")
    else:
        print("无效的选择！")

if __name__ == "__main__":
    main()

代码解析：

1. 函数定义 (celsius_to_fahrenheit, fahrenheit_to_celsius)： 封装了转换逻辑。
2. 主函数 (main)： 控制程序流程。
3. 用户输入 (input)： 获取用户选择的转换类型和温度值。
4. 条件判断 (if/elif/else)： 根据用户选择执行不同的转换分支。
5. 异常处理 (try/except)： 捕获用户输入非数字时的错误 (ValueError)，提供友好的错误提示。
6. 类型转换 (float())： 将输入的字符串转换为浮点数进行计算。
7. 格式化输出 (:.2f)： 控制输出的温度值保留两位小数。
8. if __name__ == "__main__":： 这是一个常见的 Python 习惯用法，确保当这个文件被直接运行时才调用 main() 函数。如果这个文件被作为模块导入到其他程序中，main() 不会自动执行。

第七章：下一步学习方向

掌握了这些基础知识后，你已经踏入了 Python 编程的大门。接下来可以探索更深入的领域：

1. 文件操作 (open(), read(), write(), close())： 学习如何读写文件。
2. 模块和包 (import)： 学习如何使用 Python 标准库和第三方库。
3. 面向对象编程 (OOP)： 学习类、对象、继承、封装和多态等概念。
4. 错误和异常处理 (try/except/else/finally)： 编写更健壮的程序。
5. 常用内置模块： 如 os (操作系统交互), datetime (日期时间处理), math (数学函数), random (随机数) 等。
6. 项目实践： 找一些小项目练手，如简单的计算器、待办事项列表、网页爬虫等。

学习编程最好的方法就是动手实践。多写代码，多调试，遇到问题善用搜索引擎和官方文档。祝你学习顺利！