首页 > 其他 > 详细

面向过程与面向对象(一)

时间:2019-06-18 13:30:18      阅读:57      评论:0      收藏:0      [点我收藏+]

标签:应该   --   dog   peak   查找   年龄   需要   @property   自定义类   

一.面向过程与面向对象:

  面向过程:

 重过程:解决问题,考虑的是解决问题的流程
 解决问题的思路清晰,但拓展性不强

 

  面向对象:
 重对象:解决问题,找到解决问题的对象
 解决问题的思路可能不止一条(理解解决问题的难度增加),但拓展性强

二.名称空间:

 能产生名称空间的有:文件 | 函数 | 类
 能产生名称空间的对象有__dict__这个值,通过该这个值访问到名字与地址的对应关系

def func():
    pass

func.__dict__[index] = 10000
print(func.__dict__)
属性:
print(func.__dict__[index]) print(func.index)
方法: func.add
= lambda n1, n2: n1 + n2 print(func.__dict__) print(func.add(10, 20))

 

三.类与对象:

类:具有相同特征与行为个体集合的抽象
 对象:有特征、行为的具体个体,就是类的具体体现

1.类拥有自己的名称空间,类的对象也拥有自己的名称空间

2.属性的访问顺序:对象优先加载自身的属性与方法,如果没有再考虑类的

 

四.对象的特有的名称空间:

class Student:
    # __init__方法会在实例化对象时被调用 , student=Student()
    # 1.会为实例化的对象形成空的名称空间
    # 2.就是一个方法,可以被传参,在 类名(实参) 这种方式下调用并传参 __init__(self, 形参)
    # 3.第一个self就是要产生的当前对象
    # 重点:在方法内部,形参拿到了实参值,利用self.属性名 = 形参 = 实参值,对对象的名称空间添加属性
    def __init__(self, name, sex):
        print(2>>>, self)
        self.name = name
        self.sex = sex


    def fn():
        print(fn run)

五.对象绑定类方法:

class A:
    def test(self):
        print(self)
        pass
a = A()
#绑定的三种方式: a.test() A.test(a) A.
__dict__[test](a)

六.类方法的调用:

class Tool:
    # 类方法:可以被类与对象调用的方法,第一个参数一定是类
    # 类方法不建议拿对象来调用
    @classmethod
    def add(cls, n1, n2):
        print(id(cls))
        cls.test()
        return n1 + n2

    @classmethod
    def test(cls):
        pass

print(Tool.add(10, 20))
tool = Tool()
print(tool.add(100, 200))
print(id(Tool), id(tool))

# 对象调用所属类的类方法,默认第一个参数传入的是 对象.__class__ 就是所属类

七.属性与方法的总结:

class OldBoy:
    # 属于类的属性
    name = 老男孩

    # 属于对象的属性
    def __init__(self, name):
        self.name = name

    # 属于类的方法
    # 需求:获取机构的名字
    @classmethod
    def get_class_name(cls):
        return cls.name

    # 属于对象的方法
    # 需求:获取校区的名字
    def get_school_name(self):
        return self.name

# 先创建校区
shanghai = OldBoy(上海校区)
shenzhen = OldBoy(深圳校区)

# 类方法的使用
# 建议使用类调用
print(OldBoy.get_class_name())
# 类方法拿对象调用并没有多少新增的意义,不建议拿对象调用
print(shanghai.get_class_name())
print(shenzhen.get_class_name())

# 对象方法的使用
# 类调用对象方法,必须把要操作的对象手动传入,不建议使用
print(OldBoy.get_school_name(shanghai))
print(OldBoy.get_school_name(shenzhen))
# 对象调用对象方法,默认将自身传入,建议使用
print(shanghai.get_school_name())
print(shenzhen.get_school_name())

八.封装:

      简单地说, 将方法与属性打包封在一个类中称为封装,方便之后调用操作.

九.类的隐藏:

     隐藏:对外隐藏类中一些属性与方法的实现细节
     优点:外界不能直接访问,让内部的属性与方法具有安全保障

class A:
    # __开头的属性,在外界不能通过 cord | __cord 直接访问:对外隐藏了
    __cord = ‘01012300‘

    # __开头的方法,在外界不能通过 get_money | __get_money 直接访问:对外隐藏了
    @classmethod
    def __get_money(cls):
        print(‘输入密码,取出100w零花钱‘)

    # 内部还是可以直接访问__开头的属性与方法
    @classmethod
    def test(cls, flag):
        print(‘test方法被外界调用‘)
        # 在调用test与访问具体数据与功能间添加安全处理的操作
        if flag == ‘自家人‘:
            print(cls.__cord)
            cls.__get_money()

  隐藏原理: 把用__开头的名字更名为 _类名__变量名

# print(A.__dict__)
print(A._A__cord)
A._A__get_money()

十.对象的隐藏(利用接口调用):

class AAA:
    def __init__(self, money):
        self.__money = money

    # 取值
    @property  # 在外界可以 对象.money 进行取值
    def money(self):
        # print(‘走方法拿到的money‘)
        return self.__money

    # 赋值
    @money.setter  # 在外界可以 对象.money = 新值 进行赋值
    def money(self, money):
        self.__money = money

    # 删除
    @money.deleter
    def money(self):
        # print(‘逗你玩‘)
        del self.__money

    def get_money(self, flag):
        if flag == 自家人:
            return self.__money
        return 0

    def set_money(self, money):
        self.__money += money

 

print(a.money)
a.money = 999999
print(a.money)

del a.money
print(a.money)

 

十一.组合:  自定义类的对象作为另外一个类的属性

  

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


t1 = Teacher("Owen", 17)
print(type(t1.name), type(t1.age))


class Student:
    # 学生可以有 老师 属性
    def __init__(self, name, age, teacher):
        self.name = name
        self.age = age
        # 自定义类的对象作为类的属性:组合
        self.teacher = teacher
# 创建一个学生
stu = Student(Bob, 18, t1)
print(stu.__dict__)

# 学生的老师年龄和姓名
print(stu.name)
print(stu.teacher)
print(stu.teacher.name)
print(stu.teacher.age)

十二.继承

    1.继承语法:

继承的语法:
# class 类名(父类名): pass

class A:
    pass

print(A.__bases__)  # object 
没有定义的类都是继承object

print(Leader.__bases__)  # Student
定义了父类就继承父类

   2.父类隐藏后的继承:

class Sup:
    __num = 10

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

    @property
    def name(self):
        print(self)            # <__main__.Sub object at 0x02BA8490>
print(self.__dic__) # 名称空间的key是‘_Sup_name‘
return self.__name @classmethod def __c_fn(cls): print(cls, c fn) def __o_fn(self): print(self.name, o fn) class Sub(Sup): def test(self): print(self.__dict__) # {‘_Sup__name‘: ‘sssssssss‘} print(self._Sup__name) pass sub = Sub(sssssssss) print(sub.name) sub.test()
sub._Sup__c_fn()

  3.方法的重写(完全不用父类的):

 有继承关系下的属性查找顺序:
 1.优先找自身,自身没有找父类
 2.父类没有找父类的父类
 3.一直找到最顶级的父类,如果还没有报错

# 两个名词:
先写子类,抽离 出父类
先写父类,派生 出子类
class Sup:
    num = 10

    def test(self):
        print(test sup)

class Sub(Sup):
    num = 100

    # 先写好父类的方法,由于父类方法的功能不满足子类需求,
    # 子类可以重写父类方法:方法名与父类相同,自定义方法的实现体
    def test(self):
        print(test sub)

print(Sub.num)
Sub().test()

  4.方法的重用(部分仍用父类的):

class Sup:
    def test(self):
        print(>>>sup, self)
        print(test sup)


class Sub(Sup):
    pass
    # 重用:还需要父类方法的功能,在父类方法功能基础上再添加新功能
    # 突破点:在子类中去调用父类的方法,还有保证调用者是子类(子类的对象)
    def test(self):
        # Sup().test()

        # python2中写法
        # super(Sub, self).test()
        # python3中简化写法
        super().test()

        print(>>>sub, self)
        print(test sub)


Sub().test()

 5.__init__结合super()使用:

# 人类:只需要初始化 - name
# 老师: 要初始化 - name salary
# 学生: 要初始化 - name grade
class Sup:
    def test(self):
        print(self)

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

class Sub(Sup):
    # 有继承关系下,只要名字相同,即使产生不同,还是属于同一个方法
    def test(self, num):
        super().test()
        print(num)

    # 默认父级的__init__可以被继承过来,
    # 但是会出现子类对象的属性比父类多

    def __init__(self, name, salary):
        super().__init__(name)  # 父级有的共性功能通过super()交给父级做
        self.salary = salary  # 子类特有的自己来完成

# Sub().test(10)
# Sub().test()  # 使用还是使用自身带参的,不能使用父级不带参的
# (本质名字相同就是一个,优先查找自己的)

     6.多继承:

# 简单的多继承
‘‘‘
# 属性的查找顺序:优先找自己的,如果没有,按照继承先后查找父级
class A:
    name = ‘A‘
    num = 10

class B:
    name = ‘B‘
    count = 100

# 子类可以继承所有父类的所有可继承属性
class C(A, B):  # 自己 => A => B
    # name = ‘C‘
    pass

print(C.num)
print(C.count)
print(C.name)
# 打印属性查找的顺序
print(C.mro())
‘‘‘

# 复杂的多继承
‘‘‘
class A:
    name = "A"
class B(A):
    name = "B"
class C:
    name = "C"
class D(C):
    name = "D"
class E(B, D):
    name = "E"
print(E.mro())
‘‘‘

# 经典类:python2中才有,没有继承任何类的类
# 新式类:python2中直接或间接继承object的类,python中所定义的所有类


class G: name = "G"
class C(G): pass
class B(C): pass
class E(G): pass
class D(E): name = "D"
class F(G): pass
class A(B, D, F): pass
print(A.mro())

    7.菱形继承:

 经典类:python2中才有,没有继承任何类的类 - 深度优先 新式类:python2中直接或间接继承object的类,python中所定义的所有类 - 广度优先

 深度优先,在查找第一个分支是就将菱形的头查找了 广度优先,菱形的头在所有分支查找接收后再被查找

 通过 类.mro() 查看继承顺序图

 

十三.接口思想:

# 接口类:用来定义功能的类,为继承它的子类提供功能的,
# 该类的功能方法一般不需要有实现体,实现体有继承它的子类自己去实现
class PetInterface:
    def close_master(self): pass

class WatchInterface:
    def watch_door(self): pass

class Dog(PetInterface, WatchInterface):
    def jiao(self): pass

    def chi(self): pass

    def pao(self): pass

    # 一定要重写接口的方法

十四.抽象类:

# 抽象父类:拥有抽象方法(子类共有的方法,但是父类不能有具体的实现体)的父类
#       抽象方法:方法名是具体的,但是实现体是抽象的(在子类中重写来具象化)

# python中借助abc来实现抽象父类
import abc  # abstract base class
class Quan(metaclass=abc.ABCMeta):
    def __init__(self, name):
        self.name = name
    def run(self):
        print(self.name + running)

    # 抽象父类中的抽象方法,在继承它的子类中必须有自己的实现体
    #       -- 抽象父类中的抽象方法实现体就没有意义,实现与不实现都是pass填充
    @abc.abstractmethod
    def chi(self):
        # print(self.name + ‘肉‘)
        pass
    @abc.abstractmethod
    def jiao(self):
        # print(‘汪汪汪‘)
        pass

    @classmethod
    @abc.abstractmethod
    def fn(cls): pass

class Dog(Quan):
    @classmethod
    def fn(cls): pass

    def kanmen(self):
        print(self.name + 看门)
    def chi(self):
        super().chi()
        print(self.name + 狗粮)
    def jiao(self):
        print(汪汪汪)

class Wolf(Quan):
    @classmethod
    def fn(cls): pass

    def bulie(self):
        print(self.name + 捕猎)
    def chi(self):
        print(self.name + )
    def jiao(self):
        print(嗷嗷嗷)

dog = Dog(来福)
wolf = Wolf(常委)

dog.jiao()
# wolf.jiao()
# dog.run()
# wolf.run()

十五.多态:

# 多态:对象的多种状态 - 父类对象的多种(子类对象)状态

import abc
class People(metaclass=abc.ABCMeta):
    def __init__(self, name):
        self.name = name

    @abc.abstractmethod
    def speak(self): pass

class Chinese(People):
    def speak(self):
        print(说中国话)

class England(People):
    def speak(self):
        print(说英国话)


if __name__ == __main__:
    # 多态的体现:功能或是需求,需要父类的对象,可以传入父类对象或任意子类对象均可以
    #       注:一般都是规定需要父类对象,传入子类对象
    def ask_someone(obj):
        print(让%s上台演讲 % obj.name)  # 父类提供,自己直接继承
        obj.speak()  # 父类提供,只不过子类重写了

    ch = Chinese(王大锤)
    en = England(Tom)

    ask_someone(ch)
    ask_someone(en)

十六.鸭子类型

import abc
class People(metaclass=abc.ABCMeta):
    def __init__(self, name):
        self.name = name

    @abc.abstractmethod
    def speak(self): pass

class Chinese(People):
    def speak(self):
        print(说中国话)

class England(People):
    def speak(self):
        print(说英国话)

# 鸭子类型:
# 1.规定有什么属性及什么方法的类的类型叫鸭子类型
# 2.能提供出规定的属性与方法的对象就是鸭子
class Test:
    def __init__(self, name):
        self.name = name
    def speak(self):
        print(说鸟语)

if __name__ == __main__:
    def ask_someone(obj):
        print(让%s上台演讲 % obj.name)
        obj.speak()

    test = Test(鸭子)
    ask_someone(test)

十七.格式化与析构方法

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

    # 格式化方法:在外界打印该类对象是被调用
    # 格式化外界直接打印该类对象的字符串表示结果
    def __str__(self):
        # return ‘abc‘
        # return super().__str__()
        return <name:%s | age:%s> % (self.name, self.age)

    # 析构方法:在对象被消耗的那一刹那被调用,在被消耗前可以做一些事情
    def __del__(self):
        # del会在self代表的对象被消耗的时候被调用
        # 我们可以在析构函数中释放该对象持有的其他资源,
        # 或者将一些持有资源持久化(保存到文件或数据库中)
        del self.name  # 也可以将name存起来

十八.反射:通过字符串与类及类的对象的属性(方法)建立关联

class A:
    num = 10
print(hasattr( A ,num))           #判断类中是否有num属性      True
print(getattr(A,num,default))   #获取类中num的属性值,没有则拿默认值   10
delattr(A,num)                    #删除类中num属性
setattr(A,tag,10)                 #在类中设置一个tag属性


class B:
    def __init__(self,name):
        self.name=name
b = B(BOb)
print(hasattr( b ,name))         #判断对象中是否有name属性      True
print(getattr(b,name,default)) #获取对象中name的属性值,没有则拿默认值   10
delattr(b,name)                  #删除对象中name属性
setattr(b,tag,10)                #在对象中设置一个tag属性
print(b.tag)



class C:
    def fn(self):
        print(fn)
    @classmethod
    def func(cls):
        print(func)

#类调对象方法,需要传入对象当做参数
fn=getattr(C,fn)
c = C()
fn(c)
#对象调对象方法
c = C()
fn=getattr(c,fn)
fn()
#类调类方法
func = getattr(C,func)
func()

十九.异常处理:

# 程序运行时的错误
# 程序中的异常处理机制:
# 1.程序中的所有异常都会被处理
# 2.程序中的所有异常都需要手动处理
# 3.如果没有手动处理异常,异常会交给Python解释器处理
#       -- 处理的方式就是打印异常信息,并停止接收器

# 异常信息的三部分:
# 1.异常的追踪信息:提示错误位置
# 2.异常的类型:告知处理异常应该捕获什么类型
# 3.异常的内容:告知错误信息

# 处理异常的语法:
‘‘‘
try:
    # 会出现异常的代码块
except  异常类型 as 异常别名:
    # 异常处理逻辑
else:
    # 没有出现异常会执行该分支
finally:
    # 无论是否出现异常都会执行该分支
‘‘‘

try:
    print(adsdasadsdasadsdas)
except NameError as e:
    print(异常信息:, e)
else:
    print(被检测的代码块正常)
finally:
    print(异常是否出现都会执行该分支)

print(end)

 

面向过程与面向对象(一)

标签:应该   --   dog   peak   查找   年龄   需要   @property   自定义类   

原文:https://www.cnblogs.com/sima-3/p/11044539.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号