从 0 到 1 学 Python:10 天啃透基础语
- 2026-09-08 12:15:02
我整理了这份 10 天 Python 基础通关攻略！每天啃透 1 个核心模块，全是实打实的干货，看完就能上手敲代码，纯零基础也能跟，学完直接能写简单小程序～
第 1 天 吃透变量
变量的核心
概念变量就是程序里用来存储信息的容器，一个赋值语句由三部分组成：变量名+等号（赋值符号）+存储的信息
例：n = 100n 是变量名，100 是变量存储的内容
注释的使用
用#加文字表示注释，是程序里的说明性文字，不参与程序运行，方便自己和别人看懂代码。
变量的命名规则（5 个核心要求）
只能由字母、数字、下划线 (_) 组成，比如n2_是合法变量名
数字不能开头，比如2n不合法，n2合法
严格区分大小写，比如n和N是两个不同的变量
变量名中不能有空格，比如n m不是一个合法变量名
不能用 Python 的保留字做变量名，比如if、while、for等都不行
💡 小建议：变量名尽量起得有意义，方便后续阅读和修改代码，比如g_iCountStars（g 代表全局变量，i 代表整型变量，CountStars 表示数星星，一眼就能看懂用途）
常见的 3 种变量类型
n = 100整型变量：由正整数、负整数和0组成s = '100'字符串型变量：用单引号或双引号包裹的数据f = 100.0 # 浮点型变量：带小数的数字
变量的基本使用
Python 的变量很灵活，直接重新赋值就能改变变量类型，整型 / 浮点型变量可以直接做数学计算
例：
n = '100'初始是字符串变量n = 10重新赋值，变量类型变成整型n = n + 1 # 整型变量做加法计算，结果为11
第 2 天 输入输出 + 字符串操作
输出：print () 函数的使用
print()可以输出括号里的任意信息，默认输出后自动换行，还能自定义输出格式，直接看例子：
print(123)直接输出数字，结果：123print('你好', end='')end=''表示不换行，结尾加，结果：你好print('早安', '中国') # 多内容用逗号分隔，输出自动空格，结果：早安 中国s = '测试'; print(s) # 分号隔开，实现一行写多条语句，结果：测试
字符串的两个实用操作
字符串拼接：多个字符串用+连接，按先后顺序组合
例：print('中国' + '广州')结果：中国广州print('广州' + '中国')结果：广州中国
字符串乘法：字符串和数字用*相乘，得到多个重复的字符串，满足交换律print('开心' * 10)结果：输出 10 个开心print(10 * '开心')结果：和上面一样，输出 10 个开心
强制类型转换（解决字符串和数字拼接问题）
字符串和数字不能直接用+拼接，需要用强制类型转换临时改变变量类型，注意：临时转换不会改变原变量的类型，只有重新赋值才会改变。
核心转换方法：
str(x)：把 x 转为字符串类型
int(x)：把 x 转为整型（x 必须是数字格式的字符串 / 数字）
float(x)：把 x 转为浮点型
例：
a = 1001b = '个愿望'print(str(a) + b)把整型a转为字符串，才能拼接，结果：1001个愿望
如果想永久改变变量类型，直接重新赋值即可：a = str(a)
第 3 天 全掌握运算符
布尔类型：只有真和假两种值
布尔类型是专门用来表示 “真” 和 “假” 的变量类型，只有True（真）和False（假）两个值，注意首字母必须大写
例：
a = True定义布尔类型变量
比较运算符：比大小，结果是布尔值
用来判断两个值的大小 / 相等关系，运算结果一定是True或False，常用的有 6 个：>、<、>=、<=、==、!=
例：
a = 10; b = 5a > ba大于b，结果：Truea < ba小于b，结果：Falsea >= b # a大于或等于b，结果：Truea <= b # a小于或等于b，结果：Falsea == b # a等于b，结果：False（注意是两个等号，一个等号是赋值）a != b # a不等于b，结果：True
逻辑运算符：多条件判断，结果是布尔值
用来把多个比较条件组合起来判断，运算结果也是True或False，常用的有3 个：and、or、not，优先级：not > and > or
a and b：并且，a 和 b 都为真，结果才是真，有一个假就是假
a or b：或者，a 和 b 有一个为真，结果就是真，都假才是假
not c：取反，c 为真则结果为假，c 为假则结果为真例：
a = 10; b = 5; c = Truea >= b or a != b andnot c按优先级计算，结果：True
算术运算符：做数学计算
常用的有 7 个，直接看例子，易懂好记：
print(2 + 3)加法，结果：5print(2 - 3)减法，结果：-1print(2 * 3) # 乘法，结果：6print(2 / 2) # 除法，结果一定是浮点型，这里：1.0print(5 % 3) # 取余（求除法的余数），结果：2print(2 ** 3) # 乘方（3个2相乘），结果：8print(3// 2) # 整除（只取除法的整数部分），结果：1
复合赋值符号：简化计算赋值
把 “运算 + 赋值” 合在一起，写起来更简洁，核心有 7 个：+=、-=、*=、/=、%=、**=、//=
例：a = 5; a += 2等价于 a = a + 2，结果 a=7
其他符号用法一致：a -= 2 → a = a - 2，a *= 2 → a = a * 2
第 4 天 分支 + 循环基础
if 语句：分支（选择）结构，按条件执行代码
根据不同的条件，执行不同的代码块，一组if…elif…else语句的规则：
只有1 个 if开头，判断第一个条件
中间可以有0 个或多个 elif，判断后续条件
最后可以有0 个或 1 个 else，表示剩下的所有情况
从上到下判断，只要有一个条件为 True，执行完对应的代码块就会退出整个 if 语句
💡 关键：条件后面要加冒号，满足条件的代码块必须缩进（1 个 Tab 键或 4 个空格）例：根据成绩输出评价
s = int(input('输入数学成绩:'))输入的字符串转为整型if s < 70 :分数小于70 print('加油，少年！') # 缩进的代码属于该条件elif 70 <= s < 90 : # 分数70到89之间 print('还有进步空间！')elif 90 <= s <= 99 : # 分数90到99之间 print('学霸同学！')else : # 其他情况（分数≥100） print('超级学霸！！！')
while 语句：循环结构，重复执行代码
只要while后面的条件为True，就会一直重复执行缩进的代码块；条件为False，循环就结束。
💡 注意：一定要在循环内设置 “让条件变 False” 的语句，避免无限循环（死循环）
例：计算 1+2+…+1000 的累加和
a = 1; s = 0a初始为1（起始数），s初始为0（存储累加和）while a <= 1000 :条件：a小于等于1000时，继续循环 s += a # 把当前a的值累加到s中，等价于s = s + a a += 1 # a自增1，让a慢慢变大，最终会超过1000，结束循环print(s) # 循环结束后执行（和while对齐，不缩进），输出累加和
第 5 天 循环进阶
break：强制跳出循环
如果while的条件一直是True（死循环），可以用break语句直接结束距离最近的一层循环，立刻退出，不再执行循环内后续的代码。
例：累加，直到和超过 1000 就停止
a = 0初始值为0while a < 100:条件：a小于100时循环 a += 1 # a自增1 if a % 7 != 0: # 判断：如果a不是7的倍数（取余结果不为0） continue # 跳过本次循环的后续代码，直接判断下一次条件 print(a) # 只有a是7的倍数时，才会执行输出print('循环结束')
多重循环：循环嵌套，解决复杂问题
在一个循环内，再写另一个循环，就是多重循环（常用的是双层循环），外层循环执行一次，内层循环会完整执行一遍。
例：打印经典的九九乘法表
i = 1i表示行数，从1开始while i <= 9:外层循环：控制行数，一共9行 j = 1 # j表示列数，每一行都从1开始 while j <= 9and j <= i: # 内层循环：控制列数，列数不超过行数 print(i, '', j, '=', ij, end=' ') # 按格式输出，结尾加3个空格 j += 1 # 列数自增1 print() # 内层循环结束后，输出空行，实现换行 i += 1 # 行数自增1
第 6 天 列表 + for-in 循环
列表：存储多个数据的有序集合
可以把大量相同性质的数据放在一起，组成一个新的变量，里面的每个数据叫做元素，元素按顺序排列，用下标表示位置（下标从 0 开始）。
示例：多个成绩组成一个列表，下标0是100，下标1是99，以此类推num = [100, 99, 96, 92, 87, 56, 96, 78, 55]示例：多个家庭成员组成一个列表，下标0是爸爸，下标1是妈妈family = ['爸爸', '妈妈', '姐姐', '我']
💡 小知识点：空列表：t = []，里面没有元素，长度为 0列表可以存储不同类型的元素（比如t = ['数学', 100]），但不推荐，不方便管理
列表的常用操作（增删改查）
用一个例子讲透所有核心操作，直接上手敲代码就能懂：
planet = ['水星', '金星', '地球']创建列表print(planet[2])查：通过下标访问元素，下标2是地球，结果：地球planet[2] = '美丽的地球' # 改：通过下标修改元素值print(len(planet)) # 查：len(列表)获取列表长度，结果：3planet.append('火星') # 增：append(元素)，在列表末尾添加元素planet.insert(3, '月球') # 增：insert(下标, 元素)，在下标3的位置插入月球a = planet.pop() # 删：pop()，移除最后一个元素，把移除的元素赋值给aa = planet.pop(2) # 删：pop(下标)，移除下标2的元素，赋值给aplanet.remove('金星') # 删：remove(元素)，删除从下标0开始的第一个指定元素print(planet) # 查：输出整个列表，最终结果：['水星', '月球']
for-in 循环：遍历的 “懒人神器”，比 while 更简洁
专门用来遍历（依次访问）列表、数字序列等，写法简单，不用手动控制自增，比 while 循环更适合做遍历操作。
用法 1：遍历列表，依次访问每个元素
fruits = ['apple', 'banana', 'orange']for a in fruits:依次把fruits里的元素赋值给a print(a)依次输出每个元素，结果：apple → banana → orange
用法 2：遍历数字序列，结合 range () 函数
range(a, b)表示生成从a 到 b-1的数字序列，不包含 b
for i in range(1, 100):遍历1到99的所有数字 print(i)依次输出1、2、3…99
第 7 天 方法的定义与调用
方法的核心概念
把一段有独立功能的代码封装起来，给它起一个名字，后续需要用这个功能时，直接调用名字就行，不用重复写代码，这就是方法，核心作用：封装、复用、简化代码。
方法的三种定义格式
格式 1：无参数、无返回值的方法
定义后直接调用，执行封装的代码即可
def getRet():def+方法名+()+冒号，定义方法 a = 10方法内的代码，实现具体功能 b = 3 print(a % b) # 输出10取余3的结果getRet() # 调用方法，直接写方法名+()，结果：1
格式 2：带参数的方法
如果需要把方法外的数据传到方法内使用，就在()里定义参数，调用时按次序传入数据（实参）
def getRet(a, b):定义2个参数a和b，接收外部传入的值 print(a % b)用参数做计算，输出结果getRet(10, 3) # 调用方法，按次序传入10和3，结果：1
格式 3：带返回值的方法
如果需要把方法内的计算结果传到方法外，用return语句返回结果，调用方法时可以接收这个结果，也可以直接输出
def getRet(a, b):定义2个参数 return a % breturn返回计算结果，方法执行到return就结束print(getRet(10, 3)) # 调用方法，输出返回值，结果：1
方法的编写规范
方法的命名规则和变量完全一样（字母 / 数字 / 下划线、数字不开头等）
方法内部可以调用其他方法，但不能定义新的方法
方法名推荐用驼峰式，比如getname改成getName，更清晰
方法名建议用动词 + 名词，一眼看懂功能，比如getName（获取名字）、getAdd（获取累加和）
方法实操示例：封装累加功能
def printAnswer(n):封装输出功能的方法，参数n是要输出的结果 print('计算结果是：' + str(n))def getAdd(a, b):封装累加功能的方法，参数a是起始数，b是结束数 s = 0 # s存储累加和 for i in range(a, b+1): # 遍历a到b的所有数字（b+1才会包含b） s += i # 累加 printAnswer(s) # 调用输出方法，打印结果getAdd(1, 100) # 调用累加方法，计算1到100的和，结果：计算结果是：5050
第 8 天 类与对象
类的核心概念
类是一种抽象的高级数据类型，用来定义一类事物的属性（特征，比如名字、颜色、大小）和行为（方法，比如做什么动作），比如 “球类” 可以定义属性：名字、大小、颜色；行为：打、拍。💡 规范：类名习惯首字母大写，比如Ball、Fruits类的基本定义格式
以定义 “球类” 为例，包含实例化方法__init__ 和普通类方法：
__init__：是 Python 的固定方法名（左右各两个下划线），叫实例化方法，创建对象时会自动调用，用来定义类的属性
self：是类方法的第一个参数，必须写，代表 “类的实例（对象）本身”，用来给属性赋值
普通类方法：定义类的行为，和普通方法的定义类似，第一个参数也是self
class Ball():定义类，类名Ball def init(self):实例化方法，定义属性 self.name = '篮球' # 定义属性：名字，self.属性名 = 属性值 self.size = '大' # 定义属性：大小 self.color = '棕色' # 定义属性：颜色 def play(self): # 普通类方法，定义行为（打） print('打' + self.name)# 用self.属性名访问类的属性
对象：类的具体实例
类是抽象的，比如 “球类”，而对象是类的具体存在，比如 “篮球”、“排球”，利用类名 ()可以创建对象，创建后就能通过对象访问属性、调用方法。
用法：对象名.属性名（访问属性）、对象名.方法名()（调用方法）
b1 = Ball()创建对象b1，自动调用__init__方法b2 = Ball()创建对象b2print(b1.color + b1.size + b1.name) # 访问b1的属性，结果：棕色大篮球b2.play() # 调用b2的方法，结果：打篮球
带参数的类：动态定义属性
如果想在创建对象时，才确定属性的值（比如创建篮球、排球时，名字 / 大小 / 颜色不同），可以给__init__方法加参数，创建对象时传入具体值即可。
python
class Ball():定义类 def init(self, n, s, c):给实例化方法加3个参数（self必须第一个） self.name = n # 把参数n赋值给属性name self.size = s # 参数s赋值给属性size self.color = c # 参数c赋值给属性color def play(self): # 普通类方法 print('打' + self.name)# 创建不同对象，传入不同参数，动态定义属性b1 = Ball('篮球', '大', '棕色') # 创建篮球对象b2 = Ball('排球', '小', '白色') # 创建排球对象print(b1.color + b1.size + b1.name) # 结果：棕色大篮球b2.play() # 结果：打排球
第 9 天 类与列表结合
编程中，经常需要创建多个同类型的对象（比如多个水果对象、多个学生对象），这时把对象存入列表，就能用列表的操作批量管理、遍历对象，非常方便。
步骤 1：先定义一个类
以 “水果类” 为例，定义属性（名字）和行为（购买）：
class Fruits():定义水果类 def init(self, name):实例化方法，1个参数（水果名） self.name = name # 定义属性：名字 def buy(self): # 普通类方法，定义行为：购买 print('买' + self.name)
步骤 2：把对象添加到列表（三种方法，任选其一）
方法 1：先创建对象，再初始化列表
apple = Fruits('苹果')创建苹果对象grape = Fruits('葡萄')创建葡萄对象banana = Fruits('香蕉') # 创建香蕉对象fts = [apple, grape, banana] # 把对象加入列表
方法 2：先创空列表，用 append () 添加对象
apple = Fruits('苹果')grape = Fruits('葡萄')banana = Fruits('香蕉')fts = []创建空列表fts.append(apple)末尾添加苹果对象fts.append(grape) # 末尾添加葡萄对象fts.append(banana) # 末尾添加香蕉对象
方法 3：直接在列表中创建对象（最简洁）
fts = [Fruits('苹果'), Fruits('葡萄'), Fruits('香蕉')]💡 小知识点：列表的所有操作（pop、remove、insert 等），对存储对象的列表都适用，放心使用！
步骤 3：遍历列表中的对象
和遍历普通列表完全一样，遍历出的每个元素都是类的对象，可以正常访问属性、调用方法。
例：先批量添加 7 个西瓜对象，再遍历所有水果对象，输出名字
批量添加7个西瓜对象到列表for i in range(1, 8):循环7次（1到7） fts.append(Fruits('西瓜')) # 每次添加一个西瓜对象# 遍历列表中的所有水果对象for f in fts: # 依次把列表中的对象赋值给f print(f.name, end=' ') # 访问对象的name属性，输出名字，结尾加空格
运行结果：苹果 葡萄 香蕉 西瓜 西瓜 西瓜 西瓜 西瓜 西瓜 西瓜
第 10 天 常用工具库
Python 内置了很多工具库（模块），每个库都有专门的功能，使用前只需用import库名导入，就能直接使用库中的方法，入门阶段先掌握最常用的time和random库，轻松实现时间控制、随机数生成。
time 库：处理和时间相关的操作
导入：import time
用法 1：获取当前时间
time.time()：获取时间戳（一个浮点数，代表当前时间距离 1970 年 1 月 1 日 00:00:00 的秒数）
time.strftime(格式, time.localtime())：获取指定格式的本地时间，格式符注意大小写（% Y = 年，% m = 月，% d = 日，% H = 时，% M = 分，% S = 秒）
import time导入time库now = time.time()获取时间戳print('当前时间戳:', now) # 输出时间戳，例：1661502447.2778742# 输出指定格式的时间print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))# 运行结果，例：2025-12-2413:27:27
用法 2：控制程序的时间间隔
time.sleep(秒数)：让程序休眠指定的秒数，期间程序处于 “假死” 状态
循环检测时间差：避免程序假死，更灵活地控制时间
import time导入time库用法1：休眠5秒print('开始', time.time())time.sleep(5) # 程序暂停5秒钟print('结束', time.time())# 用法2：循环检测时间差，控制5秒内的循环start = time.time() # 记录开始时间s = 0 # 统计循环次数while time.time()-start <=5: # 当前时间 - 开始时间 ≤5秒，继续循环 s += 1 # 循环次数+1print('5秒内循环次数:', s) # 输出循环次数，例：19365260（次数仅供参考）
random 库：生成随机数（最常用）
导入：import random
核心用法：生成指定范围的随机整数
random.randint(a, b)：生成闭区间 [a, b]之间的随机整数，包含 a 和 b，要求 a ≤ b
import random导入random库n = random.randint(-10, 20)生成-10到20之间的随机整数（包含-10和20）print(n) # 输出随机数，每次运行结果不同
通关结语
恭喜你！到这里，Python 的基础语法就全部学完了！从变量、运算符到循环、类，再到常用工具库。
学编程，多看代码 + 多敲代码 + 多练项目，基础打牢后，后续学习爬虫、数据分析、自动化办公等内容都会事半功倍！
正想学习 Python 的同学，我也准备了零基础学习资料包，包含课件笔记、PDF 电子书、经典小项目源码、问题解答等，全部免费领取，帮你少走弯路，快速上手
