python学习之面向对象学习

所向无敌

封装实例:　　
class People:
　　
    __country = 'China'
　　

　　
def __init__(self,name,age,sex):
　　
    self.__name = name
　　
#self._People__name = name
　　
   self.__age = age
　　
    self.__sex = sex
　　

　　
def tell_info(self):
　　
    print('人的名字是：%s， 人的年龄是: %s, 人的性别是: %s' %(self.__name, self.__age, self.__sex))
　　
p = People('alex', 29, 'male')
　　
print(p.__dict__)
　　
p.tell_info()
　　

　　
注: 封装只在定义时检查语法
　　
p.__x = 1
　　
print(p.__x)    #打印1
　　

　　
修改属性接口
　　
class People:
　　
    def __init__(self,name,age):
　　
        self.__name = name
　　
        self.__age = age
　　

　　
    def tell_info(self):
　　
        print('人的名字是: %s, 人的年龄是: %s' %(self.__name, self.__age))
　　

　　
    def set_info(self,x, y):
　　
        if not isinstance(x, str):
　　
            raise TypeError('名字必须是字符串')
　　
        if not isinstance(y, int):
　　
            raise TypeError('年龄必须是整数')
　　

　　
        self.__name = x
　　
        self.__age = y
　　

　　
p = People('alex', 20)
　　
p.tell_info()
　　
p.set_info('hyh', 18)
　　
p.tell_info()
　　

　　
四、特性
　　
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)
　　

　　
p1=People('egon',75,1.85)
　　
print(p1.bmi)
　　

　　
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是
　　
执行了一个函数然后计算出来的，这种特性的使用方式遵循统一访问原则
　　

　　
五、绑定方法与非绑定方法
　　
类中定义的函数分成两大类：
　　

　　
　　一：绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：
　　

　　
　　　　1. 绑定到类的方法：用classmethod装饰器装饰的方法。
　　

　　
                为类量身定制
　　

　　
                类.boud_method(),自动将类当作第一个参数传入
　　

　　
              （其实对象也可调用，但仍将类当作第一个参数传入）
　　

　　
　　　　2. 绑定到对象的方法：没有被任何装饰器装饰的方法。
　　

　　
               为对象量身定制
　　

　　
               对象.boud_method(),自动将对象当作第一个参数传入
　　

　　
             （属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）
　　

　　
　　二：非绑定方法：用staticmethod装饰器装饰的方法
　　

　　
　　   1. 不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已
　　

　　
　　　　注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，
　　
        对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说。
　　

　　
       例子:
　　
       import hashlib
　　
       import time
　　
       class MySQL:
　　
           def __init__(self,host,port):
　　
                self.id=self.create_id()
　　
                self.host=host
　　
                self.port=port
　　
           @staticmethod
　　
           def create_id(): #就是一个普通工具
　　
                m=hashlib.md5(str(time.clock()).encode('utf-8'))
　　
                return m.hexdigest()
　　
       print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
　　
       conn=MySQL('127.0.0.1',3306)
　　
       print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数
　　

　　
       classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个
　　
       参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法
　　

　　
       例子:
　　
       settings.py文件内容
　　
       HOST='127.0.0.1'
　　
       PORT=3306
　　

　　
       import settings
　　
       import hashlib
　　
       import time
　　
       class MySQL:
　　
           def __init__(self,host,port):
　　
               self.host=host
　　
               self.port=port
　　

　　
           @classmethod
　　
           def from_conf(cls):
　　
               print(cls)
　　
               return cls(settings.HOST,settings.PORT)
　　
       print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
　　
       conn=MySQL.from_conf()print(conn.host,conn.port)
　　
       conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类