Python笔记

Python笔记

SIYI171 幻想是一名作家
  2025-04-11 20:20:21 2025-04-11 20:20:21 创建   2025-11-05 04:48:48 2025-11-05 04:48:48 更新    3.5k 字  14 分钟  

变量

定义与赋值

变量是存储数据的容器。在 Python 里，你无需提前声明变量的类型，直接给变量赋值即可创建变量。

1
2
3
4
# 给变量 x 赋值为整数 10
x = 10
# 给变量 name 赋值为字符串 "Alice"
name = "Alice"

上述代码中，x 和 name 就是变量，分别存储了整数和字符串类型的数据。

变量命名规则

  • 变量名只能包含字母（大写或小写）、数字和下划线 _。
  • 变量名不能以数字开头。
  • 变量名不能是 Python 的关键字，如 if、else、for 等。
  • 变量名应具有描述性，便于理解代码的含义，例如用 age 表示年龄，用 student_name 表示学生姓名。

变量的动态类型特性

Python 是动态类型语言，意味着同一个变量可以在不同时刻存储不同类型的数据。

1
2
3
4
5
6
# 变量 num 初始存储整数
num = 5
print(num)
# 变量 num 现在存储字符串
num = "Five"
print(num)

数据类型

1. 数字类型

Python 中有几种数字类型，常见的有整数（int）、浮点数（float）和复数（complex）。

整数（int）：表示没有小数部分的数字，可以是正数、负数或零。

1
2
age = 25
count = -10

浮点数（float）：表示带有小数部分的数字。

1
2
height = 1.75
price = 9.99

复数（complex）：由实部和虚部组成，虚部用 j 或 J 表示。

1
c = 3 + 4j

2. 字符串类型（str）

字符串是由零个或多个字符组成的序列，可以用单引号、双引号或三引号表示。

1
2
3
4
5
6
7
# 单引号字符串
message1 = 'Hello'
# 双引号字符串
message2 = "World"
# 三引号字符串，可用于多行字符串
paragraph = """This is a
multi - line string."""

字符串支持多种操作，如拼接、索引和切片。

1
2
3
4
5
6
7
# 字符串拼接
greeting = message1 + " " + message2
print(greeting)
# 字符串索引，索引从 0 开始
print(greeting[0])
# 字符串切片，获取指定范围的子字符串
print(greeting[1:4])
正向索引

正向索引是从字符串的起始位置开始计数，索引值从 0 开始，依次递增。也就是说，字符串的第一个字符索引为 0，第二个字符索引为 1，依此类推。

1
2
3
4
5
6
7
8
text = "Python"
# 访问第一个字符
first_char = text[0]
# 访问第三个字符
third_char = text[2]

print(f"第一个字符: {first_char}")
print(f"第三个字符: {third_char}")
  • 定义了字符串 text，值为 "Python"。
  • text[0] 表示访问字符串 text 的第一个字符，结果为 'P'。
  • text[2] 表示访问字符串 text 的第三个字符，结果为 't'。
逆向索引

逆向索引是从字符串的末尾位置开始计数，索引值从 -1 开始，依次递减。即字符串的最后一个字符索引为 -1，倒数第二个字符索引为 -2，依此类推。

1
2
3
4
5
6
7
8
text = "Python"
# 访问最后一个字符
last_char = text[-1]
# 访问倒数第二个字符
second_last_char = text[-2]

print(f"最后一个字符: {last_char}")
print(f"倒数第二个字符: {second_last_char}")
  • 定义了字符串 text，值为 "Python"。
  • text[-1] 表示访问字符串 text 的最后一个字符，结果为 'n'。
  • text[-2] 表示访问字符串 text 的倒数第二个字符，结果为 'o'。
切片

切片用于获取字符串的子字符串，其语法格式为 [start:stop:step]，其中：

  • start：切片的起始索引（包含该索引对应的字符），默认为 0。
  • stop：切片的结束索引（不包含该索引对应的字符），默认为字符串的长度。
  • step：切片的步长，即每隔多少个字符取一个字符，默认为 1。
1
2
3
4
5
6
7
8
9
10
11
text = "Python Programming"
# 从索引 0 到索引 5（不包含 5）
substring1 = text[0:5]
# 从索引 7 到字符串末尾
substring2 = text[7:]
# 从字符串开头到索引 6（不包含 6）
substring3 = text[:6]

print(f"substring1: {substring1}")
print(f"substring2: {substring2}")
print(f"substring3: {substring3}")
  • text[0:5] 从索引 0 开始，到索引 5 结束（不包含索引 5 对应的字符），结果为 "Pytho"。
  • text[7:] 从索引 7 开始，一直到字符串末尾，结果为 "Programming"。
  • text[:6] 从字符串开头开始，到索引 6 结束（不包含索引 6 对应的字符），结果为 "Python"。
1
2
3
4
5
6
7
8
text = "Python Programming"
# 每隔一个字符取一个字符
substring4 = text[::2]
# 反向取字符
substring5 = text[::-1]

print(f"substring4: {substring4}")
print(f"substring5: {substring5}")
  • text[::2] 表示从字符串开头到末尾，步长为 2，即每隔一个字符取一个字符，结果为 "Pto rgamn"。
  • text[::-1] 表示步长为 -1，即反向取字符，结果为 "gnimmargorP nohtyP"。
1
2
3
4
5
text = "Python Programming"
# 从正向索引 2 到逆向索引 -3
substring6 = text[2:-3]

print(f"substring6: {substring6}")

text[2:-3] 表示从正向索引 2 开始，到逆向索引 -3 结束（不包含逆向索引 -3 对应的字符），结果为 "thon Programm"。

3. 布尔类型（bool）

布尔类型只有两个值：True 和 False，常用于条件判断。

1
2
is_student = True
has_license = False

4. 列表类型（list）

列表是有序的、可变的元素集合，用方括号 [] 表示，元素之间用逗号分隔。

1
2
3
fruits = ['apple', 'banana', 'cherry']
# 列表中的元素可以是不同类型
mixed_list = [1, "hello", True]

列表支持多种操作，如索引、切片、添加和删除元素。

1
2
3
4
5
6
7
8
# 访问列表元素
print(fruits[0])
# 修改列表元素
fruits[1] = 'grape'
# 列表末尾添加元素
fruits.append('orange')
# 删除列表指定位置的元素
del fruits[2]

5. 元组类型（tuple）

元组是有序的、不可变的元素集合，用圆括号 () 表示，元素之间用逗号分隔。

1
2
3
numbers = (1, 2, 3)
# 元组可以只包含一个元素，但需要在元素后面加逗号
single_element_tuple = (4,)

由于元组不可变，不能修改、添加或删除元组中的元素，但可以进行索引和切片操作。

1
2
3
4
# 访问元组元素
print(numbers[0])
# 元组切片
print(numbers[1:3])

6. 集合类型（set）

集合是无序的、唯一的元素集合，用花括号 {} 表示，或者使用 set() 函数创建。

1
2
3
4
5
# 创建集合
unique_numbers = {1, 2, 3, 2, 1}
print(unique_numbers)  # 输出: {1, 2, 3}
# 使用 set() 函数创建集合
empty_set = set()

集合支持交集、并集、差集等操作。

1
2
3
4
5
6
7
8
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# 交集
intersection = set1.intersection(set2)
# 并集
union = set1.union(set2)
# 差集
difference = set1.difference(set2)

7. 字典类型（dict）

字典是无序的键值对集合，用花括号 {} 表示，键和值之间用冒号 : 分隔，键值对之间用逗号分隔。

1
person = {'name': 'Bob', 'age': 30, 'city': 'New York'}

可以通过键来访问、修改和添加字典中的值。

1
2
3
4
5
6
# 访问字典中的值
print(person['name'])
# 修改字典中的值
person['age'] = 31
# 添加新的键值对
person['job'] = 'Engineer'

数据类型的转换

Python 允许你在不同数据类型之间进行转换，例如将整数转换为字符串，将列表转换为集合等。

1
2
3
4
5
6
7
8
9
# 整数转字符串
num = 10
str_num = str(num)
# 字符串转整数
str_value = "20"
int_value = int(str_value)
# 列表转集合
my_list = [1, 2, 2, 3]
my_set = set(my_list)

输出

1. print() 函数基础用法

print() 函数是 Python 里用于输出信息到控制台的常用工具。它可以输出各种类型的数据，像字符串、数字、列表等。

1
2
3
4
5
6
# 输出字符串
print("Hello, World!")
# 输出整数
print(123)
# 输出列表
print([1, 2, 3])

你还能在 print() 函数里同时输出多个值，值之间用逗号分隔，输出时这些值会以空格分隔开。

1
2
3
name = "Alice"
age = 25
print("Name:", name, "Age:", age)

2. 格式化输出

在 Python 中，有多种方式能实现格式化输出，以下为你介绍常见的几种：

f - 字符串（Python 3.6 及以上版本支持）

f - 字符串是一种简洁且直观的格式化字符串的方式，在字符串前加上 f 或 F，然后在字符串里用花括号 {} 包裹变量名。

1
2
3
name = "Bob"
age = 30
print(f"His name is {name} and he is {age} years old.")

str.format() 方法

str.format() 方法能把值插入到字符串里的占位符 {} 中。

1
2
3
name = "Charlie"
age = 35
print("Her name is {} and she is {} years old.".format(name, age))

你也可以通过指定索引来明确占位符对应的参数。

1
print("{1} is {0} years old.".format(40, "David"))

旧式的 % 格式化

在 Python 早期版本里，使用 % 来进行字符串格式化。%s 用于字符串，%d 用于整数，%f 用于浮点数。

1
2
3
name = "Eve"
age = 45
print("My name is %s and I'm %d years old." % (name, age))

3. 控制输出格式

你能够对输出的格式进行控制，例如控制浮点数的小数位数。

1
2
3
pi = 3.1415926
# 保留两位小数
print(f"Pi is approximately {pi:.2f}")

输入

input() 函数基础用法

input() 函数可用于从控制台获取用户输入，它会把用户输入的内容作为字符串返回。

1
2
name = input("Please enter your name: ")
print(f"Hello, {name}!")

在上述代码中，程序会暂停并等待用户输入名字，用户输入后按下回车键，输入的内容会被赋值给变量 name。

输入数据类型转换

由于 input() 函数返回的是字符串类型，若你需要其他数据类型，就需要进行类型转换。

1
2
3
4
5
6
7
8
9
# 获取用户输入的整数
age_str = input("Please enter your age: ")
age = int(age_str)
print(f"You will be {age + 1} years old next year.")

# 获取用户输入的浮点数
height_str = input("Please enter your height (in meters): ")
height = float(height_str)
print(f"Your height in centimeters is {height * 100}.")

条件语句

1. if 语句

if 语句是最基本的条件语句，用于根据条件判断是否执行特定的代码块。如果条件为 True，则执行 if 语句块中的代码；如果条件为 False，则跳过该代码块。

1
2
3
4
5
6
7
8
9
语法格式：
if 条件:
    # 条件为 True 时执行的代码块
    代码语句
    
示例：    
age = 18
if age >= 18:
    print("你已经成年了。")

2. if - else 语句

if - else 语句在 if 语句的基础上增加了一个 else 分支，当 if 条件为 False 时，会执行 else 代码块中的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
语法格式：
if 条件:
    # 条件为 True 时执行的代码块
    代码语句
else:
    # 条件为 False 时执行的代码块
    代码语句


示例：
age = 16
if age >= 18:
    print("你已经成年了。")
else:
    print("你还未成年。")

3. if - elif - else 语句

当需要进行多个条件判断时，可以使用 if - elif - else 语句。elif 是 else if 的缩写，可添加多个 elif 分支来进行更多条件的判断。一旦某个条件为 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
语法格式：
if 条件1:
    # 条件 1 为 True 时执行的代码块
    代码语句
elif 条件2:
    # 条件 2 为 True 时执行的代码块
    代码语句
elif 条件3:
    # 条件 3 为 True 时执行的代码块
    代码语句
...
else:
    # 以上所有条件都为 False 时执行的代码块
    代码语句
    
示例：
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

4. 嵌套条件语句

条件语句可以嵌套使用，即在一个条件语句的代码块中再包含另一个条件语句，用于处理更复杂的逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
age = 20
gender = "female"
if age >= 18:
    if gender == "male":
        print("成年男性")
    else:
        print("成年女性")
else:
    if gender == "male":
        print("未成年男性")
    else:
        print("未成年女性")

循环语句

1. for 循环

for 循环用于遍历可迭代对象（如列表、元组、字符串、字典等）中的每个元素，依次执行循环体中的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
语法格式：
for 变量 in 可迭代对象:
    # 循环体，对每个元素执行的代码
    代码语句

示例：
# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 遍历字符串
message = "Hello"
for char in message:
    print(char)

# 遍历字典的键值对
person = {"name": "Alice", "age": 25}
for key, value in person.items():
    print(f"{key}: {value}")

2. while 循环

while 循环会在条件为 True 时不断执行循环体中的代码，直到条件变为 False。

1
2
3
4
5
6
7
8
9
10
语法格式：
while 条件:
    # 循环体，条件为 True 时执行的代码
    代码语句
    
示例：
count = 0
while count < 5:
    print(count)
    count = count + 1

3. 循环控制语句

break 语句：用于立即终止当前所在的循环，跳出循环体，不再执行循环中剩余的代码

1
2
3
4
for i in range(10):
    if i == 5:
        break
    print(i)

continue 语句：用于跳过当前循环中剩余的代码，直接进入下一次循环。

1
2
3
4
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

else 子句：在 for 循环和 while 循环中都可以使用 else 子句。当循环正常结束（即没有被 break 语句终止）时，会执行 else 代码块中的内容。

1
2
3
4
for i in range(5):
    print(i)
else:
    print("循环正常结束")

4. 嵌套循环

循环语句也可以嵌套使用，即在一个循环体中再包含另一个循环，常用于处理二维数据结构等场景。

1
2
3
4
5
# 打印乘法口诀表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} x {i} = {i * j}", end="\t")
    print()
  • 标题: Python笔记
  • 作者: SIYI171
  • 创建于 : 2025-04-11 20:20:21
  • 更新于 : 2025-11-05 04:48:48
  • 链接: https://blog.siyi171.xyz/2025/04/11/python-notes/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
目录
Python笔记
  1. 变量
    1. 定义与赋值
    2. 变量命名规则
    3. 变量的动态类型特性
    4. 数据类型
    5. 数据类型的转换
  2. 输出
    1. 1. print() 函数基础用法
    2. 2. 格式化输出
    3. 3. 控制输出格式
  3. 输入
    1. input() 函数基础用法
    2. 输入数据类型转换
  4. 条件语句
    1. 1. if 语句
    2. 2. if - else 语句
    3. 3. if - elif - else 语句
    4. 4. 嵌套条件语句
  5. 循环语句
    1. 1. for 循环
    2. 2. while 循环
    3. 3. 循环控制语句
    4. 4. 嵌套循环