python自动化开发-[第七天]-面向对象

今日概要：

　　1、继承

　　2、封装

　　3、多态与多态性

　　4、反射

　　5、绑定方法和非绑定方法

一、新式类和经典类的区别　　

大前提：
1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
3.所有类甭管是否显式声明父类，都有一个默认继承object父类
在python2中的区分
经典类：
class 类名:
    pass

经典类：
class 类名(父类):
    pass

在python3中，上述两种定义方式全都是新式类

二、类的两种作用:属性引用和实例化

例子：

class gailun:
    country = 'demaxiya'
    def __init__(self,name,attack_id=50,flood=100):
        self.name = name
        self.attack_id = attack_id
        self.flood = flood

    def attack(self,persen):

        self.flood -= persen.attack_id

　　1、属性引用（类名.属性）

class gailun:  #定义一个英雄gailun类,不通玩家可以用他实例出自己的英雄
    country = 'demaxiya' #定义一个类变量
    def __init__(self,name,attack_id=50,flood=100):  #定义一个初始化函数
        self.name = name
        self.attack_id = attack_id
        self.flood = flood

    def attack(self,persen):  #定义一个函数属性

        self.flood -= persen.attack_id

g = gailun('dragon')  #创建了一个对象
print (g.country) #引用类的数据属性,该属性所有对象和实例共享
gailun.country #引用类的属性,该属性所有对象和实例共享
g.name = 'banana' #增加属性
del g.name #删除属性

　　2、实例化__init__,self

　　　　类名加括号就执行类的__init__函数的运行，可以用__init__来定义每一个实例的特征

g = gailun('德玛西亚')#就是在执行gailun.__init__(g,'德玛西亚')，然后执行__init__内的代码g.name=‘德玛西亚’等

　　

一，类的属性有两种属性可以查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值
二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类
类名.__bases__# 类所有父类构成的元组
类名.__dict__# 类的字典属性,名称空间
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

　　3、对象/实例只有一种作用:属性作用

三、类的名称空间与对象/实例的名称空间

　　创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

　　类有两种属性:数据属性和函数属性

　　类的数据属性是共享给所有对象的

>>> id(r1.camp) #本质就是在引用类的camp属性，二者id一样
4315241024
>>> id(Riven.camp)
4315241024

　　类的函数属性是绑定给所有对象的

>>> id(r1.attack)
>>> id(Riven.attack)

'''
r1.attack就是在执行Riven.attack的功能，python的class机制会将Riven的函数属性attack绑定给r1，r1相当于拿到了一个指针，指向Riven类的attack功能

除此之外r1.attack()会将r1传给attack的第一个参数
'''

　　创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

　　在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

练习：每次对象实例化一次,就计数一次，最后打印出总次数

class count(object):
    num = 0   #定义类变量
    def __init__(self,name):
        self.name = name
        count.num +=1

g = count('alex')
g1 = count('egon')

print (count.num)

四、类的继承

　　1、继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

class ParentClass1:  #定义父类
    pass 

class ParentClass2: #定义子类
    pass

class SubClass1(ParentClass1): #继承ParentClass1类，派生出SubClass1子类
    pass

class SubClass2(ParentClass1, ParentClass2): #继承ParentClass1类,ParentClass2，派生出SubClass1子类
    pass

　　2、查看当前类的继承 类名.__bases__查看当前类所有的继承,   ****__base__只查看从左到右继承的第一个子类

#查看当前类的继承顺序
print(SubClass1.__bases__)
print(SubClass2.__bases__)

'''

输出:
(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>) 

'''

　　3、继承的好处：减少冗余代码

　　 4、派生的定义:在子类定义新的属性，覆盖掉父类的属性，称为派生

例子：

class Animal:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('eating')

    def talk(self):
        print('%s 正在叫' %self.name)

class People(Animal):
    def __init__(self, name, age, sex,education):
        Animal.__init__(self,name,age,sex)
        self.education=education

    def talk(self):
        Animal.talk(self)
        print('%s say hello' %self.name)

class Pig(Animal):
    pass

class Dog(Animal):
    pass

peo1=People('xiaoming',18,'male','小学肄业') #People.__init__

pig1=Pig('xiaohong',20,'female')

dog1=Dog('xiaogang',30,'male')

print(peo1.education)

peo1.talk()
pig1.talk()
dog1.talk()

'''
输出：
小学肄业
xiaohong 正在叫
xiaohong say hello
xiaoming 正在叫
xiaogang 正在叫
'''

　　5、继承查找顺序：

class Parent:
    def foo(self):
        print('Parent.foo')
        self.bar() #s.bar()

    def bar(self):
        print('Parent.bar')

class Sub(Parent):
    def bar(self):
        print('Sub.bar')

s=Sub()  #实例化
s.foo() #s.foo 查看当前类里没有foo，就去继承的父类里去查找，父类里有foo，同时调用self.bar，
　　　　　　　　　由于传入的self为sub实例化的对象，所以子类和父类同时存在相同的函数属性，优先查找子类的

'''
输出
Parent.foo
Sub.bar
'''

class Parent:
    def foo(self):
        print('Parent.foo')
        self.bar() #s.bar()

    def bar(self):
        print('Parent.bar')

class Sub(Parent):
    pass

s=Sub()
s.foo() #s.foo

'''
输出：
Parent.foo
Parent.bar
'''

　　6、子类继承，修改父类属性

class Animal:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('eating')

    def talk(self):
        print('%s 正在叫' % self.name)

class People(Animal):
    def __init__(self, name, age, sex, education):
        Animal.__init__(self, name, age, sex)   #继承父类的__init__功能
        self.education = education

    def talk(self):
        Animal.talk(self)
        print('%s say hello' % self.name)

class Pig(Animal):
    pass

class Dog(Animal):
    pass

peo1 = People('alex', 18, 'male', '小学肄业')  # People.__init__
pig1 = Pig('wupeiqi', 20, 'female')
dog1 = Dog('yuanhao', 30, 'male')

print(isinstance(peo1,People))
print(isinstance(pig1,Pig))
print(isinstance(dog1,Dog))

print(isinstance(peo1,Animal))
print(isinstance(pig1,Animal))
print(isinstance(dog1,Animal))

'''
输出：
True
True
True
True
True
True
'''

　　7、继承反映的是一种什么是什么的关系,组合也可以解决代码冗余问题，但是组合反映是一种什么有什么的关系

组合例子：

　　当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

class Teacher(People):
    def __init__(self,name,age,sex,salary):
        People.__init__(self,name,age,sex)
        self.salary=salary

class Student(People):
    pass

class Date:
    def __init__(self, year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day

    def tell(self):
        print('%s-%s-%s' % (self.year, self.mon, self.day))

class Teacher(People):
    def __init__(self, name, age, sex, salary, year, mon, day):
        self.name = name
        self.age = age
        self.sex = sex
        self.salary = salary
        self.birth = Date(year, mon, day)

class Student(People):
    def __init__(self, name, age, sex, year, mon, day):
        self.name = name
        self.age = age
        self.sex = sex
        self.birth = Date(year, mon, day)

t=Teacher('egon',18,'male',3000,1995,12,31)
t.birth.tell()  #组合的形成
'''
输出
1995-12-31
'''

五、接口的定义　　

  定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。

　　java中接口的定义　　

=================第一部分：Java 语言中的接口很好的展现了接口的含义: IAnimal.java
/*
* Java的Interface很好的体现了我们前面分析的接口的特征:
* 1)是一组功能的集合,而不是一个功能
* 2)接口的功能用于交互,所有的功能都是public,即别的对象可操作
* 3)接口只定义函数,但不涉及函数实现
* 4)这些功能是相关的,都是动物相关的功能,但光合作用就不适宜放到IAnimal里面了 */

package com.oo.demo;
public interface IAnimal {
    public void eat();
    public void run();
    public void sleep();
    public void speak();
}

=================第二部分：Pig.java：猪”的类设计,实现了IAnnimal接口
package com.oo.demo;
public class Pig implements IAnimal{ //如下每个函数都需要详细实现
    public void eat(){
        System.out.println("Pig like to eat grass");
    }

    public void run(){
        System.out.println("Pig run: front legs, back legs");
    }

    public void sleep(){
        System.out.println("Pig sleep 16 hours every day");
    }

    public void speak(){
        System.out.println("Pig can not speak"); }
}

=================第三部分：Person2.java
/*
*实现了IAnimal的“人”,有几点说明一下:
* 1)同样都实现了IAnimal的接口,但“人”和“猪”的实现不一样,为了避免太多代码导致影响阅读,这里的代码简化成一行,但输出的内容不一样,实际项目中同一接口的同一功能点,不同的类实现完全不一样
* 2)这里同样是“人”这个类,但和前面介绍类时给的类“Person”完全不一样,这是因为同样的逻辑概念,在不同的应用场景下,具备的属性和功能是完全不一样的 */

package com.oo.demo;
public class Person2 implements IAnimal {
    public void eat(){
        System.out.println("Person like to eat meat");
    }

    public void run(){
        System.out.println("Person run: left leg, right leg");
    }

    public void sleep(){
        System.out.println("Person sleep 8 hours every dat");
    }

    public void speak(){
        System.out.println("Hellow world, I am a person");
    }
}

=================第四部分：Tester03.java
package com.oo.demo;

public class Tester03 {
    public static void main(String[] args) {
        System.out.println("===This is a person===");
        IAnimal person = new Person2();
        person.eat();
        person.run();
        person.sleep();
        person.speak();

        System.out.println("\n===This is a pig===");
        IAnimal pig = new Pig();
        pig.eat();
        pig.run();
        pig.sleep();
        pig.speak();
    }
}

java中的interface

继承的两种用途：

　　一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）

　　二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能

class File:
    def read(self): #定接口函数read
        raise TypeError('类型错误') #raise主动抛出异常

    def write(self): #定义接口函数write
        raise TypeError('类型错误')

class Txt(File): #文本，具体实现read和write
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(File): #磁盘，具体实现read和write
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(File):
    # def read(self):
    #     print('进程数据的读取方法')
    #
    # def write(self):
    #     print('进程数据的读取方法')
    def xie(self):
        pass

    def du(self):
        pass
p=Process()
p.read()

t=Txt()
p=Process()
d=Sata()

print(isinstance(t,File))
print(isinstance(p,File))
print(isinstance(d,File))

t.read()
p.read()
d.read() 

　　2、为什么要用接口

　　接口提取了一群类共同的函数，可以把接口当做一个函数的集合。然后让子类去实现接口中的函数。

　　这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。

　　归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

　　比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。

　　再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样

五、抽象类

　　1 什么是抽象类

　　与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

　　2 为什么要有抽象类

　　如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

　 　　比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

　　从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

　 　　从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的

例子：　

import abc
class File(metaclass=abc.ABCMeta):#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
    @abc.abstractmethod
    def read(self): #定接口函数read
        pass

    @abc.abstractmethod
    def write(self): #定义接口函数write
        pass

class Process(File):
    def read(self):  #将read名字修改，或者缺少这两个参数，就会报错
        # print('进程数据的读取方法')
        pass
    def write(self):
        print('进程数据的读取方法')

    # def xie(self):
    #     pass
    #
    # def du(self):
    #     pass
p=Process()
p.read()

六、类的继承顺序

　　新式类:广度优先

　　经典类:深度优先

　　通过mro(),可以查看类的继承顺序

继承顺序：

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

继承顺序

***子类继承父类的方法super()　

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('开动啦...')

class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
        super().__init__(name,speed,load,power)
        self.line=line

    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        super(Subway,self).run()

class Mobike(Vehicle):#摩拜单车
    pass

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

***不用super()出现的问题

#每个类中都继承了且重写了父类的方法
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        A.__init__(self)

class C(A):
    def __init__(self):
        print('C的构造方法')
        A.__init__(self)

class D(B,C):
    def __init__(self):
        print('D的构造方法')
        B.__init__(self)
        C.__init__(self)

    pass
f1=D()

print(D.__mro__) #python2中没有这个属性

　　当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次（注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表）

解决例子：

#每个类中都继承了且重写了父类的方法
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        super(B,self).__init__()

class C(A):
    def __init__(self):
        print('C的构造方法')
        super(C,self).__init__()

class D(B,C):
    def __init__(self):
        print('D的构造方法')
        super(D,self).__init__()

f1=D()

print(D.__mro__) #python2中没有这个属性

七、多态和多态性

　　1、多态是同一种事物的不同形态

　　2、多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同功能的函数

　　　　在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

　　3、多态性的优点：

　　　　1.增加了程序的灵活性

　　　　以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)

　　　　2.增加了程序额可扩展性

　　　　通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用 　　

　　

#!/usr/bin/python
# -*- coding:utf-8 -*-

#多态是同一种事物的多种形态
class Animal:
    def talk(self):
        print('正在叫')

class People(Animal):
    def talk(self):
        print('say hello')

class Pig(Animal):
    def talk(self):
        print('哼哼哼')

class Dog(Animal):
    def talk(self):
        print('汪汪汪')

class Cat(Animal):
    def talk(self):
        print('喵喵喵')

peo1=People()
pig1=Pig()
dog1=Dog()
cat1=Cat()

#多态性

# peo1.talk()
# dog1.talk()
# pig1.talk()

def func(x):
    x.talk()

func(peo1)
func(pig1)
func(dog1)
func(cat1) 

八、封装

　　1、封装的定义：

　　　　1：封装数据的主要原因是：保护隐私

　　　　2：封装方法的主要原因是：隔离复杂度（快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了）

　　2、类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问

　　3、在python中用双下划线的方式实现隐藏属性（设置成私有的）

　　类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：　　

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

例子：

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, #p._People__name
            self.__age,
            self.__sex))

p=People('alex',18,'male')
print(p.__dict__)
p.tell_info()

print(p.__name)

p.__salary=3000  #__私有属性或者变量只在定义时候修改
print(p.__dict__)

print(People.__dict__)

People.__n=11111111111111111111111111
print(People.__dict__)
print(People.__n)

例子：

class Parent:
    def foo(self):
        print('from parent.foo')
        self.__bar() #self._Parent__bar()

    def __bar(self): #_Parent__bar
        print('from parent.bar')

class Sub(Parent):
    # def __bar(self): #_Sub__bar
    #     print('from SUb.bar')
    pass
s=Sub()
s.foo()

s._Parent__bar()

九、特性

　　property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

例子：

　　1、求圆面积和圆的周长，人的体脂

#!/usr/bin/python
# -*- coding:utf-8 -*-

import math
class round(object):

    def __init__(self,leght):
        self.leght = leght

    @property
    def zhouchang(self):
        return math.pi * self.leght

    @property
    def mianji(self):
        return math.pi * ((self.leght/2) ** 2)

g = round(10)
print(g.zhouchang)

print (g.mianji)

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)

a = People('alex',70,1.70)
print (a.bmi)

　　2、python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

class People:
    def __init__(self,name,permmission=False):
        self.__name=name
        self.permmission=permmission
    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,value):
        if not isinstance(value,str): #在设定之前进行类型检查
            raise TypeError('名字必须是字符串类型')
        self.__name=value

    @name.deleter
    def name(self):
        if not self.permmission:
            raise PermissionError('不允许的操作')
        del self.__name

p=People('egon')

# print(p.name)
#
# p.name='egon666'
# print(p.name)
#
# p.name=35357
p.permmission=True
del p.name

十、绑定方法和非绑定方法

类中定义的函数分成两大类：

 

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

 

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

 

                为类量身定制

 

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

 

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

 

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

 

               为对象量身定制

 

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

 

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

 

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

 

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

 

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

 

简单例子：

class Foo:
    def test1(self):
        pass
    @classmethod   #只能类进行调用
    def test2(cls):
        print(cls)
    @staticmethod #类和对象都可以调用
    def test3():
        pass

f=Foo()
print(f.test1)
print(Foo.test2)
print(Foo.test3)
print(f.test3)

　　1、staticmethod

　　　　statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果，python为我们内置了函数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> #查看结果为普通函数

　　2、classmethod

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

settings.py

　　

HOST='127.0.0.1'
PORT=3306

示例:　　

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
        print('conneting...')
    @classmethod
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT) #MySQL('127.0.0.1',3306)
    def select(self): #绑定到对象的方法
        print(self)
        print('select function')

# conn=MySQL('192.168.1.3',3306)
# conn.select()

# conn1=MySQL('192.168.1.3',3306)
conn2=MySQL.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

　　3、classmethod和staticmethod区别　

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
    @staticmethod
    def from_conf():
        return MySQL(settings.HOST,settings.PORT)

    # @classmethod
    # def from_conf(cls):
    #     return cls(settings.HOST,settings.PORT)

    def __str__(self):
        return '就不告诉你'

class Mariadb(MySQL):
    def __str__(self):
        return '主机:%s 端口:%s' %(self.host,self.port)

m=Mariadb.from_conf()
print(m) #我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行，打印就不告诉你：

时间练习：

class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now(): #用Date.now()的形式去产生实例,该实例用的是当前时间
        t=time.localtime() #获取结构化的时间格式
        return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
    @staticmethod
    def tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间
        t=time.localtime(time.time()+86400)
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

a=Date('1987',11,27) #自己定义时间
b=Date.now() #采用当前时间
c=Date.tomorrow() #采用明天的时间

print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day)

#分割线==============================
import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,但是结果为
'''
输出结果:
<__main__.Date object at 0x1013f9d68>
'''
因为e就是用Date类产生的,所以根本不会触发EuroDate.__str__,解决方法就是用classmethod

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    # @staticmethod
    # def now():
    #     t=time.localtime()
    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)

    @classmethod #改成类方法
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿
'''
输出结果:
year:2017 month:3 day:3
'''　　

练习：

　　定义MySQL类

　　　　1.对象有id、host、port三个属性

　　　　2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一

　　　　3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化

　　　　4.为对象定制方法，save和get，save能自动将对象序列化到文件中，文件名为id号，文件路径为配置文件中DB_PATH;get方法用来从文件中反序列化出对象

class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now(): #用Date.now()的形式去产生实例,该实例用的是当前时间
        t=time.localtime() #获取结构化的时间格式
        return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
    @staticmethod
    def tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间
        t=time.localtime(time.time()+86400)
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

a=Date('1987',11,27) #自己定义时间
b=Date.now() #采用当前时间
c=Date.tomorrow() #采用明天的时间

print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day)

#分割线==============================
import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,但是结果为
'''
输出结果:
<__main__.Date object at 0x1013f9d68>
'''
因为e就是用Date类产生的,所以根本不会触发EuroDate.__str__,解决方法就是用classmethod

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    # @staticmethod
    # def now():
    #     t=time.localtime()
    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)

    @classmethod #改成类方法
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿
'''
输出结果:
year:2017 month:3 day:3
'''

十一、反射

　　1、python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

　　hasatter 判断object中有没有一个变量字符串对应的方法或属性

　　getatter 获取成员

　　setatter 设置成员

　　delatter 检查成员

例子1:

class Foo(object):

    def __init__(self):
        self.name = 'abc'

    def func(self):
        return 'ok'

obj = Foo()
#获取成员
ret = getattr(obj, 'func')#获取的是个对象
r = ret()
print(r)
#检查成员
ret = hasattr(obj,'func')#因为有func方法所以返回True
print(ret)
#设置成员
print(obj.name) #设置之前为:abc
ret = setattr(obj,'name',19)
print(obj.name) #设置之后为:19
#删除成员
print(obj.name) #abc
delattr(obj,'name')
print(obj.name) #报错

例子2：ftp的client

　　　

好处一：实现可插拔机制

　　　　有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

　　　　总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

#!/usr/bin/python
# -*- coding:utf-8 -*-

class FtpClient:
    'ftp客户端,但是还么有实现具体的功能'
    def __init__(self,addr):
        print('正在连接服务器[%s]' %addr)
        self.addr=addr

    def get(self):
        print('is getting')

使用ftp的client

import ftpclient
f1=ftpclient.FtpClient('192.168.1.1')

if hasattr(f1,'get'):
    func=getattr(f1,'get')
    func()

print('其他的代码1')
print('其他的代码2')
print('其他的代码3')