#######面向对象#######
##类与对象的理解及封装特性
## 面向对象的编程语言
# - 类: 一个模板, (人类，动物)---是一个抽象的， 没有实体的一个群体
# - 对象: (eg: 甲、乙、 丙 、 丁)
# - 属性: (表示这类东西的特征：都有眼睛， 嘴巴或者鼻子等等)
# - 方法： (表示这类物体可以做的事情， eg: 吃饭， 睡觉，学习等)
# class: 类
from collections import Counter
# 例子: str, list, dict, Counter 都属于类
# object代表是， 人类继承于哪一个类， 如果不知道继承哪个类， 就写object；
class 人类(object):
# print('hello')
# 构造方法(魔术方法)， 当创建对象的时候， 自动执行的函数
def __init__(self, name, age, gender): #代笔此类共有的属性
# python解释器自动将对象传给self这个形参
# 将对象与该对象的属性绑定在一起.
# 调用对象的属性两种方式:
# - 张三.name
# - self.name
self.name = name # 属性
self.age = age # 属性
self.gender = gender # 属性
print(self) # 实质上是一个对象， <__main__.人类 object at 0x7f4fdc4864a8>
# 方法(在类里面定义的函数， 叫做方法)
def eat(self):
print("%s 正在吃饭..." %(self.name))
# 创建对象====根据模板(类)创建对象(真实存在)
张三 = 人类("张三", 10, 'male')
print("张三:", 张三)
# 看对象的属性
print(张三.name)
print(张三.age)
print(张三.gender)
# 让对象执行方法
张三.eat()
应用示例：
创建一个类People,拥有的方法为砍柴,娶媳妇,回家;实例化对象,执行相应的方法
显示如下:
kebo,18岁,男,开车去娶媳妇
james,22岁,男,上山去砍柴
curry,10岁,女,辍学回家
提示:
属性:name,age,gender
方法:goHome(), kanChai(),quXiFu()
class People(object): # 类
def __init__(self, name, age, gender): # 属性
self.name = name
self.age = age
self.gender = gender
def gohome(self): # 方法
print('%s %d %s 辍学回家'.center(40, '*') % (self.name, self.age, self.gender))
def kanchai(self): # 方法
print('%s %d %s 上山去砍柴'.center(40, '*') % (self.name, self.age, self.gender))
def quxifu(self): # 方法
print('%s %d %s 开车去娶媳妇'.center(40, '*') % (self.name, self.age, self.gender))
# 实例化
kobe = People('kobe', 18, 'male')
james = People('james', 22, 'male')
curry = People('curry', 10, 'famale')
# 调用方法
kobe.gohome()
james.kanchai()
curry.quxifu()
## 类的私有属性和私有方法
类的私有属性:
__private_attrs：两个下划线开头，声明该属性为私有，
不能在类地外部被使用或直接访问。
在类内部的方法中使用时 self.__private_attrs。
类的方法:
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，
类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
self 的名字并不是规定死的(因为是形参)，也可以使用 this，但是最好还是按照约定是用 self。
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，
不能在类地外部调用。self.__private_methods。
class People(object):
def __init__(self, name, __age):
self.name = name
self.age = __age
def play(self):
print("%d岁的%s正在打篮球" % (self.age, self.name))
def __fun(self):
print('%s正在玩耍' % self.name)
if __name__ == "__main__":
kobe = People('kobe', 18)
print(kobe.age)
kobe.play()
kobe.__fun()
"""
运行结果：
Traceback (most recent call last):
18
File "/root/PycharmProjects/houzeyu/面向对象/私有属性和私有方法.py", line 17, in <module>
18岁的kobe正在打篮球
kobe.__fun()
AttributeError: 'People' object has no attribute '__fun'
"""
## 栈数据结构的封装
应用:栈的数据结构
class Stack:
栈的方法:
入栈(push), 出栈(pop), 栈顶元素(top),
栈的长度(lenght), 判断栈是否为空(isempty)
显示栈元素(view)
操作结果:
栈类的实例化
入栈3次
出栈1次
显示最终栈元素
class Stack(object):
def __init__(self):
self.stack = []
def push(self, value):
self.stack.append(value)
def pop(self):
if self.stack:
item = self.stack.pop()
return item
else:
return False
def top(self):
if self.stack:
return self.stack[-1]
else:
return False
def lenght(self):
return len(self.stack)
def isempty(self):
return self.stack==[]
def view(self):
return ",".join(self.stack)
s = Stack() #实例化
s.push('abc')
s.push('1')
s.push('2')
print(s.top())
print(s.isempty())
print(s.lenght())
item= s.pop()
print(s.view())
## pygame
游戏编程：按以下要求定义一个乌龟类和鱼类并尝试编写游戏
假设游戏场景为范围（x,y）为0<=x<=10,0<=y<=10
游戏生成1只乌龟和10条鱼
它们的移动方向均随机
乌龟的最大移动能力为2（它可以随机选择1还是2移动），鱼儿的最大移动能力是1
当移动到场景边缘，自动向反方向移动
乌龟初始化体力为100（上限）
乌龟每移动一次，体力消耗1
当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
鱼暂不计算体力
当乌龟体力值为0（挂掉）或者鱼儿的数量为0游戏结束
import random
class Trutle(object):
def __init__(self):
self.x = random.randint(0, 10)
self.y = random.randint(0, 10)
self.power = 100
def move(self):
move_skill = [-2, -1, 0, 1, 2]
new_x = self.x + random.choice(move_skill)
new_y = self.y + random.choice(move_skill)
self.x = self.is_valid(new_x)
self.y = self.is_valid(new_y)
self.power -= 1
def is_valid(self, value):
if value < 0:
return abs(value)
elif value > 10:
return 10 - (value - 10)
return value
def eat(self):
self.power += 20
class Fish(object):
def __init__(self):
# 随机生成鱼的坐标
self.x = random.randint(0, 10)
self.y = random.randint(0, 10)
def move(self):
# 鱼的最大移动能力为1
move_skill = [-1, 0, 1, ]
# 计算出鱼新的坐标; (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
def start_game():
t1 = Trutle()
fishes = [Fish() for i in range(10)]
while True:
if t1.power <= 0:
print("乌龟没体力了， Game over.........")
break
elif len(fishes) == 0:
print("鱼被吃光了， Game over......... ")
break
else:
t1.move()
for index, fish in enumerate(fishes):
fish.move()
if t1.x == fish.x and t1.y == fish.y:
t1.eat()
fishes.remove(fish)
print("鱼被吃掉， 还剩%d条鱼......." % (len(fishes)))
print("乌龟最新体能为%s" % (t1.power))
else:
print("乌龟没有吃到鱼， 最新体能为%s" % (t1.power))
if __name__ == "__main__":
print("startgame".center(50, '*'))
start_game()
## 继承特性
##我们引入 - 父类与子类/基类和派生类 的概念，例如：
# class Animals(object):
# def __init__(self, name, age):
# self.name = name
# self.age= age
# def eat(self):
# print('eating......')
#
#
# class Dog(Animals): # 当Dog没有构造方法时，执行Animals里面的构造方法
# def __init__(self, name, age, power):
# # self.name = name
# # self.age = age
# # 执行Dog的父类的构造方法;
# super(Dog, self).__init__(name, age)
# self.power = power
# def eat(self):
# print(self.power)
# super(Dog, self).eat()
class Animals(object):
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('eating...')
class Dog(Animals):
def __init__(self,name,age,power):
super(Dog, self).__init__(name, age)
self.power = power
def eat(self):
super(Dog, self).eat()
print(self.power)
if __name__ == '__main__':
d1 = Dog('wangcai', 10, 100)
d1.eat()
class Animals(object):
def __init__(self, name, __age):
self.name = name
# 私有属性, 在类的内部都是可以访问的, 类的外部或者子类都不可以访问
self.__age = __age
# 私有方法
def __info(self):
print(self.__age)
class Dog(Animals):
def __init__(self, name, __age, power):
super(Dog, self).__init__(name, __age)
self.power = power
# def drink(self):
# print(self.__age)
# 父类的私有属性， 子类的方法时不能查看与操作
# 父类的私有方法， 子类是不能查看与操作
## 多继承原理
# 在python2中既有新式类也有经典类;
# 经典类的继承算法: 深度优先算法
# 新式类的继承算法: 广度优先算法
# python3全部都是新式类; 例如：
class D:
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()注：
实例化A后，依次注释掉类A B C内的方法内容运行结果如下：
## 利用继承特性实现乌龟吃鱼游戏
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 Turtle(Animals):
def __init__(self):
super(Turtle, self).__init__()
self.power = 100
def move(self, move_skill=(-2, -1, 0, 1, 2)):
super(Turtle, self).move(move_skill)
self.power -= 1
def eat(self):
# 当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
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 = Turtle()
fishes = [Fish() for i in range(10)]
while True:
if t1.power <= 0:
print("乌龟没体力了， Game over.........")
break
elif len(fishes) == 0:
print("鱼被吃光了， Game over......... ")
break
else:
t1.move()
for index, fish in enumerate(fishes):
fish.move()
if t1.x == fish.x and t1.y == fish.y:
t1.eat()
fishes.remove(fish)
print("鱼被吃掉， 还剩%d条鱼......." % (len(fishes)))
print("乌龟最新体能为%s" % (t1.power))
else:
print("乌龟没有吃到鱼， 最新体能为%s" % (t1.power))
if __name__ == "__main__":
print("startgame".center(50, '*'))
start_game()