编程就是告诉计算机一步一步做什么。Python 之所以适合入门，因为它读起来像英语，代码量少，还免费。一个程序大概分三步：准备数据，处理数据，输出结果。
变量和数据类型
变量就像贴了标签的储物盒。赋值就是把东西放进盒子，然后通过标签来用。
name = "小明" # 把"小明"放进 name 这个盒子里
age = 18
height = 1.75
is_student = True
print(name) # 小明
Python 里常见的数据类型：
- 整数
int：没有小数，比如苹果的个数 - 浮点数
float：带小数，比如身高、价格 - 字符串
str：用引号包围的文字 - 布尔值
bool：只有True和False，像开关
student_count = 45 # int
price = 19.99 # float
name = "李华" # str
is_raining = True # bool
print(type(age)) # <class 'int'>
print(type(price)) # <class 'float'>
有时候需要把一种类型转换成另一种：
text_number = "123"
real_number = int(text_number) # 字符串 -> 整数
print(real_number) # 123
score = 95
score_text = str(score)
print("我的分数是：" + score_text) # 我的分数是：95
price = 19.99
whole_price = int(price) # 浮点 -> 整数，直接截断小数
print(whole_price) # 19
运算符
算术运算
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 幂运算
比较运算
x = 10
y = 5
print(x == y) # False 等于？
print(x != y) # True 不等于？
print(x > y) # True 大于？
print(x < y) # False 小于？
print(x >= y) # True 大于等于？
print(x <= y) # False 小于等于？
逻辑运算
and 需要两个条件都成立，or 只要一个成立，not 取反。
is_weekend = True
has_money = True
can_shopping = is_weekend and has_money # True
is_holiday = False
can_rest = is_holiday or is_weekend # True
print(not is_raining) # 若 is_raining 为 True，则输出 False
输入与输出
input() 让程序停下来等用户输入，print() 把结果展示出来。
name = input("请输入你的名字：")
age = input("请输入你的年龄：")
print("你好，" + name + "！")
print("你今年" + age + "岁了")
# 格式化输出更清晰
price = 19.99
quantity = 3
total = price * quantity
print(f"单价：{price}元，数量：{quantity}，总价：{total:.2f}元")
# 输出：单价：19.99 元，数量：3，总价：59.97 元
条件判断
让程序根据不同情况做不同的事。
age = 18
if age >= 18:
print("你已经成年了！")
# 二选一
age = 16
if age >= 18:
print("成年")
else:
print("未成年")
# 多分支
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 70:
print("中等")
elif score >= 60:
print("及格")
else:
print("不及格")
# 嵌套判断
age = 20
has_license = True
has_car = False
if age >= 18:
if has_license:
if has_car:
print("可以开车出门")
else:
print("有驾照但没车")
else:
print("需要先考驾照")
else:
print("年龄不够，不能开车")
循环
while 循环
当条件满足时一直重复，直到条件不成立为止。常用于不知道具体循环次数的情况。
count = 0
while count < 5:
print(f"这是第{count + 1}次循环")
count += 1 # 别忘了改变条件，否则死循环
password = ""
while password != "123456":
password = input("请输入密码：")
print("密码正确！")
for 循环
遍历一个序列（列表、字符串等）的每个元素，知道要重复多少次。
fruits = ["苹果", "香蕉", "橙子", "草莓"]
for fruit in fruits:
print(f"我喜欢吃{fruit}")
for char in "Python": # 逐个字符
print(char)
range() 可以生成数字序列。
for i in range(5): # 0 到 4
print(i)
for i in range(2, 6): # 2 到 5
print(i)
for i in range(1, 11, 2): # 1,3,5,7,9 (步长2)
print(i)
循环控制：break 和 continue
# break：立即结束整个循环
for i in range(10):
if i == 5:
break
print(i) # 只打到 0~4
# continue：跳过本轮剩下的代码，进入下一轮
for i in range(10):
if i % 2 == 0: # 偶数则跳过
continue
print(i) # 只输出奇数
数据结构
列表 (list)
有序、可变的序列，像动态的购物车。
shopping_list = ["苹果", "牛奶", "面包"]
mixed_list = [1, "苹果", 3.14, True]
# 索引（从0开始，负索引从-1开始）
fruits = ["苹果", "香蕉", "橙子", "草莓", "葡萄", "芒果"]
print(fruits[0]) # 苹果
print(fruits[-1]) # 芒果
# 切片 [start:stop:step]
numbers = [0,1,2,3,4,5,6,7,8,9]
print(numbers[2:6]) # [2,3,4,5]
print(numbers[:4]) # [0,1,2,3]
print(numbers[5:]) # [5,6,7,8,9]
print(numbers[::2]) # [0,2,4,6,8]
修改列表：
fruits = ["苹果", "香蕉"]
fruits.append("橙子") # 末尾添加
fruits.extend(["草莓", "葡萄"]) # 合并另一个列表
fruits.insert(1, "梨") # 在索引1插入
# 删除
del fruits[1] # 按索引删除
removed = fruits.pop(2) # 弹出索引2的元素
fruits.remove("梨") # 删除第一个匹配值
# 修改
fruits[1] = "葡萄"
fruits[0:2] = ["芒果", "菠萝"] # 切片赋值
fruits[1:1] = ["西瓜", "哈密瓜"] # 切片插入
常用操作：
numbers = [1,3,5,3,7,9,3,1]
print(len(numbers)) # 8
print(numbers.count(3)) # 3
print(numbers.index(5)) # 2
print(5 in numbers) # True
元组 (tuple)
与列表类似，但创建后不能修改。适合存放不该变的数据。
colors = ("红色", "绿色", "蓝色")
print(colors[0]) # 红色
# colors[0] = "黄色" 会报错
# 解包
student_info = ("张三", 18, "清华大学")
name, age, school = student_info
print(f"{name}今年{age}岁，在{school}上学")
字典 (dict)
键值对的集合，通过键快速查找值，就像通讯录。
contacts = {
"张三": "13800138000",
"李四": "13900139000"
}
print(contacts["张三"]) # 13800138000
contacts["赵六"] = "13600136000" # 添加
contacts["张三"] = "13800138001" # 修改
del contacts["李四"]
# 安全访问
print(student.get("name")) # 小明
print(student.get("address", "未知")) # 未知（带默认值）
print("name" in student) # True
print(student.keys()) # 所有键
print(student.values()) # 所有值
集合 (set)
无序、不重复的元素集合，自带去重效果。
fruits = {"苹果", "香蕉", "橙子", "苹果"} # 重复的苹果自动去掉
print(fruits) # {'橙子', '香蕉', '苹果'} 顺序不定
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # 并集
print(set1 & set2) # 交集
print(set1 - set2) # 差集
print(set1 ^ set2) # 对称差集
函数
函数就是封装好的逻辑块，定义一次可以重复用。
def make_tea(tea_type, sugar_level=1):
"""泡茶函数，返回一杯茶的描述"""
tea_description = f"一杯{tea_type}"
if sugar_level > 1:
tea_description += f"，糖度{sugar_level}级"
return tea_description
print(make_tea("绿茶")) # 一杯绿茶
print(make_tea("红茶", 3)) # 一杯红茶，糖度3级
print(make_tea(sugar_level=5, tea_type="乌龙茶"))
# 一杯乌龙茶，糖度5级
参数
位置参数必须按顺序传，关键字参数可以按名字传，默认参数可以不传。
def order_coffee(coffee_type, size="中杯", sugar=True, ice=False):
order = f"{size}{coffee_type}"
order += "，加糖" if sugar else "，无糖"
order += "，加冰" if ice else "，热饮"
return order
print(order_coffee("拿铁")) # 中杯拿铁，加糖，热饮
print(order_coffee("美式", "大杯")) # 大杯美式，加糖，热饮
print(order_coffee("卡布奇诺", sugar=False)) # 中杯卡布奇诺，无糖，热饮
可变参数 *args 和 **kwargs 可以接收任意数量的参数：
def make_smoothie(*fruits, **extras):
smoothie = "混合果汁包含：" + "、".join(fruits)
if extras:
smoothie += "，额外添加："
for item, amount in extras.items():
smoothie += f"{item}{amount}份、"
return smoothie.rstrip("、")
print(make_smoothie("香蕉", "草莓"))
print(make_smoothie("芒果", "菠萝", "椰子", ice=2, sugar=1))
返回值
可以返回单个值，也可以返回多个值（实际上是个元组），甚至返回字典。
def analyze_scores(scores):
avg = sum(scores) / len(scores)
return avg, max(scores), min(scores), len(scores)
def get_student_report(name, scores):
avg = sum(scores) / len(scores)
grade = "优秀" if avg >= 90 else "良好" if avg >= 80 else "及格"
return {
"姓名": name,
"平均分": round(avg, 2),
"最高分": max(scores),
"最低分": min(scores),
"等级": grade
}
avg, high, low, cnt = analyze_scores([85,92,78,96,88])
report = get_student_report("小明", [85,92,78,96,88])
lambda 匿名函数
lambda 可以快速定义一个小函数，通常用在只需要一次的地方。
square = lambda x: x * x
print(square(5)) # 25
# 用在高阶函数里，比如排序
pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
pairs.sort(key=lambda pair: pair[1]) # 按字符串排序
模块
把代码按功能放进不同的文件，就是模块。导入方式有好几种：
# 导入整个模块
import math
print(math.sqrt(16)) # 4.0
# 导入特定函数
from math import sqrt, pi
print(sqrt(25)) # 5.0
# 导入并起别名
import math as m
from datetime import datetime as dt
print(m.sqrt(36)) # 6.0
print(dt.now())
# 动态导入（较少用）
module_name = "math"
math_module = __import__(module_name)
常用内置模块：
math 提供数学函数和常量：
print(math.ceil(3.2)) # 4
print(math.floor(3.8)) # 3
print(math.gcd(48, 18)) # 6
random 搞定随机：
import random
print(random.randint(1,100)) # 1~100 的整数
print(random.choice(["苹果","香蕉"])) # 随机选一个
random.shuffle(fruits) # 原地打乱
datetime 处理日期和时间：
from datetime import datetime, timedelta
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))
tomorrow = now + timedelta(days=1)
os 模块与操作系统交互：
import os
print(os.getcwd()) # 当前目录
print(os.listdir('.')) # 列出目录内容
print(os.path.exists('test.txt'))
面向对象编程
类和对象
类像是设计图纸，对象是根据图纸造出来的东西。
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
def introduce(self):
return f"我叫{self.name}，今年{self.age}岁"
def study(self, hours):
self.score += hours * 0.5
return f"学习了{hours}小时，分数提升了{hours * 0.5}"
# 创建对象
student1 = Student("小明", 18, 85)
print(student1.introduce()) # 我叫小明，今年18岁
print(student1.study(2)) # 学习了2小时，分数提升了1.0
封装
把内部细节藏起来，只通过公开方法访问。用双下划线前缀表示私有属性。
class BankAccount:
def __init__(self, initial_balance=0):
self.__balance = initial_balance # 私有
def deposit(self, amount):
if amount > 0:
self.__balance += amount
return f"存款成功，当前余额：{self.__balance}"
return "金额必须大于0"
def get_balance(self):
return self.__balance
account = BankAccount(1000)
account.deposit(500)
print(account.get_balance()) # 1500
# print(account.__balance) # 报错，无法直接访问
继承
子类继承父类的属性和方法，还能添加自己的东西。
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
return f"{self.name}在吃东西"
class Dog(Animal):
def speak(self):
return "汪汪！"
def fetch(self):
return f"{self.name}在接飞盘"
class Cat(Animal):
def speak(self):
return "喵喵！"
def climb(self):
return f"{self.name}在爬树"
dog = Dog("旺财")
print(dog.speak()) # 汪汪！
print(dog.eat()) # 旺财在吃东西
print(dog.fetch()) # 旺财在接飞盘
多态
不同对象对同一个方法可以有不同的响应。
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
class Rectangle:
def __init__(self, width, height):
self.width, self.height = width, height
def area(self):
return self.width * self.height
# 遍历不同类型的图形，各自计算面积
for shape in [Circle(5), Rectangle(4, 6)]:
print(f"面积：{shape.area():.2f}")
接下来学什么
基础语法只是开始。理解了变量、循环、函数和类之后，可以试着写几个小项目：计算器、猜数字、通讯录管理。练手过程中你会自然而然碰到文件读写、异常处理、第三方库，到时候再根据需要去查。编程就像学骑自行车，摔几跤，然后突然就能跑起来了。
