Python 3学习 ——面向对象

Python 学习——面向对象

 写此博客 是为了激励自己，并且将自己的心得以及遇到的问题与人分享

一、面向对象基础

　　　　　　　　　　　　　　　　面向对象就是一个类和对象的应用。

　　1.定义方法：

----------------------------------------------------------------

　　　　class 类名：

　　　　　　def 方法名（self , arg）:

　　　　　　print(arg)

　　　　中间人 = 类名（）

　　　　中间人.方法名（arg）

----------------------------------------------------------------

self 代指，调用方法的 对象 （中间人）

　　2.构造方法：类名加（）自动执行构造方法

class Person:
    def __init__(self,name,age):
        self.n = name
        self.a = age
    def show(self):
        print("%s  %s " %(self.n,self.a))

liufeiduo = Person('刘飞铎',19)
liufeiduo.show()

chengjunfei = Person('程俊飞',18)
chengjunfei.show()

 　　3.继承

class Father:   # 父类，基类
    def 篮球(self):
        pass
    def 足球(self):
        pass
    def 抽烟(self):
        pass

class Son(Father):  # 子类，派生类
    def 排球(self):
        pass


s = Son()
s.篮球()

　　子类重写父类方法

class F:
    def f1(self):
        print('F,f1')
    def f2(self):
        print('F,f2')

class S(F):
    def s1(self):
        print('S,s1')
    def f2(self):
        print('S,s2')

obj = S()
obj.s1()    #S,s1　　s1中的self 是形参，此时代指 obj
obj.f2()    #S,s2   　　

　　self 永远指调用方法的调用者

　　两种调用父类的方法：

　　　　　　　　　　方法一： super
class F:
    def f1(self):
        print('F,f1')
    def f2(self):
        print('F,f2')

class S(F):
    def s1(self):
        print('S,s1')
    def f2(self):
        super(S,self).f2()  #执行父类中的f2方法   #super代指了它的父类
        print('S,s2')

obj = S()

obj.f2()
'''
F,f2
S,s2
'''

　　　　　　　　　　方法二：通过父类名调用方法
class F:
    def f1(self):
        print('F,f1')
    def f2(self):
        print('F,f2')

class S(F):
    def s1(self):
        print('S,s1')
    def f2(self):
        #super(S,self).f2()  #执行父类中的f2方法   #super代指了它的父类
        print('S,s2')
        F.f2(self)
obj = S()

obj.f2()
'''
S,s2
F,f2
'''

　　多继承：Python 与 C++ 独有支持多继承，一个子类可以继承多个父类。

class F1:
    def a(self):
        print('F1.a')

class F2:
    def a(self):
        print('F2.a')

class Son(F1,F2):   # 按照从左到右的顺序，"一条路找到黑的顺序"来进行找。 如果有同一个根时，根最后执行。
    pass

obj = Son()
obj.a()     #F1.a

 　　4.多态

def func(arg):
    print(arg)
                 #   Python 中的原生多态，不被类型所限定。
func(1)

func('llalala')

二、面向对象中级

　　1.类成员

　　　　字段

　　　　　　普通字段，保存在对象中，执行只能通过对象访问。

　　　　　　静态字段，保存在类中，在内存中只保存一份，执行时可以通过对象访问也可以通过类进行访问。

class Provience:
    country = '中国'

    def __init__(self,name):
        self.name = name
henan = Provience('河南')
print(Provience.country)    #中国
print(henan.name)    #河南

　　　　方法

　　　　　　普通方法，保存在类中，由对象来进行调用。self --> 对象

　　　　　　静态方法，保存在类中，由类直接调用。

　　　　　　类方法，保存在类中，由类直接调用。cls --> 当前类

class Foo:

    def bar(self):  #普通方法
        print('bar')

    @staticmethod
    def sta(a1,a2):  #静态方法   self 就不是必须存在的了
        print(a1,a2)

    @classmethod
    def classmd(cls):  #类方法  cls 是类名 不依赖对象 可以通过类直接执行
        print(cls)
        print('classmd')

object = Foo()
object.bar()    #bar

Foo.sta(2,4)   #2 4 调用者直接类调用就可以了

Foo.classmd()    # <class '__main__.Foo'>  classmd

　　应用场景：

　　　　　　如果对象中需要保存一些值，执行某功能时，需要使用对象中的值 --->  普通方法。

　　　　　　不需要任何对象中的值 ---> 静态方法。

　　类的成员——属性：按照方法的方式写，按照字段调用的方式调用。

class Foo:
    def __init__(self):
        self.name = 'a'

    def bar(self):
        print('bar')

    @property　　#通过property装饰器
    def per(self):  # 属性：  伪造成方法，但访问的时候使用的是字段的方式
        print('per')

obj = Foo()
obj.per

　　利用 属性 完成分页的功能：

class Pergination:

    def __init__(self,current_page):
        self.page = int(current_page)

    @property
    def start(self):
        val = (self.page - 1) * 10
        return val
    @property
    def end(self):
        val = self.page * 10
        return val
li = []

for i in range(1000):
    li.append(i)

while True:
    p = input('请输入要查看的页码: ')#     每页显示十条
    obj = Pergination(p)

    print(li[obj.start:obj.end])

三、面向对象高级

　　1. 成员修饰符

　　　　公有成员

　　　　私有成员 　　__字段名

　　　　　　- 无法直接访问，只能间接访问

　　　　　　- 继承过来的私有字段是无法进行访问，内部访问指的是自身内部，继承过来的不可以。

　私有字段
 1 class Foo:

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

    def show(self): #间接访问私有字段方法
        return self.__age

obj = Foo('chengjunfei',20)
print(obj.name)
print(obj.show())       #间接访问私有字段

　　2. 特殊成员

　　　　__init__　类（）　　自动执行

　　　　__call__   对象（） 类（）（）自动执行

class Foo:

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

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



Foo()() #init  call

object = Foo()
object()    #对象后面加括号会执行 __call__ 中的方法，Python的一个内置语法。

　　　　__int__    int（对象）

　　　　__str__    str（对象）

　　　　__add__  

class Foo:
    def __init__(self):
        pass

    def __add__(self, other):
        return 123

obj1 = Foo()
obj2 = Foo()

r = obj1 + obj2
# 两个对象相加时，自动执行第一个对象的__add__方法，并且将第二个对象当作参数传递进去。

print(r,type(r))    #123 <class 'int'>

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

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

class Foo:

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

object = Foo('刘飞铎',21)

d = object.__dict__
print(d)    #{'name': '刘飞铎', 'age': 21}

c = Foo.__dict__
print(c)    #{'__module__': '__main__', '__init__': <function Foo.__init__ at 0x0000016D6A1499D8>,
            #  '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>,
            #  '__doc__': None}

　　　　__getitem__　　# 切片（slice类型）或者索引　　　　有返回值

　　　　__setitem__　　没有返回值

　　　　__delitem__　　没有返回值

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)
        print(value)

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


li = Foo('Liufeiduo',22)
r = li[8]   #自动执行li对象中的__getitem__方法，8当作参数传递给了item

print(r)    #18

li[100] = 'asdf'    # def __setitem__(self, key, value):
del li[985]     # def __delitem__(self, key):

　　　　__iter__ ：如果类中有 __iter__ 方法，对象 ---> 可迭代对象。

　　　　　　　　　对象.__iter__ （）的返回值，就是迭代器。

　　　　　　　　　for 循环 遇到 迭代器，就执行 next( ) 方法就行了。

　　　　　　　　　for 循环 遇到 可迭代对象，要先通过 可迭代对象.__iter__ ( )方法获取迭代器然后继续执行next( )方法。

class Foo:

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __iter__(self):
        return iter([11,22,33,44])

li = Foo('liufeiduo',22)
#1.获取li对象的类 Foo 中的__iter__ 方法，并获取其返回值。
#2.去循环上一步中返回的对象。
for i in li:
    print(i)    # 11/r 22/r 33/r 44/r

　　3. metaclass  类的祖宗

　　　　a. 在Python中，一切事物都是对象。

　　　　b. 

　　　　　　class  Foo():

　　　　　　　　pass

　　　　　　obj = Foo()

　　　　　　# obj 是对象，Foo 是类。

　　　　　　# Foo 类也是一个对象，type 的对象。

　　　　c. 类都是 type 类的对象   type(...)

　　　　　"对象"都是类的对象    类()

class MyType(type):
    def __init__(self,*args,**kwargs):
        print('123')
        pass


class Foo(object,metaclass=MyType):
    def func(self):
        print('hello')

# 执行结果：  123

　　类后面加括号，创建对象并不是直接执行了该类的 __init__ 方法，先执行 type 的 __call__ 方法，再执行该类的 __new__ 方法，再然后执行了 __init__ 方法。

　　

　　4. 异常处理

#-----------------最基本的---------------------
while True:
    try:
        inp = input('请输入序号:')
        # 代码块，逻辑
        i = int(inp)
    except Exception as e:
        # e 是Exception的对象，对象中封装了错误信息。
        # 上述代码块出错，自动执行当前块内容。
        print(e)
        i = 1

    print(i)

#--------------写异常的基本流程--------------------------------
    try:
        int ('w3rs')
    except IndexError as e:
        print('IndexError',e)
    except ValueError as e:
        print('ValueError',e)
    except Exception as e:
        print('Exception',e)

    else:
        print('else')

    finally:
        print('....')
#--------------------------------------------

　　　　写异常时，先 except ‘小弟’，后写‘大哥’，else 后面是没有捕捉到错误时执行，finally 后是无论如何都会执行。

　　主动抛出异常

try:
    raise Exception('我是主动抛出的异常')　　# 主动触发异常
except Exception as e:
    print(e)
    # 执行结果：我是主动抛出的异常

　　主动触发异常的小应用（记录错误日志）

def db():
   #return True
    return False

def index():
    try:
        result = db()
        if not result:
            #打开文件，写日志
            raise Exception('数据库处理错误')　　#当数据库返回值为False时，主动抛出异常，记录日志。

    except Exception as e:
        str_error = str(e)
        print(str_error)
        #打开文件写日志
        
index()

　　自定义异常

class LfdError(Exception):

    def __init__(self,msg):
        self.message = msg

    def __str__(self):
        return self.message

obj = LfdError('liufeiduo')
print(obj)

try:
    raise LfdError('我错了')
except LfdError as e:
    print(e)

　　断言　　assert + 条件  如果满足条件，继续执行，若不满足条件，直接报错。用于强制用户服从，不服从就报错，可捕获但一般不捕获。

　　5. 反射

　　　　在Python 中执行反射效率蛮高的。

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

　　　　①getattr方法，到某某东西中获取某某内容。

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

    def show(self):
        return "%s-%s" %(self.name,self.age)
object = Foo('liufeiduo',22)

# b = "name"
# print(object.__dict__[b])
inp = input('>>>>>>>>>>')
#去什么东西里面获取什么内容
b = getattr(object,inp)

print(b)    #liufeiduo

　　　　②hasattr方法，去检测对象中是否有某成员，返回True、False。

　　　　③setattr方法，在对象中主动设置某个值。

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

    def show(self):
        return "%s-%s" %(self.name,self.age)
object = Foo('liufeiduo',22)


setattr(object,'love','chengjunfei')
print(object.love)  #chengjunfei

　　　　④delattr方法，将主动设置的某个值删除掉。

　　　　反射在模块之间也是可以用的。

　　6.单例模式

class Foo:

    __v = None

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

        else:
            cls.__v = Foo()
            return cls.__v

object1 = Foo.get_instance()
print(object1)
object2 = Foo.get_instance()
print(object2)

#          执行结果：
#<__main__.Foo object at 0x000001137E007908>
#<__main__.Foo object at 0x000001137E007908>

　　好处：内存中对象只创建一份就可以了。