python面向对象实例王者荣耀_python大佬养成计划--面向对象

类

面向对象编程具有三大特性：多态、继承、封装

定义：是一个抽象的模板

对象：类实例化

属性：这个类实例化后的对象具有的特征

方法：类对象可以执行的函数

类的定义

class 类名

class People(object):

# object代表是， 人类继承于哪一个类， 如果不知道继承哪个类， 就写object；

# 构造方法(魔术方法)， 当创建对象的时候， 自动执行的函数

def __init__(self, name, age, gender):

# python解释器自动将对象传给self这个形参.

# 看self到底是什么东西?

# 将对象与该对象的属性绑定在一起.

# 调用对象的属性两种方式:

# - Tom.name

# - self.name

self.name = name # 属性

self.age = age # 属性

self.gender = gender # 属性

# print(self) # 实质上是一个对象， <__main__.People object at 0x0000024111324630>

# 方法(在类里面定义的函数， 叫做方法)

def eat(self):

print("%s 正在吃饭..." %(self.name))

# 创建对象====根据模板(类)创建对象(真实存在)

Tom = People("Tom Smith", 10, 'male')

#测试

# 看对象的属性

print(Tom.name)

print(Tom.age)

print(Tom.gender)

# 让对象执行方法

Tom.eat()

私有属性和私有方法

1).类的私有属性:

__private_attrs：两个下划线开头，声明该属性为私有，

不能在类地外部被使用或直接访问。

在类内部的方法中使用时 self.__private_attrs。

2).类的方法:

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，

类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的(因为是形参)，也可以使用 this，但是最好还是按照约定是用 self。

3).类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，

不能在类地外部调用。self.__private_methods。

class People(object):

def __init__(self,name,age,gender, money):

self.name = name

self.age = age

self.gender = gender

self.__money = money

self.__play()

def __play(self):

print("王者荣耀正在进行时......")

p1 = People('user1', 10, 'male', 1000000)

print(p1.gender)

p1.__play()#报错，AttributeError: 'People' object has no attribute '__play'

栈数据结构

栈的方法有入栈(push), 出栈(pop), 栈顶元素(top),栈的长度(lenght), 判断栈是否为空(isempty)，显示栈元素(view)

操作结果:

栈类的实例化

入栈2次

出栈1次

显示最终栈元素

class Stack(object):

def __init__(self):

self.stack_list =[]

def push(self,val):

self.stack_list.append(val)

return True

def pop(self):

self.stack_list.pop()

return True

def top(self):

return self.stack_list[-1]

def lenght(self):

return len(self.stack_list)

def isempty(self):

return self.stack_list ==[]

def view(self):

return ",".join(self.stack_list)

stack1 = Stack()

stack1.push('3')

stack1.push('4')

print(stack1.view())

stack1.pop()

print(stack1.view())

第二特性之继承

概念：

父类与子类/基类和派生类

class Anminal(object):

def __init__(self,name,age):

self.name = name

self.age = age

def eat(self):

print("i'm hungry,i want to eat something~~~")

class Dog(Anminal):

def __init__(self,name,age,power):

#当子类没有的属性和方法，会到父类里面找。如果父类有没有，就会报错

#父类的私有属性和私有方法，子类不能查看与操作

super(Dog, self).__init__(name,age)

self.power =power

def eat(self):

super(Dog, self).eat()

print("wang~~")

H = Dog('大黄',6,100)

print(H.power)

print(H.name)

print(H.age)

H.eat()

多继承

# 经典类

class Person1:

pass

p1 = Person1()

print(p1)

# 新式类

class Person2(object):

pass

p2 = Person2()

print(p2)

在python2中既有新式类也有经典类;

经典类的继承算法: 深度优先算法

新式类的继承算法: 广度优先算法，同级优先

python3全部都是新式类;

def test(self):

print("D test")

class C(D):

pass

def test(self):

print("C test")

class B(D):

pass

#def test(self):

# print("B test")

class A(B,C):

pass

# def test(self):

# print("A test")

a = A()

a.test()

乌龟吃鱼

游戏编程：按以下要求定义一个乌龟类和鱼类并尝试编写游戏

假设游戏场景为范围（x,y）为0<=x<=10,0<=y<=10

游戏生成1只乌龟和10条鱼

它们的移动方向均随机

乌龟的最大移动能力为2（它可以随机选择1还是2移动），鱼儿的最大移动能力是1

当移动到场景边缘，自动向反方向移动

乌龟初始化体力为100（上限）

乌龟每移动一次，体力消耗1

当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20

鱼暂不计算体力

当乌龟体力值为0（挂掉）或者鱼儿的数量为0游戏结束

import random

class Animals(object):

def __init__(self):

# 随机生成动物的坐标

self.x = random.randint(0, 10)

self.y = random.randint(0, 10)

def move(self, move_skill):

# 计算出乌龟新的坐标; (10,0) (12,0)

new_x = self.x + random.choice(move_skill) # 12

new_y = self.y + random.choice(move_skill) # 0

# 更新乌龟的坐标值

self.x = self.is_vaild(new_x)

self.y = self.is_vaild(new_y)

def is_vaild(self, value): # 12

"""判断坐标值是否合法(0~10之间), 返回合法的值"""

if value < 0: # eg: -2 == abs(-2) ==> 2

return abs(value)

elif value > 10: # eg: 12 ====> 10-(12-10) ==> 8

return 10 - (value - 10)

return value

class Trutle(Animals):

# 构造函数何时执行？ 类实例化对象(创建对象)时， 自动调用该函数内容

def __init__(self):

super(Trutle, self).__init__()

# 乌龟初始化体力为100（上限）

self.power = 100

def move(self, move_skill = [-2, -1, 0, 1, 2]):

super(Trutle, self).move(move_skill)

# 乌龟每移动一次，体力消耗1

self.power -= 1

def eat(self):

# 当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20

if self.power>80:

self.power =100

else:

self.power +=20

class Fish(Animals):

def move(self, move_skill = (-1, 0, 1 )):

# 鱼的最大移动能力为1

super(Fish, self).move(move_skill)

def start_game():

# 创建一个乌龟

t1 = Trutle()

# 创建10个鱼

# fishs = []

# for i in range(10):

# fishs.append(Fish())

fishs = [Fish() for i in range(10)]

# 游戏开始运行

while True:

# 判断游戏是否结束(乌龟没体力或者鱼被吃光了)

if t1.power <= 0:

print("乌龟没体力了， Game over.........")

break

elif len(fishs) == 0:

print("鱼被吃光了， Game over......... ")

break

else:

# 乌龟和鱼随机移动

t1.move()

for index, fish in enumerate(fishs):

fish.move()

# 判断乌龟是否吃到了鱼？

if t1.x == fish.x and t1.y == fish.y:

t1.eat()

fishs.remove(fish)

print("鱼被吃掉， 还剩%d条鱼......." %(len(fishs)))

print("乌龟最新体能为%s" %(t1.power))

# 当乌龟的坐标与每一条鱼进行比较， 都没有重合， 也就是没有迟到一条鱼;

else:

print("乌龟没有吃到鱼， 最新体能为%s" %(t1.power))

# 如果这个脚本(模块)， 没有被调用， 则执行下面的代码

if __name__ == "__main__":

print("游戏开始".center(50, '*'))

start_game()