Python基础语法-JXin的博客

学习笔记说明

这是一篇Python的学习笔记，关于Python基础语法，仅做记录

语言基本特征

解释型
强类型
动态类型
面向对象

注释

# 这是单行注释

"""
这是多行注释
可以写多行
"""

'''
这也是多行注释
可以写多行
'''

1
2
3
4
5
6
7
8
9
10
11

数据类型

类别	类型名	字面量	说明
数字类型	int	1, 2, -3, 0	支持无限大小
数字类型	float	1.5, -0.3, 2e10	64位双精度
数字类型	complex	1+2j, 3-4j	j表示−1‾‾‾√
数字类型布尔类型	bool	True, False	True是1的别名 False是0的别名
字符串	str	“hello”, ‘world’	-
空值	NoneType	None	-
容器类型	多种类型	后续介绍	list/tuple/…

原子类型/基本内置类型/标量类型：int、float、complex、bool、str、NoneType

容器类型：list、tuple、…

# 整数（多种进制）
print(42)       # 十进制
print(0b1010)   # 二进制 = 10
print(0o52)     # 八进制 = 42
print(0x2A)     # 十六进制 = 42

# 浮点数（多种写法）
print(3.14)     # 小数形式
print(-0.5)     # 负数
print(2.5e10)   # 科学计数法 = 25000000000.0
print(1.2e-3)   # 负指数 = 0.0012

# 布尔值
print(True)     # 真
print(False)    # 假

# 字符串（单双引号等价）
print("hello")  # 双引号
print('world')  # 单引号
print('''Hello
world''')  # 多行字符串
print("""Hello
world""")  # 多行字符串

# 空值
print(None)     # 空值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

type函数

# 整数
print(type(42))       # <class 'int'>
print(type(0b1010))   # <class 'int'>
print(type(0o52))     # <class 'int'>
print(type(0x2A))     # <class 'int'>

# 浮点数
print(type(3.14))     # <class 'float'>
print(type(-0.5))     # <class 'float'>
print(type(2.5e10))   # <class 'float'>
print(type(1.2e-3))   # <class 'float'>

# 布尔值
print(type(True))     # <class 'bool'>
print(type(False))    # <class 'bool'>

# 字符串
print(type("Hello"))  # <class 'str'>
print(type('World'))  # <class 'str'>

# 空值
print(type(None))     # <class 'NoneType'>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注意：type函数返回的不是字符串，而是类型对象

print(type(42) == int) # True

变量

变量定义

Python是动态类型语言，变量无需声明类型，直接赋值即可创建。
Python里面没有常量，都是变量

# 变量赋值
name = "Alice"      # 字符串
age = 25            # 整数
pi = 3.14159        # 浮点数
is_valid = True     # 布尔值

1
2
3
4
5

变量命名规则

规则	说明	示例
字母/下划线开头	变量名必须以字母或下划线开头	`name`, `_value`
区分大小写	`Name` 和 `name` 是不同的变量	`Name = 1`, `name = 2`
不能是关键字	不能使用Python保留字	`if`, `for`, `class` 等
只能包含字母/数字/下划线	不能包含空格或特殊字符	`user_name`, `value2`

关键字（不能作为变量名）：

False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

# 有效命名
user_name = "张三"
_age = 25
MAX_SIZE = 100
value2 = 3.14

# 无效命名（会报错）
# 2value = 10      # 数字开头
# user-name = "a"  # 包含连字符
# class = 5        # 关键字

1
2
3
4
5
6
7
8
9
10

命名规范

类型	规范	示例
变量名	小写字母，下划线分隔（snake_case）	`user_name`, `total_count`
常量名	全大写字母，下划线分隔	`MAX_SIZE`, `PI`
类名	首字母大写的驼峰命名（PascalCase）	`UserInfo`, `DataModel`
私有变量	以下划线开头	`_internal`, `__private`

多重赋值

# 同时赋值多个变量
a, b, c = 1, 2, 3

# 交换变量值
x, y = 10, 20
x, y = y, x  # x=20, y=10

# 相同值赋给多个变量
a = b = c = 0  # a=0, b=0, c=0

1
2
3
4
5
6
7
8
9

变量类型转换

# 字符串转整数
age_str = "25"
age_int = int(age_str)      # 25

# 整数转字符串
num = 100
num_str = str(num)          # "100"

# 整数转浮点数
x = 5
x_float = float(x)          # 5.0

# 浮点数转整数（截断小数）
y = 3.9
y_int = int(y)              # 3（不是四舍五入）

# 转布尔值
print(bool(0))      # False
print(bool(1))      # True
print(bool(""))     # False
print(bool("hi"))   # True

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

字符串格式化（f-string）

Python 3.6+ 引入了 f-string（格式化字符串字面量），是最简洁、最常用的字符串格式化方式。

在字符串前加 f 或 F，在花括号 {} 中直接嵌入变量或表达式：

name = "Alice"
age = 25
print(f"姓名: {name}, 年龄: {age}")  # 姓名: Alice, 年龄: 25

# 直接嵌入表达式
a, b = 3, 5
print(f"{a} + {b} = {a + b}")       # 3 + 5 = 8

1
2
3
4
5
6
7

运算符

算术运算符

运算符	名称	int	float	str	bool	NoneType
`+`	加法	数值相加	数值相加	字符串拼接	True=1, False=0	不支持
`-`	减法	数值相减	数值相减	不支持	True=1, False=0	不支持
`*`	乘法	数值相乘	数值相乘	字符串重复	True=1, False=0	不支持
`/`	除法	返回float	返回float	不支持	True=1, False=0	不支持
`//`	整除	整数除法	整数除法	不支持	True=1, False=0	不支持
`%`	取余	取余数	取余数	不支持	True=1, False=0	不支持
`**`	幂运算	幂运算	幂运算	不支持	True=1, False=0	不支持

# int
print(5 + 3)        # 8
print(5 - 3)        # 2
print(5 * 3)        # 15
print(5 / 3)        # 1.666...
print(5 // 3)       # 1
print(5 % 3)        # 2
print(5 ** 3)       # 125

# float
print(5.0 + 3.0)    # 8.0
print(5.0 - 3.0)    # 2.0
print(5.0 * 3.0)    # 15.0
print(5.0 / 3.0)    # 1.666...
print(5.0 // 3.0)   # 1.0
print(5.0 % 3.0)    # 2.0
print(5.0 ** 3.0)   # 125.0

# str
print("Hello" + "World")  # "HelloWorld"
print("Hi" * 3)           # "HiHiHi"

# bool (True=1, False=0)
print(True + True)   # 2
print(True * 5)      # 5
print(False * 10)    # 0

# NoneType - 所有算术运算都会报错
# print(None + 1)   # TypeError

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

比较运算符

运算符	名称	int	float	str	bool	NoneType
`==`	等于	数值比较	数值比较	内容比较	True==1, False==0	None==None
`!=`	不等于	数值比较	数值比较	内容比较	True!=0	None!=非None
`<`	小于	数值比较	数值比较	字典序比较	True=1, False=0	不支持
`>`	大于	数值比较	数值比较	字典序比较	True=1, False=0	不支持
`<=`	小于等于	数值比较	数值比较	字典序比较	True=1, False=0	不支持
`>=`	大于等于	数值比较	数值比较	字典序比较	True=1, False=0	不支持

# int
print(5 == 5)       # True
print(5 != 3)       # True
print(5 > 3)        # True

# float
print(5.0 == 5.0)   # True
print(5.0 != 3.0)   # True
print(5.0 > 3.0)    # True

# str (按字典序/ASCII码比较)
print("abc" == "abc")     # True
print("abc" != "def")     # True
print("abc" < "def")      # True
print("A" < "a")          # True (A=65, a=97)

# bool
print(True == 1)          # True
print(False == 0)         # True
print(True > False)       # True

# NoneType
print(None == None)       # True
print(None != 0)          # True
print(None != False)      # True
# print(None > 0)         # TypeError

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

链式比较

Python 支持链式比较，可以像数学公式一样连续写比较运算符：

x = 5

# 传统写法（其他语言）
print(x > 1 and x < 10)   # True

# Python 链式比较（更简洁）
print(1 < x < 10)         # True
print(1 < x <= 5)         # True
print(5 <= x < 10)        # True
print(1 < x < 3)          # False

# 甚至可以更复杂
print(1 < x < 10 < 100)   # True

1
2
3
4
5
6
7
8
9
10
11
12
13

等价规则： a < b < c 等价于 a < b and b < c，但只计算一次 b。

赋值运算符

运算符	示例	等价于	适用类型
`=`	`a = 5`	-	所有类型
`+=`	`a += 3`	`a = a + 3`	int, float, str
`-=`	`a -= 3`	`a = a - 3`	int, float
`*=`	`a *= 3`	`a = a * 3`	int, float, str
`/=`	`a /= 3`	`a = a / 3`	int, float
`//=`	`a //= 3`	`a = a // 3`	int, float
`%=`	`a %= 3`	`a = a % 3`	int, float
`**=`	`a **= 3`	`a = a ** 3`	int, float

# int
a = 10
a += 5    # a = 15
a -= 3    # a = 12
a *= 2    # a = 24
a /= 4    # a = 6.0 (注意：/= 结果变为float)

# str
s = "Hello"
s += " World"  # s = "Hello World"
s *= 2         # s = "Hello WorldHello World"

1
2
3
4
5
6
7
8
9
10
11

海象运算符（:=）

Python 3.8 引入的赋值表达式，可以在表达式中同时进行赋值和求值。

# 传统写法：先赋值，再判断
line = input("输入: ")
while line != "quit":
    print(f"你输入了: {line}")
    line = input("输入: ")

# 使用海象运算符：赋值和判断合二为一
while (line := input("输入: ")) != "quit":
    print(f"你输入了: {line}")

1
2
3
4
5
6
7
8
9

注意： 海象运算符是 Python 3.8 的新特性，老版本不支持。

逻辑运算符

运算符	说明	返回值规则
`and`	逻辑与	第一个为False则返回第一个，否则返回第二个
`or`	逻辑或	第一个为True则返回第一个，否则返回第二个
`not`	逻辑非	返回True或False

各类型真假值：

int: 0为False，其他为True
float: 0.0为False，其他为True
str: ""为False，其他为True
bool: False为False，True为True
NoneType: None为False

# int
print(0 and 5)        # 0 (0为False，返回0)
print(3 and 5)        # 5 (3为True，返回5)
print(0 or 5)         # 5 (0为False，返回5)
print(3 or 5)         # 3 (3为True，返回3)
print(not 0)          # True
print(not 5)          # False

# float
print(0.0 and 5.0)    # 0.0
print(3.0 and 5.0)    # 5.0
print(not 0.0)        # True

# str
print("" and "hello") # "" (空字符串为False)
print("hi" and "hello") # "hello"
print(not "")         # True
print(not "hello")    # False

# bool
print(True and False)  # False
print(True or False)   # True
print(not True)        # False

# NoneType
print(None and True)   # None
print(None or True)    # True
print(not None)        # True

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

三元运算符（条件表达式）

Python 的三元运算符（条件表达式）是一种简洁的 if-else 写法，用于在一行中根据条件选择不同的值。

语法：

结果 = 真值 if 条件 else 假值

score = 85

# 传统写法
if score >= 60:
    result = "及格"
else:
    result = "不及格"

# 三元运算符（更简洁）
result = "及格" if score >= 60 else "不及格"
print(result)  # 及格

# 嵌套三元运算符（不推荐过度嵌套）
age = 25
category = "青年" if age < 40 else ("中年" if age < 60 else "老年")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意： 三元运算符适合简单的条件判断，复杂的逻辑应使用传统的 if-else 结构以保持代码可读性。

输入输出

print输出

# 输出字符串
print("Hello, World!")

# 输出多个值，用空格分隔
print("年龄:", 25)

# 自定义分隔符
print("a", "b", "c", sep="-")  # a-b-c

# 自定义结束符（默认换行）
print("Hello", end=" ")
print("World")  # Hello World

1
2
3
4
5
6
7
8
9
10
11
12

input输入

# 接收用户输入，返回字符串类型
name = input("请输入你的名字: ")
print("你好,", name)

# input返回的是字符串
age_str = input("请输入年龄: ")
age = int(age_str)  # 需要转换为整数
print("明年你", age + 1, "岁")

1
2
3
4
5
6
7
8

流程控制

条件判断

语法	说明
`if 条件:`	条件为True时执行
`elif 条件:`	前一个条件为False且当前条件为True时执行
`else:`	前面所有条件都为False时执行

# 基本if-else
age = 18
if age >= 18:
    print("成年人")
else:
    print("未成年人")

# if-elif-else
score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 60:
    grade = "C"
else:
    grade = "D"
print(f"成绩等级: {grade}")

# 单行if-else（三元表达式）
result = "通过" if score >= 60 else "不及格"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

注意： Python使用缩进（通常为4个空格）表示代码块，不使用花括号。

pass占位符

pass是Python中的占位符语句，不执行任何操作，用于语法上需要语句但逻辑上暂时不需要的情况。

# 空循环体
i = 0
while i < 5:
    pass  # 暂时不执行任何操作
    i += 1

# 空代码块（占位）
if True:
    pass  # 待实现

1
2
3
4
5
6
7
8
9

循环

while循环

# 基本while循环
count = 0
while count < 5:
    print(count)
    count += 1

# 带条件的while循环
user_input = ""
while user_input != "quit":
    user_input = input("输入'quit'退出: ")
    print(f"你输入了: {user_input}")

1
2
3
4
5
6
7
8
9
10
11

循环控制语句

语句	作用
`break`	立即终止整个循环
`continue`	跳过当前迭代，进入下一次循环

# break - 找到第一个大于5的数就停止
num = 1
while num <= 10:
    if num > 5:
        print(f"找到大于5的数: {num}")
        break
    num += 1

# continue - 跳过奇数，只打印偶数
num = 0
while num < 10:
    if num % 2 != 0:
        num += 1
        continue
    print(num)  # 0, 2, 4, 6, 8
    num += 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

循环else子句

循环可以带有一个else子句，当循环正常结束（没有被break中断）时执行。

# while循环的else
count = 0
while count < 3:
    print(count)
    count += 1
else:
    print("while循环正常完成")

# 典型用法：查找元素
num = 1
while num <= 9:
    if num == 4:
        print("找到: 4")
        break
    num += 2  # 模拟遍历奇数1, 3, 5, 7, 9
else:
    print("未找到: 4")  # 会执行，因为4不在奇数序列中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

重要区别：

循环被break中断 → 不执行else
循环正常结束（包括continue）→ 执行else

作业

作业一：代码输出结果预测

阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。

# 变量定义
a = 10
b = 3.5
c = "Python"
d = True
e = None

# 1. 数据类型与 type 函数
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))
print(type(a) == int)

# 2. 变量类型转换
print(int(b))
print(float(a))
print(str(a) + c)
print(bool(0))
print(bool(""))
print(bool("hello"))

# 3. 算术运算符
print(a + 5)
print(a / 4)
print(a // 4)
print(a % 4)
print(a ** 2)
print(c * 2)

# 4. 字符串格式化（f-string）
name = "Alice"
age = 25
print(f"姓名: {name}, 年龄: {age}")
print(f"明年{age + 1}岁")
print(f"{a} + {5} = {a + 5}")

# 5. 比较运算符与链式比较
print(a > 5)
print(a == 10)
print(5 < a < 20)
print(c == "python")
print("A" < "a")

# 6. 逻辑运算符
print(True and False)
print(True or False)
print(not d)
print(0 and 5)
print(3 or 5)
print("" and "hello")
print("hi" or "hello")
print(not None)

# 7. 三元运算符
score = 85
result = "及格" if score >= 60 else "不及格"
print(result)
level = "A" if score >= 90 else ("B" if score >= 80 else "C")
print(level)

# 8. 赋值运算符
x = 10
x += 5
print(x)
x -= 3
print(x)
x *= 2
print(x)
x /= 4
print(x)

s = "Hi"
s += " Python"
print(s)
s *= 2
print(s)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

作业二：循环与判断代码输出预测

阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。

# 1. while 循环 + if-else
n = 1
result = 0
while n <= 5:
    if n % 2 == 0:
        result += n
    else:
        result -= n
    n += 1
print(result)

# 2. continue 和 break
num = 1
while num <= 10:
    if num == 3:
        num += 1
        continue
    if num == 7:
        break
    print(num)
    num += 1

# 3. 循环 else 子句
i = 0
while i < 3:
    print(i)
    i += 1
else:
    print("end")

# 4. 嵌套条件
x = 15
if x < 10:
    print("A")
elif x < 20:
    if x % 2 == 0:
        print("B")
    else:
        print("C")
else:
    print("D")

# 5. 综合练习
a = 1
b = 0
while a <= 5:
    if a == 3:
        b += 10
    elif a % 2 == 0:
        b += a * 2
    else:
        b += a
    a += 1
print(b)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

作业三：BMI 计算器

编写一个 BMI 计算器程序，要求如下：

用户输入：通过 input() 函数获取用户的身高（单位：米）和体重（单位：千克）。
计算 BMI：使用公式 BMI = 体重(kg) / 身高(m)² 计算 BMI 值。
判断分类：根据 BMI 值判断身体状况（参考中国成人标准）：
- BMI < 18.5：偏瘦
- 18.5 ≤ BMI < 24：正常
- 24 ≤ BMI < 28：超重
- BMI ≥ 28：肥胖
输出结果：使用 f-string 格式化输出用户的 BMI 值和分类结果。
健康建议：根据分类结果给出相应的健康建议，例如：
- 偏瘦：建议适当增加营养摄入，进行适量运动
- 正常：保持良好的生活习惯
- 超重/肥胖：建议控制饮食，增加运动量

示例输出：

请输入您的身高（米）：1.75
请输入您的体重（千克）：70
您的 BMI 值为：22.86
身体状况：正常
建议：保持良好的生活习惯，继续保持！

1
2
3
4
5

作业四：素数筛选器

素数（质数） 是指在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的数。例如：2、3、5、7、11 都是素数，而 4、6、8、9 则不是。

编写一个程序，要求如下：

用户输入：通过 input() 函数获取起始数字和结束数字。
输入合法性检查：
- 输入必须是正整数（大于 0 的整数）
- 结束数字必须大于起始数字
- 如果输入不合法，给出相应提示并要求重新输入
素数判断：使用循环判断该范围内每个数字是否为素数。
输出结果：打印该范围内的所有素数，并统计素数的个数。

示例输出：

请输入起始数字：10
请输入结束数字：50
10 到 50 之间的素数有：
11 13 17 19 23 29 31 37 41 43 47
共计 11 个素数

1
2
3
4
5

作业答案

作业一

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>
True
3
10.0
10Python
False
False
True
15
2.5
2
2
100
PythonPython
姓名: Alice, 年龄: 25
明年26岁
10 + 5 = 15
True
True
True
False
True
False
True
False
0
3

hi
True
及格
B
15
12
24
6.0
Hi Python
Hi PythonHi Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

作业二

# 第一题：-3
# 第二题：1 2 4 5 6
# 第三题：0 1 2 end
# 第四题：C
# 第五题：28

1
2
3
4
5

作业三

# 获取用户输入
height = float(input("请输入您的身高（米）："))
weight = float(input("请输入您的体重（千克）："))

# 计算 BMI
bmi = weight / (height**2)

# 判断分类
if bmi < 18.5:
    category = "偏瘦"
    advice = "建议适当增加营养摄入，多吃富含蛋白质的食物，进行适量力量训练。"
elif bmi < 24:
    category = "正常"
    advice = "保持良好的生活习惯，均衡饮食，适量运动，继续保持！"
elif bmi < 28:
    category = "超重"
    advice = "建议控制饮食，减少高热量食物摄入，增加有氧运动，如慢跑、游泳等。"
else:
    category = "肥胖"
    advice = "建议咨询专业医生或营养师，制定科学的减重计划，注意饮食控制和规律运动。"

# 输出结果
print(f"\n您的 BMI 值为：{bmi:.2f}")
print(f"身体状况：{category}")
print(f"建议：{advice}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

作业四

# 获取并验证起始数字
while True:
    start = int(input("请输入起始数字："))
    if start <= 0:
        print("输入无效，请输入一个正整数！")
        continue
    break

# 获取并验证结束数字
while True:
    end = int(input("请输入结束数字："))
    if end <= 0:
        print("输入无效，请输入一个正整数！")
        continue
    if end <= start:
        print(f"结束数字必须大于起始数字 {start}，请重新输入！")
        continue
    break

# 输出结果
print(f"\n{start} 到 {end} 之间的素数有：")

# 使用 while 循环遍历范围内的每个数字
num = start
prime_count = 0

while num <= end:
    if num >= 2:
        # 判断 num 是否为素数
        is_prime = True
        i = 2
        while i * i <= num:
            if num % i == 0:
                is_prime = False
                break
            i += 1

        if is_prime:
            if prime_count > 0:
                print(" ", end="")
            print(num, end="")
            prime_count += 1

    num += 1

print()
print(f"共计 {prime_count} 个素数")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47