首页 > 其他分享> > 第五周整理笔记

第五周整理笔记

2022-07-17 19:11:07 作者：互联网

常见内置函数
迭代器
异常捕获(迭代器)
生成器
模块
包的概念
- 包的作用
- 包的使用
目录规范
常见内置模块

常见内置函数

内置函数：提前定义好的可以直接使用

函数	说明
abs()	求绝对值
all()	判断容器类型中的所有数据值对应的布尔值是否为True，所有的数据值都为True的情况下结果才是True
any()	判断容器类型中的所有数据值对应的布尔值是否为True，所有的数据值只要有一个为True结果就是True
bin()	十进制转二进制
oct()	十进制转八进制
hex()	十进制转十六进制
int()	类型转换，其他进制转十进制
bytes()	类型转换，返回一个字节对象
callable()	判断某个变量是否可以加括号调用（call在IT专业名词中翻译成调用>>>:加括号执行）
chr()	依据ASCII码表实现字符与数字的转换
ord()	依据ASCII码表实现字符与数字的转换
dir()	获取对象内部可以通过句点符获取的数据
divmod()	获取除法之后的整数和余数
enumerate()	枚举
eval()	能够识别字符串中python代码并执行(不识别复杂结构的代码，只能识别最简单的)
exec()	能够识别字符串中python代码并执行(能够识别复杂结构的代码)
hash()	返回一串随机的数字(哈希值)
help()	查看帮助信息
isinstance()	判断某个数据是否属于某个数据类型
pow()	幂指数
round()	四舍五入

迭代器

迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代

迭代

迭代就是更新换代，每次迭代都需要基于上一次的成果

可迭代对象

可迭代对象（能够支持for循环取值）：字符串(str)、列表(list)、字典(dict)、元组(tuple)、集合(set)、文件对象(本身就是迭代器对象)

不可迭代对象：整型(int)、浮点型(float)、布尔值(bool)、函数名

判断可迭代对象：内置有 __ iter__ 方法的都叫做可迭代对象

内置：通过句点符直接能够点出来的东西都叫内置
__ XXX__：针对双下划线开头双下划线结尾的方法，统一读作双下XXX

迭代器对象

作用：迭代器对象给我们提供了一种不依赖于索引取值的方式，因为有迭代器对象的存在，我们才能对字典、集合这些无序类型循环取值

判断迭代器对象：内置有__ iter__ 和 __ next __的对象都称为迭代器对象

迭代器对象实操

迭代器对象取值

res = 'jason'.__iter__()  # res已经是迭代器对象
print(res.__next__())  # j
print(res.__next__())  # a
print(res.__next__())  # s
print(res.__next__())  # o
print(res.__next__())  # n
print(res.__next__())  # 没有了直接报错

d1 = {'name': 'jason', 'pwd': 123}
res = d1.__iter__()
print(res.__next__()) # name
print(res.__next__()) # pwd


l1 = [11, 22, 33, 44, 55, 66, 77, 88]
# 需求:不使用for循环 依次打印出列表中所有的数据值
# 1.先将列表变成迭代器对象
res = l1.__iter__()
# 2.定义一个计数器
count = 0
# 3.编写while循环
while count < len(l1):
    print(res.__next__())
    count += 1

迭代器反复使用

l = [11, 22, 33, 44]
print(l.__iter__().__next__())  # 11  每次都是产生了一个新的迭代器对象
print(l.__iter__().__next__())  # 11
print(l.__iter__().__next__())  # 11
print(l.__iter__().__next__())  # 11

res = l.__iter__()
print(res.__iter__().__next__())  # 11  每次使用的都是一个迭代器对象
print(res.__iter__().__next__())  # 22
print(res.__iter__().__next__())  # 33
print(res.__iter__().__next__())  # 44

双下方法

res = l.__iter__()  # 可以简写iter(l)
res.__next__()  # 可以简写next(res)

可迭代对象与迭代器对象的关系

可迭代对象调用__ iter__方法之后就会变成迭代器对象
迭代器对象调用__ iter__方法无论多少次还是迭代器对象本身

for循环本质

语法结构

for 变量名 in 可迭代对象:
        for循环体代码

for会自动将in后面的数据调用__ iter__()变成迭代器对象
之后每次循环调用__ next__()取值
最后没有值__ next__()会报错 for能够自动处理该错误让循环正常结束

异常捕获(迭代器)

异常

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行，程序在运行的过程中如果出现了异常会导致整个程序的结束

异常结构

关键字line所在行：精准提示哪一行代码出错
最后一行冒号左侧：错误类型
最后一行冒号右侧：错误具体原因（改bug关键）

异常类型

异常名称	描述
Exception	常规错误的基类
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError	Python 语法错误
IndentationError	缩进错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

异常分类

语法错误：不允许出现，一旦出现立刻修改
逻辑错误：允许出现，允许出错之后修改即可

异常捕获代码实现

当代码不确定什么时候会报错的情况下需要自己写代码处理异常
异常捕获的使用相当于是提前预测可能出现的问题并提前给出处理的措施

try/except语句

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理，如果你不想在异常发生时结束你的程序，只需在try里捕获它

1.基本语法结构：

try:
    可能会出错的代码
except 错误类型1 as e: # e就是具体错误的原因
    对应错误类型1的解决措施
except 错误类型2 as e: # e就是具体错误的原因
    对应错误类型2的解决措施
except 错误类型3 as e: # e就是具体错误的原因
    对应错误类型3的解决措施
except 错误类型4 as e: # e就是具体错误的原因
    对应错误类型4的解决措施
             ...

2.万能异常（笼统的处理方式）

try:
    可能会出错的代码
except Exception as e: # 万能异常方式1
    print(e)
except BaseException as e: # 万能异常方式2
    print(e)

try....except...else语法

try监测的代码出错的情况下正常运行结束，不会执行else子代码
try监测的代码没有出错的情况下正常运行结束，则会执行else子代码

# try监测的代码出错的情况下正常运行结束，不会执行else子代码
try:
    name
except Exception as e:
    print('出错了')
else:
    print('try监测的代码没有出错的情况下正常运行结束，则会执行else子代码')
    
# try监测的代码没有出错的情况下正常运行结束，则会执行else子代码
try:
    name = 'jason'
except Exception as e:
    print('出错了')
else:
    print('try监测的代码没有出错的情况下正常运行结束，则会执行else子代码')

try…except…finall语法

try监测的代码无论有没有出错，最后都会执行finally子代码

# try监测的代码无论有没有出错，最后都会执行finally子代码
try:
    name
    # name = 'jason'
except Exception as e:
    print('出错了')
finally:
    print('try监测的代码无论有没有出错，最后都会执行finally子代码')

断言(assert)

断言数据属于什么类型，如果不对则直接报错，对则正常执行下面的代码

name = 'jason'
assert isinstance(name, list)  # 断言name属于list类型,如果不对则报错,对则执行后面的代码,感觉和if作用差不多
print('针对name数据使用列表相关的操作')

主动抛异常(raise)

raise语句主动触发异常

name = input('username>>>:').strip()
	if name == 'jason':
        # raise NameError('jason来了 快跑!!!')
        raise Exception('反正就是不能过')
     else:
        print('不是jason，那没事了')

注意

异常捕获能尽量少用就尽量少用
被try检测的代码能尽量少就尽量少

生成器

在 Python 中，使用了 yield 的函数被称为生成器。生成器是一个返回迭代器的函数，只能用于迭代操作，生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象。

生成器对象

本质：迭代器对象

迭代器对象是编译器提供给我们的，现成的
生成器对象是根据迭代器的原理，我们自己敲的，主要依赖__ iter__ 与__ next__方法以及 yield关键字

创建生成器对象方法：

方式一：调用带yield关键字的函数
方式二：生成器表达式

作用：优化代码，提供一种不依赖于索引的取值方式，节省了占用空间

生成器函数

当函数体代码中有yield关键字，那么函数名第一次加括号调用不会执行函数体代码，而是由普通的函数变成了迭代器对象（生成器）返回值

def index():
    print('你瞅啥')
    yield 

print(index)  # <function index at 0x000001F499F7A5E0>
res = index()
print(res)  # <generator object index at 0x0000021E18BACA50>

yield可以在函数体代码中出现多次，每次调用__ next__方法都会从上往下执行直到遇到yield代码停留在此处

def index():
    print('你瞅啥')
    yield 1
    print('瞅你咋地')
    yield 2
    print('爱瞅瞅')
    yield 3

print(index)
res = index()
print(res) 

res.__next__() # 你瞅啥
res.__next__() # 瞅你咋地
res.__next__() # 爱瞅瞅

yield后面如果有数据值，则会像return一样返回回去，如果有多个数据值逗号隔开，那么也会自动组织成元组返回

def index():
    print('你瞅啥')
    yield 1, 2, 3
    print('瞅你咋地')
    yield 2
    print('爱瞅瞅')
    yield 3

print(index)
res = index()
print(res) 
    
print(res.__next__()) # 你瞅啥 (1, 2, 3)
print(res.__next__()) # 瞅你咋地 2
print(res.__next__()) # 爱瞅瞅 3

yield其他用法

def index(name,food=None):
    print(f'{name}准备干午饭!!!')
    while True:
        food = yield
        print(f'{name}正在吃{food}')
res = index('jason')
res.__next__()
res.send('烧烤')  # 传值并自动调用__next__方法
res.send('火锅')  # 传值并自动调用__next__方法
res.send('钵钵鸡')  # 传值并自动调用__next__方法

生成器表达式（元组生成式）

l1 = (i**2 for i in range(10) if i > 3)
print(l1)  # <generator object <genexpr> at 0x000001A793439C10>

迭代取值和索引取值的差异

索引取值

优势：可以随意反复的获取任意数据
劣势：针对无序的容器类型无法取值

迭代取值

优势：提供了一种通用的取值方式
劣势：取值一旦开始只能往前不能后退

模块

简介

模块：一系列功能的结合体，使用模块就相当于拥有了这结合体内的所有功能（是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句）

模块分类

内置模块：python解释器自带的，可以直接使用（import time）
自定义模块：我们自己写的模块
第三方模块：在网络上别人写的模块，使用时需要提前下载(图形识别、图形可视化、语音识别)

模块表现形式

py文件（py文件也可以叫做模块文件）
含有多个py文件的文件夹（按照模块功能的不同划分不同的文件夹存储）
已被编译为共享库或DLL的c或c++扩展（了解）
使用c编写并链接到python解释器的内置模块（了解）

模块文件注意事项

学习模块的时候，模块文件名称得用英文
py文件被当做模块导入的时候不需要考虑后缀

导入模块的两种语法句式

导入模块句式一：import句式

import md
'''
执行文件：run.py
被导入的文件：import 后面的文件名 eg：md.py
'''

过程：

创建执行文件的名称空间
创建被导入文件的名称空间
执行被导入文件中的代码，将产生的名字存储到被导入文件的名称空间中
在执行文件会获取一个模块的名字，通过该名字点的方式就可以使用到被导入的文件名称空间中的名字

注意：同一个程序反复导入相同的模块，导入的语句只会执行一次

导入模块句式二：from-import句式（指名道姓的导入）

from md import money, read1
print(money)
read1()

过程：

创建执行文件的名称空间
创建被导入文件的名称空间
执行被导入文件中的代码，将产生的名字存储到被导入文件的名称空间中
在执行文件中获取到指定的名字，指向被导入文件的名称空间

两种导入句式的优缺点

import …

优点：通过点的方式可以使用到模块内所有的名字，并且不会冲突
缺点：什么都可以点，有时候并不想让所有的名字都能被使用

from … import …

优点：指名道姓的使用指定名字，还不需要加模块名前缀
缺点：名字容易产生冲突（冲突：绑定关系被修改）

导入模块句式的其他用法

起别名

情况一：多个模块文件名相同（多个人写）

from md import money as md_my
from md import money as md1_my
print(md_my)
print(md1_my)

情况二：原有的模块文件名复杂

import mdddddddddd as md

导入多个名字

import time, sys, os
# 上述导入方式建议多个模块功能相似才能适应，不相似尽量分开
import time
import os
import sys

from md import money,read1,read2
# 这个导入方式是推荐使用的，因为多个名字出自于同一个模块文件

全导入

# 需求：需要使用模块名称空间中的很多名字，并且只能使用from...import句式
from md import * # *表示所有
'''针对 * 的导入还可以控制名字的数量'''
__all__ = [字符串名字]
# 可以用来在模块文件中控制*能够获取的名字

循环导入问题

判断文件类型

name内置名

所有py文件都自带__ name__内置名
当py文件是执行文件的时候__ name__ 的结果是__ main__
当py文件是被导入文件的时候__ name__的结果是模块名(文件名)

name内置名的应用场景

一般是模块开发者用于测试自己的代码

模块的查找顺序

内存查找>>>>>内置中查找>>>>>sys.path中查找(程序系统环境变量)

内存查找：导入一个文件，然后在导入过程中删除该文件，发现还可以使用
创建一个跟内置模块名相同的文件名（注意：创建模块文件的时候尽量不要与内置模块名冲突）
sys.path中查找(程序系统环境变量)：导入模块的时候一定要知道谁是执行文件
- 所有的路径都是参照执行文件来的，执行文件默认只能导入同级的模块文件
- 如果要导入不同级的模块文件，需要添加模块文件的路径

绝对导入与相对导入

绝对导入

定义：绝对导入就是以执行文件所在的sys.path为起始路径往下一层层查找

由于pycharm会自动将项目根目录添加到sys.path中，所以查找模块肯定不报错的方法就是永远从根目录往下一层层找

注意：如果不是用pycharm运行，则需要将项目根目录添加到sys.path(针对项目根目录的绝对路径有os模块可以帮助我们获取

相对导入

定义：可以不参考执行文件所在的路径，直接以当前模块文件路径为准

储备知识：

.在路径中意思是当前路径
..在路径中意思是上一层路径
../..在路径中意思是上上一层路径

注意：

相对导入只能在模块文件中使用，不能在执行文件中使用
相对导入在项目比较复杂的情况下可能会出错
相对导入尽量少用，推荐使用绝对导入

包的概念

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。简单来说，包就是文件夹，但该文件夹下必须存在 __ init__ .py 文件, 该文件的内容可以为空。__ init__ .py 用于标识当前文件夹是一个包。

包的作用

内部存放多个py文件（模块文件），是为了更方便管理模块文件

包的使用

import 包名
导入包名其实导入的是里面的__ init__ .py文件（里面有什么就用什么），也可以跨过__ init__.py文件直接导入包里面的模块文件

注意

针对python3解释器，其实文件夹里面有没有__ init__ .py文件无所谓，都是包
针对python2解释器，文件下面必须要有__ init__ .py文件才能被当做包

目录规范

文件分类详细

文件夹名	描述	例子
bin	用于存储程序的启动文件	start.py
conf	用于存储程序的配置文件	settings.py
core	用于存储程序的核心逻辑	src.py
lib	用于存储程序的公共功能	common.py
db	用于存储程序的数据文件	userinfo.py
log	用于存储程序的日志文件	log.log
interface	用于存储程序的接口文件	user.py order.py goods.py
README（文本文件）	用于存储程序的说明、介绍、广告（类似于产品说明书）	README
requirements.txt	用于存储程序所需的第三方模块名称和版本	requirements.txt

README文件说明

README文件是每个项目都应该有的一个文件
目的：能简要描述该项目的信息，让读者快速了解这个项目
需要说明以下几个事项:
1. 软件定位，软件的基本功能
2. 运行代码的方法：安装环境、启动命令等
3. 简要的使用说明
4. 代码目录结构说明，更详细点可以说明软件的基本原理
5. 常见的问题说明

requirements.txt文件说明

这个文件的存在是为了方便开发者，维护软件的依赖库，我们需要的第三方库都可以写进去，pycharm非常智能，会通过识别版本号以及包名导入，这样也方便我们查看使用了哪些python包。

注意：在编写软件的时候，可以不完全遵循上面的文件名

start.py可以放在bin文件夹下也可以直接放在项目根目录下
db文件夹等学到真正的项目会被数据库软件替代
log文件夹等学到真正的项目会被专门的日志服务替代

常见内置模块

collection模块

属性或方法	描述
nametuple	生成可以使用名字来访问元素内容的元组
deque	双端队列，可以快速的从另一侧追加和推出对象
Counter	计数器，主要用来计数
OrderedDict	有序字典
defaultdict	带有默认值的字典

time模块

属性或方法	描述
time.time()	时间戳
time.strftime(%Y-%m-%d %H:%M:%S)或ime.strftime(%Y-%m-%d %X)	格式化时间
time.gmtime()	结构化时间
time.strptime()	格式化转结构化

datetime模块

属性或方法	描述
date.today()	获取当前日期
datetime.today()	获取当前日期和时间
datetime.timedelta(days=3)	获取两个时间之间的时间差
datetime.now()	获取当前日期和时间
datetime.utcnow()	获取当前格林威治的日期时间
datetime(2021, 5, 20, 13, 14)	创建指定的日期时间

os模块

属性或方法	描述
os.mkdir()	创建单级目录（不能创建多级目录）
os.makedirs()	创建单级目录或多级目录
os.rmdir()	删除单级目录，不支持删除多级目录（有数据的目录无法删除）
os.removedirs()	由内而外递归删除空目录，直到有数据的目录为止（有数据的目录无法删除）
os.listdir()	列举指定路径下的文件名称(文件、目录)
os.rename()	重命名文件
os.remove()	删除文件
os.getcwd()	获取当前工作路径(所在的路径) ，绝对路径
os.chdir()	改变当前工作目录到指定的路径
os.path.abspath(__ file__)	获取当前文件的绝对路径(可以不记)
os.path.dirname(__ file__)	获取当前文件所在的目录路径(必须得记)
os.path.exists()	判断路径是否存在文件、目录
os.path.isdir()	用于判断路径是否是目录(文件夹)
os.path.isfile()	用于判断路径是否是文件
os.path.join()	拼接路径
os.path.getsize()	获取文件大小(bytes)

sys模块

属性或方法	描述
sys.argv()	命令行参数List，第一个元素是程序本身路径
sys.exit(n)	退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version()	获取Python解释程序的版本信息
sys.path()	返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的
sys.platform()	返回操作系统平台名称

json模块

属性或方法	描述
json.dumps()	将其他数据类型转换成json格式字符串
json.loads()	将json格式字符串转化成对应的数据类型
json.dump()	将其他数据数据以json格式字符串写入文件
json.load()	将文件中json格式字符串读取出来并转换成对应的数据类型

标签：__,文件,迭代,笔记,print,第五,导入,模块,整理
来源： https://www.cnblogs.com/NianBai/p/16488018.html