python学习第六天----面向对象

1.创建一个类：

class Student():
    name = ''
    age = 0

    def print_file(self):
        print('name: ' + self.name)
        print('age: ' + str(self.age))


#实例化
student = Student()
student.print_file()
#name:
#age: 0

　　1. 类中函数的定义必须有self形参。这个形参指向这个类

　　2. 调用类中的变量需要通过self去调用

　类的定义：

　　类是现实世界或思维世界中的实体在计算机中的反映。它将数据以及这些数据上的操作封装在一起。

　　实例化： 就是讲零件（参数）放到这个类的工厂中，加工出来的不同的对象。

 

2.构造函数：（__init__）

class Student():
    name = ''
    age = 0

    def __init__(self):
        # 构造函数
        print('student')

    #行为与特征
    def do_homework(self):
        print('homework')

student1 = Student()
# student

　　1. 构造函数的调用是在实例化时自动执行的。我们也可以显式的去调用。

student1.__init__();

　　构造函数与普通函数的区别：构造函数返回为None，而且，自定义返回值时也只能是None

class Student():
    name = ''
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        self.name = name
        self.age = age



    #行为与特征
    def do_homework(self):
        print('homework')

student1 = Student('孙悟空', '1000')
print(student1.name)
print(student1.age)

　　在构造方法中可以初始化对象的一些静态变量。

类变量与实例变量：

　　类变量指的是定义类的时候，类里边定义的变量。如name和age。

 

　　self不是关键字，可以命名为其他的名字（标识符），但是python建议我们使用self。

　　self是和对象实例相关联的，可以调用实例方法。

 

　　

探究类 与对象的变量查找顺序

class Student():
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        name = name
        age = age



    #行为与特征
    def do_homework(self):
        print('homework')

student1 = Student('孙悟空', '1000')
print(student1.name)
#qiyue

　　此时打印student1对象字典：

print(student1.__dict__)
#{}

　　修改：

class Student():
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        self.name = name
        self.age = age



    #行为与特征
    def do_homework(self):
        print('homework')

student1 = Student('孙悟空', '1000')
# print(student1.name)
print(student1.__dict__)
#{'name': '孙悟空', 'age': '1000'}

　　

　　对对象内的属性查找顺序----如果有实例变量，就获取实例变量，如果没有实例变量，就获取类变量。

class Student():
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        self.name = name
        self.age = age



    #行为与特征
    def do_homework(self):
        print('homework')

student1 = Student('孙悟空', '1000')
print(student1.name)
print(Student.name)
print(student1.__dict__)
print(Student.__dict__)

结果如下：

孙悟空
qiyue
{'name': '孙悟空', 'age': '1000'}
{'__module__': '__main__', 'name': 'qiyue', 'age': 0, '__init__': <function Student.__init__ at 0x000002326DF3A0D0>, 'do_homework': <function Student.do_homework at 0x000002326DF3A160>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}

在实例中访问实例变量和类变量：

class Student():
   
    sum = 0
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        self.name = name
        self.age = age
        print(Student.sum)
        print(self.sum)
        print(self.__class__.sum)


    #行为与特征
    def do_homework(self):
        print('homework')

student1 = Student('孙悟空', '1000')

#结果是
# 0
# 0
# 0

 

修改类变量。

class Student():
   
    sum = 0
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        self.name = name
        self.age = age
        self.__class__.sum += 1
        print('当前班级总数为' + str(self.__class__.sum))


    #行为与特征
    def do_homework(self):
        print('homework')

student1 = Student('孙悟空', '1000')
student2 = Student('李哪吒', '1000')
student2 = Student('姜尚', '1000')
student2 = Student('姬发', '1000')
student2 = Student('九尾狐', '1000')
student2 = Student('子受', '1000')
#打印结果：
#当前班级总数为1
#当前班级总数为2
#当前班级总数为3
#当前班级总数为4
#当前班级总数为5
#当前班级总数为6

类方法：

class Student():
   
    sum = 0
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        self.name = name
        self.age = age
        self.__class__.sum += 1
        print('当前班级总数为' + str(self.__class__.sum))


    #行为与特征
    #实例方法
    def do_homework(self):
        print('homework')
    

    #类方法 --- 装饰器,需要一个特定的指向，等同实例方法的self，但是python建议使用cls
    @classmethod
    def plus_sum(cls):
        cls.sum += 1
        print(cls.sum)

student1 = Student('石敢当', 18)
Student.plus_sum()
student1 = Student('孙悟空', 18)
Student.plus_sum()
student1 = Student('贾宝玉脖子上的石头', 18)
Student.plus_sum()

打印结果：

当前班级总数为1
2
当前班级总数为3
4
当前班级总数为5
6

python允许对象调用类的方法。

 

 

静态方法：

　　静态方法与类方法和实例方法的不同：

　　　　⑴ 静态方法不必强制传入self或者cls（self指的是实例本身，cls指的是类本身）

 

class Student():
   
    sum = 0
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        # 构造函数
        # 初始化对象的特征
        self.name = name
        self.age = age

    #行为与特征
    #实例方法
    def do_homework(self):
        print('homework')
    

    #类方法 --- 装饰器,需要一个特定的指向
    @classmethod
    def plus_sum(cls):
        cls.sum += 1
        print(cls.sum)

    #静态方法
    @staticmethod
    def add(x, y):
        print(Student.sum)
        print('This is a static method')

student1 = Student('石敢当', 18)
Student.add(1, 2)
student1.add(2,3)

　　打印结果：

0
This is a static method
0
This is a static method

　　说明由类或者实例都可以调用静态方法。

成员可见性：公开和私有

　　如果给方法名或变量名前加上双下划线，而方法名或或变量名后面没有双下划綫，python则认为这个方法为私有的。同时应极力避免在方法名后加双下划线，以分开python内置方法和自定义方法

class Student():
    
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.score = 0


    def __marking(self, score):
        self.score = score
        print(self.name + '同学本次考试分数为' + str(self.score))


student1 = Student('石敢当', 18)
student1.__marking(59)

结果是：

Traceback (most recent call last):
  File "c2.py", line 41, in <module>
    student1.__marking(59)
AttributeError: 'Student' object has no attribute '__marking'

　　在类以外，可以通过类名.方法来执行所有的类里边的所有的非私有方法。

 

　　注意点：

class Student():
   
    sum = 0
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):

        self.name = name
        self.age = age
        self.__score = 0

    def ___marking(self, score):
        self.__score = score
        print(self.name + '同学本次考试分数为' + str(self.score))
        
    #静态方法
    @staticmethod
    def add(x, y):
        print(Student.sum)
        print('This is a static method')

student1 = Student('石敢当', 18)
print(student1.__score)

　　打印结果：

Traceback (most recent call last):
  File "c2.py", line 41, in <module>
    print(student1.__score)
AttributeError: 'Student' object has no attribute '__score'

 

　　此时是访问不到的，但是赋值呢？修改最后一句代码：

student1.__score = -1
print(student1.__score)

　　打印结果是：-1

　　那么，此时是私有变量被修改为共有变量了么？

class Student():
   
    sum = 0
    name = 'qiyue'
    age = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__score = 0

    def marking(self, score):
        self.__score = score
        print(self.name + '同学本次考试分数为' + str(self.__score))

    def getScore(self) :
        print(self.__score)

   
student1 = Student('石敢当', 18)
student1.marking(50)
student1.__score = -1
print(student1.__score)
student1.getScore()
print(student1.__dict__)

　　结果是：

石敢当同学本次考试分数为50
-1
50
{'name': '石敢当', 'age': 18, '_Student__score': 50, '__score': -1}

　　由此可见，私有变量__score被被替换为名_Student__score的共有变量，且可以通过实例方法中的self.__score获取到。

继承：

　　c4.py中的内容：

class Human():

    sum = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_name(self):
        print(self.name)

　　

　　c3.py中的内容：

from c4 import Human

class Student(Human):

    def do_homework(self):
        print('english homework')

student1 = Student("曹雪芹", 220)
print(student1.sum)
print(Student.sum)
print(student1.name)
print(student1.age)
student1.get_name()    

　　

　　Student被称为Human的子类，Human也就是Student的父类。

　　运行c3的结果是：

 

0
0
曹雪芹
220
曹雪芹

　　可以看出，方法和变量皆被继承。

　　python是允许多继承的。

　　对于继承时变量如何传递？修改c3

 

from c4 import Human

class Student(Human):

    def __init__(self, school, name, age):
        self.school = school
        Human.__init__(self,name, age)

    def do_homework(self):
        print('english homework')

student1 = Student("没有", "曹雪芹", 220)
print(student1.name)
print(student1.age)
student1.get_name()

打印结果：

曹雪芹
220
曹雪芹

关键字： super

　　它是代表父类的关键字。当父类的方法名与子类的方法名相同时，通过实体类点出来的方法是子类的。此时，可以通过super来调用父类的同名方法。代码验证如下：

　　c4中在Human类下增加do_homework方法：

 

 def do_homework(self):
        print("this is parent method")

　　修改c3：

from c4 import Human

class Student(Human):

    def __init__(self, school, name, age):
        self.school = school
        # Human.__init__(self,name, age)
        super(Student, self).__init__(name, age)

    def do_homework(self):
        super(Student, self).do_homework()
        print('english homework')

student1 = Student("没有", "曹雪芹", 220)
student1.do_homework()

打印的结果是:

this is parent method
english homework