001 python基础实战

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

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

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

1.创建一个目录

2.程序

 1 #!/usr/bin/python
 2 #-*- coding:UTF-8 -*-
 3 import os
 4 def remove_ad_text(dir2,text):
 5     """
 6     用来删除特定广告文本的函数
 7     该函数会检索指定根目录下的所有文件和目录，并递归，使得所有的广告词都删除
 8     :param dir2: 指定要检查的根目录
 9     :param text: 指定特定的广告词
10     :return:
11     """
12     #如果不是目录，则返回
13     if not os.path.isdir(dir2):
14         return
15     #如果传递的dir2末尾没有路径分隔符，则加入路径分割符
16     if not dir2.endswith(os.path.sep):
17         dir2+=os.path.sep
18 
19     #获取该目录下的所有文件或者文件夹，返回列表
20     names=os.listdir(dir2)
21     #依次遍历目录或者文件名  #对文件与子目录的处理方式不同
22     for name in names:
23         #拼接操作,路径和文件名
24         sub_path=os.path.join(dir2,name)
25         #是否为目录
26         if(os.path.isdir(sub_path)):
27             remove_ad_text(sub_path,text)
28         ##都要重命名
29         name=name.replace(text,"")
30         #组合新路劲
31         new_path=os.path.join(dir2,name)
32         os.rename(sub_path,new_path)
33 
34 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.程序

  1 #!/usr/bin/python
  2 #-*- coding:UTF-8 -*-
  3 import sys
  4 import random
  5 import time
  6 class Card:
  7     """
  8     定义扑克牌，每个对象是一个牌
  9     """
 10     def __init__(self,card_type,card_text,card_value):
 11         """
 12         初始化方法
 13         :param card_type: 扑克牌类型
 14         :param card_text: 扑克牌显示的文本
 15         :param card_value: 扑克牌的真实值
 16         """
 17         self.card_type=card_type
 18         self.card_text=card_text
 19         self.card_value=card_value
 20 
 21 class Role:
 22     """
 23     定义角色类，用来表示庄家与玩家，庄家是电脑，玩家是用户
 24     """
 25     def __init__(self):
 26         """
 27         初始化方法
 28         """
 29         #定义列表，用来保存当前角色手中的牌，初始化为空
 30         self.cards=[]
 31 
 32     def show_card(self):
 33         """
 34         向控制台上打印所有的牌
 35         :return:
 36         """
 37         for card in self.cards:
 38             print(card.card_type,card.card_text,sep="",end="")
 39         ##换行
 40         print()
 41 
 42     def get_value(self,min_or_max):
 43         """
 44         获得当前角色手中牌的点数，这里重要的是知道最大最小点数的计算方式
 45         :param min_or_max: str类型的，值为min或者max
 46             当值为min，返回最小点数。即所有的A都是1，用来判断是否爆牌
 47             当值为max，返回在不爆牌的时候的最大点数。即A可能表示为1或者11。
 48         :return:返回手中牌的点数
 49         """
 50         #总的点数
 51         sum2=0
 52         #A的数量
 53         A=0
 54         for card in self.cards:
 55             #累加牌面所有的点数
 56             sum2+=card.card_value
 57             if card.card_text=='A':
 58                 A+=1
 59         if min_or_max=='max':
 60             #逐渐减少A的数量
 61             for i in range(A):
 62                 value=sum2-i*10
 63                 if value<=21:
 64                     return value
 65         return sum2-A*10
 66 
 67     def burst(self):
 68         """
 69         判断是否爆牌，是则返回True，否则返回False
 70         :return: 返回bool
 71         """
 72         return self.get_value("min")>21
 73 
 74 class CardManager:
 75     """
 76     扑克牌的管理者，管理一整套牌，并且可以发牌
 77     """
 78     def __init__(self):
 79         #保存一整套扑克牌
 80         self.cards=[]
 81         #定义牌的类型
 82         all_card_type="♥♠♣♦"
 83         #定义牌面的文本
 84         all_card_text=['A','K','Q','J','10','9','8','7','6','5','4','3','2']
 85         #定义真实值
 86         all_card_value=[11,10,10,10,10,9,8,7,6,5,4,3,2]
 87         #一个嵌套循环，创建一个扑克牌
 88         for card_type in all_card_type:
 89             for index,card_text in enumerate(all_card_text):
 90                 card=Card(card_type,card_text,all_card_value[index])
 91                 ##加到整副扑克牌
 92                 self.cards.append(card)
 93         ##洗牌，方便发牌
 94         random.shuffle(self.cards)
 95 
 96     def send_card(self,role,num=1):
 97         """
 98         给电脑或者玩家发牌,不能重复的发牌
 99         :param role: 角色
100         :param num: 发牌的张数，默认为1张
101         :return:
102         """
103         for i in range(num):
104             card=self.cards.pop()
105             role.cards.append(card)
106 
107 
108 ##测试
109 #创建扑克牌管理器
110 cards=CardManager()
111 #创建角色
112 computer=Role()
113 player=Role()
114 #初始化
115 cards.send_card(computer)
116 cards.send_card(player,2)
117 ##显示
118 computer.show_card()
119 player.show_card()
120 
121 ##询问玩家是否要牌
122 while True:
123     choice=input("是否再要一张牌？【y/n】")
124     if choice=='y':
125         cards.send_card(player)
126         player.show_card()
127         computer.show_card()
128         #判断，玩家是否爆牌
129         if player.burst():
130             print("爆牌，输了")
131             sys.exit()
132     else:
133         break
134 
135 ##庄家发牌
136 while True:
137     print("庄家发牌中----")
138     #产生一个间隔
139     time.sleep(1)
140     cards.send_card(computer)
141     player.show_card()
142     computer.show_card()
143     ##判断，是否爆牌
144     if computer.burst():
145         print("庄家爆牌，你赢了")
146         sys.exit()
147     elif computer.get_value("max")>=17:
148         break
149 
150 ##做判断，前提是没有爆牌
151 play_value=player.get_value("max")
152 computer_value=computer.get_value("max")
153 if play_value>computer_value:
154     print("你赢了")
155 elif play_value== computer_value:
156     print("平局")
157 else:
158     print("你输了")

4.效果