[ python ] 初始面向对象

首先,通过之前学习的函数编写一个 人狗大战 的例子。

分析下这个需求,人 狗 大战  三个事情。
角色:人、狗
动作:狗咬人,人打狗

 

先创建人和狗两个角色:

复制代码
def person(name, hp, aggr, sex):
    data = {
        'name': name,
        'hp': hp,
        'aggr': aggr,
        'sex': sex
    }

    return data


def dog(name, hp, aggr, dog_type):
    data = {
        'name': name,
        'hp': hp,
        'aggr': aggr,
        'dog_type': dog_type
    }

    return data


kk = person('kk', 100, 5, 'male')    # 人的角色
gg = dog('gg', 100, 10, 'teddy')    # 狗的角色
人和狗两个角色
复制代码

 

 

人创建完成,但是我们还有两个动作才能开始游戏,于是使用函数在写两个动作:

复制代码
def person(name, hp, aggr, sex):
    data = {
        'name': name,
        'hp': hp,
        'aggr': aggr,
        'sex': sex
    }

    return data


def dog(name, hp, aggr, dog_type):
    data = {
        'name': name,
        'hp': hp,
        'aggr': aggr,
        'dog_type': dog_type
    }

    return data


kk = person('', 100, 5, 'male')
gg = dog('狗狗', 100, 10, 'teddy')



def bite(g, p):
    p['hp'] -= g['aggr']
    print('%s 被咬,掉了%s 的血。' %(p['name'], g['aggr']))

bite(gg, kk)

def hit(p, g):
    g['hp'] -= p['aggr']
    print('%s 被打,掉了%s 的血。' %(g['name'], p['aggr']))

hit(kk, gg)
两个动作
复制代码

 

 

上面的代码已经实现了我们最初设计的人狗大战,但是每个函数都是相互独立的,没有任何限制。也就是说,可以出现以下这种情况:

复制代码
hit(gg, kk)
bite(kk, gg)

执行结果:

人 被打,掉了10 的血。
狗狗 被咬,掉了5 的血。
复制代码

 

 

这样,人和狗正好相反了,应该是人打狗,狗咬人才对。因此必须要加上限制:

复制代码
def person(name, hp, aggr, sex):
    data = {
        'name': name,
        'hp': hp,
        'aggr': aggr,
        'sex': sex
    }

    def hit(g):
        g['hp'] -= data['aggr']
        print('%s 被打,掉了%s 的血。' % (g['name'], data['aggr']))

    data['hit'] = hit
    return data


def dog(name, hp, aggr, dog_type):
    data = {
        'name': name,
        'hp': hp,
        'aggr': aggr,
        'dog_type': dog_type
    }

    def bite(p):
        p['hp'] -= data['aggr']
        print('%s 被咬,掉了%s 的血。' % (p['name'], data['aggr']))

    data['bite'] = bite
    return data


kk = person('', 100, 5, 'male')
gg = dog('狗狗', 100, 10, 'teddy')

kk['hit'](gg)
gg['bite'](kk)
为角色的动作加上限制
复制代码

 

 

这样,我们在代码层面就实现了限制,代码基本完美了。

 

回看我们上面的代码,创建的是角色函数,也就是通过角色函数,我们可以创建无数的人和狗大战。

人是人类、狗是狗类 通过这样的思想来进行编程就是面向对象的编程思想。从角色和大类入手,上帝视角

比如:
人类,是一个大类,这个大类里面有各种各样的属性,比如吃饭,睡觉,打豆豆这都是共性。
类中还有方法,方法就是一个过程,一个动作,做某件事。
比如:爬山、打篮球。这些都是动作,都应该是一个方法出现;

 

面向过程与面向对象

面向过程的程序设计核心是过程。过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线。

优点:极大的降低了写程序的复杂度,只需要顺着要执行的步骤,堆叠代码即可;
缺点:一套流水线或者流程就是用来解决一个问题,代码牵一发而动全身。

应用场景:一般 bash 脚本都是面向过程思想写出来的,处理流程化事件。


面向对象的程序设计

面向对象的程序设计的核心是对象。

优点:解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。
缺点:可控性差,无法像面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间交互解决问题。

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

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

面向对象编程可以使程序的维护和扩展变得更简单,并且可以大大提高程序开发效率,基于面向对象的程序可以使它人更加容易理解你的代码逻辑。
虽然 面向对象很好用,但是它并没有比面向过程高级,对于不同的应用需求场景采用合适的编程思想才是最重要的。

 

def functionName(args):
    函数体
申明函数
class Data:
    pass
申明类

 

 

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

属性引用(类名.属性)

1
2
3
4
5
class Person:
    role = 'person'
     
    def walk(self):
        print('person is walking...')

 上面代码中 role 是 Person的一个属性,walk 是 Person的方法。

 

print(Person.role)  # 查看人的role属性
print(Person.walk)  # 引用人的走路方法,注意,这里不是在调用

 

 

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

复制代码
class Person:
    def __init__(self, name):
        self.name = name


p = Person('hkey')  # 实例化 Person
print(p.name)

# 执行结果:
# hkey


p = Person('hkey') 就是一个实例化的过程,实例化会自动执行 __init__()方法。
复制代码

 

 

关于 self

self: 在实例化时自动将对象/实例本身传给__init__的第一个参数
复制代码
class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        print(id(self))
        
        
p = Person('hkey', 20, 'male')  # 实例化 Person
print(id(p))

# 执行结果:
# 2074449353472
# 2074449353472
复制代码

通过上面的代码,我们可以查看到 self 和 对象 p 内存空间地址是一致的,印证了上面这句话。

如何查看一个类有哪些属性和方法,可以使用__dict__方法

复制代码
class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


print(Person.__dict__)
p = Person('hkey', 20, 'male')  # 实例化 Person
print(p.__dict__)
复制代码

 

 

对象的相关知识

对象是关于类而实际存在的一个例子,即实例
对象/实例只有一种作用:属性引用

复制代码
class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

p = Person('hkey', 20, 'male')  # 这一步就是实例化一个对象p



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


p = Person('hkey', 20, 'male')  # 实例化 Person

print('name:', p.name)
print('age:', p.age)
print('sex:', p.sex)
print('walk:', p.walk)    # 在类中,方法也是对象。

# 执行结果:

# name: hkey
# age: 20
# sex: male
# walk: <bound method Person.walk of <__main__.Person object at 0x0000024A4E819400>>
对象的使用
复制代码

 

 

这里,我们把之前人狗大战的例子通过面向对象来重写下:

复制代码
class Person(object):
    def __init__(self, name, hp, aggr, job):
        self.name = name
        self.hp = hp
        self.aggr = aggr
        self.job = job

    def hit(self, gg):
        gg.hp -= self.aggr
        print('\033[31;1m%s被打,掉了%s的血。\033[0m' % (gg.name, self.aggr))


class Dog(object):
    def __init__(self, name, hp, aggr, kind):
        self.name = name
        self.hp = hp
        self.aggr = aggr
        self.kind = kind

    def bite(self, p):
        p.hp -= self.aggr
        print('\033[31;1m%s被咬,掉了%s的血。\033[0m' % (p.name, self.aggr))


p = Person('kk', 100, 2, 'it')
teddy = Dog('teddy', 100, 3, 'teddy')

p.hit(teddy)
print(teddy.hp)

teddy.bite(p)
print(p.hp)
人狗大战
复制代码

 

 

可以分析下上面的代码。
1. 我们创建两个类,一个人类,一个狗类
2. 通过实例化,我们创建了两个对象, p 和 teddy
3. 通过p.hit 调用人类的方法时,参数为狗类的对象,这里就是用到了对象的交互。
4. 通过teddy.bite 调用狗类的方法时,参数为人类的对象, 这里就是用到了对象的交互。

 

所以说,面向对象程序一旦开始就由对象之间的交互解决问题。

 

实例化:
    对象 = 类名(参数是__init__方法的参数)

实例 = 对象 完全没区别

对象查看属性:
    对象.属性名
    
对象调用方法:
    对象.方法名(参数)

 

练习:正方形的周长和面积

复制代码
class Squ:
    def __init__(self, length):
        self.length = length

    def per(self):
        return self.length * 4

    def area(self):
        return self.length ** 2


cfx = Squ(20)
print(cfx.per())
print(cfx.area())
正方形的周长和面积
复制代码

 

 

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

创建一个类就会创建一个类的名称空间用来存储类中定义的所有名字,这些名字称为类的属性

而类有两种属性:静态属性和动态属性

  •     静态属性就是直接在类中定义的变量
  •     动态属性就是定义在类中的方法

 

复制代码
class Person:
    language = 'Chinese'
    
    def __init__(self, name, age, job):
        self.name = name
        self.age = age
        self.job = job

hkey = Person('hkey', 20, 'it')
jay = Person('jay', 20, 'singer')
复制代码

 

 

上面的代码中有一个类,实例化出两个对象 hkey 和 jay, 如下图:

 

1. 对象是通过类实例化出来的;
2. 对象和类是单向联系,也就是说,通过对象能够找到类,但是通过类是无法寻找到对象的;
3. 对象共享类中的属性和方法,但是二者之间是相互独立的内存空间

 

复制代码
class Person:
    language = 'Chinese'

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


hkey = Person('hkey', 20, 'it')
jay = Person('jay', 20, 'singer')

print(Person.language)    # 通过类调用静态属性
print(hkey.language)    # 通过对象 hkey 调用静态属性
print(jay.language)        # 通过对象 jay 调用静态属性

# 执行结果:
# Chinese
# Chinese
# Chinese
复制代码

 

 

1. 通过类名调用静态属性,因为静态属性就在类的命名空间中,直接就可以取出使用;
2. 通过对象调用静态属性,首先对象会先在自己的命名空间中寻找 language 属性,如果没有会在类中去寻找 language 类中有则返回
3. 当对象自定义和类中静态属性一样的名称时,对象再次调用时,因为自己命名空间中已经存在,则直接返回。

复制代码
class Person:
    language = 'Chinese'

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


hkey = Person('hkey', 20, 'it')
jay = Person('jay', 20, 'singer')

print(Person.language)
hkey.language = 'English'
print(hkey.language)
print(jay.language)

# 执行结果:
# Chinese
# English
# Chinese
复制代码

 

 

所以,在使用类中静态属性的时候,最好使用 类名.静态属性 调用

 

类中静态属性使用的经典例子:

要求:创建一个类,每次实例化一个对象就记录下来。

复制代码
class Count:
    count = 0
    def __init__(self):
        Count.count += 1
a = Count()
b = Count()
print(a.count)
记录每次实例化
复制代码

 

本文作者:hukey

本文链接:https://www.cnblogs.com/hukey/p/9884156.html

版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   hukey  阅读(376)  评论(0编辑  收藏  举报
💬
评论
📌
收藏
💗
关注
👍
推荐
🚀
回顶
收起
点击右上角即可分享
微信分享提示
  1. 1 彩虹 Jay
彩虹 - Jay
00:00 / 00:00
An audio error has occurred.

彩虹 + 轨迹 (Live) - 周杰伦 (Jay Chou)

彩虹

词:周杰伦

曲:周杰伦

哪里有彩虹告诉我

哪里有彩虹告诉我

能不能把我的愿望还给我

能不能把我的愿望还给我

为什么天这么安静

为什么天这么安静

所有的云都跑到我这里

有没有口罩一个给我

有没有口罩一个给我

释怀说了太多就成真不了

释怀说了太多就成真不了

也许时间是一种解药

也许时间是一种解药

也是我现在正服下的毒药

也是我现在正服下的毒药

看不见你的笑 我怎么睡得着

看不见你的笑 我怎么睡得着

你的声音这么近我却抱不到

你的声音这么近我却抱不到

没有地球太阳还是会绕

没有地球太阳还是会绕

没有理由我也能自己走

没有理由我也能自己走

你要离开 我知道很简单

你要离开 我知道很简单

你说依赖 是我们的阻碍

你说依赖 是我们的阻碍

就算放开 但能不能别没收我的爱

就算放开 但能不能别没收我的爱

当作我最后才明白

当作我最后才明白

看不见你的笑 要我怎么睡得着

看不见你的笑 要我怎么睡得着

你的声音这么近我却抱不到

没有地球太阳还是会绕 会绕

没有理由我也能自己走掉

释怀说了太多就成真不了

也许时间是一种解药 解药

也是我现在正服下的毒药

轨迹

词:黄俊郎

曲:周杰伦

我会发着呆然后忘记你

接着紧紧闭上眼

想着哪一天 会有人代替

想着哪一天 会有人代替

让我不再想念你

我会发着呆 然后微微笑

我会发着呆 然后微微笑

接着紧紧闭上眼

又想了一遍 你温柔的脸

又想了一遍 你温柔的脸

在我忘记之前