python之面向对象

Posted 2020-12-31 3DX2Y

一、面向对象初识

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

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)

对象组合