python 11 类与对象

给大家介绍对象hhhh

封装

举个例子，把乱七八糟的数据仍到列表，数据层面的封装

把常用的代码打包成一个函数，封装

外观特征（静态）　　能做什么（动态）

对象=属性（静态） + 方法（动态）

1.方法多用函数

2.类是图纸，对象是根据图纸制作的东西

3.类在整体结构中和函数很像，所以为了区分，类的开头字母大写，函数小写

class Turtle:　　　　#封装类

　　属性

　　方法

　　def climb()　　#方法中的一个例子

tt=Turtle()　　　　#创建类，与函数类似

tt.climd()　　　　#调用类中的函数

　　　　

oo 面向对象

封装，信息隐蔽技术　　list1.sort(),排序列表，并不知道过程

继承，子类自动共享父类之间数据和方法的机制

class Mylist(list):　　#继承list的方法和属性

　　pass　　　　#什么都不用做

list2 = Mylist()

list2.append(0)

list2

[0]

多态：对不同对象调用同一方法，结果因对象而变

class A:

　　def fun(self):

　　　　print('a')

class B:

　　def fun(self):

　　　　print('b')

a=A()

b=B()

a.fun　　#a

b.fun　　#b

面向对象编程

self要写进第一个参数对象

self名称不是必须的，在python中self不是关键词，你可以定义成a或b或其它名字都可以,但是约定成俗（为了和其他编程语言统一，减少理解难度），不要搞另类，大家会不明白的。

self指的是类实例对象本身(地址) (注意：不是类本身)。

class中函数调用

在给出一个实例以后，我们调用类中的具体方法（即函数）时，默认传入了self参数（即实例地址）

这样对象不唯一，也会各自运行各自的结果

class Ba:

　　def setname(self,name):　　　　#self为实例地址

　　　　self.name = name　　　　# 代入 实例.name = name

　　def kick(self):

　　　　print('%s' % self.name)　　#打印 实例.name

a = Ba()　　　　

a.setname('a')　　　　#self地址为a（实例地址）

b = Ba()

b.setname('b')

c = Ba()

c.setname('0')

a.kick()　　　　#a

c.kick()　　　　#0

构造函数

构造方法类似于类似init()这种初始化方法，来初始化新创建对象的状态，在一个对象类创建以后会立即调用

__init__(self,param1,param2.....)

class Ba:

　　def __init__(self,name)

　　　　self.name = name

　　def kick(self):

　　　　print('%s' % self.name)

b = Ba('b')

b.kick()　　　　#b

class Per:

　　name= 'a'

>>p = Per()

>>p.name　　#a

class Per:

　　__name= 'a'

　　def g(self):

　　　　return self.__name

>>p = Per()

>>p.name　　#报错，__为私有

>>p.g　　　　#返回a

>>p._Per__name　　#返回a

_类名__变量名

继承

class Deribedclassname(baseclassname):　　　　#()中为父类，名字

class Pae:

　　def hello(self):

　　　　print('调用父类')

class Chi(Pae):

　　pass

>>p = Pae()

>>p.hello

调用父类

>>c = hello()

>>c.hello()

调用父类

如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性

对父类不受影响

class Chi(Per):

　　def hello(self):

　　　　print("调用子类“）

>>c = Chi()

>>c.hello()

调用子类

>>p.hello()

调用父类

import random as r

class Fish:
     def __init__(self):
          self.x = r.randint(0,10)
          self.y = r.randint(0,10)

     def move(self):
          self.x -= 1
          print("我的位置:",self.x,self.y)

class Gold(Fish):
     pass

class Carp(Fish):
     pass

class Sa(Fish):
     pass

class Shark(Fish):
     def __init__(self):　　　　　　#与父类冲突，覆盖父类，需要解决方案
          self.hungry = True

     def eat(self):
          if self.hungry:
               print("天天有吃的")
               self.hungry = False
          else:
               print("太撑了")
               

1.调用未绑定的父类方法

def __init__(Fish):

　　Fish.__init__(self)　　　　#在子类执行的前面调用父类，self是子类的，Shark

　　self.hugry = True

2.使用 super函数

def __init__(Fish):　　　　　　#这里的父类是Fish，super调用的就是父类的__init__()

　　super().__init__()　　　　　#有很多父类也不用一个个写，自动一层层找出__init__()的方法,

　　self.hugry = True　　　　

多重继承，多写几个父类，尽量避免使用，可能出现不可预见的BUG（致命）

组合:在一个类中以另外一个类的对象作为数据属性，称为类的组合

实例.调入类.类中数据

class Turtle:
     def __init__(self,x):
          self.num = x

class Fishl:
     def __init__(self,x):
          self.num = x

class Pool:
     def __init(self,x,y):
          self.turtle = Turtle(x)　　#把T中数据调入self.turtle,可使用self.turtle.num
          self.fish = Fish(y)　　　　　　#实例.调入类.类中数据

     def print_num(self):
          print("乌龟 %d,小鱼%d" % (self.turtle.num,self.fish.num))  

Mix -in

(转载）

class Weapon:
    def prick(self, obj):  # 这是该装备的主动技能,扎死对方
        obj.life_value -= 500  # 假设攻击力是500

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name):
        self.name = name  # 每一个角色都有自己的昵称;
        self.weapon = Weapon()  # 给角色绑定一个武器;

egg = Person('egon')
egg.weapon.prick()
#egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程

人狗大战（转载）

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value, money):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;
        self.money = money

    def attack(self,dog):
        # 人可以攻击狗，这里的狗也是一个对象。
        # 人攻击狗，那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivity

class Dog:  # 定义一个狗类
    role = 'dog'  # 狗的角色属性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.breed = breed  # 每一只狗都有自己的品种;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人，这里的狗也是一个对象。
        # 狗咬人，那么人的生命值就会根据狗的攻击力而下降
        people.life_value -= self.aggressivity

class Weapon:    #装备
    def __init__(self,name, price, aggrev, life_value):
        self.name = name
        self.price = price
        self.aggrev = aggrev
        self.life_value = life_value

    def update(self, obj):  #obj就是要带这个装备的人
        obj.money -= self.price  # 用这个武器的人花钱买所以对应的钱要减少
        obj.aggressivity += self.aggrev  # 带上这个装备可以让人增加攻击
        obj.life_value += self.life_value  # 带上这个装备可以让人增加生命值

    def prick(self, obj):  # 这是该装备的主动技能,扎死对方
        obj.life_value -= 500  # 假设攻击力是500

lance = Weapon('长矛',200,6,100)
egg = Person('egon',10,1000,600)  #创造了一个实实在在的人egg
ha2 = Dog('二愣子','哈士奇',10,1000)  #创造了一只实实在在的狗ha2

#egg独自力战"二愣子"深感吃力，决定穷毕生积蓄买一把武器
if egg.money > lance.price: #如果egg的钱比装备的价格多，可以买一把长矛
    lance.update(egg) #egg花钱买了一个长矛防身，且自身属性得到了提高
    egg.weapon = lance #egg装备上了长矛

print(egg.money,egg.life_value,egg.aggressivity)

print(ha2.life_value)
egg.attack(ha2)   #egg打了ha2一下
print(ha2.life_value)
egg.weapon.prick(ha2) #发动武器技能
print(ha2.life_value) #ha2不敌狡猾的人类用武器取胜，血槽空了一半

转载

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender,birth,course):
        self.name=name
        self.gender=gender
        self.birth=birth　　　　　　
        self.course=course
    def teach(self):
        print('teaching')

p1=Teacher('egon','male',
            BirthDate('','',''), 　　　　　　#把B中数据调入T中，实例p1
            Couse('python','','4 months')
           ) 

print(p1.birth.year,p1.birth.month,p1.birth.day)  

print(p1.course.name,p1.course.price,p1.course.period)
'''
运行结果:
1995 1 27
python 28000 4 months
'''

类写完就是类对象，实例对象

class C:

　　def x:

　　　　count = 0

>>a=C()

>>b=C()

>>c.count+=10　　　　#创建实例对象的属性

>>c.x()　　　　　　#报错，属性如果与方法名相同，属性覆盖方法

>>a.count

0

>>c.count　　

10

>>C.count　　　　#类对象

0

>>C.count += 100

>>a.count　　　　　　#增加100

100

>>c.count　　　　#实例对象的属性，不变

10

避免这种事发生，不要试图在一个类里边定义出所有能想到的特性和方法，应该理由继承和组合机制进行扩展。

用不同的词性命名，如属性名用名词，方法名用动词

关于绑定

class C:

　　def set(self,x,y)

　　　　self.x = x

　　　　self.y = y

　　def printXY(self):

　　　　print(self.x,self.y)

>>d = C()

>>d.__dict__

{}

>>C.__dice__

{.............数据，方法.}

>>d.set(1,2)　　　　#静态的绑定类对象的方法里

>>d.__dice__

{'y':2,'x':1}

>>def C

>>e =C()　　　　#报错

>>d.printXY()　　　　#1 2　　　　

尽量用实例属性，self

不要用类属性