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. 操作方法，一般不通过类名操作

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

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

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

# 类名

    # 1.查看类中所有的属性及方法 __dict__

print(Person.__dict__)
print(Person.__dict__['animal'])  # 通过__dict__方式 单独的属性及方法可以查但是不能增删改
# 工作中，学习中一般用到__dict__ 就是查看类中所有的属性及方法，不进行其他操作。

    # 2.查看,（增删改）类中某个，某些属性，某个方法，用万能的点 .
print(Person.animal)  # 查
print(Person.language)
Person.name = 'alex'    # 增
print(Person.name)
Person.animal = '低级动物'  # 改。虽然上面没改，但是在内存级别已经改动了
print(Person.animal)
# del Person.walk_way  # 删

    # 3.操作方法 一般不通过类名操作
# Person.__dict__['work'](888)   # 不建议__dict__执行方法
Person.work(999)
Person.eat(999)

对象的使用：

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

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

1. 在内存中开辟了一个对象空间
2. 自动执行类中的 __init__ 方法，并且将对象空间传给self参数，其他参数手动传入
3. 执行 __init__ 方法，给对象空间封装相应的属性。

class Person:
    animal = '高级动物'
    walk_way = '直立行走'
    language = '语言'

    def __init__(self,name,age):  # 功能：给对象封装属性
        print(self)  # self = Person() 地址是一样的
        print(666)
        self.name1 = name
        self.age1 = age

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

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


obj = Person('alex', 37)  # 这个过程是一个实例化过程，它会实例化一个对象。（它会在内存实例化一个对象空间）
print(obj)
print(obj.name1)

class Person:
    animal = '高级动物'
    walk_way = '直立行走'
    language = '语言'

    def __init__(self,name,age):  # 功能：给对象封装属性
        print(self)  # self = Person() 地址是一样的
        print(666)
        self.name1 = name
        self.age1 = age

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

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

obj = Person('alex', 37)
# 对象：
#     对象操作对象空间
#         对象查看对象空间的所有属性 __dict__
print(obj.__dict__)
        # 对象操作对象的某个属性 增删改查  万能的点 .
obj.sex = 'nan'  # 增
print(obj.__dict__)
# del obj.sex  # 删
obj.age1 = 99  # 改
print(obj.__dict__)
print(obj.name1)  # 查

#     对象操作类空间的属性  只能查
print(obj.animal)


#     对象操作类空间的方法
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__ ， 任意位置

三、对象组合

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

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

以下面的例子来讲解

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

　　

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

    def attack(self, role):
        role.hp = role.hp - self.ad
        print('%s攻击%s,%s掉了%s血,  还剩%s血' % (self.nickname, role.nickname, role.nickname, self.ad, role.hp))

    def equip_weapon(self, w):  # 给人物封装了一个武器属性，这个属性值是Weapon这个类的一个对象
        self.weapon = w


class Weapon:
    def __init__(self, name, ad):
        self.name = name
        self.ad = ad

    def fight(self, role1, role2):
       role2.hp = role2.hp - self.ad
       print('%s 用 %s 攻击了%s, %s掉了 %s 血，还剩%s血' %
             (role1.nickname, self.name, role2.nickname, role2.nickname,self.ad, role2.hp))


p1 = Gamerole('盖伦', 20, 500)
p2 = Gamerole('剑豪', 100, 200)
# p1.attack(p2)
w1 = Weapon('大宝剑', 30)
w2 = Weapon('武士刀', 80)
print(w1)
p1.equip_weapon(w1)
print(p1.weapon)  # 其实它就是 w1 地址一样
# w1.fight(p1, p2)
p1.weapon.fight(p1, p2)