python入门与进阶（9-12 9-13）

9-12 成员可见性：公开和私有
9-13 没有什么是不能访问
成员的可见性就是变量和方法的可见性！
看看思维导图

Python类.png

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的动态特性决定的

01.jpg 02.jpg 03.jpg 5.jpg 06.jpg 07.jpg