类的学习笔记

╰+哭是因爲堅強的太久メ 2023-06-03 08:59 38阅读 0赞

# 类 #

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

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

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代表的是调用该方法或者该实例属性的对象实例。

![1509107-20190801152622959-1397776473.png][]

## 类方法 ##

使用@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

![1509107-20190801160412728-304392382.png][]

## 静态方法 ##

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()

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

转载于:https://www.cnblogs.com/chxb/p/11268649.html

[1509107-20190801152622959-1397776473.png]: /images/20230601/12724b243d2c48699b1a473b697c581c.png
[1509107-20190801160412728-304392382.png]: /images/20230601/65e6ef819c444496aa60b8ab368b4c03.png