python进阶篇

小时候我们光着脚， 敢不顾深浅横撞直冲；长大后我们穿着鞋， 每走一步都小心翼翼。

1. 面对对象——封装

1.1 ：概念

面向对象的三大特征：封装、继承、多态。
类有：属性、方法
方法中的self，表示对象本身。

2. 代码

class Animal(object):
    def __init__(self,name,age,owner):      # 初始化方法
        self.name=name
        self.age=age
        self.__owner=owner      # 私有属性


    def setowner(self,owner):
        self.__owner=owner

    def getowner(self):
        return  self.__owner

    def __str__(self):      # 此方法必须有返回值，并且返回值的类型必须是 str 类型。
        return f"名字为：{self.name}\t年龄为：{self.age}\t主人为：{self.__owner}"

    def __del__(self):      # 对象销毁之前，自动调用这个方法
        print(f"啊，我被销毁了，呜呜呜~~")

dog=Animal("小白",5,"张三")
print(dog)      # 名字为：小白	年龄为：5	主人为：张三
dog.age=6
dog.setowner("李四")  # 私有属性不能直接赋值
print(dog)      # 名字为：小白	年龄为：6	主人为：李四
# 啊，我被销毁了，呜呜呜~~  （程序结束自动del dog）

2. 面对对象——继承-多态

2.1 概念

子类继承父类，子类会继承父类中公有的属性和方法。
super() 可以在子类中去调用父类中的同名方法。

2.2 代码

class Person(object):
    Have_eye=2      # 类属性
    
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        return f"名字：{self.name}\t年龄：{self.age}\t 眼睛数量：{self.Have_eye}"

    def __del__(self):
        print("Person被销毁")

    @staticmethod
    def show():
        print("我是Person")


class Student(Person):
    def __init__(self, height, name, age,money):
        super().__init__(name, age)
        self.height=height
        self.__money=money

    def getmoney(self):
        return self.__money

    def setmoney(self,money):
        self.__money=money

    def __str__(self):
        return f"名字：{self.name}\t年龄：{self.age}\t身高：{self.height}\t身价：{self.__money}\t眼睛数量：{self.Have_eye}"

    def __del__(self):
        super().__del__()      # 使用super 去调用父类中的同名方法
        print("Student被销毁")

    def show(self):
        print("我是Student")


class UniStudent(Student):

    def show(self):
        super(Student,self).show()  # super(子类名, self).方法名()  完整的写法
        super().show()
        print("我是大学Student")

    @classmethod
    def freak(cls,num):         # 修改类属性
        cls.Have_eye=num


LiSi=UniStudent(150, "李四", 22,5000)
LiSi.show()
LiSi.freak(1)
print(LiSi)

3. 闭包&装饰器

3.1 概念

闭包的作用： 保存函数内部的变量，让函数内部的变量，不会随着函数调用结束而销毁。

闭包函数形参的条件

• 函数嵌套定义，在一个函数（外部函数）中又定义了另外的一个函数（内部函数）
• 内部函数使用外部函数的变量，外部函数的变量：外部函数中定义的局部变量， 外部函数中的参数
• 外部函数返回内部函数名，外部函数返回了内部函数的引用地址

装饰器的作用： 在不改变原函数代码的基础上以及调用方式，给函数增加新的功能。
装饰器的本质就是一个闭包函数。

3.2 闭包代码

def func_outer():
    num = 10010
    def func_inner():
        print(f'获取到的外部函数的num为： {num}')
    return func_inner

# func_outer()
f = func_outer
f()

3.3 装饰器代码

def login(func):
    def func_inner():
        print('登录成功......')
        func()
    return func_inner

@login      # 本质 user_center = login(user_center)
def user_center():
    print('欢迎访问用户中心.......')

user_center()
#登录成功......\n欢迎访问用户中心.......

3.4 带参数的装饰器代码

def decorator(flag):
    def func_outer(func):
        def func_inner(a, b):
            if flag == "+":
                print('增加的功能--开始进行加法计算')
            elif flag == "-":
                print('增加的功能--开始进行减法计算')
            return func(a, b)
        return func_inner
    return func_outer

@decorator("+")
def add(a, b):
    return a + b

print(add(10, 20))

4. 文件处理（with）

4.1 概念

with 语句执行完成以后自动调用关闭文件操作，即使出现异常也会自动调用关闭文件操作

4.2 代码

with open("student.txt","r",encoding="utf-8") as f:
    f.write("adad")

# 意思上等价于
try:
    f=open("student.txt","r",encoding="utf-8")
    f=f.write("adad")
except Exception as e:
    print("文件操作错误",e)
    print("关闭文件")
finally:
    f.close()

5. 拷贝

5.1 浅拷贝

概念

copy函数是浅拷贝，只对可变类型的第一层对象进行拷贝，对拷贝的对象开辟新的内存空间进行存储，不会拷贝对象内部的子对象。

不可变类型

import copy
a="abc"
b=(1,2)
c=[1,2]
d=(1,c)     # (1, [1, 2])

"""
不可变类型:
浅拷贝不会给拷贝的对象开辟新的内存空间，而只是拷贝了这个对象的引用(地址）
修改不可变类型，并不会影响拷贝后的数据.
注意！！若元组中含有可变类型，元组中可变类型发生改变会影响修改后的数据
"""
tempa=copy.copy(a)
print(id(a)==id(tempa))      # True
tempb=copy.copy(b)
print(id(b)==id(tempb))      # True
tempd=copy.copy(d)
print(id(d)==id(tempd))      # True
a="aaa"
print(tempa)    # abc
c[1]=555
print(tempd)    # (1, [1, 555])

可变类型

import copy
a=[1,2]
b={"age":1,"num":2}
c=[a,b]     # [[1, 2], {'age': 1, 'num': 2}]
"""
可变类型:
浅拷贝会对拷贝的第一层对象另开辟新的内存空间进行存储
修改可变类型，并会影响拷贝后的数据
"""
tempa=copy.copy(a)
print(id(a)==id(tempa))      # False
tempb=copy.copy(b)
print(id(b)==id(tempb))      # False
tempc=copy.copy(c)
print(id(c)==id(tempc))      # False

a[1]=555
b["age"]=555
print(a)        # [1, 555]
print(tempa)    # [1, 2]
print(c) 		# [[1, 555], {'age': 555, 'num': 2}]
print(tempc)	# [[1, 555], {'age': 555, 'num': 2}]

5.2 深拷贝

deepcopy函数是深拷贝, 只要发现对象有可变类型就会对该对象到最后一个可变类型的每一层对象就行拷贝, 对每一层拷贝的对象都会开辟新的内存空间进行存储。

不可变类型

import copy

a="abc"
b=(1,2)
c=[1,2]
d=(1,c)     # (1, [1, 2])
"""
不可变类型:
深拷贝如果子对象没有可变类型则不会进行拷贝，而只是拷贝了这个对象的引用
否则会对该对象到 "最后一个可变类型" 的每一层对象就行拷贝
对每一层拷贝的对象都会开辟新的内存空间进行存储
"""
tempa=copy.deepcopy(a)
print(id(a)==id(tempa))      # True
tempb=copy.deepcopy(b)
print(id(b)==id(tempb))      # True
tempd=copy.deepcopy(d)
print(id(d)==id(tempd))      # False
a="aaa"
print(tempa)    # abc
c[1]=555
print(d)        # (1, [1, 555])
print(tempd)    # (1, [1, 2])
# 这里与浅拷贝由本质区别

可变类型

import copy

a=[1,2]
b={"age":1,"num":2}
c=[a,b]     # [[1, 2], {'age': 1, 'num': 2}]
"""
可变类型:
深拷贝会对该对象到最后一个可变类型的每一层对象进行拷贝
对每一层拷贝的对象都会开辟新的内存空间进行存储
"""
tempa=copy.deepcopy(a)
print(id(a)==id(tempa))      # False
tempb=copy.deepcopy(b)
print(id(b)==id(tempb))      # False
tempc=copy.deepcopy(c)
print(id(c)==id(tempc))      # False

a[1]=555
b["num"]=555

print(c)        # [[1, 555], {'age': 1, 'num': 555}]
print(tempc)    # [[1, 2], {'age': 1, 'num': 2}]

6. 时间函数

from datetime import datetime
import time

nowtime = datetime.now()    # 获取当前日期时间
print(nowtime,type(nowtime))
# 2021-09-12 19:28:59.914934 <class 'datetime.datetime'>

#  datetime类型转换为str类型
str_nowtime=datetime.strftime(nowtime,"%Y-%m-%d %H:%M:%S")  # 注意必须是大写小写的YmdHMS
print(str_nowtime,type(str_nowtime))
# 2021-09-12 19:28:59 <class 'str'>

# 将str转换为datetime类型
datetime_nowtime=datetime.strptime(str_nowtime,"%Y-%m-%d %H:%M:%S")
print(datetime_nowtime,type(datetime_nowtime))
# 2021-09-12 19:28:59 <class 'datetime.datetime'>

# 时间戳
timestamp=round(time.time())
print(timestamp)

# 时间戳转换为datetime类型
ts_datetime=datetime.fromtimestamp(timestamp)
print(ts_datetime)
# 2021-09-12 19:29:00

# 将datetime转换为时间戳
ts=ts_datetime.timestamp()
print(round(ts))

7. 日志

import logging

# 1. 创建一个logger对象
logger=logging.getLogger()

# 2. 创建handler对象
# stream_hander=logging.StreamHandler()       # 输出至控制台
file_hander=logging.FileHandler(            # 输出至文件中
    filename='../Logs/run.log',
    mode='a',
    encoding='utf-8'
)


# 3. 设置日志信息格式
fmt=logging.Formatter(
    "%(asctime)s - [%(levelname)s] - %(filename)s [line:%(lineno)d]: %(message)s "
)
# stream_hander.setFormatter(fmt)
file_hander.setFormatter(fmt)

# 4. 把handler对象加入logger对象中
# logger.addHandler(stream_hander)
logger.addHandler(file_hander)

# 5. 设置日志输出等级
logger.setLevel(10)

# 6. 日志输出信息
logger.debug("这是个 debug 信息……")
logger.info("这是个 info 信息……")
logger.warning("这是个 warning 信息……")
logger.error("这是个 error 信息……")
logger.critical("这是个 critical 信息……")