python笔记24（回顾、复习）

一、内容回顾

面向对象

类变量
方法
：静态方法
：类方法
：绑定方法
：属性property

单例模块

单例模块：设计模式

单例的应用场景

__new__(self):实例创建，在init之前工作

logging模块

记录日志的

记录错误、操作日志

给程序员看的：①统计使用；②用来做故障排除的（debug）；③记录错误，完成优化代码的。

logging.basicconig:①使用方便，②不能实现，编码问题；不能同时向文件和屏幕上输出。

logging.debug,logging.warning

logger对象：

复杂：
①创建一个logger对象；
②创建一个文件操作符；
③创建一个屏幕操作符；
④创建一个格式；
给logger对象绑定文件操作符
给logger对象绑定屏幕操作符
给文件操作符设定格式
给屏幕操作符设定格式
用logger对象来操作。
import logging
logger=logging.getLogger()
fh=logging.FileHandler('log.log')
sh=logging.StreamHandler()
logger.addHandler(fh)
logger.addHandler(sh)
formatter=logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s')
sh.setFormatter(formatter)
fh.setFormatter(formatter)
logger.warning('message')

collections模块

from collections import OrderedDict
odic=OrderedDict([('a',1),('b',2),('c',3)])
print(odic)
# # odic['k']='k1'
# # odic['k1']='k2'
for k,v in odic.items():
    print(k,v)

#模块namedtuple
#创建一个类，这个类没有办法，所有属性的值都不能修改
from collections import namedtuple
Course=namedtuple('course',['name','price','teacher'])
python=Course('python',1980,'lexm')
print(python)
print(python.name)
=======================
course(name='python', price=1980, teacher='lexm')
python

====
只读属性：t属性不能修改
import time
t=time.localtime()
print(t)

项目开发规范

补充

反射

hasattr
setattr
getattr
class A:
    @staticmethod
    def func():
        print('12345')
    
getattr(A,)
delattr

通过对象来获取实例变量、绑定方法

通过类 来获取类变量，类方法、静态方法

通过模块名来获取模块中的任意变量（普通变量，函数，类）

通过文本件来获取本文件中的任意变量。

getttr(sys.modules[__name__],'变量名')

抽象类/接口类

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

class Foo:
    def func(self):
        raise NotImplementedError

 class Son(Foo):
    pass

s=Son()
s.func()

模块和包

模块：py文件写好了的，对程序员直接提供某方面功能的文件。

import,from import

什么是包：

文件夹，存储多个py文件的文件夹。

如果导入的是一个包的化，这个包里的模块默认是不能用的。

需要完成__init__.py文件的内容。

导入一包相当于执行init.py文件中的内容。

项目规范

bin  start
#import os，sys
#base_path=os.path.dirname(os.path.dirname(__file__))#当前文件
#sys.path.append(base_path)
#from src import core
conf  setting
src  业务逻辑
student.py
from src import core
core.py
from conf import settings
db  数据文件
lib  扩展文件
log  日志文件

模块总结

os：操作系统(作业：计算文件夹大小，考虑绝对路径)
os.path.getsize('d:codes21')
#文件
#文件
#路径
#listdir,walk

sys
#sys.path 模块搜索路径，一个模块是否能被导入，全看sys.path中是否有这个模块所在的路径。
#sys.argv,获取命令行参数，python c://aaa.py remove 文件路径
#sys.module，存储了当前程序中用到的所有模块，反射文件中内容。
json，支持所有语言
#序列化，将其他类型转换成str/bytes类型
#json格式：
#1所有的字符串都是双引号
#2最外层只能是列表或者字典
#3只支持int float str list dict bool
#4存在字典的key只能是str
#5不能连续load多次
pickle，只支持py
#1所有的数据类型都可以写到文件中
#2支持连续load多次
random（作业，发红包，没一个人抢到金额概率一样，共计200元，小数的不准确性（print(random.uniform(1,5)））
import random
random.choice([1,2,3,4])#随机抽取一个
random.sample([1,2,3,4,5],3)#抽取多个
#randint
#choice
#sample                                                
#shuffle,洗牌，算法

time
#time时间戳
#sleep（）让程序暂停ns
hashlib(作业，检验文件的一致性，文件，视频，图片)
#md5
#sha
#import hashlib
#hashlib.md5('xxl'.encode())--如果使用sha算法时，将此处md5改成sha
#md5.update('str'.encode())
#print(md5.hexdigest())

datetime
from datetime import datetime
dt=datetime.now()
print(datetime.timestamp(dt))
#now()
#utc()
#strftime('%Y-%m-%d')获取到一个datetime对象
#timedelta(days=140),时间的加
#fromtimestamp(时间戳)时间戳转datetime
#timestamp(datetime对象),datetime转时间戳
pickle
shutil
#import
shutil.make_archive()压缩文件，shutil.unpack_archive()解压文件，shutil.retree()删除目录，shutil.move(),移动文件

#importlib
#import importlib
#importlib.import_module('模块名')
#print(os.path.isdir('xxx')),判断是否为目录，isfile,是否为文件                                                
copy
getpass，在命令行密文显示
                                                
copy
                                                
logging
#两种配置方式：basicconfig,logger
 collections
 #OderdDict,namedtuple,deque,defaultDict
  functools
 #reduce(add,iterable)                                               
                                                
                                                
                                                

面向对象

三大特性：封装，继承，多态
#封装：
①广义的封装：类中的成员
②狭义的封装：私有成员,__名字，只有在类的内部使用，类的外部不能调用。
#继承，所有的查找名字（调用方法和属性）都是先找自己，自己没有找父类
#如果自己和父类都有，希望自己和父类都调用，super（）指定类名直接调用
①父类，基类，超类
②派生类，子类
③多继承，查找顺序，深度优先，广度优先
④单继承，子类可以使用父类的方法
#多态
-一个类表现出来的多种状态,多个类表现出相似的状态
-user类，用户类
-vip_user
-svip_user
①鸭子类型
#vip_user,svip_user
#list,tuple
基础概念：
#什么是类:具有相同方法和属性的一类事物
#什么是对象，实例：一个拥有具体属性值和动作的具体个体
#实例化：从一个类得到一个具体对象的过程
#实例
#实例化
组合：
#一个类的对象作为另一个类对象的实例变量
类成员：类变量，绑定方法，
特殊成员：类方法classmethod
静态方法：staticmethod
属性：property

特殊成员
双下方法，魔术方法，内置方法
#__str__
__new__，构造方法
__init__，初始化方法
__dict__
__call__,对象加括号就能使用
__enter__,__exit__，with上下文管理
__getitem__
__setitem__
__delitem__
__add__，两个对象相加
__iter__
__dict__

相关内置函数：isinstance,对象和类
issubclass,类和类
type,类型，类=type（对象）
super遵循mro顺序查找上一个类的

新式类和经典类：
py2继承object就是新式类
#默认是经典类
py3都是新式类，默认继承object

新式类：
#继承object
支持super
多继承，广度优先
mro方法

经典类：
#py2中不继承object
#没有super语法
#多继承深度优先
没有mro方法