week7_notebooke

回顾：
类：具有相同属相和技能的一类事物
对象：类的具体表现
class A：
    country = 'China'  #静态变量，静态字段
    
    def __init__(self):    #动态变量，方法
    self.name = name
    self.age = age
    def func(self):
    print(555)
obj1 = A('alex',1000)  #实例化的过程
1.创建一个对象，开辟一个空间
2.自动执行__init__方法，并将obj1对象本身传给self
3.将name，age的内容封装到obj1对象空间中
print(obj1.country)
obj1.func()

为什么对象可以调用类里面的字段和方法？


类空间，对象空间
组合：
class A:
def __init__(self,name,obj):
    self.name = name
    self.obj = obj
    class B:
    name = 'alex'
    def func(self):
    print(777)

b1 = B()
a1 = A('oldboy',b1)
print(a1.name)
print(a1.obj.name)
a1.obj.func()

继承：
多继承，单继承
多继承；
新式类（默认继承object，python3都是新式类，广度优先），钻石继承

经典类（不继承object，python2中默认经典类，可以设置新式类，深度优先）


super.func()


今日大纲：
接口类，抽象类
(多态)鸭子类型
封装
面向对象整体结构及成员
私有成员,公有成员
其他方法


接口类，抽象类
含义：是一种编写代码时的规范





#####################################################################
from abc import ABCMeta, abstractmethod
class Payrole(metaclass=ABCMeta):   # 抽象类或者接口类，制定规范，统一方法名
    @abstractmethod
    def pay(self,money): pass


class QQpay(Payrole):
    def pay(self, money):
        print('您已经通过QQ支付了%s元' % money)


class Wechatpay(Payrole):
    def pay(self, money):
        print('您已经通过微信支付了%s元' % money)


class Alipay(Payrole):
    def pay(self, money):
        print('您已经通过支付宝支付了%s元' % money)


def pay(obj, money):
    obj.pay(money)


qq = QQpay()
wechat = Wechatpay()
ali = Alipay()

pay(qq,300)
pay(wechat,600)
pay(ali,1200)
#############################################################################

多态,鸭子类型
含义：python默认支持多态
鸭子类型：对于一些相似功能，简称鸭子类型
推荐书籍（核心编程2版和核心编程3版）


封装
 广义封装：封装到对象中的属性是一种封装
狭义封装：私有性封装（类的外部不能调用,在类的内部可以访问）
私有：私有静态字段（私有静态变量）


面向对象整体结构及成员

class A:

    company_name = '老男孩教育'  # 静态变量(静态字段)
    __iphone = '1353333xxxx'  # 私有静态变量(私有静态字段)


    def __init__(self,name,age): #普通方法(构造方法)

        self.name = name  #对象属性(普通字段)
        self.__age = age  # 私有对象属性(私有普通字段)

    def func1(self):  # 普通方法
        pass

    def __func(self): #私有方法
        print(666)


    @classmethod  # 类方法
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        print('类方法')

    @staticmethod  #静态方法
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print('静态方法')

    @property  # 属性
    def prop(self):
        pass

类的结构细分

面试题，需注意：

私有成员,公有成员



属性：property 属性将你的一些方法伪装成属性，在代码上没有改变，但表现更加合理。

类方法：一般由类名直接调用有些情况，对于类内部的方法，无需对象直接调用，而类名直接调用即可
静态方法：不用类对象，对象传入任何值，直接调用即可。



class Good:
    def __init__(self,name,origin_price,discount):
        self.name = name
        self.__origin_price = origin_price
        self.__discount = discount

    @property
    def price(self):
        return self.__origin_price*self.__discount

    @price.setter
    def price(self,new_price):
        self.__origin_price = new_price

p1 = Good('apple',5,0.8)
print(p1.price)
p1.price = 8

注意：动态输入禁止使用eval和exec,会出现直接执行命令情况。
反射：
类中：
getattr()和hasattr结合使用
setattr()  #增加或者修改
delattr()  #删除

class Foo(object):
 
    staticField = "old boy"
 
    def __init__(self):
        self.name = 'wupeiqi'
 
    def func(self):
        return 'func'
 
    @staticmethod
    def bar():
        return 'bar'
 
print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')

对象中：
class Foo:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性
print(hasattr(obj,'name'))
print(hasattr(obj,'say_hi'))

#获取属性
n=getattr(obj,'name')
print(n)
func=getattr(obj,'say_hi')
func()

print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

#设置属性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'sb')
print(obj.__dict__)
print(obj.show_name(obj))

#删除属性
delattr(obj,'age')
delattr(obj,'show_name')
delattr(obj,'show_name111')#不存在,则报错

print(obj.__dict__)

模块中：
#一个模块中的代码
def test():
    print('from the test')
"""
程序目录：
    module_test.py
    index.py
 
当前文件：
    index.py
"""
# 另一个模块中的代码
import module_test as obj

#obj.test()

print(hasattr(obj,'test'))

getattr(obj,'test')()

当前模块中：
import sys
def s1():
    print 's1'


def s2():
    print 's2'


this_module = sys.modules[__name__]

hasattr(this_module, 's1')
getattr(this_module, 's2')

其他方法
__len__:
class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)
a = A()
print(len(a))

__hash__:
class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))

__str__:
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
class A:
    def __init__(self):
        pass
    def __str__(self):
        return '太白'
a = A()
print(a)
print('%s' % a)

__repr__:
如果一个类中定义了__repr__方法，那么在repr(对象) 时，默认输出该方法的返回值。
class A:
    def __init__(self):
        pass
    def __repr__(self):
        return '太白'
a = A()
print(repr(a))
print('%r'%a)

__call__:
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__


__eq__:
class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
print(a == b)

__new__:
class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        print('in new function')
        return object.__new__(A, *args, **kwargs)

a = A()
print(a.x)
单例模式：



__del__:

析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。


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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)