python面向对象

1 什么是类

　　定义：用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法，对象是类的实例。

　　描述　　

class F():
    a = 10
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def describe(self):
        print("大家好，我是%s，今年%d岁了" % (self.name, self.age))

　　　　self参数为实例（对象）本身。

　　　　__init__(self)为构造方法，创建实例时自动执行。

　　　　类变量：a为类变量在整个实例化的对象中是公用的，它定义在类中且在函数体之外，类变量通常不作为实例变量使用。

　　　　实例化：创建一个类的实例，类的具体对象

　　　　对象：通过类定义的数据结构实例，对象包括两个数据成员（类变量和实例变量）和方法。

2 类的三大特性

　　2.1 封装

　　　　变量在类中的方法进行传递。

　　2.2 继承　

　　　　继承：子类继承父类的字段和方法。

　　　　方法重写：当父类中的方法功能不能满足子类的需求，可在子类中重新写父类的方法。

　　　　如果在子类中需要父类中的构造方法，就要显示调用父类的构造方法，或者不重写父类的构造方法；子类不重写__init__，实例化子类时，会自动调用父类定义的__init__，如果重写了__inti__时，实力化子类就不会调用父类定义的__init__；如果重写了__inti__方法，要继承父类的构造方法，可以用以下两种方法：super(子类,self).__init__(参数1,参数2, ...)或者是：父类名.__init__(参数1,参数2, ...)

class F():
    a = 10
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def describe(self):
        print("大家好，我是%s，今年%d岁了" % (self.name, self.age))


class S(F):
    def __init__(self, name, age, sex):
        F.__init__(self, name, age)
        self.sex = sex

    def describe(self):
        # super(S, self).describe()
        F.describe(self)
        print("大家好，我是%s，%s生，今年%d岁了" % (self.name, self.sex, self.age))


s = S("alex", 20, "男")
s.describe()

　　2.3 多态

　　　　多态：子类可继承多个父类

　　　　属性和方法查找顺序：从左到右，如果左右都继承同一个父类，那么先执行左右，再查找父类。、

　　　　Pycharm中找源码的快捷键：CTRL+鼠标左单击名称。也能通过左边的导航窗口进行查找。

3 类成员

　　3.1 字段

　　　　静态字段：属于类，可以通过对象访问，也可通过类访问，类属性。

　　　　普通字段：属于对象，只能通过对象访问。

　　3.3 方法

　　　　普通方法：保存在类中，由对象调用。

　　　　静态方法：保存在类中，由类直接调用，添加@staticmethod装饰器，self不是必须的，可由类直接调用。

　　　　类方法：静态方法情况下，self修改为cls，cls为当前类。

　　　　应用场景：如果对象中需要保存一些值，执行某功能时，需要使用对象中的值，使用普通方法；不需要任何对象中的值，使用静态方法。

　　　　@property：在普通方法之上，在对象调用方法时，不用加上括号。

class Province():

    # 静态字段，将对象中的重复的数据保存为一份，避免重复
    country = "中国"

    def __init__(self, name):
        # 普通字段
        self.name = name
        print(Province.country)

    # 静态方法，属于类
    @staticmethod
    def xo():  # 此处不需要传递self参数
        print("静态方法")

    # 将方法伪造成了一种字段
    @property
    def end(self):
        temp = '%s nb' % self.name
        print(temp)

    # 类方法，属于类
    @classmethod
    def xxoo(cls):
        print("classmethod",cls)

    # 普通方法
    def show(self):
        print(self.name)

Province.xo()
Province.xxoo()

obj = Province("内蒙古")
obj.end
obj.show()

4 成员修饰符

　　私有成员：__属性或方法，对象无法直接访问，可通过类内部访问；私有属性不能通过类继承，但可通过父类的方法返回值间接访问。

class Foo():

    __v = '123'

    def __init__(self, name, age):
        self.name = name  # 公有的
        self.__age = age  # 私有的，外部无法直接访问

    def show(self):
        print(self.__age)  # 内部能访问
        print(Foo.__v)

    @staticmethod
    def stat():
        return Foo.__v

    def __f1(self):
        print("私有方法")

    def f2(self):
        self.__f1()

class s(Foo):

    def __init__(self, name):
        self.name = 123
        super(s,self).__init__()

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

obj = Foo('alex', 18)
print(obj.name)
ret = Foo.stat()
print(ret)
obj.f2()

5 特殊成员

 　　__init__，类()自动执行

　　__call__，对象()，类()()自动执行
　　__int__，int(对象)

　　__str__，str()方法

　　__add__，对象相加自动执行。

　　__del__，析构方法，对象被销毁时，自动执行。

　　__dict__，将对象中封装的所有内容通过字典的形式返回

　　__getitem__，索引时执行。

　　__setitem__，赋值时执行。

　　__delitem__，删除值执行。

　　__iter__，如果类中有__iter__方法，那么这个类创建的对象可进行迭代。

class Foo():

    def __init__(self):
        print('init')

    def __call__(self, *args, **kwargs):
        print('call')


obj = Foo()
obj()

class Foo():

    def __init__(self):
        print('init')

    def __int__(self):
        return 1

    def __str__(self):
        return 'alex'

obj = Foo()
# 自动执行对象的__int__方法，将结果返回给int对象
i = int(obj)
k = str(obj)
print(i)
print(k)
print(obj)  # 自动执行Foo函数里面的__str__方法，首先str()，接着执行__str__

class Foo():

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __add__(self, other):
        return self.age + other.age

    def __del__(self):
        print('析构方法')  # 对象销毁时，自动执行

obj1 = Foo('alex', 19)
obj2 = Foo('eiro', 66)
# 两个对象相加时，自动执行第一个对象的__add__方法，并且将第二个对象当作参传递进入
r = obj1 + obj2
print(r, type(r))

class Foo():

    def __init__(self, name, age):
        self.name = name
        self.age = age


obj = Foo('alex', 18)
d = obj.__dict__
ret = Foo.__dict__
print(d)
print(ret)

class Foo():

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        return item + 10

    def __setitem__(self, key, value):
        print(key, value)

    def __delitem__(self, key):
        print(key)

li = Foo('alex', 18)
r = li[8]  # 自动执行li对象的类中的__getitem__方法，8当作方法传递给item
print(r)

li[100] = 'alex'

del li[999]

class Foo():

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        if type(item) == slice:
            print("切片处理")
        else:
            print("索引处理")

    def __setitem__(self, key, value):
        print(key, value)

    def __delitem__(self, key):
        print(key)

li = Foo('alex', 18)
r = li[12334]  # 自动执行li对象的类中的__getitem__方法，8当作方法传递给item
li[1:2:2]

class Foo():

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __iter__(self):
        return iter([1,2,3,4,5,6,6])

li = Foo('alex', 18)
# 如果类中有__iter__方法，创建的对象是可迭代对象
# 对象.__iter__()返回值：迭代器
# for循环，迭代器，next
# 执行对象li类Foo中的__iter__方法，获取返回值。
# 循环上一步中返回的对象
for i in li:
    print(i)

6 metaclass

　　python中，一切事都是对象。

　　实例是类的对象，类是type类的对象。type(Foo,)，python中称对象都是以类的对象。

class MyType(type):

    def __init__(self, *args, **kwargs):
        # self = Foo
        print("MyType中的init方法")

    def __call__(self, *args, **kwargs):
        # self = Foo
        r = self.__new__()

# 创建类的时候，使用Mytype类创建。
class Foo(object, metaclass=MyType):

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        retrun "创建对象"  #obj是在new里面创建的

    def func(self):
        print('hello')

#
obj = Foo()

7 反射

　　通过字符串的形式操作对象中的成员。

　　getattr()

　　hasattr()

　　setattr()

　　delattr()

class Foo():

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        return '%s-%s' % (self.name, self.age)


obj = Foo('alex', 18)
# b = 'name'
# print(obj.__dict__[b])

# 去什么东西里面获取什么
# inp = input("->")
# r = getattr(obj, inp)
# print(r)

func = getattr(obj, 'show')
print(func())
print(hasattr(obj, 'name'))
setattr(obj, 'k1', 'v1') #
print(obj.k1)
delattr(obj, 'k1')

# 模拟路由器
inp = input("请输入要查看的url：")

class Foo():

    def __init__(self):
        self.name = 123

    def f1(self):
        return '首页'

    def f2(self):
        return '新闻'

    def f3(self):
        return '精华'

obj = Foo()
# if inp == 'f1':
#     obj.f1()
# elif inp == 'f2':
#     obj.f1()
# elif inp == 'f3':
#     obj.f3()
# else:
#     print('输入错误，没有执行')

if hasattr(obj, inp):
    r = getattr(obj, inp)
    print(r())
else:
    print('输入错误')

8 单例模式

　　例如连接数据库，数据库连接池的概念，明确某个类只有只有一个实例存在。

class Foo():

    def __init__(self, name, age):
        self.name = name
        self.age = age

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



obj = Foo('alex', 18)  # Foo类的实例，创建过程也是实例化过程
# 单例，单个实例，用于使用同一份实例（对象）
v = None
while True:
    if v:
        v.show()
    else:
        v = Foo('alex', 18)
        v.show()

class Foo():

    __v = None

    @classmethod
    def get_instance(cls):
        if cls.__v:
            return cls.__v
        else:
            cls.__v = Foo()
            return cls.__v


# 单例模式
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)