58.基础语法-面向对象编程oop

类

所有类都需要继承，若不指定继承的类，系统默认继承object系统默认类
查询类中的元素用dir()

print(dir(object))

关于self

self.属性
- 实力化之后的调用
- self就是代表实例的名字
- 若self.属性，调用后，方法中没有self.属性，则会向上找类的同名属性

class.类属性

用这种方法调用,方法中想要用类的属性

class Lei():
    name = "lei_name"
    def fangfa(self):
        self.name = "fangfa_name"
        print(self.name)
        print(__class__.name)

a = Lei()
a.fangfa()
print(a.name)
print(Lei.name)

init构造函数

在类实例化时自动执行，执行一些基础的初始化工作
参数self必须有
子类有构造函数，则父类的构造函数就不执行了
若子类需要执行父类的构造函数，可以用super().__init__()调用

class gz():
    name = None
    age = 0
    def __init__(self):
        self.name = "菲"
        self.age = 38

g = gz()
print(g.name)
print(g.age)

面向对象的三大特征：继承，封装，多态

1.继承

所有的类都默认继承object，这是系统默认的
子类可以使用父类的内容，若成员与父类冲突，调用子类优先使用子类，不影响父类本身
子类如果想扩充父类方法，可以在定义新方法的同时调用父类方法(类名.方法或 super().方法)，实现代码的复用
父类，基类，超类 : 被继承的类

issubclass()

可以检查某一个类是不是其他类的子类

class jc0():
    name = "a"
class jc1():
    name = "b"
    def f(self):             #父类方法
        print("我是父类的方法{}".format(self))
class jc3(jc0, jc1):
    def g(self):
        jc1.f(self)          #调用父类方法1
        super().f()          #调用父类方法2
        print("我是子类的方法")
jc4 = jc3()
print(jc4.name)
print(issubclass(jc3,jc0))
jc4.g()

super()

用子类对象调用父类的方法和属性

class Father():
    def a(self):
        print("我是父类的方法")
class Son(Father):
    def a(self):  #子类的复写
        print("我是子类的方法")
su = Son()
su.a()
super(Son, su).a()

2.封装

对对象的成员进行访问限制
封装的三个级别：公开(public),受保护(protected),私有(private)

私有

最高级别的封装，只能在当前类或对象中访问
属性前加两个下划线“__”
PYTHON的私有本质是改了个名字，如果想，还是可以访问到的“_类名__私有元素名字”

class Fengzhuang():
    name = "python"
    __age = 1
print(Fengzhuang.name)
print(Fengzhuang._Fengzhuang__age)

受保护的

在类中或子类中可以访问，在外部不可以访问
成员前添加一个下划线“_”
这种形式不是PYTHON硬性规定，而是大家公认的形式

class Shoubaohu():
    _name = "python"

公开的

就是普通的定义成员

3.多态

同一个对象在不同情况下以不不同的状态出现
在python中多态是一种设计思想，不是语法

类的相关函数

issubclass()

检测一个类时不时另一个类的子类

class A():
    name = "A"
class B(A):
    name = "B"
print(issubclass(B, A))

hasattr

检测一个类或者对象，是否包括一个成员

a = A()
print(hasattr(a, "name"))

getattr

获取对象的属性，如果没有该属性，返回预设值。

print(getattr(a, "name", None))

setattr

修改对象内的属性，如果没有对象，会报错

s = A()
setattr(s, "name", 1)
print(s.name)

delattr

删除类属性

d = A()
delattr(A, "name")

dir

dir(A)

property()

对对象属性进行修饰操作，对属性进行相应操作(读取，修改，删除)时，触发相应方法进行修饰
参数内顺序时固定的读，写，删除

class Pr():
    
    def __init__(self):
        pass
    def fget(self):
        return self._name * 2     #如果不加“_”会报递归深度报错
    def fset(self, name):
        self._name = name.upper() #upper()字符串大写，swapcase()字符串小写
    def fdel(self):
        self._name = "None"
    
    name = property(fget, fset, fdel, "对name属性进行修饰")

pro = Pr()
pro.name = "qwe"
print(pro.name)

常用的类的魔术函数

不需要人为调用，只是在特定的时候触发的函数

操作类

__new__对象实例化的方法，我们一般不使用
__init__构造函数，初始化函数时候使用
__call__把对象当函数使用时候，调用此魔术函数

class Cy():
    def __init__(self):
        pass
    def __call__(self):
        print("我被当作函数调用了")
    def __str__(self):
        return "我被当作字符串调用了"

cy = Cy()
cy()

__str__当对象被当作字符串使用的时候，调用此魔术函数

print(cy)

__getattr__ 当调用对象属性不存在时，本该报错，但你希望触发相应的方法是使用

class Gta():
    name = "1"
    def __getattr__(self, name):
        print("没有你要找的属性{}".format(name))
    def __setattr__(self, name, value):
        print("你对{}进行了赋值操作".format(name))
        #self.name = value 如果用此种方法，会进入死循环，不断的自我调用
        super().__setattr__(name, value)

gt = Gta()
print(gt.dieiasdalssddsdf)

__setattr__ 对类的属性进行赋值时，自动触发

gt.name = "123"
print(gt.name)

描述符类

__set__() 调用一个属性时,触发
__get__() 为一个属性赋值时,触发
__delete__() 采用del删除属性时,触发

class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符
    def __get__(self, instance, owner):
        print('__get__(),被执行了')
    def __set__(self, instance, value):
        print('__set__(),被执行了')
    def __delete__(self, instance):
        print('__delete__(),被执行了')

运算相关

等等用时候查看

类和对象的三种方法

实例方法
- 需要实例化对象才能够使用
类方法
- 不需要实例化，用类可以直接访问
- 区别：可以对类的属性进行修改
静态方法
- 不需要实例化
- 区别：只能通过类调用

class ren():
    
    #实例方法,用self
    def chi(self):
        print(self)
        print("吃~~~~~~~！")
    
    #类方法，用cls
    @classmethod
    def he(cls):
        print(cls)
        print("喝~~~~~~~~~！")
    
    #静态方法，不用
    @staticmethod
    def wan():
        print("玩~~~~~~~~~~！")

h = ren()

#实例方法
h.chi()
#类方法
ren.he()
#静态方法
ren.wan()

抽象类

定义：没有具体事项内容的方法的类，包括抽象方法的类
意义：规范子类的行为接口，子类若要实例化，就必须实现父类的抽象方法
抽象类的创建：借助 import abc 模块来实现
特点：
1. 可以包括抽象方法，也可以包括具体方法。
2. 抽象类不允许实例化，只能被继承，继承后必须实现抽象，否则依然不允许实例化。
3. 抽象类的作用就时设定类的标准，便于开发时，有统一的规范

import abc
class Humen(metaclass=abc.ABCMeta):
    
    #定义抽象方法
    @abc.abstractmethod
    def chi(self):
        pass

    #定义类的抽象方法
    @abc.abstractclassmethod
    def he(self):
        pass

    #定义静态抽象方法
    @abc.abstractstaticmethod
    def wan():
        pass

    #普通方法
    def le():
        print("乐~~~~！")

posted @ 2020-02-22 16:51 TK_tank 阅读(77) 评论(0) 编辑收藏举报

刷新页面返回顶部

TK_tank

58.基础语法-面向对象编程oop

类

关于self

__class__.类属性

__init__构造函数

面向对象的三大特征：继承，封装，多态

1.继承

issubclass()

super()

2.封装

私有

受保护的

公开的

3.多态

类的相关函数

issubclass()

hasattr

getattr

setattr

delattr

dir

property()

常用的类的魔术函数

操作类

描述符类

运算相关

类和对象的三种方法

抽象类

class.类属性

init构造函数