## Scribble Diffusion

一款开源的涂鸦 AI 绘画工具，能够将草图转换为精致的图像，基于 Replicate 提供的 API 来实现，使用 ControlNet 来固定图形布局，使用比较简单，直接画图，然后配上描述，点击 Go 即可生成精致的图片，感兴趣的可以去体验一下。

通过简单的线条和几何形状，以及一句话简单描述，即可创造出个性化的艺术作品，生成的图像可以保存和分享，让你感受到绘画的乐趣和快乐！

## 网站地址

Scribble Diffusion：[https://scribblediffusion.com/](https://scribblediffusion.com/)


Scribble Diffusion-使用AI将草图转换为精致图像

    import requests
    from bs4 import BeautifulSoup
    
    ## 发送请求，获得数据
    def getHtml(page):
        url = ""
        header = {"User-Agent": ""}
        r = requests.get(url, params={"reportTime": "2021-06-30", "pageNum": page}, headers=header)
        return r.text
    
    ## 解析表格标题
    def parseTitle(soup):
        table = soup.find(id="myTable04")
        ths = table.find_all("th")
        title = [th.text for th in ths]
        return title
    
    ## 解析表格数据
    def parseData(soup):
        tbody = soup.find(id="myTable04").find("tbody")
        trs = tbody.find_all("tr")
        data = []
        for tr in trs:
            tds = tr.find_all("td")
            tdsv = [td.text for td in tds]
            data.append(tdsv)
        return data
    
    ## 抓取和解析全部数据
    tableData = []
    for page in range(1, 224):
        html = getHtml(page)
        soup = BeautifulSoup(html, "lxml")
        if page == 1:
            title = parseTitle(soup)
            tableData.append(title)
        pageData = parseData(soup)
        tableData.extend(pageData)
    
    tableData[:5]  # 查看前五条记录
    len(tableData)  # 查看数据集大小


Python爬虫模块化程序编写

## 21点纸牌游戏

21点又名BlackJack，由2到5个人玩，使用4副扑克除大小王之外的208张牌，游戏者的目标是使手中的牌的点数之和不超过21点且尽量大。

# art.py

    logo = r"""
    .------.            _     _            _    _            _
    |A_  _ |.          | |   | |          | |  (_)          | |
    |( / ).-----.     | |__ | | __ _  ___| | ___  __ _  ___| | __
    |   /|K /  |     | '_ | |/ _` |/ __| |/ / |/ _` |/ __| |/ /
    |  / | /   |     | |_) | | (_| | (__|   <| | (_| | (__|   <
    `-----|   / |     |_.__/|_|__,_|___|_|_ |__,_|___|_|_\
          |  / K|                            _/ |
          `------'                           |__/
    """

# main.py

    ############### Blackjack House Rules #####################
    # The deck is unlimited in size.
    # There are no jokers.
    # The Jack/Queen/King all count as 10.
    # The Ace can count as 11 or 1.
    # Use the following list as the deck of cards:
    # cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
    # The cards in the list have equal probability of being drawn.
    # Cards are not removed from the deck as they are drawn.
    import random
    import os
    from art import logo
    def deal_card():
    """Returns a random card from the deck."""
    cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
    card = random.choice(cards)
    return card
    def calculate_score(cards):
    """Take a list of cards and return the score calculated from the cards"""
    # Check for a blackjack (a hand with only 2 cards: ace + 10) and return 0 instead of the actual score. 0 will represent a blackjack.
    if sum(cards) == 21 and len(cards) == 2:
    return 0
    # If the score is already over 21, remove the 11 and replace it with a 1.
    if 11 in cards and sum(cards) > 21:
    cards.remove(11)
    cards.append(1)
    return sum(cards)
    def compare(user_score, computer_score):
    # If you and the computer are both over, you lose.
    if user_score > 21 and computer_score > 21:
    return "You went over. You lose ?"
    if user_score == computer_score:
        return &quot;Draw ?&quot;
    elif computer_score == 0:
        return &quot;Lose, opponent has Blackjack ?&quot;
    elif user_score == 0:
        return &quot;Win with a Blackjack ?&quot;
    elif user_score &gt; 21:
        return &quot;You went over. You lose ?&quot;
    elif computer_score &gt; 21:
        return &quot;Opponent went over. You win ?&quot;
    elif user_score &gt; computer_score:
        return &quot;You win ?&quot;
    else:
        return &quot;You lose ?&quot;
    
    def play_game():
    print(logo)
    
    user_cards = []
    computer_cards = []
    is_game_over = False
    
    for _ in range(2):
        user_cards.append(deal_card())
        computer_cards.append(deal_card())
    
    while not is_game_over:
        user_score = calculate_score(user_cards)
        computer_score = calculate_score(computer_cards)
        print(f&quot;   Your cards: {user_cards}, current score: {user_score}&quot;)
        print(f&quot;   Computer's first card: &quot;)
    
        if user_score == 0 or computer_score == 0 or user_score &gt; 21:
            is_game_over = True
        else:
            # If the game has not ended, ask the user if they want to draw another card.
            user_should_deal = input(&quot;Type 'y' to get another card, type 'n' to pass: &quot;).lower()
            if user_should_deal == &quot;y&quot;:
                user_cards.append(deal_card())
            else:
                is_game_over = True
    
    # Once the user is done, it's time to let the computer play. The computer should keep drawing cards as long as it has a score less than 17.
    while computer_score != 0 and computer_score &lt; 17:
        computer_cards.append(deal_card())
        computer_score = calculate_score(computer_cards)
    
    print(f&quot;   Your final hand: {user_cards}, final score: {user_score}&quot;)
    print(f&quot;   Computer's final hand: {computer_cards}, final score: {computer_score}&quot;)
    print(compare(user_score, computer_score))
    
    Ask the user if they want to restart the game. If they answer yes, clear the console and start a new game of blackjack and show the logo from art.py.
    while input("Do you want to play a game of Blackjack? Type 'y' or 'n': ").lower() == "y":
    os.system("cls")
    play_game()


Python实现21点纸牌游戏

## Hangman游戏

Hangman直译为“上吊的人”，是一个猜单词的双人游戏。由一个玩家想出一个单词或短语，另一个玩家猜该单词或短语中的每一个字母。第一个人抽走单词或短语，只留下相应数量的空白与下划线。

## hangman_words.py

    word_list = ["ardvark", "baboon", "camel"]

## hangman_art.py

    stages = [
        r"""
      +---+
      |   |
      O   |
     /|  |
     /   |
          |
    =========
    """,
        r"""
      +---+
      |   |
      O   |
     /|  |
     /    |
          |
    =========
    """,
        r"""
      +---+
      |   |
      O   |
     /|  |
          |
          |
    =========
    """,
        r"""
      +---+
      |   |
      O   |
     /|   |
          |
          |
    =========""",
        r"""
      +---+
      |   |
      O   |
      |   |
          |
          |
    =========
    """,
        r"""
      +---+
      |   |
      O   |
          |
          |
          |
    =========
    """,
        r"""
      +---+
      |   |
          |
          |
          |
          |
    =========
    """,
    ]
    logo = r"""
    _
    | |
    | |__   __ _ _ __   __ _ _ __ ___   __ _ _ __
    | '_  /  | '_  / _ | '  _  / _ | '_
    | | | | (| | | | | (| | | | | | | (| | | | |
    || ||__,|| ||, || || |_|,|| ||
    / |
    |/
    """

## main.py

    import random
    from hangman_art import logo, stages
    from hangman_words import word_list
    chosen_word = random.choice(word_list)
    word_length = len(chosen_word)
    end_of_game = False
    lives = 6
    print(logo)
    Create blanks
    display = []
    for _ in range(word_length):
    display += "_"
    while not end_of_game:
    guess = input("Guess a letter: ").lower()
    if guess in display:
        print(f&quot;You've already guessed {guess}&quot;)
        continue
    
    # Check guessed letter
    for position in range(word_length):
        letter = chosen_word[position]
        if letter == guess:
            display[position] = letter
    
    # Check if user is wrong.
    if guess not in chosen_word:
        print(f&quot;You guessed {guess}, that's not in the word. You lose a life.&quot;)
        lives -= 1
    
    # Join all the elements in the list and turn it into a string.
    print(f&quot;{' '.join(display)}&quot;)
    
    print(stages[lives])
    
    if &quot;_&quot; not in display:
        end_of_game = True
        print(&quot;You win!&quot;)
    
    if lives == 0:
        end_of_game = True
        print(&quot;You lose.&quot;)</code></pre>
    
    


Python实现Hangman游戏

## 美国国家游戏

针对美国各州名称测试您的知识。

    import turtle
    import pandas
    screen = turtle.Screen()
    screen.title("U.S. States Game")
    image = "blank_states_img.gif"
    screen.addshape(image)
    turtle.shape(image)
    data = pandas.read_csv("50_states.csv")
    all_states = data.state.to_list()
    guessed_states = []
    while len(guessed_states) < 50:
    answer_state = screen.textinput(title=f"{len(guessed_states)}/50 States Correct",
    prompt="What's another state's name?").title()
    if answer_state.lower() == "exit":
    missing_states = []
    for state in all_states:
    if state not in guessed_states:
    missing_states.append(state)
    new_data = pandas.DataFrame(missing_states)
    new_data.to_csv("states_to_learn.csv")
    break
    if answer_state in all_states:
    guessed_states.append(answer_state)
    t = turtle.Turtle()
    t.hideturtle()
    t.penup()
    state_data = data[data.state == answer_state]
    t.goto(int(state_data.x), int(state_data.y))
    t.write(answer_state)

## 关联资源下载

包含 2 个文件：50_states.csv 和 blank_states_img.gif。

下载地址：[https://gaga.lanzoum.com/i1K1R0s824oh](https://gaga.lanzoum.com/i1K1R0s824oh)


Python实现美国国家游戏US States Game

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。