09面向对象
2019-02-28 本文已影响0人
白眸怪ya
9-1 类的定义
# 面向对象
# 有意义的面向对象的代码
# 类 = 对象
# 类、对象
# 实例化
# 类基本的作用就是：封装
class Student():#定义一个类，那么在类的内部可以做哪些事情呢？
name = ''
age = 0 #在类的内部可以定义若干个变量
def print_file(self):#在类的内部可以定义一个函数,必须加self，这是跟定义普通函数的区别
print('name:' + self.name) #添加self来引用
print('age:' + str(self.age))
#在定义函数结束以后，考虑一下，如何调用类内部的函数？（这个过程叫做实例化）
# 什么是实例化？
student = Student()#这就是实例化的过程
student.print_file()#这就是调用类下面方法的过程
# 类只负责刻画描述，不会用来执行代码，如果在函数内部跟调用普通函数一样去调用类，是不正确的
# 要调用就在类的外部
9-2 浅谈函数与方法的区别
最好的方法就是：一个模块专门存放类，另一个模块专门负责调用，通过引用的方式来调用。省的错乱！
9-3 类与对象
#方法和函数的区别：
#没有特别强调方法和函数的区别
#方法更多的应用于设计层面
#在类下面的变量称为数据成员。当然也可以称作变量
# 9—3 本章要关注的就是类和对象
# 类和对象就是通过实例化的关系关联在一起的！！！！首先来看看什么是类？！
# 类是现实世界或思维世界中的实体在计算机中的反映
# 它将数据以及这些数据上的操作封装在一起
class Student():
name = ''
age = 0
# 数据成员刻画学生的特征 ，学生能做什么事就叫做行为！！
# 类的概念：行为和特征
# 类是一个群体，对象是具体的。类像一个模板！！！
def print_file(self):
print('name:' + self.name)
print('age:' + str(self.age))
student = Student()
student.print_file()
9-4 构造函数
9-5 区别模块变量与类中的变量
9-6 类变量与实例变量
本节重点：什么是实例化？实例化的意义！
class Student():
name = ''
age = 0
def do_homework(self):
print('homework')
# print('name:' + self.name)
# print('age:' + str(self.age))
student1 = Student()
student2 = Student() #这三个所代表的特征是相同的。但是在计算机中是不同的，如图1
student3 = Student()
print(id(student1))
print(id(student2))
print(id(student3))
#如何让这3个对象在实例化以后不相同呢？函数中通过传递参数的形式实现的，那么这里也可以通过
# 向类传递不同的参数来生成不同的对象
class Student():
name = ''
age = 0
def __init__(self): #构造函数
#初始化对象的属性
print('student')
def do_homework(self):
print('homework')
# print('name:' + self.name)
# print('age:' + str(self.age))
student1 = Student() #不能在这里传递参数，这是不正确的！
student1.__init__() #打印结果如图2，会出现两个student，为什么呢？因为构造函数是自动调用的
#student2 = Student() #这三个所代表的特征是相同的。但是在计算机中是不同的，如图1
#student3 = Student()
class Student():
name = ''
age = 0
def __init__(self):
print('student')
def do_homework(self):
print('homework')
student1 = Student()
a = student1.__init__() #构造函数也是可以调用的，如图3!但是却不能用于return
print(a)
print(type(a))
class Student():
name = ''
age = 0
def __init__(self,name,age): #在这里传入两个参数
#构造函数
#初始化对象的属性
#区分类变量（和类相关的）和实例变量（和对象相关联在一起的）！！！
name = name #第一个name是类中的变量name，第二个name是参数中的name
age = age
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18) #上面的参数有了，这里必须要传入参数，不然报错
print(student1.name)#通过 . 来访问的
#打印结果如图4，是一个空的，那么构造函数里的name，如何改变类里的变量name呢？
# 看下面的例子
class Student():
name = '小鱼'
age = 0
def __init__(self,name,age):
#构造函数
#初始化对象的属性
#区分类变量（和类相关的）和实例变量（和对象相关联在一起的）！！！
self.name = name #通过self.的形式就构建了与类变量不同的实例变量
self.age = age
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
student2 = Student('喜小乐',18)
print(student1.name) #打印实例的name
print(student2.name)
print(Student.name) #打印类的name
#如图5所示
image
image
image
image
image
9-7 类与对象的变量查找顺序
class Student():
name = ''
age = 0
def __init__(self,name,age):
name = name
age = age
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
print(student1.name)
#打印结果如图1，什么也没有！
# 类变量和构造函数里面的对象同模块里的局部变量和全局变量对比是错误的。
#那么为什么打印的是空？什么也没有呢？打印的明明就是实例变量，为什么会出现空呢？
# 看看下面的例子！
class Student():
name = 'xiaoyu'
age = 0
def __init__(self,name,age):
name = name #通过self.来赋值实例变量。此处没有
age = age
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
print(student1.name)
print(Student.name)
# 如图 2，打印了两个变量，实例变量和类变量都是相同的。为什么？
class Student():
name = 'xiaoyu'
age = 0
def __init__(self,name,age):
name = name #通过self.来赋值实例变量。此处没有
age = age
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
print(student1.__dict__) #打印的结果是空的字典，如图3
#print(student1.name)
#print(Student.name)
# 当我们加完self以后看看结果
class Student():
name = 'xiaoyu'
age = 0
def __init__(self,name,age):
self.name = name #通过self.来赋值实例变量。此处没有
self.age = age
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
print(student1.__dict__)
# 打印结果如图4
# 如果尝试去寻找实例变量的时候，如果没有找到，Python并不会返回空，它会去类变量里面找
# 看看类变量的dict！
class Student():
name = 'xiaoyu'
age = 0
def __init__(self,name,age):
self.name = name #通过self.来赋值实例变量。此处没有
self.age = age
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
print(student1.__dict__)
print(Student.__dict__)#打印结果如图5
image
image
image
image
image
9-8 self与实例方法
class Student():
sum = 0
name = '小鱼'
age = 0
# 实例方法 定义实例方法的时候必须加上self
def __init__(self,name,age):
self.name = name
self.age = age #self就是当前调用某一个人方法的应用，例如do_homework
#指向的就是student1
#print('student')
def do_homework(self):
print('homework')
student1 = Student('石敢当',18) #调用的时候不需要加上self
student1.do_homework()
print(student1.name)
print(student2.name)
print(Student.name)
# 实例变量和对象也就是和类所生成的实例相关联的的变量
# 实例方法和对象和实例相关联的，也就是实例可以调用的方法，实例方法最大的特点就是第一个参数要传入self
9-9 在实例方法中访问实例变量与类变量
看一看思维导图
image
问题如下，在实例方法的内部（强调在实例方法的内部）可以访问类变量吗？如果可以访问，那么访问的方式是什么？
class Student():
sum = 0
name = '小鱼'
age = 0
# 实例方法 定义实例方法的时候必须加上self
def __init__(self,name,age): #构造函数的意义是初始化类的特征的
#构造函数可以看做是一个特殊的实例方法。和普通的实例方法几乎是一样的
#最大的不同是，调用的方式的不同
self.name = name
self.age = age
print(self.name) #实例方法里操作实例变量
def do_homework(self):#实例方法是描述类的行为的
print('homework')
student1 = Student('石敢当',18) #调用构造函数是通过类后面加上括号的方式来调用的
student1.do_homework()#调用普通函数的是通过实例对象后面加点
print(student1.name)
print(student2.name)
print(Student.name)
# 来看一个经典的例子（容易犯错的，反面教材）
class Student():
sum = 0
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
print(self.name) #看看这个打印结果 有不一样的吗？
print(name) #看看这个打印结果 有不一样的吗？打印结果如图1，都是一样的，为什么？
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
#当我们把形参列表中的name改成name1 看看结果是什么？如图2
class Student():
sum = 0
name = '小鱼'
age = 0
def __init__(self,name1,age):
self.name = name1
self.age = age
print(self.name)
print(name)
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
# 为什么出现图2的错误？
# 因为self.name 读取的是实例变量，而print(name)读取的是形参列表，所以造成了假象，打印了两个一样的结果
# 所以加上self很有必要
# 如何在实例方法中访问类变量？
class Student():
sum = 0 #sum是内置函数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
print(sum) #在实例方法中访问类变量看图3打印结果
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
# 在看一个例子
class Student():
sum1 = 0 #不是内置函数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
print(sum1) #在实例方法中访问类变量看图4打印结果
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
# 上述的两个例子说明千万不要妄图在实例方法的内部通过不加self直接访问实例变量
# 也不要想着不加前缀来访问类变量
# 来看看正确的在实例方法中访问类变量的两种方式 如图5所示
class Student():
sum1 = 0
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
print(Student.sum1) #在内部的使用
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
print(student1.name)
print(Student.sum1) #通过大写类名加点号在加变量名，这是在外部的使用！在内部同样可以！
# 第二种方式
class Student():
sum1 = 0
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
print(self.__class__.sum1) #这种方法也可以
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
print(student1.name)
print(Student.sum1)
image
image
image
image
image
9-10 类方法
看看下列思维导图
image
本节课重点讲述类方法
# 实例方法里操作类变量，如让学生的总数加1
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
self.__class__ .sum += 1 #这是在构造函数里的操作
print('当前班级学生总数为：' + str(self.__class__.sum))
# print(self.__class__.sum += 1) #每次创建一个对象，说明班级多了一个学生
def do_homework(self):
print('homework')
student1 = Student('石敢当',18)
student2 = Student('喜小乐',18)
student3 = Student('西门庆',18)
# 打印结果如图1所示
# 第二种方法也可以实现实例方法的类操作变量，如下
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
# print(self.__class__.sum += 1) #每次创建一个对象，说明班级多了一个学生
def do_homework(self):
self.__class__ .sum += 1 #在普通函数里也可以实现这样的操作
print('当前班级学生总数为：' + str(self.__class__.sum))
print('homework')
student1 = Student('石敢当',18)#到时再调用的时候，应该使用如下调用方法
student1.do_homework()
student2 = Student('喜小乐',18)
student2.do_homework()
student3 = Student('西门庆',18)
student3.do_homework()
#打印结果如图2所示
# 实例方法专门操作实例变量的，那么类方法也是专门操作类变量的，下面来看类方法操作类变量
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
self.__class__ .sum += 1 #这是在构造函数里的操作
print('当前班级学生总数为：' + str(self.__class__.sum))
# print(self.__class__.sum += 1) #每次创建一个对象，说明班级多了一个学生
def do_homework(self):
print('homework')
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
print(cls.sum)
student1 = Student('石敢当',18)
Student.plus_sum() #调用的方法是在这样的
student2 = Student('喜小乐',18)
Student.plus_sum()
student3 = Student('西门庆',18)
Student.plus_sum()
# 打印结果如图3，为什么会造成图3 的原因！！！因为在构造函数里有self.__class__ .sum += 1
# 所以打印的结果就是图3这种，1，2，3，4，5，6
# 类方法里的cls，也可以全部换成this等这样的，当然也可以换成self
# 我们可以用类来调用类方法，我们可不可以用对象来调用类方法呢？答案是可以的
# 看看下面的例子
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
self.__class__ .sum += 1 #这是在构造函数里的操作
print('当前班级学生总数为：' + str(self.__class__.sum))
# print(self.__class__.sum += 1) #每次创建一个对象，说明班级多了一个学生
def do_homework(self):
print('homework')
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
print(cls.sum)
student1 = Student('石敢当',18)
student1.plus_sum()#用对象来调用类方法，最好不要用！！！
image
image
image
9-11 静态方法
看看思维导图
image
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
self.__class__ .sum += 1 #这是在构造函数里的操作
print('当前班级学生总数为：' + str(self.__class__.sum))
# print(self.__class__.sum += 1) #每次创建一个对象，说明班级多了一个学生
def do_homework(self):
print('homework')
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
print(cls.sum)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
# 来看看静态方法的调用方式！！！
student1 = Student('石敢当',18)
student1.add(1,2)#静态方法被对象调用
Student.add(1,2)#静态方法也可以被类调用
# 如图1
# 思考一个问题，类方法和静态方法可不可以访问实例变量？
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
self.__class__ .sum += 1 #这是在构造函数里的操作
#print('当前班级学生总数为：' + str(self.__class__.sum))
# print(self.__class__.sum += 1) #每次创建一个对象，说明班级多了一个学生
def do_homework(self):
print('homework')
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
#print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print(self.name)
#print('this is a static method')
# 来看看静态方法的调用方式！！！
student1 = Student('石敢当',18)
student1.add(1,2)#静态方法被对象调用
Student.add(1,2)#静态方法也可以被类调用
student1.plus_sum()#对象访问类方法
Student.plus_sum()#类访问类方法
# 打印结果如图3所示，造成图3的原因如下
# 如果尝试在静态方法和类方法里引用实例变量会直接报错的
# 静态方法和类方法（类方法好用点），静态方法慎重使用
image
image
image
9-12 成员可见性：公开和私有
9-13 没有什么是不能访问
成员的可见性就是变量和方法的可见性！
看看思维导图
image
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age):
self.name = name
self.age = age
self.__class__ .sum += 1 #这是在构造函数里的操作
#print('当前班级学生总数为：' + str(self.__class__.sum))
# print(self.__class__.sum += 1) #每次创建一个对象，说明班级多了一个学生
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
#print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print(self.name)
#print('this is a static method')
student1 = Student('石敢当',18) #这两段代码表示在外部访问
student1.do_homework()
# 变量和类都分为内部和外部
# 所有的成员数据都可以从外部访问。这样会造成类的不安全
# 对于某些势力变量我们不允许别人从外部更改，只允许自己从内部更改。看下面的例子
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.score = 0
self.__class__ .sum += 1
def marking(self,score): #定义一个实例方法
self.score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18) #这两段代码表示在外部访问
student1.marking(88) #完成打分操作
#打印结果如图01所示
#如果要破坏这个分数，看下列的结果
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.score = 0
self.__class__ .sum += 1
def marking(self,score): #定义一个实例方法
self.score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18) #这两段代码表示在外部访问
student1.marking(-1)
# 如图2所示，得分是负数
# 方法的强大请看下面的例子，它能够保证数据的安全性
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.score = 0
self.__class__ .sum += 1
def marking(self,score): #定义一个实例方法
self.score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18) #这两段代码表示在外部访问
student1.marking(-1)
# 如图2所示，得分是负数
# 方法的强大请看下面的例子，它能够保证数据的安全性
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.score = 0
self.__class__ .sum += 1
def marking(self,score): #定义一个实例方法
self.score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18) #这两段代码表示在外部访问
student1.marking(-1)
# 如图2所示，得分是负数
# 方法的强大请看下面的例子，它能够保证数据的安全性
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.score = 0
self.__class__ .sum += 1
def marking(self,score): #定义一个实例方法
if score < 0:
return '不能够给别人打负分' #通过这两行代码，可以有限保护类数据的安全性
self.score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18)
result = student1.marking(-1)
print(result)
# 如图3所示
# 编程过程中，一个类里的数据变量是类的一个非常重要的特征数据，一般来说，我们想修改类的这样一个特征
# 的值，不应该通过直接访问变量的方式，来改变变量的状态。正确的方式是所有对于类下面变量的更改都应该
# 通过方法来完成
# 有没有什么方法可以通过外部来阻止其他人对数据进行操作呢？有，这就牵扯到成员可见性的问题！
# 为什么可以对上面student.score来进行赋值？因为score的成员可见性是公开的
# 公开的 public 如score
# 私有的 private
# 在Python中，没有public 和private这样的关键字来指定方法和变量的可见性，
# 那么Python是如何来决定一个变量或者一个方法的成员可见性呢？
# 给一个变量或者方法加了双下划线，说明这个变量或者方法是私有的，若不加双下划线，则说明是公开的
# 看看一个例子
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.score = 0
self.__class__ .sum += 1
def marking(self,score): #定义一个实例方法
if score < 0:
return '不能够给别人打负分' #通过这两行代码，可以有限保护类数据的安全性
self.score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18)
result = student1.marking(-1)
print(result)
# 如图3所示
# 编程过程中，一个类里的数据变量是类的一个非常重要的特征数据，一般来说，我们想修改类的这样一个特征
# 的值，不应该通过直接访问变量的方式，来改变变量的状态。正确的方式是所有对于类下面变量的更改都应该
# 通过方法来完成
# 有没有什么方法可以通过外部来阻止其他人对数据进行操作呢？有，这就牵扯到成员可见性的问题！
# 为什么可以对上面student.score来进行赋值？因为score的成员可见性是公开的
# 公开的 public 如score
# 私有的 private 既不能读取也不能赋值!
# 在Python中，没有public 和private这样的关键字来指定方法和变量的可见性，
# 那么Python是如何来决定一个变量或者一个方法的成员可见性呢？
# 给一个变量或者方法加了双下划线，说明这个变量或者方法是私有的，若不加双下划线，则说明是公开的
# 看看一个例子
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.score = 0
self.__class__ .sum += 1
def __marking(self,score): #在前面加上双下划线，变成私有的了
if score < 0:
return '不能够给别人打负分' #通过这两行代码，可以有限保护类数据的安全性
self.score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18)
result = student1.__marking(-1) #调用这个私有的方法，看打印结果！
print(result)
# 如图5所示
# 再来看看另外一个例子
class Student():
sum = 0 #一个班级学生的总数
name = '小鱼'
age = 0
def __init__(self,name,age): #此处添加参数score，是我们自己想看到的，不想让别人从外部访问
self.name = name
self.age = age
self.__score = 0
self.__class__ .sum += 1
def marking(self,score): #在前面加上双下划线，变成私有的了
if score < 0:
return '不能够给别人打负分' #通过这两行代码，可以有限保护类数据的安全性
self.__score = score
print(self.name + '同学本次考试分数为：' + str(self.score))
def do_homework(self):
self.do_english_homework() #这就是在内部调用！！！
print('homework')
def do_english_homework(self):
print()
# 定义一个类方法的格式如下,@classmethod叫做装饰器
@classmethod
def plus_sum(cls):#实例方法用self,类方法用cls
cls.sum += 1 #模仿实例方法的书写模式
#print(cls.sum)
print(self.name)
# 静态方法的格式
# 静态方法和类方法和实例方法相比较不需要传递参数
@staticmethod
def add(x,y):
print(Student.sum)#静态方法的内部也是可以访问类变量的 如图2
print('this is a static method')
student1 = Student('石敢当',18)
result = student1.marking(-1)
print(result)
student1.__score = -1 #将score变成私有的
#print(student1.__score) # 打印结果如图6
print(student1.__dict__)# 打印结果如图7所示，红框部分说明，就是累变量里的变量，被保护起来了，无法动态改写
# 根据图6 打印结果出现了，那么就是说私有的是不是失效了呢？不是没有成功，而是相当于给student1新添加了
# 一个实例变量，这是由于Python的动态特性决定的
image
image
image
image
image
image
9-14 继承.
本节课重点讲解继承性。看思维导图
image
test1.py内容如下：
class Human():
sum = 0
def __init__(self,name,age):
self.name = name
self.age = age
def get_name(self):
print(self.name)
test.py内容如下：
from test1 import Human
class Student(Human): #student子类继承human父类
# sum = 0
# def __init__(self,name,age):
# self.name = name
# self.age = age
# self.__score = 0
# self.__class__ .sum += 1
def do_homework(self):
print('english homework')
student1 = Student('石敢当',18)
print(student1.sum)
print(Student.sum)
print(student1.name)
print(student1.age)
student1.get_name()
# 看下面的代码
from test1 import Human
class Student(Human): #student子类继承human父类
# sum = 0
def __init__(self,school,name,age):
self.school = school #school 属于子类，name，age属于父类，那么如何在子类里把name和age传给父类？
Human.__init__(self,name,age)#这样就实现了在子类里调用父类的构造函数
# self.name = name
# self.age = age
# self.__score = 0
# self.__class__ .sum += 1
def do_homework(self):
print('english homework')
student1 = Student('人民路小学','石敢当',18)
# print(student1.sum)
# print(Student.sum)
print(student1.name)
print(student1.age)
# student1.get_name()
image
image
9-15 子类方法调用父类方法：super关键字
父类
class Human():
sum = 0
def __init__(self,name,age):
self.name = name
self.age = age
def get_name(self):
print(self.name)
def do_homework(self):
print('this is a paraent method')
from test1 import Human
class Student(Human): #student子类继承human父类
# sum = 0
# def __init__(self,name,age):
# self.name = name
# self.age = age
# self.__score = 0
# self.__class__ .sum += 1
def do_homework(self):
print('english homework')
student1 = Student('石敢当',18)
print(student1.sum)
print(Student.sum)
print(student1.name)
print(student1.age)
student1.get_name()
# 看下面的代码
from test1 import Human
class Student(Human): #student子类继承human父类
# sum = 0
def __init__(self,school,name,age):
self.school = school #school 属于子类，name，age属于父类，那么如何在子类里把name和age传给父类？
#Human.__init__(self,name,age)#这样就实现了在子类里调用父类的构造函数
super(Student,self).__init__(name,age)#这样就完成了调用父类的构造函数，super关键字指的就是父类human
# self.name = name
# self.age = age
# self.__score = 0
# self.__class__ .sum += 1
def do_homework(self):
super(Student,self).do_homework()#super不仅可以应用于构造函数，也可以应用于普通方法里
print('english homework')
student1 = Student('人民路小学','石敢当',18)
student1.do_homework()#父类和子类相同的时候，有限打印子类，如图1
# print(student1.sum)
# print(Student.sum)
# print(student1.name)
# print(student1.age)
# student1.get_name()
image
image
作者：buaishengqi
链接：https://www.jianshu.com/p/cb76b85d8eab
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
