python AI应用开发编程实战 大模型实战模块相关基础（三）

模块基础讲解：

我们在对大模型开发的时候，会需要大理的模块，甚至是在接入gpt 的时候也是要安装他们的模块，并且在使用大模型接入前，我们要对企业数据预处理，或业务融合预外理，比如将公司数据整理成文档，我们需要大量的其它模块协作

，比如自动采集公司聊天保存，自动采集办公数据，文档识别  xml 数据格式处理，所以在之前我们先要了解模块相关知识，

 

在Python中，模块是用来组织代码的一种方式。它将一组相关的函数、类、变量等封装在一个文件中，可以被其他程序引用和重用。

模块的相关概念包括：

1. 导入模块：使用 ​import​语句导入一个已经存在的模块，可以通过模块名访问其中的函数、类、变量等。

2. 别名：可以使用 ​as​关键字给导入的模块设置一个别名，方便使用。例如：​import math as m​，可以通过 ​m.xxx​来访问math模块的函数或变量。

3. 导入特定内容：可以使用 ​from module_name import name1, name2​语句只导入模块中的某些函数、类或变量。只导入一部份，可以做到导入优化

4. 导入所有内容：可以使用 ​from module_name import *​语句导入模块中的所有函数、类和变量。但不建议频繁使用这种方式，因为容易引起命名冲突。

5.  模块搜索路径：Python解释器在导入模块时会按照一定的规则搜索模块所在的位置。可以使用 ​sys.path​查看当前的搜索路径。
   

   备注，用模块带星导入功能是加入内存，使用时不在加前缀，如果是用模块方式导入，要加模块名，为了命名空间混乱，建议导入模块名，这样一眼就看出来是那个模块的东西

• 使得它们可以直接在当前模块中使用，而无需通过 ​模块名.成员名​的方式来访问。需要注意的是，这种方式会容易引起命名空间的混乱，应尽量避免在生产环境中使用。

   

自定义一个模块的步骤如下：

1. 创建一个新的Python文件，命名为 ​module_name.py​，例如：​my_module.py​。

2. 在文件中定义函数、类、变量等需要封装的内容。

3. 在其他程序中通过 ​import my_module​或 ​from my_module import name​来导入你自定义的模块并使用其中的内容。

注意事项：

• 模块文件必须以 ​.py​为后缀。
• 模块名应具有描述性且避免与Python内置模块名冲突。
• 可以在同一个目录下创建多个模块文件，它们互相之间可以相互导入和调用。
• 可以将多个相关的模块放在同一个文件夹下，并通过导入文件夹名的方式来使用其中的模块。

以下示列，新建一个模块它有三个方法

# my_module.py
def greet(name):
    return f"Hello, {name}!"

def add(x, y):
    return x + y

def multiply(x, y):
    return x * y

attr1 = "Attribute 1"
attr2 = "Attribute 2"
attr3 = "Attribute 3"

　在需要使用这个文件进，只需要先导入模块名，然后在引用的地方加上模块名打点，然后给上方法名或属性

# main.py

import my_module

name = "Alice"
result = my_module.greet(name)
print(result)

sum_result = my_module.add(3, 5)
print(sum_result)

product_result = my_module.multiply(2, 4)
print(product_result)

print(my_module.attr1)
print(my_module.attr2)
print(my_module.attr3)

　　假设 我们的路径并不是在同一层文件的话，我们需要将其它路径的目录加入全局。

将 ​/path/to/module​目录添加到Python的模块搜索路径中。你可以通过在Python脚本中添加以下代码来实现：

　

import sys
sys.path.append('/path/to/module')

　2，然后就可以在另一个Python文件中导入并使用自定义模块了。示例代码如下：

# 导入自定义模块
import my_module

# 使用自定义模块中的函数和属性
name = "Bob"
result = my_module.greet(name)
print(result)
....................................................................................此处略

 命 名冲突：

如果使用导入模块中方法的方式导入，并且文件中存在同名的函数、变量或类等成员，会发生以下情况：
如果模块中的方法和当前文件中同名的方法在调用时不产生冲突，则会正常执行。在这种情况下，模块中的方法会覆盖当前文件中同名的方法，并且只能通过模块名来访问模块中的方法。
如果模块中的方法和当前文件中同名的方法在调用时产生冲突，则会导致命名冲突错误。Python解释器无法区分该调用的是哪一个方法，而会抛出 ​NameError​或 ​AttributeError​等异常。此时，需要通过修改方法名或者使用完整的模块名来避免冲突。或在导入时采用As 关健字重命名

　上面是导入模块，但是有时候新建一个包。然后导出的需求。这个时候其实就是在运行包下面那个init的文件，所以一个文件夹如果有--init-- 就代码这是一个包

假设你有一个名为 ​my_package​的包，其中包含两个文件：​module1.py​和 ​module2.py​。每个文件都有两个方法。

首先，确保正确组织你的项目结构如下：

my_package/
    __init__.py
    module1.py
    module2.py
main.py
​
然后，在 ​module1.py​中定义两个方法：

def greet():
    print("Hello from module1")

def add_numbers(a, b):
    return a + b

​
在 ​module2.py​中也定义两个方法：

def say_hello():
    print("Hello from module2")

def multiply_numbers(a, b):
    return a * b

​
接下来，在 ​main.py​中导入并使用 ​my_package​包中的方法。

from my_package import module1, module2

# 使用module1中的方法
module1.greet()
result = module1.add_numbers(5, 3)
print(result)

# 使用module2中的方法
module2.say_hello()
product = module2.multiply_numbers(4, 2)
print(product)
from my_package import module1, module2

　　random模块功能说明（随机模块）

　

random模块是Python中处理随机数的模块。它提供了各种生成随机数的函数和方法。

random.random()

生成一个范围在[0, 1)之间的随机浮点数。
random.randint(a, b)

生成一个指定范围内的整数，包括a和b。
参数a表示下限，参数b表示上限。
random.randrange([start], stop[, step])

在指定范围内按指定步长递增获取一个随机数。
参数start表示起始值，默认为0。
参数stop表示终止值（不包含）。
参数step表示步长，默认为1。
random.choice(sequence)

从序列中获取一个随机元素。
参数sequence表示一个有序类型，可以是列表、元组或字符串等。
random.sample(sequence, k)

从指定序列中随机获取指定数量的元素并返回一个新的列表。
参数sequence表示一个可迭代对象。
参数k表示要获取的元素数量。
下面是一些示例：

　　

 

import random

print(random.random())
print(random.randint(1, 7))
print(random.randrange(1, 10))
print(random.choice('liukuni'))
print(random.choice("学习Python"))
print(random.choice(["Good", "is", "a", "handsome", "boy"]))
print(random.choice(("Tuple", "List", "Dict")))
print(random.sample([1, 2, 3, 4, 5], 3))

模块time 功能说明

Python中的 ​time​模块提供了处理时间的函数，可以用于获取当前时间、日期、延时操作等。以下是 ​time​模块的一些常用功能和使用说明：

1. 获取当前时间戳：
   

   import time
   
   timestamp = time.time()  # 返回从1970年1月1日开始的秒数
   print(timestamp)

2 ：时间戳转换为时间元组：

timestamp = time.time()
time_tuple = time.localtime(timestamp)  # 时间戳转换为本地时间元组
print(time_tuple)

time_str = time.strftime("%Y-%m-%d %H:%M:%S", time_tuple)  # 将时间元组格式化为指定格式的字符串
print(time_str)

其他常用函数：
time.sleep(3) 延时  程序延时三秒
​​time.localtime()​：返回当前时间的时间元组。
​​time.mktime(time_tuple)​：将时间元组转换为时间戳。
​​time.gmtime()​：返回当前时间的格林尼治时间。
​​time.ctime()​：返回当前时间的字符串表示（类似asctime）。
​​time.clock()​：返回程序运行时间。
​​time.monotonic()​：返回系统钟的时间，不受系统时间调整影响。

　os模块

有些时候一些字符串需要转成对象，或对象转成字符串，比如一个对象不能直接写入文件的，需要转成字符串，读取的时候程序中如果要用到json  也需要转换一下，这时候会用到json  和  pickie 模块，请记录这二个模块，  只建议  dump 一次，也只建议能load 一次。

json & pickle 模块。用于序列化的两个模块，json，用于字符串 和 python数据类型间进行转换  但是对象中的对象如果二层，第二层的会是地址，json 处理不了，需要用到pickle，pickle，用于python特有的类型 和python的数据类间进行转换。并可以将子对象保存成一个地址，在使用这个子对象时候，只需要将以前的对象复制过来，就不会报错。否则还是运行不了。它只是起到了能将子对象保存为一个内存地址作用。它们功能一样，简单 的json  用json  如果json 有对象套对象，请用pickle

Json模块提供了四个功能:dumps、dump、loads、load

pickle模块提供了四个功能:dumps、dump、loads、load

第一步导入json      import json

将python对象转成json
data = {"name": "John", "age": 30, "city": "New York"}
json_data = json.dumps(data)
将JSON字符串转换回Python对象（解码）：
json_data = '{"name": "John", "age": 30, "city": "New York"}'
data = json.loads(json_data)
从文件读取JSON数据：
with open('data.json', 'r') as file:
    data = json.load(file)
将数据写入文件：
data = {"name": "John", "age": 30, "city": "New York"}
with open('data.json', 'w') as file:
    json.dump(data, file)

​​json.dump()​ 是 json 模块中的一个方法，用于将 Python 对象转换为 JSON 格式并将其写入文件。具体来说，​json.dump(obj, fp)​ 接受两个参数：

 

• ​​obj​：要序列化为 JSON 格式并写入文件的 Python 对象。
• ​​fp​：一个以写模式打开的文件对象，数据将被序列化为 JSON 格式并写入此文件。
• 参考示例：
  

  import json

  data = {"name": "John", "age": 30, "city": "New York"}

  with open('data.json', 'w') as file:
  json.dump(data, file)   ##，Python 字典对象 ​data​ 被转换为 JSON 格式，并通过 ​json.dump()​ 方法写入到名为 ​data.json​ 的文件中。

shelve 模块   　　

　

​​shelve​ 模块是 Python 中用于持久化对象的模块。它提供了一种将 Python 对象存储在磁盘上，并能够在需要时重新加载的方式 ，这个模块就是简单的k,v 健值对方式保存数据，个人理解为保存python字典格式时用。使用 ​shelve​ 模块，我们先创建一个所谓的 shelve 对象，它类似于一个字典，可以将任意可被 pickle 序列化的 Python 对象存储为键值对。这样，我们就可以随时从磁盘中检索这些对象，而不需要每次都从头开始创建它们。

以下是一个简单的示例，展示了如何使用 ​shelve​ 模块：

import shelve
# 创建或打开一个 shelve 文件
with shelve.open('data') as db:
    # 存储数据
    db['name'] = 'John Doe'
    db['age'] = 30
    
# 再次打开 shelve 文件
with shelve.open('data') as db:
    # 获取数据
    name = db['name']
    age = db['age']
    
    # 打印数据
    print(name, age)

　　以下代码来自老男孩 课堂截图：

python  操作xml      xml 是一种精典的数据格式，可以描述很多属性，但是这些年了json 这种精单的描述格式方法，就多了一程数据格式选择，现在安卓开发，java web 开发中还会用到这些格式，我们今天讨论的是对这程格式数的的查增删改，虽然这种场景用得不多，查可能多一些，但是作为一个学习者，了解一下是必须要的，

以下是一个完整的xml 格式

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>5990</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

　　将xml代码转换为json格式的方法:

我们可以使用Python中的 ​xmltodict​库来将XML格式转换为JSON格式。以下是一个示例代码，演示了如何将你提供的XML数据转换为JSON数据：
首先，安装 ​xmltodict​ 库：
pip install xmltodict
pip install xmltodict​
然后，使用以下Python代码进行转换：
import xmltodict
import json
xml_data = """
<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>5990</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>
"""

json_data = json.dumps(xmltodict.parse(xml_data), indent=4)
print(json_data)
import xmltodict
import json

xml_data = """
<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>5990</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>
"""

json_data = json.dumps(xmltodict.parse(xml_data), indent=4)
print(json_data)

python 读取xml 文件

 其它方法可以点开下面的文容，现在文本也经很长了，不好滚动了、 

当使用Python处理XML数据时，通常会使用 ​xml.etree.ElementTree​模块。以下是一个简单示例演示如何使用Python来增删改查XML数据：

首先，假设有一个名为 ​example.xml​ 的文件，内容如下：

<data>
    <person>
        <name gender="male">John Doe</name>
        <age>30</age>
        <city>New York</city>
    </person>
</data>
<data>
    <person>
        <name gender="male">John Doe</name>
        <age>30</age>
        <city>New York</city>
    </person>
</data>
​
接下来，我们可以通过下面的Python代码来进行操作：

读取XML数据
import xml.etree.ElementTree as ET

tree = ET.parse('example.xml')
root = tree.getroot()
import xml.etree.ElementTree as ET

tree = ET.parse('example.xml')
root = tree.getroot()
​
查找数据
# 查找名为 city 的元素
city_element = root.find('.//city')
print(city_element.text)

# 查找包含属性 gender='male' 的 name 元素
male_name = root.find(".//name[@gender='male']")
print(male_name.text)
# 查找名为 city 的元素
city_element = root.find('.//city')
print(city_element.text)

# 查找包含属性 gender='male' 的 name 元素
male_name = root.find(".//name[@gender='male']")
print(male_name.text)
​
修改数据
# 修改 John Doe 的值为 Jane Smith
male_name.text = 'Jane Smith'
tree.write('example.xml')  # 保存修改后的结果
# 修改 John Doe 的值为 Jane Smith
male_name.text = 'Jane Smith'
tree.write('example.xml')  # 保存修改后的结果
​
添加数据
# 添加新的 person 元素
new_person = ET.Element('person')
name = ET.Element('name', {'gender': 'female'})
name.text = 'Alice'
age = ET.Element('age')
age.text = '25'
city = ET.Element('city')
city.text = 'London'

new_person.append(name)
new_person.append(age)
new_person.append(city)

root.append(new_person)
tree.write('example.xml')  # 保存添加后的结果
# 添加新的 person 元素
new_person = ET.Element('person')
name = ET.Element('name', {'gender': 'female'})
name.text = 'Alice'
age = ET.Element('age')
age.text = '25'
city = ET.Element('city')
city.text = 'London'

new_person.append(name)
new_person.append(age)
new_person.append(city)

root.append(new_person)
tree.write('example.xml')  # 保存添加后的结果
​
删除数据
# 删除指定条件下的元素
for person in root.findall('person'):
    name = person.find('name')
    if name.text == 'Alice':
        root.remove(person)

tree.write('example.xml')  # 保存删除后的结果
# 删除指定条件下的元素
for person in root.findall('person'):
    name = person.find('name')
    if name.text == 'Alice':
        root.remove(person)

tree.write('example.xml')  # 保存删除后的结果