绑定方法两种：

1、绑定给对象的

class Student():
  country = ‘CHINA‘
  
  
  def __init__(self,name,age):
    self.name = name
    self.age = age
   
  def tell_info(self):
    print(‘%s-30‘ %(self.name,self.age))
    
    
    
obj = Student(‘jesse‘,12)
obj.tell_info()

# 对象调参数，类里面的函数tell_info本来就有参数，所以不用传，所以是绑定说是给对象的

2、绑定给类的

类方法是绑定给类的，类来调用,把类名当作第一个参数传入

# 建一个settings.py 文件 
# 文件内容：
# IP = ‘192.168.1.101‘
# PORT = 3306

import settings


class Mysql():
    country = ‘CHINA‘

    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    def tell_info(self):
        print(‘IP地址为：%s 端口为：%s‘ % (self.ip, self.port))

    @classmethod
    def from_config(cls):  # 从配置文件导入
        obj = cls(settings.IP, settings.PORT)
        return obj

obj = Mysql.from_config()
Mysql.tell_info(obj)
      # obj = Mysql(settings.IP,setting.PORT)
# 这里的Mysql写死了需要将类名写活
# 就用到了 @classmethod装饰器
# 这个装饰器将：
# Mysql.from_config()  前面的类名传到函数括号里面
obj = Mysql.from_config()
Mysql.tell_info(obj)

注意如果发生既想绑定给对象又想绑定给类的情况我们就直接将它绑定给对象，让后用self.___class_方法 来绑定给类

非绑定方法

即不绑定给对象，也不绑定给类

先小小了解一下uuip模块

import uuid
print(uuid.uuid4())
# 会随机生成一串字符串

class Mysql():
  def __init__(self,ip,port):
    self.ip = ip
    self.port = port
    
  @staticmethod # 静态方法
  def create_id():
    # 这里下面没有需要用到对象的代码
    # 所以这里是可以没有self的
    # 但我们调用的时候用到了对象
    # 我们可以用@staticmethod装饰器装饰一下
    # 后面就可以用对象调用它了
   
    import uuid
    print(uuid.uuid4())
    
    
obj = Mysql(‘127.0.0.1‘,3306)
obj.create_id()
Mysql.creat_id()  # 我们发现用类也可以调用了

# 这就是非绑定方法

参数用不到可以不用传，这就是非绑定方法

隐藏属性

1、如何隐藏属性？

class People():
  __country = ‘CHINA‘  # 在前面加__该属性就被隐藏了
  
  
  def __init__(self,name,age)
  	self.name = name
    self.age = age
    
 obj = People(‘ly‘,18)   
# 被隐藏就取不到了
print(People.__dict__) # 查看类里面的属性
# 会发现隐藏的__country 变成了_People__country
# 语法上在定义阶段进行了变形

# print(People._People__country) 这样就可以取出来了，但这样取就比较麻烦
# 删除和上面同理

该隐藏对外不对内,因为在函数定义阶段发生了变形，那所以包含该属性的代码也同时发生了变形。所以虽然在外部取不到，但是我们可以在写一个调用该属性的方法。

class People():
  __country = ‘CHINA‘  
  
  def __init__(self,name,age)
  	self.name = name
    self.age = age
    
    
  def get_country(self):
    return ‘国家：%s‘% self.__country
    
obj = People(‘ly‘,18)

2、为什么要隐藏

该隐藏对外不对内，如果想访问类中隐藏属性，在类中开放对外访问的接口，可以更好的对外部做限制

class People():
  __country = ‘CHINA‘  
  
  def __init__(self,name,age)
  	self.name = name
    self.age = age
    
    
  def get_country(self):
    return ‘国家：%s‘% self.__countr
  
  
  def set_country(self,v):
  	if not type(v) is str:
      print(‘country必须是str类型‘)
      return
    self.__country = v
  # 对更改作出限制  
  def del_country(self):
    print(‘不能删除‘)
   

peoperty装饰器

装饰器：装饰器实在不修改被张是对象原代码以及调用方式的前提下为被装饰对象添加新功能的可调用对象

‘‘‘
成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖，高于32
  体质指数（BMI）= 体重(kg) ? 身高^2(m)
‘‘‘

class People():
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    def bmi(self):
        return self.weight / self.height ** 2


obj1 = People(‘jesse‘, 65, 1.75)
print(obj1.bmi())
  

property是一个装饰器，是用来绑定给对象的方法伪装成一个数据属性

class People():
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height
		@property
    def bmi(self):
        return self.weight / self.height ** 2


obj1 = People(‘jesse‘, 65, 1.75)
print(obj1.bmi) # 加了property装饰器之后调用就不需要加括号

property的另一个语法,针对隐藏属性的操作，能够让使用者查找不到

class Student():
  __school = ‘十三中‘  # 将学校属性隐藏起来
  def __init__(self,name,age,gender):
    self.name = name
    self.age = age
    self.gender = gender
    
  def get_school(self):
    return self.__school
  
  
  def set_school(self,v)
    if not type(v) is str:
      print(‘学校名称必须为字符串‘)
     	return
    self.name = v
    
  def del_school(self):
    print(‘不可以删除学校名称‘)
    
    
  school = property(get_school,set_school,del_school)
# 将这些功能 加上property语法赋值给一个变量名，就可以通过变量名来进行操作了

obj1 = People(‘jesse‘,‘16‘,‘mael‘)

print(obj1.school)  # 这样就能取出学校名字了相当于之前没加property的 print(obj1.get_school)

obj1.school = ‘十八中‘ # property 会检测语法，察觉到这是更改操作就会执行 obj1.set_school = ‘十八中‘

del obj1.school # 也是同理

还有一种用法，和上面用法一样

class Student():
  __school = ‘十三中‘  # 将学校属性隐藏起来
  def __init__(self,name,age,gender):
    self.name = name
    self.age = age
    self.gender = gender
    
  @property  # 相当于 school = property(school)
  def school(self):
    return self.__school
  
  @school.setter
  def school(self,v)
    if not type(v) is str:
      print(‘学校名称必须为字符串‘)
     	return
    self.name = v
  @school.deleter 
  def school(self):
    print(‘不可以删除学校名称‘)
    
# 加装饰器用法  
1、先将所有功能函数名称定义成要伪装调用的函数名称，比如这里面我们就用school 
2.在get_school功能上加一个property装饰器
  在set_school功能上 @school.setter
  在school.del功能上 @school.deleter

推荐用这种加装饰器的方式，更加清晰

继承

1、什么是继承

继承是一种创建新类的方式，新建的类可称为子类或派生类，父类又可以称之为基类或超类

在Python这门语言中是支持多继承的，即新建的类可以继承一个或多个父类

class Parent1:
  pass


class Parent2:
  pass
  

class Sub1(Parent1): # 单继承
  pass


class Sub2(Parent1,Parent2): # 多继承
  pass

print(Sub1.__bases__)
print(Sub2.__bases__)

在Python2中有经典类与新式类之分

新式类：继承了object类的子类，以及该子类的子类等

经典类：没有继承object类的子类，以及该子类的子类等

在Python3中没有继承任何类，那么就会默认继承object，所以Python中只有新式类

子类中没有的属性会去父类那找，

python的多继承：

优点：子类可以同时遗传多个父类的属性，最大限度的重用代码

缺点：代码可读性扩张性会变差，不建议使用多继承，如果一定要用，应该用使用Mixins

2、为什么要用继承

用来解决类与类之间代码冗余的问题，将共有的东西提取到父类当中

3、如何使用继承

class All_people():
  school = ‘清华大学‘
  def __init__(self,name,age,gender):
    self.name = name
    self.age = age
    self.gender = gender

class Student(All_people):
  def choose_course(self):
    print(‘学生 %s 正在选课‘ %self.name)
    
    
    
    
class Teacher(All_people):
	
  def __init__(self,name,age,gender,courses):
    All_people.__init__(self,name,age,sex)
    self.courses = courses
    
    
stu_obj = Student(‘jesse‘,‘18‘,‘male‘)
print(stu_obj.school)

对象 绑定关系 隐藏属性 property 继承