来自 威尼斯国际官方网站 2019-12-23 06:03 的文章
当前位置: 威尼斯国际官方网站 > 威尼斯国际官方网站 > 正文

19_面向对象编制程序1,python全栈开拓从入门到抛

以下笔记绝大部分(百分之80或以上)摘自我的授课老师之一:老男孩教育中的景老师。
她上课讲的知识点由浅入深,引人入胜,听她的课完全不会感觉到困阿,而且不知不觉中就感觉掌握了。
她的博客是:

由于面向对象编程是一门思想,目前的我还并没有能力直接转化成自已的语言去组织浅显地讲述出来,而且学习的时间也紧迫,
并不允许过多的去研究。故有鉴于此,后面的学习笔记大多会以整理转摘为主!

面向过程 VS 面向对象 

面向过程的程序设计的核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西。

优点是:极大的降低了写程序的复杂度,只需要顺着要执行的步骤,堆叠代码即可。

缺点是:一套流水线或者流程就是用来解决一个问题,代码牵一发而动全身。

应用场景:一旦完成基本很少改变的场景,著名的例子有Linux內核,git,以及Apache HTTP Server等。

 

面向对象的程序设计的核心是对象(上帝式思维),要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记,如来要解决的问题是把经书传给东土大唐,如来想了想解决这个问题需要四个人:唐僧,沙和尚,猪八戒,孙悟空,每个人都有各自的特征和技能(这就是对象的概念,特征和技能分别对应对象的属性和方法),然而这并不好玩,于是如来又安排了一群妖魔鬼怪,为了防止师徒四人在取经路上被搞死,又安排了一群神仙保驾护航,这些都是对象。然后取经开始,师徒四人与妖魔鬼怪神仙互相缠斗着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

面向对象的程序设计的

优点是:解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。

缺点:可控性差,无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间的交互解决问题即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现,一刀砍死3个人,这个游戏就失去平衡。

应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方。

在python 中面向对象的程序设计并不是全部。

面向对象编程可以使程序的维护和扩展变得更简单,并且可以大大提高程序开发效率 ,另外,基于面向对象的程序可以使它人更加容易理解你的代码逻辑,从而使团队开发变得更从容。

了解一些名词:类、对象、实例、实例化

类:具有相同特征的一类事物(人、狗、老虎)

对象/实例:具体的某一个事物(隔壁阿花、楼下旺财)

实例化:类——>对象的过程(这在生活中表现的不明显,我们在后面再慢慢解释)

面向过程 VS 面向对象

面向过程的程序设计的核心是过程(流水线式思维),过程即解决问题的步骤,
面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西。
优点是:
极大的降低了写程序的复杂度,只需要顺着要执行的步骤,堆叠代码即可。
缺点是:
一套流水线或者流程就是用来解决一个问题,代码牵一发而动全身。
应用场景:
一旦完成基本很少改变的场景,著名的例子有Linux內核,git,以及Apache HTTP Server等。

面向对象的程序设计的核心是对象(上帝式思维),
要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,不存在的也可以创造出来。

面向对象的程序设计好比如来设计西游记,如来要解决的问题是把经书传给东土大唐,如来想了想解决这个问题需要四个人:唐僧,沙和尚,猪八戒,孙悟空,每个人都有各自的特征和技能(这就是对象的概念,特征和技能分别对应对象的属性和方法),然而这并不好玩,于是如来又安排了一群妖魔鬼怪,为了防止师徒四人在取经路上被搞死,又安排了一群神仙保驾护航,这些都是对象。然后取经开始,师徒四人与妖魔鬼怪神仙互相缠斗着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

面向对象的程序设计的
优点:
解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。
缺点:
可控性差,无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间的交互解决问题,即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现,一刀砍死3个人,这个游戏就失去平衡。

应用场景:
需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方。

在python 中面向对象的程序设计并不是全部。
面向对象编程可以使程序的维护和扩展变得更简单,并且可以大大提高程序开发效率 ,
威尼斯国际官方网站 ,另外,基于面向对象的程序可以使它人更加容易理解你的代码逻辑,从而使团队开发变得更从容。

了解一些名词:类、对象、实例、实例化
类:具有相同特征的一类事物
对象(实例):具体的某一个事物
实例化:类——>对象的过程

在python中,用变量表示特征,用函数表示技能,因而具有相同特征和技能的一类事物就是‘类’,
对象是则是这一类事物中具体的一个。

面向对象编程
类的概念 : 具有相同属性和技能的一类事物
例:人类 抽象
对象 : 就是对一个类的具体的描述
例:具体的人 具体

使用面向对象的好处:
1 使得代码之间的角色关系更加明确
2 增强了代码的可扩展性
3 规范了对象的属性和技能
面向对象的特点:结局的不确定性

初识类和对象

python中一切皆为对象,类型的本质就是类,所以,不管你信不信,你已经使用了很长时间的类了

>>> dict #类型dict就是类dict
<class 'dict'>
>>> d=dict(name='eva') #实例化
>>> d.pop('name') #向d发一条消息,执行d的方法pop
'eva'

从上面的例子来看,字典就是一类数据结构,我一说字典你就知道是那个用{}表示,里面由k-v键值对的东西,它还具有一些增删改查的方法。但是我一说字典你能知道字典里具体存了哪些内容么?不能,所以我们说对于一个类来说,它具有相同的特征属性和方法。

而具体的{'name':'eva'}这个字典,它是一个字典,可以使用字典的所有方法,并且里面有了具体的值,它就是字典的一个对象。对象就是已经实实在在存在的某一个具体的个体。

 

再举一个其他的例子,通俗一点,比如你现在有一个动物园,你想描述这个动物园,那么动物园里的每一种动物就是一个类,老虎、天鹅、鳄鱼、熊。他们都有相同的属性,比如身高体重出生时间和品种,还有各种动作,比如鳄鱼会游泳,天鹅会飞,老虎会跑,熊会吃。

但是这些老虎熊啥的都不是具体的某一只,而是一类动物。虽然他们都有身高体重,但是你却没有办法确定这个值是多少。如果这个时候给你一只具体的老虎,而你还没死,那你就能给他量量身高称称体重,这些数值是不是就变成具体的了?那么具体的这一只老虎就是一个具体的实例,也是一个对象。不止这一只,其实每一只具体的老虎都有自己的身高体重,那么每一只老虎都是老虎类的一个对象。

在python中,用变量表示特征,用函数表示技能,因而具有相同特征和技能的一类事物就是‘类’,对象是则是这一类事物中具体的一个。

类的知识

初识类

声明

def functionName(args):
           '函数文档字符串'
           函数体

'''
class 类名
    '类的文档字符串'
    类体

'''

#我们创建一个类
class Data:      #类名的首字母必须是大写
    pass

class Person:   #定义一个人类
    role = 'person'   #人的角色属性都是人
    def walk(self):   #人都可以走路,也就是有一个走路方法,也叫动态属性
        print("person is walking...")

类有两种作用:属性引用和实例化

属性引用(类名.属性)

class Person:                #定义一个类
    role='person'            #定义这个人的角色属性都是人类
    def walk(self):          #人都可以走路,也就有一个走路的方法
        print("person is walking...")

print(Person.role)         #查看人的role属性
print(Person.walk)         #引用人的走路方法,注意这里不是在调用,打印的是这个方法的内存地址
'''
输出结果
person
<function Person.walk at 0x0000022DCDAFC8C8>   
'''

实例化:类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每个实例定制自己的特征

class Person:                #定义一个类
    role='person'            #定义这个人的角色属性都是人类
    def __init__(self,name):   #每一个角色都有自己的昵称
       self.name=name
    def walk(self):          #人都可以走路,也就有一个走路的方法
        print("person is walking...")

print(Person.role)         #查看人的role属性
print(Person.walk)         #引用人的走路方法,注意这里不是在调用,打印的是这个方法的内存地址
'''
输出结果
person
<function Person.walk at 0x0000022DCDAFC8C8>   
'''

 

实例化的过程就是类----->对象的过程

原本我们只有一个Person类,在这个过程中,产生了一个egg对象,有自己具体的名字、攻击力和生命值

语法:对象名=类型(参数)

查看属性&&调用方法

class Person:
    role='person'
    def __init__(self,name):
        self.name=name
    def walk(self):
        print("person is walking...")

print(Person.role)
print(Person.walk)
egg=Person('egon')     #类名()就等于在执行Person.__init__() 执行完__init__()就会返回一个对象。这个对象类似一个字典,存着属于这个人本身的一些属性和方法 把egon值传给了name
print(egg.name)     #查看属性直接 对象名.属性名
print(egg.walk())    #调用方法,对象名.方法名()

关于self

self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字,但是正常人都不会这么做。因为你乱改会造成别人不认识。切记

类属性的补充

一:我们定义的类的属性到底存到哪里了?有两种方式查看
dir(类名):查出的是一个名字列表
类名.__dict__:查出的是一个字典,key为属性名,value为属性值

二:特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

创建一个类:

威尼斯国际官方网站 1

类名的作用:
1:引用静态变量(静态属性)
        1)类名.__dict__['静态变量名'] 可以查看,但是不能删改
        2)类名.静态变量名 直接就可以访问,可以删改.删除一个静态变量 del 类名.静态变量名

接上例:
# 引用静态变量(静态属性)
print(Preson.role)
print(Preson.__dict__['role'])
# 类名.静态属性名 等同于 类名.__dict__['静态属性名']
# 且前者使用起来比后者优雅简单多了,所以以后要用到的时候统一使用前者的格式。
print(Preson.money)
Preson.money = 1000  # 类名.静态变量名,直接可以修改和进行删除
print(Preson.money)

person
person
0
1000

2:引用动态变量(动态属性)
        1)类名.方法名  查看这个方法的内存地址
        2)类名.方法名(实参)  调用了这个方法,必须传一个实参,这个实参传给了self

关于self
self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字,但是正常人都不会这么做。因为你瞎改别人就不认识。

接上例:
# 实例化给人与狗各创造一个对象
tiele = Person('tiele', '男', 31, 10, )
xiaobai = Dog('小白', '金毛寻回犬', 38, 15)

# 类名.方法名,查看内存地址
print(Person.attack)

# 类名.方法名(实参),调用此方法
Person.attack(tiele, xiaobai)

# print输出
<function Person.attack at 0x0000000000DD5510>
tiele 对 小白 发起了一次攻击
造成了 10 点伤害
小白 还余 28 HP

实例化的过程:
    1.创造一个实例,此实例将会作为一个实际参数。  
    2.自动触发一个__init__的方法,并且把实例以参数的形式传递给__init__方法中的self形参。
    3.执行完__init__方法之后,会将self自动返回给你定义的对象名。

# __init__方法 :初始化方法,给一个对象添加一些基础属性的方法,一般情况下是针对self的赋值。

对象
    在类的内部 self是本类的一个对象。
    在类的外部,每一个对象都对应着一个名字,这个对象指向一个对象的内存空间。
对象是关于类而实际存在的一个例子,即实例
对象/实例只有一种作用:属性引用
当然了,你也可以引用一个方法,因为方法也是一个属性,只不过是一个类似函数的属性,我们也管它叫动态属性。
引用动态属性并不是执行这个方法,要想调用方法和调用函数是一样的,都需要在后面加上括号。

属性的调用:
对象名.属性名               第一种调用方法
对象名.__dict__['属性名']   第二种调用方法
接上例:
print(tiele.name)  # 输出 tiele
print(tiele.__dict__['sex'])  #输出 男

方法的调用 :
类名.方法名(对象名)  # 那么方法中的self参数就指向这个对象
对象名.方法名()      # 这样写 相当于方法中的self参数直接指向这个对象

接上例:
# 类名.方法名(对象名)
Person.attack(tiele, xiaobai)
# 对象名.方法名()
tiele.attack(xiaobai)

# 显示如下:
tiele 对 小白 发起了一次攻击
造成了 10 点伤害
小白 还余 28 HP
tiele 对 小白 发起了一次攻击
造成了 10 点伤害
小白 还余 18 HP

对象的内存空间里: 只存储对象的属性,而不存储方法和静态属性。
方法和静态属性都存储在类的内存空间中,为了节省内存,让多个对象去共享类中的资源。

对象属性是独有的,静态属性和方法是共享的。
对象使用名字:先找自己内存空间中的,再找类的内存空间中的。

类名.静态变量名 :对于静态属性的修改,应该使用类名直接修改。
接上例:
print(Person.money)
Person.money = 1000
print(Person.money)

# 显示
0
1000

程序的解耦
    1) 当计算的规模足够大的时候 我们应该在编码的过程当中让操作尽量原子化。
    2) 尽量用返回值来代替print。

类属性的补充:
一:我们定义的类的属性到底存到哪里了?
有两种方式查看
dir(类名):查出的是一个名字列表
类名.__dict__:查出的是一个字典,key为属性名,value为属性值

二:特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

对象的相关知识

#一个游戏人狗大战
class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;

    def attack(self,dog):  
        # 人可以攻击狗,这里的狗也是一个对象。
        # 人攻击狗,那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivit

类命名空间与对象、实例的命名空间

创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性。
而类有两种属性:静态属性和动态属性
静态属性就是直接在类中定义的变量
动态属性就是定义在类中的方法

其中类的数据属性是共享给所有对象的,而类的动态属性是绑定到所有对象的。
创建一个对象/实例就会创建一个对象/实例的名称空间,存放对象/实例的名字,称为对象/实例的属性。
在obj.name会先从obj自己的名称空间里找name,找不到则去类中找,类也找不到就找父类...最后都找不到就抛出异常。

后面的内容请接着看面向对象编程2的博文笔记
【end】

对象是关于类而实际存在的一个例子,即实例

对象/实例只有一种作用:属性引用

egg = Person('egon',10,1000)
print(egg.name)
print(egg.aggressivity)
print(egg.life_value)

当然了,你也可以引用一个方法,因为方法也是一个属性,只不过是一个类似函数的属性,我们也管它叫动态属性。
引用动态属性并不是执行这个方法,要想调用方法和调用函数是一样的,都需要在后面加上括号

print(egg.attack)

本文由威尼斯国际官方网站发布于威尼斯国际官方网站,转载请注明出处:19_面向对象编制程序1,python全栈开拓从入门到抛

关键词: