🎯 本章目标

• ✅ 了解什么是编程以及 Python 的特点
• ✅ 学会安装 Python 和 IDLE
• ✅ 掌握 print() 函数的基本用法
• ✅ 理解字符串和数字的区别

什么是编程？

安装 Python

你的第一行代码：Hello World

print("Hello, World!")
print("你好，Python！")
print("我在学习编程！")

print() 的更多用法

print(100)              # 打印数字，不需要引号
print(3 + 5)            # 可以计算，会输出 8
print(10 * 10)          # 输出 100
print("年龄：", 12)    # 用逗号隔开，可以同时打印多个
print("2 + 3 =", 2 + 3)  # 输出：2 + 3 = 5

注释：给代码写"笔记"

# 这是一行注释，Python不会执行它
print("Hello")  # 注释也可以写在代码后面
# print("这行被注释掉了，不会执行")

📝 本章小结

• 💡 编程就是给计算机写指令
• 💡 print() 用于输出内容到屏幕
• 💡 字符串需要用引号包围，数字不需要
• 💡 Python 语法简洁，适合初学者

🎯 本章目标

• ✅ 理解变量的概念（存储数据的"盒子"）
• ✅ 掌握三种基本数据类型：int、float、str
• ✅ 学会使用 type() 查看数据类型
• ✅ 掌握类型转换：int()、float()、str()
• ✅ 理解 TypeError 常见错误

什么是变量？

name = "小明"      # 把字符串"小明"放进变量name
age = 12         # 把数字12放进变量age
pi = 3.14       # 把小数3.14放进变量pi
is_student = True  # 把True放进变量is_student（布尔值）

print(name)      # 输出：小明
print(age + 1)   # 输出：13

三种基本数据类型

# 整数运算
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  (取余，10除以3余1)
print(a ** b)  # 1000 (幂运算，10的3次方)

字符串操作

first = "Python"
second = "编程"
print(first + second)        # 输出：Python编程
print("哈" * 5)              # 输出：哈哈哈哈哈
print("我今年" + 12)         # ❌ 报错！字符串和数字不能直接相加
print("我今年" + str(12))  # ✅ 正确！用str()把数字转成字符串

# 字符串长度
word = "Python"
print(len(word))   # 6

类型查看与转换

print(type(10))      # 
print(type(3.14))    # 
print(type("hello")) # 

# 类型转换
print(int("100"))     # 100 (字符串转整数)
print(float("3.5"))   # 3.5 (字符串转浮点数)
print(str(2024))    # "2024" (数字转字符串)

⚠️ 常见错误：TypeError

age = input("你今年几岁了？")  # 输入: 12
print("明年你就" + age + 1 + "岁了")  # ❌ 报错！

📝 本章小结

• 💡 变量 = 名字，用来存储数据
• 💡 整数(int)、浮点数(float)、字符串(str)
• 💡 字符串和数字不能直接相加，需要转换
• 💡 type() 可以查看数据类型

🎯 本章目标

• ✅ 掌握 input() 函数获取用户输入
• ✅ 理解 input() 返回的是字符串
• ✅ 学会使用 f-string 格式化输出
• ✅ 掌握 int()、float() 转换输入数据

获取用户输入：input()

name = input("请输入你的名字：")
print("你好，" + name + "！欢迎学习Python！")

重要：input() 返回的是字符串！

age = input("你今年几岁了？")   # 假设输入 12
# age 现在是字符串 "12"，不是数字 12

# 需要转换成整数
age = int(input("你今年几岁了？"))   # 现在 age 是数字 12
print("明年你就" + str(age + 1) + "岁了！")

类型转换函数

# 做一个简单的加法计算器
num1 = int(input("请输入第一个数字："))
num2 = int(input("请输入第二个数字："))
print("两数之和是：", num1 + num2)

格式化字符串：f-string

name = "小明"
age = 12
print(f"你好，{name}！你今年{age}岁。")
# 输出：你好，小明！你今年12岁。

# 甚至可以在大括号里计算
print(f"5 + 3 = {5+3}")  # 输出：5 + 3 = 8

📝 本章小结

• 💡 input() 用于获取键盘输入
• 💡 input() 返回的永远是字符串
• 💡 f-string 是格式化输出的最佳方式
• 💡 计算前记得把输入转成数字

🎯 本章目标

• ✅ 理解 Python 的缩进规则
• ✅ 掌握 if、elif、else 的用法
• ✅ 学会使用比较运算符：>、<、==、!=
• ✅ 理解逻辑运算符：and、or、not
• ✅ 能够编写简单的条件判断程序

📝 Python 的缩进规则

# ✅ 正确的缩进
if age >= 18:
    print("你已成年")      # ← 缩进4个空格
    print("可以考驾照")    # ← 同一层级，同样缩进
else:
    print("你未成年")      # ← else 也要缩进
    print("还不能考驾照")  # ← 同一层级

# ❌ 错误的缩进 - 会报错！
if age >= 18:
print("你已成年")          # ← 没有缩进，IndentationError！
    print("可以考驾照")    # ← 缩进不一致

if 语句：让程序做选择

score = 85

if score >= 60:
    print("恭喜你，及格了！")
else:
    print("别灰心，下次加油！")

比较运算符

if score == 100:
    print("满分！太厉害了！")
elif score >= 90:
    print("优秀！")
elif score >= 80:
    print("良好！")
elif score >= 60:
    print("及格！")
else:
    print("不及格，需要努力！")

逻辑运算符：and、or、not

age = 15
has_ticket = True

if age >= 12 and has_ticket:
    print("可以入场！")
else:
    print("不能入场。")

# not 的用法
is_raining = False
if not is_raining:
    print("今天不下雨，可以出去玩！")

嵌套 if：if 里面还有 if

score = 85
attendance = 95

if score >= 60:
    print("成绩及格")
    if attendance >= 90:
        print("而且全勤，获得表扬！")
    else:
        print("但出勤率不够高。")
else:
    print("成绩不及格，需要补考。")

📝 本章小结

• 💡 缩进是 Python 的灵魂，4个空格为标准
• 💡 if/elif/else 用于条件判断
• 💡 == 是比较，= 是赋值，不要混淆
• 💡 and、or、not 用于组合多个条件

🎯 本章目标

• ✅ 掌握 for 循环遍历 range()
• ✅ 理解 range() 的三种用法
• ✅ 掌握 while 循环的条件控制
• ✅ 学会使用 break 和 continue
• ✅ 理解循环嵌套的概念

for 循环：重复做一件事

# range(5) 会产生 0, 1, 2, 3, 4
for i in range(5):
    print(i)

# 输出：
# 0
# 1
# 2
# 3
# 4

range() 的更多用法

range(5)        # 0, 1, 2, 3, 4
range(1, 6)    # 1, 2, 3, 4, 5 （从1开始到6之前）
range(0, 10, 2) # 0, 2, 4, 6, 8 （步长为2）
range(10, 0, -1) # 10, 9, 8, ..., 1 （倒着数，步长-1）

🎯 range() 可视化演示

while 循环：条件满足就一直执行

count = 1
while count <= 5:
    print("第" + str(count) + "次")
    count = count + 1   # 重要！要让条件最终变为False，否则会无限循环

break 和 continue

# break 示例：找到第一个能被7整除的数
for i in range(1, 100):
    if i % 7 == 0:
        print("找到了：", i)
        break       # 找到就退出，不再继续找

# continue 示例：打印1-10中的奇数
for i in range(1, 11):
    if i % 2 == 0:
        continue    # 偶数跳过，不执行下面的print
    print(i)        # 只打印奇数

循环嵌套

# 打印乘法表的一部分
for i in range(1, 4):
    for j in range(1, 4):
        print(f"{i}x{j}={i*j}", end="  ")
    print()  # 换行
# 输出：
# 1x1=1  1x2=2  1x3=3
# 2x1=2  2x2=4  2x3=6
# 3x1=3  3x2=6  3x3=9

📝 本章小结

• 💡 for 用于已知次数的循环
• 💡 while 用于条件控制的循环
• 💡 range(start, stop, step) 灵活控制序列
• 💡 break 跳出循环，continue 跳过本轮

🎯 本章目标

• ✅ 理解列表(list)的基本操作
• ✅ 掌握索引访问和切片
• ✅ 学会列表的增删改查
• ✅ 理解元组(tuple)的不可变性
• ✅ 掌握列表推导式

列表：可以装很多东西的"书包"

fruits = ["苹果", "香蕉", "橙子", "葡萄"]
scores = [85, 92, 78, 96, 88]
mixed = [1, "hello", 3.14, True]   # 列表里可以混放不同类型的数据
empty = []   # 空列表

索引：取出列表中的某个元素

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

print(fruits[0])   # 苹果 （第一个元素）
print(fruits[1])   # 香蕉 （第二个元素）
print(fruits[-1])  # 葡萄 （最后一个元素，-1表示倒数第一）
print(fruits[-2])  # 橙子 （倒数第二个）

切片：取出列表的一部分

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])   # [2, 3, 4] （索引2到4，5不包含）
print(nums[:4])    # [0, 1, 2, 3] （从头开始到索引3）
print(nums[6:])    # [6, 7, 8, 9] （从索引6到末尾）
print(nums[:])       # [0, 1, 2, ..., 9] （复制整个列表）

列表常用操作

fruits = ["苹果", "香蕉"]

# 添加元素
fruits.append("橙子")      # 在末尾添加：["苹果", "香蕉", "橙子"]
fruits.insert(1, "草莓")   # 在索引1位置插入：["苹果", "草莓", "香蕉", "橙子"]

# 删除元素
fruits.remove("香蕉")     # 删除"香蕉"（按值删除）
del fruits[0]             # 删除索引0的元素
popped = fruits.pop()       # 删除并返回最后一个元素

# 其他
len(fruits)                 # 获取列表长度（有几个元素）
fruits.sort()               # 排序（数字从小到大，字符串按字母）
fruits.reverse()            # 反转列表
"苹果" in fruits           # 判断"苹果"是否在列表中，返回True/False

遍历列表

scores = [85, 92, 78, 96]

# 方法1：直接遍历元素
for score in scores:
    print(score)

# 方法2：用索引遍历
for i in range(len(scores)):
    print(f"第{i+1}个成绩：{scores[i]}")

# 方法3：用 enumerate 同时获取索引和值
for i, score in enumerate(scores):
    print(f"索引{i}对应的值是{score}")

元组：不可变的列表

point = (3, 4)       # 坐标点
date = (2024, 5, 22)  # 日期

print(point[0])   # 3
# point[0] = 5    # ❌ 报错！元组不能修改

📝 本章小结

• 💡 列表用 []，可以存放多个数据
• 💡 索引从 0 开始，负数表示倒数
• 💡 append() 添加，remove() 删除
• 💡 元组用 ()，创建后不能修改

🎯 本章目标

• ✅ 理解字典(dict)的键值对结构
• ✅ 掌握字典的增删改查操作
• ✅ 学会遍历字典的键、值、键值对
• ✅ 了解集合(set)的去重功能

什么是函数？

def say_hello():
    print("你好！")
    print("欢迎来到Python世界！")

# 调用函数
say_hello()
say_hello()   # 可以反复使用！

带参数的函数

def greet(name):
    print("你好，" + name + "！")

greet("小明")    # 输出：你好，小明！
greet("小红")    # 输出：你好，小红！

# 多个参数
def add(a, b):
    result = a + b
    print(f"{a} + {b} = {result}")

add(3, 5)     # 输出：3 + 5 = 8
add(10, 20)   # 输出：10 + 20 = 30

返回值：return

def multiply(a, b):
    return a * b

result = multiply(4, 7)
print(result)   # 输出：28

# 更实用的例子：计算圆面积
def circle_area(radius):
    return 3.14 * radius * radius

area = circle_area(5)
print(f"半径为5的圆面积是 {area}")   # 78.5

默认参数值

def greet(name, greeting="你好"):
    print(f"{greeting}，{name}！")

greet("小明")              # 你好，小明！
greet("小红", "早上好")   # 早上好，小红！

变量的作用域

total = 100   # 全局变量

def show_total():
    print(total)   # 可以读取全局变量

def add_score(score):
    global total   # 声明要修改全局变量
    total = total + score

add_score(10)
print(total)   # 110

📝 本章小结

• 💡 字典用 {}，存储键值对
• 💡 通过 key 访问 value：dict[key]
• 💡 keys()、values()、items() 用于遍历
• 💡 集合自动去重，适合判断成员关系

🎯 本章目标

• ✅ 综合运用所学知识
• ✅ 学会分析和拆解问题
• ✅ 培养编程思维
• ✅ 完成多个实战项目

项目一：猜数字游戏

import random

secret = random.randint(1, 100)   # 随机生成1-100的数字
print("猜数字游戏！我想了一个1-100之间的数字。")

while True:
    guess = int(input("请输入你的猜测："))

    if guess == secret:
        print("🎉 恭喜你，猜对了！")
        break
    elif guess < secret:
        print("太小了，再大一点！")
    else:
        print("太大了，再小一点！")

项目二：简易计算器

def calculator():
    print("===== 简易计算器 =====")
    a = float(input("请输入第一个数字："))
    op = input("请输入运算符(+ - * /)：")
    b = float(input("请输入第二个数字："))

    if op == "+":
        print("结果：", a + b)
    elif op == "-":
        print("结果：", a - b)
    elif op == "*":
        print("结果：", a * b)
    elif op == "/":
        if b == 0:
            print("错误：不能除以0！")
        else:
            print("结果：", a / b)
    else:
        print("未知的运算符")

calculator()

项目四：成绩管理系统（分步实现）

步骤1：创建空列表存储成绩

# 创建一个空列表，用来存储所有成绩
scores = []
print("成绩管理系统启动！")

步骤2：实现"添加成绩"功能

# 获取用户输入并添加到列表
score = int(input("请输入成绩："))
scores.append(score)
print("添加成功！当前成绩：", scores)

步骤3：实现"查看统计"功能

# 计算最高分、最低分、平均分
if len(scores) > 0:
    print("最高分：", max(scores))
    print("最低分：", min(scores))
    print("平均分：", sum(scores) / len(scores))
    
    # 统计及格人数（成绩>=60）
    pass_count = 0
    for s in scores:
        if s >= 60:
            pass_count += 1
    print(f"及格人数：{pass_count}/{len(scores)}")
else:
    print("还没有成绩！")

步骤4：用循环和菜单整合所有功能

scores = []

while True:
    print("
===== 成绩管理系统 =====")
    print("1. 添加成绩")
    print("2. 查看所有成绩")
    print("3. 查看统计信息")
    print("4. 退出")
    
    choice = input("请选择操作(1-4)：")
    
    if choice == "1":
        score = int(input("请输入成绩："))
        scores.append(score)
        print("✅ 添加成功！")
    elif choice == "2":
        print("所有成绩：", scores)
    elif choice == "3":
        # 这里放步骤3的统计代码
        pass
    elif choice == "4":
        print("再见！")
        break
    else:
        print("❌ 无效选择，请重新输入")

项目三：石头剪刀布

import random

def get_winner(player, computer):
    if player == computer:
        return "平局"
    if (player == "石头" and computer == "剪刀") or \
       (player == "剪刀" and computer == "布") or \
       (player == "布" and computer == "石头"):
        return "你赢了"
    return "电脑赢了"

while True:
    player = input("请出拳（石头/剪刀/布），或输入退出：")
    if player == "退出":
        break
    computer = random.choice(["石头", "剪刀", "布"])
    print(f"你出了{player}，电脑出了{computer}")
    print(get_winner(player, computer))

📝 本章小结

• 💡 函数 = 可重复使用的代码块
• 💡 def 函数名(参数): 定义函数
• 💡 return 用于返回结果
• 💡 参数可以有默认值

📝 本章小结

• 💡 猜数字游戏：random + 循环 + 条件
• 💡 计算器：函数 + 条件判断
• 💡 成绩管理：列表 + 循环 + 统计
• 💡 编程需要多练习，熟能生巧

🎯 本章目标

• ✅ 理解网络编程基础概念
• ✅ 掌握Socket编程
• ✅ 学会使用Flask构建Web应用
• ✅ 理解RESTful API设计原则

🌐 网络编程基础

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('www.example.com', 80))
client.send(b'GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n')
response = client.recv(4096)
print(response.decode())
client.close()

🔥 Flask Web框架入门

from flask import Flask, jsonify, request
app = Flask(__name__)

@app.route('/')
def home():
    return 'Hello, World!'

@app.route('/api/users', methods=['GET', 'POST'])
def users():
    if request.method == 'POST':
        data = request.get_json()
        return jsonify({'message': 'User created', 'data': data}), 201
    return jsonify({'users': ['Alice', 'Bob']})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

📝 本章小结

• 💡 Socket是网络通信的基础
• 💡 Flask让Web开发变得简单
• 💡 RESTful API是现代Web服务的标准

🎯 本章目标

• ✅ 理解同步与异步的区别
• ✅ 掌握async/await语法
• ✅ 学会使用asyncio库
• ✅ 理解协程和事件循环

⚡ 异步编程基础

import asyncio

async def say_hello():
    print('Hello')
    await asyncio.sleep(1)
    print('World')

asyncio.run(say_hello())

async def main():
    tasks = [
        asyncio.create_task(say_hello()),
        asyncio.create_task(say_hello()),
    ]
    await asyncio.gather(*tasks)

asyncio.run(main())

📝 本章小结

• 💡 async def 定义异步函数
• 💡 await 等待异步操作完成
• 💡 asyncio.gather() 并发执行多个任务

🎯 本章目标

• ✅ 掌握NumPy数组操作
• ✅ 学会使用Pandas处理数据
• ✅ 能够用Matplotlib绑制图表
• ✅ 理解数据清洗流程

📊 NumPy数组操作

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr * 2)  # [2 4 6 8 10]
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix.shape)  # (2, 3)
print(np.mean(arr))   # 平均值
print(np.std(arr))    # 标准差

🐼 Pandas数据处理

import pandas as pd
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['北京', '上海', '广州']
})
print(df[df['age'] > 25])
print(df.describe())
print(df.groupby('city')['age'].mean())

📝 本章小结

• 💡 NumPy适合数值计算
• 💡 Pandas适合表格数据处理
• 💡 Matplotlib用于数据可视化

🎯 本章目标

• ✅ 理解机器学习基本概念
• ✅ 学会使用Scikit-learn
• ✅ 掌握常见分类和回归算法
• ✅ 理解模型评估方法

🤖 机器学习基础

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

X = [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
y = [0, 0, 1, 1, 1]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = LogisticRegression()
model.fit(X_train, y_train)

predictions = model.predict(X_test)
print(f'准确率: {accuracy_score(y_test, predictions)}')

📝 本章小结

• 💡 监督学习需要标签数据
• 💡 训练集用于学习，测试集用于评估
• 💡 特征工程是关键步骤

🎯 本章目标

• ✅ 掌握SQL基础语法
• ✅ 学会使用SQLite
• ✅ 理解ORM概念
• ✅ 掌握SQLAlchemy

🗄️ SQLite基础

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

cursor.execute('''CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER
)''')

cursor.execute('INSERT INTO users (name, age) VALUES (?, ?)', ('Alice', 25))
conn.commit()

cursor.execute('SELECT * FROM users')
print(cursor.fetchall())

conn.close()

📝 本章小结

• 💡 SQL是数据库操作的标准语言
• 💡 ORM让数据库操作更Pythonic
• 💡 注意SQL注入防护

🎯 本章目标

• ✅ 学会使用pytest进行单元测试
• ✅ 掌握异常处理最佳实践
• ✅ 理解日志记录的重要性
• ✅ 了解性能优化技巧

🧪 pytest单元测试

import pytest

def add(a, b):
    return a + b

def test_add():
    assert add(1, 2) == 3
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

def test_add_type_error():
    with pytest.raises(TypeError):
        add("1", 2)

# 运行: pytest test_example.py -v

📝 日志记录

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='app.log'
)

logger = logging.getLogger(__name__)

logger.debug('调试信息')
logger.info('普通信息')
logger.warning('警告信息')
logger.error('错误信息')
logger.critical('严重错误')

📝 本章小结

• 💡 测试是保证代码质量的关键
• 💡 日志帮助排查问题
• 💡 异常处理让程序更健壮

核心区别：

• 可变性：list是可变的（mutable），可以添加、删除、修改元素；tuple是不可变的（immutable），一旦创建就不能修改
• 性能：tuple比list更轻量，访问速度更快，占用内存更少
• 用途：tuple通常用于存储不变的数据，如坐标、日期等；list用于存储需要经常修改的数据

概念解释：

• 浅拷贝：只拷贝对象的第一层，嵌套的对象仍然引用原对象
• 深拷贝：递归拷贝所有层级，生成一个完全独立的新对象

装饰器定义：装饰器是一种修改函数或类行为的语法糖，使用@符号放在函数定义上方。

参数说明：

• *args：接收任意数量的位置参数，封装成元组
• **kwargs：接收任意数量的关键字参数，封装成字典

生成器特点：

• 使用yield关键字返回值
• 每次只产生一个值，节省内存
• 可以表示无限序列
• 惰性计算，按需生成

函数对比：

• map()：对每个元素执行操作，返回所有结果
• filter()：根据条件过滤元素，返回满足条件的元素
• reduce()：对序列进行累积计算，返回最终结果

GIL概念：

• GIL（Global Interpreter Lock）：全局解释器锁，是Python解释器中的一个机制
• 影响：同一时刻只有一个线程执行Python字节码，限制了多线程的并行执行
• 解决方案：使用多进程（multiprocessing）绕过GIL，或使用C扩展

猴子补丁定义：在运行时动态修改模块、类或函数的行为，而不需要修改源代码。

方法对比：

• __new__：创建实例对象，在__init__之前调用
• __init__：初始化实例对象，在对象创建后调用

概念对比：

• 可迭代对象：可以用for循环遍历的对象（list、tuple、dict、set、str等）
• 迭代器：实现了__iter__()和__next__()方法的对象，可以逐个获取元素

with语句：用于简化资源管理，确保资源在使用后正确释放，无论是否发生异常。

运算符对比：

• is：比较对象身份（内存地址），判断是否是同一个对象
• ==：比较值是否相等，判断内容是否相同

作用域查找顺序：

• L (Local)：本地作用域，函数内部
• E (Enclosing)：闭包作用域，外层函数
• G (Global)：全局作用域，模块级别
• B (Built-in)：内置作用域，Python内置

闭包定义：闭包是指一个函数记住并访问其创建时的词法作用域，即使函数在原始作用域之外被调用。

表达式对比：

• 列表推导式：用方括号，立即生成完整列表，占用内存
• 生成器表达式：用圆括号，惰性求值，按需生成，节省内存

异常处理机制：

并发方案对比：

• 多线程：共享内存，适合IO密集型任务，但受GIL限制
• 多进程：独立内存，适合CPU密集型任务，可并行执行

序列化模块对比：

• json：人类可读的文本格式，跨语言兼容，只能序列化基本数据类型
• pickle：Python专用的二进制格式，可序列化任意Python对象，不跨语言

单例模式：确保一个类只有一个实例，并提供全局访问点。