python中b类调用a类的方法_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