作为一名大三在读的学生，自学计算机软件，参加了一些机器人竞赛，也自己做过一些比较复杂的项目，从机器视觉到web开发，不说精通，但是也可以落地到工程实践中。
在大学的3年时间中学习的技术栈比较广，语言比较丰富，也具备了自己的一套多语言学习路线，希望可以帮助大家。本系列文章中在更细致的讲解中可能存在偏差，请大家友好交流积极指正
单语言学习阶段
这个阶段是大部分程序员的入门阶段，在这个阶段，选好一门合适的起手语言是非常重要的。在学习过程中，我们需要更强力的学习反馈，即学习的成就感，这个反馈感是非常重要的。
在大多数的计算机专业的学生中，第一门语言基本就是C语言，但是我认为C语言的难度太大，对于新手来说学习成就感就差很多，因为面对相对复杂的问题的时候，其代码量的庞大加上其语言的设计初衷就偏向底层，学习难度对初学来说必然的很高的。
这里我推荐使用python作为第一语言的入门学习。这个语言的设计初衷就是易读、易用、兼顾优雅与实用，Python 的设计很大程度上参考了吉多(一个荷兰程序员)参与开发的 ABC 语言（一门面向教学的语言），这里就不过多赘述。接下来我会带着大家快速回顾或者入门python(不做细致讲解)，就算是没有编程基础的小白，学习python并不是一个很难的事情。
python在我看来，其逻辑表达和语法极其简洁，并且与自然语言非常相似，接下来我会快速回顾python的语法特性，并帮助初学者快速入门
变量的定义
在python中我们不需要像C/C++或者java那样明确定义一个变量的类型，也不需要像js那样定义这个变量的读写性。在python中，定义一个变量变得非常轻松和快捷
number = 1 # 定义一个数字
float_number = 1.1 # 定义一个小数，在编程中，叫浮点数
string = 'this is a string' # 定义一个字符串
对于编程小白来说，这里需要引入一些新的概念
- 浮点数：浮点数在python编程初期可以直接认为是小数，对于python，我尽可能少的解释类型
- 字符串：不属于数字的范畴，用引号包裹，在python中，单引号和双引号都可以用于包裹一个字符串
我们可以注意到，python中定义一个变量只需要直接赋值即可，我们不需要关注计算机系统内部如何分配内存的问题
输出与输入
这个部分是针对控制台的
这个也必然是快速入门编程不可缺少的一个部分。很多教程的第一门课就是教大家如何用编程语言输出hello world。在快速入门和回顾中，我放在第二个部分，因为我们同样可以输出变量
为什么要输出
这个问题用于解答新手的问题，我在初学阶段就有这个疑惑。
答案很明显，我们需要让计算机软件与人进行交互，即人机交互。交互过程中，软件是需要主动想用户发出一些通知的，这个就是输出，所以我们需要学输出。对应的，输入也是必要的。
输出
几乎所有语言的输出都是一样的，调用某个函数，然后传入一个变量或者一个常量，就可以输出了。在python中，这个函数是print
print(a) # 输出一个变量的值
print('123') # 输出一个字符串常量
print(1) # 输出一个数字
写了那么多的语言，我觉得print有一个必须掌握的特性，这个是其他语言的都没有的，f-string。在print中参杂变量和常量的时候是常见的场景，比如我们经常要输出xxx进行了yyy操作，这种情况我们可以
# 场景：输出“用户123进行了登录操作”，其中user_id=123，action="登录"
user_id = 123
action = "登录"
# 写法1：使用print不定参数（空格分隔，格式不可控）
print(user_id, '进行了', action, '操作')
# 输出：123 进行了 登录 操作（变量和常量之间会多一个空格）
# 写法2：旧式%格式化（语法繁琐，类型易出错）
print('%s进行了%s操作' % (user_id, action))
# 输出：123进行了登录操作（无空格，但需手动匹配%s/%d等类型符）
# 写法3：str.format()（语法冗余，变量多了易混乱）
print('{}进行了{}操作'.format(user_id, action))
# 输出：123进行了登录操作（需用{}占位，变量多时代码可读性下降）
而 Python 3.6 + 引入的 f-string（格式化字符串字面值），彻底解决了这个问题，也是你必须掌握的核心特性：我们只需要在字符串前面加个f，然后把变量写在大括号里即可
print(f'{user_id}进行了{action}操作')
python就是这么简单。
- 在C语言中，大部分的输出都是使用写法2
- 在C++和java中，大部分的输出都类似于写法1
输入
在python中，使用input函数就可以实现用户输入的功能，而且我们可以很轻松的将用户输入的数据赋值到变量中
user_input = input()
这里先一笔带过，input的用法还是很简单的，里面的参数就不再快速入门阐述
判断逻辑（条件分支）
编程中最核心的逻辑之一就是“根据不同条件执行不同操作”，这就是判断逻辑。生活中我们常说“如果下雨就带伞，否则就不带”，对应到Python里就是判断逻辑的直观体现。
Python的判断逻辑语法极其简洁，完全贴近自然语言，不需要像C/C++/Java那样写繁琐的大括号，仅用缩进就能区分代码块（这是Python的核心语法特色：缩进代表代码归属）。
基础if判断
# 场景：判断一个数字是否大于10
number = 15
# 基础语法：if 条件: 执行代码（注意条件后的冒号和代码缩进）
if number > 10:
print(f'{number}大于10') # 缩进4个空格（或1个Tab），代表属于if代码块
if-else（二选一）
# 场景：判断考试分数是否及格（60分及格）
score = 58
if score >= 60:
print(f'分数{score}，及格啦！')
else: # 否则（条件不满足时执行）
print(f'分数{score}，不及格，继续努力！')
if-elif-else（多选一）
当需要判断多个条件时，用elif（else if的简写），完全贴合“如果…如果…否则…”的自然语言逻辑：
# 场景：根据分数判断等级（90+优秀/80-89良好/60-79及格/＜60不及格）
score = 85
if score >= 90:
print(f'分数{score}，等级：优秀')
elif score >= 80: # 仅当上面的if不满足时，才会判断这个条件
print(f'分数{score}，等级：良好')
elif score >= 60:
print(f'分数{score}，等级：及格')
else: # 所有条件都不满足时执行
print(f'分数{score}，等级：不及格')
关键说明
- Python的判断条件支持常见的比较运算符：
>（大于）、<（小于）、>=（大于等于）、<=（小于等于）、==（等于，注意不是单个=，单个=是赋值）、!=（不等于）。 - 无需像C语言那样写
if (number > 10)（括号可选），Python直接写if number > 10即可，更简洁。 - 缩进是Python的语法规则（不是风格）：缩进不一致会直接报错，这是新手最容易踩的坑，但也让代码结构更清晰。
循环逻辑
循环的核心是“重复执行一段代码”，生活中“重复数10个数”“每天背10个单词”都是循环。Python提供两种核心循环：for循环（适合“已知循环次数”）和while循环（适合“未知循环次数，满足条件就循环”），语法同样简洁到贴近自然语言。
for循环（遍历/定次循环）
for循环是Python最常用的循环，尤其适合遍历列表、字符串等序列，或执行固定次数的循环（配合range()函数）。
1. 遍历序列（如列表、字符串）
# 场景1：遍历列表中的每个数字并输出
numbers = [1, 2, 3, 4, 5]
for num in numbers: # 依次取出numbers中的每个元素，赋值给num（in表示“在…中”）
print(f'当前数字：{num}')
# 场景2：遍历字符串中的每个字符
message = 'Python'
for char in message:
print(f'当前字符：{char}')
2. 固定次数循环（range()函数）
range(n)生成0到n-1的整数序列，range(a, b)生成a到b-1的序列，完美解决“执行N次”的需求：
# 场景1：输出1到10（range(1,11)表示1、2…10）
for i in range(1, 11):
print(i)
# 场景2：计算1到100的累加和
total = 0
for i in range(1, 101):
total += i # 等价于 total = total + i
print(f'1到100的和：{total}') # 输出：5050
while循环（条件循环）
while循环适合“不知道要循环多少次，只要条件满足就继续”的场景，比如“让用户输入数字，直到输入0为止”。
# 场景1：循环输出数字，直到数字大于5
count = 1
while count <= 5: # 条件满足时执行循环体
print(f'当前计数：{count}')
count += 1 # 必须修改条件变量，否则会无限循环！
# 场景2：用户输入数字，直到输入0退出
while True: # 无限循环（条件永远为真）
user_num = int(input('请输入一个数字（输入0退出）：')) # input默认返回字符串，转成整数
if user_num == 0:
print('输入了0，退出程序')
break # 终止循环
print(f'你输入的数字是：{user_num}')
循环中的关键控制
break：立即终止整个循环（如上例）。continue：跳过当前循环的剩余代码，直接进入下一次循环：# 场景：输出1到10，但跳过偶数 for i in range(1, 11): if i % 2 == 0: # 偶数（取模等于0） continue # 跳过本次循环，不执行下面的print print(i) # 仅输出奇数：1、3、5、7、9
对比其他语言
- C/C++/Java的for循环需要写
for (int i=0; i<10; i++)，语法繁琐；Python的for i in range(10)更直观。 - 其他语言用
break/continue的逻辑一致，但Python无需大括号，仅靠缩进就能清晰区分循环体，新手更容易理解。
函数
函数是编程中一个重要的概念，在所有编程语言里面都必然有这个东西
我们先回顾一下函数在数学中的表达
- 在初中阶段，函数是这样的：y=2x+1
- 在高中阶段，函数是这样的：f(x)=2x+1
其本质就是一个输出对应一个唯一的输出，我们可以将这个概念迁移到编程上
我们可以定义一个函数
def f(x):
return 2 * x + 1
# 我们可以这样用，这个时候，res就是5
res = f(2)
现在你基本掌握了函数定义和调用的方法，就是
def 函数名(参数):
return 返回值
# 调用的时候
函数名(参数)
我们将函数这个概念推广到计算机，我们是这样认为的：函数可以封装一段可重复执行的代码逻辑，输入参数，输出结果。当然，你也可以不输出结果，你可以直做逻辑；你也可以不输入参数，如果这个函数不需要传参的话。所有函数可以帮你避免重复写相同代码，让程序结构更清晰，也是模块化编程的基础
我举个例子，不同于上面示例
无返回值的函数
# 无参数、无返回值：仅执行打印逻辑
def say_hello():
print("你好！这是一个只做事不返回结果的函数")
# 调用后只会打印内容，不会有“返回值”
say_hello()
# 如果强行接收返回值，会得到Python的“空值”None
res = say_hello()
print(res) # 输出：None
多参数函数
数学里也有多变量函数（比如 f (x,y)=x+y），编程中同理
# 多参数函数：计算两个数的和
def add(x, y):
return x + y
# 调用时按顺序传参即可
res = add(3, 5)
print(res) # 输出：8
作用域
既然提到了函数，就不得不说作用域。
简单说就是函数内部的变量，外部是无法访问的，举个例子
def f(x):
result = 2 * x + 1
return result
# 直接访问函数内部的变量result（和返回值无关）
print(result) # 报错NameError: name 'result' is not defined
说了外部不能访问内部，那内部能不能访问外部呢
是可以的，但是情况比较特殊，举个例子
a = 1
def f():
print(a)
f()
这样写的话，会有输出结果吗？ 答案是：会的，输出1，因为函数内是可以访问外部的变量的。就是说，大的作用域（这个例子中是全局作用域）的变量在子作用域中是可读的
a = 1
def f():
a = 2
f()
print(a)
这个时候我们来猜一下会输出1还是2
答案是1，因为函数内赋值是作用域是函数内的，函数内的a=2没有传递到函数外的a。就是说，大的作用域（这个例子中是全局作用域）的变量在子作用域中是不可写的
但是如果你硬要写，怎么办呢？
可以用global关键字，将a标记为全局变量
a = 1
def f():
global a
a = 2
f()
print(a)
这时候输出的就是2了
类与面向对象
前面我们讲了变量、函数、作用域。这些已经足够你写出结构清晰的小程序。但当项目规模变大，函数会越来越多，变量会越来越杂，代码开始变得难以维护。这时就需要引入一个更高阶的抽象方式：面向对象编程（OOP）。
为什么需要类？
先从一个现实问题出发。
假设你要表示一个“用户”，这个用户有：
- 用户ID
- 用户名
- 密码
- 登录行为
用之前的知识你可能会这样写：
user_id = 1
username = "admin"
password = "123456"
def login(user_id):
print(f'用户{user_id}登录成功')
问题在哪里？
- 数据和行为是分离的
- 如果有多个用户，你要写很多变量
- 数据之间没有组织结构
这在工程实践中是不可接受的。
于是，我们引入“类”。
什么是类？
如果用一句话概括：
类是对一类事物的抽象描述。
在编程中：
- 类 = 模板
- 对象 = 根据模板创建的具体实例
类定义结构，对象是具体的数据实体。
类的基本语法
Python中定义类非常简单：
class User:
pass
这只是一个空类。真正有意义的类，需要包含“属性”和“方法”。
对象（实例）的创建
我们定义一个完整一点的类：
class User:
def __init__(self, user_id, username):
self.user_id = user_id
self.username = username
def login(self):
print(f'用户{self.user_id}登录成功')
现在解释几个关键点：
__init__ 是什么？
- 这是构造函数
- 在创建对象时自动执行
- 用于初始化对象的属性
self 是什么？
这是初学者最困惑的地方。
简单理解：
self 代表“当前这个对象本身”。
当你创建对象时：
u1 = User(1, "admin")
此时：
- self 就是 u1
- user_id = 1
- username = "admin"
对象的使用
u1 = User(1, "admin")
u1.login()
输出：
用户1登录成功
现在你会发现一个核心优势：
数据 + 行为 被封装在了一起。
类的本质：封装
面向对象第一个核心思想是：
封装（Encapsulation）
即：
将数据和操作数据的行为放在一起。
对比函数式写法：
def login(user):
print(f'用户{user["id"]}登录成功')
面向对象写法：
user.login()
后者更符合人类思维方式。
多个对象
类真正的价值在于可以创建多个对象：
u1 = User(1, "admin")
u2 = User(2, "guest")
u1.login()
u2.login()
每个对象都有独立的数据。
这在工程开发中极其重要，例如：
- Web系统中的用户对象
- 订单对象
- 设备对象
- 消息对象
属性的访问与修改
print(u1.username) # 访问属性
u1.username = "root" # 修改属性
print(u1.username)
对象内部数据可以通过 对象.属性 访问。
类变量 vs 实例变量
再进阶一点。
class User:
count = 0 # 类变量
def __init__(self, name):
self.name = name
User.count += 1
类变量属于“类本身”，所有对象共享。
u1 = User("a")
u2 = User("b")
print(User.count) # 2
self.name是实例变量count是类变量
这个区别在后端开发中非常重要。
面向对象三大特性
虽然在Python中不会强制强调，但理论上有三大核心特性：
封装
刚才讲过。
继承
允许一个类继承另一个类。
class Admin(User):
def delete_user(self):
print("删除用户")
Admin继承User的所有属性和方法。
admin = Admin(1, "root")
admin.login()
admin.delete_user()
多态
同样的方法，不同对象表现不同。
class Dog:
def speak(self):
print("汪汪")
class Cat:
def speak(self):
print("喵喵")
def make_sound(animal):
animal.speak()
只要对象有 speak() 方法，就可以调用。
Python是动态类型语言，这种多态实现非常自然。
工程视角理解类
作为工程实践者，你需要这样理解类：
- 类 = 数据结构 + 业务逻辑
- 类 = 模块的最小抽象单元
- 类 = 领域建模的核心工具
在Web后端中：
- 一个数据库表 → 一个实体类
- 一个请求体 → 一个DTO类
- 一个业务模块 → 一个Service类
当你真正开始写大型系统时，你会发现：
项目本质上就是一堆类之间的协作。
什么时候不该用类？
不是所有场景都需要面向对象。
- 小脚本
- 一次性工具
- 简单数据处理
函数式写法更直接。
真正的工程能力，不是“到处写类”，而是知道什么时候抽象。
讲到这里，你基本就学完了python的核心语法，之后的文章将进一步帮助大家深入理解这门语言，将其前后语法点结合起来总体看这门语言，然后更进一步分享我在多语言全栈学习中的一些经验
