【原创】异常和第三方包导入讲解

da11

# 异常和第三方包导入讲解

# import方式导入Time模块
#import time

# from方式导入time模块的sleep功能
#from time import sleep

# from 模块名 import *方式导入，这时，即可使用time的所有功能
#from time import *

# 通过别名import方式导入Time模块
import time as MyTime

# 通过别名from方式导入Time.sleep功能
from time import sleep as MySleep

# 导入自定义模块
from MyModule import *

# 使用import直接导入包里面的模块
import TestPackage.Package1
import TestPackage.Package2

# 使用from导入包里面的模块--方法1
from TestPackage import Package1 as newpackage1
from TestPackage import Package2 as newpackage2

# 使用from 包名.模块名 导入模块里面的功能
from TestPackage.Package1 import printadd as padd
from TestPackage.Package2 import printrm as prm

from TestPackage import *

# 异常和包综合案例
from my_utils import str_util
from my_utils import file_util

"""
为什么要捕获异常：
提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

捕获常规异常：
基本语法：
try：
    可能发生错误的代码
except：
    如果出现异常执行的代码

捕获全部异常：
try:
    可能发生错误的代码
except Exception as e:
    如果出现异常执行的代码

# 和上方的捕获常规异常其实是一样的效果！

捕获指定的异常：
基本语法：
try：
    能发生错误的代码
except 异常错误类型 as e:
    如果出现异常执行的代码

# 注意：
    · 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
    · 一般try下方只放一行尝试执行的代码。

捕获多个异常：
当捕获多个异常时，可以把要捕获的异常类型的名字，放到except后，并使用元组的方式进行书写。
try:
    能发生错误的代码
except (异常类型1,异常类型2):
    如果出现异常执行的代码

异常else（可选）
异常else表示的是如果没有异常要执行的代码。

异常的finally（可选）
finally表示的是无论是否异常都要执行的代码，例如关闭文件

异常是具有传递性的



Python的模块：
Python模块（Module），是一个Python文件，以.py结尾，模块能定义函数，类和变量，模块里也能包含可执行的代码。

模块的作用：Python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块。
我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能。
大白话：模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用（导入模块去使用）

模块的导入方式：
模块在使用前需要先导入，导入的语法如下：
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]

常用的组合形式如：
· import 模块名
· from 模块名 import 类、变量、方法等
· from 模块名 import *
· import 模块名 as 别名
· from 模块名 import 功能名 as 别名

import模块名使用方式：
import 模块名
import 模块名1,模块名2

模块名.功能名()

from 模块名 import 功能名
基本语法：
from 模块名 import 功能名
功能名()
# 相当于我直接导入模块里面的单独功能直接使用。

from 模块名 import *
基本语法：
from 模块名 import *
功能名()

as定义别名
基本语法：
# 模块定义别名
import 模块名 as 别名

# 功能定义别名
from 模块名 import 功能 as 别名

Python中已经帮我们实现了很多的模块，不过有时候我们需要一些个性化的模块，这里就可以通过自定义模块实现，也就是自己制作一个模块

注意：
· 每个python文件都可以作为一个模块，模块的名字就是文件的名字。也就是说自定义模块名必须要符合标识符命名规则
· 当导入多个模块的时候，且模块内有同名功能，当调用这个同名功能的时候，调用到的是后面导入的模块的功能，前面的功能将会被覆盖掉，如果出现这种情况，建议使用别名功能！

=======================================================================

什么是python包
从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__.py文件，该文件夹可用于包含多个模块文件。
从逻辑上看，包的本质依然是模块。



包的作用：
当我们的模块文件越来越多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块。



导入包：
方法一：
import 包名.模块名

方式二：
from 包名 import 模块名

什么是第三方包：
包可以包含一堆的python模块，而每个模块又内含许多的功能。
所以，我们可以认为：一个包，就是一堆同类型功能的集合体。



在python程序的生态中，有许多非常多的第三方包（非python官方），可以极大的帮助我们提高开发效率，如：
· 科学计算中常用的：numpy包
· 数据分析中常用的：pandas包
· 大数据计算中常用的：pyspark、apache-flink包
· 图形可视化常用的：matplotlib、pyecharts
· 人工智能常用的：tensorflow
等
这些第三方的包，极大的丰富python的生态，提高了开发效率。
但是由于是第三方，所以python没有内置，所以我们需要安装它们才可以导入使用哦。

使用命令行安装第三方包--pip
第三方包的安装非常简单，我们只需要使用python内置的pip程序即可。

打开命令行，直接输入
pip install 包名称
即可通过网络快速安装第三方包
# pip安装包切换国内源：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

"""

# 捕获常规异常的案例
try:
    with open("D:/test.txt","r",encoding="UTF-8") as f:
        print(f.readline())
except:
    print("程序错误，只读文件不存在")

# 捕获指定的变量类型异常，e就是异常的对象，也可以定义其他别名
try:
    print(sjdhjashj)
except NameError as e:
    print(f"捕获到变量类型错误: {e}")

# 捕获多个异常
try:
    print(a=1/0)
except (NameError,ZeroDivisionError) as e1:
    print(e1)

# 异常else 异常else表示的是如果没有异常要执行的代码。
sjdhjashj=1
try:
    print(sjdhjashj)
except NameError as e:
    print(f"捕获到变量类型错误: {e}")
else:
    print("try捕获异常模块没有捕获到异常")

#  finally表示的是无论是否异常都要执行的代码，例如关闭文件
try:
    f_work1 = open("D:/test.txt", "r", encoding="UTF-8")
except Exception as e:
    print(f"捕获到错误: {e}")
    f_work1 = open("F:/MyFile.txt", "w", encoding="UTF-8")
finally:
    f_work1.close()

def fun1():
    print(1/0)

try:
    fun1()
except Exception as e:
    print("异常的传递性练习，异常类型: ",e)

print("---------------------------------------------------异常讲解完成")

print("Time模块开始执行")
#time.sleep(1)                                  # 通过模块名.功能名 就可以使用模块内部的全部功能了(类、函数、变量)--import调用方式
#sleep(1)                                       # from 导入模块单个功能方式
MyTime.sleep(0.5)                               # import 别名导入的方式
MySleep(0.5)                                    # from 别名导入的方式
printadd(3,3)                      # 执行自定义模块的方法
# printup(2,3)                                  # 导入的模块文件中'__all__'没有指定printup元素！
TestPackage.Package1.printadd(1,2)        # 通过import方法导入，调用Python包里面的模块、里面的功能
TestPackage.Package2.printrm(3,2)         # 通过import方法导入，调用Python包里面的模块、里面的功能
newpackage1.printadd(3,2)                 # 通过from方法导入并起别名，调用Python包里面的模块、里面的功能
newpackage2.printrm(6,1)                  # 通过from方法导入并起别名，调用Python包里面的模块、里面的功能
padd(3,2)                                 # 通过from 包名.模块名 方法导入功能并起别名，直接使用对应模块功能
prm(6,1)                                  # 通过from 包名.模块名 方法导入功能并起别名，直接使用对应模块功能
# TestPackage.Package2                          # 包的__init__控制只能允许导入Package1

# 异常、包、数据容器综合案例



print(str_util.substr(str_util.str_reverse("~啊明聪好你"),0,5))
file_util.print_file_info("F:/123.txt")
file_util.append_to_file("F:/123.txt",str_util.substr(str_util.str_reverse("~啊明聪好你"),0,5))
print("Time模块结束")






# 下方是自定义包

# TestPackage.__init__.py

# 创建包会默认创建本文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹
# 和模块的__all__控制一样，控制import *能够导入的内容，不过这里列表的元素使用的是模块名字，而不是功能名
# 注意：此变量控制的仅仅针对是from xx import * 这种方式！！
__all__= ['Package1']




# TestPackage.Package1.py

def printadd(a, b):
    print(a + b)


# TestPackage.Package2.py


def printrm(a, b):
    print(a - b)






# 综合练习案例包--my_utils
# my_utils.__init__.py
# 这个文件是空的

# my_utils.str_util.py


"""
字符串相关的工具模块
"""

def str_reverse(s):
    """
     接受传入字符串，将字符串反转返回
     这个功能是底层写法，更简便的写法应该是 return s[::-1]
    Args:
        s: 接收的字符串变量

    Returns:返回反转后的变量

    """
    i=len(s)
    str_cache=""
    while i>0:
        str_cache = str_cache + s[i-1]
        i = i-1

    return str_cache

def substr(s,x,y):
    """
     按照下标x和y，对字符串进行切片
    Args:
        s: 接收的字符串变量
        x: 开始下标
        y: 结束下标

    Returns:返回切片后的变量

    """
    return s[x:y]

if __name__== "__main__":
    print(str_reverse("hai"))
    print(substr("hai",0,2))

# my_utils.file_util.py

"""
文件相关的工具模块
"""

def print_file_info(file_name):
    """
     已只读模式打开文件功能，如果文件不存在，则手动接收异常，并创建对应的文件对象，最后关闭文件
    Args:
        file_name: 文件路径

    """
    f = None

    try:
        f = open(file_name,"r",encoding="UTF-8")
        print(f.read())
    except Exception as e:
        print(f"文件不存在:{e}")
        f = open(file_name, "w", encoding="UTF-8")
    finally:
        f.close()

def append_to_file(file_name,date):
    """
     追加文件内容
    Args:
        file_name: 文件路径
        date: 要追加的数据

    Returns:

    """
    f = open(file_name,"a",encoding="UTF-8")
    f.write(date)
    f.close()