class Turtle:#python 中类名约定以大写字母开头
  '''关于类的简单例子。。。'''
  #属性 == 类变量
  color ="green"
  weight="10kg"
  legs=4
  shell=True
  mouth='big'
  #方法
  def climb(self):
    self.name = "test"  #实例变量：定义在方法中的变量，只作用于当前实例的类。
    print("我在很努力爬。")
  def run(self):
    print('我在很努力跑。')
  def bite(self):
    print('我要要要要要')
  def sleep(self):
    print('我要睡觉啦。')
#创建一个实例对象也就是类的实例化！
tt =Turtle() #类的实例化，也就是创建一个对象，类名约定大写字母开头
tt.bite() #创建好类后就能调用类里面的方法叻；
tt.sleep()

class MyList（list）:#创建一个类继承list的所有方法和属性
   pass   #相当于一个占位符
list1=MyList()  #类实例化
list1.append(1)  #继承后调用list的方法append()

> class A:
    def fun(self):
       print('aaaa')
>class B ():
    def fun(self):
       print('bbb')
> a=A()
>b=B()
>a.fun()
aaaa
>b.fun()
bbb

>class Ball():
    def setname(self,name):
       self.name=name
    def kick (self):
       print("我叫%r,谁踢我"%self.name)
>a=Ball()  实例化生成a对象
>a.setname('a') 调用方法设名为a
>b=Ball()
>b.setname('b')
>c=Ball()
>c.setname()
>a.kick ()  通过self知道是哪个对象调用kick方法
我叫'a',谁踢我
>b.kick()
我叫'b',谁踢我

>class Ball:
    def __init__(self,name):
       self.name = name
    def kick(self):
       print('我叫%r,谁踢我'%self.name)
> b=Ball('b') #创建对象，这时__init__(self):就被调用了，可以传入b
>b.kick()
我叫'b',谁踢我

> class P():
    __name="liyue"  #私有变量，外部不能通过.操作符直接访问了

class A(B):
   ………….

> class Parent():
    defhello(self):
       print("helloliyue!")
> class Child(Parent):
    pass
> p=Parent()
> p.hello()
hello liyue!
> c=Child()
> c.hello()
hello liyue!

> class Parent():
    defhello(self):
       print("helloliyue!")
> class Child(Parent):
    defhello(self):
       print("hahah!")
> p=Parent()
>p.hello ()
hello liyue!
> c =Child()
>c.hello () #子类和父类方法相同，（子类重写父类方法）会覆盖父类方法，但是父类自己的方法不变
hahah!

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)
classGoldfish(Fish): #子类
  pass
classCarp(Fish):   #子类
  pass
classSalmon(Fish):  #子类
  pass
classShark(Fish):
  def __init__(self):  #这里重写了__init__方法，就会覆盖掉父类的方法了，用到super函数后就可以继续使用父类的方法。
  #super函数不用给定任何基类的名字(如下)，它会一层层找出代码所有父类里面对应的方法，要改变该类的继承关系时只需修改这个类的父类就行就是括号里面的Fish。
    super().__init__() #super().重写的属性或方法
    self.hungry = True
  def eat(self):
    if self.hungry:
      print("我要吃了。。。")
      self.hungry = False
    else:
      print('好饱了。。。')
> f=Fish()
>f.move()
我的位置是： -1 3
>f.move()
我的位置是： -2 3
>g=Goldfish()
>g.move()
我的位置是： 4 4
>s=Salmon()
>s.move()
我的位置是： 8 1
>s.move()
我的位置是： 7 1
> s=Shark()
>s.eat()
我要吃了。。。
>s.eat()
好饱了。。。
>s.move()
我的位置是： 5 10  #这就是子类就可以使用父类的move()方法
>s.move()
我的位置是： 4 10

class Turtle():  #定义乌龟类
  def __init__(self,x):
    self.num = x
classFish():  #定义鱼类
  def __init__(self,y):
    self.num = y
classPool():   #定义水池类
  def __init__(self,x,y):
    self.turtle = Turtle(x)  #直接把需要的类在这里实例化就行了，组合实现
    self.fish = Fish(y)
  def print_num(self):
    print("水池中总共有乌龟%d只，小鱼%r条。"%(self.turtle.num,self.fish.num)
> p =Pool(1,10)
>p.print_num ()
水池中总共有乌龟1只，小鱼10条

>class C(): #类，当类写完后就变成了类对象
    def x(self):
       print("xaaa")
> c =C()  #c是实例对象，C()是类对象
> c.x()
xaaa
> c.x= 1  #实例对象初始化一个变量
> c.x
1
> c.x()  #就不能继续调用原来的方法了，同名会覆盖掉类的方法
Traceback (most recent call last):
 File"<pyshell#18>", line 1, in <module>
  c.x()
TypeError: 'int' object is not callable

>class CC:     #类
    def setxy(self,x,y):
       self.x = x
       self.y = y
    def printxy(self):
       print(self.x,self.y)
> dd= CC()   #实例对象，类对象
>dd.__dict__  #查看实例对象所拥有的属性
{}
>CC.__dict__  #查看类对象所拥有的属性
mappingproxy({'setxy':<function CC.setxy at 0x00000000031F9B70>, 'printxy': <functionCC.printxy at 0x00000000031F9BF8>, '__module__': '__main__', '__weakref__':<attribute '__weakref__' of 'CC' objects>, '__dict__': <attribute '__dict__'of 'CC' objects>, '__doc__': None})
>dd.setxy (4,5)  #实例对象中传入x，y
>dd.__dict__  #实例对象就有属性了，这两个属性紧属于实例对象的，类对象中是没有的
{'y': 5, 'x': 4}     #类对象中是没有实例对象传入的，这归功与绑定这个功能，self

> delCC
>dd.setxy (3,4)
>dd.__dict__
{'y': 4, 'x': 3}
> dd =CC()
Traceback (most recent call last):
 File"<pyshell#45>", line 1, in <module>
  dd =CC()
NameError: name 'CC' is not defined
>dd.printxy ()
3 4