学习日记22

今日内容

绑定方法

1.绑定给对象的
2.绑定给类的

绑定给对象

class Student():
    country = 'China'
    def __init__(self,name,age):
        self.name1 = name
        self.age = age
        
    def tell_info(self):
        print('%s-%s' % (self.name, self.age))
        
obj = Student('egon', 30)
obj.tell_info()  #对象调用方法，不需要再传参数
​
Student.tell_info(obj)  #类调用方法，要传参数

绑定给类的

import settings
class Mysql():
    country = 'China'
    def __init__(self,ip,port):
        self.ip = ip
        self.port = port
        
    def tell_info(self):
        print('%s-%s' % (self.ip, self.port))
        
    # 类方法是绑定给类的，类来调用，把类名当作第一个参数传递   用到类名就写装饰器
    @classmethod 
    # 原理  cls =》 Mysql（类名）
    def from_config(cls):
        obj = cls(setting.IP, setting.PROT)
        return obj
    
obj = Mysql('127.0.0.1',80)
Mysql.from_config()
​
# 不管绑定给谁，都只能传一个参数 
# 如果想要既传类又传对象 就绑定给对象
# self.__class__  找到产生对象的类

非绑定方法

非绑定方法：不绑定给对象，也不绑定给类

# 调用方法参数该怎么传就怎么传
class Mysql():
    def __init__(self,ip,port): 
        self.ip = ip
        self.port = port
        
    @staticmethod # 静态方法，类调用的时候才要用
    def create_id():
        import uuid
        print(uuid.uuid4())
        
obj = Mysql('127.0.0.1',3306)
Mysql.create_id()

uuid模块

随机字符串，基本上永不重复

隐藏属性

1、如何隐藏

# 原理
# 在类定义阶段，把隐藏对象语法变形,只要改变语法还可以使用
# __country -> _People__country
# 该隐藏对外不对内
# 原理是在定义阶段，扫描到调用隐藏对象的语句时，依旧会语法变形，所以可以直接调用
# 如果想访问类中的隐藏属性，在类中开放对外的接口，可以更好的对外部做限制
#变形操作只在类定义阶段，之后的所有属性或者方法，都不会变形
​
class People(): 
    __country = 'China' # __即隐藏对象
    def __init__(self,name,age):
        self.name1 = name
        self.age = age
        
    def __func(self): # _People__func
        print('func')
        
    #如果外部想调用
    def get_country(self):
        return self.__country 
        # self._People__country
        
    def set_country(self,v):
        if type(v) is not str:
            print("country必须是str类型")
            return
        self.__country = v
        
obj = People('ly', 18)
print(obj.get_country())

2、为什么要隐藏

1：封装数据：将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

2：封装方法：目的是隔离复杂度

取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
隔离了复杂度,同时也提升了安全性

补充：python3中统一了类与类型的概念

l1 = list([1,2,3])
​
l1.append(4)  # list.append(l1,4)

peoperty装饰器

# 将一个函数功能伪装成一个数据属性
例1
class People(): 
    __country = 'China'
    def __init__(self,name,age):
        self.__name = name
        self.age = age
        
    @peoperty  
    def name(self):
        return self.__name
    
    @name.setter # 修改的时候，也必须写上面的名字
    def name(self, v):
        if type(v) is not str:
            print("country必须是str类型")
            return
        self.__name = v
     
    @name.deleter
    def name(self):
        print('不能删除')       
    
obj = People('ly', 18)
obj.name = 'x'
print(obj.name)
​
例2
class People(): 
    __country = 'China'
    def __init__(self,name,age):
        self.__name = name
        self.age = age
         
    def get_name,(self):
        return self.__name
    
    def nset_name(self, v):
        if type(v) is not str:
            print("country必须是str类型")
            return
        self.__name = v
     
    def del_name(self):
        print('不能删除')
        
    # 必须按照这个顺序写（获取，修改，删除）
    xxx = property(get_name,set_name,del_name)
    
obj = People('ly', 18)
print(obj.xxx)
obj.xxx = 'egon'
print(obj.xxx)
del obj.xxx

面向对象的三大特征

封装，继承，多态

继承

1.什么是继承
    继承就是一种新建类的方式
    新建的类称为子类或者叫派生类
    被继承的类称为父类或者叫基类
    子类可以遗传父类的属性
2.为什么用继承
    类解决对象与对象之间的代码冗余问题
    继承解决类与类之间的代码冗余的问题
3.如何使用继承
    python支持多继承
    
    经典类：没有继承object类的子子孙孙类都是经典类
    新式类：继承了object以及该类的子子孙孙类都是新式类
    
    python2中才区分新式类和经典类
    python3都是新式类
    
    
class Pareent1:
    pass
​
class Pareent2:
    pass
​
class Sub1(Pareent1):
    pass
​
class Sub2(Pareent1,Pareent2):
    pass
​
print(Sub1.__base__)
print(Sub2.__bases__)
​
继承的案例
class people()
    schOOl = "SH"
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
​
class Student(people):
    
    #递归
    def __init__(self, name, age, gender, course = None):
        if course is None:
            self.course = []
        #self.__init__()
        People.__init__(self, name, age, gender)
   
    
    def choose_course(self,course):
        self.course.append(course)
        print('%s 选课成功 %s' % (self.name, self.courses))
        
class Teacher(people):
    def __init__(self, level):
        People.__init__(self, name, age, gender)
        self.level = level
    
    def score(self, stu_obj, num):
        stu_obj.num = num
        print('%s老师给%s打了%s分' % (self, name, stu_obj, num))
        
        
stu1 = Student('tom', 19, 'male')
tea1 = Teacher('tom', 19, 'male')
​
子类如何使用父类的属性
方式1：指名道姓的使用父类，跟继承没有关系
方式2：严格以来继承 super()