面向对象

类、对象

1.类：类是现实世界或思维世界中实体在计算机中的反映。它将数据以及这些数据上的操作封装在一起。是一个抽象概念并不具体。一类事物的总称

命名时第一个字母最好大写、最好不要用下划线连接       class 类的名字():   

在类的内部：可以定义若干个变量、可以定义函数

如何使用类：实例化

总结：类最基本作用：封装（封装里面的变量和代码）

           类下边的函数称作为方法，一定要加self且如果在函数内部想要使用类所定义的变量需要通过self.变量名

          调用类时要在类外部调用，类只负责描述，定义，不负责执行代码

class Student():  #定义一个名为Student的类
    name=""  #定义name变量
    age=0    #定义age变量
    # 行为 与 特征
    def print_file(self):     #定义print_file函数，在类中定义必须加self
        print("name:"+self.name)   #使用类中定义的变量时，必须加self.
        print("age:"+str(self.age)) #使用类中定义的变量时，必须加self.转化age为字符串
                                      #类定义完毕
student=Student()    #调用类
student.print_file()

如何在另外一个模块使用类（最好一个模块全是定义类，一个模块全是使用类）

from p5 import Student

student=Student()
student.print_file()

方法和函数的区别：没有绝对的区别

2.对象：表示一个具体的概念。是具体取值。当类被实例化后成具体对象。

类就像一个印刷机是一个模板，通过类可以产生很多对象。类可以通过传入各种各样特征的具体值而产生各种各样不同的对象。

实例化以及实例化的意义

模块里  局部变量和全局变量：局部变量不会改变全局变量的值

类里     类变量和实例变量

类变量是和类相关在一起的   实例变量是和对象相关在一起的

class Student():  #定义一个名为Student的类
    sum =0  #定义类变量  不是针对对象的某一个具体特征
    name='qiyue'  #定义name变量        类变量  其实在这不合适
    age=0    #定义age变量         类变量
    # 行为 与 特征
#“类变量”和“实例变量”  实例方法
    def __init__(self,name,age):    #构造函数,构造函数的调用是自动运行的，也可以自己调用
        self.name=name            #构造函数的主要作用是初始化对象的属性  定义实例变量加self.
        self.age=age         #定义实例变量
        print(self.name)    #访问实例变量要加self
        print(Student.sum)          #在内部访问类变量方法一
        print(self.__class__.sum)   #在内部访问类变量方法二

    def do_homework(self):     #定义do_homework函数，在类中定义必须加self
        print("homework")   #使用类中定义的变量时，必须加self.

student1 = Student('石敢当',18)    #调用类
student2 = Student('喜小乐',19)
print(student1.name)           
print(student2.name)
print(Student.name)               #在外部访问类变量，通过类名.类变量名
为什么要有类  要有类变量？？

一、self与实例方法

1.实例方法定义时要有self（可以用this等等，但建议用self）

2.调用实例方法时不需要对self传递数

self只和对象有关，代表实例 

在实例方法内部如何访问类变量

方法一：   在实例方法内    print(类名.类变量名)

方法二： 在实例方法内      print(self.__class__.类变量名) 

class Student():  #定义一个名为Student的类
    sum=0
    name='qiyue'  #定义name变量        类变量
    age=0    #定义age变量         类变量
    # 行为 与 特征
#“类变量”和“实例变量”
    def __init__(self,name,age):    #构造函数,构造函数的调用是自动运行的，也可以自己调用
        self.name=name    #初始化对象的属性  定义实例变量加self.
        self.age=age         #定义实例变量
        print(self.name)     #使用实例变量时，必须加self.
        print(self.age)

    def do_homework(self):     #定义实例方法do_homework函数，在类中定义必须加self
        self.__class__.sum +=1    #调用类变量sum
        print("当前班级学生总数为："+str(self.__class__.sum))
        print("homework")

student1 = Student('石敢当',18)    #调用类
student1.do_homework()
student2 = Student('喜小乐',18)    #调用类
student2.do_homework()

 

二、类方法

如何定义一个类方法   在定义函数之前先输入一行

@classmethod

class Student():  #定义一个名为Student的类
    sum=0
    name='qiyue'  #定义name变量        类变量
    age=0    #定义age变量         类变量
    # 行为 与 特征
#“类变量”和“实例变量”
    def __init__(self, name, age):  # 构造函数,构造函数的调用是自动运行的，也可以自己调用
        self.name = name  # 初始化对象的属性  定义实例变量加self.
        self.age = age  # 定义实例变量
        print(self.name)  # 使用实例变量时，必须加self.
        print(self.age)

    def do_homework(self):     #定义实例方法do_homework函数，在类中定义必须加self
        print("homework")
    @classmethod               #定义类方法  主要操作类变量
    def plus_sum(cls):
        cls.sum += 1  # 调用类变量sum
        print("当前班级学生总数为：" + str(cls.sum))

student1 = Student('石敢当',18)    #调用类
student1.plus_sum()               #使用对象来调用类方法  不建议
Student.plus_sum()                #使用类来调用类方法
student2 = Student('喜小乐',18)    #调用类
student2.plus_sum()

三、静态方法

class Student():  #定义一个名为Student的类
    sum=0
    name='qiyue'  #定义name变量        类变量
    age=0    #定义age变量         类变量
    # 行为 与 特征
#“类变量”和“实例变量”
    def __init__(self, name, age):  # 构造函数,构造函数的调用是自动运行的，也可以自己调用
        self.name = name  # 初始化对象的属性  定义实例变量加self.
        self.age = age  # 定义实例变量
        print(self.name)  # 使用实例变量时，必须加self.
        print(self.age)

    def do_homework(self):     #定义实例方法do_homework函数，在类中定义必须加self
        print("homework")
    @classmethod               #定义类方法  主要操作类变量
    def plus_sum(cls):
        cls.sum += 1  # 调用类变量sum 不可以调用实例变量
        print(cls.sum)
        print(self.name)
    @staticmethod             #定义静态方法   不建议经常用
    def add(x,y):
        print(Student.sum)           #静态方法里可以访问类变量但不可以访问实例变量
        print("this is a static method")

student1 = Student('石敢当',18)    #调用类
student1.plus_sum()       #使用对象来调用类方法
Student.plus_sum()        #使用类来调用类方法
student1.add(1,2)         #使用对象来调用静态方法
Student.add(1,2)          #使用类来调用静态方法

3.成员的可见性：即变量和方法的可见性

一个类下边的变量是他非常重要的特征，如果要修改类变量的默认值，不应该在外部通过直接访问变量的方式来改变它的状态，正确的方式应该是所有对类下面变量的更改都应该在类内部通过方法完成。

class Student():  #定义一个名为Student的类
    sum=0

    def __init__(self, name, age):  # 构造函数,构造函数的调用是自动运行的，也可以自己调用
        self.name = name  # 初始化对象的属性  定义实例变量加self.
        self.age = age  # 定义实例变量
        self.score=0

    def marking(self,score):   #定义实例方法marking  用来限制自己变量的范围
        if score<0:
            return "不能够给别人打负分"
        self.score=score
        print(self.name+"同学本次考试分数为："+str(self.score))

    def do_homework(self):     #定义实例方法do_homework函数，在类中定义必须加self
        print("homework")

student1 = Student('石敢当',18)    #调用类
result=(student1.marking(-1))   #通过实例方法来访问
print(result)

成员可见性：公开的（public：可以类的外部直接访问，赋值，读取）和私有的（private：在外部无法直接读取或设置）

当给变量或方法加上双下划线__时python会认为这个变量或方法是私有的（构造函数__init__除外），如

def __marking(self,score):

由于python的动态性特征，可以在外面重新给创建变量赋值。

class Student():  #定义一个名为Student的类
    sum=0

    def __init__(self, name, age):  # 构造函数,构造函数的调用是自动运行的，也可以自己调用
        self.name = name  # 初始化对象的属性  定义实例变量加self.
        self.age = age  # 定义实例变量
        self.__score=0

    def marking(self,score):   #定义实例方法marking  用来限制自己变量的范围
        if score<0:
            return "不能够给别人打负分"
        self.__score=score
        print(self.name+"同学本次考试分数为："+str(self.__score))

    def do_homework(self):     #定义实例方法do_homework函数，在类中定义必须加self
        print("homework")

student1 = Student('石敢当',18)    #调用类
result=(student1.marking(59))   #通过实例方法来访问
print(result)
student1.__score=-1     #能运行并不是类中的__score不是私有的而是添加了新的实例变量
print(student1.__score)
print(student1.__dict__)  #查看student1中的内容
student2 = Student('喜小乐',18)
print(student2.__score)  #没有重新给__score赋值，读取原先的私有__score所以不行

面向对象的三大特性：继承性、封装性、多态性。

1.继承性：避免定义重复的方法或变量。子类可以从父类中继承

class Human():        #父类  存放在p2.py
    sum=0
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def get_name(self):  #构造实例方法，必须加self
        print(self.name)

    def do_homework(self):
        print("This is a parent method")

from p2 import Human   #调用父类

class Student(Human):  #子类
    def __init__(self, school,name,age):  #需要把父类中构造函数的变量传入
        self.school=school
        #Human.__init__(self,name,age) #调用父类中的方法，必须加self,通过类调用实例方法，不推荐
        super(Student,self).__init__(name,age)#调用父类中的方法  前边有self，后边不用加
    def do_homework(self):     #定义实例方法do_homework函数，在类中定义必须加self
        super(Student,self).do_homework() #调用父类中的do_homework方法
        print("homework")
student1 = Student("人民路小学",'石敢当',18)    #实例化
student1.do_homework()