【Python基础】从变量到面向对象：打通 Python 入门核心语法

🔥个人主页：爱和冰阔乐

📚专栏传送门：《数据结构与算法》 、C++

🐶学习方向：C++方向学习爱好者

⭐人生格言：得知坦然 ，失之淡然

---

🏠博主简介

文章目录

• 前言
• [一、Python 程序的基本认识](#一、Python 程序的基本认识)
• • [1.1 Python 文件如何执行](#1.1 Python 文件如何执行)
  • [1.2 缩进决定代码块](#1.2 缩进决定代码块)
  • [1.3 和 C/C++ 的直观对比](#1.3 和 C/C++ 的直观对比)
• 二、变量与数据类型
• • [2.1 Python 不是没有类型](#2.1 Python 不是没有类型)
  • [2.2 常见基础类型](#2.2 常见基础类型)
• 三、字符串与输入输出
• • [3.1 字符串定义](#3.1 字符串定义)
  • [3.2 字符串拼接与格式化](#3.2 字符串拼接与格式化)
  • [3.3 input 获取的一定是字符串](#3.3 input 获取的一定是字符串)
• 四、运算符与流程控制
• • [4.1 运算符](#4.1 运算符)
  • [4.2 条件判断](#4.2 条件判断)
  • [4.3 match...case](#4.3 match...case)
  • [4.4 循环](#4.4 循环)
• 五、数据容器
• • [5.1 容器整体对比](#5.1 容器整体对比)
  • [5.2 列表 list](#5.2 列表 list)
  • [5.3 列表合并、去重与推导式](#5.3 列表合并、去重与推导式)
  • [5.4 元组、集合、字典](#5.4 元组、集合、字典)
• 六、函数：让代码可复用
• • [6.1 函数定义与调用](#6.1 函数定义与调用)
  • [6.2 变量作用域与参数](#6.2 变量作用域与参数)
  • [6.3 不定长参数与 lambda](#6.3 不定长参数与 lambda)
• 七、模块、包与类型注解
• • [7.1 模块和包](#7.1 模块和包)
  • [7.2 类型注解](#7.2 类型注解)
• 八、面向对象基础
• • [8.1 类与对象](#8.1 类与对象)
  • [8.2 方法、类属性与封装](#8.2 方法、类属性与封装)
  • [8.3 继承与多态](#8.3 继承与多态)
• 九、综合案例：学生成绩统计
• • [9.1 需求分析](#9.1 需求分析)
  • [9.2 完整代码](#9.2 完整代码)
  • [9.3 核心拆解](#9.3 核心拆解)
• [十、从 C/C++ 思维切换到 Python 思维](#十、从 C/C++ 思维切换到 Python 思维)
• • [10.1 不要总是用下标遍历](#10.1 不要总是用下标遍历)
  • [10.2 善用 Python 的表达方式](#10.2 善用 Python 的表达方式)
• 十一、初学者最容易踩的几个坑
• • [11.1 `input()` 拿到的永远是字符串](#11.1 input() 拿到的永远是字符串)
  • [11.2 不要把可变对象当默认参数](#11.2 不要把可变对象当默认参数)
  • [11.3 列表遍历时不要一边遍历一边删除](#11.3 列表遍历时不要一边遍历一边删除)
  • [11.4 `is` 和 `==` 不是一回事](#11.4 is 和 == 不是一回事)
  • [11.5 代码能跑不代表写得好维护](#11.5 代码能跑不代表写得好维护)
• 总结

前言

学完 C 语言后再看 Python，很多同学第一感觉是：这门语言怎么这么"随意"？变量不用写类型，语句后面不用写分号，代码块也不用花括号，甚至几行代码就能完成 C 语言一大段逻辑。

这个感觉还停留在表面。

Python 真正重要的地方，不只是语法简洁，而是它封装了很多底层细节，让我们更关注数据组织、逻辑表达和功能复用。C 语言更像是在训练我们理解计算机底层；Python 则更像是在训练我们快速把想法转换成能运行、能维护的程序。

本文从 Python 入门几块内容展开：

变量与数据类型

字符串与输入输出

运算符与流程控制

列表、元组、集合、字典

函数、模块、包、类型注解

类、对象、封装、继承、多态

结论：Python 入门不是背语法，而是理解语法解决什么问题。

一、Python 程序的基本认识

1.1 Python 文件如何执行

Python 文件以 .py 结尾，例如：

hello.py
main.py
student.py

一个最简单的程序如下：

print("hello python")

对比 C 语言可以发现，Python 没有强制要求写 main 函数，也不需要头文件和分号。解释器会从文件第一行开始，自上而下执行。

1.2 缩进决定代码块

Python 中最重要的规则之一就是：缩进不是排版，而是语法。

age = 18

if age >= 18:
    print("已经成年")
    print("可以学习更多编程知识")
else:
    print("还未成年")

在 C/C++ 中，代码块由 {} 决定；在 Python 中，代码块由缩进决定。同一代码块缩进必须一致，否则可能报错。

⚠️ 注意：Python 不使用 {} 表示代码块，缩进本身就是代码结构。

1.3 和 C/C++ 的直观对比

对比点	C/C++	Python
代码块	{}	缩进
语句结束	通常写 ;	一般不写
变量类型	定义时声明	运行时由对象决定
运行方式	编译后运行	解释执行为主
编程体验	更贴近底层	更贴近逻辑表达

二、变量与数据类型

2.1 Python 不是没有类型

在 C 语言中定义变量需要写类型：

int age = 18;
double score = 99.5;

Python 可以直接写：

age = 18
score = 99.5
name = "张三"
is_pass = True

这不代表 Python 没有类型，而是变量名不需要提前绑定某一种固定类型。可以使用 type() 查看类型：

num = 13.0

print(type("hello"))
print(type(10))
print(type(num))

也可以使用 isinstance() 判断类型：

data = 5.0

print(isinstance(data, float))
print(isinstance(data, int))

结论：Python 的变量名更像贴在对象上的标签，而不是固定类型的内存盒子。

2.2 常见基础类型

类型	含义	示例
int	整数	10
float	浮点数	3.14
str	字符串	"python"
bool	布尔值	True
list	列表	[1, 2, 3]
tuple	元组	(1, 2, 3)
set	集合	{1, 2, 3}
dict	字典	{"name": "张三"}

Python 允许同一个变量名先指向整数，再指向字符串：

x = 10
x = "hello"

语法上可以，但实际开发不建议这样乱用。变量名应该表达稳定含义，否则代码可读性会下降。

三、字符串与输入输出

3.1 字符串定义

Python 中字符串可以使用单引号、双引号、三引号：

s1 = "hello"
s2 = 'python'
s3 = """
你好
python
"""

三引号适合多行文本，也常用于函数说明文档。

如果字符串里本身包含引号，可以使用转义字符：

s = 'it\'s very good'
print(s)

常见转义字符有 \n、\t、\'、\"、\\，分别表示换行、制表符、引号和反斜杠。

3.2 字符串拼接与格式化

字符串可以用 + 拼接：

a1 = "你好"
a2 = "世界"
age = 18

print(a1 + "," + a2)
print("我的年龄是：" + str(age))

⚠️ 注意：字符串不能直接和数字拼接，数字需要先用 str() 转换。

更推荐使用 f-string：

name = "小明"
a = 10
b = 20

print(f"大家好，我是{name}")
print(f"{a} + {b} = {a + b}")

f-string 的优点是直观，变量和表达式可以直接放在 {} 中。

3.3 input 获取的一定是字符串

输入使用 input()：

name = input("请输入你的姓名：")
print(f"欢迎你，{name}")

重点来了：

结论：无论键盘输入什么，input() 获取到的永远是字符串。

如果要参与计算，需要类型转换：

x = int(input("请输入第一个整数："))
y = int(input("请输入第二个整数："))

print("x + y =", x + y)

接收小数则用 float()：

x = float(input("请输入第一个数据："))
y = float(input("请输入第二个数据："))

print("x + y 的值为", x + y)

浮点数运算可能出现精度损失：

print(0.1 + 0.2)

结果可能是 0.30000000000000004。这不是 Python 算错了，而是二进制无法精确表示所有十进制小数。

四、运算符与流程控制

4.1 运算符

Python 常见算术运算符：

运算符	含义
+	加
-	减
*	乘
/	除
//	整除
%	取模
**	幂运算

示例：

print("10 ** 3:", 10 ** 3)
print("10 // 3:", 10 // 3)
print("10 / 2.1:", 10 / 2.1)

逻辑运算符中，and 对应 C/C++ 的 &&，or 对应 ||，not 对应 !。

Python 还支持连续比较：

num = int(input("请输入一个整数："))

if 10 <= num <= 20:
    print(f"{num} 在 10 到 20 之间")

4.2 条件判断

score = int(input("请输入你的成绩："))

if score >= 750:
    print("成绩输入有误")
elif score >= 680:
    print(f"我要上清华，因为我的分数 {score} 超过 680 分")
else:
    print("继续努力")

多分支判断中，顺序很关键。特殊条件放前面，兜底条件放后面。

4.3 match...case

match...case 类似 C 语言中的 switch...case：

day = int(input("请输入星期几（1-7）："))

match day:
    case 1:
        print("周一：工作会议")
    case 2:
        print("周二：学习")
    case 3 | 4 | 5:
        print("周三到周五：继续努力")
    case 6 | 7:
        print("周六周日：休息")
    case _:
        print("输入错误")

其中 | 表示匹配多个值中的任意一个，_ 表示其他所有情况。

4.4 循环

while 适合循环次数不确定，但条件明确的场景：

num = 5

while num >= 0:
    print("继续执行循环")
    num -= 1
else:
    print("循环正常结束")

如果循环被 break 打断，else 不会执行。

for 更适合遍历容器：

for ch in "python":
    print(ch)

for i in range(1, 6):
    print(i)

range(1, 6) 包含 1，不包含 6。

五、数据容器

5.1 容器整体对比

列表 list 有序、可重复、可修改，适合保存一组数据；元组 tuple 有序但不可修改，适合保存固定数据；字符串 str 是文本序列；集合 set 无序且元素不重复，适合去重；字典 dict 保存键值对，适合描述对象信息。

🔍 关键发现：学 Python 不熟悉容器，就像学 C 语言不熟悉数组和结构体。

5.2 列表 list

列表可以保存多个元素：

s = [1, 2, 3, 4, 2, 3.6, "hello", True]
print(type(s))

列表支持下标访问：

nums = [10, 20, 30, 40]

print(nums[0])
print(nums[-1])

常见方法：

s = [1, 3, 5, 2, 66, 98, 6]

s.append(32)
s.insert(0, 11111)
s.remove(2)
s.sort()
s.reverse()

e = s.pop(0)
print(e)
print(s)

列表、字符串、元组都支持切片：

s = [1, 2, 3, 4, 5, 6, 7]

print(s[0:5:2])
print(s[:3])
print(s[3:])
print(s[::-1])

5.3 列表合并、去重与推导式

合并两个列表并去重：

num_list1 = [19, 23, 54, 64, 875, 20, 123, 54]
num_list2 = [55, 80, 72, 35, 60, 123, 54]

num_list = [*num_list1, *num_list2]

new_list = []
for num in num_list:
    if num not in new_list:
        new_list.append(num)

print(new_list)

生成 1 到 20 的平方：

ss_list = [i ** 2 for i in range(1, 21)]
print(ss_list)

提取偶数并求平方：

nn_list = [12, 17, 45, 93, 33, 95, 97, 80, 32]
new = [i ** 2 for i in nn_list if i % 2 == 0]
print(new)

⚠️ 注意：列表推导式适合简单逻辑，复杂逻辑不要强行压成一行。

5.4 元组、集合、字典

元组不可修改：

t = (10, 20, 30)
print(t[0])

如果只有一个元素，必须加逗号：

t1 = (10)
t2 = (10,)

print(type(t1))
print(type(t2))

集合适合去重：

nums = [1, 2, 2, 3, 4, 4, 5]
new_nums = list(set(nums))
print(new_nums)

集合还支持交集、并集、差集：

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a & b)
print(a | b)
print(a - b)

字典是键值对结构：

stu = {
    "name": "张三",
    "age": 18,
    "city": "北京"
}

print(stu["name"])
print(stu.get("score", 0))

遍历字典：

for key, value in stu.items():
    print(key, value)

六、函数：让代码可复用

6.1 函数定义与调用

函数用于封装一段可以重复使用的逻辑。

def out():
    print("------------")
    print("------------")

out()

结论：函数的核心价值不是少写几行代码，而是把稳定逻辑封装成可复用单元。

计算圆面积：

def circle_area(r):
    area = 3.14 * r * r
    return area

print(circle_area(10))

返回多个值：

def circle_area_len(r):
    """
    这是计算圆的周长和面积的函数
    """
    area = 3.14 * r * r
    length = round(2 * 3.14 * r, 1)
    return area, length

area, length = circle_area_len(10)
print(area, length)

6.2 变量作用域与参数

函数内部定义的是局部变量：

num = 100

def circle(r):
    pi = 3.14
    num = 1000
    print("函数内部 num =", num)
    return r * r * pi

circle(10)
print("函数外部 num =", num)

如果想修改全局变量，需要 global，但大量使用全局变量不是好习惯，因为函数依赖外部状态越多，维护越困难。

参数可以按位置传，也可以按关键字传：

def reg_stu(name, age, gender="男", city="北京"):
    print(f"注册成功，姓名: {name}, 年龄: {age}, 性别: {gender}, 城市: {city}")
    return {"name": name, "age": age, "gender": gender, "city": city}

stu = reg_stu(name="王林", age=20)
print(stu)

默认参数必须放在没有默认值的参数后面。

6.3 不定长参数与 lambda

*args 接收位置参数：

def calc_data1(*args):
    min_data = min(args)
    max_data = max(args)
    avg = sum(args) / len(args)
    return min_data, max_data, round(avg, 1)

print(calc_data1(1, 6, 74, 52, 89, 1111))

**kwargs 接收关键字参数：

def calc_data(*args, **kwargs):
    avg_data = sum(args) / len(args)

    if kwargs.get("round"):
        avg_data = round(avg_data, kwargs.get("round"))

    return avg_data

print(calc_data(100, 200, 300, round=2))

函数还可以作为参数：

def add(x, y):
    return x + y

def calc(x, y, oper):
    return oper(x, y)

print(calc(10, 20, add))

匿名函数：

data_list = ["C++", "C", "Python", "JavaScript", "Go"]
data_list.sort(key=lambda item: len(item))
print(data_list)

七、模块、包与类型注解

7.1 模块和包

模块可以理解为一个 Python 文件。

circle.py：

PI = 3.14

def area(r):
    return PI * r * r

main.py：

import circle

print(circle.area(10))

也可以只导入指定成员：

from circle import area

print(area(10))

包可以理解为包含多个模块的文件夹：

utils/
    __init__.py
    my_fun.py
    my_var.py
main.py

一句话总结：

函数解决代码复用
模块解决文件拆分
包解决模块管理

7.2 类型注解

Python 是动态类型语言，但可以写类型提示：

name: str = "张三"
age: int = 18
score: float = 99.5

函数也可以写：

def add(x: int, y: int) -> int:
    return x + y

容器类型：

nums: list[int] = [1, 2, 3]
stu: dict[str, int] = {"age": 18}

📝 说明：类型注解主要是给人和工具看的提示，不等价于 C/C++ 的编译期强类型检查。

八、面向对象基础

8.1 类与对象

面向过程关注步骤，面向对象关注对象。

对象有哪些属性？
对象能做哪些事情？
对象之间有什么关系？

定义类：

class Car:
    pass

c1 = Car()
c1.name = "宝马"
c1.price = 150000

print(c1.__dict__)

动态添加属性虽然可以，但不推荐。更推荐在 __init__ 中初始化：

class Car:
    def __init__(self, c_name, c_price):
        self.name = c_name
        self.price = c_price

c1 = Car("宝马", 150000)
print(c1.__dict__)

self 表示当前对象，类似 C++ 中的 this。

8.2 方法、类属性与封装

class Car:
    wheel = 4

    def __init__(self, name, price):
        self.name = name
        self.price = price

    def running(self):
        print(f"{self.name} 正在高速运行！")

    def __str__(self):
        return f"{self.name} {self.price}"

c = Car("宝马", 150000)
c.running()
print(c)

wheel 是类属性，属于类本身；name 和 price 是实例属性，属于具体对象。

封装可以隐藏内部实现：

class User:
    def __init__(self, name, password):
        self.name = name
        self.__password = password

    def get_name(self):
        return self.name

双下划线开头的属性通常表示私有属性，不建议在类外部直接访问。

8.3 继承与多态

继承描述类与类之间的关系。

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def change(self):
        print(f"{self.brand} {self.model} 正在补充能源...")

class FuelCar(Car):
    def charge(self):
        super().change()
        print(f"{self.brand} {self.model} 正在补充燃料...")

class ElectricCar(Car):
    def charge(self):
        super().change()
        print(f"{self.brand} {self.model} 正在充电...")

多态指同一个调用，传入不同对象，表现不同：

def handle_charge(car):
    car.charge()

handle_charge(FuelCar("BMW", "X5"))
handle_charge(ElectricCar("BYD", "汉"))

Python 还有鸭子类型思想：更关注对象有没有某种行为，而不是它一定属于哪个类型。

class Duck:
    def swimming(self):
        print("鸭子正在游泳")

class Dog:
    def swimming(self):
        print("小狗正在游泳")

def go_swimming(obj):
    obj.swimming()

go_swimming(Duck())
go_swimming(Dog())

只要对象有 swimming() 方法，就可以被使用。

九、综合案例：学生成绩统计

9.1 需求分析

需求如下：

输入多个学生成绩
保存学生姓名和分数
计算最高分、最低分、平均分
按照成绩从高到低排序
输出成绩报告

这里可以用列表保存多个学生，用字典描述单个学生，用函数拆分不同功能。

9.2 完整代码

def input_students():
    students = []
    count = int(input("请输入学生人数："))

    for i in range(count):
        name = input(f"请输入第 {i + 1} 个学生姓名：")
        score = float(input(f"请输入 {name} 的成绩："))
        students.append({"name": name, "score": score})

    return students


def calc_report(students):
    scores = [stu["score"] for stu in students]
    max_score = max(scores)
    min_score = min(scores)
    avg_score = round(sum(scores) / len(scores), 2)
    return max_score, min_score, avg_score


def print_report(students):
    students.sort(key=lambda stu: stu["score"], reverse=True)
    max_score, min_score, avg_score = calc_report(students)

    print("---------- 成绩报告 ----------")
    print(f"最高分：{max_score}")
    print(f"最低分：{min_score}")
    print(f"平均分：{avg_score}")
    print("---------- 排名 ----------")

    for index, stu in enumerate(students, start=1):
        print(f"{index}. {stu['name']}：{stu['score']}")


def main():
    students = input_students()
    print_report(students)


if __name__ == "__main__":
    main()

9.3 核心拆解

这个案例串起了很多基础语法：

列表保存多个学生
字典描述单个学生
函数拆分输入、计算、输出
列表推导式提取成绩
lambda 指定排序规则
enumerate 同时获取排名和学生信息

if __name__ == "__main__" 用于判断当前文件是否被直接运行。如果是直接运行，就调用 main()；如果是被其他模块导入，就不会自动执行。

结论：这行代码的意义是区分"直接运行"和"被导入使用"两种场景。

十、从 C/C++ 思维切换到 Python 思维

10.1 不要总是用下标遍历

Python 如果只是访问元素，更推荐直接遍历：

nums = [10, 20, 30, 40]

for num in nums:
    print(num)

如果需要下标，可以使用 enumerate()：

for index, num in enumerate(nums):
    print(index, num)

10.2 善用 Python 的表达方式

交换两个变量：

a = 10
b = 20
a, b = b, a

函数返回多个值：

def get_data():
    return 10, 20, 30

a, b, c = get_data()

拆分程序结构：

重复逻辑封装成函数
相关函数拆到模块
多个模块组织成包
数据和行为强相关时考虑类

这就是从"能写代码"到"会组织代码"的关键一步。

十一、初学者最容易踩的几个坑

Python 入门时，很多错误不是语法没背熟，而是对语言规则的理解还停留在 C/C++ 的习惯里。下面这些问题，基本是新手代码里出现频率最高的几类。

11.1 input() 拿到的永远是字符串

很多同学写计算器、成绩统计、年龄判断时，第一处报错往往都和 input() 有关：

age = input("请输入年龄：")

if age >= 18:
    print("已经成年")

这段代码看起来没问题，但实际会报错。原因是 input() 得到的是字符串，"18" 和整数 18 不是同一种类型。正确写法是先转换：

age = int(input("请输入年龄："))

if age >= 18:
    print("已经成年")

只要涉及数学运算或大小比较，就要先确认数据类型。

11.2 不要把可变对象当默认参数

下面这个写法很容易出问题：

def add_student(name, students=[]):
    students.append(name)
    return students

print(add_student("张三"))
print(add_student("李四"))

很多人以为第二次调用会得到一个新列表，实际不是。默认参数只会在函数定义时创建一次，后续调用会复用同一个列表。更稳的写法是：

def add_student(name, students=None):
    if students is None:
        students = []
    students.append(name)
    return students

这个坑不难，但如果在项目里出现，会让数据越跑越乱。

11.3 列表遍历时不要一边遍历一边删除

比如要删除列表里的偶数，很多人会这样写：

nums = [1, 2, 3, 4, 5, 6]

for num in nums:
    if num % 2 == 0:
        nums.remove(num)

列表删除元素后，后面的元素会往前移动，循环过程就可能跳过某些数据。更推荐生成一个新列表：

nums = [1, 2, 3, 4, 5, 6]
nums = [num for num in nums if num % 2 != 0]
print(nums)

如果逻辑复杂，也可以先把要删除的元素记录下来，再统一处理。

11.4 is 和 == 不是一回事

== 比较的是值是否相等，is 比较的是两个变量是否指向同一个对象。

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)
print(a is b)

两个列表内容一样，所以 a == b 是 True；但它们是两个不同对象，所以 a is b 是 False。平时判断数值、字符串、列表内容是否相等，用 == 就够了。

11.5 代码能跑不代表写得好维护

入门阶段能跑通当然重要，但后面要慢慢关注可维护性。比如同一段逻辑写了三遍，就可以考虑函数；一个文件越来越长，就可以考虑模块；数据和操作总是一起出现，就可以考虑类。

写 Python 不要只追求"短"。有时候一行推导式确实漂亮，但如果读起来费劲，不如拆成几行。代码是写给机器执行的，也是写给以后修改代码的人看的。

总结

本文围绕 Python 基础语法，从变量、容器、函数、模块、面向对象到综合案例，梳理了一条入门学习路径。

如果只记一条主线，可以这样理解：变量负责保存数据，流程控制负责决定代码怎么走，容器负责组织一组数据，函数负责复用逻辑，模块和包负责拆分文件，面向对象负责把数据和行为放到一起管理。

Python 看起来简单，但并不代表可以随便写。缩进、类型转换、可变对象、作用域、模块导入，这些规则都会真实影响程序运行结果。基础阶段把这些点搞清楚，后面学爬虫、自动化、数据分析、Web 开发时会轻松很多。

学习 Python 最怕两种状态：一种是只背语法，不知道什么时候用；另一种是只追求代码短，结果自己过几天都看不懂。更稳的方式是先把代码写清楚，再慢慢写得简洁。

最终结论：Python 入门的关键不是记住所有语法，而是理解每个语法背后解决的问题。

如果说 C/C++ 帮我们理解底层逻辑，那么 Python 更适合快速组织数据、表达想法、构建功能。

资源分享：

https://www.python.org

python中文网官网

pycharm官网