Cet article vous expliquera la manière stupide d'apprendre le disque réseau Baidu pdf avancé de Python 3 et la manière stupide d'apprendre le téléchargement de livres électroniques Python 3. J'espère que cela vous sera utile.N'oubliez pas de mettre ce site en signet.
« Manière stupide » d'apprendre la série d'articles de base de Python 3
"Stupid Ways" pour apprendre les bases de Python 3 Partie 1 - Impression et saisie
"Stupid Ways" pour apprendre les bases de Python 3 Partie 2 - Opérations sur les fichiers
"Stupid Ways" pour apprendre les bases de Python 3 Partie 3 - Fonctions
"Stupid Ways" pour apprendre Python 3 Bases Partie 4 - Conteneurs de données et structure du programme
"Stupid Ways" pour apprendre les bases de Python 3 Partie 5 - Classes orientées objet
"Stupid Ways" pour apprendre les bases de Python 3 Partie 6 - Project Skeleton et tests automatiques
"Stupid Ways" "Learning Python 3 Septième partie - Créer un site Web simple
Créer un site Web simple
- « Manière stupide » d'apprendre la série d'articles de base de Python 3
- avant-propos
- 7.1 Installation du framework Web-flask et création de projet
- 7.2 Utilisation de la méthode orientée objet pour concevoir un jeu à trois corps
- 7.3 Écrire un script de test automatique pour game.py
- 7.4 Écrire des modèles HTML
- 7.5 Créer un moteur de jeu Web à trois corps
- 7.6 Effet de jeu en cours
- épilogue
avant-propos
C'est enfin le dernier article de cette série, et je suis un peu excité. Bien qu'il y ait eu beaucoup de temps au milieu, chaque mot de code m'a fait comprendre les avantages de la persistance et du résumé, et j'ai pu reconstruire les connaissances initialement stockées dans un coin de mon esprit et devenir ma propre construction de connaissances. l'étude, le cerveau a également effectué un "massage" spirituel dans chaque résumé.
Dans cet article, j'utiliserai la méthode de programmation orientée objet pour écrire un jeu à trois corps de type dialogue (avec Zhang Beihai comme protagoniste) et créer un site Web de jeu simple via flask (seulement c'est ce que j'ai appris jusqu'à présent ).
7.1 Installation du framework Web-flask et création de projet
Pour utiliser les services Web, un framework "Web" doit être installé, ce qui réduit la charge de développement. Dans le livre, l'application du cadre du flacon est principalement introduite. Après avoir activé l'environnement virtuel, passez
pip install flask
Pour réaliser l'installation, le processus d'installation est comme indiqué dans la figure ci-dessous : 
Une fois l'installation du flacon terminée, vous devez créer un projet à trois corps et entrer la commande suivante dans PowerShell :
cd projects
mkdir threebody
cd threebody
mkdir bin
mkdir threebody
mkdir tests
mkdir docs
mkdir templates
new-item -type file .\threebody\__init__.py
new-item -type file .\tests\__init__.py
La différence avec la création de projet précédente est qu'un nouveau répertoire nommé "templates" est créé pour stocker le modèle html du site Web.
7.2 Utilisation de la méthode orientée objet pour concevoir un jeu à trois corps
Créez un nouveau game.py dans le répertoire threebody\threebody comme programme principal du jeu à trois. L'idée de conception de l'ensemble du jeu à trois corps est réalisée par la commutation de scène.Les joueurs peuvent entrer dans différentes intrigues en faisant des choix, similaires à des jeux tels que "Autumn Memories". Le cœur du programme est une conception de type Scene, et le code spécifique est :
class Scene:
"""基本场景类"""
def __init__(self, name, deion):
self.name = name
self.deion = deion
self.paths = {}
def enter(self, direction):
return self.paths.get(direction, None)
def add_paths(self, paths):
self.paths.update(paths)
Chaque scène initialise la classe Scene en tant qu'objet. Lors de l'initialisation, restituez le nom et la description du tracé de la scène, et initialisez les chemins du dictionnaire qui déterminent la direction du tracé. Utilisez la fonction enter(direction) pour renvoyer l'objet de scène spécifié par direction, et utilisez la fonction add_paths(paths) pour mettre à jour les chemins du dictionnaire de direction de tracé, afin d'établir la connexion de tracé de différents objets de scène. Le contexte de l'intrigue est illustré dans la figure ci-dessous : 
l'intrigue du jeu commence à partir de la sélection naturelle et se termine avec le mausolée de l'espace. Si chaque scène du milieu est sélectionnée de manière incorrecte, elle entrera dans la scène de la mort (selon les différentes intrigues, la scène de la mort doit être subdivisée). Le jeu peut être rejoué en sélectionnant rejouer pendant la scène de la mort. Ce flux de tracé est réalisé via add_paths dans Scene. Le code spécifique est le suivant :
natureSelectionFleet.add_paths({
'1': death_1_1,
'2': death_1_2,
'3': death_1_3,
'4': escape,
'*': natureSelectionFleet
})
escape.add_paths({
'1': death_2,
'2': death_2,
'3': death_2,
'4': control_terminal,
'*': escape
})
control_terminal.add_paths({
'1': extrasolar,
'2': death_3,
'3': death_3,
'4': death_3,
'*': control_terminal
})
extrasolar.add_paths({
'1': fleet_earth,
'2': death_2,
'3': death_4,
'*': extrasolar
})
fleet_earth.add_paths({
'1': death_2,
'2': ultimate_rule_fleet,
'3': ultimate_rule_fleet,
'*': fleet_earth
})
ultimate_rule_fleet.add_paths({
'1': blue_space_fleet,
'2': death_6,
'3': death_5,
'4': death_2,
'*': ultimate_rule_fleet
})
blue_space_fleet.add_paths({
'1': last_episode,
'2': death_6,
'*': blue_space_fleet
})
Le * ici représente l'entrée invalide du joueur. Lorsque l'entrée est invalide, la scène de l'intrigue ne changera pas et restera dans la scène d'origine. Le travail restant consiste à concevoir différents objets de scène, le code spécifique est :
#自然选择号死亡场景
death1 = """
自然选择号在与三体文明'水滴'探测器的激战中被摧毁......
"""
death_1_1 = Scene("游戏失败",
f"""
原来你也接收了思想钢印。
警卫员！
马上逮捕章北海！
{death1}
""")
death_1_2 = Scene("游戏失败",
f"""
章北海，你这个懦夫！
你的内心充分暴露出来了，表面是个人类必胜论者，
内心确是一个失败论者。
警卫员！
马上逮捕章北海！
{death1}
""")
death_1_3 = Scene("游戏失败",
f"""
你是云天明？
警卫员！
马上通知地球舰队！
{death1}
""")
death_2 = Scene("游戏失败", death1)
death_3 = Scene("游戏失败",
f"""
飞船控制失败！
{death1}
"""
)
death_4 = Scene("游戏失败",
f"""
东方延绪：
章北海, 我代表星舰地球逮捕你。
全员准备，返航迎击三体人的探测器。
{death1}
""")
death_5 = Scene("游戏失败",
f"""
在更改航线后，遭遇了三体文明的舰队，被击毁...
""")
death_6 = Scene("游戏失败",
f"""
遭遇了黑暗森林法则，被星舰地球中的其它战舰次声波核弹攻击，
全员阵亡！
""")
#自然选择号
natureSelectionFleet = Scene("自然选择号",
"""
东方延绪：
章北海执行舰长，我是自然选择号的舰长东方延绪。欢迎您。
现在我把自然选择号的指挥权交给您。飞船有四种前进模式，
当进入前进4模式时，船员必须进入睡眠仓。现在，我需要
再次确认您是否受到思想钢印的影响，请您回答我这个问题：
'人类是否必胜？'
[1] 必胜
[2] 必败
[3] 这要取决于我所见到的三体文明
[4] 人的意志胜过一切
""")
#逃离太阳系
escape = Scene("自然选择号战舰控制中心",
"""
东方延绪：
章北海舰长，现在我交出自然选择号的控制权。据地球舰队传来的最新消息：
三体文明的探测器-水滴-已经抵达太阳系的边缘，15分钟后将与地球舰队接触。
现在飞船等待您发布第一条命令：
[1] 前进1 逃离太阳系
[2] 前进2 逃离太阳系
[3] 前进3 逃离太阳系
[4] 前进4 逃离太阳系
""")
#飞控终端
control_terminal = Scene("自然选择号战舰飞控终端","""
警告！
警告！
警告！
飞船进入前进4必须通知所有船员进入深海睡眠模式。请输入飞控密码：
[1] Man Always Remember Love Because Of Romance Only
[2] If You Give Me A Pivot Point I Could Move The Earth
[3] The Sun Rather Than The Earth At The Center Of The Universe
[4] Two Heads Are Always Better Than One
""")
# 太阳系外
extrasolar = Scene("自然选择号战舰","""
飞船已经飞出了太阳系，身后的蓝色空间号、深空号、终极规律号以及企业号正在追击。
下一步命令是：
[1] 延续人类文明，向前飞，向远飞
[2] 掉头击毁追击战舰
[3] 将舰队指挥权交给东方延续舰长
"""
)
# 星舰地球
fleet_earth = Scene("星舰地球","""
地球舰队已经被水滴摧毁.......
五艘战舰必须延续文明的责任，太空将是我们最后的归宿。星舰地球决定：
[1] 处决人类的叛徒章北海，回去与水滴战斗
[2] 处决人类的叛徒章北海，继续飞往十八光年外的天鹅座NH558J2
[3] 章北海是英雄，继续飞往十八光年外的天鹅座NH558J2
"""
)
#终极规律号
ultimate_rule_fleet = Scene("终极规律号","""
终极规律号战舰中出现了一种不安的气氛......
十四光年，飞船的资源是有限的，如何得到补给？
舰长，我们该怎么办？
[1] 向其它四艘战舰发射次声波氢弹
[2] 向其它四艘战舰求援，请求补给
[3] 要求星舰地球更改航程，找到补给点
[4] 回地球吧
"""
)
#蓝色空间号
blue_space_fleet = Scene("蓝色空间号","""
警告！
警告！
警告！
终极规律号的次声波氢弹冲击波即将到达....
防御成功，舰队损伤5%...
等待下一步命令：
[1] 发射高能伽马射线激光击毁终极规律号
[2] 逃离
""")
#最后的场景
last_episode = Scene("太空陵墓","""
蓝色空间号带走了所有的燃料和配件，并将自然选择号、企业号、深空号的
残骸切割多段，围城巨石阵，构建了一处太空陵墓，纪念人类第一次体会到
宇宙‘黑暗森林’的可怕。
恭喜你，顺利通过了剧情！
"""
)
START = 'natureSelectionFleet'
# 返回场景名字对应的场景对象
def load_scene(name):
return globals().get(name)
# 返回场景对象对应的场景名字
def name_scene(scene):
for key, value in globals().items():
if value == scene:
return key
7.3 Écrire un script de test automatique pour game.py
Ensuite, un script de test automatisé pour game.py sera écrit. Créez un nouveau game_tests.py dans le répertoire tests\, et l'outil de test est toujours nosetests. Testez la fonction d'initialisation, add_paths et entrez les fonctions de Scene dans game.py respectivement. Le code spécifique est :
from nose.tools import *
from threebody.game import *
def test_scene():
gold = Scene("GoldRoom",
"""This room has gold in it you can grab.
There's a door to the north.""")
assert_equal(gold.name, "GoldRoom")
assert_equal(gold.paths, {})
def test_add_enter_paths():
center = Scene("Center", "Test room in the center.")
north = Scene("North", "Test room in the north.")
south = Scene("South", "Test room in the south.")
center.add_paths({'north': north, 'south': south})
assert_equal(center.enter('north'), north)
assert_equal(center.enter("south"), south)
def test_game_map():
start_room = load_scene(START)
assert_equal(start_room.enter('1'), death_1_1)
assert_equal(start_room.enter('2'), death_1_2)
assert_equal(start_room.enter('3'), death_1_3)
assert_equal(start_room.enter('4'), escape)
assert_equal(start_room.enter('*'), natureSelectionFleet)
Il convient de noter que lors de l'importation de fonctionnalités, toutes les classes et variables globales mentionnées doivent être importées depuis threebody\game.py. Les résultats des tests dans PowerShell sont :
7.4 Écrire des modèles HTML
Dans le jeu à trois corps, nous avons utilisé des modèles de mise en page et des formulaires POST. Créez deux fichiers show_room.html et layout.html dans le répertoire templates\. Le code du modèle de mise en page est :
<html>
<head>
<title>三体游戏</title>
</head>
<body>
{% block content %}
{% endblock %}
</body>
</html>
Contient principalement le titre "Three-Body Game". Le code du formulaire POST est :
{% extends "layout.html" %}
{% block content %}
<h1>{
{ room.name }}</h1>
<pre>
{
{ room.deion }}
</pre>
{% if room.name == "游戏失败"%}
<p><a href="/">Play Again?</a></p>
{% elif room.name == "太空陵墓" %}
<p><a href="/">退出游戏</a></p>
{% else %}
<p>
<form action='/play' method='POST'>
- <input type='text' name='action'><input type='SUBMIT'>
</form>
</p>
{% endif %}
{% endblock %}
Dans ce fichier html, le modèle de mise en page est chargé en premier, puis le nom de l'objet de la scène et la description du tracé sont affichés sur la page Web. Activez ensuite l'instruction de jugement conditionnel if-else. Lorsque la chaîne nommée "échec du jeu" est détectée, "jouer à nouveau ?" s'affiche en bas de la description de l'intrigue ; lorsque la chaîne nommée "Space Mausoleum" est détectée, Display " Quitter le jeu" en bas de la description de l'intrigue ; sinon, affichez une zone de texte attendant que l'utilisateur saisisse des informations pour faire avancer l'intrigue.
7.5 Créer un moteur de jeu Web à trois corps
Le fichier python du moteur de jeu doit être créé dans le répertoire principal du projet, c'est-à-dire le premier répertoire à trois corps. J'ai créé un fichier de moteur Web appelé app.py. Il fait principalement référence aux fonctionnalités FLASK, session, redirect, url_for, request, render_template dans le cadre du réseau flask. Bien sûr, pour exécuter le jeu, game.py doit également être introduit. Le code spécifique est le suivant :
from flask import Flask, session, redirect, url_for, request
from flask import render_template
from threebody import game
app = Flask(__name__)
@app.route("/")
def index():
#this is used to "setup" session with starting values
session['scene_name'] = game.START #利用会话临时存储场景名字
return redirect(url_for("play"))
@app.route("/play", methods=['POST', 'GET'])
def play():
scene_name = session.get('scene_name') #获得当前场景的名字
if request.method == 'GET':
room = game.load_scene(scene_name) #通过场景的名字加载场景对象
return render_template("show_room.html", room=room)
else:
action = request.form.get('action')
if scene_name and action:
room = game.load_scene(scene_name)
next_scene = room.enter(action) #获取下一个场景的对象
if not next_scene:
next_scene = room.enter('*')
#将下一个场景的名字存在临时会话中，供web服务器使用
session['scene_name'] = game.name_scene(next_scene)
else:
session['scene_name'] = game.name_scene(next_scene)
return redirect(url_for("play"))
# YOU SHOULD CHANGE THIS IF YOU PUT ON THE INTERNET
app.secret_key = 'sdjffiweriwuer923riew3shfs'
if __name__ == "__main__":
app.run()
La première fonction principale du programme est index(), qui représente le répertoire principal "/", et utilise la session session temporaire pour stocker le nom de la scène, afin qu'il puisse être utilisé lors du prochain appel. Retournez dans le répertoire "/play". La seconde fonction principale du programme est play(). Il existe deux modes POST ou GET dans le répertoire "/play". Lorsqu'aucune entrée utilisateur n'est obtenue, la valeur par défaut est GET. À ce moment, le moteur charge le fichier show_room.html. Une fois que l'utilisateur a saisi des informations valides, il passe en mode post. À ce moment, le moteur obtient la scène de tracé suivante en fonction des informations, la stocke dans la session de session et retourne au répertoire de lecture pour charger la scène suivante. Enfin, exécutez automatiquement le moteur de jeu Web via l'instruction app.run().
7.6 Effet de jeu en cours
Dans Powershell, exécutez
python app.py
Le résultat est : 
le mode débogage est fermé à ce moment, si vous voulez l'ouvrir, changez app.run() en app.run(debug = True). Lors de l'exécution sur la page Web locale, selon l'invite, entrez localhost:5000/ sur le navigateur. L'effet est le suivant :
épilogue
C'est la première série d'articles écrits par moi-même sur CSDN.Bien qu'il n'y ait rien de nouveau dans le contenu, j'insiste pour écrire, organiser ma pensée très clairement, et savoir ce que je ne maîtrise pas encore. Ensuite, vous devez vous taire pendant un certain temps, continuer à étudier et continuer à écrire.