全栈开发：从单语言到多语言的高效学习路径——(1) 单语言的快速入门

作为一名大三在读的学生，自学计算机软件，参加了一些机器人竞赛，也自己做过一些比较复杂的项目，从机器视觉到web开发，不说精通，但是也可以落地到工程实践中。

在大学的3年时间中学习的技术栈比较广，语言比较丰富，也具备了自己的一套多语言学习路线，希望可以帮助大家。本系列文章中在更细致的讲解中可能存在偏差，请大家友好交流积极指正

单语言学习阶段

这个阶段是大部分程序员的入门阶段，在这个阶段，选好一门合适的起手语言是非常重要的。在学习过程中，我们需要更强力的学习反馈，即学习的成就感，这个反馈感是非常重要的。

在大多数的计算机专业的学生中，第一门语言基本就是C语言，但是我认为C语言的难度太大，对于新手来说学习成就感就差很多，因为面对相对复杂的问题的时候，其代码量的庞大加上其语言的设计初衷就偏向底层，学习难度对初学来说必然的很高的。

这里我推荐使用python作为第一语言 的入门学习。这个语言的设计初衷就是易读、易用、兼顾优雅与实用，Python 的设计很大程度上参考了吉多(一个荷兰程序员)参与开发的 ABC 语言（一门面向教学的语言），这里就不过多赘述。接下来我会带着大家快速回顾或者入门python(不做细致讲解)，就算是没有编程基础的小白，学习python并不是一个很难的事情。

python在我看来，其逻辑表达和语法极其简洁，并且与自然语言非常相似，接下来我会快速回顾python的语法特性，并帮助初学者快速入门

变量的定义

在python中我们不需要像C/C++或者java那样明确定义一个变量的类型，也不需要像js那样定义这个变量的读写性。在python中，定义一个变量变得非常轻松和快捷

python 复制代码

number = 1  # 定义一个数字
float_number = 1.1 # 定义一个小数，在编程中，叫浮点数
string = 'this is a string'  # 定义一个字符串

对于编程小白来说，这里需要引入一些新的概念

浮点数：浮点数在python编程初期可以直接认为是小数，对于python，我尽可能少的解释类型
字符串：不属于数字的范畴，用引号包裹，在python中，单引号和双引号都可以用于包裹一个字符串

我们可以注意到，python中定义一个变量只需要直接赋值即可，我们不需要关注计算机系统内部如何分配内存的问题

输出与输入

这个部分是针对控制台的

这个也必然是快速入门编程不可缺少的一个部分。很多教程的第一门课就是教大家如何用编程语言输出hello world。在快速入门和回顾中，我放在第二个部分，因为我们同样可以输出变量

为什么要输出

这个问题用于解答新手的问题，我在初学阶段就有这个疑惑。

答案很明显，我们需要让计算机软件与人进行交互，即人机交互。交互过程中，软件是需要主动想用户发出一些通知的，这个就是输出，所以我们需要学输出。对应的，输入也是必要的。

输出

几乎所有语言的输出都是一样的，调用某个函数，然后传入一个变量或者一个常量，就可以输出了。在python中，这个函数是print

python 复制代码

print(a)  # 输出一个变量的值
print('123')  # 输出一个字符串常量
print(1)  # 输出一个数字

写了那么多的语言，我觉得print有一个必须掌握的特性，这个是其他语言的都没有的，f-string。在print中参杂变量和常量的时候是常见的场景，比如我们经常要输出xxx进行了yyy操作，这种情况我们可以

python 复制代码

# 场景：输出"用户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，然后把变量写在大括号里即可

python 复制代码

print(f'{user_id}进行了{action}操作')

python就是这么简单。

在C语言中，大部分的输出都是使用写法2
在C++和java中，大部分的输出都类似于写法1

输入

在python中，使用input函数就可以实现用户输入的功能，而且我们可以很轻松的将用户输入的数据赋值到变量中

python 复制代码

user_input = input()

这里先一笔带过，input的用法还是很简单的，里面的参数就不再快速入门阐述

判断逻辑（条件分支）

编程中最核心的逻辑之一就是"根据不同条件执行不同操作"，这就是判断逻辑。生活中我们常说"如果下雨就带伞，否则就不带"，对应到Python里就是判断逻辑的直观体现。

Python的判断逻辑语法极其简洁，完全贴近自然语言，不需要像C/C++/Java那样写繁琐的大括号，仅用缩进就能区分代码块（这是Python的核心语法特色：缩进代表代码归属）。

基础if判断

python 复制代码

# 场景：判断一个数字是否大于10
number = 15

# 基础语法：if 条件: 执行代码（注意条件后的冒号和代码缩进）
if number > 10:
    print(f'{number}大于10')  # 缩进4个空格（或1个Tab），代表属于if代码块

if-else（二选一）

python 复制代码

# 场景：判断考试分数是否及格（60分及格）
score = 58

if score >= 60:
    print(f'分数{score}，及格啦！')
else:  # 否则（条件不满足时执行）
    print(f'分数{score}，不及格，继续努力！')

if-elif-else（多选一）

当需要判断多个条件时，用elif（else if的简写），完全贴合"如果...如果...否则..."的自然语言逻辑：

python 复制代码

# 场景：根据分数判断等级（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. 遍历序列（如列表、字符串）

python 复制代码

# 场景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次"的需求：

python 复制代码

# 场景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为止"。

python 复制代码

# 场景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：跳过当前循环的剩余代码，直接进入下一次循环：

python 复制代码

# 场景：输出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

其本质就是一个输出对应一个唯一的输出，我们可以将这个概念迁移到编程上

我们可以定义一个函数

python 复制代码

def f(x):
    return 2 * x + 1
    
# 我们可以这样用，这个时候，res就是5
res = f(2)

现在你基本掌握了函数定义和调用的方法，就是

python 复制代码

def 函数名(参数):
    return 返回值
    
# 调用的时候
函数名(参数)

我们将函数这个概念推广到计算机，我们是这样认为的：函数可以封装一段可重复执行的代码逻辑 ，输入参数，输出结果。当然，你也可以不输出结果，你可以直做逻辑；你也可以不输入参数，如果这个函数不需要传参的话。所有函数可以帮你避免重复写相同代码，让程序结构更清晰，也是模块化编程的基础

我举个例子，不同于上面示例

无返回值的函数

python 复制代码

# 无参数、无返回值：仅执行打印逻辑
def say_hello():
    print("你好！这是一个只做事不返回结果的函数")

# 调用后只会打印内容，不会有"返回值"
say_hello()
# 如果强行接收返回值，会得到Python的"空值"None
res = say_hello()
print(res)  # 输出：None

多参数函数

数学里也有多变量函数（比如 f (x,y)=x+y），编程中同理

python 复制代码

# 多参数函数：计算两个数的和
def add(x, y):
    return x + y

# 调用时按顺序传参即可
res = add(3, 5)
print(res)  # 输出：8

作用域

既然提到了函数，就不得不说作用域。

简单说就是函数内部的变量，外部是无法访问的，举个例子

python 复制代码

def f(x):
    result = 2 * x + 1
    return result

# 直接访问函数内部的变量result（和返回值无关）
print(result)  # 报错NameError: name 'result' is not defined

说了外部不能访问内部，那内部能不能访问外部呢

是可以的，但是情况比较特殊，举个例子

python 复制代码

a = 1
def f():
    print(a)

f()

这样写的话，会有输出结果吗？答案是：会的，输出1，因为函数内是可以访问外部的变量的。就是说，大的作用域（这个例子中是全局作用域）的变量在子作用域中是可读的

python 复制代码

a = 1

def f():
    a = 2

f()
print(a)

这个时候我们来猜一下会输出1还是2

答案是1，因为函数内赋值是作用域是函数内的，函数内的a=2没有传递到函数外的a。就是说，大的作用域（这个例子中是全局作用域）的变量在子作用域中是不可写的

但是如果你硬要写，怎么办呢？

可以用global关键字，将a标记为全局变量

python 复制代码

a = 1

def f():
    global a
    a = 2

f()
print(a)

这时候输出的就是2了

类与面向对象

前面我们讲了变量、函数、作用域。这些已经足够你写出结构清晰的小程序。但当项目规模变大，函数会越来越多，变量会越来越杂，代码开始变得难以维护。这时就需要引入一个更高阶的抽象方式：面向对象编程（OOP）。

为什么需要类？

先从一个现实问题出发。

假设你要表示一个"用户"，这个用户有：

用户ID
用户名
密码
登录行为

用之前的知识你可能会这样写：

python 复制代码

user_id = 1
username = "admin"
password = "123456"

def login(user_id):
    print(f'用户{user_id}登录成功')

问题在哪里？

数据和行为是分离的
如果有多个用户，你要写很多变量
数据之间没有组织结构

这在工程实践中是不可接受的。

于是，我们引入"类"。

什么是类？

如果用一句话概括：

类是对一类事物的抽象描述。

在编程中：

类 = 模板
对象 = 根据模板创建的具体实例

类定义结构，对象是具体的数据实体。

类的基本语法

Python中定义类非常简单：

python 复制代码

class User:
    pass

这只是一个空类。真正有意义的类，需要包含"属性"和"方法"。

对象（实例）的创建

我们定义一个完整一点的类：

python 复制代码

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 代表"当前这个对象本身"。

当你创建对象时：

python 复制代码

u1 = User(1, "admin")

此时：

self 就是 u1
user_id = 1
username = "admin"

对象的使用

python 复制代码

u1 = User(1, "admin")
u1.login()

输出：

复制代码

用户1登录成功

现在你会发现一个核心优势：

数据 + 行为被封装在了一起。

类的本质：封装

面向对象第一个核心思想是：

封装（Encapsulation）

即：

将数据和操作数据的行为放在一起。

对比函数式写法：

python 复制代码

def login(user):
    print(f'用户{user["id"]}登录成功')

面向对象写法：

python 复制代码

user.login()

后者更符合人类思维方式。

多个对象

类真正的价值在于可以创建多个对象：

python 复制代码

u1 = User(1, "admin")
u2 = User(2, "guest")

u1.login()
u2.login()

每个对象都有独立的数据。

这在工程开发中极其重要，例如：

Web系统中的用户对象
订单对象
设备对象
消息对象

属性的访问与修改

python 复制代码

print(u1.username)  # 访问属性

u1.username = "root"  # 修改属性
print(u1.username)

对象内部数据可以通过 对象.属性 访问。

类变量 vs 实例变量

再进阶一点。

python 复制代码

class User:
    count = 0  # 类变量
    
    def __init__(self, name):
        self.name = name
        User.count += 1

类变量属于"类本身"，所有对象共享。

python 复制代码

u1 = User("a")
u2 = User("b")

print(User.count)  # 2

self.name 是实例变量
count 是类变量

这个区别在后端开发中非常重要。

面向对象三大特性

虽然在Python中不会强制强调，但理论上有三大核心特性：

封装

刚才讲过。

继承

允许一个类继承另一个类。

python 复制代码

class Admin(User):
    def delete_user(self):
        print("删除用户")

Admin继承User的所有属性和方法。

python 复制代码

admin = Admin(1, "root")
admin.login()
admin.delete_user()

多态

同样的方法，不同对象表现不同。

python 复制代码

class Dog:
    def speak(self):
        print("汪汪")

class Cat:
    def speak(self):
        print("喵喵")

python 复制代码

def make_sound(animal):
    animal.speak()

只要对象有 speak() 方法，就可以调用。

Python是动态类型语言，这种多态实现非常自然。

工程视角理解类

作为工程实践者，你需要这样理解类：

类 = 数据结构 + 业务逻辑
类 = 模块的最小抽象单元
类 = 领域建模的核心工具

在Web后端中：

一个数据库表 → 一个实体类
一个请求体 → 一个DTO类
一个业务模块 → 一个Service类

当你真正开始写大型系统时，你会发现：

项目本质上就是一堆类之间的协作。

什么时候不该用类？

不是所有场景都需要面向对象。

小脚本
一次性工具
简单数据处理

函数式写法更直接。

真正的工程能力，不是"到处写类"，而是知道什么时候抽象。

讲到这里，你基本就学完了python的核心语法，之后的文章将进一步帮助大家深入理解这门语言，将其前后语法点结合起来总体看这门语言，然后更进一步分享我在多语言全栈学习中的一些经验

全栈开发：从单语言到多语言的高效学习路径——(1) 单语言的快速入门

单语言学习阶段

变量的定义

输出与输入

为什么要输出

输出

输入

判断逻辑（条件分支）

基础if判断

if-else（二选一）

if-elif-else（多选一）

关键说明

循环逻辑

for循环（遍历/定次循环）

1. 遍历序列（如列表、字符串）

2. 固定次数循环（range()函数）

while循环（条件循环）

循环中的关键控制

对比其他语言

函数

无返回值的函数

多参数函数

作用域

类与面向对象

为什么需要类？

什么是类？

类的基本语法

对象（实例）的创建

__init__ 是什么？

self 是什么？

对象的使用

类的本质：封装

封装（Encapsulation）

多个对象

属性的访问与修改

类变量 vs 实例变量

面向对象三大特性

封装

继承

多态

工程视角理解类

什么时候不该用类？

`init` 是什么？

`self` 是什么？