Day10-包模块异常

最新推荐文章于 2024-07-29 21:16:24 发布

李好秀

最新推荐文章于 2024-07-29 21:16:24 发布

阅读量224

点赞数

分类专栏： Python基础 python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_52426915/article/details/128753549

版权

python 同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

Python基础

21 篇文章 0 订阅

订阅专栏

0-1 变量和多态

'''
变量多态

python 中的变量（标识符），的类型是根据所代表的对象，进行自动推导得到的

'''

n = 1
print(type(n))

n = 3.14
print(type(n))

n = True
print(type(n))


def show():
    print('show')


n = show
n()
print(type(n))

0-2 类方法

定义格式:
@classmethod
def 方法名(cls,...):
	pass
	
调用格式:
类对象.类方法名

注意:
	在类方法中,不能使用self
	但是可以使用 cls,该参数用来表示 当前类对象,这个参数也是自动传递的\
	
应用场景:
一般在设计类时,如果有类方法,该类一般不会去实例对象,直接使用类对象来操作(比如:数学函数类)
一役用来定义工具类使用

Math.max(1,2)

'''类方法'''


class MyMath(object):
    # 定义一个类属性
    n = 999

    # 标准格式
    @classmethod  # 这是一个装饰 器，用来表示下面的方法是一个类方法
    def sum(cls, *args):
        print(cls.n)
        m = 0
        for i in args:
            m += i
        return m

    # @classmethod 是一个装饰 器，用来修饰一个方法成为类方法，当在执行该 类方法时，解释 会自动 将类对象传递到参数 cls中
    @classmethod
    def show(cls):
        print('show class method')


# 执行类方法
print(MyMath.sum(1, 2, 3, 4, 5))

mm = MyMath()
print(mm.sum(1, 2, 3, 4, 5))

MyMath.show()

0-3 静态方法

格式:
@staticmethod
def 方法名(参数列表....):
	pass

'''
静态方法
'''


# 设计 一个编码工具类
class EncodeUtil(object):
    n = 1

    # 编码方法
    @staticmethod
    def encode_data(data, format):
        print(f'对数据 {data} 使用 {format} 格式 进行了编码')

    # 解码方法
    @staticmethod
    def decode_data(data, format):
        print(EncodeUtil.n)
        print(f'对数据 {data} 使用 {format} 格式 进行了解编码')


# 测试
# eu = EncodeUtil()
# eu.encode_data('hello','utf-8')


EncodeUtil.encode_data('Hello', 'utf-8')
EncodeUtil.decode_data("hello", 'GBK')

调用方式:
同类方法
类对象.静态方法名()

设计目的:
静态方法实际上就是放到类当中的一堆普通函数

作用:
静态方法同类方法相似,也是在不需要实例对象产生的条件下,可以使用静态方法来实现
一般这两种方法,都是用在工具类的实现上.
通过类,将一系列的功能方法进行整合到一起.

# 实例方法,必须通过实例对象调用执行,(第一个参数是当前调用该方法的实例)

# 类方法, 当不需要产生实例对象时,可以使用类方法来实现相应的代码功能,类方法可以直接
使用类对象来调用,类方法的第一个参数是 cls,用来接收当前类对象,通过个参数,
可以各个类方法中进行共享数据

# 静态方法, 作用同类方法相似,但是静态方法不接收任何默认参数(实例对象或类对象),静态方法
其实就是将一些相关联的普通方法使用类进行整合.

类方法和静态方法,一般在使用时,大多数用来实现工具类.

1. 模块介绍

在Python中,一个.py文件就是一个模块

在Python,万物皆对象,模块也不例外

通过模块,可以有效的组织代码结构,让代码结构更加清晰

但是,初期可能让大家逻辑上更加混乱

2. 导入模块

导入模块是指:
在一个.py文件中,使用另外一个.py文件时,需要将这个文件导入
在一个模块中,使用另外一个模块时,需要将这个模块导入

import os
import time
import random
import sys 
import functools

'''自定义模块'''

n = 1


def show():
    print('show')


class Cat(object):
    def show(self):
        print('Cat_show')


print(n)
show()
tom = Cat()
tom.show()

'''
系统模块的使用
'''

import os
import time
import sys

print(os.getcwd())

# sleep 函数是一个time模块中定义的函数，用来让程序休眠，这是一个阻塞函数
time.sleep(3)
print('over')

# sys.argv 变量用来接收命令行参数
print(sys.argv)

方式一：
	import 模块名  (掌握)

方式二：
  	from 模块名 import 成员名 (掌握)

	特例：
	from 模块名 import * (掌握)

别名：
	import 模块名 as 别名
	from 模块名 import 成员名 as 成员别名

''''自定义模块'''

n = 1

def show():
    print('show')


class Cat(object):
    def show(self):
        print('Cat_show')

# 方式一
# import p_05模块
#
# # 使用时，需要使用模块对象.成员
# print(p_05模块.n)
#
# p_05模块.show()
#
# tom = p_05模块.Cat()
# tom.show()

# 方式一的别名形式
# 别名就是为复杂的模块名起一个代号
# 可以通过这个代号 来调用 模块中的相应的成员

# import p_05模块 as p5m
# print(p5m.n)
# p5m.show()
# p5m.Cat().show()
# p5m.Cat().show()


# 方式 二
# 导入指定模块中的指定成员
# from p_05模块 import n
# from p_05模块 import show
# from p_05模块 import Cat as CatClass
#
# # 当使用from-import 方式 导入 时，不需要再使用 模块名.成员 形式
# # 可以在当前文件中，直接 使用成员名，相当于将导入的成功复制到了本地一份
# print(n)
# show()
# CatClass().show()


# 这两种 方式 的区别
# 使用import时，可以将整个模块中的成员 都 导入 进来
# 使用 from-import 时，可以使用谁导入谁，更加节省资源
# 如果想使用 From-import 方式 ，也可以导入所有的成员
# 如果使用通配符 * 的方式 导入所有的成员，那么就不能使用 as 为成员起别名了
from p_05模块 import *

print(n)
show()
Cat().show()

两种导入方式区别：
1.import方式,是拿到了模块对象的引用地址,通过这个地址来使用模块中的成员
2.from-import方式,相当于将被导入模块中的成员,复制了一份到本地模块中.
    所以可以直接使用成员来访问被导入的成员
3.对于 import 方式来说,没有任何限制
4.对于from-import方式来说,有些成员是不能被导入的(有权限限制)

'''
两种导入 模块方式的区别
'''


# import p_06模块 as p6m
#
# print(p6m.x)
# print(p6m._y)
# print(p6m.__z)


# from p_06模块 import *
# print(x)
# 在使用这种 方式 导入 时，不会将私有的属性导入
# print(_y)
# print(__z)


# from -import 方式 的命令冲突问题

def x():
    print('x Function')


from p_06模块 import *

# x = 1

print(x)
x()

3. all

__all__ 是一个魔法属性,类型是一个列表,元素是字符串类型
作用:
	可以改变在使用 from-import 方式导入模块时,成员的导入规则

3.1 from-import

在导入时,会产生命名冲突问题
在程序中最后的定后会起作用

4. 模块导入的搜索顺序(了解)

模块的分类:
	1.自定义模块
	2.系统模块
	3.第三方模块

'''
模块查找顺序
'''

import sys
# print(sys.path)

import p_06模块

import os

import pymysql

sys.path.append('C:\\Users\\KG\\Desktop')

import AAAA

print(AAAA.n)
print(sys.path)

查找顺序:
	1. 当前程序所在目录
	2. 在当前程序所在工程的根目录
	3. PYTHONPATH
	4. 系统目录
	5. site_packages 第三方模块的安装目录

name (掌握)
作用:
如果__name__ 出现在当前执行的模块中时,得到的值是 main 这个字符串,用来表示执行的是当前文件
如果__name__ 出现在在了被导入模块中时,得到的值是被导入模块的模块名

n = 1

def show():
    print('show')


class Cat(object):
    def show(self):
        print('Cat_show')


# 在当前文件下测试成员的使用

# 当使用 __name__ 属性在获取当前模块名时，会有两种 效果
# 如果当前模块文件是  主动执行 时，__name__ 得到的结果是字符串 __main__ 表示这是程序的入口
# 如果当前模块文件是  被动执行 时（被别人导入时），__name__　得到的结果就是当前模块文件的文件名
print('name:', __name__)

if __name__ == '__main__':
    print(n)
    show()
    Cat().show()

'''
使用模块
'''
import p_08模块

print(__name__)

# 通过这个判断 来做为程序的程序 入口
if __name__ == '__main__':
    print('程序 的入口')

    print(p_08模块.n)

5. 包

包:就是一个文件夹

区别:
	在python3以前,包中是有一个文件 __init__.py ,没有该文件的就是一个普通 的文件夹,有该文件才是包
	在python3以后,不管有没有,都认为是一个包

6. 导入包中的模块

方式一:
	通过包和模块的路径,明确的告诉解释器,要导入哪个包里的哪个模块
	import 包名.模块名
	from 包名 import 模块名
	from 包名.模块名 import 成员名


方式二:
	import 包名
	from 包名 import *

	在导入时,不会指定模块名,只指定包名
	这时,默认情况下(__init__.py 为空)哪个模块都不会导入

	为了能让模块正常导入,这里需要 __init__.py 文件中设置可以被导入的模块
	通过方式:
	from . import 模块名

	注意:
	__all__ 只对 from 包名 import * 方法生效,对 import 包名 方式无效
	__all__ 在 __init__.py 文件中的使用了解即可

如果包有很多层级的情况:
www.ittest.cn
cn
ittest
python
java
c++

from cn.ittest.python import database

www.ittest.cn
cn
ittest
web
a.py
b.py
c.py
spider
a.py
b.py
c.py

'''
导入包中的模块
'''
# 导入 normal_dir 这个包中的 a 模块
import normal_dir.a

print(normal_dir.a.m)

import normal_dir.a as nda

print(nda.m)

# 使用from-import 方式导入
# 从  normal_pack 包中导入 b 模块
# 使用时，需要指定包名. 成员
from normal_pack import b

print(b.n)

# 从 normal_pack的 b 模块中，导入 b 模块中的所有成员
from normal_pack.b import *

print(n)

# 小结模块导入:
1. 导入模块:
两种方式
import 包名.模块名 -> 包名.模块名.成员
from 包名.模块名 import 成员名 -> 直接使用成员
from 包名 import 模块名 -> 模块名.成员
from 包名.模块名 import * -> 直接使用成员

2. all 这个魔法属性,会影响 from - import * 这种导入方式的模块
在all 中指定的模块或成员会被导入,没有指定的不会被导入

3. 了解模块导入时的搜索路径
	sys模块中的path变量中保存了搜索路径
	a. 当前程序所在同级目录
	b. 当前程序所在工程的根目录
	c. PYTHONPATH 环境变量中设置的目录
	d. 系统目录
	e. site-packages 这个第三方模块安装目录
	
4. 包
	包就是一个文件夹
	包和普通文件夹的功能在于 包中有一个 __init__.py 文件
	
	该文件的作用是在只导入包时,指定可以导入的模块有哪些
	如果这个文件是空的,那么在导入这个包时,不会导入任何模块
	
	在指定可以导入的模块时, 可以使用  from . import 可导入模块名

# import cn.itcast.web.a as weba1
# print(weba1.m)
#
# from cn.itcast.web import a as weba2
# print(weba2.m)
#
# from cn.itcast.web.a import *
# print(m)

# 想直接导入这个 web 包
# 在这里，如果只导到包的位置，那么通过 这个包去找模块时，会报错，因为不确定要导入哪个模块
# 需要在包中的 __init__.py 中，告诉解释器，当导入包时，应该导入哪些模块
# import cn.itcast.web as web
# print(web.a.m)
# print(web.b.n)


# from cn.itcast import web
# print(web.a.m)
# print(web.b.n)



# 小结：
'''
当在使用 import 方式 ，或from-import 方式 导入包时，
需要在 __init__.py 文件中，明确的指出可以被导入的模块有哪些
使用 from . import 模块名 形式指定 
如果在该 文件中没有指定 可以导入的模块时，默认不导入任何模块
'''

import cn.itcast.web as web
print(web.a.m)

from cn.itcast.web import *
print(a.m)
print(b.n)

7.异常概述

异常: 不正常
程序在执行过程中发生了不可预知的问题.
导致程序崩溃 

NameError
TypeError
ValueError
AttribitueError
SyntaxError
IndexError

改- index()

# class 语法错误 (Exception)
#
#    class 简单语法错误 (语法错误)
#         没有缩进
#         使用全角符号
#
#     高级语法错误
#         逻辑性错误

try:
可能会出现异常问题的代码
except Exception as e:
当出现异常时,解决异常的代码
else:
当没有出现异常时,正常执行的代码
finally:
无论是否出现异常,都会执行这里的代码

语法糖

with open(‘a.txt’,‘r’) as f:
f.read()

'''
使用 try-except 进行基本的异常处理

'''

s = 'Hello'

try:
    # 这句代码会发生异常
    print(s.index('O'))
# except ValueError:
except Exception:
    print('查找的子串不存在')

# 使用Try 来尝试执行 后面语句 块中的代码 ，如果代码 发生异常问题
# 那么异常信息就会被 except 捕捉到，可以在 except 后面进行异常处理
# 如果代码 没有异常，那么程序就正常运行，不会执行except 后的代码


print('over')

异常的传递

当代码出现了很层级的调用时,在其中发生了异常,如果没有处理这个异常,这个异常会自动向上抛出
如果上层也没有处理,那么再继续向上抛出,直到抛到解释器,解释器默认处理异常的方式就是中断程序,
将异常信息显示控制台上

8. 异常处理

语法:
	try:
		可能出现异常的代码
	except Exception:
		当异常发生时,处理异常的代码

8. 多个异常的处理

将多个异常通过圆括号包裹成一个元组

语法:
	try:
		可能出现异常的代码
	except (异常1,异常2,...):
		当异常发生时,处理异常的代码

8-1: 异常别名-获取异常信息

语法:
	try:
		可能出现异常的代码
	except (Exception,... )as e:
		print(e)
		当异常发生时,处理异常的代码

'''
注意：同时捕捉多个异常，但是同一时刻只能有一个异常发生
'''

try:
    # n = 1
    n / 0
# except (ZeroDivisionError, NameError) as e:
# except Exception as e:
except:
    print('出现异常了')

9. else：(可选的,理解)

在异常处理时,当没有异常发生的情况后,需要执行的代码,放到 else 语句块

'''
异常处理子句，else 用来处理没有异常的的情况
'''

try:
    f = None
    f = open('b.txt', 'r')
except Exception as e:
    print('要打开的文件不存在')
    print(e)
else:
    # 对文件的读取操作
    print('else 是当没有出现异常时，执行的else语句 块')
    print(f.read())
finally:
    # 不管是否出现异常，都要执行这个语句块
    # 一般这个模块中，主要写的内容 是资料关闭或回收
    # 比如，文件的关闭，网络连接的关闭，数据库的关闭
    print('无论是否出现异常，都会执行finally语句 块')
    if f != None:
        f.close()

with open('a.txt', 'r') as f:
    print(f.read())

10. finally:(可选的,掌握)

无论异常是否发生,都会执行这个语句块里的内容

应用:
	一般应用在资源需要关闭资源的场景上
	比如:文件的关闭,网络连接的关闭,数据库的关闭

11. 异常的传递

在发生异常时,异常的发生点可能在很深的函数调用过程中,这时如果不处理异常的话,异常会被一层一层的抛出
如果谁都没有处理,最终抛给解释器,解释是没办法处理异常,解释会将异常信息显示到终端

'''
异常的传递
'''


def func_a():
    print('Func a run ...')
    func_b()


def func_b():
    print("Func b run ...")

    try:
        func_c()
    except Exception:
        print('你的除数为0了')


def func_c():
    print('Func c run ...')
    # try:
    #     print(1 / 0)
    # except Exception:
    #     print('你的除数为0了')

    print(1 / 0)


func_a()

12. 自定义异常

格式:
class 异常名Error(Exception):
	def __init__(self,msg=''):
		self.__msg = msg

	def __str__(self):
		return self.__msg



class CustomError(Exception):
	pass

'''自定义异常

格式 ：
class 异常名Error(Exception):
    pass
'''


# 定义一个用来判断当前手机号是否有非法字符的异常
class PhoneNumberNotDigitError(Exception):
    pass


# 定义一个用来判断手机号位数是否合法的异常
class PhoneNumberLengthError(Exception):
    def __init__(self, msg):
        self.__msg = msg

    def __str__(self):
        return self.__msg


# 定义一个函数，用来获取一个电话号码
def get_phone_number():
    pn = input('请输入一个11位的手机号：')
    if pn.isdigit() == False:
        # 抛出自定义的异常
        raise PhoneNumberNotDigitError()
    elif len(pn) != 11:
        raise PhoneNumberLengthError('手机号位数不正确')

    return '输入的手机号是合法的：' + pn

# get_phone_number()

13. 自定义异常的抛出

raise 异常对象

raise 类名
raise 类名()

from p_16自定义异常 import *

try:
    num = get_phone_number()
except (PhoneNumberLengthError, PhoneNumberNotDigitError) as e:
    print(e)
else:
    print(num)

李好秀

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Day10-包模块异常

在Python中,一个.py文件就是一个模块在Python,万物皆对象,模块也不例外通过模块,可以有效的组织代码结构,让代码结构更加清晰但是,初期可能让大家逻辑上更加混乱异常: 不正常程序在执行过程中发生了不可预知的问题.导致程序崩溃NameErrorTypeErrorValueErrorIndexError改- index()# class 语法错误 (Exception)# class 简单语法错误 (语法错误)# 没有缩进# 使用全角符号# 高级语法错误# 逻辑性错误。
复制链接

扫一扫