三万字长文带你入门——Python

Python是一种高级、解释型编程语言，以其简洁明了的语法和强大的功能著称。由吉多·范罗苏姆于1991年创建，Python支持多种编程范式，拥有丰富的库和框架，适用于数据分析、人工智能、Web开发等多个领域。

学习Python不仅因为它易学易用，适合初学者快速上手，更因为其广泛的行业应用和强大的社区支持，使得Python成为提升个人技能和职业竞争力的理想选择。

1 Python 环境搭建

访问Python的官方网站可以下载Python 3，此外，如果需要Python的支持文档，也可以直接在官网查找，或者直接点击：Python文档。

1.安装Python

• 在Windows上，运行下载的.exe安装程序。确保在安装过程中勾选“Add Python to PATH”选项，以便将Python添加到系统环境变量中。
• 在macOS上，通常下载.pkg文件并通过安装向导进行安装。
• 在Linux上，可以使用包管理器（如apt、yum等）安装Python，或者从源码编译安装。

2.验证安装

• 打开命令行工具（Windows上的CMD或PowerShell，macOS/Linux上的Terminal）。
• 输入python --version或python3 --version，如果安装成功，系统会显示Python的版本号。

验证完成之后就可以通过python或者python3进入命令行，开始编写和执行Python代码或者使用简单的文本编辑器编写代码并保存为.py文件，然后通过命令行运行这些文件。

2 Python 简介

2.1 Python 版本

现市面上存在Python 2.x和Python 3.x两个版本。

建议使用Python 3.x，因为它是当前和未来的主流版本，而Python 2.x已过时。Python 3.0发布于2008年，不再向下兼容。如果需要兼容旧代码，可以使用Python 2.7作为过渡。

2.2 集成开发环境

第一章最后面，我们介绍了Python文件的后缀以及运行方式。但是，上述方式存在一定的不方便，可以安装python的集成开发环境（Integrated Development Environment，IDE），IDE一般包括图形用户界面、代码编辑器（支持 代码补全、自动缩进）、编译器／解释器和调试器（断点／单步执行）。常见的集成开发环境包括：

1.PyCharm

• 由JetBrains公司开发，是专为Python设计的IDE。
• 提供免费的Community版和付费的Professional版。
• 支持代码自动完成、项目管理、版本控制、调试等功能。

2.Visual Studio Code（VSCode）

• 是一款轻量级但功能强大的编辑器，支持多种编程语言。
• 通过安装Python扩展，可以提供智能感知、调试、代码格式化等功能。
• 免费且开源。

3.Jupyter Notebook

• 一个交互式计算环境，允许用户编写和运行Python代码，并将代码、计算结果和文本结合在一起。
• 适合数据分析和科学计算。

4.Spyder

• 是一个专为科学计算设计的IDE，内置了IPython。
• 提供代码编辑、交互式计算、变量探索等功能。
• 是Anaconda发行版的一部分，但也可以独立安装。

2.3 Python 注释

Python 中的注释有单行注释和多行注释。

# 单行注释以#开头
print("Hello, World!")

# 多行注释用三个单引号'''或者三个"""将注释括起来

'''
多行注释，用三个单引号
多行注释，用三个单引号 
'''
print("Hello, World!")

"""
多行注释（字符串），用三个双引号
多行注释（字符串），用三个双引号 
"""
print("Hello, World!")

3 Python 基础

3.1 Python 变量

程序就是用来处理数据的，而变量就是用来存储数据的。
在 Python 中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在Python中，如果变量名需要由二个或多个单词组成时，可以按照以下方式命名：

• 每个单词都使用小写字母
• 单词与单词之间使用 _下划线连接

例如：first_name、last_name、qq_number、qq_password

此外，还可以利用驼峰命名法来命名

1.小驼峰式命名法

第一个单词以小写字母开始，后续单词的首字母大写
例如：firstName、lastName

2.大驼峰式命名法

每一个单词的首字母都采用大写字母

• 例如：FirstName、LastName、CamelCase

变量定义实例：

• 苹果的价格是 8.5 元/斤
• 买了7.5 斤 苹果
• 计算付款金额

# 定义苹果价格变量
price = 8.5
# 定义购买重量
weight = 7.5 
# 计算金额
money = price * weight
print(money)

在Python中，定义变量是不需要指定类型（在其他很多高级语言中都需要）。

3.2 Python 标识符

标示符就是程序员定义的变量名、函数名。标识符命名规则：

• 标示符可以由 字母、下划线 和 数字组成
• 不能以数字开头
• 不能与关键字重名

3.3 Python 关键字

关键字就是在 Python内部已经使用的标识符， 关键字具有特殊的功能和含义，开发者不允许定义和关键字相同的名字的标示符。
通过以下命令可以查看 Python中的关键字

import keyword
print(keyword.kwlist)

4 Python 基本数据类型

4.1 数据类型

Python数据类型可以分为数字型和非数字型。
数字型

• 整型 (int)
• 浮点型（float）
• 布尔型（bool） ：真 True 非 0 数 —— 非零即真，假
  False 0。
• 复数型 (complex)：主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题。

非数字型

• 字符串
• 列表
• 元组
• 字典

Python类型转换

int(x) ：将 x 转换为一个整数
float(x)：将 x 转换到一个浮点数

1.数字类型变量之间可以直接计算

在 Python 中，两个数字型变量是可以直接进行 算数运算的
如果变量是 bool型，在计算时：True对应的数字是 1，False对应的数字是 0。

2.字符串变量之间使用 + 拼接字符串

在Python中，字符串之间可以使用+ 拼接生成新的字符串

first_name = "三"
last_name = "张" 
print(first_name + last_name)

3.字符串变量可以和整数使用*重复拼接相同的字符串

print("-" * 50)
# 会输出‘--------------------------------------------------’也就是5个-

4.数字型变量和字符串之间不能进行其他计算

first_name = "zhang"
x = 10
print(x + first_name)
# print会报错

4.2 变量输入

input 函数
在 Python 中可以使用 input函数从键盘等待用户的输入，用户输入的任何内容Python都认为是一个字符串

字符串变量 = input("提示信息：")

变量输入实例演练：

• 收银员输入苹果的价格，单位：元／斤
• 收银员输入用户购买苹果的重量，单位：斤
• 计算并且输出付款金额

# 1. 输入苹果单价
price_str = input("请输入苹果价格：")
# 2. 要求苹果重量
weight_str = input("请输入苹果重量：")
# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)
# 2> 将苹果重量转换成小数
weight = float(weight_str)
# 3> 计算付款金额
money = price * weight
print(money)

改进版（由于Python将用户输入的内容默认为字符串，因为需要对输入内容进行数据类型转换，但是这样又很麻烦，因此可以进行改进）

price = float(input("请输入价格:"))

4.3 变量输出

在 Python 中可以使用print函数将信息输出到控制台
格式化：%被称为格式化操作符，专门用于处理字符串中的格式，包含 % 的字符串，被称为格式化字符串，%和不同的字符连用，不同类型的数据需要使用不同的格式化字符。
格式化字符含义 ：

• %s ：字符串
• %d ：有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
• %f：浮点数，%.2f 表示小数点后只显示两位
• %% ： 输出 %

%操作符是比较老式的操作，str.format() 是比较新的函数。

print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
# 输出：站点列表 Google, Runoob, 和 Taobao

格式化输出演练：
需求

• 定义字符串变量 name，输出 我的名字叫 小明，请多多关照！
• 定义整数变量 student_no，输出 我的学号是 000001
• 定义小数 price、weight、money，输出 苹果单价 9.00 元／斤，购买了 5.00 斤，需要支付 45.00元
• 定义一个小数 scale，输出 数据比例是 10.00%

print("我的名字叫 %s，请多多关照！" % name)
print("我的学号是 %06d" % student_no)
print("苹果单价 %.02f 元／斤，购买 %.02f 斤，需要支付 %.02f 元" % (price, weight, money))
print("数据比例是 %.02f%%" % (scale * 100))

5 Python 运算符

5.1 运算符分类

1.算术运算符
算数运算符是运算符的一种是完成基本的算术运算使用的符号，用来处理四则运算。常见的算术运算符包括以下：

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取模（返回除法的余数）
• **：幂运算
• //：整除（返回除法的整数部分）

在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果

print("-" * 50)
#输出为：'----------------------------------------' 

2.比较运算符

• ==：等于
• !=：不等于
• >：大于
• <：小于
• >=：大于等于
• <=：小于等于

3.逻辑运算符

• and：逻辑与
• or：逻辑或
• not：逻辑非

4.赋值运算符

• =：赋值
• +=：加赋值
• -=：减赋值
• *=：乘赋值
• /=：除赋值
• %=：取模赋值
• **=：幂赋值
• //=：整除赋值

5.位运算符

• &：按位与
• |：按位或
• ^：按位异或
• ~：按位取反
• <<：左移
• >>：右移

5.2 运算符的优先级

和数学中的运算符的优先级一致，在 Python 中进行数学计算时，

• 同样也是：先乘除后加减
• 同级运算符是从左至右计算
• 可以使用 () 调整计算的优先级

除了算术运算符的常规运算优先级之外，其他各运算符的优先级排序如下：

• ** ： 幂 (最高优先级)
• * / % // ：乘、除、取余数、取整除
• + - ： 加法、减法
• <= < > >= ：比较运算符
• == != ：等于运算符
• = %= /= //= -= += *= **= ： 赋值运算符
• not or and：逻辑运算符

6 Python语句

在程序开发中，一共有三种流程方式：

• 顺序 —— 从上向下，顺序执行代码
• 分支 —— 根据条件判断，决定执行代码的分支
• 循环 —— 让 特定代码 重复 执行

6.1 判断语句

在 Python中，if 语句 就是用来进行判断的，格式如下：

if 要判断的条件:
    条件成立时，要做的事情
# 注意：代码的缩进为一个 `tab` 键，或者 4 个空格 —— 建议使用空格

判断语句使用实例：

1. 定义一个整数变量记录年龄
2. 判断是否满 18 岁 （>=）
3. 如果满 18 岁，允许进网吧嗨皮

# 1. 定义年龄变量
age = 18
# 2. 判断是否满 18 岁
# if 语句以及缩进部分的代码是一个完整的代码块
if age >= 18:
    print("可以进网吧嗨皮……")
# 3. 思考！- 无论条件是否满足都会执行
print("这句代码什么时候执行?")

在使用if判断时，只能做到满足条件时要做的事情。那如果需要在 不满足条件的时候，做某些事情，则需要：

if 要判断的条件:
    条件成立时，要做的事情
else:
    条件不成立时，要做的事情

在开发中，使用 if 可以 判断条件，使用 else 可以处理条件不成立的情况。但是，如果希望再增加一些条件，条件不同，需要执行的代码也不同时，就可以使用 elif

if 条件1:
    条件1满足执行的代码
elif 条件2:
    条件2满足时，执行的代码
elif 条件3:
    条件3满足时，执行的代码
else:
    以上条件都不满足时，执行的代码

elif的应用场景是：同时 判断 多个条件，所有的条件是平级的。
在开发中，使用 if 进行条件判断，如果希望在条件成立的执行语句中再增加条件判断，就可以使用 if 的嵌套

• if 的嵌套的应用场景就是：在之前条件满足的前提下，再增加额外的判断
• if 的嵌套的语法格式，除了缩进之外和之前的没有区别

if 条件1:
    条件1 满足执行的代码
    if 条件1 基础上的条件2:
        条件2 满足时，执行的代码 
    # 条件2 不满足的处理
    else:
        条件2 不满足时，执行的代码 
# 条件1 不满足的处理
else:
 条件1 不满足时，执行的代码

if的嵌套演练——火车站安检

• 定义布尔型变量 has_ticket 表示是否有车票
• 定义整型变量 knife_length 表示刀的长度，单位：厘米
• 首先检查是否有车票，如果有，才允许进行 安检
• 安检时，需要检查刀的长度，判断是否超过 20 厘米。如果超过 20厘米，提示刀的长度，不允许上车；如果不超过 20 厘米，安检通过。
• 如果没有车票，不允许进门

# 定义布尔型变量 has_ticket 表示是否有车票
has_ticket = True
# 定义整数型变量 knife_length 表示刀的长度，单位：厘米
knife_length = 20
# 首先检查是否有车票，如果有，才允许进行 安检
if has_ticket:
    print("有车票，可以开始安检...")
    # 安检时，需要检查刀的长度，判断是否超过 20 厘米
    # 如果超过 20 厘米，提示刀的长度，不允许上车
    if knife_length >= 20:
         print("不允许携带 %d 厘米长的刀上车" % knife_length)
    # 如果不超过 20 厘米，安检通过
    else:
        print("安检通过，祝您旅途愉快……")
# 如果没有车票，不允许进门
else:
 print("大哥，您要先买票啊")

6.2 循环语句

循环的作用就是让 指定的代码 重复的执行。
1.while语句基本语法
while 循环最常用的应用场景就是让执行的代码按照指定的次数重复执行

while 条件(判断 计数器 是否达到 目标次数):
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...
    处理条件(计数器 + 1)

打印5遍Hello Python展示：

# 1. 定义重复次数计数器
i = 1
# 2. 使用 while 判断条件
while i <= 5:
    # 要重复执行的代码
    print("Hello Python")
    # 处理计数器 i
    i = i + 1
print("循环结束后的 i = %d" % i)

2.while循环嵌套

while 条件 1:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...
    while 条件 2:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...
        处理条件 2
    处理条件 1

打印九九乘法表：

# 初始化外层循环变量i，表示乘法表的行数
i = 1
# 外层循环，控制乘法表的行数，从1到9
while i <= 9:
    # 初始化内层循环变量j，表示乘法表的列数
    j = 1
    # 内层循环，控制每行中的乘法表达式数量，从1到i
    while j <= i:
        # 打印乘法表达式，使用制表符作为分隔，不换行
        print(f"{j} * {i} = {i * j}", end="\t")
        # 列数j加1，准备打印下一个乘法表达式
        j += 1
    # 每打印完一行后换行，准备打印下一行
    print()
    # 行数i加1，准备打印下一行乘法表
    i += 1

6.3 break和continue关键字

break和 continue是专门在循环中使用的关键字。

• break ：在循环过程中，如果 某一个条件满足后，不再希望循环继续执行，可以使用 break 退出循环
• continue：在循环过程中，如果 某一个条件满足后，不希望执行循环代码，但是又不希望退出循环

6.4 转义字符

转义字符用于表示那些在字符串中通常无法直接包含的字符，例如换行符、制表符或引号等。
转义字符以反斜杠（\）开头。以下是一些常用的Python转义字符：

• \：表示反斜杠本身。
• '：表示单引号。
• "：表示双引号。
• \n：表示换行符。
• \t：表示制表符（Tab）。
• \r：表示回车符

7 Python 函数

所谓函数，就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用。

7.1 函数基础

函数的使用包含两个步骤：

1. 定义函数 —— 封装独立的功能
2. 调用函数 —— 享受封装的成果

函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的重用。
定义函数的语法：

def 函数名():
    函数封装的代码
    ……
# 函数名应该符合标识符的命名规则

调用函数很简单的，通过函数名()即可完成对函数的调用
定义函数演练实例：

1. 编写一个打招呼 say_hello 的函数，封装三行打招呼的代码
2. 在函数下方调用打招呼的代码

name = "小明" 
# 解释器知道这里定义了一个函数
def say_hello():
    print("hello 1")
    print("hello 2")
    print("hello 3")
print(name)
# 只有在调用函数时，之前定义的函数才会被执行
# 函数执行完成之后，会重新回到之前的程序中，继续执行后续的代码
say_hello()
print(name)

注：函数必须先定义后调用

7.2 函数参数

在函数名的后面的小括号内部填写参数，多个参数之间使用 , 分隔。
函数参数演练实例：

1. 开发一个 sum_2_num 的函数
2. 函数能够实现两个数字的求和功能

def sum_2_num(num1, num2):
    result = num1 + num2
    print("%d + %d = %d" % (num1, num2, result))
sum_2_num(50, 20)

函数，把具有独立功能的代码块组织为一个小模块，在需要的时候调用
函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

1. 在函数内部，把参数当做变量使用，进行需要的数据处理
2. 函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递

7.3 形参和实参

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的

7.4 函数返回值

在程序开发中，有时候，会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理。在函数中使用 return 关键字可以返回结果。

def sum_2_num(num1, num2):
    # 对两个数字的求和
    return num1 + num2
# 调用函数，并使用 result 变量接收计算结果
result = sum_2_num(10, 20)
print("计算结果是 %d" % result)

7.5 函数的嵌套

一个函数里面又调用了另外一个函数，这就是函数嵌套调用

# 函数1
def test1():
    print("*" * 50)
    print("test 1")
    print("*" * 50)
#函数2
def test2():
    print("-" * 50)
    print("test 2")
    # 函数2中嵌套了函数1
    test1()
    print("-" * 50)

test2()

7.6 使用模块中的函数

模块是 Python 程序架构的一个核心概念。
模块就好比是工具包，要想使用这个工具包中的工具，就需要导入import这个模块。每一个以扩展名 py 结尾的 Python 源代码文件都是一个模块。在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具。

1. 新建 hm_10_分隔线模块.py
2. 复制 hm_09_打印多条分隔线.py 中的内容，最后一行 print 代码除外
3. 增加一个字符串变量

hm_10_分隔线模块.py

name = "黑马程序员"

新建 hm_10_体验模块.py 文件，并且编写以下代码

import hm_10_分隔线模块
hm_10_分隔线模块.print_line("-", 80)
print(hm_10_分隔线模块.name)

注：

1. 可以 在一个 Python 文件 中 定义变量或者函数
2. 然后在 另外一个文件中 使用 import导入这个模块（模块名也是一个标识符）
3. 导入之后，就可以使用 模块名.变量 / 模块名.函数的方式，使用这个模块中定义的变量或者函数

7.7 随机数

在Python中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”，导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数。
例如：random.randint(a, b) ，返回 [a, b]之间的整数，包含 a 和 b

# 导入random
import random
# 使用random库中的函数
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20 
random.randint(20, 20) # 结果永远是 20 
random.randint(20, 10) # 该语句是错误的，下限必须小于上限

8 高级变量类型

在4.1，介绍了Python中的数据类型可以分为 数字型 和 非数字型。
数字型

• 整型 (int)
• 浮点型（float）
• 布尔型（bool） ：真 True 非 0 数 —— 非零即真，假 False 0。
• 复数型 (complex)：主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题。

非数字型

• 字符串
• 列表
• 元组
• 字典

在 Python 中，所有非数字型变量都支持以下特点：

1. 都是一个序列sequence，也可以理解为容器
2. 取值[]
3. 遍历for in
4. 计算长度、最大/最小值、比较、
5. 删除 链接 +和 重复 *
6. 切片

8.1 列表

List（列表）是 Python中使用最频繁的数据类型，在其他语言中通常叫做数组。

1. 专门用于存储一串信息
2. 列表用 [] 定义，数据之间使用 , 分隔
3. 列表的索引从 0开始。索引就是数据在列表中的位置编号，索引又可以被称为下标
4. 从列表中取值时，如果超出索引范围，程序会报错

1.创建列表

# 创建一个空列表
empty_list = []
# 创建一个包含元素的列表
fruits = ['apple', 'banana', 'cherry']

2.访问列表元素

fruits = ['apple', 'banana', 'cherry']
print(fruits[0])  # 输出：apple
print(fruits[1])  # 输出：banana

3.列表切片

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
print(fruits[1:4])  # 输出：['banana', 'cherry', 'date']

4. 列表方法

Python提供了许多内置方法来操作列表：

• append(x)：在列表的末尾添加一个元素x。
• extend(iterable)：将一个可迭代对象的所有元素添加到列表末尾。
• insert(i, x)：在指定位置i插入一个元素x。
• remove(x)：删除列表中第一个值为x的元素。
• pop([i])：删除列表中指定位置i的元素，并返回该元素。如果不指定位置，默认删除并返回列表中的最后一个元素。
• clear()：清空列表中的所有元素。
• index(x[, start[,end]])：返回列表中第一个值为x的元素的索引，可以指定搜索的起始和结束位置。
• count(x)：返回x在列表中出现的次数。
• sort(key=None, reverse=False)：对列表中的元素进行排序。
• reverse()：反转列表中的元素顺序。

5.列表推导式

列表推导式（List Comprehension）提供了一种简洁的方式来创建列表

squares = [x**2 for x in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

6.列表的嵌套
列表可以包含其他列表作为其元素，这种结构称为嵌套列表或矩阵

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

7. 列表的遍历
遍历就是从头到尾依次从列表中获取数据
在 Python 中为了提高列表的遍历效率，专门提供的迭代 iteration 遍历，使用for就能够实现迭代遍历。

# for 循环内部使用的变量 in 列表
for name in name_list:
    循环内部针对列表元素进行操作
    print(name)

8. del关键字
使用del关键字(delete) 同样可以删除列表中元素，del关键字本质上是用来将一个变量从内存中删除的，如果使用 del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了。

del name_list[1]

8.2 元组

在Python中，元组（Tuple）是一种不可变的序列类型，用于存储一系列的元素。与列表不同，元组一旦创建就不能修改，这意味着你不能添加、删除或更改元组中的元素。元组通常用于保护数据不被改变，并且由于其不可变性，元组在某些情况下比列表更高效。
1.创建元组
元组可以通过圆括号()来创建，或者直接用逗号分隔元素来创建：

# 创建一个空元组 
empty_tuple = () 
# 创建一个包含元素的元组 
fruits = ('apple', 'banana', 'cherry') 
# 也可以省略圆括号 
fruits = 'apple', 'banana', 'cherry'

2.访问元组元素
元组元素可以通过索引来访问，索引从0开始：

fruits = ('apple', 'banana', 'cherry') 
print(fruits[0]) # 输出：apple 
print(fruits[1]) # 输出：banana

3.元组切片
可以使用切片操作来获取元组的一部分：

fruits = ('apple', 'banana', 'cherry', 'date', 'elderberry') 
print(fruits[1:4]) # 输出：('banana', 'cherry', 'date')

4.元组的不可变性
尝试修改元组的元素会导致错误：

fruits = ('apple', 'banana', 'cherry') 
# 下面的代码会抛出TypeError # fruits[0] = 'orange'

5.元组方法
元组提供的方法较少，主要包括：

• count(x)：返回x在元组中出现的次数。
• index(x[, start[,end]])：返回元组中第一个值为x的元素的索引，可以指定搜索的起始和结束位置

6.元组解包
元组可以被解包到多个变量中

fruits = ('apple', 'banana', 'cherry') 
a, b, c = fruits 
print(a) # 输出：apple 
print(b) # 输出：banana 
print(c) # 输出：cherry

7.单元素元组
创建单元素元组时，需要在元素后面加上逗号：

single_element_tuple = (42,)

元组在Python中用于确保数据的完整性，由于其不可变性，元组在多线程环境中是安全的，并且可以用作字典的键。
8. 循环遍历

# for 循环内部使用的变量 in 元组
for item in info:
    # 循环内部针对元组元素进行操作
    print(item)

9. 元组和列表见的转换
使用 list 函数可以把元组转换成列表

list(元组) 

使用 tuple函数可以把列表转换成元组

tuple(列表)

8.3 字典

在Python中，字典（Dictionary）是一种可变的、无序的键值对集合。字典中的每个键值对（key-value pair）用冒号:分隔，键（key）必须是不可变类型（如字符串、数字或元组），而值（value）可以是任何数据类型。字典的键必须是唯一的，但值可以重复。
1.创建字典
可以使用花括号{}来创建字典，或者使用dict()构造函数

# 使用花括号创建字典
my_dict = {'name': 'Alice', 'age': 25, 'country': 'Wonderland'}
# 使用dict()构造函数创建字典
my_dict = dict(name='Alice', age=25, country='Wonderland')

2.访问字典元素
通过键来访问字典中的值

my_dict = {'name': 'Alice', 'age': 25, 'country': 'Wonderland'}
print(my_dict['name'])  # 输出：Alice
如果尝试访问不存在的键，将会抛出KeyError。为了避免这个错误，可以使用get()方法，它会在键不存在时返回None（或指定的默认值）：
print(my_dict.get('name'))  # 输出：Alice
print(my_dict.get('city'))  # 输出：None
print(my_dict.get('city', 'Default City'))  # 输出：Default City

3. 修改字典
可以添加、修改或删除字典中的键值对

# 添加或修改键值对
my_dict['email'] = 'alice@example.com'
my_dict['age'] = 26
# 删除键值对
del my_dict['country']

4. 字典方法
Python提供了许多内置方法来操作字典：

• keys()：返回字典中的所有键。
• values()：返回字典中的所有值。
• items()：返回字典中的所有键值对。
• clear()：清空字典。
• copy()：返回字典的一个副本。
• pop(key[,default])：删除字典中指定的键，并返回该键对应的值。如果键不存在，返回默认值（如果没有提供默认值，则抛出KeyError）。
• popitem()：删除并返回一个键值对（Python 3.7+中按插入顺序）
• update(other)：用另一个字典或其他键值对更新字典。

5.字典推导式
字典推导式（Dictionary Comprehension）提供了一种简洁的方式来创建字典

squares = {x: x**2 for x in range(6)}
print(squares)  # 输出：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

6. 列表的遍历

# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming: 
    print("%s: %s" % (k, xiaoming[k]))

8.4 字符串

在Python中，字符串（String）是一种用于表示文本数据的基本数据类型。字符串是由字符组成的序列，可以使用单引号’、双引号"或三引号’''或"""来创建。三引号允许字符串跨越多行。
1.创建字符串

# 使用单引号
s1 = 'Hello, World!'
# 使用双引号
s2 = "Hello, World!"
# 使用三引号创建多行字符串
s3 = '''This is a
multi-line
string.'''

2.字符串不可变
字符串在Python中是不可变的，这意味着你不能更改字符串中的单个字符

s = "Hello"
# s[0] = 'h'  # 这会抛出TypeError，因为字符串不可变

3.字符串操作
连接字符串：可以使用+运算符来连接字符串

s1 = "Hello"
s2 = "World"
s3 = s1 + " " + s2  # 结果：'Hello World'

字符串乘法：可以使用*运算符来重复字符串

s = "Hello" * 3  # 结果：'HelloHelloHello'

访问字符：可以通过索引来访问字符串中的字符

s = "Hello"
print(s[0])  # 输出：H

字符串切片：可以使用切片操作来获取字符串的一部分

s = "Hello, World!"
print(s[7:12])  # 输出：World

4. 字符串方法
Python提供了许多内置方法来操作字符串：

• len(s)：返回字符串的长度。
• s.islower()：将字符串转换为小写。
• s.isupper()：将字符串转换为大写。
• s.strip()：去除字符串两端的空白字符。
• s.split(sep=None)：根据分隔符sep分割字符串，返回一个列表。
• s.join(iterable)：将一个可迭代对象中的元素连接成一个字符串，元素之间用s作为分隔符。
• s.replace(old,new)：将字符串中的old替换为new。
• s.find(sub)：查找子字符串sub在字符串中的位置，返回索引
• s.startswith(prefix)：检查字符串是否以prefix开头。
• s.endswith(suffix)：检查字符串是否以suffix结尾。

在 ipython3中定义一个字符串，例如：hello_str = “”。输入hello_str.按下TAB键，ipython会提示字符串能够使用的方法。

5. 格式化字符串

使用%操作符

name = "Alice"
age = 30
s = "Hello, %s. You are %d years old." % (name, age)

使用str.format()方法

s = "Hello, {}. You are {} years old.".format(name, age)

使用f-string（Python 3.6+）

s = f"Hello, {name}. You are {age} years old."

字符串实例演练：

1. 截取从 2 ~ 5 位置 的字符串
2. 截取从 2 ~ 末尾 的字符串
3. 截取从 开始 ~ 5 位置 的字符串
4. 截取完整的字符串
5. 从开始位置，每隔一个字符截取字符串
6. 从索引 1 开始，每隔一个取一个 截取从 2 ~ 末尾 - 1 的字符串
7. 截取字符串末尾两个字符
8. 字符串的逆序（面试题）

# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])
# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序（面试题）
print(num_str[::-1])

9 变量进阶

9.1 变量引用

如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用。 变量不再对之前的数据引用变量 改为对新赋值的数据引用。

9.2 可变和不可变类型

不可变类型，内存中的数据不允许被修改：

• 数字类型 int, bool, float, complex, long(2.x)
• 字符串 str
• 元组tuple

可变类型，内存中的数据可以被修改：

• 列表 list
• 字典 dict

9.3 局部变量和全局变量

• 局部变量是在函数内部定义的变量，只能在函数内部使用
• 全局变量是在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量。

为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求，例如，全局变量名前应该增加 g_ 或者 gl_ 的前缀。

10 面向对象基本概念

在Python中，面向对象编程（OOP）是一种使用“类”和“对象”来模拟现实世界的编程范式。

类：定义了一组具有相同属性（变量）和方法（函数）的对象。类用于封装数据和功能，是面向对象编程的核心概念。

• 属性：类中的变量，用于存储对象的状态。
• 方法：类中的函数，用于定义对象的行为。

对象：对象是类的实例，是根据类定义创建的具体实体。每个对象拥有类中定义的属性和方法，并且可以有自己的属性值。

• 实例化：创建对象的过程称为实例化。通过调用类名并传递必要的参数来创建对象。
• 属性访问：通过点（.）操作符访问对象的属性和方法。

10.1 面向对象基本语法

一个简单的Python类和对象：

# 定义一个类
class Dog:
    # 初始化方法（构造函数）
    def __init__(self, name, breed):
        self.name = name  # 实例属性
        self.breed = breed  # 实例属性
    # 实例方法
    def bark(self):
        return "Woof!"
# 创建对象（实例化）
my_dog = Dog("Buddy", "Golden Retriever")
# 访问对象属性
print(my_dog.name)  # 输出：Buddy
print(my_dog.breed)  # 输出：Golden Retriever
# 调用对象方法
print(my_dog.bark())  # 输出：Woof!

1. 在类的方法中，self是一个约定俗成的参数名，代表类的实例本身。它不是Python的关键字，可以使用其他名称，但self是最常用的。
2. 初始化方法是一个特殊的方法，用于在创建类的实例时初始化对象的状态。它被命名为__init__。

1.init函数
初始化方法，用于创建类的实例时初始化对象的状态，当对象被创建时自动调用。

class MyClass:
    def __init__(self, value):
        self.value = value

2. del函数
析构方法，用于对象被销毁时执行清理工作，当对象即将被销毁时自动调用。

class MyClass:
    def __del__(self):
        print("Object is being destroyed")

3.str函数
返回对象的字符串表示形式，用于打印对象时提供易读的输出，当使用print()函数或str()函数时调用。

class MyClass:
    def __str__(self):
        return "Custom string representation"

4.dir 函数
dir()函数用于返回对象的属性及方法列表。如果对象有__dir__()方法，该方法将被调用。否则，dir()会尝试找到对象的字典属性__dict__，或者通过迭代对象的类型__mro__中的属性来构建列表。

class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}!")

obj = MyClass("Alice")
print(dir(obj))

10.2 私有属性和私有方法

在Python中，私有属性和私有方法是指那些只能在类的内部访问的属性和方法。Python没有严格的访问控制机制，但通过命名约定来实现私有化。
1.私有属性
私有属性是通过在属性名前加上双下划线（__）来表示的。

class MyClass:
    def __init__(self):
        self.__private_attribute = "This is private"

    def get_private_attribute(self):
        return self.__private_attribute

obj = MyClass()
print(obj.get_private_attribute())  # 正确访问私有属性
# print(obj.__private_attribute)    # 错误：AttributeError

2.私有方法
私有方法的定义与私有属性类似，也是通过在方法名前加上双下划线（__）来表示。私有方法只能在类的内部调用。

class MyClass:
    def __init__(self):
        self.__private_method()

    def __private_method(self):
        print("This is a private method")

    def public_method(self):
        self.__private_method()

obj = MyClass()  # 输出: This is a private method
obj.public_method()  # 输出: This is a private method
# obj.__private_method()  # 错误：AttributeError

10.3 继承

Python中的继承是一种面向对象编程（OOP）机制，允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。继承可以提高代码的可重用性，并允许创建更复杂的类层次结构。

1.基本继承

在Python中，子类通过在类定义中指定父类来继承父类。子类会继承父类的所有属性和方法，除非子类中明确覆盖它们。

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# 创建实例
my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")

print(my_dog.speak())  # 输出: Woof!
print(my_cat.speak())  # 输出: Meow!

Dog和Cat类都继承自Animal类。它们继承了__init__方法，但覆盖了speak方法。

2.方法覆盖

子类可以覆盖父类中的方法。当子类的方法与父类的方法同名时，子类的方法将被调用。

class Parent:
    def my_method(self):
        print("Parent's method")

class Child(Parent):
    def my_method(self):
        print("Child's method")

obj = Child()
obj.my_method()  # 输出: Child's method

3.调用父类方法

子类需要调用父类中被覆盖的方法。这可以通过使用super()函数实现。

class Parent:
    def my_method(self):
        print("Parent's method")

class Child(Parent):
    def my_method(self):
        super().my_method()  # 调用父类的方法
        print("Child's method")

obj = Child()
obj.my_method()
# 输出:
# Parent's method
# Child's method

4. 多重继承

Python支持多重继承，即一个类可以继承多个父类。

class Swimmer:
    def swim(self):
        print("I can swim!")

class Runner:
    def run(self):
        print("I can run!")

class Athlete(Swimmer, Runner):
    pass

athlete = Athlete()
athlete.swim()  # 输出: I can swim!
athlete.run()   # 输出: I can run!

方法解析顺序

在多重继承中，Python使用方法解析顺序（Method Resolution Order, MRO）来确定方法的调用顺序。MRO可以通过__mro__属性或mro()方法查看。

class A:
    def my_method(self):
        print("A's method")

class B(A):
    pass

class C(A):
    def my_method(self):
        print("C's method")

class D(B, C):
    pass

obj = D()
obj.my_method()  # 输出: C's method
print(D.__mro__)
# 输出: (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

继承的注意事项

1. 避免复杂的继承层次：虽然继承可以提高代码的可重用性，但过于复杂的继承层次可能导致代码难以理解和维护。
2. 使用组合而非继承：在某些情况下，使用组合（即通过包含其他类的实例来实现功能）可能比继承更灵活和清晰。
3. 明确继承关系：确保子类和父类之间的关系清晰明确，以避免不必要的混淆。

10.4 多态

多态是面向对象编程（OOP）的一个核心概念，它允许不同的类对象对同一消息（方法调用）做出响应，但具体的实现细节由对象的实际类型决定。Python作为一种动态类型语言，天然支持多态。

1.Python中的多态实现

在Python中，多态可以通过以下几种方式实现：

1. 方法覆盖：子类覆盖父类的方法，调用时根据对象的实际类型来决定使用哪个方法。
2. 鸭子类型：Python支持鸭子类型（Duck Typing），即“如果它看起来像鸭子，游起来像鸭子，那么它就是鸭子”。这意味着只要对象实现了所需的方法，就可以被接受，而不需要继承自特定的类。
3. 抽象基类：通过定义抽象基类（ABC）来强制子类实现特定的方法，确保多态性。

方法覆盖

class Animal:
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_sound(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

animal_sound(dog)  # 输出: Woof!
animal_sound(cat)  # 输出: Meow!
"""
Animal类定义了一个speak方法，Dog和Cat类分别覆盖了这个方法。函数animal_sound可以接受任何Animal类型的对象，并调用其speak方法，具体的行为取决于对象的实际类型。
"""

鸭子类型

class Printer:
    def print(self, document):
        print(f"Printing {document}")

class FaxMachine:
    def print(self, document):
        print(f"Faxing {document}")

def send_document(device, document):
    device.print(document)

printer = Printer()
fax_machine = FaxMachine()

send_document(printer, "Hello, World!")  # 输出: Printing Hello, World!
send_document(fax_machine, "Hello, World!")  # 输出: Faxing Hello, World!
"""
在这个例子中，Printer和FaxMachine类都有一个print方法，但它们的行为不同。函数send_document不需要知道对象的具体类型，只要对象有print方法即可。
"""

抽象基类

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_sound(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

animal_sound(dog)  # 输出: Woof!
animal_sound(cat)  # 输出: Meow!
"""
Animal是一个抽象基类，它定义了一个抽象方法speak。Dog和Cat类必须实现这个方法。这样可以确保所有Animal类型的对象都具有speak方法，从而实现多态。
"""

多态的优点

1. 代码可重用性：通过多态，可以编写通用的代码来处理不同类型的对象。
2. 灵活性：多态允许在运行时动态地决定对象的行为。
3. 扩展性：新的类可以通过实现相同的方法来加入到多态体系中，而不需要修改现有代码。

10.5 静态方法

在Python中，静态方法（Static Method）是一种不需要访问类或实例属性的方法。它通过使用@staticmethod装饰器来定义。静态方法不接受self或cls参数，因此它们不能访问类或实例的属性和方法。

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

# 调用静态方法
result_add = MathUtils.add(5, 3)
result_multiply = MathUtils.multiply(5, 3)

print(result_add)  # 输出: 8
print(result_multiply)  # 输出: 15

在这个例子中，MathUtils类定义了两个静态方法：add和multiply。这些方法可以在不创建MathUtils实例的情况下直接调用。

静态方法与类方法的区别

• 静态方法：不接受self或cls参数，不能访问类或实例的属性和方法。适用于与类相关但不依赖于类或实例状态的工具函数
• 类方法：接受cls参数，可以访问类属性和方法，但不能访问实例属性和方法。类方法通常用于工厂方法或需要访问类属性的方法。

10.6 单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。单例模式通常用于管理共享资源、配置管理器、连接池等场景。

方法1:使用模块

Python模块在第一次导入时会被初始化，因此可以利用这一特性来实现单例模式。

# singleton.py
class Singleton:
    def __init__(self):
        self.value = "Some value"
singleton_instance = Singleton()
其他模块使用
from singleton import singleton_instance
print(singleton_instance.value)  # 输出: Some value

方法2:使用类属性

通过控制类的实例化过程来确保只有一个实例。

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
            cls._instance.value = "Some value"
        return cls._instance

# 使用
s1 = Singleton()
s2 = Singleton()

print(s1 == s2)  # 输出: True
print(s1.value)  # 输出: Some value

方法3：使用装饰器

创建一个装饰器来包装类，确保类只有一个实例。

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class MyClass:
    def __init__(self):
        self.value = "Some value"

# 使用
s1 = MyClass()
s2 = MyClass()

print(s1 == s2)  # 输出: True
print(s1.value)  # 输出: Some value

方法4：使用元类

通过自定义元类来控制类的实例化过程。

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(metaclass=SingletonMeta):
    def __init__(self):
        self.value = "Some value"

# 使用
s1 = Singleton()
s2 = Singleton()

print(s1 == s2)  # 输出: True
print(s1.value)  # 输出: Some value

10.7 Python 异常

Python中的异常是一种在运行时用来表示错误或异常条件的机制。当程序中发生错误时，Python解释器会抛出（raise）一个异常。如果异常没有被捕获和处理，程序将终止执行，并显示错误信息。Python提供了丰富的内置异常类型，同时也允许开发者自定义异常。
异常处理是通过try、except、else和finally块来实现的。这种结构允许程序在发生异常时做出响应，而不是直接崩溃。

try:
    # 尝试执行的代码
    pass
except ExceptionType1:
    # 处理ExceptionType1异常的代码
    pass
except (ExceptionType2, ExceptionType3) as e:
    # 同时处理ExceptionType2和ExceptionType3异常的代码
    # 变量e是异常的实例
    pass
else:
    # 如果没有异常发生，执行这里的代码
    pass
finally:
    # 无论是否发生异常，都会执行这里的代码
    pass

常见内置异常

Python有许多内置的异常类型，用于表示不同的错误情况。以下是一些常见的内置异常：

• ValueError：当传入无效的参数值时抛出。
• TypeError：当操作或函数应用于不适当类型的对象时抛出。
• IndexError：当尝试访问序列中不存在的索引时抛出。
• KeyError：当尝试访问字典中不存在的键时抛出。
• IOError：当输入/输出操作失败时抛出（在Python 3中，IOError被OSError取代）
• ZeroDivisionError：当除数为零时抛出。

自定义异常

开发者可以通过继承内置的Exception类或其子类来创建自定义异常。自定义异常可以提供更具体的错误信息，使得异常处理更加清晰和有针对性。

class MyCustomError(Exception):
    """自定义异常类"""
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

# 使用自定义异常
try:
    raise MyCustomError("Something went wrong!")
except MyCustomError as e:
    print(e)  # 输出: Something went wrong!

异常的链式调用

在处理异常时，有时需要在except块中再次抛出异常，以提供更多的上下文信息。Python支持异常的链式调用，这可以通过使用raise … from …语法来实现。

def func():
    try:
        # 尝试执行某操作
        pass
    except Exception as e:
        # 抛出新的异常，并保留原始异常的上下文
        raise ValueError("An error occurred") from e

try:
    func()
except ValueError as e:
    print(e)  # 输出: An error occurred

10.8 Python 模块和包

在Python中，模块和包是组织代码的基本单位，它们有助于将代码分割成可管理的块，并提供命名空间管理。

1.模块（Module）

模块是一个包含Python定义和声明的文件。模块可以定义函数、类和变量，也可以包含可执行的代码。

使用模块

要使用一个模块，通常需要先导入它。Python提供了几种导入模块的方式：

# 导入整个模块
import module_name
# 导入模块内的特定函数或类
from module_name import function_name, class_name

创建模块

创建模块非常简单，只需要创建一个.py文件，并在其中编写代码。例如，创建一个名为mymodule.py的文件：

# mymodule.py

def my_function():
    print("Hello from my_function")

class MyClass:
    def __init__(self):
        print("Hello from MyClass")

然后在其他Python文件中导入并使用它：

import mymodule

mymodule.my_function()  # 输出: Hello from my_function
obj = mymodule.MyClass()  # 输出: Hello from MyClass

2.包

包是一个包含多个模块的目录。在Python中，任何包含__init__.py文件的目录都被视为包，可以使用import语句导入。从Python 3.3开始，init.py文件不再是必需的，但仍然推荐使用它来保持向后兼容性。

创建包

要创建一个包，你需要创建一个目录，并在其中放置一个__init__.py文件。例如，创建一个名为mypackage的目录：

mypackage/
    __init__.py
    module1.py
    module2.py

init.py可以为空，或者包含初始化包的Python代码。

使用包

你可以使用import语句导入包中的模块：

import mypackage.module1

或者使用from语句导入特定的模块或属性

from mypackage import module1
from mypackage.module2 import my_function

10.9 Python文件

在Python中，文件操作是一个常见的任务，涉及读取、写入、修改和删除文件。Python提供了多种方法来处理文件，使得文件操作既简单又强大。以下是Python中文件操作的基本概念和常用方法。

打开文件

在Python中，使用内置的open()函数来打开文件。open()函数需要两个参数：文件名和模式（如读取、写入等）。

file = open('example.txt', 'r')

模式参数：

• ‘r’：读取模式（默认）。如果文件不存在，抛出异常。
• ‘w’：写入模式。如果文件存在，会被覆盖。
• ‘a’：追加模式。如果文件存在，写入的内容会被追加到文件末尾。
• ‘b’：二进制模式。用于读写二进制文件。
• ‘+’：更新模式。用于读写文件。

读取文件

打开文件后，可以使用不同的方法来读取文件内容。

# 读取整个文件内容
content = file.read()
print(content)

# 读取一行
line = file.readline()
print(line)

# 读取所有行并返回一个列表
lines = file.readlines()
print(lines)

写入文件

写入文件时，需要以写入模式（‘w’或’a’）打开文件。

# 写入内容
file.write("Hello, World!\n")

# 写入多行
file.writelines(["Line 1\n", "Line 2\n"])

关闭文件

文件操作完成后，应使用close()方法关闭文件，以释放系统资源。

file.close()

使用with语句

为了确保文件在使用后正确关闭，可以使用with语句。这是一种更优雅的文件操作方式，它会在代码块执行完毕后自动关闭文件。

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)
# 文件在with块结束时自动关闭

文件指针

文件对象有一个文件指针，用于指示当前读写位置。可以使用seek()和tell()方法来控制文件指针。

# 移动文件指针到文件开头
file.seek(0)

# 获取当前文件指针位置
position = file.tell()
print(position)

删除文件

要删除文件，可以使用os模块中的remove()函数。

import os
os.remove('example.txt')

文件和目录操作

Python的os和shutil模块提供了许多用于文件和目录操作的函数，如创建目录、复制文件、移动文件等。

import os
import shutil

# 创建目录
os.mkdir('new_directory')

# 复制文件
shutil.copy('source.txt', 'destination.txt')

# 移动文件
shutil.move('source.txt', 'new_directory/')

Python提供了丰富的文件操作功能，使得处理文件变得简单而高效。通过使用内置的open()函数、with语句以及os和shutil模块，可以轻松实现文件的读取、写入、删除和目录操作。这些功能是进行数据处理和系统管理时不可或缺的工具。

10.10 eval()函数

eval() 函数是一个非常强大的内置函数，它用于执行一个字符串表达式，并返回表达式的结果。

# 简单的表达式
result = eval('2 + 3')
print(result)  # 输出: 5

# 使用变量
x = 10
result = eval('x + 5')
print(result)  # 输出: 15

# 使用globals和locals参数
eval('print(x + y)', {'x': 5}, {'y': 10})
# 输出: 15