本周内容概览

函数
- 常见内置函数
- 可迭代对象与迭代器对象
- 异常捕获
- 生成器对象
- 生成器表达式
- 迭代取值与索引取值的区别
模块
- 模块简介
- 循环导入问题
- 模块的查找顺序
- 绝对导入与相对导入
- 包的概念
- 软件开发目录规范
- 常见内置模块

一、函数

常见内置函数

# abs 求绝对值
abs(-5)  # 5
# all与any 判断是否数据内数据值的对应布尔值是否都为True
# all判断是否全为True
all(1, 0)  # False 
all(1, 1)  # True
#  any判断是否有一个为True
any(1, 0)  # True
any(1, 1)  # True
# bin oct hex 将其他进制数转换为对应的进制数
# bin 二进制
res = bin(50)
print(res)  # 0b110010
# oct 八进制
res = oct(0b110010)
print(res)  # 0o62
# hex 十六进制
res = hex(0o62)
print(res)  # 0x32
# int 转换数据类型，将其他进制转换为十进制
res = int('20')
print(res, type(res))  # 20 <class 'int'>
print(int(0o62))  # 50
# bytes 将数据值转换成二进制
print(bytes([1, 2, 3, 4, 5]))  # b'\x01\x02\x03\x04\x05'
# coolable 判断名字是否能加括号执行
name = 'jason'
print(callable(name))  # False
def func(): pass
print(callable(func))  # True
# chr ord 字符与ASCII码相互转换
# ord 将对应字符转换成ASCII码
print(ord('a'))  # 97
# chr 将ASCII码转换成对应字符
print(chr(65))  # A
# dir 获取对象内部可以通过句点符获取的数据
print(dir(str))
# divmod 分别获取除法后的商和余
d1, d2 = divmod(10, 3)
print(d1, d2)  # 3 1
# enumerate 枚举
for e, i in enumerate([11, 22, 33]):
	print(e, i)

可迭代对象与迭代器对象

迭代是需要基于上一次的结果，越来越靠近目标
内置有__iter__方法的都可以被称为可迭代对象
能够被for循环的数据类型都是可迭代的
可迭代对象调用__iter__返回一个迭代器对象
迭代器对象拥有__iter__和__next__两种方法
迭代器对象提供了一种不依赖与索引的取值方式
迭代器对象一定是可迭代对象，可迭代对象不一定是迭代器对象
__iter__和__next__可以简写为iter() next()
迭代器对象不会直接生成全部数据，只会在调用时生成一个，有效节省内存
异常捕获

一旦程序出现了异常，程序就会停止运行

异常的结构：
- 第二行代表错误的位置
- 第三行代表错误类型和具体错误信息
异常分为语法错误和逻辑错误：
- 语法错误是不能也不应该出现的错误，说明代码的语法不正确
- 逻辑错误是可以出现的错误，发现及时修改
  什么情况下使用异常捕获：
- 在代码可能会因为一些不确定的因素导致报错时
- 异常捕获相当在报错之前就准备好报错后采取的措施
异常捕获的语法结构
```
try:
	预测可能会异常的代码
except 错误类型 as e:
	对应错误类型的应对措施
"""
try关键字
可以使用多个except
e代表详细的错误信息
错误类型可以使用Exceptin，捕获所有错误类型
可以使用else语句，在try语句正常结束时执行
可以使用finally语句，无论如何都会执行
"""
```
```
  ##### 主动抛出异常
  * 使用raise关键字加错误类型，可以主动抛出异常信息
```

生成器对象

生成器

本质上就是迭代器，只不过迭代器是解释器提供的，生成器是我们自定义的
学习生成器对象的目的是为了优化代码，提供了一种不基于索引的取值方式，还有就是可以减少占用内存

自定义生成器

def func():
	print(111)
	num = yield 123
	print(num)
	print(222)
	yield
res = func()
print(res)  # <generator object func at 0x000001CD2C090AC0>
res1 = res.__next__()  # 111
print(res1)  # 123
res.send(321)
"""
在函数中使用yield关键字，在调用时不会执行函数体代码，而是返回一个生成器对象
使用__next__方法执行函数体代码，在遇到yield停滞，等待下一次执行
可以在yield后添加返回值
yield还可以接收外界传入的数据值
send除了传入数据外还自动调用了__next__方法
使用send方法前必须先使用一次__next__方法
"""

生成器表达式

和列表生成器类似，外层使用小括号括起来可以使用一个for和一个if

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

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

迭代取值：
- 不依赖与索引，对于无序数据类型也可以取值
- 只能依次向下取值
索引取值
- 不能取值无序数据类型
- 可以根据索引任意取值

二、模块

模块简介

模块就是将许多功能结合在一起的一个py文件
- 模块的分类
1. 内置模块
  python解释器自带的，可以直接导入
2. 自定义模块
  我们自己写的模块文件
3. 第三方模块
  别人写的模块，存放于网络上，使用前需要下载
- 导入模块的句式
1. import
```
 import md
 md.fn()
"""
 直接使用import导入模块，使用模块名.名字的方式调用模块中的名字
 这样导入不容易产生变量名冲突
 但是会将所有的名字全部导入
 """
```
1. from…import…
```
from md import fn
fn()
"""
导入md模块中的fn函数名，然后就可以直接使用了
这样可以控制导入哪些名字
但是容易产生变量名冲突
"""
```
- 补充知识
1. 起别名
  一般在多个模块文件名相同或原有的模块文件名复杂的情况下使用
  在import后使用as关键字加上想要起的别名
```
import md as m
```
2. 导入多个名字
  在import后填写多个模块名，名字之间使用逗号隔开，就可以导入多个模块，不过除非模块功能相似，不然不建议这么写
```
import time, datetime
```
3. 全部导入
  在想要直接导入模块内所有名字时，可以使用*号全部导入
```
from dm import *
```
循环导入问题
- 循环导入就是两个文件之间相互导入
a.py：
```
import b
def a_func():
	pass
b_func()
```
b.py
```
import a
def b_func():
	pass
a_func()
```
- 在导入b文件时会先执行，执行b文件会导入a文件，导入a文件会执行a文件，a文件因为导入过b文件所以不会再导入，执行到调用b_func时还没有导入，所以报错
- 解决方法是在导入前先把名字准备好，但最好不要出现循环导入现象
模块的查找顺序
- 模块的查找顺序为：内存>内置>sys.path中路径
绝对导入与相对导入
- 绝对导入：
  根据项目的根目录一层层往下找，如不是使用的pycharm，最好在运行文件中先将sys.path中添加项目根目录
- 相对导入：
  根据运行文件的位置，去导入对应模块位置
  相对导入只能在模块文件中使用，不能在运行文件中使用
  相对导入使用 . 表示当前目录， … 表示上级目录， …/… 表示上上级目录
包的概念
- 对于python3来说，文件夹就是包，对于python2来说，只有文件夹里带有__init__.py文件的才是包
- 包是为了更方便的管理模块文件，一个包里一般存放功能类似的模块
- 具体使用
```
import 包名
"""
导入包名实际上是导入包的__init__.pu文件
能使用的只有__init__文件中导入的模块
可以使用这个特性来控制导入包时可以使用的模块
"""
```
软件目录开发规范

以后使用多个文件夹编程时，对于文件夹的名字有一定的规范
1. bin 用于存放程序启动文件
2. conf 用于存放程序配置文件
3. core 用于存放程序核心逻辑
4. db 用于存放程序数据文件
5. lib 用于存放程序公共功能
6. log 用于存放程序日志文件
7. interface 用于存放程序接口文件
8. read.txt 编写程序说明
9. requirements.txt 保存程序所需第三方模块的名字和版本

常见内置模块

collections

"""提供了更多数据类型"""
# 具名元组
from collections import namedtuple
coord = namedtuple('坐标', ['x', 'y'])
# coord = namedtuple('坐标', 'x y')  # 简写
res = coord('4', '9')
print(res)  # 坐标(x=4, y=9)


# 双端队列
from collections import deque
res = deque()
print(res)  # deque([])
res.append(1)
res.append(2)
res.append(3)
print(res)  # deque([1, 2, 3])
"""
队列的特性是先进先出
而双端队列两端都可以增加和移除数据
"""
res.appendleft(4)
print(res)  # deque([4, 1, 2, 3])
res.pop()
print(res)  # deque([4, 1, 2])
res.popleft()
print(res)  # deque([1, 2])


# 有序字典
from collections import OrderedDict
"""
字典在python3.6之前是无序列表
可以使用这个模块生成有序字典
"""
d2 = OrderedDict([('a', 1), ('b', 2)])
print(d2)


# 默认字典
from collections import defaultdict
"""可以先看做一种构建字典的方式"""
d1 = defaultdict(k1=[], k2=[])
print(d1)  # defaultdict(None, {'k1': [], 'k2': []})


# 计数器
from collections import Counter
res = 'asdfzxcvfdasvczx'
d2 = Counter(res)
print(d2)  # Counter({'a': 2, 's': 2, 'd': 2, 'f': 2, 'z': 2, 'x': 2, 'c': 2, 'v': 2})

time模块
- 时间模块有三种格式：
  1. 时间戳：time.time()，返回值是从1970年1月1号0时0分0秒到执行时经过的秒数
  2. 结构化时间：time.gmtime()，返回值是方便计算机识别的时间元组
  3. 格式化时间：strftime()，返回值是方便我们看的时间
    时间戳和格式化时间不能相互转换，需要经过结构化时间转换
datetime模块
- 和time模块相似，都是关于时间的模块
  不过datetime模块把功能分成了几个类
  最主要使用的有：
1. time 关于时间
2. date 关于日期
3. datetime 关于日期与时间
4. timedelta 关于时间间隔
5. tzinfo 关于时区

import datetime
"""获取当前日期时间"""
t1 = datetime.datetime.today()
print(t1)  # 2022-07-15 15:59:55.932242
t2 = datetime.datetime.now()
print(t2)  # 2022-07-15 15:59:55.932242


"""获取当前日期"""
d1 = datetime.date.today()
print(d1)  		# 2022-07-15


"""获取时间间隔"""
t1 = datetime.timedelta(days=3)  # 获取时间差值
print(t1)  # 3 days, 0:00:00

os模块

os模块的操作主要是跟运行程序的操作系统相关

importos
"""创建目录"""
os.mkdir(r'a')  # 创建单级目录
os.makedirs(r'a\b\c')  # 创建多级目录

"""删除目录"""
os.rmdir(r'a')  # 删除单级目录，如果目录不是空目录就会报错
os.removedirs(r'a\b\c')  # 只能删除空目录，如果最下层目录删除后，上层目录也是空目录了，那么会继续删除，直到遇到不是空的目录

"""列举指定路径下的所有目录与文件"""
l1 = os.listdir()
print(l1)  # 返回的结果是一个列表
l2 = os.listdir(r'D:\\')  # 也可以使用绝对路径或相对路径指定目录

"""重命名目录或文件"""
os.rename(r'a', r'b')  # 第一个参数是原名字，第二个参数是新名字
os.rename(r'a\aa', r'a\bb')  # 如果要修改目录下的文件，新名字也需要填写目录路径，否则会移动到执行文件的目录下

"""删除文件"""
os.remove(r'f.txt')

"""获取当前工作路径(绝对路径)"""
job_path = os.getcwd()
print(job_path)  # F:\pythonProject\day23
# 获取的是当前工作路径，也就是执行文件的所在的路径，所以导入的其他文件中使用到了os.getcwd，也是打印的执行文件所在的路径

"""获取文件路径"""
print(os.path.abspath(__file__))  # 获取当前文件的绝对路径
print(os.path.dirname(__file__))  # 获取当前文件的目录路径
# os.path.dirname与os.getcwd在同一个文件中获取的路径是一样的，但是模块文件使用os.path.dirname，还是返回模块文件所在的目录路径

"""判断路径是否存在"""
print(os.path.exists(r'a'))  # True  判断指定路径的目录或文件是否存在
print(os.path.exists(r'a\b\c\a.txt'))  # True
print(os.path.exists(r'a\c'))  # Flase
print(os.path.isdir(r'a'))  # True    只能判断指定的是否是目录
print(os.path.isdir(r'aaa.txt'))  # False
print(os.path.isfile(r'aaa.txt'))  # True 只能判断指定的是否是文件
print(os.path.isfile(r'a'))  # False

"""拼接路径"""
p = os.path.dirname(__file__)
print(p)  # F:\pythonProject\day23
res = os.path.join(p, 'a.txt')
print(res)  # F:\pythonProject\day23\a.txt
# 因为操作系统的不同，路径分隔符也不同，使用join可以自动识别当前系统而使用正确的分隔符

"""获取文件大小"""
print(os.path.getsize(r'aaa.txt'))  # 1596 使用bytes为单位
print(os.path.getsize(r'a'))  # 0 不能获取目录大小

sys模块

sys模块的操作主要是跟python解释器相关

import sys
print(sys.path) # 返回查询模块路径的列表
print(sys.version)  # 返回当前解释器信息
print(sys.platform)  # 查询当前的操作系统

"""argv"""
# 使用argv需要以命令行执行当前文件，执行文件时使用空格追加数据值，argv的返回值是列表，列表第一个值是文件名
# 使用异常捕获实现登录功能
res = sys.argv
'''需求 命令行执行当前文件必须要提供用户名和密码 否则不准执行'''
try:
    username = res[1]
    password = res[2]
except IndexError as e:
    print('需要输入用户名和密码')
else:
    if username == 'jason' and password == '123':
        print('您可以执行该文件')
    else:
        print('用户名或密码错误')

json模块

用于与其他操作系统传递数据

import json
"""序列化"""
user_dict = {'name': 'jason', 'pwd': 123}
res = json.dumps(user_dict)
print(res)  # {"name": "jason", "pwd": 123}
"""dump需要配合open打开文件使用"""
with open('a.txt', 'w') as f:
	json.dump(user_dict, f)  # 序列化并写入文件
"""反序列化"""
res1 = json.loads(res)
print(res1)  # {'name': 'jason', 'pwd': 123}
"""load需要配合open打开文件使用"""
with open('a.txt', 'r') as f:
	res2 = json.load(f)  # 反序列化并将内容读出到res2