类的学习笔记

类

类的作用是用来封装事物的属性和描述，当类作为一个模块时，建议不要在模块中实例化和调用类。

 类变量、实例变量、实例方法

class Student:
    name = 'will'
    age = 0
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('从构造内部找',name)
        print(age)

    def do_homework(self):
        print("homework")
    def print_sum(self):
        Student.sum += 1
        return Student.sum 
s1 = Student("jack",24)
print("实例的name属性",s1.name)
print("类的name属性",Student.name)
print(s1.print_sum())
s2 = Student("Marry",25)
print(s2.print_sum())
s3 = Student("Joe",30)
print(Student.sum)
#调用内部函数更改类属性
print(s3.print_sum()) #3

self代表的是调用该方法或者该实例属性的对象实例。

 类方法

使用@classmethod装饰器

class Student:
    name = 'will'
    age = 0
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def do_homework(self):
        print(self.name + " do homework") #在实例方法中访问实例变量
    #类方法定义的格式如下：单纯参数改成cls不够，仍需在方法前面加上一个装饰器
    @classmethod
    def print_sum(cls):
        cls.sum += 1
        print("当前学生数：",cls.sum)
s1 = Student("jack",24)
Student.print_sum() #通过类调用类方法
s2 = Student("mary",23)
Student.print_sum()
s3 = Student("Sona",27)
Student.print_sum()
#通过对象调用类方法也可以，python允许这样做，但是这样不常用
s1.print_sum()
s2.print_sum()
s3.print_sum()

还可以直接这样

class Student:
    name = 'will'
    age = 0
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #类方法定义的格式如下：单纯参数改成cls不够，仍需在方法前面加上一个装饰器
    @classmethod
    def print_sum(cls):
        cls.sum += 1
        print("当前学生数：",cls.sum)

Student.print_sum() #通过类调用类方法
Student.print_sum()
Student.print_sum()
print(Student.sum) #3

 静态方法

class Student:
    name = 'will'
    age = 0
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #类方法定义的格式如下：单纯参数改成cls不够，仍需在方法前面加上一个装饰器
    @classmethod
    def print_sum(cls):
        cls.sum += 1
        print("当前学生数：",cls.sum)
        #print(self.name)  NameError 报错 说明类方法无法访问实例变量
    #定义静态方法 ，静态方法和普通函数没什么区别，而且不常用，能用类方法解决就用类方法。
    @staticmethod
    def add(x,y):
        print(x + y)
        #print(self.name)  NameError 报错 说明静态方法无法访问实例变量
s1 = Student("smith",26)
#同调用类方法一样，通过类和实例都可以调用静态方法，最好用类调用，逻辑上容易理解
s1.add(5,6)
Student.add(4,5)

 私有变量隐藏

class Student:
    name = 'will'
    age = 0
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age
        #私有变量
        self.__score = 12
    def do_homework(self):
        #类空间内实例方法中调用另外一个实例方法
        self.do_english_homework()
    def do_english_homework(self):
        print(self.name + " is doing english homework")
    def marking(self,score):
        if score < 0:
            return "不能打负分"
        self.__score = score
        print(self.name+"当前分数" +  str(self.__score))
        self.__reading() #内部方法调用私有方法不会报错
    #私有方法
    def __reading(self):
        print("students are reading")

s1 = Student("will",26)
s1.do_homework()
s1.marking(50)
#python里对变量的修改，不应该直接对变量赋值，而是通过方法更改变量值，这样我们可以在
result = s1.marking(-1)
print(result)

#这样会报错
#print(s1.__score)

#从外部新建私有变量不会报错
s1.__number = 40
print(s1.__number)
print(s1.__dict__) #_Student__score代表隐藏变量

s2 = Student('soso',23)
print(s2.__dict__) #
print(s2._Student__score) #这样可以读取隐藏的变量，但是这样就失去隐藏的意义，所以一般不读取隐藏的变量
#私有方法从外部调用会报错,内部其他函数调用没有问题
#s1.__reading()

继承

class Human:
    sum = 1
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def get_name(self):
        print("名字：",self.name)
    
    def do_homework(self):
        print("doing  homework")

from c5 import Human
class Student(Human):
    
    def __init__(self,school,name,age):
        self.school = school
        # Human.__init__(self,name,age) #调用父类构造函数时，需要显式的输入self参数
        #调用父类构造函数的第二种方法super()函数
        super(Student,self).__init__(name,age)
    def do_homework(self):
        super(Student,self).do_homework()
        print("doing englishhomework")
s1 = Student("Janco","will",26)
print(s1.school)
print(s1.name)
print(s1.age)
print(s1.get_name()) #调用父类方法
print(s1.sum) #调用父类的类变量
s1.do_homework()

子类可以继承父类的类变量，方法。