精华内容
下载资源
问答
  • 用python制作应用程序 当普通人想要学习打字时,他们会使用Typing master之类的软件。 但是由于我们是程序员,所以我们可以使用我们的知识来编写自己的打字导师应用。 一如既往,Python将会是最好的选择,因为它易于...

    用python制作应用程序

    当普通人想要学习打字时,他们会使用Typing master之类的软件。 但是由于我们是程序员,所以我们可以使用我们的知识来编写自己的打字导师应用。 一如既往,Python将会是最好的选择,因为它易于理解,并为我们的特定目的提供了很多库。 让我们开始吧!

    为了检查我们的打字速度和准确性,我们需要记录击键。 为此,我们将使用一个名为tkinter的python库。 由于tkinter已从Python 3.4及更高版本内置,因此您无需使用pip进行安装。

    这个应用程式如何运作?

    首先,我们将获取许多英文字母的数据集。 然后,我们将从该数据集中向用户随机呈现单词。 用户必须输入这些单词。 如果他成功键入一个单词,他将得到下一个单词。 同样,用户将获得特定数量的生命。 一旦用户输入错误的字母,他将失去生命。 如果他的生活结束了,比赛就结束了。 而且,基于用户键入特定单词所花费的时间以及正确键入的字母数来计算分数。

    此项目中使用的英语单词的数据集可以在这里找到。 下载此文件并将其存储在存在python文件的相同位置。 该文件包含大约10,000个英语单词。 我们将从列表中随机选择给定数量的单词。 对于分数计算,每当用户正确按下一个字母时,我们就将分数加1。 还为每个单词分配了时间限制,该时间限制是单词长度的倍数。 如果用户在时间限制之前输入单词,则剩余时间将添加到得分中。

    代码

    import tkinter as tk
    import random
    from os import system, name
    import time
    
    def clear () :
        if name == 'nt' :
            _ = system( 'cls' )
        else :
            _ = system( 'clear' )
    
    index = 0
    list_index = 0
    list = []
    word_count = 10
    
    f = open( 'words.txt' , 'r' )
    for line in f:
        list.append(line.strip())
    
    random.shuffle(list)
    
    list = list[:word_count]
    print( "---WELCOME TO TYPING TUTOR---" )
    time.sleep( 1 )
    clear()
    print( "Total words: " , len(list))
    time.sleep( 2 )
    clear()
    print( "Word " +str(list_index+ 1 )+ " out of " +str(word_count)+ ": " +list[list_index])
    
    start_time = time.time()
    end_time = 0
    time_multiplier = 2
    
    lives = 3
    
    score = 0
    
    def keypress (event) :
        global index
        global list_index
        global list
        global lives
        global score
        global start_time
        global end_time
        global time_multiplier
    
        word = list[list_index]
    
        if event.char == word[index]:
            index = index + 1
            score = score + 1
        else :
            clear()
            print( "Word " + str(list_index + 1 ) + " out of " + str(word_count) + ": " + list[list_index])
            print( "wrong letter!" )
            lives = lives - 1
            print( "Lives left: " , lives)
            if lives == 0 :
                print( "Game Over!" )
                print( "Final Score: " , score)
                root.destroy()
            return
        if index == len(word):
            clear()
            print( "right!" )
            index = 0
            list_index = list_index + 1
            end_time = time.time()
            time_taken = int(end_time - start_time)
            time_left = time_multiplier * len(word) - time_taken
            score = score + time_left
            print( "time taken: " + str(time_taken) + " out of " + str(time_multiplier*len(word)) + " seconds." )
            print( "Current score: " , score)
            time.sleep( 1.5 )
            start_time = end_time
            clear()
    
        if list_index < len(list) and index == 0 :
            print( "Word " + str(list_index + 1 ) + " out of " + str(word_count) + ": " + list[list_index])
    
        elif list_index == len(list):
            clear()
            print( "Congratulations! you have beaten the game!" )
            print( "Final Score: " , score)
            root.destroy()
    
    root = tk.Tk()
    root.bind_all( '' , keypress)
    root.withdraw()
    root.mainloop()

    将此代码复制到新的python文件,并将其命名为app.py。 可以使用word_count变量设置游戏中显示的单词总数。 当前设置为time_multiplier变量控制分配给每个单词的时间。 当前设置为2。这意味着对于长度为5的单词,时间限制为5 * 2 = 10秒。 lives变量定义玩家获得的生活数量。 每当玩家错误地键入字母时,生命都会过去。

    要运行此代码,请打开命令提示符,将目录更改为该python文件的存储位置,然后键入: python app.py

    请注意,运行此代码后,命令提示符将不会保留为活动窗口。 您不必担心。 只需开始输入显示的单词的字母即可。 当您继续正确输入时,乐谱将更新,并且接下来的单词将继续出现。 另外,您实际上不会在屏幕上的任何地方看到要键入的单词。 您只需要继续按正确的键即可。 每当您按下任何不正确的键时,都会扣除生命。

    而已。 希望您喜欢这篇文章。 如有任何疑问,请发表评论。 还可以查看我在Medium上的文章,并在Twitter上关注我。 还可以在此博客上查看我的其他文章!

    翻译自: https://hackernoon.com/make-your-own-typing-tutor-app-using-python-6i19734se

    用python制作应用程序

    展开全文
  • 最近一直在学习python,突发奇想,可以做一个人工智能程序。但别的先不提,光做一个语音识别我都不会做呀!![痛哭流涕],我便只能做一个石头剪子布来安慰一下我受伤的心灵………… 制作带有人工智能的石头剪子布...
  • 如何用python制作贪吃蛇以及AI版贪吃蛇

    千次阅读 多人点赞 2020-08-22 12:31:11
    用python制作普通贪吃蛇 贪吃蛇,应该是90后小时候的记忆(至少是我的),今天,我们就python这款编程语言来实现贪吃蛇 系统:所有都可以 需导入模块: random pygame pygame.locals sys 下载以上模块指令: ...

    用python制作普通贪吃蛇

    哈喽,大家不知道是上午好还是中午好还是下午好还是晚上好!
    贪吃蛇,应该是90后小时候的记忆(连我这个00后也不例外),今天,我们就用python这款编程语言来实现贪吃蛇
    系统:所有都可以
    需导入模块:
    random
    pygame
    pygame.locals
    sys
    下载以上模块指令:
    random和sys是Python自带的,我们只需要下载pygame即可
    下载pygame:
    在开始菜单输入“cmd”回车打开,输入``指令:pip install pygame
    苹果电脑需要改成:pip3 install pygame
    下载好后,打开python的shell界面,输入import pygame,回车,如果没报错,及代表安装完成。
    接下来什么都不说,直接奉上代码(恕我没写注释):

    import random
    import pygame
    import sys
    from pygame.locals import *
     
    Snakespeed = 17
    Window_Width = 800
    Window_Height = 500
    Cell_Size = 20  # Width and height of the cells
    # Ensuring that the cells fit perfectly in the window. eg if cell size was
    # 10     and window width or windowheight were 15 only 1.5 cells would
    # fit.
    assert Window_Width % Cell_Size == 0, "Window width must be a multiple of cell size."
    # Ensuring that only whole integer number of cells fit perfectly in the window.
    assert Window_Height % Cell_Size == 0, "Window height must be a multiple of cell size."
    Cell_W = int(Window_Width / Cell_Size)  # Cell Width
    Cell_H = int(Window_Height / Cell_Size)  # Cellc Height
     
     
    White = (255, 255, 255)
    Black = (0, 0, 0)
    Red = (255, 0, 0)  # Defining element colors for the program.
    Green = (0, 255, 0)
    DARKGreen = (0, 155, 0)
    DARKGRAY = (40, 40, 40)
    YELLOW = (255, 255, 0)
    Red_DARK = (150, 0, 0)
    BLUE = (0, 0, 255)
    BLUE_DARK = (0, 0, 150)
     
     
    BGCOLOR = Black  # Background color
     
     
    UP = 'up'
    DOWN = 'down'      # Defining keyboard keys.
    LEFT = 'left'
    RIGHT = 'right'
     
    HEAD = 0  # Syntactic sugar: index of the snake's head
     
     
    def main():
        global SnakespeedCLOCK, DISPLAYSURF, BASICFONT
     
        pygame.init()
        SnakespeedCLOCK = pygame.time.Clock()
        DISPLAYSURF = pygame.display.set_mode((Window_Width, Window_Height))
        BASICFONT = pygame.font.Font('freesansbold.ttf', 18)
        pygame.display.set_caption('Snake')
     
        showStartScreen()
        while True:
            runGame()
            showGameOverScreen()
     
     
    def runGame():
        # Set a random start point.
        startx = random.randint(5, Cell_W - 6)
        starty = random.randint(5, Cell_H - 6)
        wormCoords = [{'x': startx, 'y': starty},
                      {'x': startx - 1, 'y': starty},
                      {'x': startx - 2, 'y': starty}]
        direction = RIGHT
     
        # Start the apple in a random place.
        apple = getRandomLocation()
     
        while True:  # main game loop
            for event in pygame.event.get():  # event handling loop
                if event.type == QUIT:
                    terminate()
                elif event.type == KEYDOWN:
                    if (event.key == K_LEFT) and direction != RIGHT:
                        direction = LEFT
                    elif (event.key == K_RIGHT) and direction != LEFT:
                        direction = RIGHT
                    elif (event.key == K_UP) and direction != DOWN:
                        direction = UP
                    elif (event.key == K_DOWN) and direction != UP:
                        direction = DOWN
                    elif event.key == K_ESCAPE:
                        terminate()
     
            # check if the Snake has hit itself or the edge
            if wormCoords[HEAD]['x'] == -1 or wormCoords[HEAD]['x'] == Cell_W or wormCoords[HEAD]['y'] == -1 or wormCoords[HEAD]['y'] == Cell_H:
                return  # game over
            for wormBody in wormCoords[1:]:
                if wormBody['x'] == wormCoords[HEAD]['x'] and wormBody['y'] == wormCoords[HEAD]['y']:
                    return  # game over
     
            # check if Snake has eaten an apply
            if wormCoords[HEAD]['x'] == apple['x'] and wormCoords[HEAD]['y'] == apple['y']:
                # don't remove worm's tail segment
                apple = getRandomLocation()  # set a new apple somewhere
            else:
                del wormCoords[-1]  # remove worm's tail segment
     
            # move the worm by adding a segment in the direction it is moving
            if direction == UP:
                newHead = {'x': wormCoords[HEAD]['x'],
                           'y': wormCoords[HEAD]['y'] - 1}
            elif direction == DOWN:
                newHead = {'x': wormCoords[HEAD]['x'],
                           'y': wormCoords[HEAD]['y'] + 1}
            elif direction == LEFT:
                newHead = {'x': wormCoords[HEAD][
                    'x'] - 1, 'y': wormCoords[HEAD]['y']}
            elif direction == RIGHT:
                newHead = {'x': wormCoords[HEAD][
                    'x'] + 1, 'y': wormCoords[HEAD]['y']}
            wormCoords.insert(0, newHead)
            DISPLAYSURF.fill(BGCOLOR)
            drawGrid()
            drawWorm(wormCoords)
            drawApple(apple)
            drawScore(len(wormCoords) - 3)
            pygame.display.update()
            SnakespeedCLOCK.tick(Snakespeed)
     
     
    def drawPressKeyMsg():
        pressKeySurf = BASICFONT.render('Press a key to play.', True, White)
        pressKeyRect = pressKeySurf.get_rect()
        pressKeyRect.topleft = (Window_Width - 200, Window_Height - 30)
        DISPLAYSURF.blit(pressKeySurf, pressKeyRect)
     
     
    def checkForKeyPress():
        if len(pygame.event.get(QUIT)) > 0:
            terminate()
        keyUpEvents = pygame.event.get(KEYUP)
        if len(keyUpEvents) == 0:
            return None
        if keyUpEvents[0].key == K_ESCAPE:
            terminate()
        return keyUpEvents[0].key
     
     
    def showStartScreen():
        titleFont = pygame.font.Font('freesansbold.ttf', 100)
        titleSurf1 = titleFont.render('Snake!', True, White, DARKGreen)
        degrees1 = 0
        degrees2 = 0
        while True:
            DISPLAYSURF.fill(BGCOLOR)
            rotatedSurf1 = pygame.transform.rotate(titleSurf1, degrees1)
            rotatedRect1 = rotatedSurf1.get_rect()
            rotatedRect1.center = (Window_Width / 2, Window_Height / 2)
            DISPLAYSURF.blit(rotatedSurf1, rotatedRect1)
     
            drawPressKeyMsg()
     
            if checkForKeyPress():
                pygame.event.get()  # clear event queue
                return
            pygame.display.update()
            SnakespeedCLOCK.tick(Snakespeed)
            degrees1 += 3  # rotate by 3 degrees each frame
            degrees2 += 7  # rotate by 7 degrees each frame
     
     
    def terminate():
        pygame.quit()
        sys.exit()
     
     
    def getRandomLocation():
        return {'x': random.randint(0, Cell_W - 1), 'y': random.randint(0, Cell_H - 1)}
     
     
    def showGameOverScreen():
        gameOverFont = pygame.font.Font('freesansbold.ttf', 100)
        gameSurf = gameOverFont.render('Game', True, White)
        overSurf = gameOverFont.render('Over', True, White)
        gameRect = gameSurf.get_rect()
        overRect = overSurf.get_rect()
        gameRect.midtop = (Window_Width / 2, 10)
        overRect.midtop = (Window_Width / 2, gameRect.height + 10 + 25)
     
        DISPLAYSURF.blit(gameSurf, gameRect)
        DISPLAYSURF.blit(overSurf, overRect)
        drawPressKeyMsg()
        pygame.display.update()
        pygame.time.wait(500)
        checkForKeyPress()  # clear out any key presses in the event queue
     
        while True:
            if checkForKeyPress():
                pygame.event.get()  # clear event queue
                return
     
     
    def drawScore(score):
        scoreSurf = BASICFONT.render('Score: %s' % (score), True, White)
        scoreRect = scoreSurf.get_rect()
        scoreRect.topleft = (Window_Width - 120, 10)
        DISPLAYSURF.blit(scoreSurf, scoreRect)
     
     
    def drawWorm(wormCoords):
        for coord in wormCoords:
            x = coord['x'] * Cell_Size
            y = coord['y'] * Cell_Size
            wormSegmentRect = pygame.Rect(x, y, Cell_Size, Cell_Size)
            pygame.draw.rect(DISPLAYSURF, DARKGreen, wormSegmentRect)
            wormInnerSegmentRect = pygame.Rect(
                x + 4, y + 4, Cell_Size - 8, Cell_Size - 8)
            pygame.draw.rect(DISPLAYSURF, Green, wormInnerSegmentRect)
     
     
    def drawApple(coord):
        x = coord['x'] * Cell_Size
        y = coord['y'] * Cell_Size
        appleRect = pygame.Rect(x, y, Cell_Size, Cell_Size)
        pygame.draw.rect(DISPLAYSURF, Red, appleRect)
     
     
    def drawGrid():
        for x in range(0, Window_Width, Cell_Size):  # draw vertical lines
            pygame.draw.line(DISPLAYSURF, DARKGRAY, (x, 0), (x, Window_Height))
        for y in range(0, Window_Height, Cell_Size):  # draw horizontal lines
            pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, y), (Window_Width, y))
     
     
    if __name__ == '__main__':
        try:
            main()
        except SystemExit:
            pass
    
    
    

    以上是贪吃蛇的全部代码,接下来,我们来制作AI版贪吃蛇。

    用python制作AI版贪吃蛇

    AI版贪吃蛇,即让系统自己玩贪吃蛇,一句话:自己玩自己。下面开始:
    系统:什么都可以
    需导入的模块:
    pygame
    sys
    time
    random
    如果你已经下载好了pygame,即可直接开始。
    还是什么都不说,直接奉上代码(这次有注释)

    #coding: utf-8
    import pygame,sys,time,random
    from pygame.locals import *
    # 定义颜色变量
    redColour = pygame.Color(255,0,0)
    blackColour = pygame.Color(0,0,0)
    whiteColour = pygame.Color(255,255,255)
    greenColour = pygame.Color(0,255,0)
    headColour = pygame.Color(0,119,255)
    
    #注意:在下面所有的除法中,为了防止pygame输出偏差,必须取除数(//)而不是单纯除法(/)
    
    # 蛇运动的场地长宽,因为第0行,HEIGHT行,第0列,WIDTH列为围墙,所以实际是13*13
    HEIGHT = 15
    WIDTH = 15
    FIELD_SIZE = HEIGHT * WIDTH
    # 蛇头位于snake数组的第一个元素
    HEAD = 0
    
    # 用数字代表不同的对象,由于运动时矩阵上每个格子会处理成到达食物的路径长度,
    # 因此这三个变量间需要有足够大的间隔(>HEIGHT*WIDTH)来互相区分
    # 小写一般是坐标,大写代表常量
    FOOD = 0
    UNDEFINED = (HEIGHT + 1) * (WIDTH + 1)
    SNAKE = 2 * UNDEFINED
    
    # 由于snake是一维数组,所以对应元素直接加上以下值就表示向四个方向移动
    LEFT = -1
    RIGHT = 1
    UP = -WIDTH#一维数组,所以需要整个宽度都加上才能表示上下移动
    DOWN = WIDTH 
    
    # 错误码
    ERR = -2333
    
    # 用一维数组来表示二维的东西
    # board表示蛇运动的矩形场地
    # 初始化蛇头在(1,1)的地方
    # 初始蛇长度为1
    board = [0] * FIELD_SIZE #[0,0,0,……]
    snake = [0] * (FIELD_SIZE+1)
    snake[HEAD] = 1*WIDTH+1
    snake_size = 1
    # 与上面变量对应的临时变量,蛇试探性地移动时使用
    tmpboard = [0] * FIELD_SIZE
    tmpsnake = [0] * (FIELD_SIZE+1)
    tmpsnake[HEAD] = 1*WIDTH+1
    tmpsnake_size = 1
    
    # food:食物位置初始在(4, 7)
    # best_move: 运动方向
    food = 4 * WIDTH + 7
    best_move = ERR
    
    # 运动方向数组,游戏分数(蛇长)
    mov = [LEFT, RIGHT, UP, DOWN]                                           
    score = 1 
    
    # 检查一个cell有没有被蛇身覆盖,没有覆盖则为free,返回true
    def is_cell_free(idx, psize, psnake):
        return not (idx in psnake[:psize]) 
    
    # 检查某个位置idx是否可向move方向运动
    def is_move_possible(idx, move):
        flag = False
        if move == LEFT:
            #因为实际范围是13*13,[1,13]*[1,13],所以idx为1时不能往左跑,此时取余为1所以>1
            flag = True if idx%WIDTH > 1 else False
        elif move == RIGHT:
            #这里的<WIDTH-2跟上面是一样的道理
            flag = True if idx%WIDTH < (WIDTH-2) else False
        elif move == UP:
            #这里向上的判断画图很好理解,因为在[1,13]*[1,13]的实际运动范围外,还有个
            #大框是围墙,就是之前说的那几个行列,下面判断向下运动的条件也是类似的
            flag = True if idx > (2*WIDTH-1) else False
        elif move == DOWN:
            flag = True if idx < (FIELD_SIZE-2*WIDTH) else False
        return flag
    # 重置board
    # board_BFS后,UNDEFINED值都变为了到达食物的路径长度
    # 如需要还原,则要重置它
    def board_reset(psnake, psize, pboard):
        for i in range(FIELD_SIZE):
            if i == food:
                pboard[i] = FOOD
            elif is_cell_free(i, psize, psnake): # 该位置为空
                pboard[i] = UNDEFINED
            else: # 该位置为蛇身
                pboard[i] = SNAKE
        
    # 广度优先搜索遍历整个board,
    # 计算出board中每个非SNAKE元素到达食物的路径长度
    def board_BFS(pfood, psnake, pboard):
        queue = []
        queue.append(pfood)
        inqueue = [0] * FIELD_SIZE
        found = False
        # while循环结束后,除了蛇的身体,
        # 其它每个方格中的数字为从它到食物的曼哈顿间距
        while len(queue)!=0: 
            idx = queue.pop(0)#初始时idx是食物的坐标 
            if inqueue[idx] == 1: continue
            inqueue[idx] = 1
            for i in range(4):#左右上下
                if is_move_possible(idx, mov[i]):
                    if idx + mov[i] == psnake[HEAD]:
                        found = True
                    if pboard[idx+mov[i]] < SNAKE: # 如果该点不是蛇的身体
                        if pboard[idx+mov[i]] > pboard[idx]+1:#小于的时候不管,不然会覆盖已有的路径数据
                            pboard[idx+mov[i]] = pboard[idx] + 1
                        if inqueue[idx+mov[i]] == 0:
                            queue.append(idx+mov[i])
        return found
    
    # 从蛇头开始,根据board中元素值,
    # 从蛇头周围4个领域点中选择最短路径
    def choose_shortest_safe_move(psnake, pboard):
        best_move = ERR
        min = SNAKE
        for i in range(4):
            if is_move_possible(psnake[HEAD], mov[i]) and pboard[psnake[HEAD]+mov[i]]<min:
              #这里判断最小和下面的函数判断最大,都是先赋值,再循环互相比较
                min = pboard[psnake[HEAD]+mov[i]]
                best_move = mov[i]
        return best_move
    
    # 从蛇头开始,根据board中元素值,
    # 从蛇头周围4个领域点中选择最远路径
    def choose_longest_safe_move(psnake, pboard):
        best_move = ERR
        max = -1
        for i in range(4):
            if is_move_possible(psnake[HEAD], mov[i]) and pboard[psnake[HEAD]+mov[i]]<UNDEFINED and pboard[psnake[HEAD]+mov[i]]>max:
                max = pboard[psnake[HEAD]+mov[i]]
                best_move = mov[i]
        return best_move
    
    # 检查是否可以追着蛇尾运动,即蛇头和蛇尾间是有路径的
    # 为的是避免蛇头陷入死路
    # 虚拟操作,在tmpboard,tmpsnake中进行
    def is_tail_inside():
        global tmpboard, tmpsnake, food, tmpsnake_size
        tmpboard[tmpsnake[tmpsnake_size-1]] = 0 # 虚拟地将蛇尾变为食物(因为是虚拟的,所以在tmpsnake,tmpboard中进行)
        tmpboard[food] = SNAKE # 放置食物的地方,看成蛇身
        result = board_BFS(tmpsnake[tmpsnake_size-1], tmpsnake, tmpboard) # 求得每个位置到蛇尾的路径长度
        for i in range(4): # 如果蛇头和蛇尾紧挨着,则返回False。即不能follow_tail,追着蛇尾运动了
            if is_move_possible(tmpsnake[HEAD], mov[i]) and tmpsnake[HEAD]+mov[i]==tmpsnake[tmpsnake_size-1] and tmpsnake_size>3:
                result = False
        return result
    
    # 让蛇头朝着蛇尾运行一步
    # 不管蛇身阻挡,朝蛇尾方向运行
    def follow_tail():
        global tmpboard, tmpsnake, food, tmpsnake_size
        tmpsnake_size = snake_size
        tmpsnake = snake[:]
        board_reset(tmpsnake, tmpsnake_size, tmpboard) # 重置虚拟board
        tmpboard[tmpsnake[tmpsnake_size-1]] = FOOD # 让蛇尾成为食物
        tmpboard[food] = SNAKE # 让食物的地方变成蛇身
        board_BFS(tmpsnake[tmpsnake_size-1], tmpsnake, tmpboard) # 求得各个位置到达蛇尾的路径长度
        tmpboard[tmpsnake[tmpsnake_size-1]] = SNAKE # 还原蛇尾
        return choose_longest_safe_move(tmpsnake, tmpboard) # 返回运行方向(让蛇头运动1步)
    
    # 在各种方案都不行时,随便找一个可行的方向来走(1步),
    def any_possible_move():
        global food , snake, snake_size, board
        best_move = ERR
        board_reset(snake, snake_size, board)
        board_BFS(food, snake, board)
        min = SNAKE
    
        for i in range(4):
            if is_move_possible(snake[HEAD], mov[i]) and board[snake[HEAD]+mov[i]]<min:
                min = board[snake[HEAD]+mov[i]]
                best_move = mov[i]
        return best_move
        
    #转换数组函数
    def shift_array(arr, size):
        for i in range(size, 0, -1):
            arr[i] = arr[i-1]
    
    def new_food():#随机函数生成新的食物
        global food, snake_size
        cell_free = False
        while not cell_free:
            w = random.randint(1, WIDTH-2)
            h = random.randint(1, HEIGHT-2)
            food = WIDTH*h + w
            cell_free = is_cell_free(food, snake_size, snake)
        pygame.draw.rect(playSurface,redColour,Rect(18*(food//WIDTH), 18*(food%WIDTH),18,18))
    
    # 真正的蛇在这个函数中,朝pbest_move走1步
    def make_move(pbest_move):
        global snake, board, snake_size, score
        shift_array(snake, snake_size)
        snake[HEAD] += pbest_move
        p = snake[HEAD]
        for body in snake:#画蛇,身体,头,尾
          pygame.draw.rect(playSurface,whiteColour,Rect(18*(body//WIDTH), 18*(body%WIDTH),18,18))
        pygame.draw.rect(playSurface,greenColour,Rect(18*(snake[snake_size-1]//WIDTH),18*(snake[snake_size-1]%WIDTH),18,18))
        pygame.draw.rect(playSurface,headColour,Rect(18*(p//WIDTH), 18*(p%WIDTH),18,18))
        #下面一行是把初始情况会出现的第一个白块bug填掉
        pygame.draw.rect(playSurface,(255,255,0),Rect(0,0,18,18))
        # 刷新pygame显示层
        pygame.display.flip() 
        
        # 如果新加入的蛇头就是食物的位置
        # 蛇长加1,产生新的食物,重置board(因为原来那些路径长度已经用不上了)
        if snake[HEAD] == food:
            board[snake[HEAD]] = SNAKE # 新的蛇头
            snake_size += 1
            score += 1
            if snake_size < FIELD_SIZE: new_food()
        else: # 如果新加入的蛇头不是食物的位置
            board[snake[HEAD]] = SNAKE # 新的蛇头
            board[snake[snake_size]] = UNDEFINED # 蛇尾变为UNDEFINED,黑色
            pygame.draw.rect(playSurface,blackColour,Rect(18*(snake[snake_size]//WIDTH),18*(snake[snake_size]%WIDTH),18,18))
            # 刷新pygame显示层
            pygame.display.flip() 
    
    # 虚拟地运行一次,然后在调用处检查这次运行可否可行
    # 可行才真实运行。
    # 虚拟运行吃到食物后,得到虚拟下蛇在board的位置
    def virtual_shortest_move():
        global snake, board, snake_size, tmpsnake, tmpboard, tmpsnake_size, food
        tmpsnake_size = snake_size
        tmpsnake = snake[:] # 如果直接tmpsnake=snake,则两者指向同一处内存
        tmpboard = board[:] # board中已经是各位置到达食物的路径长度了,不用再计算
        board_reset(tmpsnake, tmpsnake_size, tmpboard)
        
        food_eated = False
        while not food_eated:
            board_BFS(food, tmpsnake, tmpboard)    
            move = choose_shortest_safe_move(tmpsnake, tmpboard)
            shift_array(tmpsnake, tmpsnake_size)
            tmpsnake[HEAD] += move # 在蛇头前加入一个新的位置
            # 如果新加入的蛇头的位置正好是食物的位置
            # 则长度加1,重置board,食物那个位置变为蛇的一部分(SNAKE)
            if tmpsnake[HEAD] == food:
                tmpsnake_size += 1
                board_reset(tmpsnake, tmpsnake_size, tmpboard) # 虚拟运行后,蛇在board的位置
                tmpboard[food] = SNAKE
                food_eated = True
            else: # 如果蛇头不是食物的位置,则新加入的位置为蛇头,最后一个变为空格
                tmpboard[tmpsnake[HEAD]] = SNAKE
                tmpboard[tmpsnake[tmpsnake_size]] = UNDEFINED
    
    # 如果蛇与食物间有路径,则调用本函数
    def find_safe_way():
        global snake, board
        safe_move = ERR
        # 虚拟地运行一次,因为已经确保蛇与食物间有路径,所以执行有效
        # 运行后得到虚拟下蛇在board中的位置,即tmpboard
        virtual_shortest_move() # 该函数唯一调用处
        if is_tail_inside(): # 如果虚拟运行后,蛇头蛇尾间有通路,则选最短路运行(1步)
            return choose_shortest_safe_move(snake, board)
        safe_move = follow_tail() # 否则虚拟地follow_tail 1步,如果可以做到,返回true
        return safe_move
    
    
    #初始化pygame
    pygame.init()
    #定义一个变量用来控制游戏速度
    fpsClock = pygame.time.Clock()
    # 创建pygame显示层
    playSurface = pygame.display.set_mode((270,270))
    pygame.display.set_caption('贪吃蛇')
    # 绘制pygame显示层
    playSurface.fill(blackColour)
    #初始化食物
    pygame.draw.rect(playSurface,redColour,Rect(18*(food//WIDTH), 18*(food%WIDTH),18,18))
    
    while True:
        for event in pygame.event.get():#循环监听键盘和退出事件
            if event.type == QUIT:#如果点了关闭
                print(score)#游戏结束后打印分数
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:#如果esc键被按下
                if event.key==K_ESCAPE:
                    print(score)#游戏结束后打印分数
                    pygame.quit()
                    sys.exit()
        # 刷新pygame显示层
        pygame.display.flip()  
        #画围墙,255,255,0是黄色,边框是36是因为,pygame矩形是以边为初始,向四周填充边框
        pygame.draw.rect(playSurface,(255,255,0),Rect(0,0,270,270),36)
        # 重置距离
        board_reset(snake, snake_size, board)
        # 如果蛇可以吃到食物,board_BFS返回true
        # 并且board中除了蛇身(=SNAKE),其它的元素值表示从该点运动到食物的最短路径长
        if board_BFS(food, snake, board):
            best_move  = find_safe_way() # find_safe_way的唯一调用处
        else:
            best_move = follow_tail()
        if best_move == ERR:
            best_move = any_possible_move()
        # 上面一次思考,只得出一个方向,运行一步
        if best_move != ERR: make_move(best_move)
        else:
            print(score)#游戏结束后打印分数
            break
        # 控制游戏速度
        fpsClock.tick(20)#20看上去速度正好
    
    
    

    ok,这就是今天的全部内容866!

    展开全文
  • 2019年,I社新作《AI少女》(illusion)推出之后吸引了大众的目光,而随着更新的完善,广大绅士更是纷纷表示,在如今的《AI少女》中,我们终于可以真正打造一个属于自己且拥有大量黑科技的家了。 作为一款...

    2019年,I社新作《AI少女》(illusion)推出之后吸引了大众的目光,而随着更新的完善,广大绅士更是纷纷表示,在如今的《AI少女》中,我们终于可以真正打造一个属于自己且拥有大量黑科技的家了。

    u=3156750325,2129447679&fm=15&gp=0.jpg

     

    图片

     

    作为一款绅士游戏,《AI少女》除了简单的基建、养成,最重要的还是与少女的互动,玩家可以选择不同的话题与少女进行聊天,试探对方的心情,让彼此能够更加深入的了解对方。看到这里我只想说,跟AI少女聊天什么的简直就是AI类科幻电影的必备桥段,电影《Her》的情节就是如此。影片中的男主终日与AI聊天、作伴,最终爱上了没有形体、只有声音的“她”。

     

    src=http___image.xinmin.cn_2016_07_14_7854dc8f69b42e145d842adc96b822fc.jpg&refer=http___image.xinmin.jpg

     

    其实在人工智能异常火热的今天,从 Siri 到小爱同学,从小冰到小娜,语音交互正悄无声息的融入我们的生活之中。全球语音交互市场规模不断扩大,预计 2025 年全球语音交互市场规模将达到 69 亿美元,目前已广泛应用到智能家居、车载语音、智能客服等行业和场景。

    作为认真好学(不是)的新时代青年,我们当然不能只看表面,还是应该来探索一下更深入的问题,比如:我们用Python是不是也可以制造一个AI机器人呢?答案当然是——肯定的!

    所需工具

    • Python 2 或者 Python 3

    • pip 和 virtualenv 来处理 Python 应用程序依赖关系

    • 一个可以访问 API 的免费 Slack 账号,或者你可以注册一个 Slack Developer Hangout team。

    • 通过 Slack 团队建立的官方 Python Slack 客户端代码库

    • Slack API 测试令牌

    搭建环境

    在终端上切换到你想要存储这个项目的目录,创建一个新的 virtualenv。

    图片

     

    激活 virtualenv:

    图片

     

    你的提示符现在应该看起来如截图:

    图片

     

    已经激活的starterbot的virtualenv的命令提示符,它可以通过 Slack 通道发送和接收消息。通过这个pip 命令安装 slackclient 库:

    图片

     

    当 pip 命令完成后,会看到类似输出,并返回提示符。

    图片

     

    在已经激活的virtualenv用pip安装slackclient的输出,获得一个访问令牌,以便我们的聊天机器人可以用它来连接到Slack API。

    Slack 实时消息传递(RTM)API

    Slack 允许程序通过一个 Web API 来访问他们的消息传递通道。

    图片

     

    使用 Web API页面的右上角登录按钮:登录后你会到达“AI聊天机器人”用户页面。

    图片

     

    定制AI聊天机器人用户页面。

    图片

     

    添加一个bot integration 并起名为“starterbot”这个页面将重新加载,你将看到一个新生成的访问令牌。

    图片

     

    为你的新 Slack 聊天机器人复制和粘贴访问令牌:在页面底部点击“Save Integration”按钮。你的聊天机器人现在已经准备好连接 Slack API。输出的Slack令牌名字为SLACK_BOT_TOKEN:

    图片

     

    得到了将这个 Slack API 用作聊天机器人的授权。

    我们建立聊天机器人还需要更多信息:我们的聊天机器人的 ID。接下来我们将会写一个简短的脚本,从 Slack API 获得该 ID。

    获得聊天机器人的 ID

    我们编写一个简短的 Python 脚本获得 StarterBot 的 ID 来热身一下。这个 ID 基于 Slack 项目而不同。

    我们需要该ID,当解析从Slack RTM上发给StarterBot的消息时,它用于对我们的应用验明正身。我们的脚本也会测试我们SLACK_BOT_TOKEN环境变量是否设置正确。

    建立一个命名为printbotid.py的新文件,并且填入下面的代码:

    图片

     

    我们的代码导入SlackClient,并用我们设置的环境变量SLACK_BOT_TOKEN实例化它。当该脚本通过python命令执行时,我们通过会访问Slack API列出所有的 Slack 用户并且获得匹配一个名字为“satrterbot”的ID。

    这个获得聊天机器人的ID的脚本我们仅需要运行一次。

    图片

     

    当它运行为我们提供了聊天机器人的ID时,脚本会打印出简单的一行输出。

    图片

     

    在你的Slack 项目中用Python脚本打印Slack聊天机器人的ID,复制这个脚本打印出的唯一ID。并将该ID作为一个环境变量BOT_ID输出。

    图片

     

    这个脚本仅仅需要运行一次来获得聊天机器人的ID。我们现在可以在我们的运行StarterBot的Python应用程序中使用这个ID。

    编码 StarterBot

    现在我们拥有了写我们的StarterBot代码所需的一切。创建一个新文件命名为starterbot.py,它包括以下代码。

    图片

     

    对os和SlackClient的导入我们看起来很熟悉,因为我们已经在theprintbotid.py中用过它们了。

    通过我们导入的依赖包,我们可以使用它们获得环境变量值,并实例化Slack客户端。

    图片

     

    该代码通过我们以输出的环境变量SLACK_BOT_TOKEN 实例化SlackClient`客户端。

    图片

     

    Slack 客户端会连接到 Slack RTM API WebSocket,然后当解析来自 firehose 的消息时会不断循环。如果有任何发给 StarterBot 的消息,那么一个被称作 handle_command 的函数会决定做什么。

    接下来添加两个函数来解析 Slack 的输出并处理命令。

    图片

     

    parse_slack_output 函数从 Slack 接受信息,并且如果它们是发给我们的 StarterBot 时会作出判断。消息以一个给我们的聊天机器人 ID 的直接命令开始,然后交由我们的代码处理。目前只是通过 Slack 管道发布一个消息回去告诉用户去多写一些 Python 代码!

    这是整个程序组合在一起的样子 (你也可以 在 GitHub 中查看该文件):

    图片

     

    图片

     

    现在我们的代码已经有了,我们可以通过 python starterbot.py 来运行我们 StarterBot 的代码了。

    图片

     

    当 StarterBot 开始运行而且连接到 API 的输出通道在 Slack 中创建新通道,并且把 StarterBot 邀请进来,或者把 StarterBot 邀请进一个已经存在的通道中。

    图片

     

    在Slack界面创建一个新通道,并且邀请 StarterBot。现在在你的通道中给 StarterBot 发命令。

    图片

    图片在你的Slack通道里给你的 StarterBot 发命令:如果你从聊天机器人得到的响应中遇见问题,你可能需要做一个修改。正如上面所写的这个教程,其中一行AT_BOT = “<@” + BOT_ID + “>:”,在“@starter”(你给你自己的聊天机器人起的名字)后需要一个冒号。从 AT_BOT 字符串后面移除:。Slack 似乎需要在@ 一个人名后加一个冒号,但这好像是有些不协调的。

    结束

    好吧,你现在已经获得一个简易的AI聊天机器人,你可以在代码中很多地方加入你想要创建的任何特性。据说有位不能经常陪女朋友的程序员小哥哥用它去陪女朋友聊天,结果下班一看,感觉自己可能不再被需要了……当然,这就是另一个故事了,毕竟并不是所有学习Python的人都有这个苦恼的~

    展开全文
  • 原标题:学了Python能干什么 | 如何用Python巧妙制作一个简易版人工智能问答程序?随着科技的发展人工智能这个词频繁被”cue“,即使不知道到底是个啥,也一定听说过智能语音助手“Siri”“小爱同学”,甚至见识过...

    原标题:学了Python能干什么 | 如何用Python巧妙制作一个简易版人工智能问答程序?

    随着科技的发展

    人工智能这个词频繁被”cue“,即使不知道到底是个啥,也一定听说过智能语音助手“Siri”“小爱同学”,甚至见识过它们抖机灵逗开心的名场面,比如:“嘿,Siri,叫小爱同学帮我开灯!”

    b2abcf0f07c14c0499bae307a352d9ec.jpeg

    经典漫画《哆啦A 梦》,早就描绘了人机和谐共处的场面;如果我们对休闲手游感兴趣的话,那“会说话的汤姆猫”,我们也一定不会感到陌生。这只灰白相间、长相傻气中带着点诡异的猫,既不聪明,也不太可爱,但人们还是对它欲罢不能。

    毫无疑问,人工智能为我们的生活提供了极大的便利,就像语音助手让我们日常出行交流更快捷方便;而陪伴式机器人,给老人和孩子带来更多欢声笑语与温情;疫情AI机器人,让当初的局面越来越好转!如此灵活多智,除了硬件的要求外,人们靠什么来赋予它们智能呢?

    当然,这其中的关键,就在于一门独特的编程语言——Python!

    8905c1c2592a46738c9377476e497f5f.jpeg

    作为简洁强大的人工智能首选语言,人工智能大多都是由Python写的。今天我们就一起来看看 学了Python到底有什么用?如何用Python巧妙制作一个简易人工智能问答程序?孩子该如何学习Python?

    0 1

    学习Python,

    轻松步入人工智能时代

    Python是一种拟人化的计算机程序设计语言,通过编写代码组成指令,然后调用这些指令就能实现许多意想不到的功能。Python在系统编程、网络爬虫、web开发、大数据分析、云计算、人工智能、金融等各领域都有所应用;在人工智能领域,更是标配语言。

    90403fb446ce465d938112f3549484cb.jpeg

    正如潘石屹在微博里所说,在农业社会,我们想解放生产力,就必须学习驾驭马、驴、牛,发展至工业社会,这些工具就变成了火车、轮船、飞机、机床等各种机器。

    40c4aed02f6d4fffa92f9e4c1c29b883.jpeg

    f980ca2709be42338846c5b337eeff16.png

    如今,我们已经开始进入人工智能时代,Python拥有强大的API和可用于AI、数据科学和机器学习的库,很快成为最常用的编程语言。想要跟上时代,让计算机听我们的指挥,就必须学会一门共通的语言——Python语言。

    随着无人超市、美团无人配送车的出现,我们也严重意识到了一个问题:人工智能的出现,肯定是会替代掉一些工作,这是无可避免的。

    而学Python有什么用呢?

    我们可以用Python制作经典游戏程序;

    用Python编写扫地机器人、汽车自动驾驶的内嵌程序;

    用Python网络爬虫,轻松自动浏览采集分析网络信息;

    我们也可以借助Python,教会孩子更多创新想法,来解决现实中复杂棘手的难题,甚至帮孩子在未来就业中更有竞争力等,轻松步入人工智能时代!

    0 2

    学习Python,

    轻松制作智能问答程序

    无论是“Siri”,“小爱同学”,还是教育陪伴机器人,它们共通的属性,不仅仅是都很受欢迎,而是它们都具备最简单的智能对话功能。 而智能对话、智能问答是人机互动的基础。

    a62e99b70a5b405a8810ee1f8022f8fb.gif

    那么,我们如何让一个机器人具备最简单的智能对话功能呢?或者说,我们如何轻松制作一个简易的人工智能问答程序呢?

    Step1:利用变量que,存储输入的问题,构成问题库;

    Step2:用if条件语句,分别设定不同问题的标准答案;

    Step 3:未设定答案的问题,统一回复“超出认知范围”;

    Step4:综合上述步骤,对常见问题设置回答,写出最终代码。

    0 3

    爱迪国际教育,

    为孩子打开Python世界大门

    既然Python如此强大,那么我们该如何上手呢?如何引导孩子,启蒙和激发孩子的兴趣呢?要知道,枯燥晦涩的英文代码界面,分分钟让孩子磨灭好不容易从Scratch中建立的学习热情,立马从编程世界里撤退!

    78fd344affc7421fa8fa42e788649bcd.gif

    爱迪国际教育Python,充分考虑青少年的身心发展需要和认知学习规律,带孩子用有趣的方式接触Python,了解Python,感受Pyhon的魅力,并充满创造性的作品案例中不动声色激发孩子的兴趣,引领孩子走进Python代码世界!

    01 实用性

    英文代码界面,

    助力孩子抽象思维培养,

    化繁为简轻松掌握解题新思路

    15fb7feb227c40838f71db4a072caca2.jpeg

    Python由生活中的人工智能和语音助手引入,通过有趣的作品案例和真实的代码语言环境,让孩子运用Python解决一些实际问题,比如:制作简易的智能问答程序,同时接触一些简单的概念和语法,比如:输入输出,条件语句,从而获得问题解决和抽象思维上的双重训练,并有意识培养孩子的自信:相信现实中问题一定会有一些创新的解决之道,比如编程。

    02 趣味性

    Mixcode串联

    Python与Scratch,

    所见即所得,抽象学习有反馈

    c13810685e1949ab9190808400ed4d86.jpeg

    Python作为爱迪国际教育Python众多体验课之一,运用Mixcode实现了Python与Scratch的互通,让孩子在实际问题解决和抽象思维的锻炼过程中,可以通过Scratch积木代码和舞台效果获得每一步抽象思考的直观反馈,形成准确联系,并顺利将Scratch中形成的概念和兴趣,迁移到Python学习中,让Python抽象概念与语法的理解变得更容易,增强孩子的学习兴趣,畏难情绪也消失于无形。

    03 科技感

    机器人语音互动与界面,

    充分营造未来感与科技感,

    激发孩子无限想象力

    27602bdeb5b6401eab550917f848a7d6.png

    Python包含完整的机器人互动场景和丰富的人工智能科技元素,一方面从视觉到语音的形象画面,帮孩子还原信马由僵的想象,让孩子迅速身临其境;另一方面,作为一种想法,启发了孩子对未来和科技的无限畅想,并让孩子意识到Python的功能强大,从而爱上Python,并通过此次课学习,对Python有更多了解,进一步激发孩子学习兴趣!

    90ea15c1bdd745488ce5a292fb62e5ac.png

    好的编程课程,善于顺应时代趋势,持续更新迭代,激发兴趣与潜能,引领孩子科技信息素养培养,真正助力孩子的未来!爱迪国际教育也将不断研发与创新,推出更多精彩课程,促进孩子健康快乐成长! 返回搜狐,查看更多

    责任编辑:

    展开全文
  • 人工智能(AI)和机器学习(ML)的兴起将带来一个新的数字化时代。但是,人们担心AI技术会取代现有的人工,这部分是正确的。正如研究预测的那样,人工智能替代工作的速度必将飞速上升,从而影响到工厂工人,会计师,放射...
  • 我们经常听到“Python”与“人工智能”这两个词,也很容易混淆这两个词,那么Python人工智能有什么关系呢?本文就来详细聊聊Python人工智能之间的关系。提到人工智能就一定会提到Python,有的初学者甚至认为人工...
  • 第 1 章 走近人工智能 11.1 初识人工智能 21.1.1 人工智能是什么 21.1.2 人工智能的发展历程 21.1.3 人工智能的应用现状 41.2 机器人世界 51.2.1 机器人的发展历史 51.2.2 什么是智能机器...
  • http://www.rocksolidarcade.com/games/dogfight2/ 制作一个可以为我们玩混战游戏的Python程序(人工智能AI))不是很酷吗? 我意识到制作一个高效的AI来玩这样的游戏是一项非常艰巨的任务,因此我决定创建一...
  • pytest缓存目录 该目录包含来自pytest的缓存插件的数据,该插件提供--lf和--ff选项以及cache夹具。 不要将其提交给版本控制。 有关更多信息,请参阅。
  • 使用进行AI扭曲的经典国际象棋 怎么玩 怎么玩 从安装Python 从安装PyGame 1.9.X 克隆此存储库: https://github.com/kailongli27/flappy-bird.git : https://github.com/kailongli27/flappy-bird.git或单击“代码...
  • 用Python制作有声小说

    2021-06-12 00:17:43
    作者:菜鸟哥来源:程序员GitHub大家好,欢迎来到 「Python数据之道」 !有不少朋友都热衷于看小说。俗话说:小说阅读一时爽,一直阅读一直爽。但是小说阅读时间久了,会给我们的眼睛带来...
  • python人工智能是指基于Python平台实现人工智能python是一门应用非常广泛的脚本程序语言,而人工智能是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。python是一款应用...
  • 作者 |Ahab,专注与 Python 数据挖掘、数据分析与机器学习来源 | Ahab杂货铺编辑 | Jane【编者按】之前作者 Python 做了一款俄罗斯方块的小游戏,这次,作者在原来工作的基础上进行了升级, AI 算法实现了一款...
  • 有很多人在问达妹,为什么人工智能学习要用Python?为什么现在大家都在学Python?今天就让达妹谈谈自己的感受。人工智能的前景随着“大数据”“云计算”“人工智能”等等科技的兴起,IT行业在今后三到五年将会迎来一...
  • 在本教程中,我们将使用MatPlotLib生成图形,并使用熊猫的库读取CSV文件。 初始化子图 (Initialize the subplot) plt.style.use('seaborn') fig = plt.figure() ax = fig.add_subplot(1,1,1) We’re going to ...
  • 使用Python制作证件照

    千次阅读 2020-06-23 22:24:40
    修改背景我们需要用到第三方库removebg,修改照片尺寸需要用到PIL库,这两个库的安装使用pip install removebg和pip install Pillow即可。 removebg涉及到api_key,需要到其官网注册并申请:...
  • 基于Python人工智能美颜系统,代码说明见:https://blog.csdn.net/m0_38106923/article/details/93338522
  • 这篇文章讲的是如何利用python制作狂拽酷炫吊炸天的二维码,非常有趣哦!可能你见过的二维码大多长这样:小猿微信号,可以扫描添加稍微好看点的长这样:Java后端编程,可以关注看看!普普通...
  • 1 # 产生新食物 2 def new_food(): 3 global food, snake_size, myfood 4 cell_free = False 5 while not cell_free: 6 food1 = [random.randint(1, HEIGHT - 2), random.randint(1, WIDTH - 2)] ...
  • 我们经常听到“Python”与“人工智能”这两个词,也很容易混淆这两个词,那么Python人工智能有什么关系呢?本文千锋武汉Python培训小编来详细聊聊Python人工智能之间的关系。提到人工智能就一定会提到Python,有...
  • 主要为大家详细介绍了AI人工智能应用,本文拟使用Python开发语言实现类似于WIndows平台的“小娜”,,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Python 制作的乒乓球! 控件 使用 W 和 S 与 AI 对战。 按 R 接收新球。 玩伙伴 如果你想和你的朋友一起玩,你可以删除AI代码。 转到代码并删除第 72 行到第 75 行。 如果 ballposition [1] > p2YPosition + 10: ...
  • 自近几年来,人工智能技术越发火热,Python这门最适合用于人工智能项目开发的语言也步入大众视野,越来越多的同学选择成为一名Python工程师。但迈入机器学习与人工智能领域绝非易事,考虑到目前市面上存在着大量可用...
  • python制作飞船大战

    万次阅读 多人点赞 2019-12-01 13:05:00
    python制作坦克大战 效果图 可以按住上下左右方向键以及WSAD让坦克运动 按0和j可以发射子弹。 具体代码与图片音源文件可以从我的GitHub地址获取 https://github.com/liuzuoping/python_Games 欢迎star 接下来我们来...
  • 这次给大家带来使用Python开发简单的小游戏,使用Python开发小游戏的注意事项有哪些,下面就是实战案例,一起来看一下。引言最近python语言大火,除了在科学计算领域python有用武之地之外,在游戏、后台等方面,...
  • import numpy as np import scipy.special import matplotlib.pyplot as plt %matplotlib inline class neuralNetwork: def __init__(): pass def query(): pass ...if __name__=='__main__':

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,443
精华内容 8,977
关键字:

如何用python制作ai

python 订阅