001 python基础实战

　　报名了阿里大学的AI，一直没有学习，今天开始正式学习。

　　今天是第一节，Python的基础编程实战，里面包含两个示例。

一：任务实现文件的批量重命名。

1.创建一个目录

　　

2.程序

 #!/usr/bin/python
 #-*- coding:UTF-8 -*-
 import os
 def remove_ad_text(dir2,text):
     """
     用来删除特定广告文本的函数
     该函数会检索指定根目录下的所有文件和目录，并递归，使得所有的广告词都删除
     :param dir2: 指定要检查的根目录
     :param text: 指定特定的广告词
     :return:
     """
     #如果不是目录，则返回
     if not os.path.isdir(dir2):
         return
     #如果传递的dir2末尾没有路径分隔符，则加入路径分割符
     if not dir2.endswith(os.path.sep):
         dir2+=os.path.sep

     #获取该目录下的所有文件或者文件夹，返回列表
     names=os.listdir(dir2)
     #依次遍历目录或者文件名  #对文件与子目录的处理方式不同
     for name in names:
         #拼接操作,路径和文件名
         sub_path=os.path.join(dir2,name)
         #是否为目录
         if(os.path.isdir(sub_path)):
             remove_ad_text(sub_path,text)
         ##都要重命名
         name=name.replace(text,"")
         #组合新路劲
         new_path=os.path.join(dir2,name)
         os.rename(sub_path,new_path)

 remove_ad_text(r"D:\下载的文件","[www.baidu.com]")

二：21点小游戏

1.题目规则

　　规则：2-9代表2-9,10-k代表10点，A可代表1点或者10点。

　　　　    庄家或者玩家各发两张牌，庄家只显示一张牌。

　　　　　1.玩家可以根据自己牌面的点数，选择是否再要下一张牌，可多次要牌，如果玩家的牌点数超过21点，则玩家负

　　　　    2.如果玩家没有超过21点，并且选择停牌，则庄家开始发牌，庄家如果没有达到17点，则一直要牌，如果达到17点，则必须停止。如果庄家牌面点数超过21点，则庄家负

　　           3.如果都没有达到21点，点数多着胜利。

2.程序分析

　　创建一副扑克牌

　　创建庄家和玩家

　　发牌，给庄家一张牌，给玩家发两张牌

　　玩家根据自己的牌面与庄家的牌面来选择是否要牌，这里要咨询

　　循环：

　　如果玩家要牌，则继续发牌。发牌之后，判断玩家是否爆牌，如果爆牌，则玩家负。

　　循环;

　　如果玩家停牌，则庄家开始要牌，如果庄家小于17，则无条件要牌，如果大于17，小于21，则必须停牌。如果庄家大于21，则庄家负。

　　如果都没有爆牌，则比较大小的点数。　　

3.程序

 #!/usr/bin/python
 #-*- coding:UTF-8 -*-
 import sys
 import random
 import time
 class Card:
     """
     定义扑克牌，每个对象是一个牌
     """
     def __init__(self,card_type,card_text,card_value):
         """
         初始化方法
         :param card_type: 扑克牌类型
         :param card_text: 扑克牌显示的文本
         :param card_value: 扑克牌的真实值
         """
         self.card_type=card_type
         self.card_text=card_text
         self.card_value=card_value

 class Role:
     """
     定义角色类，用来表示庄家与玩家，庄家是电脑，玩家是用户
     """
     def __init__(self):
         """
         初始化方法
         """
         #定义列表，用来保存当前角色手中的牌，初始化为空
         self.cards=[]

     def show_card(self):
         """
         向控制台上打印所有的牌
         :return:
         """
         for card in self.cards:
             print(card.card_type,card.card_text,sep="",end="")
         ##换行
         print()

     def get_value(self,min_or_max):
         """
         获得当前角色手中牌的点数，这里重要的是知道最大最小点数的计算方式
         :param min_or_max: str类型的，值为min或者max
             当值为min，返回最小点数。即所有的A都是1，用来判断是否爆牌
             当值为max，返回在不爆牌的时候的最大点数。即A可能表示为1或者11。
         :return:返回手中牌的点数
         """
         #总的点数
         sum2=0
         #A的数量
         A=0
         for card in self.cards:
             #累加牌面所有的点数
             sum2+=card.card_value
             if card.card_text=='A':
                 A+=1
         if min_or_max=='max':
             #逐渐减少A的数量
             for i in range(A):
                 value=sum2-i*10
                 if value<=21:
                     return value
         return sum2-A*10

     def burst(self):
         """
         判断是否爆牌，是则返回True，否则返回False
         :return: 返回bool
         """
         return self.get_value("min")>21

 class CardManager:
     """
     扑克牌的管理者，管理一整套牌，并且可以发牌
     """
     def __init__(self):
         #保存一整套扑克牌
         self.cards=[]
         #定义牌的类型
         all_card_type="♥♠♣♦"
         #定义牌面的文本
         all_card_text=['A','K','Q','J','','','','','','','','','']
         #定义真实值
         all_card_value=[11,10,10,10,10,9,8,7,6,5,4,3,2]
         #一个嵌套循环，创建一个扑克牌
         for card_type in all_card_type:
             for index,card_text in enumerate(all_card_text):
                 card=Card(card_type,card_text,all_card_value[index])
                 ##加到整副扑克牌
                 self.cards.append(card)
         ##洗牌，方便发牌
         random.shuffle(self.cards)

     def send_card(self,role,num=1):
         """
         给电脑或者玩家发牌,不能重复的发牌
         :param role: 角色
         :param num: 发牌的张数，默认为1张
         :return:
         """
         for i in range(num):
             card=self.cards.pop()
             role.cards.append(card)

 ##测试
 #创建扑克牌管理器
 cards=CardManager()
 #创建角色
 computer=Role()
 player=Role()
 #初始化
 cards.send_card(computer)
 cards.send_card(player,2)
 ##显示
 computer.show_card()
 player.show_card()

 ##询问玩家是否要牌
 while True:
     choice=input("是否再要一张牌？【y/n】")
     if choice=='y':
         cards.send_card(player)
         player.show_card()
         computer.show_card()
         #判断，玩家是否爆牌
         if player.burst():
             print("爆牌，输了")
             sys.exit()
     else:
         break

 ##庄家发牌
 while True:
     print("庄家发牌中----")
     #产生一个间隔
     time.sleep(1)
     cards.send_card(computer)
     player.show_card()
     computer.show_card()
     ##判断，是否爆牌
     if computer.burst():
         print("庄家爆牌，你赢了")
         sys.exit()
     elif computer.get_value("max")>=17:
         break

 ##做判断，前提是没有爆牌
 play_value=player.get_value("max")
 computer_value=computer.get_value("max")
 if play_value>computer_value:
     print("你赢了")
 elif play_value== computer_value:
     print("平局")
 else:
     print("你输了")

4.效果