运维小白的python之路（六）——面向对象

概述

面向过程：根据业务逻辑，从上到下写代码，一步一步的执行适用于简单的脚本编写。
函数式：将代码封装进函数中，程序通过函数的调用来完成，适用于较复杂的脚本编写。
面向对象：对函数进行类和封装，适合大型的程序开发。

面向过程编程最易被初学者接收，一般用一段代码或者时一个函数来完成程序的某一个功能。有些代码通过复制粘贴即可完成。
例如：

while True：
    if 分数 >= 90 :
        显示姓名
        显示年级
        显示成绩“A”
    if 80 <= 分数 < 90 :
        显示姓名
        显示年级
        显示成绩“B”
    if 70 <= 分数 < 80 :
        显示姓名
        显示年级
        显示成绩“C”
    if 60 <= 分数 < 70 :
        显示姓名
        显示年级
        显示成绩“D”
    if 分数 < 60 :
        显示姓名
        显示年级
        显示成绩“E”

随着对编程的了解加多，开始使用函数式编程

def func1():
    ...

def func2():
    ...

if __name__ == "__main__":
    func1()
    func2()

面向对象编程，是把函数封装进类中，把程序理解成有多个对象组成，每个对象都有不同的属性
注：Java和C#来说只支持面向对象编程，而python比较灵活即支持面向对象编程也支持函数式编程

创建对象和类

面向对象是一种编程方式，此编程方式的落地需要使用“类”和“对象”来实现，所以面向对象实际就是对“类”和“对象”的使用。
类就是一个模板。模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可执行类中的函数

#创建类
class Test:    #class是关键字，表示要创建的类，Test是类的名称
    #创建类中的方法
    def func(self): #self是特殊参数，它表示在创建实例的时候，是实例本身
        pass
    def hello(self, name)
        print("my name is %s" % name)
#根据类创建对象，创建对象再类名称的后面加上括号即可
obj = Test()
obj.func() #执行func方法
obj.hello("xiaowang") #执行hello方法

注：函数式编程与面向对象编程的区别
面向对象：创建对象，通过对象执行方法
函数式编程：执行函数

面向对象的三大特征

面向对象的三大特征是指：封装、继承和多态

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封状再某处的内容。
所以，再使用面向对象的封装的特性时，需要注意一下几点：
1.将内容封装到某处
2.从某处调用被封装的内容

将内容封装到某处

#创建类
class Test:
    def __init__(self, name, aeg):
        self.name = name
        self.age = age

#根据类Test创建对象
#自动执行Test类的init方法
obj1 = Test('xiaowang', 88)  #将xiaowang和18分别封装到obj1(self)的name和age属性中

#根据类Test创建对象
#自动执行Test类的init方法
obj2 = Test('xiaoming', 77) #将xiaoming和77分别封装到obj2(self)中的name和age属性中

self是一个形式参数，当之行obj1 = Test(‘xiaowang’, 88)时，self等于obj1；当之行obj2 = Test(‘xiaoming’, 77)时，self等于obj2
所以，内容是被封装到了obj1和哦obj2中，每个对象都有name和age属性，在内存里被分别保存。

从某处调用被封装的内容

调用被封装的内容时，有两种情况：
1.通过对象直接调用
2.通过self间接调用

通过对象直接调用被封装的内容

根据保存格式，可以如此调用被封状的内容：对象.属性名

#!/usr/bin/env python3
class Test:
    def __init__(self, name, age):
        self.name = name
        self.age = age
obj1 = Test('xiaowang', 18)
print(obj1.name) #直接调用obj1对象的name属性
print(obj1.age) #直接调用obj1对象的age属性

obj2 = Test('xiaoming', 17)
print(obj2.name)
print(obj2.age)

通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

#!/usr/bin/env python3

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

    def detail(self):
        print(self.name)
        print(self.age)

obj1 = Test('xiaowang', 18)
obj1.detail() # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此>时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

obj2 = Test('xiaoming', 22)
obj2.detail()

练习

练习一：在终端输出如下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健

函数式
#!/usr/bin/env python3
#函数式
def kaichai(name, age, sex):
    print('%s, %s岁,%s,上山去砍柴' % (name, age, sex))

def dongbei(name, age, sex):
    print('%s, %s岁,%s,开车:去东北' % (name, age, sex))

def baojian(name, age, sex):
    print('%s, %s岁,%s,开车去东北' % (name, age, sex))

def run():
    name1 = "小明"
    name2 = "老李"
    age1 = 10
    age2 = 90
    sex = "nan"
    kaichai(name1, age1, sex)
    dongbei(name1, age1, sex)
    baojian(name1, age1, sex)
    kaichai(name2, age2, sex)
    dongbei(name2, age2, sex)
    baojian(name2, age2, sex)
if __name__ == "__main__":
    run()
~         

面向对象
#!/usr/bin/env python3
#面向对象
class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.action = ('上山去砍柴','开车去东北','最爱大保健')

    def kanchai(self):
        print("%s,%s岁,%s,%s" % (self.name, self.age, self.sex, self.action[0]))

    def dongbei(self):
        print("%s,%s岁,%s,%s" % (self.name, self.age, self.sex, self.action[1]))

    def baojian(self):
        print("%s,%s岁,%s,%s" % (self.name, self.age, self.sex, self.action[2]))

xiaoming = Person('xiaoming', 12, 'nan')
xiaoming.kanchai()
xiaoming.dongbei()
xiaoming.baojian()

laowang = Person('laowang', 88, 'nan')
laowang.kanchai()
laowang.dongbei()
laowang.baojian()

上述对比可以看出，如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了… ；
而对于面向对象只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。

练习二：游戏人生程序
1、创建三个游戏人物，分别是：

苍井井，女，18，初始战斗力1000
东尼木木，男，20，初始战斗力1800
波多多，女，19，初始战斗力2500

2、游戏场景，分别：

草丛战斗，消耗200战斗力
自我修炼，增长100战斗力
多人游戏，消耗500战斗力

#!/usr/bin/env python3
class Person:
    def __init__(self, name, sex, age, hp):
        self.name = name
        self.sex = sex
        self.age = age
        self.hp = hp
    def caocong(self):
        print("正在草丛中。。。")
        self.hp = self.hp - 200
    def ziwo(self):
        print("正在自我修炼中")
        self.hp = self.hp + 100
    def duoren(self):
        print("多人中。。。")
        self.hp = self.hp - 500
    def xueliang(self):
        print(self.hp)

a = Person("xiaoming", "man", 18, 1000)
b = Person("xiaowang", "woman", 16, 1800)
c = Person("xiaolan", "man", 18, 1300)

a.caocong()
a.duoren()
a.xueliang()

二、继承

继承，面向对象中的继承和显示生活中的继承相同，子可以继承父的内容
所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
注：除了子类和父类的称谓，还有类似“派生类”，“基类”的叫法。

class 父类:
    def 父类中的方法(self):
        pass

class 子类(父类):  # 子类继承父类，即拥有了父类的所有方法
    pass父类中的方法
a = 子类()  #创建子类
a.父类中的方法() #执行葱父类中继承的方法

继承的例子

#!/usr/bin/env python3
#继承

class Animal:
    def eat(self):
        print("%s 吃" % self.name)

    def drink(self):
        print("%s 喝" % self.name)

    def shit(self):
        print("%s 啦" % self.name)

    def pee(self):
        print("%s 撒" % self.name)

class Cat(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = "猫"
    def cry(self):
        print("喵喵")

class Dog(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = "狗"
    def cry(self):
        print("汪汪")

c1 = Cat("xiaowang")
c1.pee()
c1.shit()

d1 = Dog("xiaoli")
d1.pee()
d1.eat()

多继承

在python中可以继承多个类，在java中和c#中只能继承一个类
python中的类如果继承了多个类，那么找寻方法的方式有两种，分别是：深度优先和广度优先
当类是经典类时，多继承情况下，会按照深度优先的方式查找
当类时新式类时，多继承情况下，会按照广度优先的方式查找
经典类和新式类的区别：继承了object类的类是新式类，否则就是经典类

经典类的多继承（深度优先、仅限2.7,3.0以上版本全部都是广度优先）

#!/usr/bin/env pthon3
class D:
    def bar(self):
        print('D bar')

class C(D):
    def bar(self):
        print("C bar")

class B(D):
    def bar(self):
        print("B bar")

class A(B, C):
    def bar(self):
        print("A bar")

a = A()
a.bar()
'''
在执行bar方法时
先在A类中查找，如果A 类中没有，就在B中查，B没有，在D中查，D没有，在C查，还没有，报错
顺序时A --> B --> D --> C
在这个过程中，一旦找到bar就停止查找
即先进行深度查找，再进行平行的查找，顺序从左网右
'''

新式类的多继承（广度优先）：

#!/usr/bin/env pthon3
class D:
    def bar(self):
        print('D bar')

class C(D):
    def bar(self):
        print("C bar")

class B(D):
    def bar(self):
        print("B bar")

class A(B, C):
    def bar(self):
        print("A bar")

a = A()
a.bar()
'''
在执行bar方法时
先在A类中查找，如果A 类中没有，就在B中查，B没有，在C中查，C没有，在D查，还没有，报错
顺序时A --> B --> C --> D
在这个过程中，一旦找到bar就停止查找
即先进行平行查找，再进行深度的查找，顺序从左网右
'''

三、多态

python不支持Java和C#这一类强类型语言中多台的写法，但是原生多态，其Python崇尚“鸭子类型”
多态是父类可以调用子类的功能
由于python中变量的类型时不固定的，所以python不需要多态

Java或时C#在实现多态的时候时这样的（pyton伪代码）

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'


# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj): #在这里，实现父类可以调用子类的方法，体现出多态
    """Func函数需要接收一个F1类型或者F1子类的类型"""

    print obj.show()

s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

pytho代码实现多态的功能

#!/use/bin/env python3
# 实现多态的功能

class F1:
    pass

class S1(F1):
    def show(self):
        print('S1 show')

class S2(F1):
    def show(self):
        print('S2 show')

def Func(obj):
    print(obj.show())

s1_obj = S1()
Func(s1_obj)

s2_obj = S2()
Func(s2_obj)

基础归纳

面向对象是一种编程方式，此编程方式是基于类和对象的使用
类是一个模板，模板中包装了多个方法
对象是根据模板创建的实例（即：对象），实例用于调用背包装在类中的函数
面向对象的三大特性：封装、继承和多态

类的成员

类的成员可以分为三大类：字段、方法和数属性
类成员：
字段：
普通字段
静态字段
方法：
普通方法
类方法
静态方法
属性：
普通属性
注：所有成员中，只有普通字段的内容保存在字段中，即：根据此类创建了多少对象，在内存中就有多少普通字段,而其他成员都是保存在类中，即无论有多少对象，再内存中只保留一份。

字段

字段包括：普通字段和静态字段，他们都在定义和使用中有所区别，最本质的区别时在内存中保存的位置不同
普通字段属于对象
静态字段属于类
字段的定义和使用

#!/usr/bin/env python3
class Province:
    country = '中国' #静态字段

    def __init__(self, name):
        self.name = name #普通字段

a = Province('北京')
print(a.name) #直接访问普通字段

print(Province.country) #直接访问静态字段
用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段

方法

方法包括：普通方法、静态方法和类方法，三种方法都是属于类的，区别在于调用的方式不同。
普通方法：由普通对象调用，至少一个self参数;执行普通方法时，自动将调用该方法的对象赋值给self;
类方法：通过装饰器@classmethod实现，由类调用;该方法可以通过类调用，也可以通过对象调用，不能通过对象调用。不能访问实例中的对象。
静态方法：通过装饰器@staticmethod实现，由类调用，无默认参数（这个方法与类无关，不能访问类中的变量）;

普通方法

太普通了，正常使用就可以，略

静态方法

完全当作一个跟类不相关的函数写就可以

类方法

类方法通过@classmethod装饰器实现，类方法和普通方法的区别是， 类方法只能访问类变量，不能访问实例变量

#!/usr/bin/env python3
class Dog(object):
    def __init__(self,name):
        self.name = name

    @classmethod
    def eat(self):
        print("%s is eating" % self.name)

d = Dog("XiaoWang")
d.eat()


dy@dy:~/python_test/Day07/Class$ python3 class_test10.py
Traceback (most recent call last):
  File "class_test10.py", line 11, in <module>
    d.eat()
  File "class_test10.py", line 8, in eat
    print("%s is eating" % self.nameo)
AttributeError: type object 'Dog' has no attribute 'name'
#报错说没有name属性，说明类方法不能访问实例中的变量

定义一个类变量来实验一下

#!/usr/bin/env python3
class Dog(object):
    name = "Form_Class"
    def __init__(self,name):
        self.name = name

    @classmethod
    def eat(self):
        print("%s is eating" % self.name)

d = Dog("XiaoWang")
d.eat()

dy@dy:~/python_test/Day07/Class$ python3 class_test10.py
Form_Class is eating

属性

属性其实就是普通方法的变种
对于属性，有一下三点知识：
属性的基本使用
属性的两种定义方式

属性的基本使用

#!/usr/bin/env python3
#属性的基本使用
class Foo:
    def func(self):
        print("This is Func")

    @property
    def prop(self):
        print("Tis is Prop")

obj = Foo()
obj.func() #方法的调用
obj.prop #属性的调用

class Goods:
    @property
    def price(self):
        return "xiaowang"
obj = Goods()
a = obj.price
print(a)
~      

类的属性的定义和调用需要注意以下几点：
定义时，在普通方法的基础上添加@property装饰器
定义时，属性仅有一个self参数
调用时，没有括号
方法：obj.func()
属性：obj.prop
注：
属性存在的意义是：访问属性时可以制造出和访问字段完全相同的假象
属性有方法变种而来，如果python中没有属性，方法网全可以代替其功能

实例：
对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：
根据用户请求的当前页和总数据条数计算出 m 和 n
根据m 和 n 去数据库中请求数据

#!/usr/bin/env python3
#属性的使用

class Paper:
    def __init__(self, current_pape):
        #用户当前请求的页码(第一页第二页)
        self.current_pape = current_pape
        #每页默认显示10条数据
        self.per_items = 10

    @property
    def start(self):
        val = (self.current_pape - 1) * self.per_items
        return val

    @property

    def end(self):
        val = self.current_pape * self.per_items
        return val
p = Paper(1)
p.start #起始值
p.end #结束值
#属性的功能就是：属性进行一系列的逻辑计算，最终将结果返回

属性定义的两种方式

属性的定义有两种方式：
装饰器：在方法上应用装饰器
静态字段：在类中定义值为property对象的静态字段

装饰器方式：在普通方法上应用@property装饰器

经典类有一种@property装饰器

#!/usr/bin/env python3
#经典类属性装饰器
class Goods:
    @property
    def price(self):
        return "xiaowang"

obj = Goods()
a = obj.price

新式类有三种@property装饰器

#!/usr/bin/env python3
#新式类的属性装饰器
class New_Goods(object):
    @property
    def price(self):
        print("@property")

    @price.setter
    def price(self, value):
        print("@price.setter")
        print(value)

    @price.deleter
    def price(self): #在程序退出的时候，会执行这个方法，想在程序结束的时候做的事
情可以写在这里，也可手动触发，触发之后在程序结束时依旧会执行
        print("price.deleter")

new_obj = New_Goods()

new_obj.price #自动执行 @property 装饰的price方法，并获取方法的返回值
new_obj.price = 123 #自动执行 @price.setter 装饰的price方法，并将123赋值给方法的
参数
del new_obj.price #自动执行 @price.deleter装饰额price方法

注：
    经典类中的属性只有一种访问方式，其对应被@property修饰的方法
    新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter

由于新式类具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

#!/usr/bin/env python3
class Goods(object):
    def __init__(self):
        self.priginal_price = 100 #原价
        self.discount = 0.8 #折扣

    @property
    def price(self):
        new_price = self.original_price * self.discount #现价 = 原价 * 折扣
        return new_price

    @price.setter
    def price(self, value):
        self.priginal_price = value

    @price.deleter
    def price(self):
        del self.original_price

obj = Goods()
obj.ptice #获取商品的价格
obj.price = 200 #修改商品的原价
del obj.price #删除商品原价

静态字段方式

创建值为ptoperty对象的静态字段

经典类和新式类用静态字段创建属性的方法一样
#!/usr/bin/env python3
class Foo:
    def get_bar(self):
        return "xiaowang"

    BAR = property(get_bar)

obj = Foo()
a = obj.BAR #自动调用get_bar方法，并获取方法的返回值
print(a)

property的构造方法中有四个参数
第一个参数是方法名，调用 对象.属性 自动触发执行方法
第二个参数是方法名，调用 对象.属性 = XXX时，自动触发执行
第三个参数时方法名，调用 del 对象.属性 时自动触发执行方法
第四个参数时字符串，调用 对象.属性.doc，此参数时该属性的表述信息

#!/usr/bin/env python3
class Foo:
    def get_bar(self):
        return "xiaowang"

    #必须两个参数
    def set_bar(self, value):
        return "set value" + value

    def del_bar(self):
        print("del xiaowang")

    BAR = property(get_bar, set_bar, del_bar, "This is doc")

obj = Foo()

a = obj.BAR
print(a)
b = obj.BAR = "1111"
print(b)
del obj.BAR
obj.BAR.__doc__

由静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对统一属性：获取、修改、删除

#!/usr/bin/env python3
class Goods(object):
    def __init__(self):
        self.original_price = 100 #原价
        self.discount = 0.8 #折扣

    def get_price(self):
        new_price = self.original_price * self.discount
        return new_price

    def set_priec(self, value):
        self.original_price = value

    def del_price(self):
        del self.original_price
        print("del self.original_price")

    PRICE = property(get_price, set_priec, del_price, "This is doc")

obj = Goods()
a = obj.PRICE
print(a)
obj.PRICE = 1000
a = obj.PRICE
print(a)
del obj.PRICE

所以，定义属性共有两种方式，分别是“装饰器”和“静态字段”，而“装饰器”针对经典类和新式类又有所不同。

类成员的修饰符

类中的成员有两种形式存在：
共有成员，再任何地方都能访问
私有成员，只有在类的内部才能访问

私有成员和共有成员的定义不同：
私有成员命名时，前两个字符时下划线。（特殊成员例外，例如init call dict等）

class A:
    def __init__(self):
        self.name = "公有字段"
        self.__foo = "私有字段"

私有成员和公有成员的访问限制不同：
静态字段：
公有静态字段：类可以访问;类内部可以访问;派生类中可以访问
私有静态字段：仅类内部可以访问;

#公有静态字段
#!/usr/bin/env python3
class A:
    name = "公有静态字段"

    def func(self):
        print(A.name)

class B(A):
    def show(self):
        print(A.name)

print(A.name) #类访问

obj = A()
obj.func() #类内部可以访问

obj_son = B()
obj_son.show() #在派生类中可以访问

#私有静态字段
#!/usr/bin/env python3
class A:
    __name = "私有静态字段"

    def func(self):
        print(A.__name)

class B(A):
    def show(self):
        print(A.__name)

print(A.__name)   #类访问 ---> 报错

a = A()
a.func() #类的内部可以访问 ---> 正确

a = B()
a.show() #派生类中的访问 ---> 报错

普通字段
公有普通字段：对象可以访问;类内部可以访问;派生类中可以访问
私有普通字段：仅类内部对象可以访问
注：如果想要强制访问私有字段，可以通过 “对象.类名_私有字段名” 访问（如：obj._C__foo）,不建议强制访问私有成员

#共有字段
#!/usr/bin/env python3
class A:
    def __init__(self):
        self.name = "公有字段"

    def func(self):
        print(self.name) #在类的内部访问

class B(A):
    def show(self):
        print(self.foo) #在派生类中访问

obj = A()
obj.name    #通过对象访问
obj.func()  #在类的内部访问

a = B()
a.show   #在派生类中访问

#私有字段
#!/usr/bin/env python3
class A:
    def __init__(self):
        self.__name = "私有字段"
    def func(self):
        print(self.__name) #类内部访问

class B(A):
    def show(self):
        print(self.__name) #派生类中访问

a = A()
print(a.__name) #通过对象访问 ----> 报错
a.func() #通过类的内访问 ----> 正确

b = B()
b.show() #通过派生类访问 ----> 报错

方法，属性的访问于上述方式相似，即：私有成员只能在类的内部访问
注：非要访问私有属性的话，可以通过 对象.类_属性名

类的特殊成员

*__doc__

表示类的描述信息

#!/usr/bin/env python3
class Foo:
    """ 这里是描述信息 """
    def func(self):
        pass

print(Foo.__doc__)

*__module__和*__class__

module表示当前操作对象在哪个模块
class 表示当前操作对象的类是什么

class_test23.py
#!/usr/bin/env python3

class A:
    def __init__(self):
        self.name = "xiaowang"


class_test24.py
#!/usr/bin/env python3
from class_test23 import A
a = A()
print(a.__module__)
print(a.__class__)

dy@dy:~/python_test/Day07/Class$ python3 class_test24.py 
class_test23
<class 'class_test23.A'>

*__init__

构造方法，通过类创建对象时，自动触发执行

#!/usr/bin/env python3
class A:
    def __init__(self):
        self.name = "xiaowang"

a = A() #自动执行__init__方法

*__del__

当对象在内存中被释放时，自动出发执行
注：此方法一般无需定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给python的解释器来执行，所以del函数都是由解释器进行垃圾回收时候自动触发的。

class Foo:
    def __del__(self):
        pass

*__call__

在对象后面加括号的时候，自动出发执行
注：构造方法（init）的执行是由创建对象出发的，即：对象 = 类名()；而对于call方法的执行是由对象后加括号触发的，即：对象()或者类()()

class Foo:
    def __init__(self):
        pass

    def __call__(self):
        print("__call__")

obj = Foo() #执行__init__
obj() #执行__call__

*__dict__

类或对象中所有的成员

#!/usr/bin/env python3
class Province
    country = "China"
    def __init__(self, name, count)
        self.name = name
        self.count = count
    def func(self, *args, **kwargs):
        print("func")

#获取类的成员
print(Province.__dict__)
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province("xiaowang", 10)
print(obj1.__dict__)
#获取对象obj1的成员
#输出输出：{'count': 10, 'name': 'xiaowang'}

*__str__

如果一个类总定义了str方法，那么在打印对象是，默认输出该方法的返回值

class Foo:
    def __str__(self):
        return "xiaowang"

obj = Foo()
print(obj) #输出“xiaowang”
##__getitem__、__setitem__、__delitem__##

用于索引操作，如字典。以上分别表示获取、设置、删除数据

#!/usr/bin/env python3
class Province
    country = "China"
    def __init__(self, name, count)
        self.name = name
        self.count = count
    def func(self, *args, **kwargs):
        print("func")

#获取类的成员
print(Province.__dict__)
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province("xiaowang", 10)
print(obj1.__dict__)
#获取对象obj1的成员
#输出输出：{'count': 10, 'name': 'xiaowang'}

*__getslice__、*__setslice__、*__delslice__

该三个方法用于分片操作，如：列表

#!/usr/bin/env python3

class Foo(object):
    def __getslice__(self, i, j):
        print('__getslice__',i,j)

    def __setslice__(self, i, j, sequence):
        print('__setslice__',i ,j)

    def __delslice__(self, i, j):
        print('__delslice__',i ,j)

obj = Foo()
obj[-1:1] #自动触发执行__getslice__
obj[0:1] = [11,22,33,44] #自动触发__setslice__
del obj[0:2] #自动触发__delslice__

*__iter__

用于迭代器，之所以列表、字典、元组可以进行for循环,都是因为内部定义了iter

class Foo(object):
    pass

obj = Foo()

    for i in obj:
        print(i)
#报错：TypeError: 'Foo' object is not iterable

class Foo(object):
    def __iter__(self):
        pass

obj = Foo()

for i in obj:
    print(i)

# 报错：TypeError: iter() returned non-iterator of type 'NoneType'

class Foo(object):
    def __init__(self, sq):
        self.sq = sq

    def __iter__(self):
        return iter(self.sq)

obj  = Foo([11,22,33,44])
for i in obj:
    print(i)
#没有报错   

以上步骤可以看出，for循环迭代的其实是iter([11,22,33,44]),所一执行流程可以变更为：

obj = iter([11,22,33,44])

for i in obj:
    print(i)

for循环内部语法

obj = iter([11,22,33,44])

while True:
    val = obj.next()
    print(val)

*__new__和*__metaclass__

阅读一下代码：

class Foo(object):
    def __init__(self):
        pass

obj = Foo() #obj是通过Foo类实例化的对象

在上述代码中，obj是通过Foo实例化的对象，其实，不仅是obj是一个对象，Foo类本身也是一个对象，因为在Python中一切事物皆对象。
如果按照一切事物皆对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某一个类的构造方法创建。

print(type(obj)) #输出：<class '__main__.Foo'>     表示，obj 对象由Foo类创建
print(typr(Foo)) #输出：<type 'type'>              表示，Foo类对象由 type 类创建

所以，obj对象是Foo类的一个实例，Foo类对象是type类的一个实例，即：Foo类对象是通过type类的构造方法创建。
创建类可以有一下两种方式

1.普通方式
class Foo(object):
    def func(self):
        print("xiaowang")

2.特殊方式（type类的构造函数）
def func(self):
    print("hello xiaowang")

Foo = type('Foo', (object,), {"func":func})
#type第一个参数：类名
#type第二个参数：当前的基类
#type第三个参数：类的成员

所以类是由type类实例化产生

反射

通过字符串映射或修改程序运行是的状态、属性、方法，有一下四个方法

getattr(object, name, default=None) 获取类的成员
hasattr(object, name) 检查是否有此成员
setattr(x, y, v) 设置成员
delattr(x, y) 删除成员

#!/usr/bin/env python3

import sys
class Webserver:
    def __init__(self, host, ip):
        self.host = host
        self.ip = ip

    def start(self):
        print("start....")

    def stop(self):
        print("stop....")

    def restart(self):
        self.stop()
        self.start()

def run_test(a,name):
    print("This in run")
    print("host",a.host)
    print("name",name)

#a = Webserver("www.aa.com", "11.1.1.1")
#a.restart()
if __name__ == "__main__":
    server = Webserver("www.aa.com", "11.1.1.1")
    if hasattr(server,sys.argv[1]): #检查对象中是否有用户输入的属性
        func = getattr(server,sys.argv[1]) #获取对象中的方法
        func()
    setattr(server, "run", run_test) #将run_test方法添加进实例server中，名字为run
    server.run(server, "xiaowang")

    delattr(server,'host') #删除server实例中的host字段
    print(server.host)

    delattr(Webserver, "stop") #删除Webserver类中的stop方法