本周总结

• 异常处理

• 生成器

• 模块

• 软件开发目录

1.异常处理

1.1异常处理语法结构

1.基本语法
	try:
        待检测的代码(可能会出错的代码)
     except 错误类型: 
        针对上述错误制定的方案
2.查看错误信息
	try:
        待检测的代码(可能会出错的代码)
     except 错误类型 as e:  # e就是系统提示的错误信息
        针对上述错误制定的方案
3.针对不同的错误类型制定不同的解决方案
	try:
        待检测的代码(可能会出错的代码)
    except 错误类型1 as e:
        针对上述错误类型1制定的方案
    except 错误类型2 as e:
        针对上述错误类型2制定的方案    
	except 错误类型3 as e:
        针对上述错误类型3制定的方案
4.万能异常 Exception/BaseException
	try:
        待检测的代码(可能会出错的代码)
    except Excepiton as e:
        针对各种常见的错误类型全部统一处理
5.结合else使用
	try:
        待检测的代码(可能会出错的代码)
    except Exception as e:
        针对各种常见的错误类型全部统一处理
    else:
        try的子代码正常运行结束没有任何报错后 再执行else子代码
6.结合finally使用
	try:
        待检测的代码(可能会出错的代码)
    except Exception as e:
        针对各种常见的错误类型全部统一处理
    else:
        try的子代码正常运行结束没有任何的报错狗 再执行else子代码
   finally:
        无论try的子代码是否报错 最后都要执行finally子代码        

1.2异常处理补充

1.断言
    name = 'guts'
	assert isinstance(name, str)
	print('哈哈哈 我就说吧 肯定是字符串')
	name.strip()
2.主动抛异常
	name = 'guts'
    if name == 'guts'
    	raise Exception('不哈哈哈')
    else:
        print('哈哈哈')

2.生成器

2.1生成器对象

1.本质
	还是内置有__iter__和__next__的迭代器对象
2.区别
	迭代器对象是解释器自动提供的
    	数据类型\文件对象>>>:迭代器对象
     生成器对象是程序员编写出来的
    	代码、关键字>>>:迭代器对象(生成器)
3.创建生成器的基本语法
	函数体代码中填写yield
    def my_iter():
    print('理塘最強伝說と絕兇の猛虎!純真丁一郎です')
    yield
    '''1.函数体代码中如果有yield关键字 
        那么函数名加括号并不会执行函数体代码
        会生成一个生成器对象(迭代器对象)
    '''
	res = my_iter()
    '''2.使用加括号之后的结果调用__next__才会执行函数体代码'''
	next(res)
    '''3.每次执行完__next__代码都会停在yield位置 下次基于该位置继续往		下找第二个yield'''
    def my_iter():
        print('理塘最強伝説と暢銷の悦刻!彷生電子煙です!')
        yield '彷生電子煙です!'
        print('理塘最強伝説と青眼の白龍!小白馬珍珠です!')
        yield '小白馬珍珠です!'
        print('理塘最強伝説と絶兇の猛虎!純真丁一郎です!')
        yield '純真丁一郎です!'
    res = my_iter()
    r1 = next(res)
    print(r1)
    r2 = next(res)
    print(r2)
    r3 = next(res)
    print(r3)
    '''4.yield还有点类似于return 可以返回返回值'''

2.2yield冷门用法

def eat(name, food = None):
    print(f'{name}准备用餐')
    while True:
        food = yield
        print(f'{name}正在吃{food}')
res =eat('guts')
next(res)  # 1.将括号内的数据传给yield前面的变量名 2.再自动调用__next__
res.send('汉堡')
res.send('包子')
res.send('蛋糕')

2.3生成器表达式

说白了就是生成器的简化写法
l1 = [i ** 2 for i in range(100)]
print(l1)

l1 = (i ** 2 for i in range(100))  # 生成器对象
print(l1)  # <generator object <genexpr> at 0x000001DFC07F7E40>
for i in l1:
    print(i)

3.模块

3.1模块简介

1.模块的本质
	内部具有一定的功能(代码)的py文件
2.python模块的历史
    python刚开始的时候所有搞其他编程语言的程序员都看不起 甚至给python起了个外号>>>:调包侠(贬义词)
    随着时间的发展项目的复杂度越来越高 上面那帮人也不得不用一下python 然后发现真香定律>>>:调包侠(褒义词)
3.python模块的表现形式
    1.py文件(py文件也可以称之为是模块文件)
    2.含有多个py文件的文件夹(按照模块功能的不同划分不同的文件夹存储)
    3.已被编译为共享库或DLL的c或C++扩展(了解)
    4.使用C编写并链接到python解释器的内置模块(了解)

3.2模块的分类

1.自定义模块
	我们自己写的模块文件
2.内置模块
	python解释器提供的模块
3.第三方模块
	别人写的模块文件(python背后真正的大佬)

3.3导入模块的两种句式

"""
强调:
	1.一定要搞清楚谁是执行文件 谁是被导入文件
	2.以后开发项目的时候py文件的名称一般是纯英文
		不会含有中文甚至空格   
		01 作业讲解.py       不会出现
		test.py views.py    出现
	3.导入模块文件不需要填写后缀名
"""
1.import句式
	以import a为例研究底层原理
    """
    1.先产生执行文件的名称空间
    2.执行被导入文件的代码
    3.在执行文件的名称空间中产生一个模块的名字
    4.在执行文件中使用该模块名点的方式使用模块名称空间中所有的名字
    """
2.from...import...句式
以from a import name, func1为例研究底层原理
"""
1.先产生执行文件的名称空间
2.执行被导入文件的代码将产生的名字放入被导入文件的名称空间中
3.在执行文件的名称空间中产生对应的名字绑定模块名称空间中对应的名字
4.在执行文件中直接使用名字就可以访问名称空间中对应的名字
"""

3.4导入模块补充说明

1.import与from...import...两者的优缺点
	import句式
    	由于使用模块名称空间中的名字都需要模块名点的方式才可以用
        所以不会清一的被执行文件中的名字替换掉
        但是每次使用模块名称空间中的名字都必须使用模块名点才可以
     from...import...句式
    	指名道姓的导入模块名称空间中需要使用的名字 不需要模块名点
        但是容易跟执行文件中名字冲突
2.重复导入模块
	解释器只会导入一次 后续重复的导入语句并不会执行

3.起别名
	import litangdingzhen as dz
    from litangdingzhen import litangzuiqiangchuanshuochangxiaodeyuekefangshengdianziyan as dzy
    from a import name as n,func1 as f1
    
4.涉及到多个模块导入
	import a
    import litangdingzhen
    如果模块功能相似度不高 推荐使用第一种 相似度搞可以使用第二种
    import a, litangdingzhen

3.5循环导入问题

1.循环导入
	两个文件之间彼此导入彼此并且相互使用各自名称空间中的名字 极容易报错
2.如何解决循环导入问题
	1.确保名字在使用之前就已经准备完毕
    2.我们一行在编写代码的过程中应该尽可能避免出现循环导入

3.6判断文件类型

所有的py文件都可以直接打印__name__对应的值
	当py文件是执行文件的时候__name__对应的值是__main__
    当py文件是被导入文件的时候__name__对应的值是模块名
 
if __name__ == '__main__':
    print('理塘最強伝説と暢銷の悦刻!彷生電子煙です!迸入了游戎理塘最強伝説と青眼の白龍!小白馬珍珠です!迸入了游戎理塘最強伝説と絶兇の猛虎!純真丁-一郎です!迸入了游戎')
 
上述脚本可以用来区分所有在py文件内python代码的执行

使用场景
	1.模块开发阶段
    2.项目启动文件

"""
from a import *  *默认是将模块名称空间中所有的名字导入
__all__  = ['名字1', '名字2']  针对*可以限制拿的名字
"""

3.7模块的查找顺序

1.内存
	import aaa
    import time
    time.sleep(15)
    print(aaa.name)
    aaa.func1()
"""
执行后删除aaa.py 因为执行开始文件内容就已经写入内存中 所有删除后可以调用 但是结束后立即释放 无法再次调用
"""    

2.内置
	import time
    print(time)
    print(time.name)
    """
    以后在自定义模块的时候尽量不要与内置模块名冲突
    """
    
3.执行文件所在的sys.path(系统环境)
	一定要以执行文件为准!!!
    我们可以将模块所在的路径也添加到执行文件的sys.path中即可
    import sys
    print(sys.path)  # 列表
    sys.path.append(r'G:\pythonProjeck\pythonProject9')
    import ccc
    print(ccc.name)

3.8绝对导入与相对导入

"""
再次强调:一定要分清楚谁是执行文件!!!
	模块的导入全部以执行文件为准
"""
绝对导入
	from mymd.aaa.bbb.ccc.ddd import name  # 可以精确到变量名
    from mymd.aaa.bbb.ccc import ddd  # 也可以精确到模块名
    ps:套路就是按照项目根目录一层层往下查找
        
相对导入
	.在路径中表示当前目录
    ..在路径中表示上一层目录
    ..\..在路径中表示上上一层目录
    不在依据执行文件所在的sys.path 而是以模块自身路径为准
    from . import b
    相对导入只能用于模块中 不能在执行文件中使用
'''
相对导入使用频率较低 一般用绝对导入即可 结构更加清晰
'''

3.9包

大白话:多个py文件的集合>>>:文件夹
专业:内部含有__init__.py文件的文件夹(python2必须要求 python3无所谓)   

3.10常见内置模块之collections模块

1.具名元组:namedtuple
    from collections impot namedtulpe
    表示二维坐标系
    point = namedtuple('点', ['x', 'y'])
    生成点信息
    p1 = point(1, 2)
    print(p1)  # 点(x=1, y=2)
    print(p1, x)  # 1
    print(p1, y)  # 2
    
    card = namedtuple('扑克牌', ['num', 'color'])
    c1 = card('A', '黑♠')
    c2 = card('k', '红♥')
    print(c1, c1.num, c1.color)
    print(c2, c2.num, c2.color)
2.队列
	队列与堆栈
    队列:先进先出
    堆栈:先进后出
    队列与堆栈都是一边只能进 一边只能出
3.deque
	frome.collections import deque
    q = deque(['a', 'b', 'c'])
    q.append('x')
    q.appendleft('y')
    print(q)  # deque(['y', 'a', 'b', 'c', 'x'])
    # 双边都能添加
4.OrderedDict
	from collections import OrderedDict
    d = dict([('a', 1), ('b', 2), ('c', 3)])
     print(d)  # dict的Key是无序的
    # {'a': 1, 'c': 3, 'b': 2}
    od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
    print(od)  # OrderedDict的Key是有序的
    # OrderedDict([('a', 1), ('b', 2), ('c', 3)])

3.11常见内置模块之时间模块

import time
"""
三种时间表现形式
	1.时间戳
		秒数
	2.结构化时间
    	主要是给计算机看的 人看不适应
    3.格式化时间
    	主要是给人看到
"""
print(time.time())
print(time.localtime())  # 结构化时间
print(time.strftime('%Y/%m/%d'))  # 2022/10/19
print(time.strftime('%Y/%m/%d %H:%M:%S'))  # 2022/10/19 15:54:41
print(time.strftime('%Y/%m/%d %X'))  # 2022/10/19 15:55:06
time.sleep(6)  # 让程序原地阻塞指定的秒数

import datetime
print(datetime.datetime.now())  # 2022-10-19 16:16:10.667850
print(datetime.datetime.today())  # 2022-10-19 16:16:29.191268
print(datetime.time.today())  # 2022-10-19
'''
datetime 年月日 时分秒
date     年月日
time     时分秒(后续会有此规律)
'''
from datetime import date,datetime
print(date.today())  # 2022-10-19
print(datetime.today())  # 2022-10-19 16:30:42.888586
print(datetime.utcnow())  # 2022-10-19 08:30:42.888586
import datetime
c = datetime.datetime(2000, 4, 24, 5, 30)
print('指定日期：', c)  # 指定日期： 2000-04-24 05:30:00
from datetime import datetime
d = datetime.strptime('2000/4/24', '%Y/%m/%d')
print(d)  # 2000-04-24 00:00:00
e = datetime.strptime('2000年4月24日星期一', '%Y年%m月%d日星期一')
print(e)  # 2000-04-24 00:00:00
f = datetime.strptime('2000年4月24日星期一5时32分18秒', '%Y年%m月%d日星期一%H时%M分%S秒')
print(f)  # 2000-04-24 05:32:18
import datetime
ctime = datetime.date.today()
print(ctime)  # 2022-10-19
time_del = datetime.timedelta(days=3)
print(ctime + time_del)  # 2022-10-22

ctime = datetime.datetime.today()
print(ctime)  # 2022-10-19 17:21:19.822662
time_del = datetime.timedelta(minutes=20)
print(ctime + time_del)  # 2022-10-19 17:41:19.822662

3.12常用内置模块之随机数模块

import random

print(random.random())  # 随机产生0到1之间的小数
print(random.randint(1, 9))  # 随机产生1到9之间的整数
print(random.randrange(1, 100, 5))  # 随机产生指定的整数
print(random.choice(['一等奖', '二等奖', '三等奖', '谢谢惠顾']))  # 随机抽取一个样本  '二等奖'
print(random.choices(['一等奖', '二等奖', '三等奖', '谢谢惠顾']))  # 随机抽取一个样本   ['二等奖']
print(random.sample(['jason', 'kevin', 'tony', 'oscar', 'jerry', 'tom'], 2))  # 随机抽指定样本数  ['tom', 'jerry']
l1 = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A']
random.shuffle(l1)  # 随机打乱数据集
print(l1)

'''产生图片验证码:每一位都可以是大写字母 小写字母 数字 4位'''
import random

def get_code(n):
    code = ''
    for i in range(n):
        random_upper = chr(random.randint(65, 90))
        random_lower = chr(random.randint(97, 122))
        random_int = str(random.randint(0, 9))
        temp = random.choice([random_upper, random_lower, random_int])
        code +=temp
    return code

res = get_code(4)
print(res)

3.13 os模块(重要)

os模块主要与代码运行所在的操作系统打交道
import os
1.创建目录(文件夹)
os.mkdir(r'd1')  # 可以创建单级目录
os.mkdir(r'd\dd\ddd')  # 不可以创建多级目录
os.makedirs(r'd\dd\ddd')  # 可以创建多级目录
os.makedirs(r'd1')  # 可以创建单级目录
2.删除目录(文件夹)
os.rmdir(r'd1')  # 可以删除单级目录
os.rmdir(r'dd\ddd\dddd')  # 不可以删除多级目录
os.removedirs(r'dd\ddd\dddd')  # 可以删多级目录
os.removedirs(r'dd\ddd\dddd\aaa')  # 只能删除空的多级目录
os.rmdir(r'aa')  # 只能删除空的单级目录
3.列举指定路径下内容名称
print(os.listdir())  # 返回一个列表 里面是当前目录下的文件名
print(os.listdir(r'G:\\'))  #返回一个列表 列表是硬盘根目录下的文件名 
4.删除/重命名文件
os.rename(r'aaa\bbb\ccc', r'aaa\bbb\ddd')  # 第二个到到第几级改第几级
os.remove(r'aaa\bbb\ccc')  # 删最后一级 只能删空文件夹
5.获取/切换当前工作目录
print(os.getcwd())   # G:\pythonProjeck\pythonProjec10
os.chdir('..')  # 返回上级目录 两个点代表上级目录
print(os.getcwd())  # G:\pythonProjeck
os.mkdir(r'hhh')  # 在G:\pythonProjeck目录创建新的文件
6.动态获取项目根路径(非常重要)
print(os.path.abspath(__file__))  # 获取执行文件的绝对路径
print(os.path.dirname(__file__))  # 获取执行文件所在的目录路径
7.判断路径是否存在(文件、目录)
print(os.path.exists(r'01.py'))  # 判断文件路径是否存在 Ture
print(os.path.exists(r'G:/pythonProjeck/pythonProjec10'))  # 判断目录是否存在  True
print(os.path.isfile(r'01.py'))  # 判断路径结构是否为文件  False
print(os.path.isfile(r'G:/pythonProjeck'))  # 判断路径是否是文件False
print(os.path.isdir(r'01.py'))  # 判断路径是否是目录 False
print(os.path.isdir(r'G:/pythonProjeck'))  # 判断路径是否是目录 True
8.路径拼接(非常重要)
s1 = r'G:/pythonProjeck/pythonProjec10'
s2 = r'01.py'
print(os.path.join(s1, s2))  # G:/pythonProjeck/pythonProjec10\01.py  # 可以识别
9.获取文件大小(字节)
print(os.path.getsize(r'a.txt))

3.14 sys模块

import sys  
print(sys.path)  # 获取执行文件的sys.path
print(sys.getrecursionlimit())  # 获取python解释器默认最大递归深度
sys.setrecursionlimit(2000)  # 修改python解释器默认最大递归深度
print(sys.version)  #3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC v.1927 64 bit (AMD64)]
print(sys.platform)  # 平台信息 win32(了解即可)
res = sys.argv  
print(res)  # 在pycharm中执行打印的是一个包含执行文件路径的列表
if len(res) != 3:
    print('执行命令缺少了用户名或密码')
else:
    username = res[1]
    password = res[2]
    if username == 'jason' and password == '123':
        print('jason您好 文件正常执行')
    else:
        print('您不是jason无权执行该文件')
# 需要在cmd中执行

3.15 json模块

json模块也称为序列化模块 序列化可以打破语言限制实现不同编程语言之间数据交互
json格式数据的作用
	可以在不同编程语言中交互
json格式数据的形式
	字符串类型并且引号都是双引号
json相关操作
	针对数据
    json.dumps()  
    json.loads()
    d1_dict = {'username': 'guts', 'password': 123}
    res = json.dumps(d1_dict)
    print(res)  # {"username": "guts", "password": 123}
    print(type(res))  # <class 'str'>
    ret = json.loads(res)  
    print(ret)  # {'username': 'guts', 'password': 123}
    print(type(ret))  # <class 'dict'>
    
    针对文件
    json.dump()
    json.load()

4.软件开发目录规范

4.1编程思想的转变

1.面条版阶段
	所有的代码全部堆叠在一起
2.函数版阶段
	根据功能的不同封装不同的函数
3.模块版阶段
	根据功能的不同拆分成不同的py文件
"""
第一个阶段可以看成是直接将所有数据放在C盘
	视频 音频 文本 图片
第二个阶段可以看成是将C盘下的数据分类管理
	视频文件夹 音频文件夹 文本文件夹 图片文件夹
第三个阶段可以堪称是将C盘下的数据根据功能的不同划分到更合适的位置
	系统文件夹 C盘
	视频文件夹 D盘
	图片文件夹 E盘
ps:类似于开公司(小作坊 小公司 上市公司)	
	为了资源的高效管理
"""    

4.2软件开发目录规范

1.文件及目录的名字可以变换 但是思想是不变的 分类管理
2.目录规范主要规定开发程序的过程中针对不同的文件功能需要做不同的分类
myproject项目文件夹
	1.bin文件夹	主要存放项目启动文件
    	start.py	启动文件可以放在bin目录下 也可以直接在项目根目录
    2.conf文件夹	主要存放项目配置文件
    	settings.py	里面存放项目的默认配置 一般都是全大写
    3.core文件夹    主要存放项目核心文件
    	src.py		里面存放项目核心功能
    4.interface文件夹   主要存放项目接口文件
    	goods.py	根据具体业务逻辑划分对应的文件
        user.py
        account.py
    5.db文件夹		主要存放项目相关数据
    	userinfo.txt
        db_handler.py	存放数据库操作相关的代码
    6.log文件夹	主要存放项目日志文件
    	log.log
    7.lib文件夹	主要存放项目公共功能
    	common.py
    8.readme文件	  主要存放项目相关说明
    9.requirements.txt文件	主要存放项目所需模块及版本 

原文地址：http://www.cnblogs.com/DragonY/p/16818777.html