发牌游戏:
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的时候数据会自动销毁