Python 零基础教程【基础篇】（更新中）

作者：辰风沐阳阅读：152 发布时间：2026-06-18 上次更新：2026-06-23

[TOC]

#### 1. Debug 工具
---

Debug 工具是 PyCharm IDE 中集成的用来调试程序的工具，在这里程序员可以看到程序的执行细节和流程或者调试 bug

Debug 工具使用步骤：打断点、Debug 调试

打断点：

+ 断点位置：目标要调试的代码块的第一行代码即可，即一个断点即可。
+ 打断点的方法：单击目标代码的行号右侧空白位置

Debug 调试：右键单击文件内容空白处，点击菜单中的 “调试 xx”。可使用以下代码片段测试 “调试工具”：

```python
name = 'liang'
print(name)
schoolName = '人生苦短，我用 Python'
print(schoolName)
```

#### 2. 数据类型及转换
---

认识 Python 中的数据类型

```python
# int 整型
print(type(1))

# float 浮点型
print(type(3.14))

# str 字符串，特点：数据都要带引号
print(type("hello"))

# bool 布尔型，通常判断使用，有两个取值 True、False（注意大小写，首字母大写）
print(type(True))
print(type(False))

# list 列表
c = [10, True, 'hello']
print(type(c))

# tuple 元组
d = (10, 3.14, 'liang')
print(type(d))

# set 集合
e = {10, 20, 'wuxi'}
print(type(e))

# dict 字典
f = { 'name': 'liang', 'age': 18 }
print(type(f))
```

数据类型之间的转换

```python
# 将数据转为浮点型
num = 1
str = '3.14'
print(float(num))
print(float(str))

# 将列表转为元组
list1 = [10, True, 'liang']
print(tuple(list1))

# 将元组转为列表
t1 = (10, 20, 30)
print(list(t1))

# eval() 计算在字符串中的有效 Python 表达式，并返回一个对象
str1 = '1'
str2 = '1.1'
str3 = '(10, True, "liang")'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))
```

#### 3. if 条件语句
---

条件语句：即条件成立执行某些代码，条件不成立则不执行这些代码或执行其它代码片段

```python
if True:
    print('条件成立执行的代码1')
    print('条件成立执行的代码2')

if False:
    print('条件成立执行的代码3')
    print('条件成立执行的代码4')

# 注意：下方没有加缩进的代码不属于 if 语句块，即和条件是否成立无关
print('这个代码会执行吗？')
```

简单条件语句：`if ... else`

```python
# 需求：年龄大于等于18，输出已经成年，可以去网吧上网

# 获取到的输入内容是字符串，需要转为数字类型
age = int(input('请输入您的年龄：'))

# if else 简单条件语句
if age >= 18:
    print(f'您输入的年龄: {age}，已经成年，可以去网吧上网')
else:
    print(f'抱歉，您输入的年龄: {age}，未成年，不可以去网吧')
```

多重判断条件语句：`if ... elif ... else`

```python
age = int(input('请输入您的年龄：'))

if age < 18:
    print(f'您输入的年龄: {age}，童工')
elif age <= 60:
    print(f'抱歉，您输入的年龄: {age}，合法工龄')
else:
    print(f'抱歉，您输入的年龄: {age}，法定退休年龄')
```

if 语句的嵌套

```python
age = int(input('请输入您的钱包余额：'))
seat = True # 是否有座位

if age >= 2:
    print(f'您的余额足够坐公交车')
    if seat:
        print('车上还有座位')
    else:
        print('每座了，只好站着了')
else:
    print(f'抱歉，余额不足，不能坐公交车了')
```

猜拳游戏案例：

```python
# 导入 random 模块，使用这个模块中的功能 random.randint() 生成随机整数
import random

# 玩家出拳
player = int(input("请出拳：0-石头 1-剪刀 2-布 --> "))
# 电脑出拳
computer = random.randint(0, 2)

print(f"玩家出拳: {player}")
print(f"电脑出拳: {computer}")

if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
    print('恭喜，玩家获胜')
elif player == computer:
    print('平局，还没分出胜负，再来一局吧')
else:
    print('抱歉，电脑获胜')
```

#### 4. 运算符
---

三目运算符也叫三元运算符或三元表达式，语法如下：

```plaintext
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
```

使用示例

```python
a = 1
b = 2
c = a if a > b else b # a > b 条件成立，返回 a 不成立返回 b
print(c) # 2

d = 10
e = 8
f = d if d > e else e
print(f) # 10
```

运算符的分类：

+ 算术运算符
+ 赋值运算符
+ 复合赋值运算符
+ 比较运算符
+ 逻辑运算符

前三类运算符（算术/赋值/复合赋值运算符）已在 [Python 零基础教程【入门篇】](https://www.itqaq.com/index/714.html) 中学习过，所以本文从比较运算符学习

赋值运算符作一个补充：

```python
# 单个变量赋值
a = 1
b = 2

# 多个变量赋值（左边的变量名数量和右侧的数据数量必须一致）
num1, num2, str = 10, 20, 'liang'
print(num1, num2, str)

# 多变量赋相同的值
c = d = 100
print(c, d)
```

比较运算符

| 运算符  | 描述  |
| ------------ | ------------ |
| ==  | 判断相等。如果两个操作数的结果相等，则条件结果为真（True），否则条件结果为假（False） |
| !=  | 不等于。如果两个操作数的结果不相等，则条件结果为真（True），否则条件结果为假（False）  |
| >  | 判断运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假  |
| <  | 判断运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假  |
| >=  | 判断运算符左侧操作数结果是否大于等于右侧操作数结果，如果小于，则条件为真，否则为假  |
| <=  | 判断运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假  |

逻辑运算符

| 运算符  |  逻辑表达式 | 描述  |
| ------------ | ------------ | ------------ |
|  and | x and y  | 布尔 “与”，如果 x 为 False，x and y 返回 False，否则它返回 y 的值  |
| or  | x or y  | 布尔 “或”，如果 x 为 True，x or y 返回 True，否则它返回 y 的值  |
| not  | not x  | 布尔 “非”，如果 x 为 True，返回 False；如果 x 为 False，返回 True  |

```python
a = 2
b = 4
c = 6

# and 都真才真，一假就假
print(a < b and c > b) # True
print(a > b and c > b) # False

# or 一真就真，都假才假
print(a < b or c > b) # True
print(a > b or c > b) # True

# not 非:取反
print(not False) # True
print(not a > b) # True
```

#### 5. 循环语句
---

循环的作用：让代码更高效的重复执行，不需要重复写多次相同的代码段

循环的分类：在 Python 中，循环分为 `while` 和 `for` 两种，最终实现效果相同

快速体验 `while` 循环

```python
# 需求: 重复执行 5 次 print("媳妇儿，我错了")
i = 0
while i < 5:
    print(f"{i}-媳妇儿，我错了")
    i += 1
```

`while` 循环的应用

```python
# 需求: 计算1-100中的偶数累加和

# 方法一: 条件判断和取余数
i = 1
sum = 0
while i <= 100:
    if i % 2 == 0:
        sum += i
    i += 1
print(f"1-100的累加和:{sum}") # 2550

# 方法二: 计数器控制
j = 2
sum2 = 0
while j <= 100:
    sum2 += j
    j += 2
print(f"1-100的累加和:{sum2}") # 2550
```

`break` 和 `continue` 是循环中满足一定条件退出循环的两种不同方式

+ break：终止此循环
+ continue：退出当前一次循环，继续执行下一次循环代码

```python
# break 终止循环，后续也不再进行循环
i = 1
while i <= 5:
    if i == 3:
        print(f"第{i}个苹果吃完了，吃饱了")
        break
    else:
        print(f"第{i}个苹果吃完了，还没吃饱")
    i += 1

# continue 结束本次循环，继续下一次的循环
i = 1
while i <= 5:
    if i == 3:
        print(f"第{i}个苹果有虫子，我不吃这个")
        i += 1
        continue
    print(f"第{i}个苹果吃完了")
    i += 1
```

`while` 循环语句的嵌套

```plaintext
while 条件1:
    条件1成立执行的代码
    ......
    while 条件2:
    条件2成立执行的代码
    ...
```

打印星星，每行输出的星星数量逐行递增

```python
# 循环 n 次，每次输出的 * 数量逐行递增
i = 0
while i < 5:
    j = 0
    while j <= i:
        print('*', end='')
        j += 1
    print()
    i += 1
```

循环嵌套经典练习题：九九乘法表

```python
# 需求：打印九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(f'{j}x{i}=' + str(i * j), end="\t")
        j += 1
    i += 1
    print()
```

`for` 循环语法格式：

```plaintext
for 临时变量 in 序列:
    重复执行的代码1
    重复执行的代码2
```

快速体验：

```python
str = 'liang123'
for item in str:
    if item == 'a':
        print('遇到a不打印')
        continue # 结束本次循环
    if item == 'g':
        print('遇到g终止循环')
        break # 终止本次循环
    print(item)
```

需求：女朋友生气了，要惩罚连续说 5 遍 “媳妇儿，我错了”。如果道歉正常完毕女朋友就原谅我了，这个程序应该怎么写 ？

+ 思考：这个 print 是不是没有循环也能执行 ？

```python
i = 1
while i <= 5:
    print('媳妇儿，我错了')
    i += 1
print('媳妇儿原谅我了')
```

`while ... else` 语法：

```plaintext
while 条件:
    条件成立重复执行的代码
else:
    循环正常结束之后要执行的代码
```

使用示例

```python
i = 1
while i <= 5:
    print('媳妇儿，我错了')
    i += 1
else:
    print('媳妇儿原谅我了')
```

退出循环的方式

所谓 `else` 指的是正常结束之后要执行的代码，即：如果是 `break` 终止循环的情况，`else` 下方缩进的代码将不执行

```python
i = 1
while i <= 5:
    if i == 3:
        print('这遍说的不真诚')
        break # 终止循环，那么 else 中的代码将不会执行
    print('媳妇儿，我错了')
    i += 1
else:
    print('真开心，媳妇儿原谅我了') # 这段代码不会执行
```

`continue` 不会影响 `else` 下方缩进代码的执行

```python
i = 1
while i <= 5:
    if i == 3:
        i += 1
        continue # 结束本次循环，else 中的代码还会执行
    print('媳妇儿，我错了')
    i += 1
else:
    print('真开心，媳妇儿原谅我了') # 这段代码正常执行
```

`for ... else` 语法：

```plaintext
for 临时变量 in 序列:
    重复执行的代码
else:
    循环正常结束之后要执行的代码
```

同理：如果是 `break` 终止循环的情况，`else` 下方缩进的代码将不执行；如果是 `continue`，则不会受其影响

```python
str = 'liang'
for i in str:
    if i == 'a':
        break
    print(i)
else:
    print('循环正常结束执行的else代码') # 不会执行
```

#### 6. 字符串
---

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可

字符串的定义方式：

```python
# 单引号
a = 'hello world'
print(type(a))

# 双引号
b = "liang"
print(type(b))

# 三引号
c = '''tom'''
print(type(c))
d = """zhang"""
print(type(d))
e = """I
am tom
"""
print(e) # 输出结果也会换行

# 处理引号转义
f = 'I\'m tom'
print(f)
```

字符串的输出：

```python
name = 'liang'
print(f"我的名字是 {name}")
print("我的名字是 %s" % name)
```

“下标” 又叫 “索引”，也就是编号。下标的作用就是通过下标快速找到对应的数据（注意：下标从 0 开始）

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作

语法格式：

+ 不包含结束位置下标对应的数据，正负整数均可
+ 步长是选取间隔，正负整数均可，可以不写，默认步长为 1

```plaintext
序列[开始位置下标:结束位置下标]
序列[开始位置下标:结束位置下标:步长]
```

使用示例：

```python
str = 'abcdefg'
# 得到整个字符串的数据
print(str) # abcdefg
# 下标得到的是下标为某个数字的数据
print(str[2]) # c
# 得到 abc 这3个数据
print(str[0:3]) # abc
# 步长截取，每3个截取一次
print(str[0:5:3]) # ad
# 如果不写开始，默认从0开始
print(str[:4]) # abcd
# 如果不写结束，表示选取到最后
print(str[2:]) # cdefg
# 如果不写开始和结束，表示选取所有
print(str[:]) # abcdefg
# 如果步长为负数，表示倒叙选取
print(str[::-1]) # gfedcba
# 坐标取负数
print(str[-4:-1]) # def
```

字符串的常用操作方法有查找、修改和判断三大类

修改字符串：指的就是通过函数的形式修改字符串中的数据

`replace()`：替换。语法格式：

```plaintext
字符串序列.replace(旧子串, 新子串, 替换次数)
```

使用示例：

```python
# 调用 replace 函数后，发现原字符串数据并没有发生改变，修改后的数据是 replace 函数的返回值
# 说明字符串是不可变类型
# 数据是否可以改变划分为 可变类型 和 不可变类型
str = 'hello world and liang and king and python'
print(str.replace('and', 'or')) # hello world or liang or king or python
print(str.replace('and', 'or', 2)) # hello world or liang or king and python
```

`split()`：按照指定字符分割字符串。语法格式：

```plaintext
字符串序列.split(分割字符, 分割次数)
```

使用示例：

```python
# split() 分割字符串，返回一个列表，丢失分割字符
str = 'hello world and liang and king and python'
print(str.split('and')) # ['hello world ', ' liang ', ' king ', ' python']
print(str.split('and', 2)) # ['hello world ', ' liang ', ' king and python']
```

`join()`：按照指定字符分割字符串。语法格式：

```plaintext
字符或子串.join(多字符串组成的序列)
```

使用示例：

```python
# join() 合并列表里面的字符串数据为一个大字符串
myList = ['aa', 'bb', 'cc']
newStr = ','.join(myList)
print(newStr) # aa,bb,cc
```

其它字符串操作函数，非重点，了解即可

```python
str = 'how are YOU ?'
# capitalize() 将字符串第一个字符转为大写，其它字符全都小写
print(str.capitalize()) # How are you ? （YOU 被转位小写了）
# title() 将字符串每个单词首字母转为大写
print(str.title()) # How Are You ?
# lower() 将字符串全部转为小写
print(str.lower()) # how are you ?
# upper() 将字符串全部转为大写
print(str.upper()) # HOW ARE YOU ?

greet = ' how old are you '
print(greet.lstrip()) # 删除左侧空白字符串
print(greet.rstrip()) # 删除右侧空白字符串
print(greet.strip())  # 删除两侧空白字符串
```

字符串判断相关操作方法：

```python
str = 'how are you'
# 判断字符串是否以某个子串开头
print(str.startswith('how')) # True
print(str.startswith('are')) # False
# 判断字符串是否以某个子串结尾
print(str.endswith('are')) # False
print(str.endswith('you')) # True

# isdigit() 判断字符串是不是纯数字
str1 = '3'
str2 = '3.14'
str3 = '3.14y'
print(str1.isdigit()) # True
print(str2.isdigit()) # False
print(str3.isdigit()) # False

# isalnum() 判断是不是数字+字母
print('123'.isalnum())  # True
print('123a'.isalnum()) # False
print('3.14'.isalnum()) # False
```

#### 7. 列表
---

列表的格式（列表可以一次性存储多个数据，且可以为不同数据类型）：

```plaintext
[数据1, 数据2, 数据3...]
```

可以通过下标或函数获取列表的数据

`index()` 函数语法格式：

```plaintext
列表序列.index(数据, 开始位置, 结束位置下标)
```

使用示例：

```python
name = ['Tom', 'King', 'Rose', 'King', 'Liang']

# 按照下标获取数据
print(name[0]) # Tom
print(name[1]) # King
print(name[2]) # Rose

# 通过函数获取列表数据
# index() 如果查找的数据不存在会报错
print(name.index('King', 0, 2)) # 1
# 统计指定数据在列表中出现的次数
print(name.count('King')) # 2
# 获取列表长度，也就是列表中数据的个数
print(len(name)) # 5
```

判断数据是否在列表中

```python
name = ['Tom', 'King', 'Rose']

# in 判断指定数据是否在列表中，在返回 True
print('King' in name)  # True
print('liang' in name) # False

# not in 判断指定数据不在列表中，不在返回 True
print('King' not in name)  # False
print('liang' not in name) # True
```

使用示例：

```python
name = input('请输入您搜索的名字: ')
name_list = ['Tom', 'King', 'Rose']

if name in name_list:
    print(f'您输入的：{name}，已经存在，无法注册')
else:
    print(f'您输入的：{name}，不存在，可以注册')
```

增加指定数据到列表中

```python
name = ['Tom', 'King']

# append() 在列表结尾追加数据
name.append('liang')
print(name) # ['Tom', 'King', 'liang']

# insert(下标, 数据) 在指定位置追加数据
name.insert(1, 'css') # ['Tom', 'css', 'King', 'liang']
print(name)
```

删除列表或列表数据

```python
name = ['Tom', 'King', 'Rose']

# del 删除列表
# 1.下面两种写法都可以
# del name
# del(name)
# print(name) # NameError: name 'name' is not defined
# 2.也可以删除指定下标的数据
del name[0]
print(name) # ['King', 'Rose']

# pop(下标) 删除指定下标的数据，如果不指定下标，默认删除最后一个数据，返回值是被删除的数据
item = name.pop(1)
print(item) # Rose
print(name) # ['King']

# remove(数据) 删除指定数据
user = ['html', 'css', 'js']
user.remove('css')
print(user) # ['html', 'js']

# clear() 清空列表
admin = ['king', 'aria']
admin.clear()
print(admin) # []
```

修改列表中的数据

```python
name = ['Tom', 'King', 'Rose']

# 修改指定下标的数据
name[1] = 'Python'
print(name) # ['Tom', 'Python', 'Rose']

# reverse() 列表数据反转
name.reverse()
print(name) # ['Rose', 'Python', 'Tom']

# sort() 排序：升序、降序
num = [2, 5, 4, 3, 1]
# num.sort() # 升序（默认值）
num.sort(reverse=True) # 降序
print(num) # [5, 4, 3, 2, 1]
```

Python 零基础教程【基础篇】（更新中）

最新发布

友情链接