Python类和对象

1.类以大写开头
2.面向对象特点
封装：内置方法
继承：子类自动共享父类之间数据和方法的机制

class mylist（list）:#mylist继承list类
    pass
list2=mylist()#list2为一个对象
list2.append(0)#可以调用list类的内置方法

多态：不同对象对同一方法而响应不同的行动

class A:#定义一个A类
    def fun(self):#定义一个函数
        print('我是小A')
class B:#定义一个类B
    def fun(self):#定义一个函数
        print('我是小B')
a=A()
b=B()
a.fun(）
b.fun()
分别输出：我是小A
         我是小B
注：不同对象对同一个方法响应不同的行动就是多态

3.面向对象方法中self
Python的self相当于C++的this指针
绑定方法，有了self就可以区分那个对象在调用方法，可以认为self是实例对象的唯一标志

 class Ball:
    def setName(self,name):
        self.name=name
    def kick(self):
        print('我叫%s，该死的谁踢我'%self.name)
 a=Ball()
 a.setName('球A')
 b=Ball()
 b.setName('球B')
 c=Ball()
 c.setName('土豆')
 a.kick()
我叫球A，该死的谁踢我
 c.kick()
我叫土豆，该死的谁踢我

4.Python面向对象的一些方法
1）_ init _(self)”构造器”方法

class Ball:
    def __init__(self,name):
        self.name=name
    def kick(self):
        print('我叫%s，该死的，谁踢我...'%self.name)
A=Ball（‘足球’）
A.kick（）

注：报错 TypeError: object() takes no parameters
原因： init两边的下划线为两个

2）公有和私有
在Python中定义私有变量只需要在变量名或者函数名前加上两个下划线，那么这个函数或者变量就会变成私有的了

class Person:
    __name='小甲鱼'#私有变量
若调用：报错'Person' object has no attribute 'name'
class Person:
    __name='小甲鱼'
    def GetNmae(self):
        return self.__name
p=Person()
p.GetNmae()
结果：小甲鱼

注：私有变量只能从内部调用
也可以如下方式调用:

#—类名——变量名
p._Person__name

5.继承
语法：
class DerivedClassName（BaseClassName）：
括号内为：被继承者，被称为基类，父类或为超类

#定义父类：
class Parent:
    def hello(self):
        print("正在调用父类方法")
#继承
class Child(Parent):
    pass
#调用
p=Child()
p.hello()
结果为：
正在调用父类方法

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

class Child(Parent):
    def hello(self):
        print("正在调用子类的方法...")
c=Child()
c.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 Goldenfish(Fish):
  pass

class Carp(Fish):
  pass

class Salmon(Fish):
  pass


class Shark(Fish):
  def __init__(self):
    self.hungry=True

  def eat(self):
    if self.hungry:
      print("吃货就像天天吃")
      self.hungry=False
    else:
      print('吃不动了')

例子shark重写了init方法，覆盖了父类方法，应该在shark中调用自己方法前应该先调用父类方法
两种方法：
1）.调用未绑定的父类方法

#在子类init方法中加入：父类名__init__(self)
Fish.__init__(self)

2）.使用super函数
不用给定基类的名字

在子类init方法中加入：super().__init__()
class Shark(Fish):
  def __init__(self):
    super().__init__()
    self.hungry=True

6.多重继承
语法：class DerivedClassName(Base1,Base2…..):
把多个父类写在括号中

class Base1:#定义父类1
    def fool1(self):
        print("我是fool1")
class Base2:#定义父类2
    def fool2(self):
        print("我是fool2")

 class C(Base1,Base2):#定义子类继承父类1，父类2
    pass

c=C()
c.fool1()
c.fool2()
结果：
我是fool1
我是fool2

7.组合
把类的实例化放到一个新类里面，就把旧类组合在里面，把没有继承关系的几个类组合起来

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

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

class Pool:
  def __init__(self,x,y):
    self.turtle=Turtle(x)#把旧类的实例化放到这个新类里面
    self.fish=Fish(y)

  def print_num(self):
    print("水池里有乌龟%d只，小鱼%d条"%(self.turtle.num,self.fish.num))

8.类，类对象，实例对象

class C:#类
    count=0


 a=C()#实例对象
 b=C()
 c=C()
 C.count#类对象
 >>> a.count
0
>>> c.count+=10
>>> c.count
10
>>> a.count
0
>>> b.count
0

python中的绑定：
要求方法要有实例才能被调用，这种限制其实就是Python所谓的绑定概念

class BB：
    def printBB（）：
        print('no zuo no die')
BB.printBB()
no zuo no die
bb=BB()
bb.printBB()#报错

9.类和对象相关的内置函数BIF
1）issubclass(class,classinfo)
一个类被认为是其自身的子类
classinfo可以是类对象组成的元组

>>>class A:
    pass

>>> class B(A):
    pass

>>> issubclass(B,A)
True
>>> issubclass(A,B)
False

2)isinstance(实例对象，类)
如果第一个参数不是对象则永远返回False
第二个参数不是类或者有类对象组成的元组会跑出typeerror异常

b1=B()
>>> isinstance(b1,B)
True

部分习题
1.按照下面提示尝试定义一个举行类并生成类实例对象
属性：长和宽
方法：设置长和宽，获得长和宽，获得面积

class Rectangle():
    length=5
    width=3
    def setRect(self):
        self.length=int(input("请输入长度"))
        self.width=int(input("请输入宽度"))
    def getRect(self):
        print("长为%d宽为%d",self.length,self.width)
    def getArea(self):
        area=self.width*self.length
        return area
>>>r=Rectangle()#实例化对象
>>> c.setRect()
请输入长度5
请输入宽度2
>>> c.getArea
10

2.游戏编程：按要求定义一个乌龟类和鱼类
~场景范围：x:0-10 y:0-10
~生成一只乌龟和一只鱼
~移动方向均为随机
~乌龟最大移动能力为2（移动距离为1或者2），小鱼为1
~当移动到边缘，自动反方向移动
~乌龟初始体力为100，移动一次消耗1体力
~乌龟和小鱼坐标重叠则吃掉鱼乌龟盛，乌龟体力耗完，小鱼胜

import random as r

class Turtle():
  x=0
  y=0
  m=0
  d=0
  def coor(self):
    self.x=r.randint(0,10)
    self.y=r.randint(0,10)
    print("乌龟此时坐标为：%d,%d"%(self.x,self.y))
  def move(self):
    self.m=r.randint(1,2)#移动距离1或者2
    self.d=r.randint(1,4)#方向，1代表上，2代表下，3代表左，4代表右
    if self.d==1:
      self.y-=self.m
    elif self.d==2:
      self.y+=self.m
    elif self.d==3:
      self.x-=self.m
    else:
      self.x+=self.m
    if self.x>10:
      self.x=20-self.x
    if self.x<0:
      self.x=-self.x
    if self.y>10:
      self.y=20-self.y
    if self.y<0:
      self.y=-self.y
    print("乌龟此时坐标为：%d,%d"%(self.x,self.y))


class Fish():
  x=0
  y=0
  def coor(self):
    self.x=r.randint(0,10)
    self.y=r.randint(0,10)
    print("小鱼此时坐标为：%d,%d"%(self.x,self.y))
  def move(self):
    self.d=r.randint(1,4)#方向，1代表上，2代表下，3代表左，4代表右
    if self.d==1:
      self.y-=1
    elif self.d==2:
      self.y+=1
    elif self.d==3:
      self.x-=1
    else:
      self.x+=1
    if self.x>10:
      self.x=20-self.x
    if self.x<0:
      self.x=-self.x
    if self.y>10:
      self.y=20-self.y
    if self.y<0:
      self.y=-self.y
    print("小鱼此时坐标为：%d,%d"%(self.x,self.y))

turtle=Turtle()
fish=Fish()


turtle.coor()
fish.coor()

turtle_x=turtle.x#初始化乌龟的随机坐标
turtle_y=turtle.y
fish_x=fish.x#初始化鱼的随机坐标
fish_y=fish.y
energy=100
count=0

while 1:
  if turtle_x==fish_x and turtle_y==fish_y:
    print("%d次fish over"%count)
    break
  else:
    energy-=1
    if energy==0:
      print("%d次turtle over!"%count)
      break
    else:
      turtle.move()
      fish.move()
      turtle_x=turtle.x#移动后乌龟的随机坐标
      turtle_y=turtle.y
      fish_x=fish.x#移动后鱼的随机坐标
      fish_y=fish.y
      count+=1