给大家介绍对象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('1995','1','27'), #把B中数据调入T中，实例p1
Couse('python','28000','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
不要用类属性