面向对象的类成员（特殊方法）

isinstance（对象，类名）   #判断该对象是否是该类及其父类的实例

issubclass（类名，类名）   #判断前类是否是后类的子类

面向对象的类成员：1、方法　　2、属性　　3、字段

字段：

　　普通保存在对象中

　　静态保存在类中

class Foo:
    cc = 123                  #静态字段
    def __init__(self):
        self.name = "Guido"  #字段，（普通字段）
    def show(self):
        print(self.name)

class province:
    country = "中国"            #静态字段在内存中只保存一份就行，在代码加载时已经创建。
    def __init__(self, name):
        self.name = name
#一般情况自己访问自己的字段，普通字段只可以通过对象访问。
hn = province("河南")
hb = province("河北")
print(hn.name)                  #用对象访问
print(province.country)         #用类访问
print(hn.country)               #通过对象也可以访问静态字段（不到万不得已不要用）

class province:
    country = "中国"
    def __init__(self, name):
        self.name = name


    def f2(self, name):
        print("cls")
        print(name)
ret = province("Guido")
ret.f2(ret.name)                #（对象.传入的参数变量）才能使用__init__里的参数。


#执行结果：
cls
Guido

　　

静态方法：

class province:
    country = "中国"
    def __init__(self, name):
        self.name = name
# 普通方法由对象去调用执行（方法属于类）
    def show(self):
        print(123)
        print(self.name)
ret = province("Guido")
ret.show()


class province:
    country = "中国"
    def __init__(self, name):
        self.name = name
#静态方法
    @staticmethod
    def  f1(arg1, arg2, arg3):      #可以无参数
        print(arg1, arg2, arg3)     #静态方法，由类调用执行，相当于属于该类的函数
ret = province("Guido")
province.f1(11, province.country, ret.name)




class province: 
　　country = "中国" 
　　def __init__(self, name): 
　　　　self.name = name 
　　#类方法（属于静态方法） 
　　@classmethod 
　　def f2(cls):                              #class至少有一个参数cls
　　　　print(cls)                            #cls是类名，cls（）创建对象 

province.f2()                                #不用传实际参数，cls自动传入类名

　　

属性：

　　不伦不类的东西，具有方法的写作形式，且具有字段的访问形式。

class pager:
    def __init__(self, all_count):
        self.all_count = all_count
    def all_pager(self):
        a1, a2 = divmod(self.all_count, 10)   #分页
        if a2 == 0:
            return a1
        else:
            return a1+1
p = pager(101)
print(p.all_count)          #执行字段
result = p.all_pager()      #执行方法
print(result)


class pager:
    def __init__(self, all_count):
        self.all_count = all_count
    @property
    def all_pager(self):
        a1, a2 = divmod(self.all_count, 10)   #分页
        if a2 == 0:
            return a1
        else:
            return a1+1
p = pager(101)
ret = p.all_pager       #利用属性执行@property在下面的方法
print(ret)




class pager:
    def __init__(self, all_count):
        self.all_count = all_count
    @property
    def all_pager(self):
        a1, a2 = divmod(self.all_count, 10)   #分页
        if a2 == 0:
            return a1
        else:
            return a1+1
    @all_pager.setter
    def all_pager(self, value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print("del all_pager")
p = pager(101)
print(p.all_count)
p.all_count = 102
del p.all_count

p.all_pager = 111       #利用属性执行@all_pager.setter下面的方法
del p.all_pager         #利用属性执行@all_pager.deleter下面的方法

 以上@的方式只是提供一种上下的对应关系。

属性的另一种方式：

class pager:
    def __init__(self, all_count):
        self.all_count = all_count
    def f1(self):
        return 123
    def f2(self, value):
        print(value)
    def f3(self):
        print("jjjj")
    foo = property(fget = f1, fset = f2, fdel = f3)
p = pager(101)
result = p.foo         #对应执行f1
print(result)
p.foo = "Guido"       #对应执行f2
del p.foo             #对应执行f3

 特殊的类成员：

class Foo:
    #构造方法（但对象建立成功就会立刻执行此方法）
    def __init__(self, name, age):
        self.name = name
        self.age = age
    #析构方法（在垃圾回收机制执行前执行）（在python程序结束前会自动调用__del__方法）
    def __del__(self):
        pass
    def __call__(self):
        print("call")
    #用print打印对象就会自动执行__str__方法
    def __str__(self):   
        return "%s - %d" %(self.name, self.age)
    
obj = Foo()
obj()          #对象（）   执行call
Foo()


obj1 = Foo("Guido",22)
obj2 = Foo("alex",23)
print(obj1)
print(obj2)


ret = str(obj1)        #无__str__方法，该操作不对内部进行字符串的转换
print(ret)             #用print打印对象就会自动执行__str__方法

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __add__(self, other):
        temp = "%s - %d" %(self.name, other.age)          #__init__里封装的参数
        return temp
    
obj1 = Foo("alex", 34)
obj2 = Foo("eric",23)

ret = obj1+obj2     #obj1+obj2 return temp, temp = ret
print(ret)

#获取对象中封装的数据
ret = obj1.__dict__
print(ret)
print(Foo.__dict__)


    def __getitem__(self, item):
        print(item)
        return 123
    def __setitem__(self, key,value):
        print("setitem")
    def __delitem__(self, key):
        print("delitem")
obj = Foo("alex", 32)
#语法对应关系
ret = obj["ad"]      #执行__getitem__
print(ret)
obj["K1"] = 11       #执行__setitem__
del obj["K1"]        #执行__delitem__
ret1 = obj[1:4]      #执行__getitem__

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __getitem__(self, item):
        print(type(item),item)
        print(item.start, item.stop, item.step)
        return 123
    def __setitem__(self, key, value):
        print(key.start, key.stop, key.step)
        print(type(key),type(value))
    def __delitem__(self, key):
        print(key.start, key.stop, key.step)
        print(type(key))
obj = Foo("alex", 22)
ret = obj[1:4:2]                        #执行__getitem__
obj[1:4] = [11,22,33,44,55]     #执行__setitem__
del obj[1:4]                              #执行__delitem__


#执行结果：
(<type 'slice'>, slice(1, 4, 2))
(1, 4, 2)
(1, 4, None)
(<type 'slice'>, <type 'list'>)
(1, 4, None)
<type 'slice'>

class Foo:
    pass
obj = Foo()
for item in obj:        #报错（对象默认是不可迭代的）
    print(item)

class Foo:
    def __iter__(self): #就是一个生成器
        yield 1         #还可以return iter([11,22,33,44])
        yield 2
obj = Foo()
for item in obj:
    print(item)


#执行结果：
1
2