【Python学习】Python基础应用

一、文件的批量重命名

1.判断是否是目录

1. 相对路径：从当前所在目录开始链接的路径(不是从根目录开始链接的路径)
2. 绝对路径：从根目录开始链接的路径

import os
# 判断是否是目录
path = r'F:\MyDesktop\test'
print(os.path.isdir(path))

2.重命名文件

os.rename(oldFilePath, newFilePath)

3.遍历当前目录

import os
# 遍历该目录
path = r'F:\MyDesktop\test'
print(os.listdir(path))

4.递归遍历

1. 递归：函数自身调用自身形成递归
2. 递归函数：可以调用自身的函数成为递归函数
3. 只要是循环能办到的事，递归就可以做
4. 递归思路：
   1. 找到临界条件
   2. 假设当前函数已经能用，调用自身得到结果
   3. 找到本次和上一次的关系
5. 注意：

def mySum(n):
    if n == 1:
        return 1
    return mySum(n - 1) + n
print(mySum(5))

5.栈模拟递归遍历

1. 栈：先进后出

6.队列模拟递归遍历

1. 队列：先进先出

7.练习-文件批量重命名(递归)

import os

# 给一个目录路径，可以重命名（去掉名字中的sunck）
def renamePath(path):
    if not os.path.isdir(path):
        # 结束程序
        return -1

    filesName = os.listdir(path)
    for fileName in filesName:
        # 拼接路径
        filePath = os.path.join(path, fileName)
        # 判断是否是目录
        if not os.path.isdir(filePath):
            # 文件
            newFileName = fileName.replace('sunck', '')
            newFilePath = os.path.join(path, newFileName)
            os.rename(filePath, newFilePath)
        else:
            # 目录
            renamePath(filePath)

def main():
    # 要修改的文件路径
    path = r'F:\MyDesktop\test\a'
    renamePath(path)


if __name__ == '__main__':
    main()

二、二十一点小游戏

• 设计类

"""
    设计类：
        玩家类：
            类名：Player
            属性：type(False电脑，True玩家)、money、点数、cards(手中牌的列表，元素为扑克对象)
            行为：获取一张扑克牌的点数、计算所有扑克牌的点数、亮牌、判断是否爆牌
        扑克牌类：
            类名：Poker
            属性：花色(♠ ♥ ♣ ♦ ? ?)、牌面值(A 2 3 4 5 6 7 8 9 10 J Q K D X)、点数
            行为：
        扑克管理类(一副扑克)：
            类名：PokerManager
            属性：Pokers(一副扑克列表)、PokerNumber(牌数量)
            行为：洗牌、发牌
"""

• player.py

class Player(object):
    def __init__(self, type):
        self.type   = type
        self.pokers = []
        self.point  = 0

    def show_poker(self, index=0):
        return "%s%s"%(self.pokers[index].type, self.pokers[index].value)
    def show_pokers(self):
        ret = ""
        index = 0
        while index < len(self.pokers):
            ret = ret + self.show_poker(index) + "  "
            index += 1
        return ret



    #获取一张扑克牌的点数
    def get_poker_point(self, poker, Aflag=False):
        if poker.value == "A":
            if Aflag:
                return 11
            else:
                return 1
        elif poker.value in ["J", "Q", "K"]:
            return 10
        else:
            return int(poker.value)
    #计算所有扑克牌的点数
    def get_pokers_point(self):
        self.point = 0
        Alist = []
        for poker in self.pokers:
            if poker.value == "A":
                Alist.append(poker)
            else:
                self.point += self.get_poker_point(poker)
        for poker in Alist:
            # A  A
            #    21           0
            subPoint = 21 - self.point
            if self.get_poker_point(poker, True) <= subPoint:
                self.point += 11
            else:
                self.point += 1


    def isboom(self):
        point = 0
        for poker in self.pokers:
            point += self.get_poker_point(poker)
        if point > 21:
            return -1

• poker.py

class Poker(object):
    def __init__(self, type, value):
        self.type  = type
        self.value = value
    def __str__(self):
        return "%s%s"%(self.type, self.value)

• poker_manager.py

import random
from poker import Poker


class PokerManager(object):
    def __init__(self):
        # 创建54扑克
        self.pokers = []
        for type in ["♠", "♦", "♥", "♣"]:
            for value in ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]:
                #创建扑克对象
                poker = Poker(type, value)
                #管理扑克对象
                self.pokers.append(poker)
        self.pokers.append(Poker("?", "D"))
        self.pokers.append(Poker("?", "X"))

    def __str__(self):
        ret = ""
        for poker in self.pokers:
            pokerStr = "%s%s"%(poker.type, poker.value)
            ret = ret + pokerStr + "  "
        return ret

    def shuffle_21dian(self):
        # 去掉大小王
        self.pokers.pop()
        self.pokers.pop()
        random.shuffle(self.pokers)

    # 从一副扑克中抽取一张牌
    def send_poker(self):
        return self.pokers.pop()
    # 给某个玩家发num张牌
    def send_pokers(self, player, num):
        for index in range(num):
            poker = self.send_poker()
            player.pokers.append(poker)

• main.py

from poker_manager import PokerManager
from player import Player

def main():
    #创建扑克牌管理对象
    pm = PokerManager()
    #洗牌
    pm.shuffle_21dian()

    #创建游戏者并发牌
    player = Player(True)
    pm.send_pokers(player, 2)
    computer = Player(False)
    pm.send_pokers(computer, 2)

    #亮牌
    print("庄家首张扑克牌为：%s"%(computer.show_poker()))
    # print(computer.show_pokers())
    # print(player.show_pokers())

    #玩家的时间
    print("------------玩家时刻------------")
    while 1:
        print("玩家：%s"%(player.show_pokers()))
        flag = input("是否继续要牌？y/n")
        if flag.upper() == "Y":
            #发一张牌
            pm.send_pokers(player, 1)

            #判断是否爆牌
            if player.isboom():
                #自爆，结束程序
                print("玩家：%s" % (player.show_pokers()))
                print("玩家输了")
                return
        elif flag.upper() == "N":
            # 计算点数并保存
            player.get_pokers_point()
            print("玩家点数：%d"%(player.point))
            break
        else:
            print("输入错误，请重新选择！")


    print("------------庄家时刻------------")
    while 1:
        # print("1庄家：%s" % (computer.show_pokers()))
        #计算庄家的点数

        computer.get_pokers_point()
        # print(computer.point)
        if computer.point < 17:
            #发牌
            pm.send_pokers(computer, 1)
            # print("2庄家：%s" % (computer.show_pokers()))
            # print(computer.point)
            if computer.isboom():
                print("庄家输了")
                return
        else:
            # 停牌
            # 计算庄家点数并保存
            computer.get_pokers_point()
            print("庄家点数：%d" % (computer.point))
            break

    if computer.point > player.point:
        print("庄家赢(庄家:%d-玩家:%d)"%(computer.point, player.point))
    elif computer.point == player.point:
        print("平局(庄家:%d-玩家:%d)" % (computer.point, player.point))
    else:
        print("玩家赢(庄家:%d-玩家:%d)" % (computer.point, player.point))

if __name__ == "__main__":
    main()