标签：

1. 面向对象特征—多态

1.1 什么是多态

多种形态，多种类型

def func(arg):
    print(arg)

func(1) #数字
func("alex") #字符
func([11, 22, 33]) #列表

1.2 其他语言对比（C#/Java）

C#/JAVA需要指定形态

def func(int arg):  #需要指定类型
    print(arg)
func(123)  # 正常输出
func("alex")  # 报错，非指定类型
# 其他语言多态实例
class A:
    pass
class B(A):
    pass
class C(A):
    pass
# arg参数：必须是A类型或A的子类类型
def func(A arg):
print(arg)
# obj = B()
# obj = C()
obj = A()
func(obj)

2. 面向对象—类成员

2.1 字段

2.1.1 字段分类

l  静态字段：保存在类里

l  普通字段：保存在对象里

class Foo:
    # 字段(静态字段，保存在类里)
    CC = 123
    def __init__(self):
        # 字段(普通字段，保存在对象里)
        self.name = ‘alex‘

    def show(self):
        print(self.name)

2.1.2 静态字段与普通字段对比实例

# 普通写法
class Province:
    def __init__(self,name):
        self.name = name
        self.country = "中国"

hn = Province(‘河南‘)
hb = Province(‘河北‘)
sd = Province(‘山东‘)
db = Province(‘黑龙江‘)

# 所有省份都存储一个country

# 静态字段
class Province:
    country = "中国"
    def __init__(self,name):
        self.name = name

hn = Province(‘河南‘)
hb = Province(‘河北‘)
sd = Province(‘山东‘)
db = Province(‘黑龙江‘)

# 共用一个country

2.1.3 静态补充

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

hn = Province(‘河南‘)

hb = Province(‘河北‘)
sd = Province(‘山东‘)
db = Province(‘黑龙江‘)
print(hn.name) #普通字段只能用对象访问
print(Province.country) #静态字段用类访问（万不得已的时候可以使用对象访问）

2.1.4 字段小结

一般情况：自己访问自己字段
规则：

l  普通字段只能用对象访问

l  静态字段用类访问（万不得已的时候可以使用对象访问）

PS：静态字段在代码加载时候，已经创建

2.2方法

2.2.1 方法分类

l  普通方法，由对象去调用执行（方法属于类）

l  静态方法，由类调用执行（当方法内部不需要对象中封装的值时，可以将方法写成静态方法）

class Province:
    country = "中国"
    def __init__(self,name):
        self.name = name
    # 普通方法，由对象去调用执行（方法属于类）
    def show(self):
        print(self.name)
    # 静态方法，由类调用执行（当方法内部不需要对象中封装的值时，可以将方法写成静态方法）
    @staticmethod
    def f1():
        print("...")
    def f2(arg1, arg2):
        print(arg1, arg2)
Province.f1()
Province.f2(111, 222)

2.2.2 创建静态方法

class Foo:
    @staticmethod      # 静态方法标识
    def f1():    # 没有self
        pass

    def f2(arg1, arg2):   # 可以传递参数
        pass

2.2.3 类方法

类方法，至少有一个cls，静态方法的一种，自动传递类名

class Province:
@classmethod
def f3(cls): # cls:class
# cls类名，cls()
pass
print(cls)
Province.f3()#不需要传参，自动传递类名

2.2.4 方法小结

所有的方法属于类

1.普通方法：至少有一个self，对象执行

2.静态方法：任意参数，类执行（对象执行，不到万不得已不要用）

3.类方法：至少有一个cls，类执行（对象执行，不到万不得已不要用）

1.3 属性

属性本身就是方法

1.3.1 属性怀方法对比实例

分页

1.3.2 属性高级实现分页实例

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", value)
    @all_pager.deleter #删除
    def all_pager(self):          print("del_all_pager")

p = Pager(101)
print("p.all_pager", p.all_pager)
p.all_pager = 111
del p.all_pager

1.3.3 属性的对应关系图

1.3.4 属性存在的第二种形式

class Pager:
    def __init__(self, all_count):
        self.all_count = all_count
    def f1(self):
        pass
    def f2(self,value):
        pass
    def f3(self):
        pass
    foo = property(fget=f1, fset=f2, fdel=f3)

p = Pager(101)

result = p.foo
print(result)

p.foo = "alex"

del p.foo

对应关系图

1.3.5 属性小结

1、      不伦不类的东西

2、      具有方法的写作形式，具有字段访问形式

第2章 成员修饰符

2.1 成员修饰符分类

私有：只能类自己本身成员内部可以访问

公有：内外部都可以访问

2.2 修饰符—字段

2.2.1 公有普通字段

class Foo:
    def __init__(self, name):
        self.name = name
    def f1(self):
        print(self.name)

obj = Foo(‘alex‘)
print(obj.name)  # 外部访问
obj.f1()  #内部访问

2.2.2 私有普通字段

class Foo:
    def __init__(self, name):
        self.__name = name  #字段前加__，#定义一个私有的静态字段
    def f1(self):
        print(self.__name)

obj = Foo(‘alex‘)
# print(obj.name)  # 外部访问，输出结果报错
obj.f1()  #内部访问

2.2.3 私有普通字段继承

class Foo:
    def __init__(self, name):
        self.__name = name  #定义一个私有的静态字段
    def f1(self):
        print(self.__name)

class Bar(Foo):
    def f2(self):
        print(self.__name)

obj = Bar("alex")
obj.f1()
# obj.f2()  #化输出结果报错，不可继承

2.2.4 私有静态字段

class Foo:
    __cc = "123"
    def __init__(self, name):
        self.__name = name  #定义一个私有的静态字段
    @staticmethod
    def f3():
        print(Foo.__cc)
obj = Foo(‘ddddd‘)
obj.f3()
Foo.f3()
print(Foo.__cc)  #报错，不可访问

2.3 修饰符—方法

class Province:
    def __init__(self,name):
        self.name = name

    def f1(self):
        print("f1，公有方法")

    @staticmethod
    def __f2():
        print("f2，私有方法")

    def f3(self):
        Province.__f2()  # 内部调用f2方法
       
Province.f1(123)
# Province.f2() # 输出结果报错，AttributeError: type object ‘Province‘ has no attribute ‘f2‘
Province.f3(456)

2.4 外部强制访问私有成员

class Foo:
    def __init__(self, name):
        self.__name = name  
    def f1(self):
        print(self.__name)
obj = Foo("alex")
# print(obj.__name)   #AttributeError: ‘Foo‘ object has no attribute ‘__name‘

print(obj._Foo__name)  #强制访问私有成员

2.5 修饰符小结：

1. 私有的只有自己可以访问，其他谁都不可以

2. 不到万不得已不要在外部强制访问私有成员  __类名__xxxxx

# 1.主程序index.py

from settings import ClassName
from backend import commons

def execute():
    # 字符串”Foo“
    cls = getattr(commons, ClassName)
    obj = cls()  # 创建对象
    obj.f1()   #执行f1方法

if __name__ == ‘__main__‘:
    execute()


# 2.配置文件 settings

Path = "backend.commons"
ClassName = "Foo"

 
# 3.程序代码
class Foo:
    def f1(self):
        print(‘Foo.f1‘)

 

 

 








# 程序执行输出结果

Foo.f1

# 1.主程序index.py

from settings import ClassName
from settings import Path

def execute():
    # 字符串”Foo“
    model = __import__(Path, fromlist=True)
    cls = getattr(model, ClassName)
    obj = cls()  # 创建对象
    obj.f1()   #执行f1方法

if __name__ == ‘__main__‘:
    execute()


# 2.配置文件 settings

Path = "lib"
ClassName = "MyFoo"


# 3.程序代码
class Foo:
    def f1(self):
        print(‘Foo.f1‘)


# 4.新建类文件

from backend.commons import Foo
class MyFoo(Foo):  #
    def f1(self):
        print(‘before‘)
        super(MyFoo, self).f1()  #f1父类的方法
        print(‘after‘)


# 程序执行输出结果

before

Foo.f1

after

面向对象（二）

标签：

原文地址：http://www.cnblogs.com/liangdalong/p/5619004.html