Python 编程起步：变量、数据结构与面向对象实例

运算符

算术运算

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}")

接下来学什么

基础语法只是开始。理解了变量、循环、函数和类之后，可以试着写几个小项目：计算器、猜数字、通讯录管理。练手过程中你会自然而然碰到文件读写、异常处理、第三方库，到时候再根据需要去查。编程就像学骑自行车，摔几跤，然后突然就能跑起来了。