一：面向对象的初识

一：面向对象

def Person(name,hp,ad,sex):         # 模子
    dic = {'name':name,'blood':hp,'attack':ad,'sex':sex}

    def fight(dog):             # 攻击  属于人
        dog['blood'] -= dic['attack']   # 狗掉血，就是人的攻击力
        print('%s打了%s，%s掉了%s血' % (dic['name'], dog['name'], dog['name'], dic['attack']))
    
    dic['fight'] = fight
    return dic

def Dog(name,hp,ad,kind):
    dic = {'name': name, 'blood': hp, 'attack': ad, 'kind': kind}

    def bite(person):           # 咬 属于狗
        person['blood'] -= dic['attack']
        print('%s咬了%s，%s掉了%s血' % (dic['name'], person['name'], person['name'], dic['attack']))

    dic['bite'] = bite
    return dic

# 互相打
ivan = Person(' ivan ',20,1,'不详')
print(alex)
hei = Dog('小黑',3000,10,'哈士奇')
print(hei)

ivan ['fight'](hei)
hei['bite']( ivan)     狗咬人，def bite(person):不用传dog，（不需要传其它的）

通过两个模子 捏出两个具体的角色
抽象 ：只能知道有哪些属性
具体 ：可以描述他的属性的值的

给两个特定的属于特定角色的方法 设置了他的使用范围
让其他角色不能随意调用属于固定角色的方法

1 先思考这个程序中有几个角色
2 然后描述这个角色 属性和动作
3 把这个属性和动作都装到一个角色中
4 面向对象编程

二：面向对象语法

对象 ：具有具体的属性值的实际存在的例子        实例
类 ：具有相同方法和属性的一类事物

class Dog:
    变量 = 1000
    变量2 = 'abc'
    变量3 = [(1,2),(3,4)]

查看类当中的变量，方法一
print(Dog.__dict__['变量'])               # Dog.__dict__ 生成一个字典
print(Dog.__dict__['变量2'])
print(Dog.__dict__['变量3'])
查看方法二（常用）
print(Dog.变量)
print(Dog.变量2)
print(Dog.变量3)

每一只狗都需要有自己的属性
class Dog:          # 狗模子  -- 类
    a = 1000        # 静态变量 这个类中的变量 是所有的对象共享的值
    def __init__(self,name,hp,ad,sex):   # init自动传进去，自动把self return回来
        print('执行我啦')
        self.__dict__['name'] = name
        self.__dict__['blood'] = hp
        self.__dict__['ad'] = ad
        self.__dict__['sex'] = sex
        print(self.__dict__)    # 上面所有的都进入到了这个字典


ivan = Dog(' ivan ',20,10,'不详')      # 具体的狗 对象 实例化的过程
ivan = Dog(' ivan ',20,10,'不详')
print(ivan.__dict__['name'])
print(ivan.__dict__['blood'])

# 对象 也是实例
# 创建一个对象也是创建实例



# 狗对象都是一个内存空间（字典）
# self实际上是由python的语法 开辟了一个属于具体的对象的空间
# 执行init,向self这块空间管理的字典中添加一些key value  ，self会自动的被返回


# 实例化的过程 ：
    1.开辟了一块空间，创造了一个self变量来指向这块空间
    2.调用init,自动传self参数，其他的参数都是按照顺序传进来的
    3.执行init
    4.将self自动返回给调用者


# ivan 就等于 self ，self返回的字典给Ivan，可以直接使用ivan内部的字典属性，直接加.就可以

class Dog:
    def __init__(self,name,hp,ad,kind):      # 初始化方法
        self.name = name                    # 实例变量   对象属性
        self.blood = hp
        self.ad = ad        # 左边ad相当于键，右边ad相当于值，使用时候是写左边的键
        self.type = kind

class Person:
    a = 1000                                # 静态变量  用类名调用
    def __init__(self,name,hp,ad,sex):        # 初始化方法
        self.name = name                     # 实例变量   对象属性
        self.blood = hp
        self.ad = ad
        self.sex = sex

    def fight(self,dog):                # 动态变量    类方法
        dog.blood -= self.ad            # 狗掉血，就是人的攻击力
        print('%s攻击了%s，%s掉了%s点血'%(self.name,dog.name,dog.name,self.ad))

ivan = Dog(' ivan ',20,10,'不详')           # ivan 对象 实例
大亮 = Person('大亮',300,20,'male')         # 大亮 对象 实例
print( ivan.blood)
大亮.fight(ivan)                  # 相当于  Person.fight(大亮, ivan)
print(ivan.blood)



1.类名可以调用所有定义在类中的名字
    变量  : a
    函数名  : def fight             (init初始化方法是自动调用)
        
2.对象名  
可以调用所有定义在对象中的属性
在init函数中 和 self相关的

# 调用函数的，且调用函数的时候，会把当前的对象当做第一个参数传递给self

三：清晰的面向对象例子

class Dog:
    def __init__(self,name,blood,ad,kind):
        self.name = name        # 向对象的内存空间中添加属性
        self.hp = blood         # 可以通过self在类的内部完成 
        self.ad = ad
        self.kind = kind

    def bite(self,person):
        person.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血' % (self.name, person.name, person.name, self.ad))

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

    def fight(self,dog):
        dog.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血'%(self.name,dog.name,dog.name,self.ad))

        
hei = Dog('小黑',300,20,'哈士奇')
ivan = Person(' ivan ',20,1,'不详')
ivan.fight(hei)
print(hei.hp)
hei.bite(ivan)
print(ivan.hp)

class Dog:
    def __init__(self,name,blood,ad,kind):
        self.name = name        # 向对象的内存空间中添加属性
        self.hp = blood         # 可以通过self在类的内部完成
        self.ad = ad
        self.kind = kind

hei = Dog('小黑',300,20,'哈士奇')
hua = Dog('小花',400,30,'萨摩耶')
print(hei.name)     # 小黑
print(hei.ad)       #  20
print(hei.kind)     # 哈士奇

hei.food = '单身狗粮'       # 也可以通过对象名在类的外部完成修改
hei.hp = 305               # 也可以在类的外部通过对象名来修改属性的值

print(hei.__dict__)  # {'name': '小黑', 'hp': 305, 'ad': 20, 'kind': '哈士奇', 'food': '单身狗粮'}
print(hei.hp)        # 305
print(hei. __dict__[‘hp’])   # 305
del hei.hp                  # 删除属性
print(hei.__dict__) # {'name': '小黑', 'ad': 20, 'kind': '哈士奇', 'food': '单身狗粮'}

# self 就是 谁实例它，就是谁

# 圆形类
# 属性 ：半径
# 方法 ：计算周长(2pir) 计算面积(pir^2)

from math import pi
print(pi)

class Circle:
    def __init__(self,r):      
        self.r = r
    def area(self):
        return pi * self.r**2
    def perimeter(self):
        return 2*self.r*pi
    
c1 = Circle(5)
c2 = Circle(15)
print(c1.area())
print(c1.perimeter())
print(c2.area())
print(c2.perimeter())

一切皆对象 ，所有的变量都是对象，是什么数据类型就是哪个对象
list 类
[1,2,3] 对象

int 数据类型
a = 1

dict
{'k':'v'}

# 数据类型 也是类
# 对象 就是具体的数字

所以有的列表都能够使用列表的方法
所以有的数字都能够使用列表的方法

四：练习

# 长方形 Rectangle               # 正方形 Square       # 圆形 circular
# 平行四边形 Parallelogram       # 三角形 Triangle
# 边长 Side length               # 高 high

# 长方形
class Rectangle:
    def __init__(self,long,wide):
        self.long=long
        self.wide=wide
    def area(self):
         return self.long*self.wide
    def perimeter(self):
         return self.long*2+self.wide*2

r1=Rectangle(2,3)
print(r1.area())        # 6
print(r1.perimeter())   # 10

# 正方形
class Square:
    def __init__(self,long):
        self.long=long
    def area(self):
         return self.long*self.long
    def perimeter(self):
         return self.long*4

r1=Square(2)
print(r1.area()) # 4 
print(r1.perimeter()) #8


# 平行四边形  底bottom  高high  斜边 hypotenuse
# 周长＝2（底边+斜边）   # 面积＝底*高
class Parallelogram:
    def __init__(self,bottom,high,hypotenuse):
        self.bottom=bottom
        self.high=high
        self.hypotenuse=hypotenuse
    def area(self):
         return self.bottom*self.high
    def perimeter(self):
         return (self.bottom+self.hypotenuse)*2

r1=Parallelogram(2,3,4)
print(r1.area())  # 6 
print(r1.perimeter()) #12


# 三角形  底bottom     高high  斜边 long
# 周长＝long *3        # 面积＝底*高/2
class Triangle:
    def __init__(self,bottom,high,long):
        self.bottom=bottom
        self.high=high
        self.long=long
    def area(self):
         return self.bottom*self.high/2
    def perimeter(self):
         return self.long*3

r1=Triangle(2,3,4)
print(r1.area())  # 3.0
print(r1.perimeter())  # 12

# 圆形
from math import pi
print(pi) # 3.141592653589793
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi * self.r**2
    def perimeter(self):
        return 2*self.r*pi

c1 = Circle(5)
c2 = Circle(15)

print(c1.area())        # 78.53981633974483
print(c1.perimeter())   # 31.41592653589793
print(c2.area())        # 706.8583470577034
print(c2.perimeter())   # 94.24777960769379

五：总结

几十个函数
去查看和圆形相关的方法是需要一定时间找到对应方法的
不管求圆形周长还是面积，都需要传参数r
所有的函数都是求周长和面积，导致给函数起名字的时候总是要带着图形

面向对象的优点
规划了代码中的函数处理的是哪一类问题
解决了传参数的问题
方便扩展
方便重用

类 ：有相同特征的事物归为一类
对象、实例 ：类的具体化

实例化 ：通过类创造一个对象的过程
    对象 = 类名(参数，参数)
    1.开辟一块内存空间，让self指向它
    2.调用__init__方法,执行init
    3.把self返回给调用者

    
类当中有哪些成员：        静态变量 ；动态变量，对象方法
对象可以存哪些方法：      所有的对象属性都在对象里
类名能做什么：           查看静态变量；实例化对象
对象名能做什么：         属性的增删改查；方法的调用

定义类
class 类名:
    静态变量 = 1000
    def __init__(self,arg1,arg2):
        if arg1<=arg2:
            self.arg1 = arg1
            self.arg2 = arg2
        else:
            self.arg1 = arg2
            self.arg2 = arg1
    def 其他方法(self):
        print('其他方法往往是类名对应的对象所做的动作、行为')
        print('往往还会用到self内部的一些变量')

对象1 = 类名(1,2)
对象2 = 类名(3,4)