Python Cheat Sheet: Guide rapide et facile essentiel

Lors de la programmation en Python , avoir une feuille de triche fiable à vos côtés peut changer la donne. Python est peut-être connu pour sa simplicité et sa lisibilité, mais il est indéniable que sa vaste gamme de caractéristiques et de fonctionnalités est trop difficile à mémoriser !

Les feuilles de triche Python servent de référence pratique pour les développeurs débutants et expérimentés. Ils fournissent un guide de référence de base pour diverses commandes, syntaxes, structures de données, etc.

Ce guide est une feuille de triche Python qui peut vous aider à naviguer à travers diverses fonctions , bibliothèques, classes et syntaxes qui peuvent être accablantes, en particulier pour les débutants.

Êtes-vous de la vieille école? Si vous préférez télécharger et imprimer, veuillez consulter le pdf ci-dessous pour vous aider dans votre parcours d'apprentissage de Python !

Python-Cheat-Sheet-1 Télécharger

Table des matières

• Référence rapide pour les bases de la syntaxe Python
  • 1. Commentaires
  • 2. Variables
  • 3. Types de données
  • 4. Déclarations conditionnelles
  • 5. Boucles
  • 6. Fonctions
• Référence rapide pour les structures de données Python
  • 1. Listes
  • 2. Tuples
  • 3 ensembles
  • 4. Dictionnaires
• Référence rapide pour les E/S de fichier Python
  • 1. Lecture de fichiers
  • 2. Écrire des fichiers
  • 3. Ajout aux fichiers
• Référence rapide pour la gestion des erreurs en Python
  • 1. Essayez et exceptez
  • 2. Enfin
  • 3. Lever des exceptions
• Référence rapide pour les modules et packages Python
  • 1. Importation de modules
  • 2. Création de packages
• Référence rapide pour la programmation orientée objet en Python
  • 1. Cours
  • 2. Héritage
  • 3. Encapsulation
• 4 bibliothèques Python utiles
  • 1. NumPy
  • 2. Les pandas
  • 3. Demandes
  • 4. Belle soupe
• Dernières pensées

Référence rapide pour les bases de la syntaxe Python

Pour lancer notre aide-mémoire Python, nous allons explorer quelques bases de la syntaxe Python. Avoir une bonne compréhension des bases de Python vous fournira une base solide pour écrire du code plus complexe.

Pour cette référence, nous avons inclus : commentaires , variables , types de données , instructions conditionnelles , boucles et fonctions .

1. Commentaires

Les commentaires sont une partie importante de votre code, car ils vous permettent d'expliquer votre processus de réflexion et de rendre votre code plus lisible. En Python, vous pouvez créer des commentaires sur une seule ligne à l'aide du symbole dièse (#).

# This is a single-line comment.

Pour les commentaires sur plusieurs lignes, vous pouvez utiliser des guillemets triples (simples ou doubles).

""" This is a
multi-line
comment. """

2. Variables

Les variables en Python sont utilisées pour stocker des données. Vous pouvez attribuer des valeurs aux variables à l'aide du signe égal (=).

x = 5
name = "John"

Les noms de variables doivent être descriptifs et respecter la convention de dénomination consistant à utiliser des lettres minuscules et des traits de soulignement pour les espaces.

user_age = 25
favorite_color = "blue"

3. Types de données

Le langage Python est livré avec plusieurs types de données intégrés par défaut. Certains des plus courants incluent:

• Types de texte : str

• Type booléen : bool

• Types numériques : entier, flottant, complexe

• Types de séquence : liste, tuple, plage

• Aucun Type : Aucun type

Pour connaître le type de données de n'importe quel objet Python, vous pouvez utiliser la fonction type() . Par exemple:

name = 'jane'
print(type(name))

#Output: 'str'

4. Déclarations conditionnelles

Les instructions conditionnelles en Python vous permettent d'exécuter du code uniquement lorsque certaines conditions sont remplies. Les instructions conditionnelles courantes sont ' if ', 'elif ' et ' else '.

if condition:
    # Code to execute if the condition is true
elif another_condition:
    # Code to execute if the another_condition is true
else:
    # Code to execute if none of the conditions are true

5. Boucles

Une boucle est utilisée pour exécuter de manière répétée un bloc de code. Python a deux types de boucles : une boucle « for » et une boucle « while ».

Jetons un coup d'œil aux deux :

Pour les boucles :

for variable in iterable:
    # Code to execute for each element in the iterable

Boucles While :

while condition:
    # Code to execute while the condition is true

À l'intérieur de ces boucles, vous pouvez utiliser des instructions conditionnelles et de contrôle pour contrôler le déroulement de votre programme.

6. Fonctions

Functions in Python are blocks of code that perform specific tasks. You can define a function using the ‘def‘ keyword, followed by the function name and parentheses containing any input parameters.

def function_name(parameters):
    # Code to execute
    return result

To call a function, use the function name followed by parentheses containing the necessary arguments.

function_name(arguments)

Now that we’ve gone over the Python basics, let’s move on to some more advanced topics in the next section.

Quick Reference for Python Data Structures

Next in our Python cheatsheet, we’ll discuss some of the most commonly used data structures in Python. These data structures are essential in managing and organizing the data in your programming projects.

There are many data structures in Python that advanced developers can use. However, we’ll focus on Lists, Tuples, Sets, and Dictionaries.

1. Lists

A list in Python is a mutable, ordered sequence of elements. To create a list, use square brackets and separate the elements with commas.

Python lists can hold a variety of data types like strings, integers, booleans, etc. Here are some examples of operations you can perform with Python lists:

• Create a list:

  my_list = [1, 2, 3]

• Access elements:

  my_list[0]

• Add an element:

  my_list.append(4)

2. Tuples

A tuple is similar to a list, but it is immutable, which means you cannot change its elements once created. You can create a tuple by using parentheses and separating the elements with commas.

Here are some examples of tuple operations:

• Create a tuple:

  my_tuple = (1, 2, 3)

• Access elements:

  my_tuple[0] #Output: 1

3. Sets

A set is an unordered collection of unique elements. You can create a set using the set() function or curly braces.

It can also hold a variety of data types, as long as they are unique. Here are some examples of set operations:

• Create a set:

   my_set = {1, 2, 3}

• Add an element:

  my_set.add(4)

• Remove an element:

  my_set.remove(1)

4. Dictionaries

A dictionary is an unordered collection of key-value pairs, where the keys are unique. You can create a dictionary using curly braces and separating the keys and values with colons. Here are some examples of dictionary operations:

• Create a dictionary:

  my_dict = {'key1': 'value1', 'key2': 'value2'}

• Access elements:

  my_dict['key1'] #Output:'value1'

• Add a key-value pair:

  my_dict['key3'] = 'value3'

• Remove a key-value pair:

  del my_dict['key1']

Remember to practice and explore these data structures in your Python projects to become more proficient in their usage! Next, we’re going to give you a reference for file I/O tasks.

Quick Reference for Python File I/O

In this section of the Python cheat sheet, we’ll focus on some common tasks related to working with files in Python, such as reading, writing, and appending data.

1. Reading Files

To read a file, you first need to open it using the built-in open() function, with the mode parameter set to ‘r‘ for reading:

file_obj = open('file_path', 'r')

Now that your file is open, you can use different methods to read its content:

• read(): Reads the entire content of the file.

• readline(): Reads a single line from the file.

• readlines(): Returns a list of all lines in the file.

It’s important to remember to close the file once you’ve finished working with it:

file_obj.close()

Alternatively, you can use the with statement, which automatically closes the file after the block of code completes:

with open('file_path', 'r') as file_obj:
    content = file_obj.read()

2. Writing Files

To create a new file or overwrite an existing one, open the file with mode ‘w‘:

file_obj = open('file_path', 'w')

Write data to the file using the write() method:

file_obj.write('This is a line of text.')

Don’t forget to close the file:

file_obj.close()

Again, consider using the with statement for a more concise and safer way to handle files:

with open('file_path', 'w') as file_obj:
    file_obj.write('This is a line of text.')

3. Appending to Files

To add content to an existing file without overwriting it, open the file with mode ‘a‘:

file_obj = open('file_path', 'a')

Use the write() method to append data to the file:

file_obj.write('This is an extra line of text.')

And, as always, close the file when you’re done:

file_obj.close()

For a more efficient and cleaner approach, use the with statement:

with open('file_path', 'a') as file_obj:
    file_obj.write('This is an extra line of text.')

By following these steps and examples, you can efficiently navigate file operations in your Python applications. Remember to always close your files after working with them to avoid potential issues and resource leaks!

In the next section, we provide a reference for error handling in Python.

Quick Reference for Error Handling in Python

In this section, you’ll learn about error handling in Python, which plays a crucial role in preventing the abrupt termination of your programs when it encounters an error.

We’ll cover the following sub-sections: Try and Except, Finally, and Raising Exceptions.

1. Try and Except

To handle exceptions in your code, you can use the try and except blocks. The try block contains the code that might raise an error, whereas the except block helps you handle that exception, ensuring your program continues running smoothly.

Here’s an example:

try:
    quotient = 5 / 0

except ZeroDivisionError as e:
    print("Oops! You're trying to divide by zero.")

In this case, the code inside the try block will raise a ZeroDivisionError exception. Since we have an except block to handle this specific exception, it will catch the error and print the message to alert you about the issue.

2. Finally

The finally block is used when you want to ensure that a specific block of code is executed, no matter the outcome of the try and except blocks. This is especially useful for releasing resources or closing files or connections, even if an exception occurs, ensuring a clean exit.

Here’s an example:

try:
    # Your code here
except MyException as e:
    # Exception handling
finally:
    print("This will run no matter the outcome of the try and except blocks.")

3. Raising Exceptions

You can also raise custom exceptions in your code to trigger error handling when specific conditions are met. To do this, you can use the raise statement followed by the exception you want to raise (either built-in or custom exception).

For instance:

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be a negative value.")

try:
    validate_age(-3)
except ValueError as ve:
    print(ve)

In this example, we’ve defined a custom function to validate an age value. If the provided age is less than zero, we raise a ValueError with a custom message. When calling this function, you should wrap it in a try-except block to handle the exception properly.

Next, we’re going to provide a quick reference for popular Python modules and packages. Let’s go!

Quick Reference for Python Modules and Packages

This section of our cheat sheet is for Python packages and modules, which are essential for structuring and organizing your code cleanly and efficiently.

You’ll learn about importing modules and creating packages.

1. Importing Modules

Modules in Python are files containing reusable code, such as functions, classes, or variables. Python offers several modules and packages for different tasks like data science, machine learning, robotics, etc.

To use a module’s contents in your code, you need to import it first. Here are a few different ways to import a module:

• import : This imports the entire module, and you can access its contents using the syntax ‘module_name.content_name.’
  For example:

  import random
  
  c = random.ranint()

• from import : This imports a specific content (function or variable) from the module, and you can use it directly without referencing the module name.

  from math import sin
  
  c = sin(1.57)

• from import *: This imports all contents of the module. Be careful with this method as it can lead to conflicts if different modules have contents with the same name.

Some commonly used built-in Python modules include:

1. math: Provides mathematical functions and constants

2. random: Generates random numbers and provides related functions

3. datetime: Handles date and time operations

4. os: Interacts with the operating system and manages files and directories

2. Creating Packages

Packages in Python are collections of related modules. They help you organize your code into logical and functional units. To create a package:

1. Create a new directory with the desired package name.

2. Add an empty file named init.py to the directory. This file indicates to Python that the directory should be treated as a package.

3. Add your module files (with the .py extension) to the directory.

Now, you can import the package or its modules into your Python scripts. To import a module from a package, use the syntax:

import 

Structure your code with modules and packages to make it more organized and maintainable. This will also make it easier for you and others to navigate and comprehend your codebase.

In the next section, we provide a reference for object-oriented programming concepts in Python.

Quick Reference for Object-Oriented Programming in Python

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects“, which can contain data and code.

The data is in the form of fields, often known as attributes or properties, and the code is in the form of procedures, often known as methods.

In this section of the cheat sheet, we’ll delve into the fundamental concepts of OOP in Python, including classes, inheritance, and encapsulation.

1. Classes

A class is a blueprint for creating objects. It defines the data (attributes) and functionality (methods) of the objects. To begin creating your own class, use the “class” keyword followed by the class name:

class ClassName:
    # Class attributes and methods

To add attributes and methods, simply define them within the class block. For example:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print("Woof!")

In this example, a new Dog object can be created with a name and breed, and it has a bark method that prints “Woof!” when called.

2. Inheritance

Inheritance allows one class to inherit attributes and methods from another class, enabling code reusability and modularity. The class that inherits is called a subclass or derived class, while the class being inherited from is called the base class or superclass.

To implement inheritance, add the name of the superclass in parentheses after the subclass name:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

For instance, you could create a subclass “Poodle” from a “Dog” class:

class Poodle(Dog):
    def show_trick(self):
        print("The poodle does a trick.")

A Poodle object would now have all the attributes and methods of the Dog class, as well as its own show_trick method.

3. Encapsulation

L'encapsulation est la pratique consistant à encapsuler des données et des méthodes qui fonctionnent sur ces données dans une seule unité, un objet dans ce cas. Cela favorise une séparation claire entre l'implémentation interne d'un objet et son interface externe.

Python utilise la manipulation de noms pour réaliser l'encapsulation des membres de la classe en ajoutant un préfixe de double trait de soulignement au nom de l'attribut, ce qui le rend apparemment privé.

class Example:
    def __init__(self):
        self.__private_attribute = "I'm private!"

    def __private_method(self):
        print("You can't see me!")

Bien que vous puissiez toujours techniquement accéder à ces membres privés en Python, cela est fortement déconseillé car cela viole les principes d'encapsulation.

En comprenant et en implémentant les classes, l'héritage et l'encapsulation dans vos programmes Python, vous pouvez utiliser la puissance et la flexibilité de la POO pour créer un code propre, modulaire et réutilisable.

Pour notre dernière section de la feuille de triche, nous vous fournirons une référence rapide pour quatre bibliothèques Python populaires.

4 Helpful Python Libraries

Several Python libraries can help you accomplish a variety of tasks or gain tools for various topics like maths, data science, web scraping, etc.

In this section, we’ll briefly discuss the following libraries: NumPy, Pandas, Requests, and Beautiful Soup.

1. NumPy

NumPy is a popular Python library for mathematical and scientific computing. With its powerful N-dimensional array object, you can handle a wide range of mathematical operations, such as:

• Basic mathematical functions

• Linear algebra

• Fourier analysis

• Random number generation

NumPy’s efficient array manipulations make it particularly suitable for projects that require numerical calculations.

2. Pandas

Pandas is a powerful data analysis and manipulation library that you can use to work with structured data. It’s also very popular in the data science community due to the wide array of tools it provides for handling data.

Some of its features include:

• Data structures like Series (1D) and DataFrame (2D)

• Data cleaning and preparation

• Statistical analysis

• Time series functionality

By utilizing Pandas, you can easily import, analyze, and manipulate data in a variety of formats, such as CSV, Excel, and SQL databases.

If you’re interested in Pandas, you can check out our video on how to resample time series data using Pandas to enhance analysis:

3. Requests

The Requests library simplifies the process of handling HTTP requests in Python. With this library, you can easily send and receive HTTP requests, such as GET, POST, and DELETE.

Some key features include:

• Handling redirects and following links on web pages

• Adding headers, form data, and query parameters via simple Python libraries

• Managing cookies and sessions

Using Requests, you can quickly and efficiently interact with various web services and APIs.

4. Beautiful Soup

Beautiful Soup is a Python library for web scraping, which allows you to extract data from HTML and XML documents. Some of its key features include:

• Searching for specific tags or CSS classes

• Navigating and modifying parsed trees

• Extracting relevant information based on tag attributes

En utilisant Beautiful Soup conjointement avec Requests, vous pouvez créer de puissantes applications de grattage Web qui collectent des informations à partir d'un large éventail de sites Web.

Dernières pensées

Et cela nous amène à la fin de notre rapide voyage sur la voie Python. Cette feuille de triche est votre guide de poche, votre fidèle compagnon lorsque vous avez besoin d'un rappel rapide des principales fonctions et commandes de Python.

Notre liste n'est pas exhaustive, mais c'est un bon début, une fondation sur laquelle vous pouvez bâtir. Alors allez-y, marquez-le, imprimez-le, collez-le sur votre mur - assurez-vous simplement qu'il est à portée de main lorsque vous codez. Bonne programmation !