【Python 继承&封装&反射&异常处理 10】

一、继承

1、语法：子类(父类)

# 学科类：存放学科名，周期，价格
class Course:
    course_lst = []
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price
# 角色：可以查看不同学科的学科名，周期，价格
class Role:
    def __init__(self,name):
        self.name = name

    def show_sourse(self):
        for item in Course.course_lst:
            print(item.name,item.period,item.price)

# students类   -->继承语法：子类（父类），直接在子类后面用括号加父类的方式即可
class Students(Role):
    def __init__(self,name):
        super().__init__(name) #super()可以调用父类的一切属性和方法
        # self.course = []

python = Course('python','6个月',19800)
java =  Course('java','6个月',20000)
Course.course_lst=[python,java]

stu = Students('wusir')
print(stu.name)
stu.show_sourse()

===执行结果===
wusir
python 6个月 19800
java 6个月 20000

二、封装

• 私有化    用“__”修饰，属性、方法、类都可以私有
• 私有化以后不能直接被调用，需要用get和set方法进行调用
• 私有化不能被继承

#私有化：用__修饰，可以属性私有化，方法私有化等

class Student:
    def __init__(self,name):
        self.__name = name #用__把name属性私有化
    def getName(self):
        return self.__name
    def setName(self,value):
        self.__name = value

stu = Student('老王')
stu.setName('赵六')
print(stu.getName())

1、面向对象的装饰器

• @property 将一个方法伪装成属性
• @staticmethod 声明方法是一个静态方法，不必传任何默认的参数
• @classmethod   装饰当前这个方法为一个类方法,默认传参数cls,表示当前所在的类名

# @property 将方法伪装成一个属性
class Circle:
    def __init__(self,r):
        self.r = r

    @property
    def area(self):
        return self.r**2*3.14

c = Circle(5)
print(c.area) #因为用了 @property把方法伪装成一个属性了，所以调用方法时就可以直接调用名字，而不需要再方法名后面加括号了

# @staticmethod 声明一个方法为静态方法，不必传默认的参数
# 不必实例化就可以调用的方法 不需要传递对象作为参数,就定义这个方法为静态方法

class Students:
    def __init__(self,name):
        self.name=name
    # 如果有__init__初始化参数，自定义方法时默认都会加上self（即：会加上默认的参数name）
    def login(self):
        print('====')

    # 如果不想要默认的参数（即：__init__内的参数），可以在方法前加@staticmethod,当然没有默认的参数了，自定义的参数是可以随意增加的
    @staticmethod
    def regirect(falg):
        print('----->')

# @classmethod 装饰当前这个方法为一个类方法，默认传参数cls,表示当前所在的类名
class Manager:
    def __init__(self,name):
        self.name=name
    @classmethod
    def login(cls): #cls就表示Manager类名
        stu = cls.name
        return stu

2、几种方法调用的方式

class A:
    def func(self):  pass  # 实例方法 self作为默认参数,需要用对象来调用

    @classmethod
    def func1(cls):  pass  # 类方法 cls作为默认参数,可以用类名来调用

    @staticmethod
    def func1():  pass  # 静态方法方法 没有默认参数,可以用用类名来调用

 三、内置方法和单例模式

1、__str__

打印一个对象总是打印对象的内存地址，对我们来说没有作用，一般可以用obj.__str__来打印方法的返回值

2、__new__

创建一块空间，在__init__方法之前还有一个创建空间的方法__new__

四、模块和包

 1、模块：多行代码拆成多个py文件，可以随意引用

# 导入模块的话
from 模块 import 变量
import 模块
模块.变量访问变量的值

import demo  #导入一个模块
obj = deom.Manager()  #类实例化

from demo import Manager #导入一个模块的类
obj = Manager()  #类实例化

2、包的导入

  # from 包.包.包 import 模块
        # 模块.xxx直接获取值
    # import 包.包.模块
        # 包.包.模块,xxx获取值

# pack.api两层包，policy是类，name是属性
import pack.api.policy as policy
policy.name

from pack.api import policy
policy.name

注意：# 无论是导入模块还是包,必须要保证被导入的模块和包所在路径在sys.path的列表中

如果sys.path没有的话，可以把需要导入的包加进去

import sys
sys.path.append('/Users/mobvista/Documents/PycharmProjects/pythonProject/day05/dir')
print(sys.path)

不管是导入模块还是导入包，都必须导入到模块（即：py文件），这样才能用模块下的函数或者属性等

五、hashlib模块

import hashlib
# 调用hashlib的md5方法，复制给md
md=hashlib.md5()
# md对123456进行加密：update
md.update(b'123456')
# 获取加密后的内容 ：hexdigest()
ret1 = md.hexdigest()
print(ret1) #e10adc3949ba59abbe56e057f20f883e

md5 = hashlib.sha1()
md5.update(b'123456')
ret2 = md5.hexdigest()
print(ret2) #7c4a8d09ca3762af61e59520943dc26494f8941b

# md5加密的结果是32位，sha1的加密结果是40位

为了防止加密后的密码被反向破解，需要加盐处理，并且是动态加盐（经常在用户名里进行加盐）

import hashlib
# 调用hashlib的md5方法，复制给md
md = hashlib.md5('只有我知道,别人不知道的秘密的字符串%s'%'alex'.encode('utf-8'))
# md对123456进行加密：update
md.update(b'123456')
# 获取加密后的内容 ：hexdigest()
ret1 = md.hexdigest()
print(ret1)