2021.2.25

最新推荐文章于 2023-09-22 10:12:30 发布

Yl~~

最新推荐文章于 2023-09-22 10:12:30 发布

阅读量117

点赞数

本文链接：https://blog.csdn.net/m0_54712172/article/details/114112153

版权

发牌游戏：
from random import shuffle


class Poker:
    colors = ['♥', '♠', '♣', '♦']
    numbers = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'joker', 'JOKER']
    table1 = {'J': 11, 'Q': 12, 'K': 13, 'A': 14, '2': 15, 'joker': 16, 'JOKER': 17}

    def __init__(self, color, number):
        self.color = color
        self.number = number

    def __repr__(self):
        return f'{self.color}{self.number}'

    def __get_poker_value(self):
        number = self.number
        if '3' <= number <= '9' or number == '10':
            return int(number)
        return Poker.table1[number]

    def __lt__(self, other):
        return self.__get_poker_value() < other.__get_poker_value()


class PokerGame:
    def __init__(self):
        # 一副牌
        self.pokers = []
        for n in Poker.numbers[:-2]:
            for c in Poker.colors:
                p = Poker(c, n)
                self.pokers.append(p)
        self.pokers.extend([Poker('', Poker.numbers[-2]), Poker('', Poker.numbers[-1])])
        print(self.pokers)

    def shuffle(self):
        """洗牌"""
        # 需要一副牌，然后把牌的顺序打乱
        shuffle(self.pokers)
        print(self.pokers)

    def deal(self):
        """发牌"""
        self.shuffle()
        p1 = []
        p2 = []
        p3 = []
        for _ in range(17):
            p1.append(self.pokers.pop(0))
            p2.append(self.pokers.pop(0))
            p3.append(self.pokers.pop(0))
        return sorted(p1, reverse=True), sorted(p2, reverse=True), sorted(p3, reverse=True), self.pokers


game1 = PokerGame()
print(game1.deal())

一.继承

1.什么是继承

子类直接拥有父类的属性和方法的过程就是继承

子类：继承者

父类：被继承者，父类又叫超类

2.怎么继承

'''
class 子类(父类）：
    pass
 注意：a.如果定义类的时候没有添加父类，默认继承python的基类object
 	  b.同一个子类可以同时继承多个父类，class 子类(父类1， 父类2， ...)
 python 中子类可以继承父类所有的属性和方法
'''

class Person:
    num = 61
    def __init__(self):
        self.name = '小红'
        self.age = 18
        self.gender = '男'

    def eat(self, food):
        print(f'{self.name}在吃{food}')

    @classmethod
    def show_num(cls):
        print('人类数量：', cls.num)

    @staticmethod
    def info():
        print('认类破坏环境')


class Student(Person):
    pass

stu1 = Student()
print(Student.num) # 61
print(stu1.name, stu1.age, stu1.gender)  # 小红 18 男
stu1.eat('包子')  # 小红在吃包子
stu1.show_num() #  人类数量：61
stu1.info()  # 认类破坏环境

二.重写

1.在子类中添加属性和方法

1）添加类属性:直接在子类中定义新的类属性

2）添加方法：直接在子类中定义新的方法

在子类中添加方法的时候可以对父类的方法进行重写

在子类中可以通过’super().方法’的形式来调用父类的方法。（注意：不能在静态方法中使用super()调用父类的方法！！！如果要调用：super(类，对象).方法（）

总结：super用法

可以通过super在子类中调用父类中的方法。

super（).方法（） - 直接调用当前类的父类的指定方法

super（类，对象）.方法（） - 调用指定类的父类的指定方法（要求对象必须是前面的类的对象）

class A:
    x = 100

    @staticmethod
    def func1():
        print('A')

    @classmethod
    def funca(cls):
        print('A1')

    def func4(self):
        print('A的对象方法1')

    def func5(self):
        print('A的对象方法2')


class B(A):
    y = 20

    @classmethod
    def func2(cls):
        print('B')

    @staticmethod
    def func1():
        print('BB')

    @classmethod
    def funca(cls):
        super().funca()  # A1 在对象方法中调用父类方法
        """cls.__base__.funca()"""
        print('B2')

    def func4(self):
        super().func4()
        super().func5()
        print('B的对象方法')

    @staticmethod
    def func3():
        # super().func1()  # 报错
        super(B, B()).func1()
        print('B的静态')


class C(B):
    pass


print(A.x)  # 100
print(B.x)  # 100
print(C.x)  # 100 孙子可以通过父亲继承爷爷

print(B.y)  #  # 20
# print(A.y)   # 父类不能调用子类
print(C.y)  # 20

B.func1()   # BB #子类里面有func1，就不会去继承父类的func1
A.func1()   # A

B.funca()  # A1   B2

class Animal:
    def __init__(self):
        self.age = 0
        self.gender = '雌'


class Cat(Animal):
    def __init__(self):
        super().__init__()
        self.color = '白色'
        self.price = 2000
        self.breed = '野猫'
    pass


cat = Cat()
print(cat.age, cat.gender)  # 0 雌
print(cat.color)  # 白色

3）对象属性的添加问题

在子类的__init__方法中通过super()去调用父类的__init__。
class A:
    def __init__(self, a, b=10):
        # a = 200, b=10
        self.a = a    # 200
        self.b = b    # 10
        self.c = 0    # 0


class B(A):
    def __init__(self, d, a):
        # d = 100, a = 200
        # super().__init__(100)
        super(B, self).__init__(a)   # A: __init__(200)
        self.d = d    # 100


bb = B(100, 200)    # B: __init__(100, 200)
print(bb.a, bb.b, bb.c, bb.d)

# 练习：
# 创建一个人类有属性：姓名、年龄、性别，要求创建人的对象的时候姓名和年龄必须赋值，性别可以赋值也可以不赋（默认是男）
# 创建学生类有属性：姓名、年龄、性别、学号、学分和电话，要求创建学生对象的时候，姓名和电话必须赋值。
# 年龄和性别可以赋值也可以不赋（默认是18和年），学分和学号创建的时候不能赋值，默认值分别是'000'和0

class Person:
    def __init__(self, name, age, gender = '男'):
        self.name = name
        self.age = age
        self.gender= gender

class Student(Person):
    def __init__(self, name, tel, gender = '男', age = 18):
        super(Student, self).__init__(name, age, gender)
        self.tel  = tel
        self.score = '000'
        self.stu_id = 0
person = Person('花花', 20)
student = Student('明明', 110)

三.多继承

多继承的时候子类可以继承所有父类的类属性和方法，但是只能继承第一个父类的对象属性

# __mro__

class Animal:
    num = 61

    def __init__(self):
        self.age = 0
        self.gender = '雄'

    @classmethod
    def show(cls):
        print('数量：', cls.num)


class Fly:
    name = '飞行器'

    def __init__(self):
        self.height = 100
        self.time = 3

    @staticmethod
    def message():
        print('飞行器')


class Bird(Fly, Animal):
    pass


print(Bird.num, Bird.name)
Bird.show()  # 数量： 61
Bird.message()  # 飞行器
b = Bird()
# print(b.age, b.gender)  # 报错，因为只能继承第一个父类的对象属性
print(b.height, b.time)  # 100 3

四.私有化

访问权限（编程常识）：

公开的：在类的内部可以使用、类的外部也可以使用还可以被继承（python中所有的属性和方法都是公开）

保护的：在类的内部可以使用，可以被继承

私有的：在类的内部可以使用

python的私有化：

# python的私有化
# 方法：在属性名或者方法名前加__就可以让属性或者方法变成私有的
# 原理：假的私有化; 在__开头的名字前加'_类名'

class A:
    num = 100
    __x = 200    # __x是私有的

    def __init__(self):
        self.name = '小明'
        self.__age = 18   # __age是私有的

    def info(self):
        print('信息：', self.__age)
        self.__f1()

    @classmethod
    def show(cls):
        print(cls.num, cls.__x)  # 100 200

    def __f1(self):
        print('对象方法')


print(A.num)  #  100
A.show()  # 100 200

# print(A.__x)  # 报错

a = A()
print(a.name)  # 小明
# print(a.__age)

print(a.__dict__)   # {'name': '小明', '_A__age': 18}
print(a._A__age)  #  # 18

五.拷贝

浅拷贝和深拷贝的区别：

不管是浅拷贝和深拷贝都是赋值被拷贝的对象产生一个新的对象，然后用新的对象来赋值

如果被拷贝的对象中有子对象，浅拷贝不复制子对象用原来的，深拷贝会复制新的子对象产生新的子对象。

from copy import  copy,deepcopy
A = [10, 20, 30, ['abc', '123']]
B = A
C = copy(A)
D = deepcopy(A)

A.append(100)
A[3].pop()

print(B)  # [10, 20, 30,['abc'],100]
print(C)  # [10, 20, 30, ['abc']]
print(D)  # [10,20,30,['abc', '123']]

六.内存管理

内存管理分为内存的开辟和释放：

1.内存的开辟 - 使用数据的时候就申请内存保存数据

python中所有的类型都是类，所有的数据都是对象，对象都是保存在堆里面

在保存数据的时候相同的不可变数据内存只保存一份，相同的可变数据在内存中会保存多份

a = 100
age = 100
list1 = [100, 200]
print(id(a), id(age), id(list1[0])) # 140718536987408 140718536987408 140718536987408

a = [10, 20]
b = [10, 20]
c = [100, [10, 20]]
print(id(a), id(b), id(c[-1]))  # 2171449045056 2171449361984 2171449362048

2.内存的释放 - 垃圾回收机制

python中内存的某个数据是否销毁（对应的内存是否释放），看这个数据在程序中的引用个数，当引用个数大于0 的时候数据不会被销毁，当数据的应用个数为0的时候数据会自动销毁