Python中的类

Python中的类
1、分为两种新式类和旧式类（经典类）
2、在Python中，是通过class关键字来定义类
3、一切的类都继承object类（基类），不管是新式类还是经典类
4、新式类：class  类名（object）      经典类：class 类名：
5、构造函数可以不写，如果不写会使用默认的构造函数
6、对象是通过类进行实例化出来的，同时对象也叫作实例
7、self就是当前类的对象本身，会自动传参的
8、Python中的类，变量就是属性，方法就是行为
9、装饰器的作用：在不改变原有的功能的基础上，给原来的方法进行加载新的功能
10、@staticmethod：返回函数的静态方法，这种静态方法是不强制传递的参数，可以通过类直接调用该方法，
                  也可以实例化之后
11、 @classmethod：返回的函数的类方法，不需要实例化也可以调用的，不需要self参数，但是第一个参数
             cls表示自身类的参数，cls自身类的参数，可以调用类的属性，类的方法、实例化的对象等等

定义类(新式类)
class People(object):
    head=1  #类变量：类 所共有的属性

    def __init__(self,name):  #构造函数，也叫构造方法，作用是用来创建对象
        #__init__双下划线开头的方法，称之为私有方法：只能是在这个类使用的
        self.name=name   #self.name就是实例变量，self也就是当前类对象的本身

    def play(self):
        #定义了一个实例方法，当一个对象被当前类实例出来，就可以使用类里面的实例方法
        print(self.name+'去巡逻')

    def drink(self):
        print(self.name+'去喝酒')

    @staticmethod
    def funv():
        print('这是一个静态方法')

    @classmethod
    # @classmethod 这里的@符叫做装饰旁，@加后面接的东西整体叫做装饰器

    def func(cls):
        print(cls.head) #通过cls（表示类自身）通过cls调用类的属性
        print('这是一个类方法')
        d=cls('Cat')
        p.play()  #在类方法里面调用类本身的其他实例方法
        #类方法：属于整个类共用的方法，也就是可以被类直接调用，也可以被某个具体的对象调用

根据类创建对象===》实例化
p=People('Andy')    #实例化一个对象p，对象p是People类中的一员，People('Andy)整体是一个匿名对象
p.play()   #Andy去巡逻
# People.play('Tom')  #直接调用类里面的方法会报错，因为没有进行实例化
p=People('Cat')   #实例化另外一个对象，命名同样为p
p.play()  #Cat去巡逻

1、对象和类调用实例变量和类变量
p=People('程度')
print(p.name)  #结果为：程度 通过对象获取实例变量
# print(People.name) #报错：类不能调用实例变量，实例变量是类中的对象，私有的
print(p.head)   #结果为：1 ==》通过对象获取到类变量，类的属性就是对象的属性
print(People.head) #结果为：1==》通过类，获取类变量，类是可以直接调用类变量的


2、对象和类调用实例方法
p=People('Andy')
p.drink() #Andy去喝酒 ===》通过对象调用实例方法
#People.drink #直接通过类调用实例方法会报错
People.drink(p) #Andy去喝酒 ==》通过类调用实例方法时，需要传入一个具体对象作为入参，才可以正常调用

3、对象和类调用类方法和静态方法
p=People('Andy') #实例化对象p
p.funv()  #这是一个静态方法 ==》通过对象调用静态方法，实例化的去调用
People.funv()   #这是一个静态方法  ==》直接通过类调用静态方法，没有实例化的去调用
p.func()  #这是一个类方法===》通过对象调用类方法
People.func() #这是一个类方法==》直接通过类调用类方法，没有实例化的去调用








经典类的定义
class A:
    def paly(self):
        print('11111')

a=A()   #对A（）类进行实例化操作，并赋值给到对象a，因为A类中没有构造函数，实例化时不需要传入实例变量
a.paly() #通过对象a.调用了a类里面的实例方法





类的三大特性
1、封装特性
2、继承特性
3、类的多态（方法重写）


封装特性
私有变量和私有方法：在类的内部以双下划线开头定义
私有变量和私有方法时不能直接在类的外部引用的，只能在类的内部，通过self才能调用到
作用：通过定义私有方法和私有变量，可以防止代码被其他的模块或者其他的代码直接进行调用，提高代码安全性



class People(object):

    def __init__(self):
        self.__age=18  #双下划线开头的变量叫做私有变量
        self.sex='man'  #这是一个普通的实例变量
        # self.age1=self.__age   #在类的内部通过self调用私有变量__age


    def __fun1(self):   #双下划线开头的方法叫做私有方法
        print('这是一个私有方法')

    def get_age(self):
        #获取私有变量的方法
        print(self.__age)

    def get_fun1(self):
        #获取私有方法的方法
        return self.__fun1()  #在类的内部通过self调用私有方法__fun1



p=People()
print(p.sex)  #直接在对象中获取到实例变量sex
# print(p.__age)  #私有变量不能直接在对象（类的外部）获取
# print(p.age1)  #age1是在类中获取了__age的变量的实例变量
p.get_age()     #通过获取私有变量的方法来进行获取私有变量
# p.__fun1   #报错，私有方法不能直接在对象中调用
p.get_fun1()    #通过在类中获取私有方法的方法来进行获取私有变量




class Father(object):
    def __init__(self):
        pass         #关键字，作用跳过

    def running(self):
        print('很健康')

    def play(self):
        print('打球')


class Mother(object):
    def __init__(self):
        pass
    def dance(self):
        print('喜欢跳舞')

class Son(Father,Mother):           #子类继承父类
    def __init__(self):
        Father.__init__(self)  #子类需要继承父类的构造函数
        Mother.__init__(self)
    def sing(self):
        print('喜欢唱歌')
    def write(self):
        print('喜欢写作')
    def play(self):
        print('踢足球')

s=Son() #对Son()实例化对象s
s.play()      #打球   s对象使用了Father类里面的方法，继承了父类的方法
s.sing()      #喜欢唱歌  继承父类的方法，不影响自身的方法运行
s.dance()     #喜欢跳舞
s.play()      #踢足球  s对象只是使用了自身的paly方法，没有使用父亲的paly方法，涉及到类的多态特征
print(isinstance(s,Son)) #True 判断对象是否为某个类的实例化
print(isinstance(s,Father)) #True 因为s对象是Son类的实例化，而且Son()是继承了Father(),
# 在实例化过程使用了Son类的构造函数，同时使用了Father类的构造函数

print(isinstance(s,People)) #False  因为s并不是People类的实例化对象
print(issubclass(Son,Father)) #True 判断一个类是否为另外一个类的子类
print(issubclass(Son,People))  #False



类的多态特性
一个对象的属性（类变量）和行为（类中的实例方法）不是由他所继承的父类决定的，
而是由其本身包含的属性（类变量）和方法（类中的实例方法决定的）
class Father(object):
    def __init__(self):
        self.age=45
        pass         #关键字，作用跳过

    def play(self):
        print('打球')

class Son(Father):           #子类继承父类
    def __init__(self):
        Father.__init__(self)  #子类需要继承父类的构造函数
        self.age=18
    def sing(self):
        print('喜欢唱歌')
s=Son()
s.play()   #虽然Son类继承了Father类的，但是类里面的方法是可以重写的
print(s.age)#结果为：18