初识面向对象-基础篇 （一）

 面向对象引入

# 人狗大战
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 就是对象 有具体的值，属性和技能都是根据类规范的

 初识面向对象

# dict
# d = {'k':'v'}
#
# list
# [1,2]
# print(dict)   # 类
# print(d)      # 对象

# 自定义类
# def 函数名():
#     pass

# class 类名:
#     属性 = 'a'
#
# 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)  # 调用方法 类名.方法名(对象名)

# print(Person.__dict__['country'])
# Person.__dict__['country'] = '印度'
# print(alex.__dict__['name'])
# alex.__dict__['name'] = '二哥'
# print(alex.__dict__)
# print(alex.name)
# print(alex.name)
# alex.name = '二哥'
# alex.__dict__['name'] = '二哥'
# alex.age = 83
# print(alex.__dict__)
# print(alex.name)

# 对象 = 类名()
# 过程：
    # 类名() 首先 会创造出一个对象，创建了一个self变量
    # 调用init方法，类名括号里的参数会被这里接收
    # 执行init方法
    # 返回self
# 对象能做的事：
    # 查看属性
    # 调用方法
    # __dict__ 对于对象的增删改查操作都可以通过字典的语法进行
# 类名能做的事：
    # 实例化
    # 调用方法 : 只不过要自己传递self参数
    # 调用类中的属性,也就是调用静态属性
    # __dict__ 对于类中的名字只能看 不能操作

 练习

# 练习一：在终端输出如下信息
#
# 小明，10岁，男，上山去砍柴
# 小明，10岁，男，开车去东北
# 小明，10岁，男，最爱大保健
# 老李，90岁，男，上山去砍柴
# 老李，90岁，男，开车去东北
# 老李，90岁，男，最爱大保健
# 老张…
def shangshan():
    print('%s,%s岁,%s,上山去砍柴')

def drive():
    print('%s,%s岁,%s,开车去东北')

def favor():
    print('%s,%s岁,%s,最爱大保健')

# shangshan('小明','10','男')
# drive('小明','10','男')

# 非常明显的处理一类事物，这些事物都具有相似的属性和功能
# 当有几个函数 需要反反复复传入相同的参数的时候，就可以考虑面向对象
# 这些参数都是对象的属性
# class Person:
#     def __init__(self,name,age,sex):
#         self.name = name
#         self.age = age
#         self.sex = sex
#     def shangshan(self):
#         print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))
#     def drive(self):
#         print('%s,%s岁,%s,开车去东北'%(self.name,self.age,self.sex))
#     def favor(self):
#         print('%s,%s岁,%s,最爱大保健'%(self.name,self.age,self.sex))
#
# ming = Person('小明','10','男')
# ming.shangshan()
# ming.drive()
# ming.favor()
# zhang = Person('老张','90','男')
# zhang.shangshan()
# zhang.drive()
# zhang.favor()

# circle 属性 半径 ，两个方法：求周长和面积
# 2pir pir**2
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r = r
#     def area(self):
#         return pi*(self.r**2)
#     def perimeter(self):
#         return 2*pi*self.r
#
# c1 = Circle(6)
# print(c1.area())
# print(c1.perimeter())

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

# 正方形 周长和面积
# 完成上午的作业 人狗大战
# 默写 4.交互文件

复习总结

# 定义类
    # class
    # 函数 ： 方法   动态属性  # 类中可以定义方法，方法都有一个必须传的参数self
    # 变量 ： 类属性 静态属性  # 类中可以定义静态属性
# __init__方法 初始化方法
    # python帮我们创建了一个对象self
    # 每当我们调用类的时候就会自动触发这个方法。默认传self
    # 在init方法里面可以对self进行赋值
# self是什么 self拥有属性都属于对象
    #在类的内部，self就是一个对象
    # alex = Person()
    # alex.walk == Person.walk(alex)
# 实例化
#     对象 = 类(参数是init方法的)
# 实例、对象     完全没有区别
# 对象查看属性
    # 对象.属性名
# 对象调用方法
    # 对象.方法名(参数)    #类名.方法名(对象名，参数)
# 正方形 周长和面积
# class Square:
#     def __init__(self,side_len):
#         self.side_len = side_len
#     def perimeter(self):
#         return self.side_len * 4
#     def area(self):
#         return self.side_len ** 2
# s = Square(5)
# s.perimeter()
# s.area()
# 完成上午的作业 人狗大战

# python入门
# 需求 能翻译成python语言

# 面向对象入门
# 当你见到一个需求 你能分析出这个问题适不适合用面向对象解决
# 如果适合 你能有一些想

# 一定要选好最适合的编程方式