En este tutorial aprenderás a abrir un archivo, escribir en él y cerrarlo. También aprenderás a leer desde el archivo usando Python. Al final de este tutorial, deberías saber lo básico de cómo usar archivos en Python.

Manejo de archivos en Python

El manejo de archivos es una actividad importante en toda aplicación web. Los tipos de actividades que se pueden realizar en un fichero abierto están controlados por los Modos de Acceso.

Estos modos describen cómo se utilizará el archivo una vez abierto y especifican dónde se ubicará el gestor de archivo dentro del mismo. Similar a un puntero, un manejador de archivo indica dónde se deben leer o poner los datos en el archivo.

En Python, hay seis métodos o modos de acceso, que son:

1. Sólo lectura ('r'): Este modo abre los ficheros de texto sólo para lectura. El inicio del fichero es donde se encuentra el manejador. Se produce un error de E/S si el fichero no existe. Este es también el modo por defecto para abrir ficheros.
2. Lectura y escritura ('r+'): Este método abre el fichero tanto para lectura como para escritura. Si el fichero no existe, se produce un error de E/S. Si el fichero no existe, se produce un error de E/S.
3. Sólo escritura ('w'): Este modo abre el fichero sólo para escritura. Los datos de los ficheros existentes se modifican y sobrescriben. El inicio del fichero es donde se encuentra el manejador. Si el fichero no existe ya en la carpeta, se crea uno nuevo.
4. Escritura y lectura ('w+'): Este modo abre el fichero tanto para lectura como para escritura. El texto se sobrescribe y se borra de un fichero existente. El inicio del fichero es donde se encuentra el manejador.
5. Sólo añadir ('a'): Este modo permite abrir el fichero para escribir. Si el fichero aún no existe, se crea uno nuevo. El manejador se coloca al final del fichero. Los datos recién escritos se añadirán al final, a continuación de los datos escritos anteriormente.
6. Añadir y leer ('a+'): Este método permite leer y escribir en el fichero. Si el fichero no existe, se crea uno. El manejador se coloca al final del fichero. El texto recién escrito se añadirá al final, a continuación de los datos escritos anteriormente.

A continuación se muestra el código necesario para crear, escribir y leer archivos de texto utilizando los métodos de manejo de archivos o modos de acceso de Python.

Cómo crear archivos en Python

En Python, se utiliza la función open() con una de las siguientes opciones - "x" o "w" - para crear un nuevo archivo:

• "x" - Crear: este comando creará un nuevo archivo si y sólo si no existe ya un archivo con ese nombre o, de lo contrario, devolverá un error.

Ejemplo de creación de un archivo en Python utilizando el comando "x":

#crear un archivo de texto con la función de comando "x"

f = open("myfile.txt", "x")

Hemos creado un nuevo archivo de texto vacío. Pero si vuelve a intentar el código anterior - por ejemplo, si intenta crear un nuevo archivo con el mismo nombre que utilizó anteriormente (si desea reutilizar el nombre de archivo anterior) obtendrá un error notificándole que el archivo ya existe. Se verá como la imagen de abajo:

• "w" - Escribir: este comando creará un nuevo archivo de texto independientemente de que exista o no un archivo en la memoria con el nuevo nombre especificado. No devuelve un error si encuentra un archivo existente con el mismo nombre - en su lugar, sobrescribirá el archivo existente.

Ejemplo de cómo crear un archivo con el comando "w":

#crear un archivo de texto con la función de comando "w"
f = open("myfile.txt", "w")
#Este comando "w" también se puede utilizar para crear un nuevo archivo, pero a diferencia del comando "x", el comando "w" sobrescribirá cualquier archivo existente con el mismo nombre.

Con el código anterior, tanto si el archivo existe como si no existe en la memoria, puedes seguir adelante y usar ese código. Sólo tenga en cuenta que sobrescribirá el archivo si encuentra un archivo existente con el mismo nombre.

Cómo escribir en un archivo en Python

Existen dos métodos para escribir en un fichero en Python, que son:

El método write():

Esta función inserta la cadena en el archivo de texto en una sola línea.

Basándonos en el archivo que hemos creado anteriormente, la siguiente línea de código insertará la cadena en el archivo de texto creado, que es "miarchivo.txt".

file.write("Hello There\n")

El método writelines():

Esta función inserta múltiples cadenas al mismo tiempo. Se crea una lista de elementos de cadena y, a continuación, se añade cada cadena al archivo de texto.

Utilizando el archivo creado anteriormente, la siguiente línea de código insertará la cadena en el archivo de texto creado, que es "miarchivo.txt".

f.writelines(["Hello World ", "You are welcome to Fcc\n"])

Ejemplo:

# Este programa muestra cómo escribir datos en un fichero de texto.

file = open("myfile.txt","w")
L = ["This is Lagos \n","This is Python \n","This is Fcc \n"]

# Asigné ["Esto es Lagos \n", "Esto es Python \n", "Esto es Fcc \n"] a la # variable L, puedes usar cualquier letra o palabra de tu elección. 
# Las variables son contenedores en los que se pueden almacenar valores. 
# La \n se coloca para indicar el final de la línea.

file.write("Hello There \n")
file.writelines(L)
file.close()

# Usa close() para cambiar el modo de acceso a los ficheros

Cómo leer de un archivo de texto en Python

Existen tres métodos para leer datos de un archivo de texto en Python. Ellos son:

El método read():

Esta función devuelve los bytes leídos en forma de cadena. Si no se especifica n, lee el fichero completo.

Ejemplo:

f = open("myfiles.txt", "r")
#('r') abre los archivos de texto sólo para lectura print(f.read())
#El "f.read" imprime los datos del archivo de texto en el shell cuando se ejecuta.

El método readline():

Esta función lee una línea de un fichero y la devuelve como cadena. Lee como máximo n bytes para la n especificada. Pero aunque n sea mayor que la longitud de la línea, no lee más de una línea.

f = open("myfiles.txt", "r")
print(f.readline())

El método readlines():

Esta función lee todas las líneas y las devuelve como elementos de cadena en una lista, uno por cada línea.

Puede leer las dos primeras líneas llamando a readline() dos veces, leyendo las dos primeras líneas del fichero:

f = open("myfiles.txt", "r")
print(f.readline())
print(f.readline())

Cómo cerrar un archivo de texto en Python

Es una buena práctica cerrar siempre el archivo cuando haya terminado de utilizarlo.

Ejemplo de cierre de un archivo de texto:

Esta función cierra el fichero de texto cuando termina de modificarlo:

f = open("myfiles.txt", "r")
print(f.readline())
f.close()

La función close() al final del código le dice a Python que bien, he terminado con esta sección de creación o lectura - es como decir Fin.

Ejemplo:

El siguiente programa muestra más ejemplos de formas de leer y escribir datos en un fichero de texto. Cada línea de código tiene comentarios para ayudarle a entender lo que está pasando:

# Programa para mostrar varias formas de leer y # escribir datos en un archivo de texto.

file = open("myfile.txt","w")
L = ["This is Lagos \n","This is Python \n","This is Fcc \n"]

#i asignó ["Esto es Lagos \n", "Esto es Python \n", "Esto es Fcc \n"]
#a la variable L

#La \n se coloca para indicar Fin de Línea

file.write("Hello There \n")
file.writelines(L)
file.close()
# usa close() para cambiar el modo de acceso al fichero


file = open("myfile.txt","r+") 
print("Output of the Read function is ")
print(file.read())
print()

# El seek(n) lleva el manejador del fichero al enésimo
# byte desde el inicio.
file.seek(0) 

print( "The output of the Readline function is ")
print(file.readline()) 
print()

file.seek(0)

# Para mostrar la diferencia entre read y readline

print("Output of Read(12) function is ") 
print(file.read(12))
print()

file.seek(0)

print("Output of Readline(8) function is ") 
print(file.readline(8))

file.seek(0)
# función readlines
print("Output of Readlines function is ") 
print(file.readlines()) 
print()
file.close()

Esta es la salida del código anterior cuando se ejecuta en el shell. Asigné "Esto es Lagos", "Esto es Python", y "Esto es Fcc" a "L" y luego le pedí que imprimiera usando la función ''file.read''.

El código de arriba muestra que la función "readline()" está devolviendo la letra basada en el número que se le especificó, mientras que la función "readlines()" está devolviendo cada cadena asignada a "L" incluyendo el \n. Es decir, la función "readlines()" imprimirá todos los datos del archivo.

Conclusión

Esperamos que, después de pasar por este tutorial, entiendas lo que es el manejo de archivos en Python. También aprendimos los modos/métodos necesarios para crear, escribir, leer y cerrar() un archivo de texto usando algunos ejemplos básicos de Python

¡Gracias por leer!

En Pandas, a veces necesitarás eliminar columnas de un Marco de Datos por varias razones, como limpiar datos, reducir el uso de memoria o simplificar el análisis. Es por ello que en este artículo, te mostraré cómo hacerlo.

Comenzaré presentando el método .drop() que es el método principal para eliminar columnas en Pandas.

Repasaremos la sintaxis y los parámetros del método .drop(), incluyendo cómo especificar las columnas a eliminar y cómo controlar si el Marco de Datos original se modifica en su lugar o se devuelve un nuevo Marco de Datos.

A continuación, proporcionaré un ejemplo de cómo usar el método .drop() para eliminar columnas de un Marco de Datos.

Cómo usar el método .drop() en Pandas

El método .drop() es una función incorporada en Pandas que te permite eliminar una o más filas o columnas de un Marco de Datos.

Devuelve un nuevo Marco de Datos con las filas o columnas especificadas eliminadas y no modifica el Marco de Datos original en su lugar, a menos que establezcas el parámetro inplace en True.

La sintaxis para usar el método .drop() es la siguiente:

DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

Aquí, DataFrame se refiere al Marco de Datos de Pandas del cual deseas eliminar filas o columnas. Los parámetros que puedes usar con el método .drop() incluyen:

• labels: Este parámetro especifica las etiquetas o índices de las filas o columnas que se van a eliminar. Puedes pasar una sola etiqueta o índice, o una lista de etiquetas o índices.
• axis: Este parámetro especifica si se van a eliminar filas o columnas. Por defecto, está configurado en 0, lo que significa que se eliminan filas. Si deseas eliminar columnas, configúralo en 1.
• index y columns: Estos parámetros son alternativas al parámetro de etiquetas y especifican las etiquetas o índices de las filas o columnas que se van a eliminar, respectivamente.
• level: Este parámetro se utiliza para eliminar un nivel específico de un índice jerárquico.
• inplace: Este parámetro es un valor booleano que determina si modificar el DataFrame original en su lugar. Por defecto, está configurado en False.
• errors: Este parámetro especifica cómo manejar errores si la(s) etiqueta(s) o índice(s) especificado(s) no se encuentran en el DataFrame. Por defecto, está configurado en raise, lo que significa que se genera un KeyError. Otras opciones son ignore y warn, que respectivamente ignorarán o mostrarán una advertencia cuando la etiqueta o índice no se encuentre.

Cómo eliminar una sola columna de un Marco de Datos en Pandas

Vamos a empezar suavemente aprendiendo primero cómo eliminar una sola columna de un Marco de Datos antes de eliminar múltiples columnas.

Muestra del código:

#Traducción al español del código
import pandas as pd
#Creamos un marco de datos de muestra
datos = {"nombre": ['Alicia', 'Bob', 'Charlie'],
        "edad": [25, 30, 35],
        "género": ['F', 'M', 'M']
        }
df = pd.DataFrame(datos)

# Mostramos el Marco de Datos original
print("DataFrame Original:\n", df)

# Damos drop a la columna "género"
df = df.drop(columns=['género'])

# Mostramos el Marco de Datos modificado
print("DataFrame Modificado:\n", df)

Resultado:

DataFrame Original:
     nombre  edad género
0   Alicia    25      F
1      Bob    30      M
2  Charlie    35      M
DataFrame Modificado:
     nombre  edad
0   Alicia    25
1      Bob    30
2  Charlie    35

En el ejemplo anterior, primero creamos un Marco de Datos de muestra con tres columnas: nombre, edad y género. Luego utilizamos el método .drop() con el parámetro columns para eliminar la columna género. El Marco de Datos resultante solo contiene las columnas nombre y edad.

Es importante tener en cuenta que el método .drop() no modifica el Marco de Datos original en su lugar. En su lugar, devuelve un nuevo Marco de Datos con la(s) columna(s) especificada(s) eliminada(s). Si deseas modificar el Marco de Datos original, necesitas asignar el resultado del método .drop() de nuevo a la variable original, como hicimos en el ejemplo anterior.

Además del parámetro columns, el método .drop() también tiene varios otros parámetros opcionales que puedes usar para controlar cómo se eliminan las columnas.

Por ejemplo, puedes usar el parámetro inplace para modificar el Marco de Datos original en su lugar en lugar de devolver un nuevo Marco de Datos. También puedes usar el parámetro axis para eliminar columnas por índice en lugar de por nombre.

Cómo eliminar varias columnas de un Marco de Datos en Pandas

En esta sección, eliminaremos varias columnas de nuestro Marco de Datos. Este enfoque es similar a eliminar una sola columna del Marco de Datos.

Para eliminar dos o más columnas de un Marco de Datos usando el método .drop() en Pandas, podemos pasar una lista de nombres de columnas al parámetro columns del método.

import pandas as pd

# creando -otra vez- un Marco de Datos
datos = {'nombre': ['John', 'Maria', 'Pedro'],
        'edad': [30, 25, 35],
        'género': ['M', 'F', 'M'],
        'ciudad': ['Ciudad de México', 'San José', 'Buenos Aires']}
df = pd.DataFrame(datos)

# Removiendo las columnas género y ciudad
df.drop(columns=['género', 'ciudad'], inplace=True)

# Damos print en el Marco de Datos modificado
print(df)

Resultado:

 nombre  edad
0   John    30
1  Maria    25
2  Pedro    35

Explicación del código:

En este ejemplo, primero creamos un Marco de Datos de muestra con cuatro columnas: nombre, edad, género y ciudad. Luego, usamos el método .drop() para eliminar las columnas ciudad y género  pasando una lista con sus nombres al parámetro columns.

Finalmente, establecemos el parámetro inplace en True para modificar el Marco de Datos original e imprimir el Marco de Datos modificado.

Ten en cuenta que también puedes eliminar columnas por sus índices pasando una lista de índices al parámetro columns. Por ejemplo, para eliminar la segunda y tercera columnas, puedes usar:

df.drop(columns=df.columns[1:3], inplace=True)

Esto eliminará las columnas con índices 1 y 2 (que son las columnas de edad y género en este ejemplo).

Conclusión

Espero que este artículo sea un recurso útil para cualquier persona que trabaje con Marco de Datos de Pandas y necesite eliminar columnas de manera eficiente y efectiva.

¡Conéctate conmigo en Twitter y LinkedIn! También puedes suscribirte a mi canal de YouTube.

¡Feliz Codificación!

En este artículo, aprenderás cómo crear nuevos directorios (que es otro nombre para las carpetas) en Python.

También aprenderás a crear una estructura de directorios anidados.

Para trabajar con directorios en Python, primero debes incluir el módulo os en su proyecto, que le permite interactuar con su sistema operativo.

El módulo os también te permite utilizar los dos métodos que cubriremos en este artículo:

• el método os.mkdir()
• el método os.makedirs()

¡Comencemos!

Cómo crear un directorio único usando el método os.mkdir() en Python

Como se mencionó anteriormente, para trabajar con directorios en Python, primero debes incluir el módulo os.

Para hacerlo, agrega la siguiente línea de código en la parte superior de su archivo:

import os

El código anterior te permitirá utilizar el método os.mkdir() para crear un nuevo directorio único.

El método os.mkdir() acepta un argumento: la ruta del directorio.

import os

# especificamos la ruta para el directorio - nos aseguramos de hacerlo entre comillas
ruta = './proyectos'

# creamos un nuevo directorio
os.mkdir(ruta)

El código anterior creará un directorio de proyectos en el directorio de trabajo actual.

Ten en cuenta que ./ representa el directorio de trabajo actual. Puedes omitir esta parte y escribir proyectos solo cuando especifique la ruta; ¡el resultado será el mismo!

Cómo manejar excepciones al usar el método os.mkdir en Python

Pero, ¿qué sucede cuando el directorio que estás intentando crear ya existe? Se genera una excepción FileExistsError:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    os.mkdir(ruta)
FileExistsError: [Errno 17] File exists: './proyectos'

Una forma de manejar esta excepción es verificar si el archivo ya existe usando un bloque if..else:

import os

ruta = './proyectos'

# verificamos si el directorio ya existe
if not os.path.exists(ruta):
  os.mkdir(ruta)
  print("Directorio %s creado!" % ruta)
else:
  print("Directorio %s ya existe" % ruta)

En el ejemplo anterior, primero verifica si el directorio ./proyectos ya existe usando el método os.path.exists().

Si es así, obtendré el siguiente resultado en lugar de un FileExistsError:

Directorio ./proyectos ya existe

Si el archivo no existe, se crea una nueva carpeta de proyectos en el directorio de trabajo actual y obtengo el siguiente resultado:

Directorio ./proyectos creado!

Alternativamente, puedes usar un bloque try/except para manejar excepciones:

import os

ruta = './proyectos'

try:
    os.mkdir(ruta)
    print("Directorio %s creado!" % ruta)
except FileExistsError:
    print("Directorio %s ya existe" % ruta)

Si ya existe una carpeta de proyectos en el directorio de trabajo actual, obtendrá el siguiente resultado en lugar de un mensaje de error:

Directorio ./proyectos ya existe.

Cómo crear un directorio con subdirectorios usando el método os.makedirs() en Python

El método os.mkdir() no te permite crear un subdirectorio. Este método te permite crear un directorio único.

Para crear una estructura de directorios anidados (como un directorio dentro de otro directorio), utiliza el método os.makedirs().

os.makedirs() acepta un argumento: la ruta completa de la carpeta que desea crear.

import os

# define el nombre del directorio con sus subdirectorios
ruta = './proyectos/juegos/juego01'

os.makedirs(ruta)

En el ejemplo anterior, creé un directorio de proyectos en el directorio de trabajo actual.

Dentro de proyectos, creé otro directorio, juegos. Y dentro de juegos, creé otro directorio más, juego01.

Conclusión

¡Y ahí lo tienes! Ahora sabe cómo crear un directorio único y un directorio con subdirectorios en Python.

Para obtener más información sobre Python, consulte el curso Python para principiantes de freeCodeCamp.

Gracias por leer y feliz codificación.

Excel es una herramienta sorprendentemente común para el análisis de datos.

Los analistas de datos pueden modificar, examinar y mostrar grandes cantidades de datos con facilidad utilizando Excel, lo que facilita la obtención de perspectivas y la toma de decisiones acertadas.

La versatilidad de Excel permite a los usuarios llevar a cabo una variedad de actividades de análisis de datos, desde operaciones matemáticas sencillas hasta análisis estadísticos complejos. Además, Excel ofrece automatización mediante el uso de programas de terceros como Python o el lenguaje de programación integrado VBA.

Excel se utiliza con frecuencia para el análisis de datos en una variedad de industrias, incluyendo la banca, la atención médica y el marketing, gracias a su versatilidad y facilidad de uso.

Pero como analista de datos, es posible que te encuentres repitiendo tareas mundanas a diario cuando trabajas con Excel.

Estas tareas pueden incluir copiar y pegar datos, dar formato a celdas y crear gráficos, entre otras. Con el tiempo, esto puede volverse monótono y consumir mucho tiempo, dejándote con menos tiempo para concentrarte en aspectos más importantes del análisis de datos, como identificar tendencias, valores atípicos y perspectivas.

Por eso, automatizar Excel utilizando Python puede cambiar el juego, ayudándote a optimizar tus flujos de trabajo y liberar tiempo para un análisis más significativo.

En este tutorial, te mostraré algunas formas útiles de crear, actualizar y analizar hojas de cálculo de Excel utilizando programación en Python. ¡Vamos a sumergirnos!

¿Cómo fusionar dos hojas de cálculo separadas con Python?

Los analistas de datos a menudo tienen que trabajar con muchas hojas de cálculo, lo que puede volverse agobiante cuando tienes que fusionar esos archivos juntos.

El código a continuación te ayuda a fusionar dos archivos separados juntos.

import pandas as pd

# Read in the two Excel files

file1 = pd.read_excel('file1.xlsx')file2 = pd.read_excel('file2.xlsx')

# Merge the two files using the concat() method
merged_file = pd.concat([file1, file2], ignore_index=True)

# Write the merged file to a new Excel file
merged_file.to_excel('merged_file.xlsx', index=False)

En este código, primero importamos la biblioteca Pandas, que utilizaremos para leer y manipular los archivos de Excel.

Primero usamos el método read_excel() para leer tanto en file1.xlsx como en file2.xlsx.

Luego, empleamos el método concat() para unir los dos archivos juntos. El argumentoignore_index=True garantiza que los valores de índice de ambos archivos se reinicien, de modo que no terminemos con valores de índice duplicados en el archivo fusionado.

Finalmente recurrimos al método to_excel() para escribir el archivo fusionado en un nuevo archivo de Excel llamado merged_file.xlsx. También establecemos index=False para asegurarnos de que la columna de índice no se incluya en el archivo de salida.

Cómo Importar y Exportar Datos con Python

Esta tarea implica el uso de bibliotecas de Python como Pandas para leer archivos de Excel en un objeto DataFrame. Luego puedes manipularlo y analizarlo utilizando Python.

También puedes exportar datos desde Python de vuelta a un archivo de Excel utilizando las mismas bibliotecas.

import pandas as pd
# Import Excel file

df = pd.read_excel('filename.xlsx', sheet_name='Sheet1')

# Export to Excel file
df.to_excel('new_filename.xlsx', index=False)

El código dado importa la biblioteca Pandas y lee un archivo de Excel llamado "filename.xlsx" desde la Hoja1 del libro de trabajo, almacenando los datos en un marco de datos de Pandas llamado "df". Luego, el marco de datos se exporta a un nuevo archivo de Excel llamado "new_filename.xlsx" utilizando el método "to_excel". El parámetro "index=False" se utiliza para excluir la indexación de filas en el archivo de salida.

Esencialmente, el código copia el contenido del archivo de Excel original a un nuevo archivo utilizando Pandas.

Cómo Limpiar y Transformar Datos usando Python

Esta tarea implica el uso de bibliotecas de Python como Pandas para limpiar y transformar datos en Excel.

Esto puede incluir la eliminación de duplicados, filtrado de datos según criterios específicos y realización de cálculos sobre los datos.

import pandas as pd

# Remove duplicates
df = df.drop_duplicates()

# Filter data
df = df[df['column_name'] > 10]

# Perform calculations
df['new_column'] = df['column1'] + df['column2']

El fragmento de código anterior realiza tareas de limpieza y manipulación de datos en un marco de datos de Pandas llamado 'df' utilizando la biblioteca Pandas.

En primer lugar, elimina filas duplicadas de 'df' utilizando el método "drop_duplicates". En segundo lugar, filtra el marco de datos 'df' seleccionando las filas donde el valor en la columna 'column_name' es mayor que 10 y asigna el resultado filtrado a un nuevo marco de datos llamado 'data_df'.

Por último, se añade una nueva columna llamada 'new_column' a 'df' que contiene la suma de los valores de 'column1' y 'column2'.

En general, el código limpia y manipula eficazmente los datos eliminando duplicados, filtrando filas específicas y añadiendo una nueva columna calculada al marco de datos original.

Cómo Realizar Análisis de Datos con Python

Este proceso implica utilizar bibliotecas de Python como Pandas y NumPy para llevar a cabo análisis de datos en datos de Excel.

Esto podría abarcar desde calcular estadísticas resumidas, como la media y la desviación estándar, hasta crear informes personalizados mediante la agrupación de datos según criterios específicos.

import pandas as pd
import numpy as np

# Calculate summary statistics
df.describe()
# Create custom reports
df.pivot_table(values='column_name', index='category_name', columns='date')

El código utiliza las bibliotecas Pandas y NumPy y realiza tareas de análisis de datos e informes en un marco de datos de Pandas llamado "df".

En primer lugar, calcula estadísticas resumidas para los datos numéricos en el marco de datos utilizando el método "describe". Este método genera información valiosa sobre la distribución, tendencia central y dispersión de los datos.

En segundo lugar, el código utiliza el método "pivot_table" para crear informes personalizados a partir del marco de datos. Este método resume y agrega los datos en el dataframe y puede producir tablas en varios formatos.

En este código, genera un nuevo marco de datos donde los valores de 'column_name' están agrupados por las columnas 'category_name' y 'date'.

En resumen, el código realiza tareas de análisis estadístico e informes en el marco de datos para obtener información de los datos.

Cómo Crear Gráficos con Python

Esta tarea implica utilizar bibliotecas de Python como matplotlib o seaborn para crear gráficos y diagramas a partir de datos de Excel.

Puedes personalizar estos gráficos para mostrar datos específicos y darles formato para cumplir con requisitos particulares.

import pandas as pd
import matplotlib.pyplot as plt
# Create a bar chart
df.plot(kind='bar', x='category_name', y='sales')
plt.show()
# Create a scatter plot
df.plot(kind='scatter', x='column1', y='column2')plt.show()

El código importa dos bibliotecas, Pandas y matplotlib.pyplot, utilizando los alias 'pd' y 'plt', respectivamente.

Luego, se utiliza el método "plot" de Pandas para crear dos tipos de gráficos. El primer tipo de gráfico es un gráfico de barras que muestra la relación entre las columnas 'category_name' y 'sales' en el dataframe "df".

El segundo tipo de gráfico es un gráfico de dispersión que muestra la relación entre las columnas 'column1' y 'column2' en el mismo marco de datos. El código utiliza los parámetros "kind='bar'" para el gráfico de barras y "kind='scatter'" para el gráfico de dispersión para crear los respectivos gráficos.

Por último, se llama al método "show" para mostrar los gráficos en la pantalla. En resumen, el código utiliza Pandas y matplotlib para crear un gráfico de barras y un gráfico de dispersión para visualizar los datos en el marco de datos "df".

Cómo Realizar Visualización de Datos en Python

Esta tarea implica utilizar bibliotecas de Python como Plotly y Bokeh para crear visualizaciones de datos interactivas a partir de datos de Excel.

Estas visualizaciones permiten a los usuarios explorar los datos de nuevas formas, como mediante el zoom en puntos de datos específicos o el filtrado de datos según criterios específicos.

import pandas as pd
import plotly.express as px
# Create a heatmap
fig = px.imshow(df.corr())
fig.show()
# Create a line chart
fig = px.line(df, x='date', y='sales', color='category')
fig.show()

El código utiliza las bibliotecas Pandas y plotly.express para crear dos tipos de visualizaciones. Primero, se crea un gráfico de mapa de calor utilizando el método "imshow" de plotly.express que visualiza la correlación entre las columnas en el marco de datos "df".

En segundo lugar, se crea un gráfico de líneas utilizando el método "line" de plotly.express que muestra la relación entre las columnas 'date' y 'sales' mientras diferencia entre las categorías basadas en la columna 'category' del dataframe. Ambos gráficos se muestran utilizando el método "show".

Cómo Automatizar la Generación de Informes con Python

Esta tarea implica utilizar scripts de Python para automatizar el proceso de generación de informes a partir de datos de Excel.

Puedes configurar estos scripts para que se ejecuten según un horario regular, como diario o semanal. También pueden actualizarse automáticamente a medida que haya nuevos datos disponibles.

import pandas as pd
# Create daily report
df_daily = df[df['date'] == '2022-01-01']
df_daily.to_excel('daily_report.xlsx', index=False)
# Create weekly report
df_weekly = df.groupby('category').sum()
df_weekly.to_excel('weekly_report.xlsx', index=False)

El código crea un informe diario mediante la creación de un nuevo marco de datos "df_daily" que incluye solo las filas donde la columna 'date' es igual a '2022-01-01'. Esto se logra utilizando la función de indexación booleana de Pandas.

Posteriormente, se utiliza el método "to_excel" para exportar los datos filtrados a un archivo de Excel llamado "daily_report.xlsx", sin incluir la columna de índice.

A continuación, el código crea un informe semanal agrupando el marco de datos "df" por la columna 'category' y sumando los valores de todas las demás columnas. Esto se logra utilizando los métodos "groupby" y "sum" de Pandas.

El resultado se guarda en un nuevo marco de datos llamado "df_weekly". Por último, se utiliza el método "to_excel" para exportar los datos agregados a un archivo de Excel llamado "weekly_report.xlsx", sin incluir la columna de índice.

En resumen, el código crea dos informes utilizando la biblioteca Pandas. El primer informe es un informe diario que incluye solo datos de una fecha específica, y el segundo informe es un informe semanal que agrupa los datos por categoría. Ambos informes se exportan a archivos de Excel utilizando el método "to_excel".

Cómo Automatizar Tareas Repetitivas con Macros y Scripts en Python

Esta tarea implica utilizar Python para automatizar tareas repetitivas en Excel, como la entrada de datos o el formato.

Puedes hacer esto creando macros o scripts que se ejecuten automáticamente, o utilizando Python para interactuar directamente con la aplicación de Excel.

import win32com.client as win32
# Open Excel file
excel = win32.gencache.EnsureDispatch('Excel.Application')
workbook = excel.Workbooks.Open(r'filename.xlsx')
# Run macro
excel.Application.Run('macro_name')
# Save and close Excel
 fileworkbook.Save()workbook.Close()excel.Quit()

El código utiliza el módulo win32com.client para interactuar con Microsoft Excel a través de la API de Windows.

Primero, se abre una instancia de la aplicación Excel utilizando el método EnsureDispatch(), y el archivo de Excel especificado se abre utilizando el método Workbooks.Open().

A continuación, se ejecuta una macro utilizando el método Application.Run(), pasando el nombre de la macro como argumento.

Finalmente, los cambios realizados en el archivo de Excel se guardan utilizando el método Save(), el libro de trabajo se cierra utilizando el método Close(), y la aplicación de Excel se termina utilizando el método Quit().

Cómo Extraer Datos con Python

Esta tarea implica utilizar bibliotecas de Python como requests y Beautiful Soup para extraer datos de páginas web u otras fuentes e importarlos a Excel.

Luego, puedes analizar y manipular estos datos utilizando bibliotecas de Python como Pandas.

import pandas as pd
import requests
from bs4 import BeautifulSoup
# Scrape data from web page
url = 'https://www.website.com/data'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
table = soup.find('table')
df = pd.read_html(str(table))[0]
# Export to Excel file
df.to_excel('scraped_data.xlsx', index=False)

Este código utiliza la biblioteca requests para enviar una solicitud GET HTTP a la URL 'https://www.example.com'. Luego utiliza la biblioteca BeautifulSoup para analizar el contenido HTML de la respuesta en un objeto BeautifulSoup nombrado 'soup'.

Puedes luego utilizar métodos de BeautifulSoup como find_all() para extraer datos específicos del HTML:

links = []for link in soup.find_all('a'):    href = link.get('href')    links.append(href)

Este código encuentra todas las etiquetas de anclaje en el HTML y extrae el valor del atributo 'href' para cada una, agregándolos a una lista nombrada 'links'.

Cómo Utilizar Python para Integrar Excel con Otras Aplicaciones

Esta tarea implica utilizar Python para integrar Excel con otras aplicaciones, como bases de datos o servicios web.

Puedes hacer esto utilizando bibliotecas de Python como pyodbc para conectarte a bases de datos o mediante el uso de APIs para conectarte a servicios web. Esto permite una transferencia y análisis de datos sin problemas entre diferentes aplicaciones.

import pandas as pd
import pyodbc
# Connect to database
cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=server_name;DATABASE=db_name;UID=user_id;PWD=password')
# Read data from database
query = 'SELECT * FROM table_name'
df = pd.read_sql(query, cnxn)
# Export to Excel file
df.to_excel('database_data.xlsx', index=False)

El código establece una conexión a una base de datos SQL Server utilizando el método pyodbc.connect(), donde el controlador, el nombre del servidor, el nombre de la base de datos, el ID de usuario y la contraseña se proporcionan como argumentos.

Luego, se define y ejecuta una consulta SQL para recuperar datos de una tabla en la base de datos utilizando el método pd.read_sql(), donde la consulta SQL y el objeto de conexión se proporcionan como argumentos. Los datos recuperados se almacenan en un marco de datos de pandas.

Finalmente, los datos en el Marco de Datos se exportan a un archivo de Excel llamado "database_data.xlsx" utilizando el método to_excel(), excluyendo la columna de índice de la exportación al establecer el parámetro index en False.

Conclusión

Python es un lenguaje versátil que puedes utilizar para automatizar muchas tareas de Excel. También puedes utilizar diversas bibliotecas como Pandas, openpyxl, xlwings y pyautogui para manipular datos, extraer información, generar informes y automatizar tareas repetitivas.

La automatización puede ahorrar tiempo y esfuerzo, reducir errores y aumentar la productividad. La competencia en Python puede ser una habilidad valiosa para cualquier profesional que trabaje con Excel, ya sea un analista de datos o financiero. Al aprender Python, puedes llevar tu trabajo a nuevos niveles.

¡Conéctate en Twitter y LinkedIn. ¡Gracias por leer!

Python es un lenguaje versátil y ampliamente conocido por su simplicidad y legibilidad.

Debido a su naturaleza de constante evolución, nuevas versiones de este lenguaje están siendo desarrolladas y entregadas frecuentemente, cada una ofreciendo nuevas funcionalidades, mejoras y arreglos de bugs.

Como desarrollador de Python, es crucial estar al tanto de la versión que estás usando, ya que ésta determina la compatibilidad de las librerías, la sintaxis a usar y las funcionalidades disponibles.

En este artículo, estaremos explorando algunos métodos para revisar qué versión de Python está instalada en nuestro sistema. Sea que estés empezando tu camino en Python, o ya seas un desarrollador con experiencia trabajando en un proyecto, conocer tu versión de Python es el primer paso para asegurarnos una ejecución segura y la compatibilidad de nuestro programa.

A continuación estaremos revisando diferentes opciones de la línea de comandos para determinar la versión de Python. Para el final de este artículo, tendrás el conocimiento necesario para que sin ningún esfuerzo verifiques tu versión de Python de manera que puedas tomar decisiones conscientes sobre las herramientas y librerías que puedes utilizar de acuerdo al resultado.

Cómo verificar la Versión de Python en Mac

Para verificar la versión de Python en Mac, debes seguir estos pasos:

Abre la aplicación de Terminal

Puedes encontrar la terminal en Mac navegando a "Aplicaciones"  → "Utilidades" → "Terminal", o también puedes utilizar la funcionalidad de búsqueda (Cmd + Espacio) y escribir "Terminal".

Una vez tenemos la terminal abierta, nuestra interfaz está lista para recibir comandos. Con lo que podemos ejecutar el siguiente:

python --version

Este comando mostrará la versión de Python que tenemos instalada en nuestro sistema Mac. Por ejemplo, en caso de tener la versión 3.9.2 de Python instalada, veríamos una salida como la siguiente:

Python 3.9.2

El número de la versión dependerá de la forma en la que hayas instalado Python en tu sistema.

Métodos alternativos para Mac

Si el comando anterior no te ha funcionado, intenta usar el comando python3 --version . Python 3 es la última versión mayor de Python, sin embargo la versión 2 fue ampliamente usada para desarrollos antes de la salida de esta última, por lo que es común que algunos sistemas vengan con ambas versiones instaladas, así que para distinguir estas versiones se suele reservar el comando python3 para la última versión.

Para verificar la versión específica de Python 3 instalada podemos usar el siguiente comando

python3 --version

Verás una salida similar a la anterior.

Otra manera de revisar nuestra versión de Python es mediante el uso del módulo sys dentro del intérprete de Python. Para empezar ejecuta el siguiente comando en tu terminal:

python

Esto lanzará el modo intérprete de Python, te darás cuenta por el prompt que te indica que puedes ejecutar comandos del lenguaje (>>>).

Dentro del intérprete, ejecuta los siguientes comandos para revisar la versión y presiona Enter:

import sys
print(sys.version)

Esto te mostrará la información sobre la versión de Python y detalles adicionales como el número de la build y la fecha de instalación.

Luego de revisar la versión de Python, puedes salir del intérprete ejecutando el comando exit(), o también presionando Ctrl + Z seguido de Enter.

Cómo revisar la versión de Python en Windows

Para verificar la versión de Python en Windows, puedes seguir estos pasos detalladamente.

Abre la Terminal de Comandos (CMD):

• Presiona la tecla Windows
• Escribe "cmd" (sin comillas) en la barra de búsqueda.
• Abre el programa "Consola de Comandos" desde los resultados de búsqueda. Esto abrirá la ventana de Consola.

Verifica que Python está instalado:

En la ventana de Comandos, ejecuta el siguiente comando y presiona Enter:

python --version

Si Python está instalado en el sistema, te mostrará una salida como esta: "Python 3.9.2".

Si Python no está instalado, verás un mensaje de error que te avisa que el comando no se reconoce en el sistema. En este caso, primero debes instalarlo antes de proceder.

Revisa la ubicación de la instalación de Python (opcional):

Otra forma de verificar la versión de Python es revisando la ubicación del ejecutable. En la ventana de Comandos, escribe el siguiente comando y presiona Enter:

where python

Este comando te indicará dónde se encuentra el ejecutable de Python en tu sistema. Por defecto, Python es instalado en un directorio como el siguiente "C:\PythonXX", donde "XX" representa la versión.

Si el comando no arroja ningún resultado, significa que Python no está instalado en el sistema o no ha sido agregado a el PATH en las variables de entorno.

Revisa la versión de Python usando el modo intérprete:

En la terminal, escribe el siguiente comando y presiona Enter:

python

Esto abrirá el intérprete de Python, junto con información sobre la versión en las primeras líneas. Por ejemplo, "Python 3.9.2 (tags/v3.9.2:1a79785, Feb 22 2021, 12:26:58)".

Para salir del modo intérprete, escribe exit() y presiona Enter.

Revisar la versión de Python usando el IDLE:

IDLE es un entorno de desarrollo integrado que viene junto con Python.

En la terminal, ejecuta el siguiente comando:

idle

Esto lanzará el modo IDLE de Python, el cuál mostrará en las primeras líneas información sobre la versión de Python que se está utilizando. Por ejemplo, "Python 3.9.2 (tags/v3.9.2:1a79785, Feb 22 2021, 12:26:58)".

Para salir del modo IDLE, dirígete a la sección "Archivo" en el menú y elige la opción "Salir" o simplemente cierra la ventana.

Siguiendo estos pasos, puedes verificar fácilmente la versión de Python instalada en tú sistema Windows.

Cómo verificar la versión de Python en Linux

Abre una terminal:

Comienza por ejecutar una nueva instancia de la aplicación de terminal en tu sistema Linux. Normalmente la puedes encontrar en la sección de aplicaciones o usando un atajo de comando como Ctrl + Alt + T.

Una vez en la terminal, ejecuta el siguiente comando:

python --version

Esto te mostrará la versión de Python instalada en tu sistema.

Nota: Algunas distros de Linux, como Ubuntu, pueden tener las versiones 2 y 3 instaladas a la vez. En ese caso, el comando anterior sirve para verificar la versión de Python 2 instalada. Para revisar la versión 3 de Python puedes ejecutar el siguiente comando:

python3 --version

Revisa la salida:

Después de ejecutar el comando, la terminal te mostrará la versión de Python instalada en tú sistema. Normalmente se presenta en el formato "Python x.y.z", donde x, y, y z representan la versión mayor, menor y micro respectivamente.

Ejemplo de salida:

Python  3.9.2

Verifica la instalación:

Puedes verificar que la versión arrojada por el comando anterior es correcta entrando a la consola interactiva de Python en tu terminal. Para hacerlo ejecuta el siguiente comando:

python

Esto abrirá la consola de Python, donde puedes ejecutar comandos interactivamente.

Revisa la versión instalada desde la consola de Python:

En la consola de Python, puedes confirmar la versión ejecutando estos comandos:

import sys
print(sys.version)

La salida te dará detalles específicos de la versión instalada de Python, incluyendo el número, información sobre la build y detalles adicionales.

Salir de la terminal de Python

Para salir de la consola de Python puedes ejecutar el método exit() o presionar Ctrl+D.

Siguiendo estos pasos podrás consultar de manera fácil la versión de Python instalada en tu sistema Linux.

Conclusión

Siguiendo las instrucciones provistas aquí puedes verificar fácilmente la versión de Python que está utilizando tu máquina ya sea Mac, Windows o Linux. Esto te ayudará a escribir tus programas en Python con una mayor confianza.

Siempre recuerda consultar documentación relevante y/o recursos de la comunidad si encuentras algún problema siguiendo estos pasos o si estás usando versiones no estándares de Python o entornos virtuales.

Ya que Python sigue evolucionando, estar actualizado con las últimas versiones es un paso importante en tus desarrollos. Este conocimiento te permite aprovechar las nuevas funcionalidades y mejoras introducidas en nuevas versiones mientras que mantienes una compatibilidad en tus desarrollos.

¡Conecta conmigo en Twitter y en LinkedIn!. También puedes suscribirte a mi canal de YouTube.

Happy Coding!

Un diccionario en Python es un grupo de elementos desordenados, cada uno de los cuales tiene un conjunto único de claves y valores.

Se puede usar como clave cualquier tipo de dato inmutable, como una cadena, un número o una tupla. Sirve como identificador único de valor en el diccionario. El valor es repetible y aplicable a todo tipo de datos.

En Python, los diccionarios se indican con llaves { }, y cada par clave-valor está delimitado por dos puntos :. Una coma separa cada par clave-valor. A continuación se muestra un ejemplo de un diccionario básico:

mi_diccionario = {"piña": 12, "manzana": 30, "naranja": 5, "palta":7}

En este ejemplo, "piña", "manzana", "naranja" y "palta" son las claves y 12, 30, 5 y 7 son los valores correspondientes.

Veremos como podemos agregar un único par clave-valor a un diccionario usando el método update(), y finalmente aprenderemos a usar el constructor dict().

¿Cómo agregar un único par clave-valor a un diccionario?

Para agregar un único par clave-valor a un diccionario en Python, podemos usar el siguiente código como ejemplo:

my_diccionario = {'a': 1, 'b': 2}
my_diccionario['c'] = 3

El código anterior creará un diccionario my_diccionario con dos pares clave-valor. Luego agregamos un nuevo par clave-valor c:3 al diccionario simplemente asignando el valor 3 a la clave c. Después de ejecutar el código, el diccionario my_diccionario ahora contendrá el par clave-valor c:3.

Podemos verificar esto imprimiendo el diccionario:

print(my_diccionario)

Obtenemos como salida:

{'a': 1, 'b': 2, 'c': 3}

Si ya existe una clave c en el diccionario, el valor se actualizará a 3.

¿Cómo agregar múltiples pares clave-valor con el método update()?

Se pueden agregar de manera simultánea varios pares clave-valor a un diccionario usando método update(). Este método inserta nuevas entradas en el diccionario original desde otro diccionario o un iterable de pares clave-valor como entrada. El valor de una clave existente en el diccionario original se actualizará con el nuevo valor.

Ahora veamos un ejemplo usando el método update() para agregar múltiples entradas a un diccionario:

my_diccionario = {'a': 1, 'b': 2}
nuevos_datos = {'c': 3, 'd': 4}

my_diccionario.update(nuevos_datos)

print(my_diccionario)

Salida:

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Otra cosa divertida de este método es que podemos usarupdate() con un iterable de pares clave-valor, como una lista de tuplas. Veamos esto en acción:

my_diccionario = {'a': 1, 'b': 2}
nuevos_datos = [('c', 3), ('d', 4)]

my_diccionario.update(nuevos_datos)

print(my_diccionario)

La salida será la misma obtenida en el ejemplo anterior:

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

¿Cómo actualizar un diccionario usando el constructor dict()?

En Python, un diccionario se puede actualizar o crear desde cero utilizando el constructor dict(). Al pasar un diccionario que contiene el nuevo par clave-valor como argumento al constructor dict(), podemos agregar un único par clave-valor a un diccionario existente.

Ejemplo:

my_diccionario = {'a': 1, 'b': 2, 'c': 3}
nuevo_diccionario = dict(my_diccionario, d=4)

print(nuevo_diccionario)

Salida:

{'a': 1, 'b': 2, 'c': 3, 'd': 4}	

En este ejemplo, contamos con el diccionario my_diccionario con 3 pares clave-valor. Luego creamos un nuevo diccionario llamado nuevo_diccionario usando el constructor dict() y agregamos el par clave-valor d:4.

Tenga en cuenta que también se puede crear un nuevo diccionario utilizando el constructor dict() a partir de una lista de pares clave-valor, donde cada par está representado por una tupla.

mi_lista = [('a', 1), ('b', 2), ('c', 3)]
mi_diccionario = dict(mi_lista)

print(mi_diccionario)

Salida:

{'a': 1, 'b': 2, 'c': 3}

Conclusión

En Python los diccionarios se usan con frecuencia para almacenar datos y proporcionar acceso rápido a ellos mediante una clave única. Resultan útiles cuando se trabajan con listas o tuplas donde necesitamos acceder a datos utilizando un identificador único en lugar de una secuencia.

Conecta conmigo en Twitter y/o Linkedln. Puedes suscribirte también a mi canal en YouTube.

¡Feliz codificación!

Pandas es una biblioteca de código abierto ampliamente usando en Python para la manipulación y el análisis de datos. Proporciona una variedad estructuras de datos y funciones para trabajar con datos, una de las cuales es DataFrame.

Los DataFrames son una herramienta poderosa para almacenar y analizar grandes cantidades de datos, pero puede resultar complicado trabajar con ellos si no se guardan o se exportan correctamente.

Es una práctica común en el análisis de datos exportar datos de Pandas, DataFrames a archivos CSV porque puede ayudar a ahorrar tiempo y recursos. Debido a su portabilidad y capacidad de ser leídos fácilmente por números aplicaciones, los archivos CSV son un formato de archivo común para almacenar y distribuir datos tabulares.

Independientemente, si eres analista de datos novato o experto, este artículo lo guiará a través del proceso de guardar DataFrames de Pandas en archivos CSV y le brindará consejos útiles sobre como hacerlo.

¿Como guardar DataFrames de Pandas usando el método .to_csv()?

El método .to_csv() es una función incorporada en Pandas que le permite guardar un DataFrame de Pandas como un archivo CSV. Esté método exporta el DataFrame a un archivo de valores separados por comas (CSV), que es un formato simple y ampliamente usando para almacenar datos tabulares.

La sintaxis para usar el método .to_csv() es la siguiente:

DataFrame.to_csv(nombre_archivo, sep=',', index=False, encoding='utf-8')

Aquí, DataFrame se refiere al DataFrame de Pandas que queremos exportar y nombre_archivo se refiere al nombre de archivo en el que se desea guardar sus datos.

El parámetro sep especifica el separador que debe usar para separar valores en el archivo CSV. De forma predeterminada es configurado en , para valores separados por comas. También podemos configurarlo con un separador diferente como /t para valores separados por tabulaciones.

El parámetro index es un valor booleano que determina si se incluye el índice del DataFrame en el archivo CSV. De forma predeterminada está configurado en False, lo que significa que el índice no está incluido.

El parámetro encoding especifica la codificación de caracteres que se utilizara para el archivo CSV. De forma predeterminada está configurado en utf-8, que es una codificación estándar para archivos de texto.

Ejemplo de código

import pandas as pd

# Creamos un simple DataFrame
Biodatos = {'Nombre': ['John', 'Emily', 'Mike', 'Lisa'],
        'Edad': [28, 23, 35, 31],
        'Genero': ['M', 'F', 'M', 'F']
        }
df = pd.DataFrame(Biodatos)

# Guardarmos el DataFrame en un archivo CSV
df.to_csv('Biodatos.csv', index=False)

Explicación

Analicemos que hace cada parte del código:

• import pandas as pd: Esto importa la biblioteca Pandas y le asigna el alias pd, que es una convención de uso común.
• Biodatos = {'Name': ['John', 'Emily', 'Mike', 'Lisa'], 'Age': [28, 23, 35, 31], 'Gender': ['M', 'F', 'M', 'F']}: Esto crea un diccionario en Python con los datos que queremos almacenar en el DataFrame. Cada clave representa una columna en el DataFrame y su valor correspondiente es una lista de valores para esa columna.
• df = pd.DataFrame(Biodatos): Esto crea DataFrame en Pandas a partir del diccionario Biodatos.
• df.to_csv('Biodata.csv', index=False): esto guarda el DataFrame en un archivo CSV llamado Biodatos.csv.

Otras maneras de guardar DataFrames de Pandas

Existen varios métodos alternativos a .to_csv() para guardar DataFrames de Pandas en varios formatos de archivos que incluyen:

1. to_excel(): Este método se usa para guardar DataFrames a un archivo Excel.
2. to_json(): Este método se usa para guardar DataFrames a un archivo JSON.
3. to_hdf(): Este método se utiliza para guardar un DataFrame como un archivo HDF5, que es un formato de datos jerárquico comúnmente utilizado en informática científica.
4. to_sql(): Este método se usa para guardar DataFrames a un archivo SQL.
5. to_pickle(): Este método se utiliza para guardar un DataFrame como un objeto seleccionado, que es una representación serializada del DataFrame.

Estos métodos alternativos brindan flexibilidad para elegir el formato de archivo que mejor se adapte a su caso de uso y pueden ser particularmente útiles para el análisis e intercambio de datos avanzados.

Conclusión

¡Gracias por leer! Espero que ahora entiendas cómo puedes convertir fácilmente tus DataFrames de Pandas exportándolos a un archivo CSV usando el método incorporado to_csv().

Conecta conmigo en Twitter o Linkdln. Puedes suscribirte a mi canal en YouTube.

¡Feliz codificación!

En Python y en la mayoría de los lenguajes de programación, las variables declaradas fuera de una función se conocen como variables globales. Se puede acceder a estas variables tanto dentro como fuera de una función, ya que tienen un alcance global.

Un ejemplo de una variable global:

x = 10 

def mostrarX():
    print("El valor de x es", x)
    
mostrarX()
# El valor de x es 10

La variable x en el código anterior se declaró fuera de una función: x = 10. Utilizando la función mostrarX(), aún pudimos acceder a x porque se declaró en un alcance global.

Veamos otro ejemplo que muestra lo que pasa cuando declaramos una variable dentro de una función y tratamos de acceder a ella en otro lugar.

def X():
    x = 10 

X()

def mostrarX():
    print("El valor de x es", x)
    
mostrarX()
NameError: name 'x' is not defined

En el ejemplo anterior, declaramos x dentro de una función e intentamos acceder a ella en otra función. Esto resultó en un NameError porque x no se definió globalmente.

Las variables definidas dentro de las funciones se llaman variables locales. Su valor sólo se puede utilizar dentro de la función en la que se declaran.

Se puede cambiar el alcance de una variable local utilizando la palabra clave global, lo cual discutiremos en la próxima sección.

¿Para qué se usa la palabra clave global en Python?

La palabra clave global se utiliza principalmente por dos razones:

1. Para modificar el valor de una variable global.
2. Para hacer que una variable local sea accesible fuera del alcance local.

Echemos un vistazo a algunos ejemplos de cada uno de estos escenarios para que puedas comprenderlo mejor.

Ejemplo #1 - Modificando una variable global usando la palabra clave global

En la última sección en la que declaramos una variable global, no intentamos cambiar el valor de la variable. Todo lo que hicimos fue acceder y mostrar su valor en una función.

Intentemos cambiar el valor de una variable global y veamos qué pasa:

x = 10 

def mostrarX():
    x = x + 2
    print("El valor de x es", x)
    
mostrarX()
# local variable 'x' referenced before assignment

Como se puede ver arriba, cuando intentamos sumar 2 al valor de x, obtuvimos un error. Esto se debe a que solo podemos acceder pero no modificar x.

Para solucionar eso, utilizamos la variable global de esta forma:

x = 10 

def mostrarX():
    global x
    x = x + 2
    print("El valor de x es", x)
    
showX()
# El valor de x es 12

Al usar la palabra clave global, pudimos modificar el valor de x y sumarle 2.

Ejemplo #2 - Cómo hacer que una variable local sea accesible fuera de su alcance local usando la palabra clave global

Cuando creamos una variable dentro de una función, no fue posible utilizar su valor en otra función porque el compilador no reconoció la variable.

Así es cómo podemos solucionarlo utilizando la palabra clave global:

def X():
    global x
    x = 10 
    
X()
    
def mostrarX():
    print("El valor de x es ", x)
    
mostrarX()
# El valor de x es 10

Para hacer posible que x sea accesible fuera de su alcance local, lo declaramos utilizando la palabra clave global: global x. Después, le asignamos un valor a x. Luego, llamamos a la función que utilizamos para declararla: X().

Cuando llamamos a la función mostrarX(), que imprime el valor de x declarado en la función X(), no obtuvimos un error porque x tiene un alcance global.

Resumen

En este artículo, hablamos de las variables globales y locales en Python.

Los ejemplos mostraron cómo declarar tanto variables globales como locales.

También discutimos la palabra clave global, que te permite modificar el valor de una variable global o hacer que una variable local sea accesible fuera de su alcance.

¡Feliz programación!

Todos somos diferentes, pero creo que casi todos disfrutamos de escuchar música.

Si deseas mantener una versión local de los archivos de audio que escuchas con frecuencia, vas a necesitar descargarlos. A veces, también querrás recortar una parte de este archivo de audio en lugar de tener solo la versión completa disponible.

Puedes desarrollar un script en Python para hacer exactamente estas cosas. También puedes ampliarlo con funcionalidades adicionales si lo deseas. Y te mostraré cómo hacerlo en este tutorial.

Una nota sobre los derechos de autor

Si has utilizado Internet antes, es probable que seas consciente de que los problemas de derechos de autor pueden provocar mucha controversia, tanto en aquellos que defienden la gratuidad del contenido como en los que no.

La propia biblioteca que utilizaremos ha tenido sus propios problemas de derechos de autor.

Afortunadamente, tenemos material libre de derechos de autor disponible para que lo disfrutemos y utilicemos en nuestros programas. En este tutorial, usaremos el cuarto movimiento de la Novena Sinfonía de Beethoven, que es libre de copyright. Esta guía asume que usarás los siguientes métodos para descargar material libre de derechos de autor. ¡No uses esta información para infringir ningún derecho de autor!

Lo que vamos a hacer en este tutorial

Primero, vamos a instalar la dependencia básica, FFMPEG. Luego, instalaremos la biblioteca youtube-dl (que también funciona con Vimeo y muchas otras plataformas) para descargar audio desde una URL de YouTube y utilizarlo en el código de Python.

A continuación, vamos a descargar la librería pydub para recortar archivos de audio e implementaremos esta funcionalidad en nuestro código.

Por último, vamos a crear una interfaz de usuario amigable para que podamos reutilizar este script más adelante sin necesidad de editar el código.

Todo esto se va a ejecutar dentro de una función principal main() para que podamos separar la funcionalidad, la implementación y el uso.

Cómo instalar el paquete FFMPEG

Este paquete es fundamental en muchos programas multimedia (y en todos los de código abierto que he usado hasta ahora). Lo necesitaremos para ambas bibliotecas de Python que instalaremos muy pronto.

Cómo instalar en Linux

Si te encuentras en una máquina que usa Debian de base (como Ubuntu o Kali), este es el comando para instalar FFMPEG:

sudo apt-get install ffmpeg

Si estás usando otra distribución, las instrucciones están acá.

Cómo instalar en Windows

Primero, hay que instalar el gestor de paquetes Chocolatey. Las instrucciones están acá, te espero.

Después de instalarlo correctamente, descarga el paquete desde una instancia de Powershell con permisos de administrador.

choco install ffmpeg

Cómo instalar en Mac

Si todavía no lo tienes, instala homebrew. Luego, en la terminal:

brew install ffmpeg

Cómo descargar audio de URLs de YouTube

Primero, descarga el paquete youtube-dl de pip. Es uno de los más guardados en GitHub.

pip install youtube-dl

Vamos a importar este módulo y luego declarar una función que va a descargar el audio en formato mp3 con una calidad razonable desde una URL de YouTube.

import youtube_dl # cliente para muchos portales de multimedia

# descarga yt_url al mismo directorio desde donde corre el script
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)

main()

El método .download() va a descargar gradualmente el flujo de audio como un archivo .webm. Una vez que detecta que el archivo completo está disponible, utilizará ffmpeg para convertirlo en un archivo de audio MP3. Esto significa que si ocurre algo, como que la conexión a Internet se interrumpa cuando el archivo esté al 90% descargado, la descarga se reanudará en el 90% en lugar de comenzar desde el principio, lo cual es bastante útil. Ten en cuenta que si ya tienes el archivo mp3 descargado, la descarga se reiniciará y sobrescribirá el archivo.

Ejecuta tu script de Python. La descarga de audio de esta interpretación del Cuarto Movimiento de la Novena Sinfonía de Beethoven debería generar un archivo MP3 de aproximadamente 33 MB con el título del video disponible localmente. Es posible que la descarga sea un poco lenta, así que aprovecha para hacerte una taza de té.

Como puedes ver, es posible pasar parámetros opcionales a youtube-dl (que también estarán disponibles como un programa independiente de línea de comandos fuera del script). Una de sus capacidades es descargar una serie de videos desde una URL de lista de reproducción. Si estás más interesado, puedes consultar su documentación. Mantendré el uso más sencillo a lo largo de este tutorial.

Cómo recortar el archivo descargado

Con el archivo descargado, ahora vamos a dividirlo localmente de forma arbitraria (puede que hayas considerado si es posible simplemente descargar un fragmento de YouTube. Todos los métodos fiables que encontré básicamente se reducirán a descargarlo completo y luego editarlo localmente). Para esto, utilizaremos la biblioteca pydub. Puedes instalarla de la siguiente manera:

pip install pydub

Esta es una biblioteca bastante útil que te permite manipular por completo el audio, reducir o aumentar el volumen en ciertos intervalos, repetir clips, y más. Por ahora, solo estamos interesados en recortar.

Para recortar nuestro archivo descargado, tendremos que obtener el nombre de archivo de nuestro MP3 recién descargado, convertir los puntos de inicio y final de nuestro intervalo de audio deseado de 'horas:minutos:segundos' a milisegundos, y finalmente utilizar pydub para dividir nuestro archivo de audio.

Cómo obtener el nombre del archivo

Lamentablemente, el método .download() no nos va a devolver el nombre de archivo generado, al cual tampoco tendremos acceso, ya que solo estamos pasando la URL como parámetro. Pero tenemos Python, y es una herramienta fantástica.

Sabemos que estamos buscando un archivo .mp3 que se generó justo antes de nuestra operación de búsqueda de nombre de archivo (Python es monohilo y va a ejecutar el código de forma síncrona por defecto). Obtendremos el nombre de nuestro archivo más reciente en el directorio del script, y eso será nuestro archivo.

Podemos realizar esta operación listando todos los archivos .mp3 en el directorio local, recopilando sus marcas de tiempo como números enteros (lo que significa el tiempo en milisegundos contados desde una fecha en el pasado determinada; esto significa que cuanto mayor sea el valor, más en el tiempo se creó el archivo) y obteniendo el archivo con el valor más alto.

Para esto, necesitaremos los módulos glob para navegar por el directorio y os para obtener información de la marca de tiempo, ambos disponibles de forma nativa.

import glob
import os

def newest_mp3_filename():
	# lista todos los mp3s en el directorio local
    list_of_mp3s = glob.glob('./*.mp3')
    # devuelve aquel con mayor valor de timestamp (último creado)
    return max(list_of_mp3s, key = os.path.getctime)

Cómo obtener HH:MM:SS en milisegundos

Una vez que cortemos nuestro archivo, pydub esperará intervalos de tiempo expresados en milisegundos. Pero para nosotros, los humanos, calcular el momento exacto en milisegundos cada vez que queramos recortar un video sería bastante molesto, así que le pediremos respetuosamente a la computadora que lo haga por nosotros.

Nuestra entrada será una cadena en el formato HH:MM:SS. Esto funciona bien si queremos recortar un video de más de una hora, pero la mayor parte del tiempo solo querremos obtener el intervalo de un minuto:segundo a otro. Así que también vamos a tener esto en cuenta.

Un milisegundo es 1/1000 de segundo, un minuto tiene 60 segundos y una hora tiene 60 minutos. Entonces, debemos obtener el valor para las horas, luego para los minutos, luego para los segundos, realizar la conversión a milisegundos en cada uno y luego sumar las partes para obtener el resultado.

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # condicional en formato HH:MM:SS
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # formato MM:SS
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # marca de tiempo en milisegundos
    return hours + minutes + seconds

Cómo obtener el audio recortado

Ahora leeremos nuestro archivo MP3 como un objeto de pydub y cortaremos el intervalo deseado. La sintaxis es exactamente la misma que las operaciones de corte en cadenas y arreglos, pero en lugar de un índice para un elemento, usaremos milisegundos para momentos específicos dentro del audio.

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
    	# levanta una excepción para detener el programa
        raise Exception("No se encontró ningún MP3 en el directorio local.")
    # lee el mp3 como un objeto de Pydub
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Comenzando proceso de recorte para el archivo ", mp3_filename, ".\n")
    print("Iniciando en ", initial, "...")
    if (len(final) > 0):
        print("...hasta ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # t0 hasta t1
    return sound[t0:] # t0 hasta el final

Cómo unirlo todo

Alle Menschen werden Brüder,
Wo dein sanfter Flügel weilt.
-- Friedrich Schiller

En caso de que te lo estuvieras preguntando, el fragmento anterior se traduce como "Todos los hombres se convertirán en hermanos, dondequiera que tus suaves alas revuelen". Es un fragmento de "Oda a la alegría", un poema de Friedrich Schiller que forma la mayor parte de la letra de las partes corales del Cuarto Movimiento.

Este es el fragmento más famoso del movimiento más famoso de la sinfonía más famosa de Beethoven. Sea quien seas, cuando y cómo hayas crecido, es muy probable que reconozcas esta pieza.

Ahora vamos a poner todo lo que hemos hecho juntos. Descargaremos el audio de YouTube, cortaremos el coro de la "Oda a la Alegría" (desde el minuto 9:51 hasta el minuto 14:04) y lo guardaremos como <nombre> - TRIM.mp3.

Si has seguido el tutorial correctamente, actualiza tu función main() para ejecutar cada paso de manera que al final tengas el MP3 completo y su versión recortada como archivos disponibles en el directorio desde el que ejecutes el script. No olvides ejecutar la función main() al final del script.

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)
    initial = "9:51"
    final = "14:04"
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("El proceso finalizó con éxito. Guardando archivo recortado como ", trimmed_filename)
    # guarda archivo con nuevo nombre
    trimmed_file.export(trimmed_filename, format="mp3")

Cómo agregar interacción desde la línea de comandos

Para esta parte, necesitaremos el módulo sys de Python, que lee la entrada pasada desde la línea de comandos, entre otras cosas. Simplemente actualizaremos las variables en la función main() para leer la entrada desde la línea de comandos en lugar de los datos actualmente codificados en el script.

ARGV lee la entrada secuencialmente como un array, comenzando desde el índice 1 (el 0 representa el nombre del script de Python en ejecución). Lo configuraremos para que lea una URL como el primer argumento y, opcionalmente, instantes de inicio y finalización para el recorte.

import sys

def main():
    if (not len(sys.argv) > 1):
        print("Por favor inserta una URL soportada por youtube-dl como tu primer argumento.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # terminar si no hay argumentos
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("El proceso finalizó con éxito. Guardando archivo como ", trimmed_filename)
    # guarda archivo con nuevo nombre
    trimmed_file.export(trimmed_filename, format="mp3")

Ejecuta el archivo para probarlo. Recuerda actualizar el nombre del script con el mismo nombre que tienes en tu máquina.

python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04

Script final

Esta es la versión final con todo integrado. Ten en cuenta que los comentarios sobre los módulos están relacionados solo con para qué los estamos utilizando y que la función main() se está invocando en la última línea.

import youtube_dl # cliente para muchos portales de multimedia
import glob # operaciones de directorio
import os # interfaz para información provista por el sistema operativo
import sys # interfaz para línea de comandos
from pydub import AudioSegment # sólo operaciones de audio

def newest_mp3_filename():
    # lista todos los mp3 en el directorio local
    list_of_mp3s = glob.glob('./*.mp3')
    # devuelve último mp3 creado
    return max(list_of_mp3s, key = os.path.getctime)

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # condicional en formato HH:MM:SS 
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # formato MM:SS 
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # marca de tiempo en milisegundos
    return hours + minutes + seconds

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
        # levanta una excepción para interrumpir programa
        raise Exception("No MP3 found in local directory.")
    # lee mp3 como objeto de Pydub
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Comenzando proceso de recorte para ", mp3_filename, ".\n")
    print("Comenzando desde ", initial, "...")
    if (len(final) > 0):
        print("...hasta ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # t0 hasta t1
    return sound[t0:] # t0 hasta el final



# descarga yt_url al mismo directorio donde corre el script
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    if (not len(sys.argv) > 1):
        print("Por favor inserta una URL soportada por youtube-dl como tu primer argumento.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # terminar si no hay argumentos
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("El proceso finalizó con éxito. Descargando archivo como ", trimmed_filename)
    # descarga archivo con nuevo nombre
    trimmed_file.export(trimmed_filename, format="mp3")

# ejemplo
# python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04
main()

Ejercicios sugeridos

1. Detectar si la primera entrada es una URL válida o no. Consulta las expresiones regulares en Python si no sabes por dónde empezar.
2. Detectar si las segundas y terceras entradas tienen un formato válido (horas:minutos:segundos O minutos:segundos).
3. Agregar una opción para cambiar el nombre del archivo MP3 directamente desde la línea de comandos. Recuerda que los argumentos de ARGV se ejecutan en orden.
4. Refactorizar este script para interactuar con su funcionalidad utilizando una interfaz gráfica de usuario (GUI). Puede ser una aplicación web o local, tu elección.

Consideraciones finales

Espero que disfrutes de este proyecto y le des un buen uso.

Recuerda que ganarse la vida como artista puede ser bastante difícil, especialmente para la mayoría que no cuenta con el respaldo de una empresa. No olvides apoyar a los artistas cuyo trabajo disfrutas siempre que puedas y también recuerda apoyar el software de código abierto.

En este tutorial, aprenderás cómo abrir un archivo, escribir en él y cerrarlo. También aprenderás cómo leer desde el archivo usando Python.

Al final de este tutorial, deberías conocer los conceptos básicos de cómo usar archivos en Python.

Manejo de archivos en Python

Manipular archivos es una actividad importante en cada aplicación web. Los tipos de actividades que se pueden realizar en el archivo abierto están controlados por los Modos de Acceso. Estos describen cómo se utilizará el archivo después de haber sido abierto.

Estos Modos de Acceso también especifican dónde debe ubicarse el controlador de archivo dentro del archivo. Similar a un puntero, un controlador de archivo indica dónde se deben leer o colocar los datos en el archivo.

En Python, hay seis métodos o modos de acceso, que son:

1. Solo lectura (‘r’): Este modo abre los archivos de texto solo para lectura. El inicio del archivo es donde se encuentra el controlador. Si el archivo no existe, se produce un error de I/O. Este es el modo predeterminado para abrir archivos.
2. Leer y escribir (‘r+’): Este método abre el archivo tanto para lectura como para escritura. El inicio del archivo es donde se encuentra el controlador. Si el archivo no existe, se produce un error de I/O.
3. Solo escritura (‘w’): Este modo abre el archivo solo para escritura. Los datos en los archivos existentes se modifican y sobrescriben. El inicio del archivo es donde se encuentra el controlador. Si el archivo aún no existe en la carpeta, se crea uno nuevo.
4. Escribir y leer (‘w+’): Este modo abre el archivo tanto para lectura como para escritura. El texto se sobrescribe y se elimina de un archivo existente. El inicio del archivo es donde se encuentra el controlador.
5. Solo agregar (‘a’): Este modo permite abrir el archivo para escritura. Si el archivo aún no existe, se crea uno nuevo. El controlador se establece al final del archivo. Los datos recién escritos se agregarán al final, siguiendo los datos escritos anteriormente.
6. Agregar y leer (‘a+’): Usando este método, puedes leer y escribir en el archivo. Si el archivo aún no existe, se crea uno nuevo. El controlador se establece al final del archivo. El texto recién escrito se agregará al final, siguiendo los datos escritos anteriormente.

A continuación se muestra el código necesario para crear, escribir y leer archivos de texto utilizando los métodos o modos de acceso de manejo de archivos de Python.

Cómo crear archivos en Python

En Python, se utiliza la función open() con una de las siguientes opciones:  – "x" o "w" – para crear un archivo nuevo:

• "x" – Crear: este comando creará un archivo nuevo solo si no existe ningún archivo con ese nombre, de lo contrario, devolverá un error.

Ejemplo de cómo crear un archivo en Python usando el comando "x":

#crear un archivo de texto con la función de comando "x"

f = open("myfile.txt", "x")

¡Hemos creado un nuevo archivo de texto vacío! Pero si vuelves a intentar el código anterior, por ejemplo, si intentas crear un nuevo archivo con el mismo nombre que usaste anteriormente (si deseas reutilizar el nombre de archivo anterior), recibirás un error que te notificará que el archivo ya existe. Se verá como la imagen a continuación:

• "w" – Escribir: Este comando creará un nuevo archivo de texto, sin importar si hay un archivo en la memoria con el nuevo nombre especificado. No devuelve un error si encuentra un archivo existente con el mismo nombre, en su lugar, sobrescribirá el archivo existente.

Ejemplo de como crear un archivo con el comando "w":

#creando un un texto con el el comando "w"

f = open("myfile.txt", "w")

#Este comando "w" también se puede utilizar para crear un archivo nuevo, pero a diferencia del comando "x", el comando "w" sobrescribirá cualquier archivo existente que se encuentre con el mismo nombre de archivo.

Con el código anterior, ya sea que el archivo exista o no exista en la memoria, aún puede continuar y usar ese código. Solo tenga en cuenta que sobrescribirá el archivo si encuentra un archivo existente con el mismo nombre.

Cómo escribir en un archivo en Python

Existen dos métodos para escribir en un archivo en Python, que son:

El método write():

Esta función inserta la cadena en el archivo de texto en una sola línea.

Según el archivo que hemos creado anteriormente, la siguiente línea de código insertará la cadena en el archivo de texto creado, que es "myfile.txt."

file.write("Hello There\n")

El método writelines():

Esta función inserta varias cadenas al mismo tiempo. Se crea una lista de elementos de cadena y luego cada cadena se agrega al archivo de texto.

Usando el archivo creado anteriormente arriba, la siguiente línea de código insertará la cadena en el archivo de texto creado, que es "myfile.txt."

f.writelines(["Hello World ", "You are welcome to Fcc\n"])

Ejemplo:

#Este programa muestra cómo escribir datos en un archivo de texto.This 

file = open("myfile.txt","w")
L = ["This is Lagos \n","This is Python \n","This is Fcc \n"]

#Asignando ["This is Lagos \n","This is Python \n","This is Fcc \n"]  a 
#la variable L, se puede usar cualquier letra o palabra de tu elección.
#Las variables son contenedores en los que se pueden almacenar valores.
#El \n se coloca para indicar el final de la línea.

file.write("Hello There \n")
file.writelines(L)
file.close()

# Usar close() para cambiar los modos de acceso a archivos

Cómo leer desde un archivo de texto en Python

Hay tres métodos para leer datos de un archivo de texto en Python. Ellos son:

El método read():

Esta función devuelve los bytes leídos como una cadena. Si no se especifica ninguna n, lee el archivo completo.
Ejemplo:

f = open("myfiles.txt", "r")
#('r’) opens the text files for reading only
print(f.read())
#El "f.read" imprime los datos en el archivo de texto en la consola cuando se ejecuta.

El método readline():

Esta función lee una línea de un archivo y la devuelve como una cadena. Lee como máximo n bytes para el n especificado. Pero incluso si n es mayor que la longitud de la línea, no lee más de una línea.

f = open("myfiles.txt", "r")
print(f.readline())

El método readlines():

Esta función lee todas las líneas y las devuelve como elementos de cadena en una lista, uno para cada línea.

Puedes leer las dos primeras líneas llamando  readline()  dos veces, leyendo las dos primeras líneas del archivo:

f = open("myfiles.txt", "r")
print(f.readline())
print(f.readline())

Cómo cerrar un archivo de texto en Python

Es una buena práctica cerrar siempre el archivo cuando se ha terminado con él.

Ejemplo para cerrar un archivo de texto:

Esta función cierra el archivo de texto cuando haya terminado de modificarlo:

f = open("myfiles.txt", "r")
print(f.readline())
f.close()

La función close()  al final del código le dice a Python, ya terminé con esta sección de creación o lectura, es como decir Fin.

Ejemplo:

El siguiente programa muestra más ejemplos de formas de leer y escribir datos en un archivo de texto. Cada línea de código tiene comentarios para ayudar a comprender lo que está sucediendo:

# Programa para mostrar varias formas de leer y
# escribir datos en un archivo de texto.

file = open("myfile.txt","w")
L = ["This is Lagos \n","This is Python \n","This is Fcc \n"]

# Asignar ["This is Lagos \n","This is Python \n","This is Fcc \n"]
# a la variable L
  
#El \n se coloca para indicar fin de línea

file.write("Hello There \n")
file.writelines(L)
file.close()
# Usar close() para cambiar los modos de acceso a archivos



file = open("myfile.txt","r+") 
print("Output of the Read function is ")
print(file.read())
print()

# La función seek(n) Mueve el puntero hacia el byte indicado,
# el byte desde el principio.
file.seek(0) 
  
print( "The output of the Readline function is ")
print(file.readline()) 
print()
  
file.seek(0)
  
# Mostrar la diferencia entre lectura y línea de lectura

print("Output of Read(12) function is ") 
print(file.read(12))
print()

file.seek(0)
  
print("Output of Readline(8) function is ") 
print(file.readline(8))
  
file.seek(0)
# Función de lectura de líneas
print("Output of Readlines function is ") 
print(file.readlines()) 
print()
file.close()

Este es el resultado del código anterior cuando se ejecuta en la consola. Se asignó  "This is Lagos", "This is Python", y "This is Fcc" a "L" y luego se pidió que imprima, usando la función ''file.read''.

El código anterior muestra que la función "readline()" devuelve la letra según el número especificado, mientras que la función "readlines()" devuelve cada cadena asignada a "L", incluido \n. Es decir, la función "readlines()" imprimirá todos los datos del archivo.

Conclusión

Con suerte, después de leer este tutorial, deberías comprender qué es el manejo de archivos en Python. También aprendimos los modos/métodos necesarios para crear, escribir, leer, y cerrar un archivo de texto usando algunos ejemplos básicos de Python.

Gracias por leer!

En este artículo, aprenderás los diferentes métodos para añadir cadenas en Python.

Otro término comúnmente usado se habla sobreañadir cadenas es concatenación. Por eso, usualmente verás estos términos — añadir y concatenar — usados de manera intercambiable.

De cualquier manera, añadir o concatenar cadenas significa agregar o unir el valor de una cadena a otra cadena.

Veamos las diferentes maneras en las que puedes hacer eso con algunos códigos de ejemplo

Cómo Añadir una Cadena en Python Usando el Operador +

Puedes usar el operador +  para añadir dos o más cadenas. Aquí hay un ejemplo:

nombre = "John"
apellido = "Doe"

print(nombre + apellido)
# JohnDoe

En el ejemplo de arriba, creamos dos variables de cadenas – nombre y apellido. Estas tienen los valores de "John" y "Doe", respectivamente.

Para añadir esas dos variables, usamos el operador +: nombre + apellido.

Te darás cuenta de que en el resultado que obtuvimos las dos variables quedaron unidas sin espacios: JohnDoe.

Puedes agregar un espacio después del valor de nombre : "John ". O antes de apellido : " Doe". Esto es:

nombre = "John "
apellido = "Doe"

print(nombre + apellido)
# John Doe

También puedes agregar espacio usando comillas cuando añadas las cadenas. Así es como:

nombre = "John "
apellido = "Doe"

print(nombre + "" + apellido)
# John Doe

Cómo agregar una cadena en Python usando el método join()

Otra forma en la que puedes agregar cadenas en Python es usando el método join().

El método join() toma un objeto iterable — Listas, Tuplas, Cadenas, Conjuntos, Diccionarios — como su parámetro. Así es como se ve la sintaxis:

cadena.join(objeto_iterable)

Aquí hay un ejemplo que muestra como podemos agregar cadenas usando el método join():

nombre = "John"
apellido = "Doe"

print("".join([nombre, apellido]))
# JohnDoe

Aquí, le pasamos nuestras dos variables de cadenas como parámetros al método join().

También te darás cuenta de que las variables fueron anidadas en corchetes  [], creando una lista de cadenas: [nombre, apellido].  Esto es porque el método solo toma un parámetro, el cual debe ser un objeto iterable.

Algo extraño acerca del método join() son las comillas que van luego del punto fi

Puedes usar esas comillas para declarar lo que aparece entre los elementos en sus valores de objeto iterables. Dejame demostrártelo con un ejemplo.

nombre = "John"
apellido = "Doe"

print("#".join([nombre, apellido]))
# John#Doe

En el ejemplo de arriba, añadí el símbolo # entre comillas: "#".join([nombre, apellido]). Este # fue añadido entre nuestras cadenas: John#Doe.

En la última sección, hemos usado diferentes métodos para agregar espacio entre nuestras cadenas. Puedes lograrlo fácilmente agregando un espacio en las comillas que preceden al método join():

nombre = "John"
apellido = "Doe"

print(" ".join([nombre, apellido]))
# John Doe

Cómo añadir una cadena en Python usando el método de cadena format()

Así es como se ve la sintaxis para el método de cadena format():

{}.format(valor)

Básicamente, el método de cadena formato, toma un value como parámetro en la sintaxis de arriba y lo inserta entre llaves. El resultado será una cadena.

Aquí hay un ejemplo:

nombre = "John"
apellido = "Doe"

print("{} {}".format(nombre, apellido))
# John Doe

Desde que proveemos dos llaves en el ejemplo y dos parámetros (nombre y apellido), el método de cadena format() inserta las cadenas en sus respectivas llaves.

Puedes añadir más cadenas dentro de las comillas donde encuentres llaves. Esto no alterará la operación del método de cadena format() — las cadenas seguirán siendo insertadas en las llaves. Esto es:

nombre = "John"
apellido = "Doe"

print("Mi nombre es {} {}".format(nombre, apellido))
# Mi nombre es John Doe

Cómo añadir una cadena en Python usando la cadena-f

Este método es muy fácil de entender. La cadena-f fue creada en Python para hacer el formato e interpolación de cadena más fácil. Pero también puede usarlo para añadir cadenas.

Para usar la cadena-f, simplemente escribes una f seguido de comillas: f"". Luego insertas cadenas y los nombres de las variables entre comillas. Todos los nombres de las variables deben colocarse entre llaves.

Aquí hay un ejemplo:

nombre = "John"
apellido = "Doe"

print(f"{nombre} {apellido}")
# John Doe

Resumen

En este artículo, hemos discutido los diferentes métodos que puedes usar para añadir cadenas en Python.

Añadir una cadena a otra significa unirlas.

Como hemos discutido en este artículo, a lo largo de los ejemplos de código, puedes añadir cadenas en Python usando el operador + , el método join(), el método de cadena format(), y la cadena-f .

¡Feliz programación!

En Python existen varios métodos para dar formato a los tipos de datos.

El operador de formato %f es usado específicamente para dar formato a valores flotantes (números con decimales)

Podemos utilizar %f para especificar el número de dígitos decimales a ser retornados cuando un número con punto flotante (decimal) es redondeado.

Cómo usar el formateador %f en Python

En esta sección, verás algunos ejemplos en cómo usar el formateador %f y los varios parámetros con los que puede ser usado para retornar diversos resultados.

Este es el primer ejemplo:

numero_flotante = 1.9876

print("%f" % numero_flotante)
# 1.987600

El usar %f en el ejemplo de arriba añadió dos ceros al número. Pero no hay nada muy especial sobre ello. Pronto veremos que más podemos hacer para modificar el valor resultante.

Nota que el operador %f debe estar anidado dentro de comillas, y debe estar separado del número flotante al cual está formateando mediante el operador módulo (%):  "%f" % numero_flotante.

Veamos otro ejemplo:

numero_flotante = 1.9876
print("%.1f" % numero_flotante)

#2.0

En el código de arriba, hemos añadido .1 entre % y f en el operador %f. Esto significa que queremos redondear el número hasta un dígito decimal.

Nota que obtendrás un resultado similar al primer ejemplo si omites el punto (.) que viene antes del dígito que le entregamos en medio % y f.

El valor resultante en nuestro ejemplo es 2.0 el cual fue retornado cuando 1.9876 fue redondeado a un dígito decimal.

Usemos %.2f y veamos que sucede.

numero_flotante = 1.9876
print("%.2f" % numero_flotante)
# 1.99

Como era de esperarse, el número de punto flotante (1.9876) fue redondeado hasta dos lugares decimales - 1.99. Por lo que %.2f significa redondear a dos espacios decimales.

Puedes jugar con el código para ver que sucede mientras cambias el número en el operador de formato.

Cómo usar el formateador %d en Python

Otro método de formateo que podemos usar con números de punto flotante en Python es el formateador %d. Este retorna el número entero en un número de punto flotante.

Aquí hay un ejemplo:

numero_flotante = 1.9876
print("%d" % numero_flotante)
# 1

En el ejemplo de arriba, hemos creado un número de punto flotante: numero_flotante = 1.9876

Cuando la variable numero_flotante es formateada usando %d, solo 1 fue retornado.

El formateador %d ignora los números decimales y solo retorna la parte entera.

Resumen

En este artículo, hablamos sobre el operador de formato %f en Python. Lo utilizas para darle formato a los números flotantes.

Dependiendo en los parámetros entregados, el formateador %f redondea un valor flotante al decimal más cercano provisto.

También hablamos del operador de formato, %d el cual solo retorna el valor entero de un número flotante.

¡Feliz codificación!

Todos hemos tenido las mismas tareas aburridas que tenemos que hacer una y otra vez, por suerte, podemos automatizar algunos de estos procesos, y así enfocarnos en cosas que realmente requieran nuestra energía y atención.

En este artículo hablaremos de algunos scripts de automatización en Python, que podrás usar fácilmente para automatizar tareas. Es importante entender que será código ya escrito que nos ayudará a realizar muchas de nuestras tareas repetitivas.

Recomiendo firmemente tener algo de experiencia en el lenguaje de programación Python antes que continuar con este artículo.

Empecemos.

Como automatizar la corrección de errores en un texto

Lo primero en la lista es la corrección de textos. Siempre que quieras eliminar errores ortográficos o de escritura en un escrito, puedes utilizar este proyecto que utiliza el módulo Lmproof.

# Python Proofreading
# pip install lmproof
import lmproof
def proofread(text):
    proofread = lmproof.load("en")
    correction = proofread.proofread(text)
    print("Original: {}".format(text))
    print("Correction: {}".format(correction))
    
proofread("Tu texto")

Primero necesitarás instalar la librería  lmproof. Después podrás utilizar la función proofread(), que toma un texto como parámetro. La función se ejecuta y muestra el texto original y el texto corregido. Puedes usarlo para corregir errores de forma rápida de un escrito o un artículo corto.

Como automatizar la reproducción de música de manera aleatoria

Mientras trabajan, muchos programadores aman escuchar música. Para estos amantes de la música (como yo), este script escoge aleatoriamente canciones desde una carpeta y las reproduce con la ayuda de los módulos de Python OS y random.

import random, os
music_dir = 'E:\\music diretory'
songs = os.listdir(music_dir)

song = random.randint(0,len(songs))

# Muestra el nombre de la cancion
print(songs[song])  

os.startfile(os.path.join(music_dir, songs[0])) 

El código va a la carpeta donde están las canciones que quieras reproducir y las pone en una lista. Entonces las reproduce de manera aleatoria una después de la otra. Con os.startfile reproducimos la canción.

Convertir automáticamente de PDF a CSV

Algunas veces necesitarás convertir datos de un pdf  a datos CSV (comma separated value, valores separados por coma), para utilizarlos para algún análisis de datos. En estos casos, este script será de mucha ayuda.

import tabula

filename = input("Enter File Path: ")
df = tabula.read_pdf(filename, encoding='utf-8', spreadsheet=True, pages='1')

df.to_csv('output.csv')

Tendrás que instalar la librería tabula  utilizando pip para poder ejecutar este código. Después de instalarla puedes pasarle tu archivo PDF para convertirlo a CSV.

La librería viene con la función read_pdf(), que toma un archivo y lo lee. Y para terminar la automatización se utiliza la función to_csv() para convertir el archivo a CSV.

Compresor automático de fotos

También puedes reducir el tamaño de una imagen comprimiéndola – Manteniendo la calidad original

import PIL
from PIL import Image
from tkinter.filedialog import *

fl=askopenfilenames()
img = Image.open(fl[0])
img.save("output.jpg", "JPEG", optimize = True, quality = 10)

Puedes usar PIL (Python Imaging Library - libreria de images de Python) para manipular imágenes, añadir filtros, desenfocar, cambiar nitidez, compresión de imágenes, cambiar bordes y mucho más.

Descargas automáticas de YouTube

El siguiente código automatiza la descarga de videos de YouTube. Simplemente, usa este programa para hacer tus descargas sin la necesidad de otras aplicaciones o páginas.

import pytube

link = input('Youtube Video URL')
video_download = pytube.Youtube(link)
video_download.streams.first().download()
print('Video Downloaded', link)

La librería pytube es muy fácil usar y con ella podrás descargar videos en tu computadora local. Todo lo que necesitas es ingresar el enlace del video y el método download() lo descargara en tu computadora

Texto a voz automáticamente

Haremos uso de la API "texto a voz" de Google para este código. La API está actualizada y funciona con diferentes idiomas y podrás seleccionar diferentes tonos y tipos de voz.

from pygame import mixer
from gtts import gTTS

def main():
   tts = gTTS('Like This Article')
   tts.save('output.mp3')
   mixer.init()
   mixer.music.load('output.mp3')
   mixer.music.play()
   
if __name__ == "__main__":
   main()

Como convertir automáticamente imágenes a PDF

Esta es una tarea muy común que probablemente harás varias veces. Talvez querrás convertir una sola o varias imágenes a PDF.

Como convertir una sola imagen a PDF:

import os
import img2pdf
with open("output.pdf", "wb") as file:
   file.write(img2pdf.convert([i for i in os.listdir('path to image') if i.endswith(".jpg")]))

Como convertir varias imágenes a PDF:

from fpdf import FPDF
Pdf = FPDF()

list_of_images = ["wall.jpg", "nature.jpg","cat.jpg"]
for i in list_of_images:
   Pdf.add_page()
   Pdf.image(i,x,y,w,h)
   Pdf.output("result.pdf", "F")

Aquí estamos usando la librería  image2pdf de Python para convertir nuestra imagen a PDF. También podemos convertir varias imágenes a PDF con solo unas cuantas líneas de código.

Verificador de plagio automático

El plagio es el acto de presentar ideas o palabras como tuyas, con o sin el permiso de la otra persona, integrándolas a un trabajo o escrito, sin dar crédito al autor original.

Este código puede ser muy útil cuando quieras buscar plagio entre 2 archivos.

from difflib import SequenceMatcher
def plagiarism_checker(f1,f2):
    with open(f1,errors="ignore") as file1,open(f2,errors="ignore") as file2:
        f1_data=file1.read()
        f2_data=file2.read()
        res=SequenceMatcher(None, f1_data, f2_data).ratio()
        
print(f"These files are {res*100} % similar")
f1=input("Enter file_1 path: ")
f2=input("Enter file_2 path: ")
plagiarism_checker(f1, f2)

Como hacer un acortador de URLs

Una URL muy larga puede ser molesta para leer o compartir, Para acortar una URL, en este código hacemos uso de una API.

from __future__ import with_statement
import contextlib
try:
	from urllib.parse import urlencode
except ImportError:
	from urllib import urlencode
try:
	from urllib.request import urlopen
except ImportError:
	from urllib2 import urlopen
import sys

def make_tiny(url):
	request_url = ('http://tinyurl.com/app-index.php?' + 
	urlencode({'url':url}))
	with contextlib.closing(urlopen(request_url)) as response:
		return response.read().decode('utf-8')

def main():
	for tinyurl in map(make_tiny, sys.argv[1:]):
		print(tinyurl)

if __name__ == '__main__':
	main()
    

'''

-----------------------------OUTPUT------------------------
python url_shortener.py https://www.wikipedia.org/
https://tinyurl.com/bif4t9

'''
    

Probador de velocidad de internet

La API para prueba de velocidad de OOKLA, permite comprobar el ping y la velocidad de internet, este pequeño código medirá la velocidad de subida y de bajada.

# Internet Speed tester
# pip install speedtest-cli
import speedtest as st

# Set Best Server
server = st.Speedtest()
server.get_best_server()

# Test Download Speed
down = server.download()
down = down / 1000000
print(f"Download Speed: {down} Mb/s")

# Test Upload Speed
up = server.upload()
up = up / 1000000
print(f"Upload Speed: {up} Mb/s")

# Test Ping
ping = server.results.ping
print(f"Ping Speed: {ping}")

Aunque haya otras alternativas como fast.com, con este código puedes hacerlo de manera rápida utilizando Python.

Conclusión

Hemos visto 10 ejemplos de automatización con Python en este artículo, espero que lo hayas encontrado útil. También puedes investigar un poco más sobre las librerías utilizadas y así expandir tu conocimiento.

Contáctame en Twitter o en LinkedIn.

! Y que tengas un gran día programando¡

Una introducción a la variable __name__ y su uso en Python

Es muy probable que hayas visto la variable __name__ cuando has revisado código de Python. A continuación puedes ver un fragmento de código de ejemplo de cómo puede lucir:

if __name__ == '__main__':    main()

En este artículo quiero mostrarte cómo puedes hacer uso de esta variable para crear módulos en Python.

¿Por qué se usa la variable _ _name_ _ ?

La variable __name__ (dos guiones bajos antes y después) es una variable especial de Python. Toma su valor dependiendo de cómo se ejecute el script contenedor.

A veces escribes un script con funciones que también pueden ser útiles en otros scripts. En Python, puedes importar ese script como un módulo en otro script.

Gracias a esta variable especial, puedes decidir si quieres ejecutar ese script, o importar las funciones definidas en el mismo.

¿Qué valores puede contener la variable __name__ ?

Cuando ejecutas tu script, la variable __name__ es igual a __main__ . Cuando importas el script contenedor, contendrá el nombre del script.

Veamos estos dos casos de uso y describamos el proceso con dos ilustraciones.

Escenario 1 - Ejecutar el script

Supongamos que escribimos el script nombreScript.py de la siguiente manera:

def miFuncion():    print 'El valor de __name__ es ' + __name__

def main():    miFuncion()

if __name__ == '__main__':    main()

Si ejecutas nombreScript.py, se sigue el proceso de abajo.

Antes de que ejecute cualquier otro código, la variable __name__ se establece a __main__. Después, las sentencias def de main y miFuncion se ejecutan. Debido a que la condición se evalúa a verdadero, la función main es llamada. Esta a su vez llama a miFuncion. Esto imprime el valor de __main__.

Escenario 2 - Importar el script en otro script

Si queremos reusar miFuncion en otro script, por ejemplo importandoScript.py, podemos importar nombreScript.py como un módulo.

El código enimportandoScript.py podría ser el siguiente:

import nombreScript as ns

ns.miFuncion()

Entonces tenemos dos ámbitos: uno de importandoScript y el segundo de nombreScript. En la imagen puedes ver como difiere del primer caso de uso.

En importandoScript.py la variable __name__ se establece a __main__. Al importar nombreScript, Python empieza a buscar un archivo agregando .py al nombre del módulo. Luego ejecuta el código contenido en el archivo importado.

Pero esta vez se establece a nombreScript; de nuevo las sentencias def para main y miFuncion son ejecutadas, pero ahora la condición evalúa a falso y main no es llamado.

En importandoScript.py llamamos a miFuncion que da como salida nombreScript. NombreScript es conocida por miFuncion cuando esa función fue definida.

Si imprimieras __name__ en importandoScript, saldría __main__. La razón de esto es que Python usa el valor conocido en el ámbito de importandoScript.

Conclusión

En este breve artículo, expliqué cómo puedes usar la variable __name__ para escribir módulos. También puedes ejecutar estos módulos por sí mismos. Esto se puede lograr al hacer uso de cómo los valores de estas variables cambian dependiendo de dónde ocurren.

Python es un gran lenguaje de programación para aprender y que puedes usar en una variedad de áreas en desarrollo de software.  Tú puedes usar Python para desarrollo de páginas web, análisis de datos, aprendizaje automático, inteligencia artificial y más.

Con la enorme cantidad de recursos para escoger, a veces es difícil saber cuál es la mejor opción.

Yo he organizado una lista de 16 tutoriales de Python para principiantes.  Esta lista incluye recursos gratuitos y de paga.

Aquí está la lista completa.  Una vez que encuentres el recurso que te interesa, da clic al link y él te llevará a una descripción más detallada de dicho recurso.  Sin más que agregar, los recursos son gratuitos.

Los mejores tutoriales de Python para principiantes

1. Aprende Python - Curso completo para principiantes (freeCodeCamp)
2. El manual de Python (Flavio Copes)
3. Tutoriales de Python para Completos Principiantes (CS Dojo)
4. Programación para Todos (Iniciándote con Python)(Universidad de Michigan)
5. Estudia esta Noche (studytonight.com/python/)
6. Nucleo de Python (SoloLearn)
7. Python Real (realpython.com)
8. Python Básico con Sam (freeCodeCamp)
9. Tutoriales para principiantes de Python (Pythonspot)
10. Tutorial de Python(Python para Principiantes)
11. Automatiza las cosas aburridas con Python (Libro Online)
12. Aprende Python 2 (Codecademy)
13. Aprende Python, el camino difícil (Libro)
14. Curso intensivo de Python para principiantes (Traversy Media)
15. Tutorial de Python - Python para principiantes (Programando con Mosh)
16. Computación científica con Python (freeCodeCamp)

Nota del traductor: Todos los recursos están originalmente en inglés.

Aprende Python: Curso completo para principiantes

En este curso en Youtube de freeCodeCamp, aprenderás programación básica como lo son listas, condicionales, cadenas, tuplas, funciones, clases y más.

También podrás construir pequeños proyectos como una calculadora básica, juego de mad libs, una aplicación para de traducción y un juego de adivinanzas.

El Manual de Python

En este artículo de Flavio Copes aprenderás acerca de cadenas, listas, tuplas, recursión y más.

También aprenderás como instalar paquetes de terceros y como trabajar con ambientes virtuales.

Tutoriales de Python para Completos Principiantes por CS Dojo

En esta serie de videos de Youtube para principiantes en Python por CS Dojo, aprenderás acerca de diccionarios, ciclos, funciones, objetos y más.

También aprenderás a construir una automatización para Twitter usando Python.

Programación para Todos (Iniciándote con Python)

En este curso de la Universidad de Michigan aprenderás acerca de funciones, ciclos, condicionales, variables y más del famoso "Dr. Chuck".

Una vez hayas aprendido lo básico, puedes continuar con el resto de la especialización y tomar el Curso de Estructuras de Datos en Python, el Curso de Acceso a Datos de Internet con Python y el Curso de Uso de Bases de Datos con Python.

Estudia esta Noche

En Estudia esta Noche, podrás aprender acerca de Python básico, manejo de errores, POO (Programación Orientada a Objetos), manejo de archivos, tipos de datos complejos, hilos múltiples y más.

Una vez hayas aprendido lo básico, puedes moverte dentro de otros módulos incluidos como la libreria NumPy, Matplotlib, Tkinter, Programación de Redes en Python y Raspado de páginas de internet usando Beautiful Soup.

Nucleo de Python

En el Curso de Python de Sololearn aprenderás acerca de cadenas, variables, Programación Orientada a Objetos, programación funcional y más.  Está lleno de evaluaciones cortas, retos y proyectos que puedes ir construyendo a lo largo del camino.

Para poder empezar necesitarás crear una cuenta gratuita.

Python Real

Los tutoriales de Python Real proveen una variedad de recursos para ayudar a tu aprendizaje de Python por medio de artículos, videos, proyectos y pequeñas evaluaciones.  Puedes empezar con los cursos básicos en tipos de datos, ciclos, funciones, cadenas y estructuras de datos.

Tu puedes moverte dentro de una extensa lista de proyectos que incluye la construcción de un diario personal, una aplicación de portafolio y un servicio de notificación de precios del Bitcoin.

Para poder acceder a todo el contenido tendrás que convertirte en suscriptor de paga.

Python Básico con Sam (freeCodeCamp)

En esta serie de Youtube de Sam Focht, podrás aprender acerca de ciclos, funciones, cadenas, recursión y más.

También podrás construir algunos proyectos, incluyendo un juego de adivinanzas, listas de compras, un juego de mesa y un generador de contraseñas aleatorio.

Tutoriales para Principiantes de Python

En esta serie de tutoriales para principiantes de Python, aprenderás acerca de tipos de datos, tuplas, objetos, clases, diccionarios y más.  También aprenderás acerca de conceptos avanzados como recursión, lambdas y enhebrado.

Una vez que cubras lo básico, puedes moverte al módulo de aprendizaje automático, bases de datos e interfaces gráficas de usuario.

Tutorial de Python

En este tutorial de Python para principiantes, aprenderás acerca de funciones, ciclos, listas, condicionales, manejo de errores y más.

Una vez aprendas lo básico, puedes explorar los otros módulos del sitio, incluyendo raspado de páginas en internet con BeautifulSoup y usando la interfaz de Youtube de programación de aplicaciones en Python.

Automatiza las cosas aburridas con Python

En el libro en línea Automatiza las cosas aburridas con Python, aprenderás acerca de diccionarios, cadenas, depuración, expresiones regulares y más.

Si prefieres el formato en video, puedes ir a la serie de Youtube que Al Sweigart ha posteado sobre este libro.

Aprende Python 2

En este curso de CodeAcademy aprenderás sobre sintaxis básica, cadenas, funciones, listas, condicionales y más.  Este curso también cubrirá temas más avanzados como segmentación de listas y expresiones lambda.

Para tomar este curso necesitarás crear una cuenta.

Aprende Python, el camino difícil

En aprende Python 2, el camino dificil, aprenderás acerca de variables, condicionales, funciones, clases, objetos y más.  También aprenderás como construir un sitio en internet y un juego.

Asimismo, tienes la opción de hacer la versión actualizada del libro, la cual se llama Python 3, el camino difícil.  Estos dos libros solamente están en la opción de pago.

Curso intensivo de Python para principiantes

En este curso de Brad Traversy en Youtube, aprenderás acerca de listas, tuplas, diccionarios, funciones, clases, y más.  Brad también te enseñará como trabajar con archivos y datos en JSON.

Tutorial de Python - Python para principiantes

En este curso de programación en Youtube con Mosh, aprenderás programación básica como variables, ciclos, cadenas, tuplas, funciones, clases y más.

También podrás construir tres proyectos: uno en automatización, uno en aprendizaje automático y finalmente uno en construcción de una página en internet con Django.

Si deseas una práctica adicional, puedes ir a los 53 ejercicios de Python para principiantes de Mosh.

Computación científica con Python.

En este curso certificado de freeCodeCamp, aprenderás acerca de ciclos, listas, diccionarios, gestión de redes, servicios de internet y más.

También tendrás la oportunidad de construir cinco proyectos: Formateador aritmético, calculadora de tiempo, aplicación de presupuesto, calculadora de área de polígonos y calculadora de probabilidades.