day21——面向对象初识、结构、从类名研究类、从对象研究类、logging模块进阶版

day21

面向对象的初识

面向对象第一个优点: 对相似功能的函数,同一个业务下的函数进行归类,分类.

想要学习面向对象必须站在一个上帝的角度去分析考虑问题.

类: 具有相同属性和功能的一类事物.

对象:某个类的具体体现.

汽车: 汽车类, 楼下停着一个车牌号为9nb11的奥迪对象.

猫科类: 类. 陈硕家的养的那个大橘.对象.

鸡类: 一个类. 家里养的一只鸡.

男神:是一类. 太白对象.

面向对象的第二优点: 你要站在上帝的角度构建代码,类就是一个公共的模板,对象就是从模板实例化出来的.

得到对象就得到了一切.

# 面向过程编程vs函数
面向过程编程
# s1 = 'fdskajfdfsdfs'
# count = 0
# for i in s1:
#     count += 1
# print(count)

# l1 = [i for i in range(10)]
# count = 0
# for i in l1:
#     count += 1
# print(count)

函数# 减少了重复代码,增强了可读性
# l1 = [i for i in range(10)]
# def my_len(argv):
#     count = 0
#     for i in argv:
#         count += 1
#     print(count)
# my_len(l1)

# 函数式编程vs面向对象编程
函数式编程
def login():
    pass

def register():
    pass

def shopping_car():
    pass

def change_pwd():
    pass

def check_paid_goods():
    pass

def check_unpaid_goods():
    pass

面向对象编程
class Auth:

    def login(self):
        pass

    def register(self):
        pass

    def change_pwd(self):
        pass

class Shopping:

    def shopping_car(self):
        pass

    def check_paid_goods(self):
        pass

    def check_unpaid_goods(self):
        pass
'''
面向对象第一个优点: 对相似功能的函数,同一个业务下的函数进行归类,分类.

想要学习面向对象必须站在一个上帝的角度去分析考虑问题.
    类: 具有相同属性和功能的一类事物.
    对象:某个类的具体体现.

汽车: 汽车类, 楼下停着一个车牌号为9nb11的奥迪对象.
猫科类: 类. 陈硕家的养的那个大橘.对象.
鸡类: 一个类. 家里养的一只鸡.
男神:是一类. 太白对象.

面向对象的第二优点: 你要站在上帝的角度构建代码,类就是一个公共的模板,对象就是从模板实例化出来的.
得到对象就得到了一切.
'''

面向对象的结构

类的命名为驼峰式

class Human:
    """
    类的具体结构
    """
    # 第一部分:静态属性
    mind = '有思想'   # 类的属性  (静态属性, 静态字段)
    language = '使用语言'

    # 第二部分: 动态方法
    def work(self):
        print('人类都会工作')

    def eat(self):
        print('人类都需要吃饭')

从类名的角度研究类

类名操作类的属性

类名查看类中所有的内容

print(Human.__dict__)

类名操作类中的静态属性 万能的点.

增:
# Human.body = '有头和四肢'
删:
# del Human.mind
改:
# Human.mind = 'liye脑残'
查:
# print(Human.language)

# class Human:
#     """
#     类的具体结构
#     """
#     # 第一部分:静态属性
#     mind = '有思想'   # 类的属性  (静态属性, 静态字段)
#     language = '使用语言'
#
#     # 第二部分: 动态方法
#     def work(self):
#         print('人类都会工作')
#
#     def eat(self):
#         print('人类都需要吃饭')

# 类名操作类中的属性
#   1. 类名查看类中所有的内容
# print(Human.__dict__)
# 	2. 类名操作类中的静态属性  万能的点.
增:
# Human.body = '有头和四肢'
删:
# del Human.mind
改:
# Human.mind = 'liye脑残'
查:
# print(Human.language)
# print(Human.__dict__)

类名调用类的方法

# 类名调用类中的方法(一般类中的(静态方法,类方法)方法不会通过类名调用)
Human.work(111)

总结

​ 一般类名就是操作类中的属性.

从对象的角度研究类

什么是对象

​ 对象是从类中出来的，只要是类名加上（），这就是一个实例化过程，这个就会实例化一个对象。

实例化对象发生了三件事

• 开辟一个对象空间.
• 自动执行______init______方法,并且将对象地址传给self.
• 运行______init______方法内的代码,给对象空间封装属性.

对象操作对象属性

• 对象查看对象的空间的所有属性

# obj = Human('李业',18)
# print(obj.__dict__)

• 对象操作对象空间的属性

# obj = Human('李业',18)
# 增:
# obj.sex = 'laddy_boy'
# 删:
# del obj.a
# 改:
# obj.a = 1000
# 查:
# print(obj.n)
# print(obj.__dict__)

对象查看类中的属性

只能调用无法改变

# obj = Human('李业',18)
# # print(obj.mind)
# obj.mind = '无脑的'
# print(obj.mind)
# print(Human.mind)

对象调用类中的方法

# obj = Human('孙戴维', 23)
# # print(f'obj---> {obj}')
# obj.work()
# obj.eat()

# class Human:
#     """
#     类的具体结构
#     """
#     # 第一部分:静态属性
#     mind = '有思想'   # 类的属性  (静态属性, 静态字段)
#     language = '使用语言'
#
#     def __init__(self):
#         # print(f'self---->: {self}')
#         # print(666)
#         self.name = '李业'
#         self.age = 18
#
#     # 第二部分: 动态方法
#     def work(self):
#         print('人类都会工作')
#
#     def eat(self):
#         print('人类都需要吃饭')
#
# obj = Human()  # 实例化过程
# 得到一个返回值,这个返回值就是 对象,实例.
# print(f'obj---> {obj}')
# 实例化一个对象发生了三件事:
'''
    1. 开辟一个对象空间.
    2. 自动执行__init__方法,并且将对象地址传给self.
    3. 运行__init__方法内的代码,给对象空间封装属性.

'''

class Human:
    """
    类的具体结构
    """
    # 第一部分:静态属性
    mind = '有思想'   # 类的属性  (静态属性, 静态字段)
    language = '使用语言'

    def __init__(self, name, age):
        # print(f'self---->: {self}')
        # print(666)
        self.n = name
        self.a = age

    # 第二部分: 动态方法
    def work(self):
        # print(f'self---> {self}')
        print(f'{self.n}都会工作')

    def eat(self):
        print(f'{self.n}都需要吃饭')

# obj = Human('李业',18)  # 实例化过程
# print(obj.n)
# print(obj.a)
# print(obj.__dict__)

# 一:对象操作对象空间的属性

# 1. 对象查看对象的空间的所有属性
# obj = Human('李业',18)
# print(obj.__dict__)

# 2. 对象操作对象空间的属性
# obj = Human('李业',18)
# 增:
# obj.sex = 'laddy_boy'
# 删:
# del obj.a
# 改:
# obj.a = 1000
# 查:
# print(obj.n)
# print(obj.__dict__)

# 二 对象查看类中的属性
# obj = Human('李业',18)
# # print(obj.mind)
# obj.mind = '无脑的'
# print(obj.mind)
# print(Human.mind)

# 三 对象调用类中的方法
# obj = Human('孙戴维', 23)
# # print(f'obj---> {obj}')
# obj.work()
# obj.eat()

# 一个类可以实例化多个对象
# obj1 = Human('李业',18)
# obj2 = Human('小可爱', 16)
# obj3 = Human('怼姐', 18)

# 变量,函数名:
# age_of_oldboy = 73
# Ageofoldboy

self是什么？

self 本身来说就是类中的方法的第一个位置参数，他会自动接收对象内存地址

一个类可以实例化多个对象

# 一个类可以实例化多个对象
# obj1 = Human('李业',18)
# obj2 = Human('小可爱', 16)
# obj3 = Human('怼姐', 18)

logging模块

• 系统日志：

  记录操作系统、服务器的硬件性能状态（cpu、网卡、内存运行），将你获取到的参数通过日志写入文件中，记录运维人员的命令

• 网站日志

  用户的访问次数，用户的停留时间，访问量，各地区的访问量等等

• 开发辅助日志

  debug、info模式、代替print

  try：

  ​ 错误

  except

  ​ 日志记录

• 用户信息日志

  记录用户的转账，流水等用户对系统的操作

更改版

"""
logging配置
"""

import os
import logging.config
# 定义三种日志输出格式 开始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '在 %(asctime)s %(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'stream': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'file': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': None,  # 日志文件
            'maxBytes': 1024*1024*1024,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['stream', 'file'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}

def get_logger():
    path = r'F:\s24\day21\liye.log'
    LOGGING_DIC['handlers']['file']['filename'] = path
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    return logger

def save():
    logger = get_logger()
    logger.info(f'{} 存入300元')  # 记录该文件的运行状态

save()

完全版

"""
logging配置
"""

import os
import logging.config

# 定义三种日志输出格式 开始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = 'all2.log'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}

def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()

logger配置文件