Python---面向对象

1.面向对象编程语言

类：一个模板，是一个抽象的没有实体的

对象：（eg：张三，李四）

属性：表示这类东西的特征

方法：表示这类物体可以做的事

class  man（object）

print（‘hello’）

构造方法：当创建对象的时候，自动执行的函数

def __init__(self,name,age,gender):
    self.name=name     ##属性
    self.age=age
    self.gender=gender
方法：在类里面定义的函数叫做方法
def eat(self):
    print(" 正在吃饭")
应用练习1

创建一个类People,拥有的方法为砍柴,娶媳妇,回家;实例化对象,执行相应的方法
显示如下:
    老李,18岁,男,开车去娶媳妇
    校思浩,22岁,男,上山去砍柴
    唐浩,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 huiJia(self):
        print("%s,%d,%s,辍学回家" %(self.name,self.age,self.gender))
    def quXiFu(self):
        print("%s,%d,%s,开车去娶媳妇" %(self.name,self.age,self.gender))
    def kanChai(self):
        print("%s,%d,%s,上山砍柴" %(self.name,self.age,self.gender))
Laoli = People('laoli',43,'男')
zhangsan = People('zhangsan',22,'女')
lisi = People('lisi',19, '男')

Laoli.quXiFu()
zhangsan.kanChai()
lisi.huiJia()

运行结果：

 str: 是个类， "hello":对象======> pyhton里面一切皆对象
类-> 对象(实例化对象)
 判断数据是否为某种数据类型, 判断某个对象是否是某个类创建/实例化出来的.
print(isinstance("hello", str）)

运行结果：

类的私有属性:
    __private_attrs：两个下划线开头，声明该属性为私有，
    不能在类地外部被使用或直接访问。
    在类内部的方法中使用时 self.__private_attrs。
类的方法:
    在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，
    类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
    self 的名字并不是规定死的(因为是形参)，也可以使用 this，但是最好还是按照约定是用 self。
类的私有方法
    __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

    def __play(self):
        print("王者荣耀正在进行时......")

p1 = People('user1', 10, 'male', 1000000)
print(p1.gender)

运行结果

Author:lvah
Name:{}.py
Date:
Email: xc_guofan@163.com
Desc:

应用练习2:栈的数据结构
class Stack:
    栈的方法:
    入栈(push), 出栈(pop), 栈顶元素(top),
    栈的长度(lenght), 判断栈是否为空(isempty)
    显示栈元素(view)
    操作结果:
    栈类的实例化
    入栈2次
    出栈1次
    显示最终栈元素

class Stack(object):
    # 构造函数
    def __init__(self):
        self.stack = []
    def push(self, value):
       
        self.stack.append(value)
        return True
    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 length(self):
        return  len(self.stack)

    def isempty(self):
        return self.stack==[]

    def view(self):
        return  ",".join(self.stack)

s = Stack()
s.push('1')
s.push('2')
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)
        # 乌龟初始化体力为100（上限）
        self.power = 100
    def move(self):
        # 乌龟的最大移动能力为2
        move_skill = [-2, -1, 0, 1, 2]
        # 计算出乌龟新的坐标; (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)
        # 乌龟每移动一次，体力消耗1
        self.power -= 1
    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 eat(self):
        # 当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
        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()
    # 创建10个鱼
    # fishs = []
    # for i in range(10):
    #     fishs.append(Fish())
    fishs = [Fish() for i in range(1000)]
    # 游戏开始运行
    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()

运行结果：

继承实现乌龟吃鱼游戏

import random
from day11.colorFont import FontColor
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
        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(1000)]

    font  = FontColor
    # 游戏开始运行
    while True:
        # 判断游戏是否结束(乌龟没体力或者鱼被吃光了)
        if t1.power <= 0:
            print(font.FAIL + "乌龟没体力了， Game over.........")
            break
        elif len(fishs) == 0:
            print(font.OKBULE + "鱼被吃光了， 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(font.OKBULE + "鱼被吃掉， 还剩%d条鱼......." %(len(fishs)))
                    print(font.OKGREEN + "乌龟最新体能为%s" %(t1.power))
            # 当乌龟的坐标与每一条鱼进行比较， 都没有重合， 也就是没有迟到一条鱼;
            else:
                print(font.FAIL + "乌龟没有吃到鱼， 最新体能为%s" %(t1.power))
# 如果这个脚本(模块)， 没有被调用， 则执行下面的代码
if __name__ == "__main__":
    print("游戏开始".center(50, '*'))
    start_game()
概念:
       - 父类与子类/基类和派生类
from io import TextIOWrapper

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()
print(open('/tmp/passwd'))
d1 = Dog("大黄", 3，100)
print(d1.name)
print(d1.age)
print(d1.power)


 1. 如果子类没有的属性和方法， 则去父类找， 如果父类也没有， 就报错。
d1.eat()
d1 = Dog("大黄", 3, 100)
print(d1.name)
print(d1.age)
print(d1.power)

 1. 如果子类没有的属性和方法， 则去父类找， 如果父类也没有， 就报错。
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)

    父类的私有方法， 子类是不能查看与操作
    def info(self):
        super(Dog, self).__info()
a = Animals('westos', 12)
d = Dog('westos', 12, 100)
 经典类
class Person1:
    pass
p1 = Person1()
print(p1)

新式类
class Person2(object):
    pass
p2 = Person2()
print(p2)
在python2中既有新式类也有经典类;


      经典类的继承算法: 深度优先算法
      新式类的继承算法: 广度优先算法
python3全部都是新式类;
class D:
    def test(self):
        print("D test")
class C(D):
    pass
    def test(self):
        print("C test")
class B(D):
    pass
class A(B,C):
    pass
a = A()
a.test()
运行结果：



    格式： \033[显示的方式;字体颜色;背景色m+显示内容
     - 0, 1(高亮)， 4(下划线) 5(闪烁) 7(反显)
class FontColor(object):
    OKBULE = '\033[94m'
    OKGREEN = '\033[92m'
    WARN = '\033[93m'
    FAIL = '\033[91m'

if __name__ == '__main__':
    f = FontColor()
    print(f.OKBULE + '你好')
    print(f.OKGREEN + '你好')
    print(f.WARN + '你好')
    print(f.FAIL + '你好')

运行结果