Python-开发之路-面向对象-进阶

今天来更详细的讲一讲面向对象的其他一些内容

类成员：

字段

- 普通字段 ：也称为动态字段，保存在对象中，只有对应的对象可以调用。
- 静态字段 ：保存在类中，类和对象都可以调用，静态字段在类代码加载时，随类一起创建。

方法

- 普通方法 ：只有创建了对象后才可以调用，
                    自动将调用该方法的对象赋值给self。
- 静态方法 ：相对于普通方法，静态方法在定义时
                    没有“self”参数,
                    上一行加上了‘@staticmethod’装饰器,
                    相当于放在类中的函数，可以由类来调用，。
- 类方法 ：必须含有“cls”参数，是‘class’的缩写，该参数是自动传递的，自动将调用该方法的类复制给cls，使用类方法时需要在上一行加上‘@classmethod’装饰器

属性

- 属性 ：让方法以字段的形势被类调用

两种字段创建方式：

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
class Province:
    #静态字段，保存在类中，所有对象都可以访问.类和对象都可以访问静态字段
    country = 'China'

    def __init__(self,name):
        #普通字段（动态字段），保存在对象中.
        self.name = name

三种方法的创建

class Province:
    #普通方法：只在使用对象时才会被调用
    def f2(self):
        print(self.name)
    #静态方法：在方法前加@staticmethod ,方法的括号中没有self，由类调用，就相当于一个函数，只是存放位置不同
    @staticmethod
    def f1(arg1,args2):
        print(arg1,args2)
    #类方法：参数至少有一个cls，是class的缩写，这个cls的参数自动传递，就跟普通的self一样。由类调用
    @classmethod
    def f3(cls):
        #cls是类名，加上（）可以创建对象
        cls()
        print(123)

属性 有两种创建方式：

一、装饰器方式创建

class Province:
    #属性，让方法以字段的形势调用
    @property
    def f4(self,all_count):
        a1,a2 = divmod(all_count,10)
        if a2 == 0:
            return a1
        else:
            return a1+1
    #属性的删除装饰器
    @f4.deleter
    def f4(self):
        pass
    #属性的设置装饰器
    @f4.setter
    def f4(self):
        pass

p = Province(101)
ret = p.f4
p.f4 = 111
del p.f4

二、静态字段方式

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7

class Pager:

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

    def f1(self):
        return 123

    def f2(self):
        pass

    def f3(self):
        pass

    foo = property(fget=f1,fset=f2,fdel=f3)

p = Pager(101)
result = p.foo
print(result)
p.foo = 'meta'

成员修饰符

    私有：
        只能类自己本身成员内部可以访问，定义时需要在前面加‘__’两个下划线（如：‘__name’）

    公有：
        在任何地方都可以访问

相对类成员就分别衍生出了：

        私有字段、公有字段
        私有方法、公有方法

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7

class Foo:

    #公有静态字段,都可以调用
    aa = '321'

    #私有静态字段,只能通过对象来进行内部调用，不能使用类来进行外部调用
    __cc = '321'
    #构造方法
    def __init__(self,name):
        #公有普通字段
        self.name = name
        #私有普通字段
        __self.age = 18

    #私有方法
    def __f1(self):
        print(self.name)
    #公有方法
    def f4(self):
        self.__f1()

    @staticmethod
    def f2():
        print(Foo.__cc)
        print(self.__name)

#类的继承
class Bar(Foo):

    def f3(self):
        print(Foo.__cc)

print(Foo.__cc,Foo.__name)
obj = Foo('1231')
#借用对象实现对私有字段的内部调用
obj.f1()
obj.f4()
#强制调用私有字段，在类名前加_
print(obj._Foo__cc)
Foo.f2
#
pjt = Bar('alex')
pjt.f3()

特殊成员

__doc__ ：获取注释信息
__init__ ：通过类创建对象时，自动触发执行
__call__ ：对象后面加括号，触发执行
__dict__ ：类或对象中的所有成员
__str__ ：如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值

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

__getslice__、__setslice__、__delslice__ ： 该三个方法用于分片操作

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

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7

class Foo:

    #构造方法：该类创建的对象，全局封装参数，相当于初始化类内部的全局变量
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #析构方法：在内存清理垃圾数据时，有则调用此方法删除垃圾数据，没有则python自行销毁
    def __del__(self):
        pass

    def __dict__(self):
        print('dict')

    def __call__(self, *args, **kwargs):
        print('call')

    def __str__(self):
        return "%s-%s" % (self.name,self.age)

    def __getitem__(self, item):
        print('getitem',type(item))
        return 123

    def __setitem__(self, key, value):
        print('setitem',type(key),type(value))

    def __delitem__(self, key):
        print('del item',type(key))

obj = Foo('mate',520)
#在对象后面加（），会执行__call__方法
obj()
Foo()()
print(obj)
ret = str(obj)
print(ret)

#获取对象中封装的字段，类自带
_dict__
ret = obj.__dict__
print(ret,Foo.__dict__)
reg = obj['meta']
print(reg)
obj['k1'] = 111
ret = obj.__dict__
print(ret)el obj['k1']
ret2 = obj[1:4:2]
obj[1:4] = [11,22,33,44,55]
del obj[1:4]