python面向对象【非常详细】

简述不全，望海涵

目录

一.封装，继承，多态

1.封装

2.继承

3.多态

二.面向对象的各种方法

1.静态方法

2.类方法

3.属性方法

三.高级面向对象

1.成员修饰符

2.特殊方法

---

一.封装，继承，多态

1.封装：

将内容封装到某个地方，以后再去调用被封装在某处的内容

例如：

 通过__init__构造器封装了name和age，让外部name和内部name分开，保证了数据的纯净性。

2.继承

子类获得父类的内容

格式：

class student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        print("这个同学叫%s,今年%d岁" % (self.name, self.age))


class student1(student):
    print("继承了student类")


student2= student1("郭富城", 19)
student2.show()

student3 = student1("黎明", 18)
student3.show()

注：1.父类和子类都重新定义了构造函数init()时，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造器，必须在子类中显示调用

2.python的类可以多继承

3.如果继承多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

3.多态

首先python不支持多态，也不用支持多态，python是一种多态语言，是一种动态类型的风格，在这种风格中，一个对象有效的语义不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定

class A:
    def prt(self):
        print("A")

class B:
    def prt(self):
        print("B")

class C:
    pass

def test(arg):
    arg.prt()
a=A()
b=B()
c=C()
test(a)
test(b)
test(c)

A,B可以打印出来，而C会报错。test方法接受的数据类型明眼人规定，它只负责接受一个参数然后调用prt方法

二.面向对象的各种方法

1.静态方法

通过@staticmethod装饰器来表示，该方法可以把@staticmethod下面的函数和所属的类截断，这个函数就不属于这个类，也没有类的属性，只不过要通过类名的方式调用

 @staticmethod静态方法将sing方法和类截断了，如果我们通过sing(self)去调用singer的self.name会报错

2.类方法

用@classmecthod装饰符来表示，类方法只能访问类变量，不能访问实例变量

class singer(object):
    name = "张学友"
#类方法sing不能访问实例变量，下面的“郭富城”无效
#类方法只能访问在类里定义的变量
    def __init__(self, name):
        self.name = name

    @classmethod
    def sing(self):
        print("%s在唱歌" % self.name)


s = singer("郭富城")
s.sing()     #实际输出:张学友在唱歌

3.属性方法

用@property装饰符表示，把一个方法变成一个静态属性，然后就利用不用加小括号那样去调用了

class singer:
    def __init__(self, name):
        self.name = name

    @property
    def sing(self):
        print("%s在唱歌" % self.name)


s = singer("郭富城")
s.sing    #sing已经变成了一个属性，调用时不加()，如s.sing()会报错

三.高级面向对象

1.成员修饰符

双下划线表示私有，私有成员不允许直接访问，只能通过内部方法去访问，私有成员也不允许被继承

2.特殊方法

1.__init__        类似构造器，在类生成对象后就会被执行

2.__del__        析构方法，在对象消亡时执行

3.__call__        在类的对象被执行时被调用

4.__int__        在对象被int()包裹的时候会被执行

5.__str__        在对象被str()包裹的时候会被执行

6.__add__        在两个对象相加的时候，调用第一个对象的__add__方法，可以将第二个对象传递进来，例如：

class abs:
    def __init__(self, age):
        self.age = age

    def __add__(self, obj):
        return self.age + obj.age

a1=abs(4)
a2=abs(5)
print(a1+a2)    #输出9

7.__dict__        这个方法是以字典的形式列出类或对象中所有成员，例如：

class abs:
    def __init__(self, age):
        self.age = age

    def __add__(self, obj):
        return self.age + obj.age

a=abs(4)
print(abs.__dict__)
print(a.__dict__)
#输出{'__module__': '__main__', '__init__': , '__add__': , '__dict__': , '__weakref__': , '__doc__': None}
#{'age': 4}

8.__getitm__方法匹配对象[索引]这种方式

__setitem__方法匹配对象[索引]=value这种方式

__delitem__方法匹配del对象[索引]这种方式

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __getitem__(self, item):
        return item
    def __setitem__(self, key, value):
        print(key,value)
    def __delitem__(self, key):
        print(key)
li=Foo("lm",90)
print(li[10])
li[10]=100
del li[10]
#输出
# 10
# 10 100
# 10

9.__iter__        类对如果想变成一个可迭代的对象，那么对象中必须要有__iter__方法，并且这个方法返回一个迭代器。for循环的对象如果是一个可迭代的对象，那么会先执行对象中的__iter__方法，获取到迭代器，然后再执行迭代器中的__next__方法获取数据，如果for循环的是一个迭代器，那么直接执行迭代器中的__next__方法

10.isinstance不仅可以判断一个变量是否是某一种数据类型，还可以判断对象是否是这个类的对象或这个类子类的对象

class father:
  pass
class son(father):
    pass
lming = son()
print(isinstance(lming, father))
#true

11.issubclass用来判断一个类是否是某个类的子类

class father:
  pass
class son(father):
    pass
print(issubclass(son, father))
#true

12.异常处理，使用try except finally组合来实现异常

try:
    int("aaa")
except IndexError as e:
    print("IndexError:",e)
except ValueError as e:
    print("ValueError:",e)
except Exception as e:
    print("Exception:",e)
else:
    print("没有异常")
finally:
    print("结束")
#输出    
# ValueError: invalid literal for int() with base 10: 'aaa'
# 结束