Hoja de trucos de Python: Guía esencial rápida y fácil

Al programar en Python , tener una hoja de trucos confiable a su lado puede cambiar las reglas del juego. Python puede ser conocido por su simplicidad y legibilidad, ¡pero no se puede negar que su amplia gama de características y funcionalidades es demasiado para memorizar!

Las hojas de trucos de Python sirven como referencia útil tanto para principiantes como para desarrolladores experimentados. Proporcionan una guía de referencia básica para varios comandos, sintaxis, estructuras de datos y más.

Esta guía es una hoja de trucos de Python que puede ayudarlo a navegar a través de varias funciones , bibliotecas, clases y sintaxis que pueden ser abrumadoras, especialmente para los principiantes.

¿Eres de la vieja escuela? ¡Prefiere descargar e imprimir, consulte el pdf a continuación para ayudarlo en su viaje de aprendizaje de Python!

Python-Cheat-Sheet-1 Descargar

Tabla de contenido

• Referencia rápida para conceptos básicos de sintaxis de Python
  • 1. Comentarios
  • 2. Variables
  • 3. Tipos de datos
  • 4. Declaraciones condicionales
  • 5. Bucles
  • 6. Funciones
• Referencia rápida para estructuras de datos de Python
  • 1. Listas
  • 2. tuplas
  • 3 juegos
  • 4. Diccionarios
• Referencia rápida para la E/S de archivos de Python
  • 1. Lectura de archivos
  • 2. Escribir archivos
  • 3. Agregar a archivos
• Referencia rápida para el manejo de errores en Python
  • 1. Prueba y excepto
  • 2. Finalmente
  • 3. Levantamiento de excepciones
• Referencia rápida para módulos y paquetes de Python
  • 1. Importación de módulos
  • 2. Creación de paquetes
• Referencia rápida para la programación orientada a objetos en Python
  • 1. Clases
  • 2. Herencia
  • 3. Encapsulación
• 4 útiles bibliotecas de Python
  • 1. Número
  • 2. pandas
  • 3. Solicitudes
  • 4. Hermosa Sopa
• Pensamientos finales

Referencia rápida para conceptos básicos de sintaxis de Python

Para comenzar nuestra hoja de trucos de Python, exploraremos algunos conceptos básicos de sintaxis de Python. Tener una sólida comprensión de los conceptos básicos de Python le proporcionará una base sólida para escribir código más complejo.

Para esta referencia, hemos incluido: comentarios , variables , tipos de datos , declaraciones condicionales , bucles y funciones .

1. Comentarios

Los comentarios son una parte importante de su código, ya que le permiten explicar su proceso de pensamiento y hacer que su código sea más legible. En Python, puede crear comentarios de una sola línea usando el símbolo de almohadilla (#).

# This is a single-line comment.

Para comentarios de varias líneas, puede usar comillas triples (simples o dobles).

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

2. Variables

Las variables en Python se utilizan para almacenar datos. Puede asignar valores a las variables utilizando el signo igual (=).

x = 5
name = "John"

Los nombres de las variables deben ser descriptivos y seguir la convención de nomenclatura de usar letras minúsculas y guiones bajos para los espacios.

user_age = 25
favorite_color = "blue"

3. Tipos de datos

El lenguaje Python viene con varios tipos de datos integrados de forma predeterminada. Algunos de los más comunes incluyen:

• Tipos de texto : str

• Tipo booleano : bool

• Tipos numéricos : int, float, complejo

• Tipos de secuencia : lista, tupla, rango

• Ninguno Tipo: Ninguno tipo

Para averiguar el tipo de datos de cualquier objeto de Python, puede usar la función type() . Por ejemplo:

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

#Output: 'str'

4. Declaraciones condicionales

Las declaraciones condicionales en Python le permiten ejecutar código solo cuando se cumplen ciertas condiciones. Las declaraciones condicionales comunes son ' si ', 'elif ' y ' si no '.

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. Bucles

Un bucle se utiliza para ejecutar repetidamente un bloque de código. Python tiene dos tipos de bucles: un bucle ' for ' y un bucle ' while '.

Echemos un vistazo a ambos:

Para bucles:

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

Mientras bucles:

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

Dentro de estos bucles, puede usar declaraciones condicionales y de control para controlar el flujo de su programa.

6. Funciones

Las funciones en Python son bloques de código que realizan tareas específicas. Puede definir una función utilizando la palabra clave ' def ', seguida del nombre de la función y los paréntesis que contienen los parámetros de entrada.

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

Para llamar a una función, use el nombre de la función seguido de paréntesis que contengan los argumentos necesarios.

function_name(arguments)

Ahora que hemos repasado los conceptos básicos de Python, pasemos a algunos temas más avanzados en la siguiente sección.

Referencia rápida para estructuras de datos de Python

A continuación, en nuestra hoja de trucos de Python, analizaremos algunas de las estructuras de datos más utilizadas en Python. Estas estructuras de datos son esenciales para administrar y organizar los datos en sus proyectos de programación.

Hay muchas estructuras de datos en Python que los desarrolladores avanzados pueden usar. Sin embargo, nos centraremos en Listas , Tuplas , Conjuntos y Diccionarios .

1. Listas

Una lista en Python es una secuencia ordenada y mutable de elementos. Para crear una lista, use corchetes y separe los elementos con comas.

Las listas de Python pueden contener una variedad de tipos de datos como cadenas, números enteros, valores booleanos, etc. Estos son algunos ejemplos de operaciones que puede realizar con las listas de Python:

• Crear una lista:

  my_list = [1, 2, 3]

• Elementos de acceso:

  my_list[0]

• Añadir un elemento:

  my_list.append(4)

2. tuplas

Una tupla es similar a una lista, pero es inmutable, lo que significa que no puede cambiar sus elementos una vez creados. Puede crear una tupla usando paréntesis y separando los elementos con comas.

Estos son algunos ejemplos de operaciones de tupla:

• Crea una tupla:

  my_tuple = (1, 2, 3)

• Elementos de acceso:

  my_tuple[0] #Output: 1

3 juegos

Un conjunto es una colección desordenada de elementos únicos. Puede crear un conjunto usando la función set() o llaves.

También puede contener una variedad de tipos de datos, siempre que sean únicos. Estos son algunos ejemplos de operaciones con conjuntos:

• Crea un conjunto:

   my_set = {1, 2, 3}

• Añadir un elemento:

  my_set.add(4)

• Eliminar un elemento:

  my_set.remove(1)

4. Diccionarios

Un diccionario es una colección desordenada de pares clave-valor, donde las claves son únicas. Puede crear un diccionario usando llaves y separando las claves y valores con dos puntos. Estos son algunos ejemplos de operaciones de diccionario:

• Crea un diccionario:

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

• Elementos de acceso:

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

• Agregue un par clave-valor:

  my_dict['key3'] = 'value3'

• Eliminar un par clave-valor:

  del my_dict['key1']

¡Recuerde practicar y explorar estas estructuras de datos en sus proyectos de Python para ser más competente en su uso! A continuación, le daremos una referencia para las tareas de E/S de archivos.

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!")

En este ejemplo, se puede crear un nuevo objeto Perro con un nombre y una raza, y tiene un método de ladrido que imprime “¡ Guau! ” cuando se llama.

2. Herencia

La herencia permite que una clase herede atributos y métodos de otra clase, lo que permite la modularidad y la reutilización del código. La clase que hereda se denomina subclase o clase derivada, mientras que la clase de la que se hereda se denomina clase base o superclase.

Para implementar la herencia, agregue el nombre de la superclase entre paréntesis después del nombre de la subclase:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

Por ejemplo, podría crear una subclase "Caniche" a partir de una clase "Perro":

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

Un objeto Poodle ahora tendría todos los atributos y métodos de la clase Dog, así como su propio método show_trick.

3. Encapsulación

La encapsulación es la práctica de envolver datos y métodos que operan sobre esos datos dentro de una sola unidad, un objeto en este caso. Esto promueve una separación clara entre la implementación interna de un objeto y su interfaz externa.

Python emplea la manipulación de nombres para lograr la encapsulación de los miembros de la clase al agregar un prefijo de subrayado doble al nombre del atributo, lo que lo hace aparentemente privado.

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

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

Aunque técnicamente aún puede acceder a estos miembros privados en Python, se desaconseja hacerlo ya que viola los principios de encapsulación.

Al comprender e implementar clases, herencia y encapsulación en sus programas de Python, puede utilizar el poder y la flexibilidad de OOP para crear código limpio, modular y reutilizable.

Para nuestra sección final de la hoja de trucos, le proporcionaremos una referencia rápida para cuatro bibliotecas populares de Python.

4 útiles bibliotecas de Python

Varias bibliotecas de Python pueden ayudarlo a realizar una variedad de tareas u obtener herramientas para varios temas como matemáticas, ciencia de datos, web scraping, etc.

En esta sección, analizaremos brevemente las siguientes bibliotecas: NumPy , Pandas , Requests y Beautiful Soup .

1. Número

NumPy es una biblioteca popular de Python para computación matemática y científica. Con su potente objeto de matriz N-dimensional, puede manejar una amplia gama de operaciones matemáticas, como:

• Funciones matemáticas básicas

• Álgebra lineal

• análisis de Fourier

• Generación de números aleatorios

Las manipulaciones de matriz eficientes de NumPy lo hacen particularmente adecuado para proyectos que requieren cálculos numéricos.

2. pandas

Pandas es una poderosa biblioteca de análisis y manipulación de datos que puede usar para trabajar con datos estructurados. También es muy popular en la comunidad de ciencia de datos debido a la amplia gama de herramientas que proporciona para el manejo de datos.

Algunas de sus características incluyen:

• Estructuras de datos como Series (1D) y DataFrame (2D)

• Limpieza y preparación de datos.

• análisis estadístico

• Funcionalidad de series de tiempo

Al utilizar Pandas, puede importar, analizar y manipular datos fácilmente en una variedad de formatos, como bases de datos CSV, Excel y SQL.

Si está interesado en Pandas, puede ver nuestro video sobre cómo volver a muestrear datos de series temporales usando Pandas para mejorar el análisis:

3. Solicitudes

La biblioteca de solicitudes simplifica el proceso de manejo de solicitudes HTTP en Python. Con esta biblioteca, puede enviar y recibir fácilmente solicitudes HTTP, como GET, POST y DELETE.

Algunas características clave incluyen:

• Manejo de redireccionamientos y seguimiento de enlaces en páginas web

• Agregar encabezados, datos de formulario y parámetros de consulta a través de bibliotecas simples de Python

• Gestión de cookies y sesiones

Al usar Solicitudes, puede interactuar rápida y eficientemente con varios servicios web y API.

4. Hermosa Sopa

Beautiful Soup es una biblioteca de Python para web scraping, que le permite extraer datos de documentos HTML y XML. Algunas de sus características clave incluyen:

• Búsqueda de etiquetas específicas o clases de CSS

• Navegación y modificación de árboles analizados

• Extracción de información relevante basada en atributos de etiquetas

Al usar Beautiful Soup junto con Requests, puede crear potentes aplicaciones de web scraping que recopilan información de una amplia gama de sitios web.

Pensamientos finales

Y eso nos lleva al final de nuestro viaje rápido por Python Lane. Esta hoja de trucos es su guía de bolsillo, su compañero de confianza para cuando necesite un recordatorio rápido de las principales funciones y comandos de Python.

Nuestra lista no es exhaustiva, pero es un comienzo sólido, una base sobre la que puede construir. Así que adelante, márquelo como favorito, imprímalo, péguelo en su pared, solo asegúrese de que esté a mano cuando esté codificando. ¡Feliz programación!