面向对象: class
函数编程
def email(): print('发送邮件')def msg(): print('发送短信')def weichat(): print('发送微信')if 1==1: email() msg() weichat() 面向对象编程
class Message: def email(self): print('发送邮件') def msg(self): print('发送短信') def weichat(self): print('发送微信')if 1 == 1: obj = Message() obj.weichat() obj.msg() obj.email() 函数:定义简单/调用简单
面向对象:缺点定义复杂/调用复杂 优点 归类 将某些类似的函数写在一起
总结:
函数的编程可能会比面向对象好
python中支持两种编程方式
面向对象的三大特征
封装 继承 多态
封装:
数据封装和方法封装
相关功能封装到一个类中
将数据封装到一个对象
继承
提高代码的重用性
先在自己类(派生类)中，没有时去父类(基类)中找
python支持多继承
多继承 先找左边
self到底是谁，self是哪个类的对象，那么就从该类开始找
super主动调用其他类的成员
类名.方法名（自己穿self） 与继承无关
super（）
多态
多种形态或多种状态
鸭子模型，只要可以嘎嘎叫的就是鸭子
由于python原生态支持多态，所以没有特殊性。但是在Java中必须为要求的形态或形态子类
面向对象的成员
分三类 变量（字段） 方法 属性
变量
实例变量
静态变量
class Province: # 静态字段 country ＝ '中国' def __init__(self, name): # 普通字段 self.name = name# 直接访问普通字段obj = Province('河北省')print obj.name# 直接访问静态字段Province.country字段的定义和使用 准则：
实例变量（字段）访问时，使用对象访问。即：obj.name
类变量（静态字段）访问时，使用方法访问，即Foo.country（是在不方便时，才用对象）
方法： 实例方法 静态方法 类方法
实例方法： def func（self）：
静态方法：@staticmethod
如果方法无需使用对象中封装的值，那么就可以使用静态方法
类方法：@classmethod
如果会使用当前类那么就使用类方法
class Foo: def __init__(self, name): self.name = name def ord_func(self): """ 定义普通方法，至少有一个self参数 """ # print self.name print '普通方法' @classmethod def class_func(cls): """ 定义类方法，至少有一个cls参数 """ print '类方法' @staticmethod def static_func(): """ 定义静态方法 ，无默认参数""" print '静态方法'# 调用普通方法f = Foo()f.ord_func()# 调用类方法Foo.class_func()# 调用静态方法Foo.static_func()方法的定义和使用
属性：通过方法改造出来
编写：方法上方写@property 方法参数：只有一个self
调用：无需加括号 对象.方法
应用场景：对于简单的方法，当无需传参且有返回值时可以使用@property
# ############### 定义 ###############class Foo: def func(self): pass # 定义属性 @property def prop(self): pass# ############### 调用 ###############foo_obj = Foo()foo_obj.func()foo_obj.prop #调用属性属性的定义和使用
修饰符
私有
成员的修饰符为两个下划线
继承中 私有变量在父类(基类)中，子类无法了解获取
公有
默认公有
嵌套（组合）
数据的各种嵌套
特殊方法
class Foo(object): def __init__(self,a1,a2): self.a1 = a1 self.a2 = a2 def __call__(self, *args, **kwargs): print(11111,args,kwargs) return 123 def __getitem__(self, item): print(item) return 8 def __setitem__(self, key, value): print(key,value,111111111) def __delitem__(self, key): print(key) def __add__(self, other): return self.a1 + other.a2 def __enter__(self): print('1111') return 999 def __exit__(self, exc_type, exc_val, exc_tb): print('22222')# 1. 类名() 自动执行 __init__# obj = Foo(1,2)# 2. 对象() 自动执行 __call__# ret = obj(6,4,2,k1=456)# 3. 对象['xx'] 自动执行 __getitem__# ret = obj['yu']# print(ret)# 4. 对象['xx'] = 11 自动执行 __setitem__# obj['k1'] = 123# 5. del 对象[xx] 自动执行 __delitem__# del obj['uuu']# 6. 对象+对象 自动执行 __add__# obj1 = Foo(1,2)# obj2 = Foo(88,99)# ret = obj2 + obj1# print(ret)# 7. with 对象 自动执行 __enter__ / __exit__# obj = Foo(1,2)# with obj as f:# print(f)# print('内部代码')# 8. 真正的构造方法# class Foo(object):# def __init__(self, a1, a2): # 初始化方法# """# 为空对象进行数据初始化# :param a1:# :param a2:# """# self.a1 = a1# self.a2 = a2## def __new__(cls, *args, **kwargs): # 构造方法# """# 创建一个空对象# :param args:# :param kwargs:# :return:# """# return object.__new__(cls) # Python内部创建一个当前类的对象(初创时内部是空的.).## obj1 = Foo(1,2)# print(obj1)## obj2 = Foo(11,12)# print(obj2) 内置函数
issubclass（）
检查第一个参数是第二个参数的子类
class Base(object): passclass Foo(Base): passclass Bar(Foo): passprint(issubclass(Bar,Base)) # 检查第一个参数是否是第二个参数的 子子孙孙类
type
获取当前对象是有哪个类创建
获取对象类
""" 获取当前对象是由那个类创建。""""""class Foo(object): passobj = Foo()print(obj,type(obj)) # 获取当前对象是由那个类创建。if type(obj) == Foo: print('obj是Foo类型')"""# #### 练习题"""class Foo(object): passclass Bar(object): passdef func(*args): foo_counter =0 bar_counter =0 for item in args: if type(item) == Foo: foo_counter += 1 elif type(item) == Bar: bar_counter += 1 return foo_counter,bar_counter# result = func(Foo(),Bar(),Foo())# print(result)v1,v2 = func(Foo(),Bar(),Foo())print(v1,v2)""" isinstance
判断第一个参数（实例）是否是第二个参数（类及父类）的实例
class Base(object): passclass Foo(Base): passobj1 = Foo()print(isinstance(obj1,Foo)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。obj2 = Base()print(isinstance(obj2,Foo)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。print(isinstance(obj2,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。# #################### 练习"""给你一个参数，判断对象是不是由某一个指定类？ type --> type(obj) == Foo给你一个参数，判断对象是不是由某一个指定类或其父类？ isinstance --> instance(obj,Foo)"""