面向对象初识

 

人狗大战
角色 : 人 狗
人 ：
    名字
    性别
    血量    hp
    攻击力  ad
狗
    名字
    品种
    血量
    攻击力
def Person(name,sex,hp,ad):
    创造了一个模子
    约束了一个人必须拥有的属性
    规范了这些属性的名字
    简化了用户的操作
def Person(name,sex,hp,ad):
    person = {
        'name': name,
        'sex': sex,
        'hp': hp,
        'ad': ad
    }
    def attack(dog):  # 人攻击狗
#         # 狗掉血，是人的攻击力
#         # 狗的血 人的攻击力
        print('%s攻击了%s' % (person['name'], dog['name']))
        dog['hp'] -= person['ad']
        print('%s掉了%s点血，%s剩余血量%s' %
              (dog['name'], person['ad'], dog['name'], dog['hp']))
    person['attack'] = attack
    return person

def Dog(name,kind,hp,ad):
    dog = {
        'name': name,
        'kind': kind,
        'hp': hp,
        'ad': ad
    }
    def bite(person):  # 狗咬人
        print('%s咬了%s' % (dog['name'], person['name']))
        if person['hp'] <= dog['ad']:
            person['hp'] = 0
            print('%s剩余血量已为0，game over' % person['name'])
        else:
            person['hp'] -= dog['ad']
            print('%s掉了%s点血，%s剩余血量%s' % (person['name'], dog['ad'], person['name'], person['hp']))
    dog['bite'] = bite
    return dog
alex = Person('alex',None,10,1)
egon = Person('egon',None,20,2)
taibai= Dog('哮天犬','teddy',100,50)
alex['attack'](taibai)
taibai['bite'](alex)

面向对象的思路：
不着急直接去计算/操作代码获取结果
从一个大的问题中  找到要描述的角色
将角色的属性和行为抽象出来形成一个模子
后期用到角色的时候，都围绕这个模子来操作
类：一类抽象的事物，(具有相同的属性和技能的一类事物)是描述一类事务有哪些属性或者行为，但是不具体——模子
（规范了属性的个数和名字）
实例=对象：就是一个依托于类的规范存在的，被赋予了具体属性值的实际存在的物体
（给类中约束的属性赋了具体的值）
实例化：有一个类产生一个对象/实例的过程
（创建对象的过程，对象=类名（）。 ）
创造一个函数   用 def
创造一个类   用 class
类中写的所有的静态属性和动态属性都是所有对象共享的
在self空间中或者在实例化之后的对象的空间中定义的变量都是属于某个对象的
实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
class Person:  #定义一个人类:
        level = " 高级动物 "    #静态变量(静态字段)（是所有的对象共享的一个属性）
    Country = 'China'   #静态变量(静态字段)（是所有的对象共享的一个属性）
    def func(self):   #动态方法(函数)
        print(123)

class Person:
    Country = 'China'
    def __init__(self,name,sex,hp,ad):
        print('self-->',self)
obj = Person('alex',None,10,1)
print('obj -->',obj)

类名称空间与对象的名称空间:
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性
而类有两种属性：静态属性和动态属性
静态属性就是直接在类中定义的变量
动态属性就是定义在类中的方法
其中类的数据属性是共享给所有对象的
Person 是一个类名
Person 中可以放两个东西：
     静态属性  变量  （是所有的对象共享的一个属性）
     动态属性（方法）  函数，自带一个叫做self的形参
静态属性和对象属性的区别是什么？
如果所有的对象的某一个值都是相同的，就用静态属性
如果每一个对象的某一个值都不同，就用对象属性。
类名可以做两件事情：
1,查看静态属性和动态属性
2,创造一个对象
print(Person.Country)    #变量的地址
print(Person.func)      #函数的地址
Person.func(0)  #Person调用方法：self也是一个需要传的参数
print(Person.__dict__)
创造一个对象object  对象=类名（）
创造一个对象的流程：
1，首先要创造一个对象，产生一些类对象的指针
2，会自动的触发__init__，将创造出来的对象的地址传给self
3，执行__init__中的代码
4，将self指向的地址再返回给调用者
self 到底是什么
obj = Person()  #对象 = 类名（）
print(obj)
obj = Person('alex',None,10,1)

class Person:
    def __init__(self,name,sex,hp,ad):#初始化方法
        self.user = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def attack(self,dog):
        print('%s攻击了%s'%(self.user,dog.user))
        dog.hp -= self.ad
        print('%s掉了%s点血，当前血量为%s'%(dog.user,self.ad,dog.hp))
class Dog:
    def __init__(self, name, kind, hp, ad):
        self.user = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        print('%s咬了%s'%(self.user,person.user))
        person.hp -= self.ad
        if person.hp> 0:
            print('%s掉了%s点血，当前血量为%s'%(person.user,self.ad,person.hp))
        else:
            person.hp = 0
            print('%s掉了%s点血，当前血量已为0'%(person.user,self.ad))
alex = Person('alex',None,10,1)  #实例化
egon = Person('egon',None,10,1)   #实例化
taibai = Dog('哮天犬','teddy',100,50)   #实例化
# print(alex.user)
# print(egon.user)
# print(taibai.user)
alex.attack(taibai)
# print(taibai.hp)
taibai.bite(alex)

面向对象的命名空间：
对象名可以调用静态属性
对象名可以调用方法
class Person:
    Country = 'China'
    def __init__(self,name):
        self.name = name
    def attack(self):
        print('attack')
类：
静态变量(字段)
动态方法：特殊的__init__方法，attack方法
class Person:
    Country = 'China'
   #Country =[ 'China']
    def __init__(self,name):
        self.name = name
alex = Person('alex')
egon = Person('egon')
alex.Country = '印度'
#alex.Country[0] = '印度'
print(alex.Country)
print(egon.Country)
print(Person.Country)

首先静态变量之所以出现：所有的对象都共享的值
调整静态变量的值：直接用类名去调整 是最准确的
对象对一个静态变量重新赋值的过程
实际上是在对象所在的内存空间中添加了一个同名属性而已
方法并没有真正存储在对象的空间中
之所以能找到，是因为每一个对象在创建之初都有一个指向类的指针
类名：
1，查看修改静态属性
2，实例化
对象名：
1，查看对象命名空间中的属性
2，调用方法
对象使用名字的特点：自己有的时候用自己的，自己没有的时候用类中的

 

类:具有相同属性和技能的一类事物
对象:类的具体表现
class 关键字
class  类名(类名首字母大写)
class Person:
    '''
    此类是构建人类
    '''
    level = '高级动物'      #静态变量(静态字段)
    mind = '有思想'
    language = '语言'

    def __init__(self):      #动态方法(函数)
        pass
    def work(self):
        print('开始工作了!!!!')
    def eat(self):
        pass

类名:
    1类名查看类中所有的变量(字段),方法(函数):
print(Person.__dict__)
    2类名对静态变量(静态字段)进行操作  最好不要通过__dict__这个字典进行操作

2.1通过类名.__dict__  不建议!!!通过这个方法
print(Person.__dict__['mind']) # 可以查值
Person.__dict__['create'] = '有创造力' #  不能增加值
del Person.__dict__['mind']  # 不能删除值
Person.__dict__['mind'] = '行尸走肉'  # 不能更改值
print(Person.__dict__)
小总结: 查询类里面所有的变量 Person.__dict__
     (增删改)查询单个变量 不要用Person.__dict__
2.2 通过类名.变量名  常用!!!
print(Person.mind)  # 可查询
print(Person.language)  #可查询
Person.create = '有创造力' # 可增加
del Person.mind # 可删除
Person.mind = '行尸走肉'
print(Person.mind)
print(Person.__dict__)
    3类名对动态方法(函数)进行操作
3.1 通过类名.__dict__  不建议!!!通过这个方法
        课下自己试一下
        3.2 类名.方法名
Person.work(111)


class Person:
    '''
    此类是构建人类
    '''
    level = '高级动物'
    mind = '有思想'
    language = '语言'

    def __init__(self,name,age,sex,area,hobby):  # 构造方法
        self.name = name  # slef.name name   #是对象属性
        self.age = age
        self.sex = sex
        self.area = area
        self.hobby = hobby

    def work(self,eye):
        self.eye = eye
        print('开始工作了!!!!')
    def eat(self):
        pass

实例化对象.
aduan = Person()  # 过程就叫做实例化一个对象
类名+():
aduan = Person('啊段',18,'男','河北邯郸','非女')
print(aduan)  # <__main__.Person object at 0x0000000001F7EA20>
1 产生一个空的对象空间
2,自动执行类中的__init__方法,并将空的对象空间传给self,剩下的值传给相应形参
3,执行init方法,给对象封装属性,并将完善好的这个对象返回给 类名() 这个对象

对象:
1,查找对象中的所有属性
aduan = Person('啊段',18,'男','河北邯郸','非女')
print(aduan.__dict__)

aduan = Person('啊段',18,'男','河北邯郸','非女')
aying = Person('啊颖',17,'女','河北衡水','开车...')
2, 对象操作对象中属性.
aduan = Person('啊段',18,'男','河北邯郸','非女')
print(aduan.name)    # 查
aduan.job = 'student'    # 增
del aduan.age    # 删
aduan.sex = 'laddyboy'
print(aduan.__dict__)
3,对象操作类中的静态变量(静态字段). 只能查询不能增删改.
aduan = Person('啊段',18,'男','河北邯郸','非女')
print(aduan.level)  # 查 类中的静态字段
aduan.level = '中等动物'  # 对象中设置新属性,而不是改变类中的level
print(aduan.level)
del aduan.level
print(Person.__dict__)
4,对象执行类中的方法.
aying = Person('啊颖',17,'女','河北衡水','开车...')
print(aying)

class Person:
    level = '高级动物'
    mind = '有思想'
    language = '语言'
    def __init__(self,name,age,sex,area,hobby):
        self.name = name
        self.age = age
        self.sex = sex
        self.area = area
        self.hobby = hobby
    def work(self,eye):
        self.eye = eye
        print('开始工作了')
zhangsan = Person('张三',12,'男','河北','踢球')
zhangsan.work('大眼睛')
print(zhangsan.__dict__)

1 self 位置参数, 默认接收的是对象空间,约定俗成叫self.
2 在类的非__init__方法中,也可以给对象添加一些属性,前提必须先执行这个方法.
总结:
类名:
1,查看所有方法:类名.__dict__
2,查看类中的静态变量:类名.mind(类名.__dict__['mind']  不建议)
3,查看类中的动态方法:类名.方法名(参数)   #需要传参
对象:
obj = 类名()
1,在内存中创建了一个空间
2,自动执行__init__(self),并将空的对象空间传给self.
3,在__init__方法中,给空的对象空间封装一些属性,并将完善好的这个对象返回给 类名() 这个对象
1,对象查看自己空间的所有属性:
对象.__dict__
2,对象操作自己的属性,万能的点:
对象.属性名(增删改查)
3,对象可以查询类中的静态字段(变量):
对象.静态变量
4,对象可以查询类中的动态方法:
对象.方法名()   #不需要传参