学习日记7.13

第 1 章 Python 入门与环境搭建

1.1 搭建 Python 开发环境

1.1.1 在 Windows 系统中搭建开发环境

1. 访问 Python 官网 (python.org) 下载 Windows 安装程序。学习python推荐选择python3.11版本
2. 运行安装程序，勾选 "Add Python to PATH" 选项。
3. 选择安装路径，点击 "Install Now"。如果不设置安装路径那么python会默认安装到C:\Users\用户名\AppData\Local\Programs\Python 这个路径下
4. 安装完成后，打开命令提示符 (cmd)，输入 python --version 验证安装。

按照以上步骤安装python

1.1.2 配置 PyCharm

访问pycharm官网(PyCharm，您需要的唯一 Python IDE)，点击下载pycharm，pycharm的社区版可以免费使用，初学者使用完全足够

1.2 第一个 Python 程序

打开 pycharm ，新建一个项目，位置可以自己设置，是之后存放代码的地方，环境选择现有，然后在python路径中选择刚刚下载的python路径，即可创建一个新的项目

在项目中新建一个python文件，就可以开始编写第一个代码Hello,World了。直接输入以下语句，就编写完成了

print("Hello, World!")

点击代码上方绿色的运行按钮之后，代码就运行完成了

上图中就是运行结果，结果为Hello ,World.结果前面的路径分别为python的地址和存放代码的地址

1.3 Python 语言代码的特点总结

1. 简洁易读：语法接近英语，使用缩进。
2. 解释型语言：无需编译，直接运行。
3. 动态类型：变量无需声明类型。
4. 面向对象：支持类、继承、多态等特性。
5. 丰富的库：拥有庞大的标准库和第三方库。

第 2 章 Python 语法元素

2.1 输出函数 print()

2.1.1 函数

函数是一段可重复使用的代码块，用于执行特定任务。Python 提供了许多内置函数，如 print()、len()、type() 等。函数通过函数名和括号调用，括号内可以传递参数。

2.1.2 print() 函数

print() 函数用于向屏幕输出信息。它可以输出字符串、数字、变量等多种类型的数据。就是刚刚Hello,World程序使用到的函数。可以使用逗号分隔多个参数，输出时默认用空格分隔。

print("Hello")  # 输出字符串
print(100)      # 输出数字
print(a,b,c,d)  # 输出多个参数
name = "Alice"
print(name)     # 输出变量
print("我正在学习",end="")
print("python") # 输出末尾设置

以上函数的输出结果如下

2.2 元素的命名

2.2.1 变量的命名规则

python中可以设置变量，为了后续便于使用变量我们需要给变量进行命名。变量的命名有以下规则

1. 变量名只能包含字母、数字和下划线，不能以数字开头，且不能包含空格
2. 变量名区分大小写（age 和 Age 是不同的变量）。
3. 不能使用 Python 关键字(如 if、for、while等）和保留字（如for,if,break等）作为变量名。
4. 建议使用有意义的英文单词，多个单词用下划线连接（如 user_name）。

2.2.2 赋值语句

赋值语句用于将值存储在变量中，使用等号 =。等号前面写变量，后面写所赋的值。

x = 10          # 将整数 10 赋值给变量 x
name = "Bob"    # 将字符串 "Bob" 赋值给变量 name
is_valid = True # 将布尔值 True 赋值给变量 is_valid

Python 支持多重赋值：

a,b=1,2

2.3 基本数据类型

2.3.1 数据类型的介绍

Python 中常见的基本数据类型有：
整数 (int)：如 10, -5, 0
浮点数 (float)：如 3.14, -0.5
字符串 (str)：如 "hello", 'world'
布尔值 (bool)：True 或 False
空值 (None)：表示空或无值

除了基本的数据类型定义，Python 还为每种数据类型提供了丰富的内置方法。下面分别介绍整数、浮点数和字符串的常用专属方法：

整数 (int) 的常用方法

整数类型提供了一些实用的方法：

• bit_length()：返回表示该整数所需的最小位数。
• to_bytes(length, byteorder)：将整数转换为字节数组。
• from_bytes(bytes, byteorder)：从字节数组创建整数（类方法）。
• round(x, n)：对浮点数 x 进行四舍五入，n 表示保留的小数位数（整数本身不需要四舍五入，但可用于处理浮点数）。
• max(iterable) 或 max(a, b, c, ...)：返回最大值。
• min(iterable) 或 min(a, b, c, ...)：返回最小值。

1. bit_length() 方法

bit_length() 方法返回表示该整数所需的最小二进制位数。

num = 42
print(f"42 的二进制位数: {num.bit_length()}")  # 输出: 6

讲解：整数 42 的二进制是 101010，需要 6 位二进制数来表示，所以 bit_length() 返回 6。

2. to_bytes() 和 from_bytes() 方法

to_bytes() 将整数转换为字节数组，from_bytes() 从字节数组还原整数。

# 转换为字节
bytes_data = num.to_bytes(2, byteorder='big')
print(f"42 的字节表示: {bytes_data}")  # 输出: b'\x00*'
从字节创建整数
new_num = int.from_bytes(bytes_data, byteorder='big')
print(f"从字节还原的整数: {new_num}")  # 输出: 42

讲解：to_bytes(2, 'big') 表示将整数转换为 2 个字节，使用大端字节序。42 转换为字节是 b'\x00*'，再通过 from_bytes() 可以还原回 42。

3. round() 方法

round() 主要用于浮点数四舍五入，但对整数使用时返回整数本身。

print(f"round(3.14159, 2): {round(3.14159, 2)}")  # 输出: 3.14
print(f"round(42): {round(42)}")  # 输出: 42

讲解：round(3.14159, 2) 保留两位小数，结果为 3.14。round(42) 对整数四舍五入，结果还是 42。

4. max() 和 min() 函数

max() 返回最大值，min() 返回最小值，可以传入可迭代对象或多个参数。

numbers = [10, 25, 3, 42, 7]
print(f"最大值: {max(numbers)}")  # 输出: 42
print(f"最小值: {min(numbers)}")  # 输出: 3
print(f"max(5, 10, 3): {max(5, 10, 3)}")  # 输出: 10
print(f"min(5, 10, 3): {min(5, 10, 3)}")  # 输出: 3

讲解：max(numbers) 从列表中找出最大值 42，min(numbers) 找出最小值 3。也可以直接传入多个参数比较。

字符串 (str) 的常用方法

字符串类型的方法最为丰富，以下是一些常用方法：

• 查找与替换：find(), replace(), count()
• 分割与连接：split(), join(), partition()
• 检查内容：startswith(), endswith(), isalpha(), isdigit()
• 切片操作：str[start:end:step]，提取子字符串
• 格式化：format()，格式化字符串
• 转义字符：使用反斜杠 \ 表示特殊字符

1. strip(), lstrip(), rstrip() 方法

这些方法用于去除字符串两端的空白字符。

text = "  Hello, Python World!  "
clean_text = text.strip()
print(f"去除空白后: '{clean_text}'")  # 输出: 'Hello, Python World!'
text3 = "   Hello World   "
print(f"strip(): '{text3.strip()}'")  # 输出: 'Hello World'
print(f"lstrip(): '{text3.lstrip()}'")  # 输出: 'Hello World   '
print(f"rstrip(): '{text3.rstrip()}'")  # 输出: '   Hello World'

讲解：strip() 去除两端空白，lstrip() 只去除左边空白，rstrip() 只去除右边空白。

2. find() 和 replace() 方法

find() 查找子串位置，replace() 替换子串。

print(f"找到 'Python' 的位置: {clean_text.find('Python')}")  # 输出: 7
new_text = clean_text.replace("World", "Universe")
print(f"替换后: {new_text}")  # 输出: Hello, Python Universe!

讲解：find('Python') 返回子串首次出现的索引（从0开始），replace('World', 'Universe') 将 "World" 替换为 "Universe"。

3. split() 和 join() 方法

split() 按分隔符分割字符串，join() 用指定字符连接字符串列表。

words = clean_text.split(", ")
print(f"分割结果: {words}")  # 输出: ['Hello', 'Python World!']
joined = "-".join(words)
print(f"连接后: {joined}")  # 输出: Hello-Python World!
csv_data = "apple,banana,orange,grape"
fruits = csv_data.split(",")
print(f"分割结果: {fruits}")  # 输出: ['apple', 'banana', 'orange', 'grape']
new_csv = ";".join(fruits)
print(f"重新连接: {new_csv}")  # 输出: apple;banana;orange;grape

讲解：split(", ") 按逗号和空格分割字符串，join() 用指定分隔符连接列表元素。

4. startswith(), endswith(), isalpha(), isdigit() 方法

这些方法用于检查字符串内容。

print(f"以 'Hello' 开头? {clean_text.startswith('Hello')}")  # 输出: True
print(f"是字母组成? {clean_text.isalpha()}")  # 输出: False（包含标点和空格）
print(f"是数字? {'123'.isdigit()}")  # 输出: True

讲解：startswith() 检查是否以指定字符串开头，isalpha() 检查是否全是字母，isdigit() 检查是否全是数字。

5. count() 方法

count() 统计子串在字符串中出现的次数。

text2 = "apple apple banana apple"
print(f"'apple' 出现次数: {text2.count('apple')}")  # 输出: 3
print(f"'a' 出现次数: {text2.count('a')}")  # 输出: 6

讲解：count('apple') 统计 "apple" 出现3次，count('a') 统计字母 "a" 出现6次。

6. 切片操作

使用 str[start:end:step] 提取子字符串。

s = "Python Programming"
print(f"前6个字符: {s[0:6]}")  # 输出: Python
print(f"从第7个开始: {s[7:]}")  # 输出: Programming
print(f"每隔一个字符: {s[::2]}")  # 输出: Pto rgamn
print(f"反转字符串: {s[::-1]}")  # 输出: gnimmargorP nohtyP

讲解：s[0:6] 提取索引0到5的字符，s[7:] 从索引7提取到末尾，s[::2] 每隔一个字符提取，s[::-1] 反转字符串。

7. format() 方法和 f-string

format() 用于格式化字符串，f-string 是更简洁的写法。

name = "Alice"
age = 25
print("姓名: {}, 年龄: {}".format(name, age))  # 输出: 姓名: Alice, 年龄: 25
print("姓名: {0}, 年龄: {1}, 再次姓名: {0}".format(name, age))  # 输出: 姓名: Alice, 年龄: 25, 再次姓名: Alice
print(f"格式化字符串: {name}今年{age}岁")  # f-string 是 format() 的简化写法

讲解：format() 使用花括号 {} 作为占位符，可以按位置或索引引用参数。f-string 在字符串前加 f，直接在花括号中写入变量名。

掌握这些数据类型的方法能够让你更高效地处理数据，编写更简洁的Python代码。在实际编程中，你可以通过 dir() 函数查看数据类型的全部可用方法，例如 dir(str) 可以查看字符串的所有方法。

2.3.2 检测数据类型

使用 type() 函数可以查看变量的数据类型。

print(type(10))        # 输出 <class 'int'>
print(type(3.14))      # 输出 <class 'float'>
print(type("hello"))   # 输出 <class 'str'>
print(type(True))      # 输出 <class 'bool'>

2.3.3 强制转换数据类型

使用内置函数可以进行类型转换：
- int()：转换为整数
- float()：转换为浮点数
- str()：转换为字符串
- bool()：转换为布尔值

num_str = "123"
num_int = int(num_str)   # 字符串转整数，结果为 123
num_float = float("3.14") # 字符串转浮点数，结果为 3.14
text = str(456)          # 整数转字符串，结果为 "456"
result = bool(0)         # 整数转布尔值，0 转为 False

2.3.4 报错信息分析

当类型转换失败时，Python 会抛出异常：

b=int(3.9)    # 结果为 3，直接截断小数部分
#错误示例：浮点数转整数会丢失小数部分，但不会报错
a=int("abc")  # 报错：ValueError: invalid literal for int() with base 10: 'abc'
# 错误示例：无法将非数字字符串转换为整数

2.3.5 多行处理

1. 多行字符串：使用三引号 ''' 或 """。
2. 多行语句：使用反斜杠 \ 或括号。

# 多行字符串
multi_line = """这是第一行
这是第二行
这是第三行"""
多行语句（使用反斜杠）
total = 10 + 
多行语句（使用括号）
numbers = (1, 2, 3,
4, 5, 6)

2.4 输入函数 input()

input() 函数用于从用户获取输入，返回的是字符串类型。

name = input("请输入你的名字：")
print("你好，" + name)
输入数字需要转换类型
age_str = input("请输入你的年龄：")
age = int(age_str)  # 将字符串转换为整数
print("明年你就", age + 1, "岁了")

2.5 注释

注释用于解释代码，不会被 Python 执行。
- 单行注释：以 # 开头
- 多行注释：使用三引号 ''' 或 """

# 这是一个单行注释
'''
这是一个多行注释
可以跨越多行
常用于函数或类的文档字符串
'''
def add(a, b):
"""这个函数用于计算两个数的和"""
return a + b

总结

本章介绍了 Python 的基本语法元素，包括输入输出函数、变量命名、数据类型和类型转换。掌握这些基础知识是编写 Python 程序的第一步。下一章将学习程序控制语句，让程序能够根据条件执行不同的代码。

第 3 章 程序控制语句

3.1 条件判断语句

3.1.1 if 语句

if 语句用于条件判断，如果条件为真，则执行缩进块内的代码。

age = 18
if age >= 18:
    print("你已成年")

3.1.2 布尔值

布尔值只有 True 和 False 两种，通常由比较运算符产生。

print(10 > 5)   # True
print(10 == 5)  # False
print(10 != 5)  # True

3.1.3 if+else 语句

if-else 语句在条件为真时执行一个代码块，为假时执行另一个代码块。

score = 85
if score >= 60:
    print("及格")
else:
    print("不及格")

3.1.4 if+elif+else 语句

if-elif-else 用于多个条件判断。

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

3.1.5 多个 elif 语句

可以有任意多个 elif 分支。

day = 3
if day == 1:
    print("星期一")
elif day == 2:
    print("星期二")
elif day == 3:
    print("星期三")
elif day == 4:
    print("星期四")
elif day == 5:
    print("星期五")
elif day == 6:
    print("星期六")
elif day == 7:
    print("星期日")
else:
    print("无效的天数")

3.1.6 条件判断语句的嵌套

可以在一个条件判断内部再嵌套另一个条件判断。

age = 20
has_license = True
if age >= 18:
if has_license:
print("可以开车")
else:
print("需要考驾照")
else:
print("未成年不能开车")

3.1.7 多个条件判断语句

使用逻辑运算符 and、or、not 连接多个条件。

age = 25
income = 50000
if age >= 18 and income > 30000:
print("符合贷款条件")
if age < 18 or income < 10000:
print("需要监护人同意")
if not (age < 18):
print("已成年")

3.1.8 if+else 语句的复合写法

Python 支持三元运算符，可以在一行中完成简单的条件判断。

# 传统写法
age = 20
if age >= 18:
    status = "成年"
else:
    status = "未成年"
复合写法（三元运算符）
status = "成年" if age >= 18 else "未成年"
print(status)
另一个例子
score = 85
result = "及格" if score >= 60 else "不及格"
print(result)

学习总结与注意事项

4.1 全文易错点总结

在学习 Python 的过程中，初学者经常会遇到一些常见的错误和陷阱。以下是本文涉及内容中需要特别注意的地方。

在开发环境搭建方面，安装 Python 时务必勾选 "Add Python to PATH"，否则在命令行中无法直接使用 python 命令。建议选择 Python 3.x 版本，避免使用已停止维护的 Python 2.x。PyCharm 等 IDE 需要正确配置 Python 解释器路径，否则无法运行代码。

基础语法方面，Python 使用缩进来定义代码块，而不是大括号，缩进不一致会导致 错误。Python 严格区分大小写。代码中必须使用英文标点符号，如括号、引号、逗号等，使用中文标点会导致语法错误。

变量与数据类型方面，变量命名不能以数字开头，不能使用 Python 关键字（如 if、for、while 等）。类型转换时，int("abc") 会抛出 ValueError，因为无法将非数字字符串转换为整数。浮点数计算可能存在精度问题，如 0.1 + 0.2 的结果不是精确的 0.3。字符串必须使用成对的单引号或双引号，不能混用。

字符串操作方面，字符串索引从 0 开始，访问超出范围的索引会引发 IndexError。切片操作 str[start:end] 包含 start 但不包含 end，容易混淆。字符串创建后不能修改，所有修改操作都会返回新字符串。反斜杠 \ 用于转义，如 \n 表示换行，\\ 表示反斜杠本身。

输入输出方面，input() 始终返回字符串，需要进行类型转换才能用于数学运算。使用 f-string 或 format() 时，花括号 {} 内必须是有效的表达式。print() 默认 end='\n'（换行），修改为 end='' 可使输出不换行。

条件判断方面，== 是相等判断，= 是赋值，两者不能混淆。逻辑运算符优先级为 not > and > or，复杂表达式建议使用括号明确优先级。嵌套的 if 语句需要正确的缩进层级。三元运算符 value_if_true if condition else value_if_false 的顺序容易写反。

4.2 学习建议与注意事项

代码规范方面，变量名使用小写字母和下划线（如 user_name），类名使用驼峰命名法（如 ClassName）。适当添加空格和空行，使代码结构清晰。使用有意义的常量代替直接写在代码中的数字。每个函数只完成一个明确的任务。

调试技巧方面，在关键位置添加 print() 语句输出变量值，是最简单的调试方法。PyCharm 等 IDE 提供强大的调试功能，可以设置断点、单步执行。将复杂功能分解为小模块，分别测试每个模块的正确性。学习使用 try...except 处理可能出现的异常。

常见陷阱方面，列表是可变的，字符串和元组是不可变的，操作方式不同。对于嵌套数据结构，简单的赋值可能只是创建引用而不是副本。在循环中修改正在迭代的集合可能导致意外结果。