1. 变量与常量：数据的 “代号”

核心重点

1：变量就是‘代号’，用于和数据之间建立绑定关系，通过变量可以使用数据
2：把右侧的值赋予左侧的变量为 赋值操作
3：命名规则：
    3.1 不可以使用关键字作为变量名使用（ 如if or）
    3.2 不可以使用内置函数名作为变量来使用
    3.3 变量名严格区分大小写 name 和 Name 是两个完全不同的值
    3.4 变量名不能以数字开头 不能包含空格
    3.5 变量名要语义化（如age而非a）；

4.常量 是在程序中一旦被赋值了，就不希望修改的量（仅规范，仍可修改)

5.注释 在代码执行过程中，不起任何作用
    1.提高代码的可读性 2.屏蔽暂时不需要的代码

规则 / 概念	详细说明	反例（错误用法）
变量本质	数据的 “绑定代号”，通过=将右侧值赋予左侧变量（赋值操作）	18 = age（左侧不能是数值）
命名规则 1	禁用 Python 关键字（如if/or/and/else）	if = 18（关键字不能做变量）
命名规则 2	禁用内置函数名（如print/type/int）	print = '输出'（覆盖内置函数）
命名规则 3	严格区分大小写，name和Name是两个变量	Name = 10后调用name（报错）
命名规则 4	不能以数字开头、含空格，可含下划线_	1age = 18 my name = '张三'
命名规则 5	语义化命名（见名知意），优先小写 + 下划线（Python 规范）	a = 18（不如age = 18清晰）
常量（约定）	Python 无 “不可修改” 的常量，仅约定全大写命名（仍可修改，仅为规范）	time = 2026（不符合常量命 名规范）

实操代码

# 变量赋值与命名
a = 180
name = '啊杰'  # 语义化命名
a = 1+1
print('我今年', a)  # 输出：我今年 2

# 常量（约定全大写）
TIME = 2026
TIME = 2027  # 仍可修改，输出：2027

2. 核心数据类型：识别数据形态

      核心重点

     字符串类型：str 只要是引号包裹的数据都是字符串
     整型 int ，正整数，负整数，0，没有小数点的数字
     浮点型 float 只要带小数点的数字都是浮点型
    type()  用来查看数据类型 

    变量名是没有数据类型的，有数据类型的是与变量名建立关系的

类型	定义	语法特征	特殊写法 / 扩展
字符串 (str)	引号包裹的任意内容（文本）	单 / 双 / 三引号均可；三引号支持多行	三引号可作多行注释；支持占位 / 格式化
整型 (int)	无小数点的数字 （正 / 负 / 0）	无小数点； 3.6以上版本 支持_分隔符	无大小上限（Python 内置大整数支持）
浮点型 (float)	带小数点的数字	含小数点；支持科学计数法（e/E）	科学计数法：3.4e+2 = 3.4×10² = 340.0

 

     实操代码    

# 字符串：引号包裹，任意内容
name = '啊鹏'  # 单引号字符串
multi_line = '''这是多行字符串
可以直接换行
无需转义'''  # 三引号多行字符串

# 整型：无小数点，支持_分隔符（3.6+）
age = 19  # 普通整型
big_num = 1_000_000  # 下划线分隔，等价于1000000（仅易读，不影响值）
print(big_num)  # 输出：1000000（自动去掉下划线）

# 浮点型：带小数点，支持科学计数法
height = 187.0  # 普通浮点型
sound_speed = 3.4e+2  # 科学计数法：3.4×10² = 340.0
china_people = 1.3e9  # 1.3×10⁹ = 1300000000.0
light_speed = 2.99E+8  # 大写E也支持，2.99×10⁸ = 299000000.0
one_ml = 1e-3  # 1×10⁻³ = 0.001（小数科学计数法）

# type()：查看“值”的类型（变量无类型，类型属于值）
print(type(name))  # 输出：<class 'str'>
print(type(age))   # 输出：<class 'int'>
print(type(height))# 输出：<class 'float'>

 3. 数据类型转换：灵活切换数据格式

核心重点

int() 带有中文的值，字符串的浮点型，不可以转换
    两边带有空格数字，字符串的纯数字，整数类型都可以转
float() 中间带有空格数字，带有汉字的值，不可以转
    纯数字，整型，浮点型都可以转
str()   转字符串，任何类型的数据，都可以转为字符串类型

 转换规则（详细避坑指南）

转换函数	可转换场景	不可转换场景	转换规则细节
int()	1. 纯数字字符串（如'100'）2. 带空格数字字符串（如' 100 '）3. 浮点型（截断小数）	含中文 / 字母的字符串（如'100a'）	1. 自动去除字符串两端空格 2. 浮点型转整型：直接截断小数（非四舍五入）
float()	1. 纯数字 / 整型 / 浮点型 2. 纯数字字符串（含空格，如' 100.5 '）	1. 含中文 / 字母的字符串 2. 非数字字符串（如'abc'）	1. 自动去除字符串两端空格 2. 整型转浮点型：末尾加.0
str()	任意类型（整型 / 浮点型 / 列表等）	无	直接将值转为字符串形式（万能转换）

实操代码

# int()转换：带空格数字字符串（自动去空格）
b = ' 100 '
res1 = int(b)
print(res1)  # 输出：100

# int()转换：浮点型（截断小数）
c = 100.9  # 注意：不是四舍五入
res2 = int(c)
print(res2)  # 输出：100（仅保留整数部分）

# float()转换：带空格浮点数字符串
d = ' 100.5 '
res3 = float(d)
print(res3)  # 输出：100.5（自动去空格）

# str()转换：万能转换
e = 100  # 整型
res4 = str(e)
print(res4, type(res4))  # 输出：100 <class 'str'>

f = [1,2,3]  # 列表（后续知识点）
res5 = str(f)
print(res5, type(res5))  # 输出：[1, 2, 3] <class 'str'>

# 错误示例（注释掉，避免运行报错）
# g = '100.5'
# res6 = int(g)  # 报错：ValueError（浮点型字符串不能转整型）

4. 字符串进阶：拼接、占位与格式化

核心重点

• 核心规则：仅字符串可与字符串拼接，不同类型拼接会报错；
• 解决方法：非字符串需先转str()，

  # 正确拼接：字符串+字符串
  name = '我爱python'
  info1 = '我叫' + name  # 输出：我爱python
  # 错误拼接（注释掉）
  # info2 = '我今年' + 18  # 报错：str + int 不支持
  
  # 正确写法：先转字符串
  info3 = '我今年' + str(18)  # 输出：我今年18

占位符使用
    %s 占位字符串，万能的，可以代替其他类型
    %i 占位整型
    %f 占位浮点型
    %d 占位十进制的整数

%m.ns   

      m:字符串的最小宽度，位数不够使用空格自动补全，正数是右对齐，负数是左对齐
      n:精度控制，最多展示几个字符
%m.nf

     m:整体宽度(整数+小数点+小数),位数不够使用空格自动补全,正数是右对齐，负数是左对齐
      n：精度控制，保留几位小数，默认保留6位小数
%m.nd

      m:最小宽度，位数不够空格来补，正数是右对齐，负数是左对齐
      n:精度控制，至少显示数字，位数不够用0补

占位符	适配类型	格式控制语法	示例	输出结果
%s	任意类型（万能）	%m.ns：m = 最小宽度，n = 字符数	%5.2s % ' 张三'	张三（右对齐，占 5 位，取 2 字符）
%d/%i	整型	%m.nd：m = 最小宽度，n = 数字数	%5.3d % 18	018（右对齐，占 5 位，补 0 到 3 位）
%f	浮点型	%m.nf：m = 总宽度，n = 小数位	%8.2f % 65.6	65.60（右对齐，占 8 位，保留 2 位小数）

f-string（Python3.6 + 推荐）

• 语法：f'固定文本{变量:格式}'；
• 格式控制：<左对齐 />右对齐 /^居中对齐，配合宽度 / 精度。

5. 转义字符：控制字符输出格式

核心重点

转义符	作用	示例代码	输出结果
\'	转义单引号（避免与字符串引号冲突）	print('huany \'ind\'')	huany 'ind'
\"	转义双引号	print("huany \"ind\"")	huany "ind"
\n	换行（光标移到下一行开头）	print('姓名\n年龄\n手机号')	姓名年龄手机号
\b	退格（删除前一个字符）	print('hello\b')	hell（删除最后一个字符o）
\r	回车（覆盖当前行内容）	print('75%\r86%')	86%（覆盖原有的75%）
\t	制表符（默认 4 个空格，可自定义）	print('a\tbcd')	a bcd（默认 4 空格）
\\	转义反斜杠（输出\本身）	print('C:\\Users\\Desktop')	C:\Users\Desktop

实操代码

# 转义单引号
print('huany \'ind \'ajia')  # 输出：huany 'ind 'ajia

# 换行符：批量换行输出
print('请输入你的信息：\n姓名\n年龄\n手机号')
# 输出：
# 请输入你的信息：
# 姓名
# 年龄
# 手机号

# 退格符：删除前一个字符
print('hello\b')  # 输出：hell（删除最后一个字符o）

# 回车符：覆盖当前行
print('75%\r86%')  # 输出：86%（原75%被覆盖）

# 制表符：默认4空格，expandtabs()自定义宽度
print('a\tbcd')  # 输出：a   bcd（默认4空格）
print('abc\tef'.expandtabs(1))  # 输出：abc ef（制表符宽度设为1）

# 制表符对齐输出（表格效果）
print('姓名\t\t年龄\t\t性别')  # 两个\t增加间距
print('张三\t\t18\t\t男')      # 输出：张三        18        男
print('李四\t78\t\tsfsfs')  # 输出：李四      78        sfsfs

6. 运算符：数值计算与逻辑判断

核心重点

算术运算符（数值计算）

运算符	名称	作用	示例	结果	注意点
+	加法	数值相加 / 字符串拼接	9+6	15	字符串仅能与字符串相加
-	减法	数值相减	9-6	3	-
*	乘法	数值相乘 / 字符串重复	9*6	54	'a'*3 → 'aaa'（字符串重复）
/	除法	数值相除，返回浮点型	9/6	1.5	结果必为浮点型（即使整除，如6/2=3.0）
//	取整	整除后取整数部分（向下取整）	9//6	1	负数取整：-9//6 = -2（向下取整）
%	取余	整除后取余数	9%6	3	余数符号与除数一致：9%-6 = -3
**	幂运算	数值的 n 次方	9**3	729	2**0.5 → 根号 2（浮点型）

赋值运算符（简化赋值）

运算符	等价写法	示例	解析
+=	x = x + y	age +=1	age = age + 1
-=	x = x - y	age -=1	age = age - 1
*=	x = x * y	price *=0.5	price = price * 0.5
/=	x = x / y	price /=0.5	price = price / 0.5
//=	x = x // y	a //=3	a = a // 3
%=	x = x % y	a %=3	a = a % 3
**=	x = x ** y	a **=3	a = a ** 3

比较运算符（返回布尔值）

运算符	名称	作用	示例	结果	特殊规则
==	等于	判断两边值是否相等	8==5	False	字符串比较：按 Unicode 码逐字符对比
!=	不等于	判断两边值是否不等	8!=5	True	-
>/<	大于 / 小于	判断数值大小 / 字符串 Unicode 码	'a'<'b'	True	字符串逐字符对比，直到找到不同字符
>=/<=	大于等于 / 小于等于	包含等于的判断	8>=8	True	-

逻辑运算符（短路求值核心）

运算符	名称	核心规则	短路求值逻辑	返回值规则
and	逻辑与	一假则假，全真才真	第一个值为假 → 直接返回第一个值（不执行后续）第一个值为真 → 返回第二个值	不是仅返回 True/False，返回实际参与运算的值
or	逻辑或	一真则真，全假才假	第一个值为真 → 直接返回第一个值（不执行后续）第一个值为假 → 返回第二个值	同上
not	逻辑非	取反，必返回布尔值	无短路（仅对单个值取反）	仅返回 True/False

实操代码

# 基础算术运算
print(9/6)   # 输出：1.5（除法必返回浮点型）
print(9//6)  # 输出：1（取整）
print(9%6)   # 输出：3（取余）
print(9**3)  # 输出：729（9×9×9）

# 字符串乘法（特殊用法）
print('a'*5)  # 输出：aaaaa

# 赋值运算符：简化代码
age = 18
age += 1  # 等价于 age = age + 1
print(age)  # 输出：19

age -= 1  # 等价于 age = age - 1
print(age)  # 输出：18

price = 100
dis = 0.5
price *= dis  # 等价于 price = price * dis
print(price)  # 输出：50.0

price /= dis  # 等价于 price = price / dis
print(price)  # 输出：100.0

a = 8
b = 3
a //= b  # 等价于 a = a // b
print(a)  # 输出：2

a %= b  # 等价于 a = a % b
print(a)  # 输出：2

a **= b  # 等价于 a = a ** 3
print(a)  # 输出：8


# 基础逻辑判断（返回布尔值）
print(True and False)  # 输出：False（一假则假）
print(False and False) # 输出：False（全假）
print(True or True)    # 输出：True（一真则真）

# and 短路求值：第一个值为假，直接返回，不执行后续
print(False and 3/0)  # 输出：False（无报错，3/0未执行）
# print(3/0 and True)  # 报错：ZeroDivisionError（第一个值执行报错）

# or 短路求值：第一个值为真，直接返回，不执行后续
print(3+4 or 3/0)  # 输出：7（3+4=7为真，3/0未执行）
# print(0 or 3/0)   # 报错：ZeroDivisionError（第一个值为假，执行第二个值）

# not 取反：必返回布尔值
print(not '')  # 输出：True（空字符串为假，取反为真）
print(not 0)   # 输出：True（0为假，取反为真）
print(not 100) # 输出：False（非0为真，取反为假）

# and 返回实际值：第一个真→返回第二个，第一个假→返回第一个
print(3+4 and 9+8)  # 输出：17（3+4=7为真，返回9+8=17）
print(3+4 and 0)    # 输出：0（3+4=7为真，返回0）
print(3-3 and True) # 输出：0（3-3=0为假，返回0）
print(3-3 and 3/0)  # 输出：0（3-3=0为假，3/0未执行）

# or 返回实际值：第一个真→返回第一个，第一个假→返回第二个
print(3+3 or 0)  # 输出：6（3+3=6为真，返回6）
print(3-3 or 5)  # 输出：5（3-3=0为假，返回5）
print('' or 0)   # 输出：0（空字符串为假，返回0）
print(0 or '')   # 输出：''（0为假，返回空字符串）

8. 进制转换：不同进制的互转

核心重点

进制	进位规则	数字范围	标识前缀	示例（十进制 25）
二进制	满 2 进 1	0、1	0b	0b11001
八进制	满 8 进 1	0-7	0o	0o31
十六进制	满 16 进 1	0-9、a-f（a=10）	0x	0x19
十进制	满 10 进 1	0-9	无	25
函数	作用	示例	结果
bin(十进制数)	十进制转二进制	bin(25)	0b11001
oct(十进制数)	十进制转八进制	oct(25)	0o31
hex(十进制数)	十进制转十六进制	hex(25)	0x19
int(值, 进制)	其他进制转十进制	int('0b11001', 2)	25

实操代码

# 十进制转其他进制
print(bin(25))   # 输出：0b11001（二进制，0b是标识）
print(oct(25))   # 输出：0o31（八进制，0o是标识）
print(hex(25))   # 输出：0x19（十六进制，0x是标识）

# 其他进制直接使用（Python自动识别前缀）
num1 = 0b11001  # 二进制25
print(num1)      # 输出：25（自动转为十进制）

# 其他进制字符串转十进制
print(int('0b11001', 2))   # 输出：25（二进制字符串转十进制）
print(int('0o1011', 8))    # 输出：521（八进制字符串转十进制）
print(int('0x11001', 16))  # 输出：69633（十六进制字符串转十进制）
print(int('0x1f', 16))     # 输出：31（十六进制1f=1×16+15=31）

9. 流程控制：分支与嵌套分支

分支结构基础（if/elif/else）

• 顺序结构：代码从上到下依次执行；
• 分支结构：根据条件执行不同代码，if→elif→else依次判断；
• 关键规则：
  • 一个if仅能匹配一个else，可匹配多个elif；
  • 一旦某个分支条件为True，其余分支不再执行；
  • 条件判断：非 0 数字 / 非空字符串为真，0 / 空字符串为假。

嵌套分支（分支内的分支）

• 外层分支执行后，才会判断内层分支；
• 缩进决定分支层级（Python 强制缩进，通常 4 个空格）。

实操代码

age = 19
gender = 'nan'

# 外层分支：判断是否成年
if age >= 18:
    print('成年')  # 外层条件成立，执行此行
    # 内层分支：成年后判断性别
    if gender == 'nan':
        print('男大')  # 内层条件成立，执行此行
    else:
        print('女大')
else:
    print('未成年')  # 外层条件不成立时执行
    # 内层分支：未成年判断性别
    if gender == 'nv':
        print('小女孩')
    else:
        print('小男孩')
# 输出：成年 → 男大

10. 输入语句：交互式数据获取

核心重点

• input('提示文本')：暂停程序，等待用户输入，输入完成后按回车继续；
• 无论用户输入什么，input()返回值默认是字符串类型；
• 若需数值计算，必须手动转换类型（如int(input())/float(input())）。

实操代码

# 基础输入：返回字符串
res1 = input('请输入你的姓名：')
print(res1, type(res1))  # 输入：张三 → 输出：张三 <class 'str'>

# 数值输入：转换为整型
res2 = int(input('请输入你的年龄：'))
print(res2 + 1)  # 输入：18 → 输出：19（整型可计算）

# 浮点型输入：转换为浮点型
res3 = float(input('请输入你的体重（kg）：'))
print(res3 * 2)  # 输入：65.5 → 输出：131.0

# 输入语句不影响后续代码执行
print('这是第一行语句')
print('这是第二行语句')
# 执行顺序：先输入→再输出两行语句

✨核心总结（必背）

1. 变量命名规范是基础，常量仅为 “全大写” 约定（可修改）；
2. 数据类型转换：int()不转浮点型字符串，str()万能转换；
3. 字符串格式化：f-string（3.6+）比占位符更简洁，优先使用；
4. 逻辑运算符核心：and/or短路求值，返回实际值；not仅返回布尔值；
5. 分支结构：匹配即执行、执行即终止，嵌套分支注意缩进层级；
6. 输入语句：默认返回字符串，数值计算前必须手动转类型。