总结
1. 类的继承
-
什么是继承
""" 继承就是让子类直接拥有父类的属性和方法 子类 - 继承者 父类 - 被继承者 """ -
继承的语法
""" class 类名(父类1, 父类2，...): pass 定义类的时候如果没有写继承关系，那么这个类默认继承python的基类: object classs 类名: == class 类名(object): """ # 子类继承父类的属性和方法 class Person: num = 0 def __init__(self, name, age, gender): self.name = name self.age = age self.gender = gender Person.num += 1 def func1(self): print(f'{self.name}今年{self.age}岁!') @classmethod def func2(cls): print(f'人类的数量:{cls.num}') @staticmethod def func3(): print('人类破坏环境！') class Student(Person): pass if __name__ == '__main__': print(Student.num) stu = Student('小米', 18, '男') stu.func1() stu.func2() stu.func3() print('='*30) -
子类中添加属性和方法
""" 1) 添加类属性和方法 直接在子类中添加新的类属性和新的方法 2) 对象属性 在子类中的__init__方法中添加新的对象属性，同时使用supper()去调用父类的__init__方法 supper的用法： supper(类, 对象).方法() - 调用指定类的父类的指定方法 """ class A: x = 10 def __init__(self, a, b): self.a = a self.b = b def func1(self): print('A中的对象方法') class C: z = 100 def __init__(self, y): self.y = y def func1(self): print('C中的对象方法') def funcc(self): print('c中的对象方法') class B(A, C): f = 'abc' def __init__(self, a, b, id=None, shool=None): # super(B, self).__init__(a, b) super().__init__(a, b) C.__init__(self, a) # A.__init__(self, a, b) self.study_id = id or '991' self.school = shool or '清华大学' def func2(self): print('B中的对象方法') @classmethod def func3(cls): print(f'B中的类属性{B.x}') def func1(self): super().func1() C.func1(self) if __name__ == '__main__': b = B(1, 3) b.func2() print('='*10) b.func1() print('='*10) b.func3() b.funcc() print(b.study_id, b.a, b.y) -
类中的方法的调用
""" 在通过类或者对象的调用方法的时候，会先看当前类是否存在这个方法，如果存在就直接使用，如果不存在就看父类中由没有对应的方法，如果由就父类 中的这个方法，父类也没有就看父类的父类...以此类推，如果找到基类都没有，程序才报错 """ class Animal: num = 0 def __init__(self): self.gender = "雌" self.age =1 def func1(self): print(f'动物的对象方法{self.gender}') class Fly: name = '飞行器' def __init__(self): self.height = 3 self.distance = 10 def func2(self): print('Fly的对象方法') class Bird(Animal, Fly): pass b = Bird() print(b.gender) -
私有化
""" 类的内容的访问权限分为三种 公开的：在类的内部和类的外部都可以使用，并且可以被继承 保护的：在类的内部可以使用，可以被继承，但是不能类的外部使用 私有的：只能在类的内部使用，不能被继承也不能在类的外部使用 从真正意义的访问权限上讲：python中所有的内容都是公开的。python的私有化是假的私有化 """ class A: num = 100 __name = 'abc' @classmethod def func1(cls): print('类的内部num', cls.num) print('类的内部num', cls.__name) print(A.num) print(A.__dict__) print(A._A__name) # AttributeError: type object 'A' has no attribute '__name'
2. 自动化办公
-
发送邮件的基本流程
-
连接服务器
# import smtplib # 连接对象 = smtplip.SMTP_SSL(服务器地址, 邮箱服务端口) # # - 服务器地址：smtp.163.com(163邮箱)、smtp.qq.com(qq邮箱) # - 邮箱服务端口：465或者25 import smtplib con = smtplib.SMTP_SSL('smtp.qq.com', 465) -
登录账号
# 连接对象.login(邮箱账号, 密码) # # - 密码：如果是163邮箱直接使用邮箱的登录密码，如果是qq邮箱就使用授权码 con.login('220924512324@qq.com', 'jfaweriaugfhj') -
创建邮件对象
# 邮件对象 = MIMEMultipart() from email.mime.multipart import MIMEMultipart email = MIMEMultipart() -
添加发件人以及收件人
# 邮件对象['From'] = '用户名 <用户名>' # 邮件对象['To'] = '收件人1' email['From'] = '宇视佟骏' email['To'] = '至幸运的您' -
添加主题
# 主题对象 = Header(邮件标题, 编码方式).encode() # 邮件对象['Subject'] = 主题对象 from email.header import Header email['Subject'] = Header('小幸运', 'utf-8').encode() -
添加正文
# 文字内容对象 = MIMEText(内容, 类型, 编码方式) # - 内容：就是文字字符串 # - 类型：plain(简单的文字内容)、html(超文本) # 邮件对象.attach(文字对象) from email.mime.text import MIMEText msg = MIMEText('哈哈哈哈哈哈哈哈哈！', 'plain', 'utf-8') -
添加附件
-
添加图片
from email.mime.image import MIMEImage with open(r'.\test.png', 'rb') as f: image = MIMEImage(f.read()) image["Content-Disposition"] = 'attachment; filename="image.jpg"' email.attach(image) -
添加附件
with open(r'.\test.pdf', 'rb') as f: content = MIMEText(f.read(), 'base64', 'utf-8') content["Content-Dosposition"] = 'attachment; filename="test.pdf"' email.attach(content)
-
-
发送邮件
con.sendmail('220924512324@qq.com', '132456234324@qq.com', email.as_string()) -
关闭连接
con.quit()
-
作业
#classTools.py
from random import shuffle
class Game:
def __init__(self) -> None:
pass
def play(self):
pass
class Player:
def __init__(self, name):
self.name = name
class LandlordsPlayer(Player):
def __init__(self, name):
super().__init__(name)
self.cards = []
self.choice_cards = []
self.old_choice_cards = self.choice_cards
def get_card(self, card):
self.cards.extend(card)
self.__sord_card()
def __sord_card(self):
self.cards.sort(key=lambda x: CardsTag.transform(x), reverse=True)
def show_cards(self):
self.old_choice_cards = self.choice_cards
self.choice_cards = []
return self.old_choice_cards
def choice_card(self, card):
# card = [self.cards[x] for x in card]
for x in card:
self.choice_cards.append(self.cards.pop(int(x)))
# self.choice_cards.append(x)
# self.cards.remove(x)
def cancel_choice_card(self, *card):
for x in card:
self.cards.append(x)
self.choice_cards.remove(x)
def cancel_choice(self):
self.cards.extend(self.choice_cards)
self.choice_cards = []
self.__sord_card()
def is_pass(self):
if len(self.choice_cards) == 0:
return True
return False
def is_end(self):
if self.cards:
return False
return True
class Farmer(LandlordsPlayer):
max_cards = 17
def __init__(self, name):
super().__init__(name)
self.cards_count = 0
def get_card(self, *card):
if self.cards_count < Farmer.max_cards:
super(Farmer, self).get_card(card)
self.cards_count += len(card)
class Landowner(LandlordsPlayer):
max_cards = 20
def __init__(self, farmer1: Farmer):
super().__init__(farmer1.name)
self.__dict__ = farmer1.__dict__
class CardsTag:
hearts_cards = ['♥3', '♥4', '♥5', '♥6', '♥7', '♥8', '♥9', '♥10', '♥J', '♥Q', '♥K', '♥A', '♥2']
spade_cards = ['♠3', '♠4', '♠5', '♠6', '♠7', '♠8', '♠9', '♠10', '♠J', '♠Q', '♠K', '♠A', '♠2']
wintersweet_cards = ['♣3', '♣4', '♣5', '♣6', '♣7', '♣8', '♣9', '♣10', '♣J', '♣Q', '♣K', '♣A', '♣2']
block_cards = ['♦3', '♦4', '♦5', '♦6', '♦7', '♦8', '♦9', '♦10', '♦J', '♦Q', '♦K', '♦A', '♦2']
other_cards = ['joker', 'JOKER']
@staticmethod
def transform(*card):
list1 = []
for x in card:
list1.append(CardsTag.__card_index(x))
return list1
@staticmethod
def compare_card(card1, card2):
return CardsTag.__card_index(card2) > CardsTag.__card_index(card1)
@staticmethod
def __card_index_(card, list1):
count = 1
for _card in list1:
if card == _card:
return count
count += 1
else:
return 0
@staticmethod
def __card_index(card):
return CardsTag.__card_index_(card, CardsTag.hearts_cards) or CardsTag.__card_index_(card, CardsTag.spade_cards) or CardsTag.__card_index_(card, CardsTag.wintersweet_cards) or CardsTag.__card_index_(card, CardsTag.block_cards) or CardsTag.__card_index_(card, CardsTag.block_cards) + 14
class Cards:
num = 54
def __init__(self):
self.data = CardsTag.hearts_cards + CardsTag.spade_cards + CardsTag.wintersweet_cards + CardsTag.block_cards + CardsTag.other_cards
class CardMachine:
def __init__(self, cards, deal_cards = 1):
self.one_deal_cards = deal_cards
self.cards = cards.data
self.cards_iter = iter(self.cards)
self.num = cards.num
self.index = 0
def deal(self):
deal_cards = list()
for _ in range(self.one_deal_cards):
deal_cards.append(self.one_deal())
return deal_cards
def one_deal(self):
if self.index < self.num:
self.index += 1
return next(self.cards_iter)
return None
def shuffle_cards(self):
shuffle(self.cards)
self.cards_iter = iter(self.cards)
self.index = 0
class CardsRule:
def compare(self, *args, **kwargs):
pass
def conform(self, *args, **kwargs):
pass
class OneCardRule(CardsRule):
def compare(self, card1, card2):
return CardsTag.compare_card(card1[0], card2[0])
def conform(self, card):
card = CardsTag.transform(*card)
if len(card) >= 4 and len(set(card)) == 1:
return True, True
if len(card) == 1:
return True, False
else:
return False, False
class TwoCardRule(CardsRule):
def compare(self, cards1, cards2):
return CardsTag.compare_card(cards1[0], cards2[0])
def conform(self, card):
print(card)
card = CardsTag.transform(*card)
if len(set(card)) == 1:
if len(card) == 2:
return True, False
elif len(card) >= 4:
return True, True
return False, False
return False, False
class FourCardRule(CardsRule):
def compare(self, cards1, cards2):
card1 = max(cards1, key=cards1.count)
card2 = max(cards2, key=cards2.count)
return CardsTag.compare_card(card1, card2)
def conform(self, card):
card = CardsTag.transform(*card)
set_card = list(set(card))
len_card = len(card)
if len_card >= 4 and len(set_card) == 1:
return True, True
if len_card == 4 and set_card == 2:
if card.count(set_card[0]) in [1, 3]:
return True, False
return False, False
else:
return False, False
class CrumpCardRule(CardsRule):
def compare(self, cards1, cards2):
if len(cards2) > len(cards1):
return True
else:
return CardsTag.compare_card(cards1[0], cards2[0])
def conform(self, card):
card = CardsTag.transform(*card)
set_card = list(set(card))
len_card = len(card)
if len_card >= 4 and len(set_card) == 1:
return True, False
class RuleFactory:
@staticmethod
def create_rule(count):
if count == 1:
return OneCardRule()
elif count == 2:
return TwoCardRule()
elif count == 4:
return FourCardRule()
class Landlords(Game):
def __init__(self, dealer: CardMachine, player1: LandlordsPlayer, player2: LandlordsPlayer, player3: LandlordsPlayer) -> None:
super().__init__()
self.dealer = dealer
self.player1 = player1
self.player2 = player2
self.player3 = player3
def play(self):
print('斗地主游戏'.center(40, '='))
print('\n'*2)
players = [self.player1, self.player2, self.player3]
shuffle(players)
self.dealer.shuffle_cards()
final_cards = []
for _ in range(3):
final_cards.append(self.dealer.one_deal())
card = self.dealer.one_deal()
while card:
for player in players:
player.get_card(card)
card = self.dealer.one_deal()
print(f'玩家({self.player1.name}):{self.player1.cards}')
print(f'玩家({self.player2.name}):{self.player2.cards}')
print(f'玩家({self.player3.name}):{self.player3.cards}')
print(f'底牌({final_cards})')
print('\n'*2)
for player in players:
is_landowner = input(f'请问您玩家({player.name})是否当地主(1: 是 其他: 否)：')
if is_landowner == '1':
landowner1 = Landowner(player)
landowner1.get_card(final_cards)
players.remove(player)
break
else:
return
print(f'玩家({self.player1.name}):{self.player1.cards}')
print(f'玩家({self.player2.name}):{self.player2.cards}')
print(f'玩家({self.player3.name}):{self.player3.cards}')
players.insert(0, landowner1)
out_card_index = 0
old_out_card_player = None
while True:
player = players[out_card_index % 3]
while True:
print(f'玩家（{player.name}）请选择出牌：')
print(f'玩家（{player.name}）的牌是:{player.cards}')
player.choice_card(self.out_cards())
if not rule:
if len(player.choice_cards) == 0:
continue
rule = RuleFactory.create_rule(len(player.choice_cards))
else:
if len(player.choice_cards) == 0:
break
correct, degree = rule.conform(player.choice_cards)
if correct:
if degree:
rule = RuleFactory.create_rule(5) # 炸弹的规则
break
player.cancel_choice()
print(f'玩家:{player.name}选择出牌错误================================')
if player.is_pass():
if old_out_card_player and len(old_out_card_player.old_choice_cards) == 0:
rule = None
print(f'玩家（{player.name}）选择pass')
player.show_cards()
else:
print(f'玩家（{player.name}）出牌的牌是：{player.show_cards()}')
out_card_index += 1
old_out_card_player = player
if player.is_end():
break
def out_cards(self):
outs = input('请输入要出的牌(牌与牌之间用空格隔开)：')
res = outs.split(' ')
return res
from classTools import *
if __name__ == '__main__':
new_cards = Cards()
new_machine = CardMachine(new_cards, 1)
player1 = Farmer('小米')
player2 = Farmer('小酒')
player3 = Farmer('阳阳')
game = Landlords(new_machine, player1, player2, player3)
game.play()
10 > 2
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
