笔记：python基础之面向对象初识

面向过程：程序设计的核心是过程（流水线式思维），一般用于小脚本。
面向对象：核心是对象，要理解对象为何物，适合复杂得程序。思想 ：角色的抽象,创建类，创建角色（实例化），操作这些实例

先有类才有对象，类为一个模子，对象为具体。
类与对象，举例：dict——类，d = {‘k’:‘v’}——对象；list——类，[1,2]——对象。

所有的类相关的内容

• 定义类
• init方法
• self是什么 self拥有属性都属于对象
• 类中可以定义静态属性
• 类中可以定义方法，方法都有一个必须传的参数self
• 实例化
• 实例、对象
• 对象查看属性
• 对象调用方法

考虑使用面向对象的情况：

• 当有几个函数，需要反反复复传入不同的参数的时候，就可以考虑面向对象，这些参数都是对象的属性；
• 非常明显的处理一类食物，这些食物都具有相似的属性和功能。

自定义类
类名的作用 就是操作属性 查看属性
格式

 def 函数名():
            pass
            
class 类名:
     静态属性 = 'aaa'
     def __init__(self):pass
print(类名.属性)

创建类，举例说明

class Person:                 # 类名
    country = 'China'         # 创造了一个只要是这个类就一定有的属性
                               # 类属性 静态属性
    def __init__(self,*args):  # 初始化方法，self是对象，是一个必须传的参数
        # self就是一个可以存储很多属性的大字典
        self.name = args[0]   # 往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]

    def walk(self,n):         # 方法，一般情况下必须传self参数，且必须写在第一个
                               # 后面还可以传其他参数，是自由的
        print('%s走走走,走了%s步'%(self.name,n))

创建对象

print(Person.country)        # 类名 可以查看类中的属性，不需要实例化就可以查看
alex = Person('狗剩儿',100,1,'不详')  # 类名还可以实例化对象，alex对象   # 实例化
print(alex.__dict__) # 查看所有属性
print(alex.name)  # 查看属性值
print(alex.hp)  # 查看属性值
alex.walk(5)    # Person.walk(alex，5)  # 调用方法 类名.方法名(对象名)

#输出：
China
{'sex': '不详', 'name': '狗剩儿', 'aggr': 1, 'hp': 100}
狗剩儿
100
狗剩儿走走走,走了5步

修改属性

#修改静态属性
print(Person.__dict__['country'])
Person.__dict__['country'] = '印度'    #不能直接修改静态属性

#修改对象属性，按属性字典修改
print(alex.__dict__['name'])
alex.__dict__['name'] = '二哥'
print(alex.__dict__)
print(alex.name)
#输出：
狗剩儿
{'sex': '不详', 'name': '二哥', 'aggr': 1, 'hp': 100}
二哥

#修改对象属性，直接调用属性进行修改
alex.name = '二哥'
alex.__dict__['name'] = '二哥'
alex.age = 83
print(alex.__dict__)
print(alex.name)
#输出：
{'sex': '不详', 'name': '二哥', 'aggr': 1, 'hp': 100, 'age': 83}
二哥

实例化：对象 = 类名()
过程：

• 类名() 首先 会创造出一个对象，创建了一个self变量
• 调用init方法，类名括号里的参数会被这里接收
• 执行init方法
• 返回self

对象能做的事：

• 查看属性
• 调用方法
• __dict__ 对于对象的增删改查操作都可以通过字典的语法进行

类名能做的事：

• 实例化
• 调用方法 : 只不过要自己传递self参数
• 调用类中的属性,也就是调用静态属性
• __dict__ 对于类中的名字只能看 不能操作

应用举例1
人狗大战

def Dog(name,blood,aggr,kind):
    dog = {
        'name': name,
        'blood': blood,  # 血量
        'aggr': aggr,  # 攻击力
        'kind': kind,
    }
    def bite(person):
        person['blood'] -= dog['aggr']
        print('%s被咬了，掉了%s的血' % (person['name'], dog['aggr']))
    dog['bite'] = bite
    return dog

def Person(name,blood,aggr,sex):
    person = {
        'name' : name,
        'blood': blood,   # 血量
        'aggr': aggr,      # 攻击力
        'sex':sex,
    }
    def attack(dog):
        dog['blood'] -= person['aggr']
        print('%s被打了，掉了%s的血' % (dog['name'], person['aggr']))
    person['attack'] = attack
    return person

# 代码精简了 方便增加人物 方便修改 人物更加规范  —— 人模子

jin = Dog('金老板',1000,100,'teddy')
alex = Person('狗剩儿',100,1,'不详')
# nezha = Person('哪吒',200,2,'不详')
print(jin)
jin['bite'](alex)
alex['attack'](jin)
# Dog函数和Person函数 都是定义了一类事物
# 直到调用了函数，赋值了之后才真的有了一个实实在在的人或狗

# 面向对象编程
# 所谓模子 就是 类 抽象的 我能知道有什么属性 有什么技能 但不能知道属性具体的值
# jin alex nezha 就是对象 有具体的值，属性和技能都是根据类规范的

#输出：
{'blood': 1000, 'name': '金老板', 'aggr': 100, 'kind': 'teddy', 'bite': <function Dog.<locals>.bite at 0x0000000004E79268>}
狗剩儿被咬了，掉了100的血
金老板被打了，掉了1的血

定义类和调用类及类方法
人狗大战升级

class Dog:
    def __init__(self,name,blood,aggr,kind):
        self.name = name
        self.hp = blood
        self.aggr = aggr
        self.kind = kind
    def bite(self,person):
        # 狗咬人，人掉血
        person.blood -= self.aggr

class Person:
    contry='china'#静态属性，不会因为不同实例而变化
    def __init__(self,name,blood,aggr,sex):
        self.name = name
        self.blood = blood
        self.aggr = aggr
        self.sex = sex
    def attack(self,dog):#这里的函数被称为方法，必须传self参数，并且只能传一个，后面还可以传其他参数，是自由的
        dog.hp -= self.aggr
        if dog.hp <= 0:
            print('%s打了%s,%s被打死了，扑街~~~'%(self.name,dog.name,dog.name))
        else:
            print('%s打了%s,掉了%s血'%(self.name,dog.name,self.aggr))

jin = Dog('金老板',100,20,'teddy')#实例化
# print(jin.name)
alex = Person('alex',999,998,'不详')
jin.bite(alex)   # Dog.bite(jin,alex)#调用方法：类名.方法名（对象）
#这里的alex就是attack函数里的dog参数
print(alex.blood)
# alex attack
alex.attack(jin)  # Person.attack(alex,jin)
print(jin.hp)

#输出：
979
alex打了金老板,金老板被打死了，扑街~~~
-898

应用举例2
用类来解决：知道圆的半径，计算面积或者周长

class Circle:
    def __init__(self,r):
        self.r=r
    def area(self):
        s=3.14*(self.r**2)
        return(s)
    def length(self):
        c=2*3.14*(self.r)
        return(c)
circle=Circle(3)
print('周长为',circle.area())

#这里可做组合的练习，给出两圆形的半径，计算其组成圆环的面积和周长
class Ring:
    def __init__(self,outside_r,inside_r):
        self.outside=Circle(outside_r)
        self.inside=Circle(inside_r)
    def area(self):
        return (self.outside.area()-self.inside.area())
    def length(self):
        return (self.inside.length()+self.inside.length())

ring=Ring(20,10)
print('====圆环形===')
print('圆环面积：',ring.area())
print('圆环周长',ring.length())

#输出：
周长为 18.84
====圆环形===
圆环面积： 942.0
圆环周长 125.60000000000001

类-组合：在一个对象的属性值是另外一个类的实例化对象，什么有什么的关系

人狗大战再升级

class Dog:
    def __init__(self,name,aggr,hp,kind):
        self.name=name
        self.aggr=aggr
        self.hp=hp
        self.kind=kind
    def bite(self,person):#攻击
        person.hp-=self.aggr
    

class Person:
    def __init__(self,name,aggr,hp,sex):
        self.name=name
        self.aggr=aggr
        self.hp=hp
        self.sex=sex
        self.money=0#默认值
    def hit(self,dog):
        dog.hp-=self.aggr
    def get_wapoon(self,wap):
        if self.money>=wap.price:
            self.money-=wap.price
            self.aggr+=wap.aggr
            self.hp+=wap.hp
            self.wapoon=wap#组合，就把武器的类加到了person里，后面就可以直接调用
        else:
            print('余额不足，请充值')
#武器类
class Wapoon:
    def __init__(self,name,aggr,hp,price):
        self.name=name
        self.aggr=aggr
        self.price=price
        self.hp=hp
    def attack(self,person):
        person.hp-=self.aggr

Alex=Person('Alex',0.5,100,'男')
Jack=Dog('Jack',50,90,'不详')
w=Wapoon('打狗棒',10,300,900)
print('Jack血量:',Jack.hp)
print('Alex血量：',Alex.hp)

print('=====第一回合=====')
Alex.hit(Jack)
Jack.bite(Alex)
print('Jack血量:',Jack.hp)
print('Alex血量：',Alex.hp)

print('=====第二回合：人买装备=====')
Alex.money+=1000#充值
Alex.get_wapoon(w)
Alex.hit(Jack)#人本身的攻击
Alex.wapoon.attack(Jack)#人使用武器，注意这里调用的是wapoon这个类里的技能
Jack.bite(Alex)
print('Jack血量:',Jack.hp)
print('Alex血量：',Alex.hp)

#输出：
Jack血量: 90
Alex血量： 100
=====第一回合=====
Jack血量: 89.5
Alex血量： 50
=====第二回合：人买装备=====
Jack血量: 69.0
Alex血量： 300

总结：

1. 类名.静态属性 —— 存储在类的命名空间里
2. 对象 = 类名() →实例化：创造了一个self对象，执行init方法，返回self对象给外部
3. 对象.属性
4. 对象.方法 → 类名.方法(对象)
5. 对象可以使用静态变量
6. 类不可以使用对象里的属性