Bac à sable d'apprentissage Python et feuille de triche

J'ai commencé à apprendre Python3 avec de la documentation sur le site officiel. J'ai aimé les exemples de code, mais malheureusement ils n'y étaient pas interactifs. Je voulais essayer d'exécuter le code moi-même, avec différentes données d'entrée et regarder la sortie. Il est également plus facile pour moi de me souvenir personnellement des constructions de langage si je les ai tapées manuellement plusieurs fois. La console Python est parfaite pour cela, mais je voulais aussi avoir une sorte de cheat sheet, qui pourrait être retourné lors de l'écriture de programmes à l'avenir, si, par exemple, la question se pose, comment écrire une boucle for en Python, etc. Et la dernière goutte était le désir de vérifier automatiquement le style d'écriture du code conformément aux normes existantes . C'était trop paresseux pour les lire et les approfondir, donc je voulais que le code soit vérifié automatiquement et suggéré quelles erreurs je faisais et comment les corriger.

En conséquence, j'ai versé toutes mes expériences sur GitHub .

Le référentiel est une collection de scripts Python , classés . Chaque script contient des exemples de code, des commentaires et des exemples d'utilisation, ainsi que des liens pour une lecture plus approfondie et une étude plus approfondie de chaque sujet.

En conséquence, le référentiel s'est avéré être un bac à sable, car les utilisateurs ont la possibilité de modifier ou d'ajouter du code, de voir comment il fonctionne et d'utiliser les tests pour vérifier son exactitude (à l'aide d' assertion . Il est également possible de vérifier que le code est conforme aux normes modernes . Dans l'ensemble, cela devrait aider aux utilisateurs d'apprendre la langue de manière plus interactive et dès le début pour maintenir une bonne propreté du code.

Le référentiel est également, à mon avis, une feuille de triche dans le sens où vous pouvez y revenir et rappeler les constructions de base du langage , les méthodes des objets, etc. De plus, du fait que le code est bourré d' assertion , les utilisateurs peuvent vérifier le résultat attendu de l'exécution des fonctions sans les démarrer.

Comment utiliser ce référentiel

Chaque script Python du référentiel a la structure suivante:

 """Lists <---    # @see: https://www.learnpython.org/en/Lists <--          ,    ( -  Lists). """ def test_list_type(): """   - ( " "  " ").     ... """ # Here is an example of how to build a list. <-- ,   squares = [1, 4, 9, 16, 25] # Lists can be indexed and sliced. # Indexing returns the item. assert squares[0] == 1 # <-- Assertion,    . # Slicing returns a new list. assert squares[-3:] == [9, 16, 25] # <-- Assertion,    . 

Par conséquent, le processus d'utilisation du référentiel peut être le suivant:

• Trouvez un sujet d'intérêt que vous souhaitez étudier ou rappeler.
• Lisez les commentaires, si nécessaire, suivez le lien avec une explication plus détaillée du sujet
• Afficher des exemples de code et des assertions.
• Modifiez ou ajoutez du code et voyez comment cela fonctionne.
• Exécutez des tests et vérifiez votre style de codage .

Sections du référentiel

1. Pour commencer
   
   • Qu'est-ce que Python
   • Syntaxe Python
   • Variables
2. Les opérateurs
   
   • Opérateurs arithmétiques ( + , - , * , / , // , % , ** )
   • Opérateurs au niveau du bit ( & , | , ^ , >> , << , ~ )
   • Opérateurs d'affectation ( = , += , -= , /= , //= etc.)
   • Opérateur de comparaison ( == != , > , < , >= , <= )
   • Opérateurs logiques ( and , or not )
   • Opérateurs d'identité ( is , is not )
   • Opérateurs d'adhésion ( in , not in )
3. Types de données
   
   • Numéros (y compris les booléens)
   • Les cordes et leurs méthodes
   • Listes et leurs méthodes (y compris les listes de compréhension)
   • Tuples
   • Ensembles et leurs méthodes
   • Dictionnaires
   • Coulée de type
4. Contrôle du flux
   
   • The if instruction The if
   • The for instruction The for (et la fonction range() )
   • The while instruction The while
   • The try instructions The try
   • The break déclaration de The break
   • The continue instruction The continue
5. Les fonctions
   
   • Définition de la fonction (instructions def et return )
   • Valeurs d'argument par défaut
   • Arguments des mots clés
   • Listes d'arguments arbitraires
   • Décompression des listes d'arguments (instructions * et ** )
   • Expressions Lambda (instruction lambda )
   • Chaînes de documentation
   • Annotations de fonction
6. Cours
   
   • Définition de class (énoncé de class )
   • Objets de classe
   • Objets d'instance
   • Objets de méthode
   • Variables de classe et d'instance
   • Héritage
   • Héritage multiple
7. Modules
   
   • Modules (déclaration d' import )
   • Forfaits
8. Erreurs et exceptions
   
   • Gestion des exceptions (instruction try )
   • raise exceptions ( raise déclaration)
9. Fichiers
   
   • Lecture et écriture ( with déclaration)
   • Méthodes des objets fichier
10. Ajouts
    
    • The pass déclaration de The pass
    • Générateurs (déclaration de yield )
11. Brève visite des bibliothèques standard
    
    • Sérialisation (bibliothèque json )
    • Fichiers jokers (bibliothèque glob )
    • Correspondance des motifs de chaîne ( re bibliothèque)
    • Mathématiques ( math , random , bibliothèques de statistics )
    • Dates et heures (bibliothèque datetime )
    • Compression des données (bibliothèque zlib )

J'espère que ce référentiel vous sera utile.