【Python教程】类及对象教程

朱雀 2022-09-11 12:16 170阅读 0赞

**一、类创建**

class Animal:
    
        def setName(self,name):
            self.name=name
    
        def getName(self):
            return self.name
    
    #创建动物猫的对象
    cat=Animal()
    cat.setName("cat")
    #调用cat对象的属性name
    print(cat.name)
    #调用cat方法的getName方法
    print(cat.getName())
    #调用cat方法的getName方法 另一种方式
    print(Animal.getName(cat))

*  类的创建使用关键字class定义，类名跟在class之后
 *  类中的方法就是函数
 *  每一个方法中的第一个参数都是self，如果方法中有多个参数，第一个参数将作为self参数使用，在调用方法时，这个参数不用自己传入，系统会将方法所属的对象传入这个参数。
 *  调用对象方法的方式有两种，一种是直接通过对象调用；另一种是通过类调用，并且传入相应的对象。

**二、方法的私有化**

在Java这类语言中提供了private关键字，进行方法或者变量的私有化，但是在python中并没有提供，不过可以使用其它方式来达到这种效果，在python类的方法名前面加上“\_\_”,可以杜绝外部访问这个类中的方法。

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class FOO:
    
        def f1(self):
            return "我是f1"
    
        def __f2(self):
            return "我是f2"
    
        #类的内部是可以调用私有方法的
        def f3(self):
            return self.__f2()
    
    f=FOO()
    f.f1()
    f.__f2() #AttributeError: 'FOO' object has no attribute '__f2'

可以看到f2是私有方法，类外部不能进行访问，否则会抛出异常，而在类的内部是可以调用私有方法的。

f2是否是真的在类外部不能调用了呢？当然不是，实际上python编译器遇到"\_\_"开头的方法会将方法名变成`_ClassName__MethodName`，照着这种形式调用，是可行的。

print(f._FOO__f2())#我是f2

另外，如果想查看类中的所有方法，应该如何做呢？

import inspect
    methods=inspect.getmembers(f,predicate=inspect.ismethod)
    print(methods)#[('_FOO__f2', <bound method FOO.__f2 of <__main__.FOO object at 0x0000000000676F28>>), 
    　　　　　　　　#('f1', <bound method FOO.f1 of <__main__.FOO object at 0x0000000000676F28>>), 
    　　　　　　　　#('f3', <bound method FOO.f3 of <__main__.FOO object at 0x0000000000676F28>>)]

**三、类的继承**

类的继承就是一个类从另一个类中获得所有的成员，父类的成员可以在子类中使用。新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class A:
        pass
    
    class B:
        pass
    
    class C(A): #单继承 C是派生类，A是基类
        pass
    
    class D(A,B):#多继承，继承多个类，中间以逗号分隔开
        pass

D类中会按照从左到右的顺序继承A类、B类中的成员，如果多个父类中有相同的成员，会按照父类书写的顺序继承，也就是说前面的父类会覆盖写在后面父类同名的方法。

**四、检测继承关系**

有时需要判断类与类之间是否有继承关系，这样可以利用父类中的方法，那么这种继承关系应该如何判断呢？可以使用issubclass函数进行判断，它接收2个参数，第一个是子类，第二个是父类，如果是继承关系返回True，否则返回False，间接的继承关系也是适用的。

class Fruits:
        pass
    
    class Apple(Fruits):
        pass
    
    print(issubclass(Apple,Fruits))#True

如果获取已知类的父类们，可以直接使用"**bases**"，这是类的一个特殊属性

class Fruits:
        pass
    
    class Apple(Fruits):
        pass
    
    print(Apple.__bases__)#(<class '__main__.Fruits'>,)

**五、类、类成员、对象的判断**

a、hasattr()

判断对象或者类中是否存在某个成员

class Bar:
    
        def f1(self):
            pass
    b=Bar()
    print(hasattr(b,"f1"))#True
    print(hasattr(Bar,"f1"))#True

b、getattr()

获取类中或对象中成员的值，它有三个参数第三个参数用于制定默认值

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class Bar:
    
        def f1(self):
            pass
    b=Bar()
    
    print(getattr(Bar,"f1"))#<function Bar.f1 at 0x0000000000535BF8>

c、setattr()

用于设置对象中成员的值，setattr函数有三个参数，前两个与getattr相同，第三个参数用于指定成员的值

#如果对象中有name属性，则更新该值，如果没有，会添加一个新的name属性，也可以更新或者添加类属性
    setattr(b,"name","bright")
    print(b.name)#bright

动态添加函数

class Bar:
    
        def f1(self):
            pass
    b=Bar()
    
    ####类添加f2函数####
    def f2():
        print("动态添f2")
    setattr(Bar,'f2',f2)
    Bar.f2()  #类调用
    
    ####对象添加f2函数###
    def f2():
        print("动态添f2")
    setattr(b,'f2',f2)
    b.f2()  #对象调用

d、isinstance

用于判断实例和类之间的关系

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    class A:
        print("A")
    
    class B(A):
        print("B")
    
    a=A()
    b=B()
    
    print(isinstance(a,A))#True
    print(isinstance(b,A))#True

**六、多态**

同类对象的多种形态，应用多态增加了程序的灵活性、扩展性。

实现多态的步骤：

*  定义新的子类
 *  重写对应的父类方法
 *  使用子类的方法直接处理,不调用父类的方法

class Animal:
    
        def eat(self):
            pass
    
        def run(self):
            pass
    
    class Dog(Animal):
    
        def run(self):
            pass

简单的来说，Dog是新定义的子类，不想调用父类的run方法，需要执行自己的run方法，这就是多态，一个类产生的多个对象，调用同一个方法，产生不同的执行结果。