资讯专栏INFORMATION COLUMN

python大佬养成计划--面向对象

hzc / 1881人阅读

摘要:的名字并不是规定死的因为是形参,也可以使用,但是最好还是按照约定是用。类的私有方法两个下划线开头,声明该方法为私有方法,只能在类的内部调用,不能在类地外部调用。。

面向对象编程具有三大特性:多态、继承、封装
定义:是一个抽象的模板
对象:类实例化
属性:这个类实例化后的对象具有的特征
方法:类对象可以执行的函数

类的定义
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()

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/42366.html

相关文章

  • python大佬养成计划----socket实现UDP通信

    摘要:是建立可靠连接,并且通信双方都可以以流的形式发送数据。相对,则是面向无连接的协议。测试结果用两个命令行分别启动服务器和客户端测试开启服务端完成一次通信 UDP TCP是建立可靠连接, 并且通信双方都可以以流的形式发送数据。 相对TCP, UDP则是面向无连接的协议。使用UDP协议时, 不需要建立连接, 只需要知道对方的IP地址和端口号, 就可以直接发数据包。 但是, 能不能到达就不知道...

    Juven 评论0 收藏0
  • python大佬养成计划----socket实现TCP通信

    摘要:我们来编写一个简单的服务器程序,它接收客户端连接,回复客户端发来的请求。如果一切顺利,新浪的服务器接受了我们的连接,一个连接就建立起来的,后面的通信就是发送网页内容了。 TCP TCP(Transmission Control Protocol 传输控制协议)是一种面向连接的、可靠的、基于字节流的传输层通信协议,由IETF的RFC 793定义。在简化的计算机网络OSI模型中,它完成第四...

    layman 评论0 收藏0
  • python大佬养成计划----flask_sqlalchemy操作数据库

    摘要:使用对象关系映射框架,它将低层的数据库操作指令抽象成高层的面向对象操作。在中,数据库使用指定。安装对数据库操作如何创建数据库操作连接为了创建初始数据库,调用方法来创建表和数据库您的数据库已经生成。最为常见的关系就是一对多的关系。 flask_sqlalchemy 使用对象关系映射(Object-Relational Mapper, ORM)框架,它将低层的数据库操作指令抽象成高层的面向...

    RdouTyping 评论0 收藏0

发表评论

0条评论

hzc

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<