1.python包和模块

当使用Python编程时，包（Packages）和模块（Modules）是两个关键的概念，它们有助于组织、管理和复用代码。

1.模块

一个.py 文件就是一个模块

模块是含有一系列数据，函数，类等的程序

• 作用

  把相关功能的函数等放在一起有利于管理，有利于多人合作开发

• 模块的分类

  1. 内置模块（在python3 程序内部，可以直接使用）

  2. 标准库模块(在python3 安装完后就可以使用的 )

  3. 第三方模块（需要下载安装后才能使用）

  4. 自定义模块(用户自己编写)

  5. 模块名如果要给别的程序导入，则模块名必须是 标识符

代码示例： 

# demo01.py
def add(a, b):
    return a + b

调用：

# demo02.py
import demo01
c = demo01.add(2,3)
print(c)

2.导入模块 

• 语法

1. import 模块名  [as 模块新名字1]

   导入一个模块到当前程序

2. from 模块名 import 模块属性名 [as 属性新名]

   导入一个模块内部的部分属性到当前程序

3. from 模块名 import *

   导入一个模块内部的全部属性到当前程序 

import mymod
mymod.mysum(10)   # 要加模块名

from mymod import get_name
print(get_name())   # 调用get_name 时不需要加 "模块名."

from mymod import *   
print(get_name())
print(name2)

• 模块的内部属性

  __file__  绑定模块的路径
  __name__  绑定模块的名称
        如果是主模块（首先启动的模块）则绑定 '__main__'
        如果不是主模块则 绑定 xxx.py 中的 xxx 这个模块名

• 模块的 __name__ 属性

  每个.py 模块文件都会有 __name__ 属性

  1. 当一个模块是最先运行的模块，则这个模块是主模块, 主模块的__name__ 属性绑定'__main__' 字符串

  2. 如果一个模块是用 三种 import 语句中的一个导入的模块，则此模块不是主模块。

     不是主模块的模块的 __name__ 绑定的 模块名

• 主模块 (__name__ == '__main__')： 当一个模块是直接运行的，即不是通过 import 语句导入的，那么它的 __name__ 属性会被赋值为 '__main__'。例如：

# main_module.py
if __name__ == "__main__":
    print("This is the main module.")

如果运行 python main_module.py，输出将是：

This is the main module.

• 被导入的模块 (__name__ == 模块名)： 当一个模块被导入到另一个模块中时，它的 __name__ 属性会被赋值为它的模块名。例如：

# imported_module.py
print(f"This module's name is {__name__}") # 被其他模块导入时会自动运行

# main_module.py
import imported_module

if __name__ == "__main__":
    print("This is the main module.")

 如果运行 python main_module.py，输出将是：

This module's name is imported_module
This is the main module.

这里 imported_module.py 被导入到 main_module.py 中，所以它的 __name__ 是 'imported_module'，而 main_module.py 是直接运行的，所以它的 __name__ 是 '__main__'。  

python 的第三方模块

PyPI · The Python Package Index

• 使用导入的模块中的函数、变量等，可以通过模块名或从语句中导入的名称来访问。

3.Python常用的内建模块

1.random模块

导入random库

import random

常用API：
 

import random
# 随机生成0-1之间的随机数
d = random.random()

# 从指定的序列中随机选择一个元素
s = random.choice("abcd")

print(s,d)

# 将数组的顺序随机打乱
list1 = [1, 2, 3, 4, 5, 6, 7]
random.shuffle(list1)
print(list1)

# 随机生成一个实数 可以通过a,b指定实数的取值范围
x = random.uniform(0,10)
print(x)

# 随机生成一个指定范围的整数
y = random.randint(0, 100)

2.os 模块

os模块是Python标准库中的一部分，提供了一种与操作系统进行交互的方法。主要功能包括文件和目录的操作、路径处理、进程管理等。

导入os库：

import os

# 打印工作目录
work_dir = os.getcwd()
print(work_dir)

# mkdir 创建目录 只能创建一层目录

# os.mkdir("C:\\Users\\Loneliness\\PycharmProjects\\Python_project\\python三大库\\python_demo\\test")
# 遍历指定目录下所有的目录和文件 列出目录和文件名
lista = os.listdir("C:\\Users\\Loneliness\\PycharmProjects\\Python_project\\python三大库\\python_demo")
print(lista)

# 通过删除指定的目录 指定的目录必须是空目录
# os.removedirs("C:\\Users\\Loneliness\\PycharmProjects\\Python_project\\python三大库\\python_demo\\test")

# remove 删除指定的文件

# os.path.split 将文件路径和文件名切割 得到文件路径和文件名
lis = os.path.split("C:\\Users\\Loneliness\\PycharmProjects\\Python_project\\python三大库\\python_demo")
print(lis,111)

# 判断目录或文件是否存在
print(os.path.exists("C:\\Users\\Loneliness\\PycharmProjects\\Python_project\\python三大库\\python_demo"))
# 判断指定路径是否是文件
print(os.path.isdir("C:\\Users\\Loneliness\\PycharmProjects\\Python_project\\python三大库\\python_demo"))

4.包

1.包的定义和作用 

定义

• 包是将模块以文件夹的组织形式进行分组管理的方法，以便更好地组织和管理相关模块。

• 包是一个包含一个特殊的__init__.py文件的目录，这个文件可以为空，但必须存在，以标识目录为Python包。

• 包可以包含子包（子目录）和模块，可以使用点表示法来导入。

作用

• 将一系列模块进行分类管理,有利于防止命名冲突

• 可以在需要时加载一个或部分模块而不是全部模块

2.导入包和子包

• 使用import关键字可以导入包和子包，以访问其中的模块和内容。

   # 同模块的导入规则
    import 包名 [as 包别名]
    import  包名.模块名 [as 模块新名]
    import  包名.子包名.模块名 [as 模块新名]
    
    from 包名 import 模块名 [as 模块新名]
    from 包名.子包名 import 模块名 [as 模块新名]
    from 包名.子包名.模块名 import 属性名 [as 属性新名]
    
    # 导入包内的所有子包和模块
    from 包名 import *
    from 包名.模块名 import *

3.使用包和子包

• 使用导入的包和模块的内容，可以通过包名和点表示法来访问。

# 使用包中的模块
import pandas as pd
data_frame = pd.DataFrame()

# 使用子包中的模块
from tensorflow.keras.layers import Dense

4.__init__.py文件

__init__.py 文件的主要作用是用于初始化Python包（package）或模块（module），它可以实现以下功能：

1. 标识包目录： 告诉Python解释器所在的目录应被视为一个包或包含模块的包。没有这个文件，目录可能不会被正确识别为包，导致无法导入包内的模块。

2. 执行初始化代码： 可以包含任何Python代码，通常用于执行包的初始化操作，如变量初始化、导入模块、设定包的属性等。这些代码在包被导入时会被执行。

3. 控制包的导入行为： 通过定义 __all__ 变量，可以明确指定哪些模块可以被从包中导入，从而限制包的公开接口，防止不需要的模块被导入。

4. 提供包级别的命名空间： __init__.py 中定义的变量和函数可以在包的其他模块中共享，提供了一个包级别的命名空间，允许模块之间共享数据和功能。

5. 批量导入模块： 可以在 __init__.py 文件中批量导入系统模块或其他模块，以便在包被导入时，这些模块可以更方便地使用。

5.第三方包

Python第三方包是由Python社区开发的，可用于扩展Python功能和解决各种问题的软件包。这些包提供了各种各样的功能，包括数据分析、机器学习、网络编程、Web开发、图形处理、自然语言处理等。

1.安装和使用

1. 使用pip：pip是Python的包管理工具，用于安装、升级和管理第三方包。确保你的Python安装中包含了pip。

2. 安装第三方包：

   • 使用pip安装包：在命令行中运行以下命令来安装包，将"package-name"替换为要安装的包的名称。

     pip install package-name

   • 安装特定版本的包：如果你需要安装特定版本的包，可以使用以下命令：

     pip install package-name==version

   • 通过镜像安装，可以使用以下命令：

     pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package1 package2 package3 ...

   • 从requirements文件安装：你可以将要安装的包及其版本记录在一个文本文件中，通常命名为requirements.txt，然后运行以下命令安装其中列出的所有包：

     pip install -r requirements.txt

3. 导入包：在Python脚本或交互式环境中，使用import语句导入已安装的包，以便在代码中使用它们。

   import package_name

4. 使用包：每个第三方包都有不同的用法和功能，通常伴随着官方文档和示例代码。你可以查阅官方文档，或者使用help()函数来了解包的功能和方法。示例：

   import package_name
   help(package_name)

5. 更新和卸载包：

   • 更新包：使用以下命令来更新已安装的包：

     pip install --upgrade package-name

   • 卸载包：如果你想卸载包，可以使用以下命令：

     pip uninstall package-name

2.依赖清单

可以使用pipreqs来维护requirements.txt文件，以便轻松地重建环境。

pipreqs是一个用于管理Python项目依赖清单的工具，它会自动分析项目代码，并生成requirements.txt文件，列出项目所需的所有依赖包及其版本。以下是使用pipreqs管理依赖清单的步骤：

安装pipreqs：

如果你还没有安装pipreqs，可以使用pip安装它(比较慢,可能会丢包)：

pip install pipreqs   

在项目目录中运行pipreqs：

进入你的项目目录，然后运行以下命令：

pipreqs .

这会分析项目代码，并在当前目录下生成一个名为requirements.txt的文件，其中包含了项目所需的所有依赖包及其版本。

如果遇到编码错误UnicodeDecodeError，则将指定编码为utf8：

pipreqs ./ --encoding=utf8
pipreqs ./ --encoding=gbk
pipreqs ./ --encoding='iso-8859-1'

查看生成的requirements.txt文件：

打开requirements.txt文件，你将看到列出的依赖包及其版本，类似于以下内容：

package1==1.0.0
package2==2.1.3
...

选择是否要修改requirements.txt文件：

pipreqs生成的requirements.txt文件可能包含一些不必要的依赖，或者可能需要手动指定特定版本。

你可以编辑requirements.txt文件，根据项目的需要添加、删除或修改依赖项。

1. 安装依赖：

   一旦你准备好了requirements.txt文件，你可以使用pip来安装项目的依赖：

   pip install -r requirements.txt

2. 定期更新依赖：

   定期使用pipreqs重新生成requirements.txt文件，以确保依赖清单保持最新。你可以使用以下命令：

   pipreqs .

pipreqs是一个方便的工具，它可以帮助你自动创建和维护项目的依赖清单。不过，需要记住，生成的依赖清单可能包含一些不必要的依赖，因此你应该仔细检查和编辑requirements.txt文件以确保它反映了项目的真实需求。

Python的包和模块是组织、管理和重用代码的重要工具。它们有助于将代码划分为可管理的单元，提高了代码的可读性和可维护性。通过模块和包，你可以更有效地组织项目，减少命名冲突，以及在不同项目之间重用代码，从而更轻松地进行Python编程。通过上述参考案例，你可以更好地理解如何在实际项目中应用这些概念。

2.Python异常

• 作用

  用作信号通知，通知上层调用者有错误产生需要处理

1.try语句

语法：

try:
    可能发生异常的语句块
except 错误类型1 [as 变量名1]:
    异常处理语句块1
except 错误类型2 [as 变量名2]:
    异常处理语句块2
...
except 错误类型n [as 变量名n]:
    异常处理语句块n
except:
    异常处理语句块other
else:
    未发生异常的语句
finally:
    最终的处理语句

• 作用

  尝试捕获异常，得到异常通知，将程序由异常状态变为正常状态

• 说明

  except 子句可以有 1个或多个

  except: 不给错误类型，可以匹配全部的错误类型

  else 子句里的语句会在 没有错误发生时执行，当处于异常时不执行

  finally 子句里的语句，无论何时都执行

• try 不会判断代码是否出现异常

• 当代码出现异常时通过except捕获

• 先执行再捕获

def exception_test():
    

    try:
        b = 1 / 0
    except ZeroDivisionError as e:
        print(f"除数不能为0:{e}")
    finally:
        print("run finally")

2.raise语句 

语法：

raise 异常类型
或
raise 异常对象

作用

• 抛出一个错误，让程序进入异常状态

• 发送错误通知给调用者

说明：

• raise 在代码出现异常的时候 向外抛异常信息
• 先判断代码是否会出现异常
• 如果会出现则向外抛异常
• 三思而后行

def raise_test(a, b):
    if b == 0:
        raise Exception("除数不能为0")
    return a / b

3.Python全部错误类型

3.Python文件操作

文件操作是Python中常见的任务之一，用于创建、读取、写入和管理文件。

1.打开文件

要执行文件操作，首先需要打开文件。使用open()函数可以打开文件，指定文件名以及打开模式（读取、写入、追加等）。

2.读取文件 

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

3.写入文件

要写入文件，需要打开文件以写入模式（'w'），然后使用write()方法。

4.关闭文件

完成文件操作后，应该关闭文件，以释放资源和确保文件的完整性。

5.使用with

更安全的方法是使用with语句，它会自动关闭文件。

with open("example.txt", "r") as file:
    content = file.read()
    # 文件自动关闭

6.检查是否存在 

可以使用os.path.exists()来检查文件是否存在。

import os
​
if os.path.exists("example.txt"):
   print("文件存在")

7.处理异常

在文件操作中，可能会出现各种异常情况，例如文件不存在或没有权限。在文件操作中捕获这些异常是个好习惯。

try:
   with open("example.txt", "r") as file:
       content = file.read()
except FileNotFoundError:
   print("文件不存在")
except Exception as e:
   print(f"发生错误：{e}")

这些是文件操作的一些常见思路和示例代码。请根据你的具体需求和场景来调整代码。在进行文件操作时，要确保小心处理文件，以避免意外数据损坏或文件损坏。

除了打开、读取和写入文件之外，还有一些其他常见的文件操作，如复制、删除和改变文件名。

8.复制文件

要复制文件，你可以使用shutil模块的copy方法。

import shutil

source_file = "source.txt"
destination_file = "destination.txt"

shutil.copy(source_file, destination_file)

9.删除文件

10.修改名称

见os 

def file_demo():
    f = open("test.txt","r+",encoding="UTF-8")
    print(f)
    # print(f.read())
    line = f.readline()
    while line:
        print(line)
        line = f.readline()

    s = "123"
    f.write(s)
    f.close()

    with open("requirements.txt","r") as f1:
        print(f1.read())

    shutil.copy("test.txt", "test1.txt")
    os.remove("test1.txt")

 4.Python JSON 数据解析

JSON（JavaScript Object Notation）是一种轻量级数据交换格式，它易于阅读和编写，同时也易于机器解析和生成。Python提供了内置的JSON模块，用于处理JSON数据。

导入模块：

import json

1.序列化 

dumps:json序列化 转换为json字符串

2.反序列化

loads:将json字符串转换为字典对象

3.对象存文件

dump:将json存入文件 文件需要先用open打开 生成一个file对象

4.从文件中取出

load:从文件中读取json 文件需要先打开

5.嵌套JSON数据

如果JSON数据包含嵌套结构，您可以使用递归来访

问和修改其中的值。

JSON可以包含列表，可以使用索引来访问列表元素。

JSON允许表示空值（null），在Python中，它通常转换为None。

6.字典和JSON格式不同之处

1. 数据类型限制：

   • JSON：支持的数据类型包括对象（类似于字典）、数组（类似于列表）、字符串、数字、布尔值和 null。JSON 不支持 Python 特有的数据类型如 tuple、set、bytes 等。

   • Python 字典：可以包含多种 Python 特有的数据类型，比如 tuple、set、bytes 等。

2. 格式要求：

   • JSON：数据必须以字符串的形式表示，键必须是双引号括起来的字符串，值可以是字符串、数字、布尔值、数组、对象或 null。

   • Python 字典：键可以是任意不可变的类型（如字符串、数字、元组），值可以是任意类型。键通常用单引号或双引号括起来，但 Python 允许在字典中使用不加引号的键。

def json_demo():
    # json是由键值对组成的 但是key必须为字符串类型
    # value 可以是任意类型
    # json一旦生成json字符串后不能改
    # 如果要修改先反序列化(loads)成字典对象进行修改
    # json结构 以{}作为开头结尾 其中的数据格式为键值对

    data = {"name": "zs", "age": 18, "address": "四川", }
    # dumps:json序列化 转换为json字符串
    # dump:将json存入文件 文件需要先用open打开 生成一个file对象
    json_str = json.dumps(data)
    print(json_str)
    json.dump(data, open("test.json","w"))

    # loads:将json字符串转换为字典对象
    # load:从文件中读取json 文件需要先打开

    # dump和load是做json文件的读写
    # dumps和loads是做json的序列化和反序列化
    data1 = json.loads(json_str)
    with open("test.json","r") as f:
        data2 = json.load(f)
        print(data2)
    print(data1)

    data3 = {
        "name": "Jack",
        "info": {
            "age": 18,
            "address": "重庆"
        }
    }
    name = data3["name"]
    print(name)
    age = data3["info"]["age"]
    print(age)

    data4 = {
        "name": 'Tom',
        'Score': [20, 30, 40, 50],
        "info": {
            "hobby": ["basketball", "football"]
        }
    }
    score = data4["Score"][2]
    print(score)
    hobby = data4["info"]["hobby"][0]
    print(hobby)

    # 如果定义json某个字段为空值
    # 在python中使用None 在python中使用None
    # 将json转换为字符串后该空值(None) 转化为null
    data5 = {
        "name": "Sum",
        "Score": None
    }
    js = json.dumps(data5)
    print(js)