面向对象之绑定方法和类属性，隐藏属性

绑定方法

'''1.绑定给对象的方法'''


# 定义一个类
class Student():
    school = 'China'

    # 定制对象自己的属性
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    '''绑定给对象来调用的方法'''
    def tell_info(self):
        print('name:%s,age:%s,gender:%s'%(self.name,self.age,self.gender))
    #默认情况下，在类内部写方法都是绑定给对象的，就由对象来调用，就会自动传递参数

stu=Student('kevin',20,'female')

'''对象来调用方法，会把对象自己当成第一个参数传递给方法的第一个形参'''
stu.tell_info()  #stu.tell_info(stu)

#类来调用方法
#问题是：绑定给对象的方法，类能不能来调用，能来调用，只不过是方法中需要几个参数就要传递几个参数，包括self自己的形参
Student.tell_info(stu)

#绑定方法
class Mysql():
    
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port

    #使用该方法是绑定给类的，那么就有类来调用，有什么特殊之处：
    '''
    会把类自动当成第一个参数传给方法的第一个形参cls
    条件:
        1.加一个装饰器 @classmethod
        2.把方法的第一个形参改为cls
        3.外部调用该方法的时候使用类来调用
        4.绑定给类的方法中，就没有self这个参数了
        5.绑定给对象的方法中，就没有cls这个参数了
    '''
    @classmethod
    def from_func(cls):
        return cls('127.0.0.1','3306')


M1=Mysql.from_func()
print(M1.ip)
print(M1.port)

非绑定方法(静态方法static)

class Person():
   #自定义属性
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender
        self.id=self.create_id()
    @staticmethod #加这个参数
    def create_id():
        """当你在函数中不需要对象，也不需要类的时候，就可以把函数设置为静态方法，
            类能调用，对象也能调用，但是不能传递参数
        """
        import uuid
        return uuid.uuid4()

    def func(self):
        '''如果你在方法中即需要对象，也需要类，就把方法绑定给对象'''


stu=Person('lining',20,'male')
print(stu.id)
print(stu.create_id())
print(Person.__name__)
print(Person.create_id()) #类可以直接调用

隐藏属性

1.怎么隐藏
2.为什么要隐藏

#类属性
#对象属性
'''
1.隐藏属性在类的定义阶段发生了变形：__类名__属性名
2.隐藏属性在类的外部能不能取到？理论上是取不到了，但是非要取，也能取到，在类的外部取隐藏之后的属性不是目的
3.类属性，类方法，对象属性都可以被隐藏
4.隐藏属性对外不对内
5.为什么要隐藏？
	就是可以对修改内部的属性的时候，可以在类的内部做更好的限制，然后再类的内部开方一个公共的接口，对外返回内部隐藏的值
'''

class Student():
    __school = 'China'  #隐藏谁就把谁的名字前面加上__

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

    def __func(self):
        print('from func')

    def __get_school(self):
        return self.__school

    def set_school(self, i):
        if type(i) is str:
            Student.__school = i
        else:
            print('err')


stu = Student('kevin', 20)



# print(stu.__school)  # 对外部隐藏，会报错
# print(Student.__dict__) #查看类的名称空间 _Student__school
# print(Student._Student__school)

# stu.func()

stu.set_school('Shanghai')
print(Student._Student__school)

property装饰器

它是一个内置的装饰器，它是把方法伪装成属性来使用
#直接通过函数名调用方法

class Student():
    __school = 'China'  #隐藏谁就把谁的名字前面加上__

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

    def func(self):
        print('from func')
    @property   #以后调用函数的时候不用加括号，但是仍然按照函数的功能去调用
    def school(self):
        return self.__school

    @school.setter  #定义一个修改的方法  都可以不用加括号，直接写方法名
    def school(self, i):
        if type(i) is str:
            Student.__school = i
        else:
            print('err')
    @school.deleter  #定义一个删除的方法
    def school(self):
        del Student.__school

stu = Student('kevin', 20)

stu.school='Tianjin'
print(stu.school)
del stu.school 
print(stu.school)

面向对象的三大特征

封装
	
    封装就是定义类，将属性和操作组织再类中
	组装：将数据和操作组装到一起
    隐藏数据：对外只暴露一些接口，通过接口访问对象，比如驾驶员使用汽车，不需要了解汽车的构造，只需要知道使用什么部件怎么驾驶就行，踩了油门就能跑，可以不了解其中的机动原理
    
继承

	多复用：继承来的就不用自己写了
    多继承少修改，OCP，使用继承来改变，来体现个性
   
多态

	面向对象编程最灵活的地方，动态绑定

 人类就是封装
 人类继承自动物类，孩子继承父母特征，分为单一继承，多继承
 多态，继承自动物类的人类，猫类的操作“吃”不同