No.24总结

Posted 2021-03-04 elliottwave

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了No.24总结相关的知识，希望对你有一定的参考价值。

No.24

内容概要

模块梳理
面向对象

内容回顾和补充

1.单例模式

什么是单例模式？
应用场景
__new__方法：创建实例，并且在__init__之前工作。
- new方法在创建对象空间时，还会在空间内创建一个指针指向对象所属类的地址。

2.logging模块

记录目的
- 给用户看
  - 银行流水
- 给程序员看
  - 统计（访问量等）
  - 故障排除
  - 用来记录错误，完成代码优化。debug
basicconfig
- 优点：使用方便
- 缺点：编码问题，不能同时向文件和屏幕输出等。
- logging.debug / logging.warning

logger对象

优点：太多
缺点：复杂
流程
- 创建一个logger对象
- 创建一个文件操作符
- 创建一个屏幕操作符
- 创建一个格式
- 给logger对象绑定文件和屏幕操作符
- 给文件和屏幕操作符设定格式
- 最后用logger对象来操作

import logging

logger = logging.getLogger()  # logger对象

fh = logging.FileHandler('log_paper.log')  # 文件操作符
sh = logging.StreamHandler()     # 屏幕操作符
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(module)s: %(message)s') # 格式

fh.setFormatter(formatter)  # 把格式绑定到文件操作符对象中
sh.setFormatter(formatter)  # 绑定到屏幕操作符对象中

logger.addHandler(fh)  # 把文件对象放入logger中
logger.addHandler(sh)

logger.warning('message')

3.collections模块

OrderedDict

from collections import OrderedDict

dic = dict([('a', 1), ('b', 2), ('c', 3)])
print(dic)

odic = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(odic)

for k in odic:
    print(k, odic[k])

namedtuple ▲

from collections import namedtuple  # 可命名元组
# 创建了一个只含有name price teacher 属性的类 course是类名
Course = namedtuple('Course',['name','price','teacher'])
python = Course('Python', 19800,'alex') # 创建了一个对象,封装了三个数据,不可进行更改.
# 这三个数据在底层是以元组的形式储存,固然这个对象中的值不能修改.
print(python)  # Course(name='Python', price=19800, teacher='alex') 元组的形式储存数据
print(python.name)
print(python.price)
# 创建了一个类,这个类没有方法,所有属性的值都不能修改

defaultdict
deque

4.项目开发

模块

什么是模块？
- py文件：已经写好的对程序员直接提供某方面功能的文件。
- 导入方式
  - import
  - from xxx import xxx
什么是包？
- 文件夹：存储了多个py文件的文件夹
- 注意事项
  - 导入一个包，相当于执行包中__init__文件
  - 如果导入的是一个包，包中其它模块默认是不能用的

规范
- 项目总目录
  - bin 程序入口
    - 模块搜索路径
```
import os
import sys
base_path = os.path.dirname(os.path.dirname(__file__))
# __file__永远是当前执行文件的绝对路径
sys.path.append(base_path)
```
  - conf 配置
    - settings.py
  - src 业务逻辑
    - student.py
      - from src import core 导入core模块（注意：只有放执行文件的bin目录和项目总目录被添加进搜索路径）
    - core.py
      - from conf import settings 导入settings模块
  - db 数据文件
  - lib 扩展模块
  - log 日志文件

5.栈和队列

栈 Stack
- 后进先出的队列 lifoqueue（last in first out）
队列 Queue
- 先进先出的队列 fifoqueue（fifo first in first out）

6.反射

通过对象来获取实例变量、绑定方法
通过类来获取类变量、类方法、静态方法
通过模块名来获取模块中的任意变量(普通变量、函数、类)
通过本文件来获取本文件中的任意变量

hasattr ▲

getattr ▲

# 反射当前文件中的内容
a = 666
import sys
print(getattr(sys.modules['__main__'], 'a')) 
print(getattr(sys.modules['__name__'], 'a'))

setattr
delattr

7.抽象类/接口类

就是给子类一个规范，让子类必须按照抽象类的规范来实现方法。

# Foo就是一个抽象类
class Foo:
    def func(self):
        raise NotImplementedError

class Son(Foo):
    def func(self):
        pass

s = Son()
s.fun()

内容详细

模块

os 操作系统

path.isfile() 判断一个目录是不是文件
path.isdir() 判断一个目录是不是文件夹

习题

'''
计算任意一个文件夹的大小(考虑绝对路径)
基础需求：这个文件夹中只有文件
进阶需求：这个文件夹中有多层文件夹嵌套，每一个文件夹中含有文件
'''
import os
def dir_size(path):
    total = 0
    File = os.walk(path)
    for file,son_file,papers in File:
        for paper in papers:
            paper_path = os.path.join(file, paper)
            size = os.path.getsize(paper_path)
            total += size
    return total
dir_size(path)

sys

sys.path 模块搜索路径一个模块能否被导入全看sys.path中有没有这个模块的路径
sys.argv 获取命令行参数
sys.modules 存储了当前程序中用到的所有模块

datetime

now() datetime对象
utcnow()
strftime(‘%Y-%m-%d %H:%M:%S‘) 格式化时间 datetime转str
strptime(‘2020-8-18 10:18:18‘, ‘%Y-%m-%d %H:%M:%S‘) str转datetime
timedelta(days=180) 时间加减
timestamp(datetime对象)
fromtimestamp(时间戳时间)

time

time() 时间戳时间
sleep(n) 让程序暂停n秒

hashlib 摘要算发模块

md5

# 数据加密
import hashlib
md5 = hashlib.md5('盐'.encode('utf-8'))
md5.update('str'.encode('utf-8'))
print(md5.hexdigest())

# 效验一致性
import hashlib
md5 = hashlib.md5()

md5.update('hellow'.encode())   
# md5.update('hell'.encode())   切分了字符串最后结果也一样
# md5.update('ow'.encode())     # 296ab79bb0e6b305a21f964bd2ac8531

print(md5.hexdigest())          # 最终结果一样

补充

# f.read(10)
# r 模式：读十个字符
# rb模式：读十个字节

# '中国'里面的'中'是一个字符
# 'alex'里面的'a'是一个字符

习题

# 两个大文件一致性校验
'视频图片文件'
import os
import hashlib
path1 = 'test1'
path2 = 'test2'

def file_md5(path):
    size = os.path.getsize(path)    # 获取文件总字节数
    md5 = hashlib.md5()
    with open(path, mode='rb') as f:
        while size > 1024:
            content = f.read(1024)  # 每次读1024个字节,
            md5.update(content)
            size -= 1024
        else:
            content = f.read()
            md5.update(content)
            size = 0
    return md5.hexdigest()

print(file_md5(path1) == file_md5(path2))

'文本文档'
import hashlib
path1 = 'test.txt'
path2 = 'tes'

def file_md5(path, row):  # 路径 每次读多少行
    md5 = hashlib.md5()
    count = 0
    with open(path, mode='r', encoding='utf-8') as f:
        while True:
            for line in f:
                md5.update(line.strip().encode('utf-8'))
                count += 1
                if count == row:
                    break
            content = f.readline()
            md5.update(content.strip().encode('utf-8'))
            if not content:
                break
    return md5.hexdigest()

print(file_md5(path1,5) == file_md5(path2,5))

sha

# 一般用sha1算发
import hashlib
sha = hashlib.sha1('盐'.encode('utf-8'))
sha.update('str'.encode('utf-8'))
print(sha.hexdigest())

json

序列化：把其它数据类型转换成 str / bytes 类型

反序列化：str / bytes 类型转换回原数据类型

所有的字符串都是双引号
最外层只能是列表或字典
只支持 int/float/bool/str/list/dict
字典的key只能是str（若key是其它类型在反序列化回来时key会变成str）
不能连续load多次（两个列表被分别序列化写入文件后，当读取文件时反序列化就会报错）
支持所有语言

pickle

几乎所有数据类型都能序列化和反序列化
支持连续load多次
只支持Python

random

randint
choice(可迭代对象)
- 验证码 / 抽奖

sample([1,2,3,4,5], 3)

随机选三个，一个奖抽取多人。

'''
发红包
每一个人能够抢到的金额的概率都是平均的
200
100
50
解决小数的不准确性
'''
# 方式一
import random

def red_pack(money, num):
    ret = random.sample(range(1, money * 100), num - 1)  
    ret.sort()
    ret.insert(0, 0)
    ret.append(money * 100)
    for i in range(len(ret) - 1):
        yield ((ret[i + 1] - ret[i]) / 100)

ret = red_pack(200, 10)
for i in ret:
    print(i)

# 方式二
import random

def fun(All_money, num):
    total_money = All_money * 100
    Moy = total_money
    while num > 1:
        accuracy = total_money / num  # 100 / 9  精准价 11.1111
        money = total_money // num  # 取整价 11
        difference = accuracy - money  # 差价 0.1111
        while True:
            result = random.randint(0, money)  # 每次抢得红包金额 10
            if result != 0:
                break
        Moy -= result
        yield result / 100
        total_money = total_money - result + difference  # 剩余红包金额 100 - 10 + 0.1111
        num = num - 1  # 剩余红包数 9 - 1
    yield Moy / 100

for i in fun(200, 10):
    print(i)

random.uniform(1,5)
- 取1到5之间的随机小数，没有位数限制。
shuffle
- 所有的棋牌类游戏，算发

logging

basicconfig
logger对象

collections

OderedDict
namedtuple
deque 双端序列
defaultDict 默认字典，可以给字典的value设置一个默认值。

shutil

make_archive() 压缩文件
unpack_archive() 解压文件
rmtree() 删除目录
move() 重命名，移动文件

getpass

getpass 在命令行密文显示输入的内容

copy

copy
deepcopy

importlib

import_module(‘模块名‘)
- 等效于 __import__(‘模块名‘)

functools

reduce(函数,可迭代对象)

面向对象

基础概念

什么是类
- 具有相同方法和属性的一类事物
什么是对象/实例
- 拥有具体属性和动作的个体
实例化
- 从一个类得到一个具体对象的过程

组合

一个类的对象作为另一个类对象的实例变量

class C_learn(object):
    pass
python = C_learn()    # python是课程类的对象

class Student(object):
    pass
alex = Student()      # alex是学生类的对象

alex.course = python  # 组合

三大特性

所有的查找名字(调用方法和属性)都是先找自己的，自己没有找父类。
如果自己和父类都有，希望自己和父类都调用，则通过 super()/指定类名两种方式调用。

继承
- 父类/基类/超类
- 子类/派生类
- 单继承
  - 子类可以使用父类的方法
- 多继承
  - 查找顺序
    - 深度优先：Py2
    - 广度优先：Py3
```
class A:
    def func(self):
        print('a')

class B(A):
    def func(self):
        print('b')

class C(A):
    def func(self):
        print('c')

class D(B, C):
    def func(self):
        print('d')

obj = D()
obj.func()
print(D.mro()) # 查看继承查找顺序
# Py2查找顺序：DBAC
# Py3查找顺序: DBCA
```
  - 新式类和经典类
    - Py2 继承object类就是新式类，默认是经典类。
    - Py3 都是新式类，默认继承object类。
    - 新式类
      - 继承object
      - 新式类支持super
      - 对于多继承广度优先(C3算法)
      - 有mro方法(查看继承查找顺序)
    - 经典类
      - 不继承object
      - 经典类没有super
      - 对于多继承深度优先
      - 无mro方法
多态
- 一个类表现出来的多种状态
- 鸭子类型
封装
- 广义：类中的成员
- 狭义：私有成员
  - __名字
  - 只能在类的内部使用，既不能在类外部调用，也不能在子类中调用。
  - 外部强制访问：_类名__名字

类成员

类变量
绑定方法
特殊成员
- 类方法 classmethod
- 静态方法 statcmethod
- 属性 property
双下方法/魔术方法/内置方法
- __new__ 构造方法
- __init__ 初始化方法
- __call__ 源码中很容易写这个用发
- __str__
- __enter__&__exit__ with上下文管理
- __getitem__ 跟中括号访问有关系
- __setitem__
- __delitem__
- __add__
- __iter__
- __dict__