面向对象

面向对象: 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)
"""