python之面向对象

Posted 3DX2Y

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python之面向对象相关的知识,希望对你有一定的参考价值。

一、面向对象初识

从结构上理解:面向对象分为两部分

class A:
    name = \'alex\'  # 静态属性,静态变量,静态字段。

    def func1(self):  # 函数,动态属性,方法
        pass

 

函数vs面向对象:

  1. 函数封装一个功能,而面向对象封装多个相关功能。
  2. 面向对象抽象,它是一种思想,站在上帝的角度去理解它。
  3. 程序可扩展,对象都是一个个独立的。耦合性,差异性。
def ragister(argv):
    pass


def login(argv):
    pass


def shoppingcar(argv):
    pass
函数
class Shopping_Car:

    def __init__(self):   # 特殊方法
        pass

    def ragister(self):
        pass

    def login(self):
        pass

    def shoppingcar(self):
        pass
面向对象

类以及对象:

类:具有相同属性或功能的一类实物

对象:对象是类的具体体现。

 

二、类名与对象的使用

首先,先来定义一个类

# 一个公共框架,一个公共模型
class Person:
    animal = \'高级动物\'
    walk_way = \'直立行走\'
    language = \'语言\'

    def eat(self):
        print(\'吃饭\')

    def work(self):
        print(\'工作\')

  

类名的使用:

  1. 查看类中的所有属性及方法 __dict__
  2. 查看,(增删改)类中的某个,某些属性,某个方法,用万能的点 "."
  3. 操作方法,一般不通过类名操作
 1 # 一个公共框架,一个公共模型
 2 class Person:
 3     animal = \'高级动物\'
 4     walk_way = \'直立行走\'
 5     language = \'语言\'
 6 
 7     def eat(self):
 8         print(\'吃饭\')
 9 
10     def work(self):
11         print(\'工作\')
12 
13 # 类名
14 
15     # 1.查看类中所有的属性及方法 __dict__
16 
17 print(Person.__dict__)
18 print(Person.__dict__[\'animal\'])  # 通过__dict__方式 单独的属性及方法可以查但是不能增删改
19 # 工作中,学习中一般用到__dict__ 就是查看类中所有的属性及方法,不进行其他操作。
20 
21     # 2.查看,(增删改)类中某个,某些属性,某个方法,用万能的点 .
22 print(Person.animal)  #
23 print(Person.language)
24 Person.name = \'alex\'    #
25 print(Person.name)
26 Person.animal = \'低级动物\'  # 改。虽然上面没改,但是在内存级别已经改动了
27 print(Person.animal)
28 # del Person.walk_way  # 删
29 
30     # 3.操作方法 一般不通过类名操作
31 # Person.__dict__[\'work\'](888)   # 不建议__dict__执行方法
32 Person.work(999)
33 Person.eat(999)
类名的使用

 

对象的使用:

  1.  对象查看对象空间的所有属性 __dict__
  2. 对象操作对象的某个属性,增删改用万能的点 "."
  3. 对象操作类空间的属性 只能查
  4. 对象操作类空间的方法

实例化过程内部进行了三个阶段:

  1. 在内存中开辟了一个对象空间
  2. 自动执行类中的 __init__ 方法,并且将对象空间传给self参数,其他参数手动传入
  3. 执行 __init__ 方法,给对象空间封装相应的属性。
 1 class Person:
 2     animal = \'高级动物\'
 3     walk_way = \'直立行走\'
 4     language = \'语言\'
 5 
 6     def __init__(self,name,age):  # 功能:给对象封装属性
 7         print(self)  # self = Person() 地址是一样的
 8         print(666)
 9         self.name1 = name
10         self.age1 = age
11 
12     def eat(self):
13         print(\'吃饭\')
14 
15     def work(self):
16         print(\'工作\')
17 
18 
19 obj = Person(\'alex\', 37)  # 这个过程是一个实例化过程,它会实例化一个对象。(它会在内存实例化一个对象空间)
20 print(obj)
21 print(obj.name1)
实例化过程
 1 class Person:
 2     animal = \'高级动物\'
 3     walk_way = \'直立行走\'
 4     language = \'语言\'
 5 
 6     def __init__(self,name,age):  # 功能:给对象封装属性
 7         print(self)  # self = Person() 地址是一样的
 8         print(666)
 9         self.name1 = name
10         self.age1 = age
11 
12     def eat(self):
13         print(\'吃饭\')
14 
15     def work(self):
16         print(\'工作\')
17 
18 obj = Person(\'alex\', 37)
19 # 对象:
20 #     对象操作对象空间
21 #         对象查看对象空间的所有属性 __dict__
22 print(obj.__dict__)
23         # 对象操作对象的某个属性 增删改查  万能的点 .
24 obj.sex = \'nan\'  #
25 print(obj.__dict__)
26 # del obj.sex  # 删
27 obj.age1 = 99  #
28 print(obj.__dict__)
29 print(obj.name1)  #
30 
31 #     对象操作类空间的属性  只能查
32 print(obj.animal)
33 
34 
35 #     对象操作类空间的方法
36 obj.eat()
对象的使用

 

三、类名称空间,对象名称空间

1.对象为什么能调用类中的属性与方法?

  obj.属性名  先从自己空间去找,没有此属性它会通过类对象指针从类中去找,类中找不到,会从父类去找。

  对象只能查看类中的属性,不能增删改类中的属性。

2.类能不能调用对象的属性?

  不能

3.对象与对象之间可以不可以互相调用?

  同一个类实例化出来的对象是不能互相访问的。

  但是不同类形成的实例化对象有可能互相访问。

 

类与对象空间:

 

 

 

class GameRole:

    rule = \'游戏规则\'

    def __init__(self,area,nickname,hp,ad):
        self.area = area
        self.nickname = nickname
        self.hp = hp
        self.ad = ad

    def attack(self):
        print(\'谁施展了一个攻击\')


gailun = GameRole(\'德玛西亚\', \'草丛伦\', 1000, 75)
yasuo = GameRole(\'艾欧尼亚\', \'托儿所\', 500, 150)
# 1.对象为什么能调用类中的属性与方法
# obj.属性名  先从自己空间去找,没有此属性它会通过类对象指针从类中去找,类中找不到,会从父类去找。

print(gailun.hp)
gailun.attack = 666  # 给对象增加属性
print(gailun.attack)  # 666

gailun.rule = gailun.rule
print(gailun.rule)   # 游戏规则
gailun.nickname = \'盖伦\'
print(gailun.nickname)
# 对象只能查看类中的属性,不能增删改类中的属性



# 2. 类能不能调用对象的属性?  不能
# print(GameRole.area)  不能

# 3. 对象与对象之间可不可以互相调用
# 同一个类实例化出来的对象是不能互相访问的。
# 但是不同类形成的实例化对象有可能互相访问。


# 给对象封装属性: __init__ , 任意位置
View Code

 

三、对象组合

组合:给一个类的对象封装一个属性,这个属性是另一个类的对象。

组合的意义:让类的对象与另一个类的对象产生关系,类与类之间产生关系。

以下面的例子来讲解

# 3,模拟英雄联盟写一个游戏人物的类(升级题).
#   要求:
#   (1)创建一个 Game_role的类.
#   (2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性.
#   (3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能:
#       例: 实例化一个对象 盖伦,ad为10, hp为100
#       实例化另个一个对象 剑豪 ad为20, hp为80
#       盖伦通过attack方法攻击剑豪,此方法要完成 \'谁攻击谁,谁掉了多少血,  还剩多少血\'的提示功能.

  

 1 class Gamerole:
 2     def __init__(self, nickname, ad, hp):
 3         self.nickname = nickname
 4         self.ad = ad
 5         self.hp = hp
 6 
 7     def attack(self, role):
 8         role.hp = role.hp - self.ad
 9         print(\'%s攻击%s,%s掉了%s血,  还剩%s血\' % (self.nickname, role.nickname, role.nickname, self.ad, role.hp))
10 
11     def equip_weapon(self, w):  # 给人物封装了一个武器属性,这个属性值是Weapon这个类的一个对象
12         self.weapon = w
13 
14 
15 class Weapon:
16     def __init__(self, name, ad):
17         self.name = name
18         self.ad = ad
19 
20     def fight(self, role1, role2):
21        role2.hp = role2.hp - self.ad
22        print(\'%s 用 %s 攻击了%s, %s掉了 %s 血,还剩%s血\' %\\
23              (role1.nickname, self.name, role2.nickname, role2.nickname,self.ad, role2.hp))
24 
25 
26 p1 = Gamerole(\'盖伦\', 20, 500)
27 p2 = Gamerole(\'剑豪\', 100, 200)
28 # p1.attack(p2)
29 w1 = Weapon(\'大宝剑\', 30)
30 w2 = Weapon(\'武士刀\', 80)
31 print(w1)
32 p1.equip_weapon(w1)
33 print(p1.weapon)  # 其实它就是 w1 地址一样
34 # w1.fight(p1, p2)
35 p1.weapon.fight(p1, p2)
对象组合

 

以上是关于python之面向对象的主要内容,如果未能解决你的问题,请参考以下文章

VSCode自定义代码片段——JS中的面向对象编程

VSCode自定义代码片段9——JS中的面向对象编程

PHP面向对象之选择工厂和更新工厂

python基础之面向对象

Python之面向对象:面向对象基础

python之面向对象编程一