面向对象: 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):
pass
class Foo(Base):
pass
class Bar(Foo):
pass
print(issubclass(Bar,Base)) # 检查第一个参数是否是第二个参数的 子子孙孙类
type
获取当前对象是有哪个类创建
获取对象类
"""
获取当前对象是由那个类创建。
"""
"""
class Foo(object):
pass
obj = Foo()
print(obj,type(obj)) # 获取当前对象是由那个类创建。
if type(obj) == Foo:
print('obj是Foo类型')
"""
# #### 练习题
"""
class Foo(object):
pass
class Bar(object):
pass
def 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):
pass
class Foo(Base):
pass
obj1 = 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)
"""