py知识(每日更新) 7.11

类的结构细分

私有成员

类中的私有成员:私有类的静态属性 私有对象属性 私有方法

# 私有静态属性
class B:
    school_name = 'college'

class A(B):
    class_name = 'python'
    __girl_num = '1个
    
    def func(self):
        print(self.school_name)
        print(self.__girl_num) # 类的外部不能访问
    
obj = A()
print(obj.class_name)
obj.fun()
print(obj.school_name)
# 对于类的共有静态属性,类的外部,类的内部,派生类都可以访问
obj = A()
print(obj.__girl_num)
# 私有静态属性:类的外部不能访问 子类也不能访问
print(obj.__girl_num)  # 

# 对象的私有属性 : 类的外部不能访问 子类中也不能访问
# 对象的私有方法 : 类的外部不能访问 子类中也不能访问

# 如果要设置一些私有的或者是不想让类外面用到的时候,密码,加密方式
# 拓展: 私有成员除了在类内部,当真访问不到么?

类方法

class A:
    num = 1
    def func(self):
        print('实例方法')
        
    @classmethd  # 类方法 由类名直接调用的方法,他会自动的将类名传给cls
    def a_func(cls):
        print(cls)
        print(cls.num) # 打印类的静态属性
        o = cls()  # 类方法中实例化一个对象
        print('这是类方法')
# 对象也可以调用类方法, 但是会自动将其从属于的类名传给cls

静态方法

# 静态方法: 不依赖于类,也不依赖于对象,他就是一个普通的函数 放置于类中,使结构更加清晰合理  
class A:
    def func(self):
        print(111)
        
    @classmethod
    def a_func(self):   # 类方法
        print(222)
        
    @staticmethod
    def b_func():   # 静态方法
        pring(333)

属性(特殊)

class A:

    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

    def bmi(self):
        return self.weight / (self.height**2)


obj = A(1.83, 90)
print(obj.bmi())
# 我们要让bmi方法伪装成属性,虽然在代码级别没有提升,但是看起来更合理

    @property   # 伪装成属性 使用的相对多一些
    def bmi(self):
        return 'get的时候运行我'


obj = A(1.83, 90)
print(obj.bmi)

-------------------------------------------------------------

    @property   # 伪装成属性
    def bmi(self):
        return 'get的时候运行我'
    
    @bmi.setter  # 调用被装饰器@bmi.setter装饰的这个函数
    def bmi(self):
        print('set的时候运行我')
    
--------------------------------------------------------------
    
    @property   # 伪装成属性
    def bmi(self):
        return 'get的时候运行我'
    
    @bmi.setter  # 调用被装饰器@bmi.setter装饰的这个函数
    def bmi(self):
        print('set的时候运行我')
        
    @bmi.deleter
    def bmi(self):
        print('delete的时候运行我')
        
# @property 使用的多一些 @setter @deleter 设置属性,你的对象属性一定不能出现同名的属性,setter deleter这两个装饰器装饰的函数不能使用return

方法2:

class Foo:
    def get_AAA(self):
        print('get的时候运行我')

    def set_AAA(self,value):
        print('set的时候运行我')

    def delete_AAA(self):
        print('delete的时候运行我')
        
    AAA = property(get_AAA,set_AAA,delete_AAA) 
    #内置property三个参数与get,set,delete一一对应 AAA是.名字

isinstance issubclass

isinstance(a,b)
# 判断a对象是由b类(b类的派生类)实例化的对象 则返回True.

issubclass(m,n)
# 判断M类是N类的子孙 类与类的关系

元类(type)(type与object的区别)

type # 判断的是对象从属于哪个类
isinstance # 判断的对象是这个类或者这个类的派生类

type 
# 元类 Python中一切皆对象 一个类也是一个对象 那么这个(类)对象肯定是由一个类实例化出来的 
# Python中创建的所有类,以及大部分list str等等这些类都是从type元类实例化得来的

# 而type类与object类之间的关系比较独特：object是type类的实例，而type类是object类的子类，这种关系比较神奇无法使用python的代码表述，因为定义其中一个之前另一个必须存在。所以这个只作为了解。

异常处理

# 错误类型
# 语法错误  自己处理 避免
# 逻辑错误

# 分流:
dic = {
    1: 111,
    2: 333,
    3: 555
}

while 1:
    try:
        num = input('请输入序号')
        int(num)
        print(dic[int(num)])
        quit()
    except KeyError as e:
        print('选项超出范围,请重新输入')
    except ValueError as e:
        print('请输入数字')

        
# 万能异常:
while 1:
    try:
        num = input('请输入序号')
        int(num)
        print(dic[int(num)])
        quit()
    except Exception as e:
        print(e)
        
# 什么时候用多分支或万能异常?
# 如果只是想把异常处理掉 让程序继续执行:万能异常
# 如果出现了异常,你想根据不同的异常执行不同的逻辑流程,要采取多分支

# 万能 + 多分支
while 1:
    try:
        num = input('请输入序号')
        int(num)
        print(dic[int(num)])
        quit()
    except KeyError as e:
        print('选项超出范围,请重新输入')
    except ValueError as e:
        print('请输入数字')
    except Exception:
         pass
        
# 异常处理的其他成员
1.
try:
except 
except
2.
try:
except 
else:  # 如果上面无异常则执行else语句 否则不执行else语句.
3.
try:
except 
finally:  # 提前捕捉 在整个程序终止之前,执行finally
finally使用场景:
    1.文件操作
    2.数据库
    3.结束函数之前,先要执行finally
        def func():
            try:
                a = 1
                b = 2
                return a + b
            finally:
                print(666)
        print(func())
        >>>> 666
        >>>> 3
       
# 主动抛出异常
raise Exception('xxxxxxxx')

# 断言  主动抛出异常
assert 条件 

# 自定义异常
class EvaException(BaseException):
    def __init__(self,msg):
        self.msg=msg
    def __str__(self):
        return self.msg

try:
    raise EvaException('类型错误')
except EvaException as e:
    print(e)

# 异常处理总结
# 异常处理不能经常使用: 异常处理耗费性能,有些错误需要进行分流使用,代码的可读性变差
# 在关键节点使用

转载于:https://www.cnblogs.com/lyoko1996/p/11171507.html