Fundamentos de Programación y Python
Fundamentos de Programación con Python para Principiantes
Instalación y Uso Básico de Python en Windows y Mac
Semántica y Sintaxis en Programación Python
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manejo de Cadenas y Operaciones Básicas en Python
Tipos de Datos en Python: Enteros, Flotantes y Booleanos
Dominio de la función `print` en Python: usos y formatos avanzados
Operaciones matemáticas avanzadas en Python: módulo, potencia y más
Entrada de información y manejo de tipos de datos en Python
Colección y Procesamiento de Datos en Python
Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos
Copiar listas en Python sin compartir memoria con slicing
Manejo de Matrices y Tuplas en Python
Matrices en Juegos y Imágenes con Python
Diccionarios en Python: Uso y Manipulación de Datos
Control de Flujo en Python
Estructuras Condicionales en Programación: Uso de If, Else y Elif
Iteración y control de flujo con bucles en Python
Iteradores y Generadores en Python: Uso Eficiente de Memoria
Listas por comprensión en Python: creación y optimización de listas
Funciones y Manejo de Excepciones en Python
Funciones y Parámetros en Python: Crea una Calculadora Básica
Funciones Lambda en Python: Uso y Aplicaciones Prácticas
Recursividad en Python: Factoriales y Serie de Fibonacci
Manejo de Excepciones y Errores en Python
Programación Orientada a Objetos en Python
Programación Orientada a Objetos en Python: Clases y Métodos Básicos
Gestión de Biblioteca con Programación Orientada a Objetos
Herencia y Polimorfismo en Programación Orientada a Objetos
Programación Orientada a Objetos: Implementación de Clases y Herencia
Polimorfismo en Programación Orientada a Objetos
Herencia y Uso de la Función super() en Python
Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python
Lectura y escritura de archivos
Manipulación de Archivos TXT y CSV en Python
Manipulación de archivos CSV con Python: lectura y escritura
Manejo de Archivos JSON en Python para Aplicaciones Web y APIs
Biblioteca estándar de Python
Uso Eficiente de la Biblioteca Estándar de Python
Uso de las librerías OS, Math y Random en Python
Análisis de Datos de Ventas con Python y Statistics
Desarrollo del juego Batalla Naval en Python
Conceptos avanzados de Python
Programación Avanzada en Python: POO, Excepciones y Proyectos
Escritura de Código Pytónico y Buenas Prácticas en Python
Comentarios y Docstrings: Buenas Prácticas en Programación
Tiempo de vida y alcance de variables en Python
Anotaciones de Tipo en Python para Código Más Legible
Validación de Tipos y Manejo de Excepciones en Python
Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones
Decoradores
Decoradores en Python: Extiende Funcionalidades de Funciones
Uso de Decoradores Anidados y con Parámetros en Python
Decoradores en Programación Orientada a Objetos en Python
Métodos y estructura de clases en Python
Uso de Métodos Mágicos en Python
Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases
Ejecutar scripts Python con `if __name__ == '__main__'`
Metaprogramación en Python: Métodos `__new__` y `__init__`
Uso de *args y **kwargs en funciones de Python
Métodos y Atributos Privados y Protegidos en Python
Uso de Property en Python: Getter, Setter y Eliminación de Atributos
Métodos estáticos y de clase en Python
Programación concurrente y asíncrona
Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas
Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`
Asincronismo en Python con AsyncIO y Corrutinas
Sincronía y Concurrencia en Python: Teoría y Práctica
Creación de módulos y paquetes
Módulos y Paquetes en Python: Reutilización y Organización de Código
Uso de Paquetes y Subpaquetes en Python con Visual Studio Code
Publicación de Paquetes Python en PyPI
Proyecto final
Sistema de Gestión de Reservas en Python Avanzado
Sistema de Gestión de Reservas en Python Avanzado
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Manipulación de archivos CSV con Python: lectura y escritura
31/63Recursos
¿Cómo trabajar con archivos CSV en Python?
Manipular archivos CSV es esencial para gestionar datos tabulares, como registros de inventario, y es fundamental en la ciencia y el análisis de datos. En esta guía, aprenderás a leer, escribir, actualizar y añadir información a archivos CSV utilizando Python.
¿Cómo se lee un archivo CSV?
Para comenzar, es necesario importar la librería csv en Python, lo cual se hace con el siguiente comando:
import csv
A continuación, se procede a abrir el archivo en modo lectura especificando su nombre. En este ejemplo, trabajamos con un archivo llamado products.csv que contiene columnas como nombre, precio, cantidad, etc.
with open('products.csv', mode='r') as file:
csv_reader = csv.DictReader(file)
for row in csv_reader:
print(row)
Esto itera sobre cada fila del archivo y las imprime como diccionarios, donde la llave es el nombre de la columna y el valor es el dato correspondiente.
¿Cómo se visualiza la información por columnas?
Si se desea visualizar datos específicos por columnas, se puede modificar el código para que imprima solo los valores de interés:
with open('products.csv', mode='r') as file:
csv_reader = csv.DictReader(file)
for row in csv_reader:
print(f"Producto: {row['nombre']}, Precio: {row['precio']}")
Este fragmento muestra cómo imprimir específicamente la columna de nombres junto con el precio correspondiente de cada producto.
¿Cómo se añade una nueva fila a un CSV?
Para añadir información al final de un archivo CSV, emplea el modo de apertura "append" ('a'). Aquí creamos un nuevo producto y agregamos sus datos:
new_product = {
'nombre': 'Cargador Inalámbrico',
'precio': '75',
'cantidad': 100,
'marca': 'MarcaX',
'categoría': 'accesorios',
'fecha_entrada': '2023-10-15'
}
with open('products.csv', mode='a', newline='') as file:
writer = csv.DictWriter(file, fieldnames=new_product.keys())
writer.writerow(new_product)
Este ejemplo muestra cómo se estructura un nuevo producto y luego se agrega al archivo existente sin sobrescribir la información previa.
¿Cómo añadir una nueva columna en un archivo CSV?
A veces es necesario no solo agregar, sino también crear nuevos datos derivados de las operaciones en las columnas existentes, como calcular un valor total. Aquí se ilustra cómo:
with open('products.csv', mode='r') as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ['total_value']
with open('products_updated.csv', mode='w', newline='') as new_file:
csv_writer = csv.DictWriter(new_file, fieldnames=fieldnames)
csv_writer.writeheader()
for row in csv_reader:
row['total_value'] = float(row['precio']) * int(row['cantidad'])
csv_writer.writerow(row)
Este código añade una nueva columna 'total_value' calculando el precio total multiplicado por la cantidad de cada producto, y guarda los cambios en un archivo nuevo para evitar alterar los datos originales.
Trabajar con archivos CSV en Python te permite manipular datos de forma eficaz, haciéndolo una herramienta poderosa para desarrolladores y científicos de datos. ¿Por qué no intentar crear nuevas operaciones con tus datos? Con práctica y dedicación, dominarás con confianza el arte de la manipulación de archivos CSV.
Aportes 99
Preguntas 4
Ordenar por:
Team Platzi! Me encanta este curso y Carli es lo más! Aunque siento que es necesario otro curso de Python previo a este, es decir, para principiantes realmente con conocimientos *cero* en programación. Digamos, para personas que no hayan visto en sus vidas estas pantallas con fondo negro. Yo soy una de esas personas.
Intento hacer todo lo que hace Carli en cada video, pero no logro entender qué es lo que estoy haciendo ni para qué. Solo tecleo, y luego me frustro.
Intento orientarme con los comentarios y me doy cuenta de que quienes comentan tienen más conocimientos de esta herramienta o del mundo de la programación, a diferencia de alguien que está en *cero*, como yo. Me perdí completamente hace un par de clases, pero lo voy a seguir intentando!
No encontré aquí en Platzi un curso sobre Python que pueda tomarse antes de este, pero si lo hay, les agradecería que me lo hicieran saber :)!
Me costó un monton entender la última parte de la clase, no lo entendí hasta ver de nuevo la clase completa, escribir el código yo mismo y ver que hacia, acá dejo el código con mis comentarios por si le es de utilidad a alguien.
```js
# Este codigo añade una nueva columna de valor total al documento csv de products
# El valor total se calcula entre el precio del producto y cantidada de este producto
import csv
file_path = "products.csv"
updated_file_peth = 'products_updated.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
# se obtienen los nombres de las columnas (encavezados) y se añade a "total value" entre estos
fieldnames = csv_reader.fieldnames + ['total_value']
with open(updated_file_peth, mode='w', newline='') as updated_File:
csv_writer = csv.DictWriter(updated_File, fieldnames=fieldnames)
csv_writer.writeheader() # se escriben los encavezados actualizados
# se calculan los "total_value" y se escriben los resultados en cada fila
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
csv_writer.writerow(row)
pass
```
El manejo de archivos CSV en Python se facilita mediante el módulo integrado `csv`, que proporciona herramientas para leer, escribir y procesar archivos CSV de manera sencilla.
\### Operaciones básicas con archivos CSV en Python
\#### 1. \*\*Leer archivos CSV\*\*
Puedes leer archivos CSV utilizando `csv.reader`, que devuelve cada fila del archivo como una lista de elementos.
\*\*Ejemplo de lectura de un archivo CSV:\*\*
```python
import csv
\# Abrir y leer un archivo CSV
with open('archivo.csv', mode='r') as archivo:
lector\_csv = csv.reader(archivo)
for fila in lector\_csv:
print(fila)
```
Cada fila del archivo se imprime como una lista, donde cada elemento corresponde a una celda de la fila CSV.
\#### 2. \*\*Leer archivos CSV con encabezados\*\*
Si el archivo CSV tiene una fila de encabezados, puedes usar `csv.DictReader`, que devuelve cada fila como un diccionario, donde las claves son los nombres de las columnas.
\*\*Ejemplo de lectura con encabezados:\*\*
```python
import csv
\# Leer un CSV con encabezado
with open('archivo\_con\_encabezado.csv', mode='r') as archivo:
lector\_csv = csv.DictReader(archivo)
for fila in lector\_csv:
print(fila) # Cada fila es un diccionario
```
En este caso, los nombres de las columnas del CSV son las claves de los diccionarios.
\#### 3. \*\*Escribir en archivos CSV\*\*
Para escribir en un archivo CSV, utilizamos `csv.writer`, que permite agregar filas como listas.
\*\*Ejemplo de escritura en un archivo CSV:\*\*
```python
import csv
\# Escribir datos en un archivo CSV
with open('archivo.csv', mode='w', newline='') as archivo:
escritor\_csv = csv.writer(archivo)
escritor\_csv.writerow(\['Nombre', 'Edad', 'Ciudad']) # Escribir encabezado
escritor\_csv.writerow(\['Juan', 28, 'Madrid'])
escritor\_csv.writerow(\['Ana', 22, 'Barcelona'])
```
El parámetro `newline=''` se usa para evitar líneas en blanco entre cada fila al escribir en el archivo.
\#### 4. \*\*Escribir en archivos CSV con encabezados\*\*
Si deseas escribir datos a un archivo CSV con encabezados, puedes usar `csv.DictWriter`. Debes especificar los nombres de las columnas como una lista y pasar cada fila como un diccionario.
\*\*Ejemplo de escritura con encabezados:\*\*
```python
import csv
\# Escribir un CSV con encabezado
with open('archivo\_con\_encabezado.csv', mode='w', newline='') as archivo:
campos = \['Nombre', 'Edad', 'Ciudad']
escritor\_csv = csv.DictWriter(archivo, fieldnames=campos)
escritor\_csv.writeheader() # Escribir encabezado
escritor\_csv.writerow({'Nombre': 'Juan', 'Edad': 28, 'Ciudad': 'Madrid'})
escritor\_csv.writerow({'Nombre': 'Ana', 'Edad': 22, 'Ciudad': 'Barcelona'})
```
\#### 5. \*\*Modificar archivos CSV\*\*
Para modificar un archivo CSV, puedes leer su contenido, almacenarlo en una lista, realizar los cambios necesarios y luego escribir el contenido modificado en el archivo nuevamente.
\*\*Ejemplo de modificación de un archivo CSV:\*\*
```python
import csv
\# Leer y modificar un archivo CSV
with open('archivo.csv', mode='r') as archivo:
lector\_csv = csv.reader(archivo)
filas = list(lector\_csv)
\# Modificar una fila
filas\[1]\[1] = '30' # Cambiar la edad de Juan a 30
\# Escribir los cambios de nuevo en el archivo
with open('archivo.csv', mode='w', newline='') as archivo:
escritor\_csv = csv.writer(archivo)
escritor\_csv.writerows(filas)
```
\#### 6. \*\*Manejo de Excepciones\*\*
Es recomendable manejar posibles excepciones al trabajar con archivos, especialmente si el archivo CSV no existe o si hay problemas de permisos.
\*\*Ejemplo de manejo de excepciones:\*\*
```python
import csv
try:
with open('archivo\_inexistente.csv', mode='r') as archivo:
lector\_csv = csv.reader(archivo)
for fila in lector\_csv:
print(fila)
except FileNotFoundError:
print("El archivo no existe.")
except IOError:
print("Error al leer el archivo.")
```
\### Modos comunes de apertura de archivos CSV
\- `'r'`: \*\*Lectura\*\*. Usado para leer el archivo.
\- `'w'`: \*\*Escritura\*\*. Sobrescribe el archivo o lo crea si no existe.
\- `'a'`: \*\*Agregar\*\*. Añade al final del archivo si existe.
\- `'r+'`: \*\*Lectura y escritura\*\*. Lee y escribe en el archivo.
\### Resumen:
\- \*\*Lectura\*\*: Usa `csv.reader` para leer filas como listas y `csv.DictReader` para leer filas como diccionarios.
\- \*\*Escritura\*\*: Usa `csv.writer` para escribir filas como listas y `csv.DictWriter` para escribir filas como diccionarios.
\- \*\*Excepciones\*\*: Maneja posibles errores como archivos inexistentes o problemas de permisos.
Esta estructura es muy útil para manejar datos tabulares de forma eficiente en Python.
```python
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
with open(file_path, mode='r', newline='') as file:
csv_reader = csv.DictReader(file)
#optener el nombre de las columnas existentes
fieldnames=csv_reader.fieldnames + ['code_product']
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer=csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() # Escribir los encabezados
for row in csv_reader:
row['code_product'] = float(row['price']) * int(row['quantity'])
csv_writer.writerow(row)
```
A medida que avanzo en el curso me siento cada vez más seguro de que para que las clases se entiendan bien, es necesario que se explique el objetivo de cada ejercicio antes de comenzar a hacerlo.
En la mayoría de las ocasiones uno tiene que deducir qué se está haciendo porque no se explican qué función tienen los parámetros que reciben las funciones ni mucho menos el objetivo de las funciones en sí.
Constantemente tengo que revisar documentación por separado o videos de YouTube para comprender el tema del que se está hablando.
Las explicaciones de los conceptos son malas y muy abiertas, inclusive para alguien que ya tiene noción de programación en otros lenguajes.
```python
#aquí añado una columna de precio de venta aproximado sumandole 35% de margen
file_path = "products.csv"
updated_file_path = "products_updated.csv"
with open(file_path, mode="r") as file:
csv_reader = csv.DictReader(file)
#obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ["total_value"] + ["sell_price"] #aqui el primer fieldname es el nombre de la columna, y csv_reader.fieldnames es una lista de los nombres de las columnas y al usar el + concatena los dos listas para obtener una nueva lista. Es decir, concatenamos las columnas existentes con la nueva columna "total_value"
with open(updated_file_path, mode="w", newline="") as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #escribir la cabecera
for row in csv_reader:
row["total_value"] = float(row["price"]) * int(row["quantity"])
row["sell_price"] = float(row["price"]) * 1.35
csv_writer.writerow(row)
```
```js
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
with open(file_path, mode = 'r') as file:
csv_reader = csv.DictReader(file)
#obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value'] + ['30%_discount_price']
with open (updated_file_path, mode = 'w', newline = '') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader()#escribir encabezado
for row in csv_reader:
row['total_value']= float(row['price']) *int(row['quantity'])
# csv_writer.writerow(row)
row['30%_discount_price'] = float(row['price'])*float(0.70)
csv_writer.writerow(row)
```import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'
with open(file\_path, mode = 'r') as file: csv\_reader = csv.DictReader(file) #obtener los nombres de las columnas existentes fieldnames = csv\_reader.fieldnames + \['total\_value'] + \['30%\_discount\_price']
with open (updated\_file\_path, mode = 'w', newline = '') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader()#escribir encabezado
for row in csv\_reader: row\['total\_value']= float(row\['price']) \*int(row\['quantity']) # csv\_writer.writerow(row)
row\['30%\_discount\_price'] = float(row\['price'])\*float(0.70) csv\_writer.writerow(row)
```js
#Nueva columna RETO
"""Haré una nueva columna llamada buy or pass, con el objetivo de saber
que productos se están acabando y adquirir más para evitar quedar sin existencias"""
file_path = "Archivos/products.csv"
updated_file_path = "Archivos/products_updated_2.csv"
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ["buy_or_pass"]
with open(updated_file_path, mode='w',newline="") as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames = fieldnames)
csv_writer.writeheader() #Escribir los encabezados
#Hallar que productos adquirir
for row in csv_reader:
#Si hay menos de 100 existencias pondrá "Buy"
if int(row["quantity"]) < 100:
row["buy_or_pass"] = "Buy"
csv_writer.writerow(row)
else:
#Si hay más de 100 existencias pondrá "Pass"
row["buy_or_pass"] ="Pass"
csv_writer.writerow(row)
```#Nueva columna RETO
"""Haré una nueva columna llamada buy or pass, con el objetivo de saber
que productos se están acabando y adquirir más para evitar quedar sin existencias"""
file\_path = "Archivos/products.csv"
updated\_file\_path = "Archivos/products\_updated\_2.csv"
with open(file\_path, mode='r') as file:
csv\_reader = csv.DictReader(file)
\#Obtener los nombres de las columnas existentes
fieldnames = csv\_reader.fieldnames + \["buy\_or\_pass"]
with open(updated\_file\_path, mode='w',newline="") as updated\_file:
csv\_writer = csv.DictWriter(updated\_file, fieldnames = fieldnames)
csv\_writer.writeheader() #Escribir los encabezados
\#Hallar que productos adquirir
for row in csv\_reader:
\#Si hay menos de 100 existencias pondrá "Buy"
if int(row\["quantity"]) < 100:
row\["buy\_or\_pass"] = "Buy"
csv\_writer.writerow(row)
else:
\#Si hay más de 100 existencias pondrá "Pass"
row\["buy\_or\_pass"] ="Pass"
csv\_writer.writerow(row)
Agregue una columna de igv antes del total value:
Mi aporte, primero me asegure de convertir Price y quantity en valores numéricos ya que lo intente hacer directamente de la lista una validación, la cual no funciono.import csv#crear nuevas columnsas en archivos csv, siempre se recomienda hacer un archivo nuevo y dejar el otro como estafile\_path='products.csv'file\_new\_path='add\_products.csv'with open(file\_path,mode='r') as file : csv\_reader= csv.DictReader(file) #obtener los nombres de las columnas existentes fieldnames=csv\_reader.fieldnames+\['total\_value','average','difference'] #de esta forma podemos crear mas columnas en nuestro archivo with open(file\_new\_path,mode='w',newline='') as update\_file : csv\_writer= csv.DictWriter(update\_file,fieldnames=fieldnames) csv\_writer.writeheader()#escribir los encabezados for row in csv\_reader: # Convertir valores para realizar cálculos price = float(row\['price']) quantity = int(row\['quantity']) row\['total\_value'] = price \* quantity row\['average'] = (price + quantity) / 2 if price < quantity: row\['difference'] = quantity - price else: row\['difference'] = price - quantity csv\_writer.writerow(row)```js
import csv
#crear nuevas columnsas en archivos csv, siempre se recomienda hacer un archivo nuevo y dejar el otro como esta
file_path='products.csv'
file_new_path='add_products.csv'
with open(file_path,mode='r') as file :
csv_reader= csv.DictReader(file)
#obtener los nombres de las columnas existentes
fieldnames=csv_reader.fieldnames+['total_value','average','difference'] #de esta forma podemos crear mas columnas en nuestro archivo
with open(file_new_path,mode='w',newline='') as update_file :
csv_writer= csv.DictWriter(update_file,fieldnames=fieldnames)
csv_writer.writeheader()#escribir los encabezados
for row in csv_reader:
# Convertir valores para realizar cálculos
price = float(row['price'])
quantity = int(row['quantity'])
row['total_value'] = price * quantity
row['average'] = (price + quantity) / 2
if price < quantity:
row['difference'] = quantity - price
else:
row['difference'] = price - quantity
csv_writer.writerow(row)
```
A la final queria agregarle un id serial, que se generara por el nombre, fue un gallo, ya que poder moverme entre los diferentes valores, era bien complicado y tocaba importara otra librería. A la final lo logre y quedo de esta manera:
```js
import csv
import uuid
file_path = 'Archivos\products.csv'
updated_file_path = 'Archivos\products_updated.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value'] + ['location'] + ['Serial']# Se añade el nombre de la nueva columna
with open(updated_file_path, mode ='w', newline = '') as updated_file: # Se abre el archivo en modo escritura
csv_writer = csv.DictWriter(updated_file, fieldnames = fieldnames)
csv_writer.writeheader() # Se escribe la cabecera con los nombres de las columnas
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity']) # Se calcula el valor total
row['location'] = 'Bodega' # Se calcula la ubicación
row['Serial'] = str(uuid.uuid4())
csv_writer.writerow(row)
```
import csv
file\_path='products.csv'updated\_file\_path= 'products\_updated.csv'
with open (file\_path, mode='r') as file: csv\_reader = csv.DictReader(file) #Obtener los nombres de las columnas existentes fieldnames = csv\_reader.fieldnames + \['total\_value'] + \['Profit'] + \['Warranty']
with open(updated\_file\_path, mode= "w", newline="") as updated\_file: csv\_writer= csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() #escribir encabezado for row in csv\_reader: row\['total\_value'] = float(row\['price'])\* int(row\['quantity']) row\['Warrany'] = '30 days' row\['profit'] = float(row\['price'])\* 0.5 csv\_writer.writerow(row)
Excelete clase.
Solo unas acotaciones:
* En el ejemplo de agregar un nuevo elemento al archivo csv, el salto de línea inicial **file.write('\n')** es solo por única vez, ya que agrega un salto de línea al final de la última final del archivo. Esto solo se debe colocar una sola vez, para que todos los nuevos registros se agreguen en la siguiente línea del final del archivo actual.
* **csv\_writer**.**writerow**(**new\_product**) ---- > Esto registra el nuevo elemento, <u>pero agrega por defecto un salto de línea implícito al final de cada línea.</u>
* **csv**. **DictWriter(variable\_archivo, columnas\[])** ---- >**** Siempre pide el archivo a escribir y una colección de columnas que son las cabeceras del archivo.
Mi aporte con un ejercicio adicional:
* Agregar una columna nueva "is\_new".
* Tendrá valor "new" si el producto tiene como fecha de ingreso (entry\_date) >= 2024-05-01
* Caso contrario, será "old"
Este ejercicio toma como base (archivo original) el archivo "products\_updated\_01.csv" y generará un nuevo archivo "products\_updated\_02.csv". Ambos archivos en la carpeta raíz "archivos\_csv"
```js
import csv
from datetime import datetime
with open("archivos_csv/products_updated_01.csv", mode="r") as file:
date_format = "%Y-%m-%d"
fecha_evaluacion = datetime.strptime("2024-05-01",date_format)
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ["is_new"]
with open("archivos_csv/products_updated_02.csv", mode="w", newline='') as new_file:
csv_writer = csv.DictWriter(new_file,fieldnames=fieldnames)
csv_writer.writeheader()
for row in csv_reader:
fecha_datetime = datetime.strptime(row["entry_date"],date_format)
if(fecha_datetime >= fecha_evaluacion):
row["is_new"] = "new"
else:
row["is_new"] = "old"
csv_writer.writerow(row)
```
En Python, al asignar una variable, utilizas el signo igual (`=`). En el caso de `fieldnames = csv_reader.fieldnames`, estás asignando a la variable `fieldnames` el valor de `csv_reader.fieldnames`, que es una lista de nombres de columnas de un archivo CSV.
El carácter `_` se utiliza comúnmente en Python para mejorar la legibilidad de los nombres de variables, como en `campo_nombre`. En cambio, el `.` se usa para acceder a atributos de un objeto, como `csv_reader.fieldnames`, donde `csv_reader` es un objeto y `fieldnames` es su atributo que contiene los nombres de las columnas.
Para esta clase, creé mi propio archivo CSV con una personalización enfocada en motos. Realicé el reto propuesto, donde el campo **nombre** representa el modelo de la moto. Además, añadí una nueva columna que incluye la combinación de la **marca y el modelo** para darle un toque más completo y profesional a la tabla.
**CODIGO 🏍️:**
```js
import csv
main_file = 'products_motos.csv'
new_file = 'products_motos_update.csv'
with open(main_file, mode='r')as main_file:
csv_reader = csv.DictReader(main_file)
fieldname = csv_reader.fieldnames + ['totally_name']
with open(new_file, mode='w', newline='')as new_file:
csv_writer = csv.DictWriter(new_file, fieldnames=fieldname)
csv_writer.writeheader()
for row in csv_reader:
row['totally_name'] = str(row['brand']) + ' ' + str(row['name'])
csv_writer.writerow(row)
```
En Python, al abrir un archivo con `mode='a'`, se especifica que el archivo se abrirá en modo "append" o "adjuntar". Esto significa que cualquier dato que escribas se añadirá al final del archivo existente, en lugar de sobrescribir el contenido actual. Es útil para agregar nuevas líneas sin eliminar la información anterior. En el contexto de archivos CSV, es ideal para añadir nuevos registros a un inventario, por ejemplo.
analizando este curso y otros varios que he tomado, concluyo que a veces cuando lo que se intenta explicar se complica o enreda es porque no queda muy claro el algoritmo, es decir, que se esta haciendo. Porque ahi estan los metodos y herramientas del lenguaje, pero si no se entiende que se esta haciendo y para que, es dificil entender los conceptos.
```js
file_path = 'products_updated.csv'
updated_file_path = 'products_newfile.csv'
with open(file_path, 'r') as file:
csv_reader = csv.DictReader(file)
columnasnombres = csv_reader.fieldnames + ['Codigo_producto']
with open(updated_file_path, 'w', newline='') as nuevofile:
csv_writer = csv.DictWriter(nuevofile, fieldnames=columnasnombres)
csv_writer.writeheader()
for row in csv_reader:
row['Codigo_producto'] = row['price'][0]
csv_writer.writerow(row)
```Aquí esta el reto, aplique una nueva columna 'Codigo\_producto' y el valor que le asigne a cada product fue el primer número de su precio
Honestamente me costo mucho entender la clase, me quedaba trabado en la hora de la operación matematica al no entender que estaba haciendo con el codigo en esa parte, use ChatGPT y me ayudo a entenderlo bastante bien, me gusta mucho la maestra Carli Code, solo que siento que hay ocasiones que no es tan explicita sobre ciertos codigos y en estos podemos quedarnos atorados, realmente el usar chatgpt ayuda al pedirle la explicación paso a paso para entenderlo de mejor manera, pero igual admiro mucho a la maestra!
Hola.
Para el error que se presentaba al adicionarle el nuevo valor de la columna a los existentes, yo lo resolví de esta manera: ```python
fieldnames = list(csv_reader.fieldnames) + ['total_value'] if csv_reader.fieldnames is not None else ['total_value']
```fue validar que no fuera nada, si eso se cumplía se transformaba en una lista y hay si se le agregaba el nuevo valor de lo contrario solo devuelve el nuevo valor.
Para trabajar con archivos CSV en Python, debes tener un archivo CSV listo en tu computadora. Puedes crear uno en cualquier editor de texto y guardar el archivo con la extensión `.csv`, o puedes descargar un archivo CSV de internet que contenga datos tabulares.
Luego, en tu código Python, asegúrate de especificar la ruta correcta donde se encuentra el archivo cuando lo abras. Por ejemplo, si el archivo se llama `products.csv` y está en la misma carpeta que tu script, simplemente usa:
```python
import csv
with open('products.csv', mode='r') as file:
reader = csv.DictReader(file)
for row in reader:
print(row)
```
Así podrás leer los datos de ese archivo.
Cuando ves una "U" al final del nombre de un archivo, especialmente en Python, puede indicar que el archivo está en modo "unicode". Sin embargo, es poco común que esto aparezca en los nombres de archivos directamente. Es más probable que el "U" sea parte de la salida de un comando o una función que está imprimiendo el nombre del archivo. Asegúrate de revisar cómo se está generando o mostrando el nombre del archivo en tu código. Verifica que no haya un error en la concatenación de cadenas o en la forma en que se está manejando el archivo.
mi solución al reto, donde agrego las nuevas\_columnas = \['total','impuesto', 'precio\_total', 'vendidos']
aqui el reto, me ayudé con gpt para adicionar la fecha actual
import csvfrom datetime import datetime
file\_path = 'products\_updated.csv'updated\_file\_path = 'products\_updated2.csv'
current\_date = datetime.now().strftime('%Y-%m-%d')
with open('products\_updated.csv', mode='r') as file: csv\_reader = csv.DictReader(file) #obtener el nuro de columnas existentes fieldnames = csv\_reader.fieldnames + \['new\_date']
with open(updated\_file\_path, mode='w', newline='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader()#escribir los encabezados
for row in csv\_reader: row\['new\_date'] = current\_date csv\_writer.writerow(row)
Observación, en mi caso sí lo escribió de una y separada en una línea por debajo de la última información, probablemente porque tengo el rainbowcsv
Para que entiendan un poco mas sobre los CSV , les dejo el link de la documentación oficial de Python
<https://docs.python.org/es/3.8/library/csv.html>
Si, cuando se trata de Python para trabajar con archivos CSV es de tener mucho cuidado y seguramente muchas bases en algunos otros conceptos como Matrices y Vectores (En verdad eso te da un criterio espacial sobre los datos que se extraen, ingresan, alteran, etc)
Entonces, si, como otros, considero que es importante tener explicado, de una manera un poco mas grafica, previamente, los "Preconceptos" para que todo este codigo haga sentido.
Porque la clase empieza simplemente con un archivo, un concepto y ya, pero sin un preconcepto y para algunos que puede que no tengamos mucho conocimiento en Codigo y estructuras de datos, se vuelve aburridor o peor aun, frustrante.
La línea `writer = csv.DictWriter(file, fieldnames=new_product.keys())` crea un objeto `DictWriter` que permite escribir en un archivo CSV en formato de diccionario.
- `file` es el archivo abierto donde se escribirán los datos.
- `fieldnames=new_product.keys()` define los nombres de las columnas usando las llaves del diccionario `new_product`, asegurando que los datos se escriban en el orden correcto según las claves del diccionario.
Este enfoque es útil para mantener la integridad de los datos al agregar nuevas filas a un archivo CSV.
```js
import csv
file_path = 'products_updated.csv'
updated_file_path = 'products_updated2.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
filednames = csv_reader.fieldnames + ['sold']
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=filednames)
csv_writer.writeheader()
for row in csv_reader:
row['sold'] = 1000 - int(row['quantity'])
csv_writer.writerow(row)
```Mi aporte :)
Yo agregué tres columnas: día, mes y año.
Descubrí que el archivo: products.csv en el final de la línea 22 tiene un espacio que está siendo computado como parte de la fecha.
Por mi parte agregue las columnas descuento si el precio era mayor o igual a 550 y si había o no stock del producto
Si sientes que va muy rápido la explicación o no entiendes todos los conceptos te recomiendo que tomes "Curso de Fundamentos en Python" de Nicolas Molina, te quedara todo mucho mas claro, ya que explica los conceptos mas profundamente.
```txt
Asi lo pude resolver
```
```python
def contar_lineas(cuento):
with open (cuento, 'r') as file:
lineas = file.readlines()
return len(lineas)
cuento = 'cuento.txt'
num_lineas = contar_lineas(cuento)
print(f'{num_lineas} lineas ')
```
Así puede resolver el reto de contar las lineas
´´´
def contar\_lineas(cuento):
with open (cuento, 'r') as file:
lineas = file.readlines()
return len(lineas)
cuento = 'cuento.txt'
num\_lineas = contar\_lineas(cuento)
print(f'{num\_lineas} lineas ')
´´´
Adiciona las columnas recaudo (generada por un condicional), categoria, rango, mes
```js
import csv
file_path = 'data1.csv'
updated_file_path = 'data_updated.csv'
with open(file_path, mode='r', encoding='utf-8-sig') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['recaudo'] +['categoria']+['rango']+['mes']
with open(updated_file_path, mode='w', encoding='utf-8-sig',newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #Escribir los encabezados
for row in csv_reader:
if int(row['edad'])<50: row ['recaudo'] = '17000'
else: row ['recaudo'] = '5000'
row['categoria']='Adulto'
row['rango']='A'
row['mes']='Febrero'
csv_writer.writerow(row)
```
```js
import csv
# #Leer archivo
# with open('python-CSV/products.csv', mode='r' ) as file:
# csv_reader = csv.DictReader(file)
# for row in csv_reader:
# #Mostrando filas
# print("row", row)
# #Mostrando información por columnas
# with open('python-CSV/products.csv', 'r') as file:
# csv_reader = csv.DictReader(file)
# for row in csv_reader:
# print(f" Producto { row['name']} | Precio: { row['price'] }")
new_product = {
'name': 'Cargador inalambrico',
'price': 75,
'quantity':100,
'brand': 'Cargador master',
'category': 'Accesorios',
'entry_date': '2024-07-01'
}
# #Agregar información a in archivo ya creado
# with open('python-CSV/products.csv', mode='a', newline='') as file:
# file.write('\n')
# csv_writer = csv.DictWriter(file, fieldnames= new_product.keys())
# csv_writer.writerow(new_product)
#Agregar un nuevo documento
file_path = 'python-CSV/products.csv'
updated_file_path = 'python-CSV/new-products.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obteniendo los nombres de las columnas
field_names = csv_reader.fieldnames + ['total_value']
print("field_names", field_names)
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames= field_names)
#Escribiendo el encabezado
csv_writer.writeheader()
# Se itera el documento original para copairse y calcularse en uno nuevo
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
csv_writer.writerow(row)
print('row', row)
```
aquí está mi reto:
```python
import csv
file_path = "products.csv" #fichero original
updated_file_path = "product_updated.csv"
with open(file_path, mode="r") as file: #abrirlo en modo lectura para que podemos añadir esa información al nuevo documento
csv_reader = csv.DictReader(file)
#se obtienen los nombres de las columnas (encabezados) y se añade a "total value" entre estos:
fieldnames= csv_reader.fieldnames + ["total_value", "extra_stock"]
with open (updated_file_path, mode="w", newline="") as updated_file: #abrimos el nuevo archivo en modo escritura porque lo estamos creando desde cero
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #Se escriben los encabezados actualizados
with open (updated_file_path, mode="w", newline="") as updated_file: #abrimos el nuevo archivo en modo escritura porque lo estamos creando desde cero
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #Se escriben los encabezados actualizados
#Se calculan los "extra_stock" y se escriben los resultados en cada fila
for row in csv_reader:
price= float(row["price"])
quantity=int(row["quantity"])
row["total_value"] = round(price*quantity, 2)
row["extra_stock"] = "Yes" if quantity>50 else "No"
csv_writer.writerow(row)
```import csv
file\_path = "products.csv" #fichero originalupdated\_file\_path = "product\_updated.csv"
with open(file\_path, mode="r") as file: #abrirlo en modo lectura para que podemos añadir esa información al nuevo documento csv\_reader = csv.DictReader(file)
\#se obtienen los nombres de las columnas (encabezados) y se añade a "total value" entre estos: fieldnames= csv\_reader.fieldnames + \["total\_value", "extra\_stock"]
with open (updated\_file\_path, mode="w", newline="") as updated\_file: #abrimos el nuevo archivo en modo escritura porque lo estamos creando desde cero csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() #Se escriben los encabezados actualizados
with open (updated\_file\_path, mode="w", newline="") as updated\_file: #abrimos el nuevo archivo en modo escritura porque lo estamos creando desde cero csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() #Se escriben los encabezados actualizados
\#Se calculan los "extra\_stock" y se escriben los resultados en cada fila for row in csv\_reader: price= float(row\["price"]) quantity=int(row\["quantity"]) row\["total\_value"] = round(price\*quantity, 2)
row\["extra\_stock"] = "Yes" if quantity>50 else "No"
csv\_writer.writerow(row)
Holaa, les comparto mi codigo donde añado dos columnas mas uno con el valor del articulo en descuento y su porcentaje, donde hago un render condicional para determinar el porcentaje que tendra el articulo.
```js
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
new_columns = ['total_value', 'discount', 'percentage_discount']
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + new_columns
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #Escribir los encabezados
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
row['discount'] = float(row['price']) * 0.7 if row["category"] == "Electronics" else float(row['price']) * 0.9
row['percentage_discount'] = "30%" if row["category"] == "Electronics" else "10%"
csv_writer.writerow(row)
```import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'
new\_columns = \['total\_value', 'discount', 'percentage\_discount']
with open(file\_path, *mode*='r') as file: csv\_reader = csv.DictReader(file) #Obtener los nombres de las columnas existentes fieldnames = csv\_reader.fieldnames + new\_columns
with open(updated\_file\_path, *mode*='w', *newline*='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, *fieldnames*=fieldnames) csv\_writer.writeheader() #Escribir los encabezados
for row in csv\_reader: row\['total\_value'] = *float*(row\['price']) \* *int*(row\['quantity']) row\['discount'] = *float*(row\['price']) \* 0.7 if row\["category"] == "Electronics" else *float*(row\['price']) \* 0.9 row\['percentage\_discount'] = "30%" if row\["category"] == "Electronics" else "10%" csv\_writer.writerow(row)
Agregue una columna de descuento para aplicar al calculo del valor total.
Para la gente que empieza de cero y que se haya perdido como yo al seguir solo directamente las clases hechas con la gran Carli!. Les recomiendo marcar estos temas como objetivo principal ya que son muy buenas herramientas, es necesario complementar sus dudas sobre las clases con otros lugares donde puedan saciar estas dudas, por ejemplo, con las condicionales, modos, el acceso a archivos etc. En sí lo principal es aprender no importa de donde sea, si ya es por medio de inteligencia artificial, videos de youtube que pican en pedazitos acerca del respectivo tema, etc.
Esto como para recomendación y no se frustren por no entender lo que se ve directamente explicado aquí en Platzi. No paren de aprender sea donde sea ;) . ¡Saludos y espero les sirva!
El reto (input):
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Jan 22 18:45:37 2025
@author: david
"""
import csv
file_path = '/home/david/Downloads/csv/products.csv'
updated_file_path = '/home/david/Downloads/csv/products_updated.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ['total_price', 'sales'] # Add 'total_price' and 'sales' to the fieldnames
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() # Write the header
for row in csv_reader:
row['total_price'] = float(row['price']) * int(row['quantity']) # Calculate total price
row['sales'] = row['total_price'] # Assuming sales are the same as total_price
csv_writer.writerow(row) # Write the row with the new columns
print(f"File updated with total_price and sales: {updated_file_path}")
```El reto (output):
```js
name,price,quantity,brand,category,entry_date,total_price,sales
Laptop,1200,4,BrandName,Electronics,2024-01-05,4800.0,4800.0
Mouse,45,120,TechGear,Accessories,2024-02-10,5400.0,5400.0
Keyboard,70,60,KeyMasters,Accessories,2024-02-12,4200.0,4200.0
Monitor,320,15,ViewSharp,Electronics,2024-03-01,4800.0,4800.0
Headphones,150,25,SoundMax,Audio,2024-03-15,3750.0,3750.0
Webcam,85,40,ClearView,Electronics,2024-03-20,3400.0,3400.0
Printer,200,10,PrintWell,Office,2024-04-01,2000.0,2000.0
Tablet,400,30,TabZone,Electronics,2024-04-05,12000.0,12000.0
Smartphone,800,20,PhonePro,Electronics,2024-04-10,16000.0,16000.0
External Hard Drive,100,50,StoreMore,Storage,2024-05-01,5000.0,5000.0
Speaker,90,35,SoundMax,Audio,2024-05-05,3150.0,3150.0
Microphone,110,18,VoiceClear,Audio,2024-05-10,1980.0,1980.0
Charger,25,150,PowerPlus,Accessories,2024-05-15,3750.0,3750.0
USB Cable,10,200,CableWorld,Accessories,2024-05-20,2000.0,2000.0
Power Bank,60,80,ChargeIt,Accessories,2024-05-25,4800.0,4800.0
Router,150,25,NetSpeed,Networking,2024-06-01,3750.0,3750.0
Mouse Pad,20,100,ComfortZone,Accessories,2024-06-05,2000.0,2000.0
Laptop Stand,55,45,ErgoLift,Accessories,2024-06-10,2475.0,2475.0
Projector,550,8,ProView,Electronics,2024-06-15,4400.0,4400.0
Graphics Tablet,250,12,ArtMaster,Electronics,2024-06-20,3000.0,3000.0
Wireless Charger,75,100,ChargerMaster,Accessories,2024-07-01,7500.0,7500.0
Wireless Charger,75,100,ChargerMaster,Accesories,2025-22-01,7500.0,7500.0
```
Como parte del reto, incluí una nueva columna que indica el nivel de producto basando en el numero de la cantidad, si es mayor a 100 dará como valor High, si es mayor a 50 Medium y si esta por debajo será Low
```python
base_file = 'products.csv'
new_file = 'products_updated.csv'
with open(base_file, 'r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldNames = csv_reader.fieldnames + ['total_value'] + ['quantity_level']
with open(new_file, 'w') as newFile:
csv_writer = csv.DictWriter(newFile, fieldnames=fieldNames)
#escribir encabezados
csv_writer.writeheader()
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
row['quantity_level'] = 'High' if int(row['quantity']) > 100 else 'Medium' if int(row['quantity']) > 50 else 'Low'
csv_writer.writerow(row)
```
Mi aporte hace una comparación de que si el stock es mayor a 50, se le puede vender a mayoristas de lo contrario no es permitido. import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'
with open(file\_path, mode='r') as file: csv\_reader = csv.DictReader(file) #Obtener los nombres de las columnas existentes fieldnames = csv\_reader.fieldnames + \['total\_value', 'wholesaler']
with open(updated\_file\_path, mode='w', newline='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() #Escribir los encabezados #Calcular el valor total for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) #Condicionar la disponibilidad para mayoristas if int(row\['quantity']) >= 50: row\['wholesaler'] = "Avaible" else: row\['wholesaler'] = "Not Avaible" #Escribir la fila actualizada csv\_writer.writerow(row)
```js
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value', 'wholesaler']
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #Escribir los encabezados
#Calcular el valor total
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
#Condicionar la disponibilidad para mayoristas
if int(row['quantity']) >= 50:
row['wholesaler'] = "Avaible"
else:
row['wholesaler'] = "Not Avaible"
#Escribir la fila actualizada
csv_writer.writerow(row)
```
**Further details about handling CSV files in Python**: <https://www.geeksforgeeks.org/working-csv-files-python/>
## **What is a CSV File?**
**CSV** (Comma Separated Values) is a simple **file format** used to store tabular data, such as a spreadsheet or database. A CSV file stores tabular data (numbers and text) in plain text. Each line of the file is a data record. Each record consists of one or more fields, separated by commas. The use of the comma as a field separator is the source of the name for this file format. For working CSV files in Python, there is an inbuilt module called CSV.
hola, aqui dejo mi experimento jjj, estuvo chevere
`import csv, os, random`
`fileOriginal = os.getcwd()+r"\platzy\manejoArchivos\csv\products.csv"fileUpdate = os.getcwd()+r"\platzy\manejoArchivos\csv\products_updated.csv"with open(fileOriginal, mode='r') as file: # abre el archivo en modo lectura # file.write('\n') # agrega un salto de linea al archivo a editar csv_reader = csv.DictReader(file) # formatea en modo de diccionario # Obtener los nombres de las columnas existentes fieldnames = csv_reader.fieldnames # obtiene el nombre de las columnas print(fieldnames) newColumns = ['total_value', 'columnaReto1', 'columnaReto2'] # nombre de la nueva columna for nc in newColumns: print(nc) fieldnames = fieldnames + [nc] # agrega la nueva columna print(fieldnames) with open(fileUpdate, mode='w', newline='') as fileUpdate: # referencia la ubicacion del nuevo archivo csv_writer = csv.DictWriter(fileUpdate, fieldnames=fieldnames) # set nuevas columnas print("csv_writer") print(csv_writer) print("///////////////") csv_writer.writeheader() # escribir encabezados for row in csv_reader: # recorre las filas del file original y guarda en el archivo nuevo con los ajustes for nw in newColumns: if nw == 'total_value': row[nw] = float(row['price']) * int(row['quantity'])# agrega la nueva columna para cada fila con su respectivo valor else: row[nw] = random.randint(100, 1000) # agrega la nueva columna para cada fila con su respectivo valor csv_writer.writerow(row)`
Es algo ficil de entender, de mi parte busque cada metodo y funcion que se vio en el video y leei sobre que se trataba pues la profe las escribio, pero en mi opinion pienso que falto hacer enfasis en los metodos de csv como por ejeplo el fieldnames que se uso como variable y funcion al mismo tiempo.
me pasa lo mismo que en el ejercicio anterior de archivos TXT no veo nada en la terminal de VSC no se que es. alguien me puede orientar. mil gracias.
Pongo por aca mi version. Agregue una impresion que salga en columnas organizadas usando pandas.import <u>pandas</u> as <u>pd</u>import <u>csv</u>
source = 'products.csv'destination = 'products\_updated.csv'
with open(source, *mode*='r') as origin: csv\_reader = <u>csv</u>.<u>DictReader</u>(origin) field\_names = csv\_reader.fieldnames + \['total\_value'] #Se preparan los campos para la nueva fila
with open(destination, *mode*='w') as result: csv\_writer = <u>csv</u>.<u>DictWriter</u>(result, field\_names) #Se indica el nuevo archivo con las nuevas columnas csv\_writer.writeheader() #Crear el encabezado
for row in csv\_reader: row\['total\_value'] = <u>float</u>(row\['price']) \* <u>int</u>(row\['quantity']) #Se crea la fila final con la operacion directa csv\_writer.writerow(row)
impresion = <u>pd</u>.read\_csv(destination)print(impresion)
```python
import pandas as pd
import csv
source = 'products.csv'
destination = 'products_updated.csv'
with open(source, mode='r') as origin:
csv_reader = csv.DictReader(origin)
field_names = csv_reader.fieldnames + ['total_value'] #Se preparan los campos para la nueva fila
with open(destination, mode='w') as result:
csv_writer = csv.DictWriter(result, field_names) #Se indica el nuevo archivo con las nuevas columnas
csv_writer.writeheader() #Crear el encabezado
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity']) #Se crea la fila final con la operacion directa
csv_writer.writerow(row)
impresion = pd.read_csv(destination)
print(impresion)
```
```js
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value'] + ['status'] # agregar la nueva columna status
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #Escribir los encabezados
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
row['status'] = 'disponible' # Dar valor a status en cada fila
csv_writer.writerow(row)
```import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'
with open(file\_path, mode='r') as file: csv\_reader = csv.DictReader(file) #Obtener los nombres de las columnas existentes fieldnames = csv\_reader.fieldnames + \['total\_value'] + \['status'] # agregar la nueva columna status
with open(updated\_file\_path, mode='w', newline='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() #Escribir los encabezados
for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) row\['status'] = 'disponible' # Dar valor a status en cada fila csv\_writer.writerow(row)
En que parte de la clase se diseño el archivo products.cvs.py?
Estoy perdido al busvcar programar en paralelo con el curso.
Gracias
Manejo de Archivos CSV (CLASE NUEVA)
Se usa import csv
mode = w es modo de escritura
He agregado una nueva columna que suma el año y la cantidad
```js
import csv
file_path = 'products.csv'
update_file_path = 'update_products.csv'
with open(file_path, mode='r') as file_csv:
csv_reader = csv.DictReader(file_csv)
fieldnames = csv_reader.fieldnames + ['total_value', 'ageplus']
with open(update_file_path, mode='w', newline='') as update_file:
csv_writer = csv.DictWriter(update_file, fieldnames=fieldnames)
csv_writer.writeheader()
for row in csv_reader:
row['total_value'] = float(int(row['price']) * int(row['quantity']))
row['ageplus'] = int(row['entry_date'].split('-')[0]) + int(row['quantity'])
csv_writer.writerow(row)
```
RETO: Pude crear nuevas columnas empleando condicionales. Bastante interesante el ejercicio!! :)
```python
import csv
old_file = 'products_updated.csv'
new_file = 'productos_available.csv'
with open(old_file, mode='r') as file:
csv_reader = csv.DictReader(file)
# fieldnames es para obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['availability'] # Nueva columna en la fila de titulos
with open(new_file, mode='w', newline='') as updated_faile_2: # Abrir el nuevo archivo en modo de escritura con salto de linea como string vacio
csv_writer = csv.DictWriter(updated_faile_2, fieldnames = fieldnames) # csv.DictWriter('nombre del archivo','nombre de las columnas')
csv_writer.writeheader() # Escribir los encabezados
for row in csv_reader:
if row['category'] == 'Accessories':
row['availability'] = 'Not available'
elif row['category'] == 'Audio':
row['availability'] = 'Available Soon'
else:
row['availability'] = 'Available'
csv_writer.writerow(row)
```
Me esta dando este error y no entiendo por que pasa.
RETO:
import csv
\# Creamos las dos variables para ingresar archivo origen y archivo nuevo
file\_original = 'products.csv'
file\_updated = 'new\_product.csv'
with open(file\_original, mode='r') as file:
csv\_reader = csv.DictReader(file)
\# Obtener los nombres de las columnas existentes
fieldnames = csv\_reader.fieldnames + \['total\_value'] + \['price\_sell'] + \['stock'] + \['profit']
with open(file\_updated, mode='w', newline='') as fileup:
csv\_writer = csv.DictWriter(fileup, fieldnames=fieldnames)
csv\_writer.writeheader() # Escribir Información encabezados
for row in csv\_reader:
row\['total\_value'] = float(row\['price']) \* int(row\['quantity'])
row\['price\_sell'] = int(row\['price']) + (int(row\['price']) \* float(60 / 100))
row\['stock'] = int(row\['quantity']) + float(80 / 100)
row\['profit'] = int(row\['price']) \* float(40 / 100)
csv\_writer.writerow(row)
El error que estás encontrando indica que el diccionario que intentas escribir con `csv_writer.writerow(row)` contiene campos que no están definidos en `fieldnames`. Para corregir esto, asegúrate de que todas las claves del diccionario `row` coincidan exactamente con los nombres de columna que especificaste al crear el `csv_writer`.
1. Revisa que tus claves en el diccionario de `row` estén correctamente escritas y que sean las mismas que las definidas en `fieldnames`.
2. Si has añadido nuevas columnas al diccionario, asegúrate de incluir sus nombres en la lista de `fieldnames` que usaste al inicializar el escritor.
Corrigiendo estos detalles, el problema debería resolverse.
Les comparto una página (puedan obtener data). Viene en otros cursos de python (por si no la tienen). Página: <https://www.kaggle.com/>
```python
import csv
import random as rn
#Se añaden dos columnas
#descuento aleatorio y precio con descuento
file_path = "28. products.csv"
updated_file_path = "28. ejercicio_products.csv"
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ['discount']
fieldnames = fieldnames + ['price_discount']
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader()
for row in csv_reader:
row['discount'] = int(rn.randint(0, 30))
row['price_discount'] = int(row['price']) - (int(row['discount']) * int(row['price']) / 100)
csv_writer.writerow(row)
```
```js
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value'] + ['color']
with open(updated_file_path, mode='w', newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() #Escribir los encabezados
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
row['color'] = 'GREEN'
csv_writer.writerow(row)
```*import* csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'
*with* open(file\_path, mode='r') *as* file: csv\_reader = csv.DictReader(file) *#Obtener nombres de las columnas existentes* fieldnames = csv\_reader.fieldnames + \['total\_value'] + \['color']
*with* open(updated\_file\_path, mode='w', newline='') *as* updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() *#Escribir los encabezados*
*for* row *in* csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) row\['color'] = 'GREEN' csv\_writer.writerow(row)
Hola,no puedo uilizar writeheader ni writerow. Debo instalar alguna biblioteca? Gracias.
Excelente clase.
Mi aporte al ejercicio import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'
with open(file\_path, mode = 'r') as file: csv\_reader = csv.DictReader(file) #Obtener los nombres de las columnas existentes fieldnames = csv\_reader.fieldnames + \['total\_value'] + \['discount\_price (80%)']
with open(updated\_file\_path , mode = 'w', newline="") as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames = fieldnames) csv\_writer.writeheader() #Escribir los encabezados
for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) row\['discount\_price (80%)'] = float(row\['price']) \* 0.80 csv\_writer.writerow(row)
añadí una fila con un valor de descuento al 80%
```python
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
with open(file_path, mode = 'r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value'] + ['discount_price (80%)']
with open(updated_file_path , mode = 'w', newline="") as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames = fieldnames)
csv_writer.writeheader() #Escribir los encabezados
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
row['discount_price (80%)'] = float(row['price']) * 0.80
csv_writer.writerow(row)
```
En Python, las rutas de archivos en sistemas Windows utilizan barras invertidas (``) como separadores de directorios. Sin embargo, Python también usa la barra invertida como un carácter especial llamado **secuencia de escape** (por ejemplo, `\n` para nueva línea, `\t` para tabulación).
Si usamos una barra invertida simple en una ruta, Python podría interpretar mal algunas combinaciones de caracteres. Para evitar este problema, podemos usar dos enfoques:
1. **Doble barra invertida (**`\`**)**: Esto le indica a Python que trate cada barra invertida como un carácter literal y no como una secuencia de escape.
2. **Cadenas sin procesar (**`r'...'`**)**: Estas permiten que las barras invertidas se interpreten literalmente, sin necesidad de usar `\`.
Es buena práctica utilizar **doble barra invertida (**`\`**)** si no estás usando una cadena sin procesar (`r'...'`). A continuación, te muestro un ejemplo de cómo hacerlo correctamente:
```js
import csv
# Se crea un nuevo producto
nuevoProducto = {
'name': 'S21 Ultra',
'price': 2000000,
'quantity': 5000,
'brand': 'Samsung',
'category': 'Tecnologia',
'entry_date': '02/10/2024'
}
# Agrega información al final del archivo
with open('D:\\Platzi\\PROGRAMACION\\Curso Python\\products.csv', 'a', newline='', encoding='utf-8') as file:
leerCsv = csv.DictWriter(file, fieldnames = nuevoProducto.keys())
leerCsv.writerow(nuevoProducto)
# Lee la información y la muestra por consola acorde a las columnas especificadas
with open('D:\\Platzi\\PROGRAMACION\\Curso Python\\products.csv', mode='r', encoding='utf-8') as file:
leerCsv = csv.DictReader(file)
for row in leerCsv:
print(f"Nombre: {row['name']}, Precio: {row['price']}, Cantidad: {row['quantity']}")
```import csv
\# Se crea un nuevo producto
nuevoProducto = {
'name': 'S21 Ultra',
'price': 2000000,
'quantity': 5000,
'brand': 'Samsung',
'category': 'Tecnologia',
'entry\_date': '02/10/2024'
}
\# Agrega información al final del archivo
with open('D:\\\Platzi\\\PROGRAMACION\\\Curso Python\\\products.csv', 'a', newline='', encoding='utf-8') as file:
leerCsv = csv.DictWriter(file, fieldnames = nuevoProducto.keys())
leerCsv.writerow(nuevoProducto)
\# Lee la información y la muestra por consola acorde a las columnas especificadas
with open('D:\\\Platzi\\\PROGRAMACION\\\Curso Python\\\products.csv', mode='r', encoding='utf-8') as file:
leerCsv = csv.DictReader(file)
for row in leerCsv:
print(f"Nombre: {row\['name']}, Precio: {row\['price']}, Cantidad: {row\['quantity']}")
Hice uno en el cual agrego 3 columnas en una sola sentencia para calcular los distintos porcentajes del total\_value
los colores los conseguí por una extensión que se llama rainbow csv, la recomiendo
Carli, saludos excelentes,clases, por favor, sería posible que hagas mas clases de automatizaciones, scripts,asi como hiciste el de las imagenes, Gracias
Hola a todos, esta es mi propuesta de solución al reto planteado:
\# Obtener los nombres de las columnas existentes y se agrega nombre de 2 columnas nuevas: total\_value e iva fieldnames = csv\_reader.fieldnames + \['total\_value'] + \['iva']
with open(updated\_file\_path, mode='w', newline='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() # Escribir encabezados
# Se calculan los valores por filas de la nuevas columnas for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) row\['iva'] = float(row\['price']) \* 0.2 csv\_writer.writerow(row)
Un CSV es un formato común para almacenar datos en forma de tabla, como en una hoja de cálculo, usando comas o a veces otros delimitadores para separar los valores.
csv.reader(): Para leer archivos CSV fila por fila.
csv.writer(): Para escribir listas de datos en un archivo CSV.
DictReader(): Para leer archivos CSV como diccionarios.
DictWriter(): Para escribir diccionarios en un archivo CSV.
## **Manejo de Archivos CSV**
Python ofrece un módulo integrado llamado `csv` que facilita la lectura y escritura de archivos CSV. A continuación, te muestro cómo usarlo.
### 1. Importar el módulo CSV
Antes de trabajar con archivos CSV, necesitas importar el módulo:
Copiar código
import csv
### 2. Leer un archivo CSV
### a) Usando `csv.reader`
Para leer un archivo CSV, puedes usar `csv.reader()`, que te permite leer el archivo fila por fila.
**Código de ejemplo**:
with open('archivo.csv', mode='r') as file:
csv\_reader = csv.reader(file)
for row in csv\_reader:
print(row) # Cada fila se imprime como una lista
### b) Usando `csv.DictReader`
Si prefieres trabajar con diccionarios (donde cada fila es un diccionario con claves que son los encabezados), puedes usar `csv.DictReader()`.
**Código de ejemplo**:
with open('archivo.csv', mode='r') as file:
csv\_reader = csv.DictReader(file)
for row in csv\_reader:
print(f"Nombre: {row\['nombre']}, Edad: {row\['edad']}, Ciudad: {row\['ciudad']}")
### 3. Escribir en un archivo CSV
Para escribir datos en un archivo CSV, puedes usar `csv.writer()` o `csv.DictWriter()`.
### a) Usando `csv.writer`
Con `csv.writer()`, puedes escribir filas en formato de lista.
**Código de ejemplo**:
with open('nuevo\_archivo.csv', mode='w', newline='') as file:
csv\_writer = csv.writer(file)
csv\_writer.writerow(\['nombre', 'edad', 'ciudad']) # Escribir encabezados
csv\_writer.writerow(\['Juan', 30, 'México'])
csv\_writer.writerow(\['Ana', 25, 'Colombia'])
### b) Usando `csv.DictWriter`
Con `csv.DictWriter()`, puedes escribir diccionarios en el archivo CSV.
**Código de ejemplo**:
with open('nuevo\_archivo.csv', mode='w', newline='') as file:
fieldnames = \['nombre', 'edad', 'ciudad']
csv\_writer = csv.DictWriter(file, fieldnames=fieldnames)
csv\_writer.writeheader() # Escribir encabezados
csv\_writer.writerow({'nombre': 'Juan', 'edad': 30, 'ciudad': 'México'})
csv\_writer.writerow({'nombre': 'Ana', 'edad': 25, 'ciudad': 'Colombia'})
### 4. Opciones adicionales al trabajar con archivos CSV
### a) Manejo de delimitadores
Por defecto, `csv.reader()` y `csv.writer()` utilizan comas como delimitadores. Si tu archivo CSV utiliza otro delimitador, como un punto y coma, puedes especificarlo usando el argumento `delimiter`.
**Código de ejemplo**:
with open('archivo.csv', mode='r') as file:
csv\_reader = csv.reader(file, delimiter=';')
for row in csv\_reader:
print(row)
### b) Manejo de nuevas líneas
Al abrir un archivo para escritura, es recomendable usar `newline=''` para evitar problemas de saltos de línea adicionales en algunas plataformas.
### 5. Consejos y buenas prácticas
* **Manejo de excepciones**: Es buena práctica manejar excepciones al trabajar con archivos. Puedes usar `try` y `except` para manejar errores como archivos no encontrados.try:
with open('archivo.csv', mode='r') as file:
\# Leer el archivo
except FileNotFoundError:
print("El archivo no fue encontrado.")
* **Cerrar archivos**: Usar `with` asegura que el archivo se cierre correctamente, incluso si ocurre un error.
* **Validar datos**: Asegúrate de validar los datos que estás leyendo o escribiendo para evitar errores.
Excelente clase ya que es una tarea cotidiana en python trabajar con archivos CSV. Por favor sigan creando este tipo de clases.
```js
import csv
# crear una variable que tendra asignado el archivo actual y otra para el nuevo archivo
file_path = 'Análisis Exploratrio de Datos\python\Manejo de Archivos\products.csv'
updated_file_path = 'products_updated.csv'
# utilizando el metodo de Reading and Writing Files
#vamos a abrir el archivo en modo lesctura, donde vamos sacar toda la info y crearle un nueva columna
with open(file_path, mode='r') as file:
#creamos una variable que tendra la info del archivo en forma de diccionario
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
# y agregamos una nueva columna
fieldnames= csv_reader.fieldnames + ['total_value'] + ['total_sell'] + ['quantity_available']
# anteriormente leimos el archivo e identificamos las columnas y agregamos las nuevas
# ahora vamos a abrir el nuevo archivo con el metodo de escritura
with open(updated_file_path, mode='w', newline='') as updated_file:
# creamos una variable que va a recibir a traves del metodo de escribir un diccionario el objeto del metodo y la varialbe que tiene los nombres de las columnas.
csv_writer = csv.DictWriter(updated_file, fieldnames= fieldnames)
csv_writer.writeheader() #Escribir los encabezados
# vamos a calcular el valor que se asignara a cada registo para la columna total value.
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
row['total_sell'] = int(4)
row['quantity_available'] = int(int(row['quantity']) - row['total_sell'] )
csv_writer.writerow(row)
```import csv
\# crear una variable que tendra asignado el archivo actual y otra para el nuevo archivo
file\_path = 'Análisis Exploratrio de Datos\python\Manejo de Archivos\products.csv'updated\_file\_path = 'products\_updated.csv'
\# utilizando el metodo de Reading and Writing Files#vamos a abrir el archivo en modo lesctura, donde vamos sacar toda la info y crearle un nueva columna
with open(file\_path, mode='r') as file: #creamos una variable que tendra la info del archivo en forma de diccionario csv\_reader = csv.DictReader(file) #Obtener los nombres de las columnas existentes # y agregamos una nueva columna fieldnames= csv\_reader.fieldnames + \['total\_value'] + \['total\_sell'] + \['quantity\_available'] # anteriormente leimos el archivo e identificamos las columnas y agregamos las nuevas # ahora vamos a abrir el nuevo archivo con el metodo de escritura with open(updated\_file\_path, mode='w', newline='') as updated\_file: # creamos una variable que va a recibir a traves del metodo de escribir un diccionario el objeto del metodo y la varialbe que tiene los nombres de las columnas. csv\_writer = csv.DictWriter(updated\_file, fieldnames= fieldnames) csv\_writer.writeheader() #Escribir los encabezados # vamos a calcular el valor que se asignara a cada registo para la columna total value. for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) row\['total\_sell'] = int(4) row\['quantity\_available'] = int(int(row\['quantity']) - row\['total\_sell'] ) csv\_writer.writerow(row)
import csv
\# crear una variable que tendra asignado el archivo actual y otra para el nuevo archivo
file\_path = 'Análisis Exploratrio de Datos\python\Manejo de Archivos\products.csv'updated\_file\_path = 'products\_updated.csv'
\# utilizando el metodo de Reading and Writing Files#vamos a abrir el archivo en modo lesctura, donde vamos sacar toda la info y crearle un nueva columna
with open(file\_path, mode='r') as file: #creamos una variable que tendra la info del archivo en forma de diccionario csv\_reader = csv.DictReader(file) #Obtener los nombres de las columnas existentes # y agregamos una nueva columna fieldnames= csv\_reader.fieldnames + \['total\_value'] + \['total\_sell'] + \['quantity\_available'] # anteriormente leimos el archivo e identificamos las columnas y agregamos las nuevas # ahora vamos a abrir el nuevo archivo con el metodo de escritura with open(updated\_file\_path, mode='w', newline='') as updated\_file: # creamos una variable que va a recibir a traves del metodo de escribir un diccionario el objeto del metodo y la varialbe que tiene los nombres de las columnas. csv\_writer = csv.DictWriter(updated\_file, fieldnames= fieldnames) csv\_writer.writeheader() #Escribir los encabezados # vamos a calcular el valor que se asignara a cada registo para la columna total value. for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) row\['total\_sell'] = int(4) row\['quantity\_available'] = int(int(row\['quantity']) - row\['total\_sell'] ) csv\_writer.writerow(row)
Existe alguna configuración para el visual studio code, para la acción de abrir un archivo cvs, es que estoy intentando abrir el archivo de producto y agregarle una nueva linea, pero el lugar de eso, me esta creando otro archivo
```js
# Utilizo el código
with open('products.csv', mode='a', newline='') as file:
file.write('\n')
csv_writer = csv. DictWriter(file, fieldnames = new_product.keys())
csv_writer.writerow(new_product)
# Donde el mode es 'a', pero se comporta como si fuera 'w'
```
```python
import csv
file_path = 'products.csv'
updated_file_path = 'product_updated.csv'
with open('products.csv', mode ='r') as file:
csv_reader = csv.DictReader(file)
#Obtener el nombre de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value'] + ['+_iva']
with open(updated_file_path, mode ='w', newline = '') as updated_file_path:
csv_writer = csv.DictWriter(updated_file_path, fieldnames = fieldnames)
csv_writer.writeheader() #Escribir los encabezados
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
#Aquí se genera la columna con el price más IVA
row['+_iva'] = float(row['total_value']) + (float(row['total_value']) * 0.19)
csv_writer.writerow(row)
```
Le traigo mi codigo, en este caso, lo que aumente es para saber si el codigo tiene dato grande si el total\_value es mas 2000, aqui mi codigo:
```js
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
with open(file_path, mode= 'r') as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ['total_values'] + ['values_big']
with open(updated_file_path, mode= 'w', newline= '') as updated_files:
csv_writer = csv.DictWriter(updated_files, fieldnames= fieldnames)
csv_writer.writeheader()
for row in csv_reader:
row['total_values'] = float(row['price']) * int(row['quantity'])
if row['total_values'] > 2000:
row['values_big'] = 'dato grande'
else:
row['values_big'] = 'dato chico'
csv_writer.writerow(row)
```import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'
with open(file\_path, mode= 'r') as file: csv\_reader = csv.DictReader(file) fieldnames = csv\_reader.fieldnames + \['total\_values'] + \['values\_big'] with open(updated\_file\_path, mode= 'w', newline= '') as updated\_files: csv\_writer = csv.DictWriter(updated\_files, fieldnames= fieldnames) csv\_writer.writeheader() for row in csv\_reader: row\['total\_values'] = float(row\['price']) \* int(row\['quantity']) if row\['total\_values'] > 2000: row\['values\_big'] = 'dato grande' else: row\['values\_big'] = 'dato chico' csv\_writer.writerow(row)
Tengo problemas para importar los archivos. He investigado y tengo el .csv en la misma carpeta que tengo guardado mi programa .py, y aún así me dice que no encuentra el archivo.
Alguien me podría ayudar?
Probé ingresando la ruta del archivo y me dice lo mismo. La verdad no puedo avanzar ni importar ningún archivo.
FileNotFoundError: \[Errno 2] No such file or directory: 'products.csv'
Le añadí una nueva columna con un descuento de 10% en caso haya un stock menor a 50. (Usé mi propio archivo CSV)
import csv
file_path = "products.csv"
updated_file_path = "products_updated.csv"
with open(file_path, mode="r") as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ["total_value"] + ["descuento"]
with open(updated_file_path, mode="w", newline="") as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader()
for row in csv_reader:
row["total_value"] = float(row["Price"]) * int(row["Stock"])
if int(row["Stock"])<50:
row["descuento"] = "10 %"
else:
row["descuento"] = "Sin descuento"
csv_writer.writerow(row)
Es sencilla la idea, pero la primera vez me costo ya que repetía el código y no es necesario, solo es ir añadiendo las variantes dentro del mismo como si fueran sumas de listas.
Logre añadirle dos columnas más, y fue con un modulo de serial.
```js
import csv
import uuid
file_path = 'Archivos\products.csv'
updated_file_path = 'Archivos\products_updated.csv'
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value'] + ['location'] + ['Serial']# Se añade el nombre de la nueva columna
with open(updated_file_path, mode ='w', newline = '') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames = fieldnames)
csv_writer.writeheader() # Se escribe la cabecera con los nombres de las columnas
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity']) # Se calcula el valor total
row['location'] = 'Bodega' # Se calcula la ubicación
row['Serial'] = str(uuid.uuid4())
csv_writer.writerow(row)
```
asi es como lo interprete, espero me corrijan si hay algo que no lo entendi de la mejor manera. gracias
Un resumen, Linea por Linea, es con ayuda de Copilot,
pero lo entendi mejor.
![]()import csv
file\_path = 'files/products.csv'updated\_file\_path = 'files/products\_updated.csv'
\#Apertura del archivo original en modo lecturawith open(file\_path, mode='r') as file:
\#Crea un objeto DictReader que leera el archivo file csv\_reader = csv.DictReader(file)
\#Obtiene los nombres de las columnas existentes y añade una nueva columna llamada total\_value. fieldnames = csv\_reader.fieldnames + \['total\_value']
#Abre el archivo products\_updated.csv en modo escritura ('w') with open(updated\_file\_path, mode='w', newline='') as updated\_file:
\#y crea un objeto DictWriter para escribir los datos. . csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() #Escribe los encabezados de las columnas en el nuevo archivo
#Itera sobre cada fila del archivo original, calcula el valor total (total\_value)
\# multiplicando el precio (price) por la cantidad (quantity), # y escribe la fila actualizada en el nuevo archivo. for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) csv\_writer.writerow(row)
```python
# Contar lineas del archivo
counter_lines = 0
lines = []
with open(file_path, "r") as file:
for line in file:
if line.strip() != '':
lines.append(line.strip())
counter_lines += 1
# print(lines)
print("Filas con contenido - ", len(lines))
print("Lineas totales - ", counter_lines)
```
```js
import csv
with open('products_updated.csv', mode ='r') as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ['IGV','cost']
with open('products_updated.csv', mode ='w', newline='') as file2:
csv_writer = csv.DictWriter(file2,fieldnames=fieldnames)
csv_writer.writeheader()
for row in csv_reader:
row['IGV'] = float(row['total_value'])*0.18
row['cost']= float(row['price'])*0.50
csv_writer.writerow(row)
```
```python
import csv
file_path= '/Users/luisdeleon/Documents/prueba_python/productos.csv'
updated_file_path = '/Users/luisdeleon/Documents/prueba_python/productos_updated.csv'
with open(file_path,mode='r') as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ['total_value']
with open(updated_file_path,mode='w',newline='') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames = fieldnames)
csv_writer.writeheader()
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
csv_writer.writerow(row)
```
Hola a todos! Yo tuve un problema de ruta, les dejo material de apoyo por si tienen el problema: "SyntaxError: invalid syntax" y no sabian sobre la ruta:
import os
\# Verifica si el archivo existe en la ruta actualif os.path.isfile('products\_updated.csv'): print(f"El archivo {'products\_updated.csv'} está en la misma ruta que el script.")else: print(f"El archivo {'products\_updated.csv'} NO está en la misma ruta que el script.")
import os
\# Obtiene la ruta del directorio actualruta\_actual = os.getcwd()print(f"La ruta actual es: {ruta\_actual}")
En que momento paso de python a chino jaja
```python
import csv
file_patch = '/Users/meridian/Library/Mobile Documents/com~apple~CloudDocs/Python/Curso Python/ImportarCSV/products.csv'
update_file_patch = '/Users/meridian/Library/Mobile Documents/com~apple~CloudDocs/Python/Curso Python/ImportarCSV/product_updatev2.csv'
print("Que incremento en porcentaje desea realizar a sus precios para el 2025: ")
ipc=float(input())
ipc = ipc /100
with open(file_patch, mode='r') as file:
csv_reader = csv.DictReader(file)
#Obtener los nombre de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_values'] + ['increase_value']
with open(update_file_patch, mode='w', newline='') as update_file:
csv_writer = csv.DictWriter(update_file, fieldnames=fieldnames)
csv_writer.writeheader() #Escribir los encabezados
for row in csv_reader:
row['total_values'] = float(row['price']) * int(row['quantity'])
row['increase_value'] = float(row['price']) * (1+ipc)
csv_writer.writerow(row)
```import csv
file\_patch = '/Users/meridian/Library/Mobile Documents/com~apple~CloudDocs/Python/Curso Python/ImportarCSV/products.csv'update\_file\_patch = '/Users/meridian/Library/Mobile Documents/com~apple~CloudDocs/Python/Curso Python/ImportarCSV/product\_updatev2.csv'print("Que incremento en porcentaje desea realizar a sus precios para el 2025: ")ipc=float(input())ipc = ipc /100
with open(file\_patch, mode='r') as file: csv\_reader = csv.DictReader(file) #Obtener los nombre de las columnas existentes fieldnames = csv\_reader.fieldnames + \['total\_values'] + \['increase\_value']
with open(update\_file\_patch, mode='w', newline='') as update\_file: csv\_writer = csv.DictWriter(update\_file, fieldnames=fieldnames) csv\_writer.writeheader() #Escribir los encabezados for row in csv\_reader: row\['total\_values'] = float(row\['price']) \* int(row\['quantity']) row\['increase\_value'] = float(row\['price']) \* (1+ipc) csv\_writer.writerow(row)
Aquí ya me perdí, que es CSV y para que sirve??
Hola, dejo mi aporte. Agradecería algún tipo de retroalimentación, Gracias!import csv
file\_path = 'products\_updated.csv'
updated\_file = 'products\_updated\_2.csv'
with open(file\_path, mode='r') as file: csv\_reader=csv.DictReader(file) #Obtener los nombres de las columnas existentes fieldnames = csv\_reader.fieldnames + \['total\_value', 'Paulo16']
with open(updated\_file, mode='w', newline='') as update\_file: csv\_writer =csv.DictWriter(update\_file, fieldnames=fieldnames) csv\_writer.writeheader()#Escribir encabezado
for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) row\['Paulo16'] = "Paulo" csv\_writer.writerow(row)```js
import csv
file_path = 'products_updated.csv'
updated_file = 'products_updated_2.csv'
with open(file_path, mode='r') as file:
csv_reader=csv.DictReader(file)
#Obtener los nombres de las columnas existentes
fieldnames = csv_reader.fieldnames + ['total_value', 'Paulo16']
with open(updated_file, mode='w', newline='') as update_file:
csv_writer =csv.DictWriter(update_file, fieldnames=fieldnames)
csv_writer.writeheader()#Escribir encabezado
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
row['Paulo16'] = "Paulo"
csv_writer.writerow(row)
```
import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'discount\_file = 'discount\_products.csv'
\# Leer el archivo original y calcular total\_valuewith open(file\_path, mode='r') as file: csv\_reader = csv.DictReader(file) fieldnames = csv\_reader.fieldnames + \['total\_value']
with open(updated\_file\_path, mode='w', newline='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader()
for row in csv\_reader: # Calcular el total value row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) csv\_writer.writerow(row)
\# Leer nuevamente el archivo original para calcular descuentoswith open(file\_path, mode='r') as file: csv\_reader = csv.DictReader(file) fieldnames\_discount = csv\_reader.fieldnames + \['precio\_con\_descuento']
with open(discount\_file, mode='w', newline='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames\_discount) csv\_writer.writeheader()
for row in csv\_reader: # Calcular el precio con descuento de $10 precio\_original = float(row\['price']) precio\_con\_descuento = precio\_original - 10 # Asegúrate de que el precio con descuento no sea negativo if precio\_con\_descuento < 0: precio\_con\_descuento = 0 row\['precio\_con\_descuento'] = precio\_con\_descuento csv\_writer.writerow(row) print(precio\_original, precio\_con\_descuento)
Le adicioné nueva columna de la sucursales de la Tienda llamada Tienda1.
import csv
file\_path = 'products.csv'updated\_file\_path = 'products\_update1.csv'
with open(file\_path, mode='r') as file: csv\_reader = csv.DictReader(file) fieldnames = csv\_reader.fieldnames +\['total\_values','Tienda'] with open(updated\_file\_path, mode='w', newline='') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() for row in csv\_reader: row\['total\_values']= (float(row\['price']) \* int(row\['quantity'])) row\['Tienda']= 'Tienda1' csv\_writer.writerow(row)
```python
import random
import string
import csv
file_path = 'products.csv'
updated_file_path = 'products_updated.csv'
iva_rate = 0.19 # IVA del 19%
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
fieldnames = csv_reader.fieldnames + ['total_value','base_iva','iva', 'code']
with open(updated_file_path, mode='w', newline = '') as updated_file:
csv_writer = csv.DictWriter(updated_file, fieldnames=fieldnames)
csv_writer.writeheader() # Escribir encabezados
for row in csv_reader:
row['total_value'] = float(row['price']) * int(row['quantity'])
base_iva = round(float(row['price']) / (1 + iva_rate), 0)
row['base_iva'] = base_iva
# Calcular IVA basado en la base redondeada
iva = float(row['price']) - base_iva
row['iva'] = round(iva, 0)
row['code'] = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
csv_writer.writerow(row)
```import randomimport stringimport csv
file\_path = 'products.csv'updated\_file\_path = 'products\_updated.csv'iva\_rate = 0.19 # IVA del 19%with open(file\_path, mode='r') as file: csv\_reader = csv.DictReader(file) fieldnames = csv\_reader.fieldnames + \['total\_value','base\_iva','iva', 'code']
with open(updated\_file\_path, mode='w', newline = '') as updated\_file: csv\_writer = csv.DictWriter(updated\_file, fieldnames=fieldnames) csv\_writer.writeheader() # Escribir encabezados
for row in csv\_reader: row\['total\_value'] = float(row\['price']) \* int(row\['quantity']) base\_iva = round(float(row\['price']) / (1 + iva\_rate), 0) row\['base\_iva'] = base\_iva # Calcular IVA basado en la base redondeada iva = float(row\['price']) - base\_iva row\['iva'] = round(iva, 0) row\['code'] = ''.join(random.choices(string.ascii\_letters + string.digits, k=10)) csv\_writer.writerow(row)
vuelvo a enivar el comentario```python
import csv
#crear nuevas columnsas en archivos csv, siempre se recomienda hacer un archivo nuevo y dejar el otro como esta
file_path='products.csv'
file_new_path='add_products.csv'
with open(file_path,mode='r') as file :
csv_reader= csv.DictReader(file)
#obtener los nombres de las columnas existentes
fieldnames=csv_reader.fieldnames+['total_value','average','difference'] #de esta forma podemos crear mas columnas en nuestro archivo
with open(file_new_path,mode='w',newline='') as update_file :
csv_writer= csv.DictWriter(update_file,fieldnames=fieldnames)
csv_writer.writeheader()#escribir los encabezados
for row in csv_reader:
# Convertir valores para realizar cálculos
price = float(row['price'])
quantity = int(row['quantity'])
row['total_value'] = price * quantity
row['average'] = (price + quantity) / 2
if price < quantity:
row['difference'] = quantity - price
else:
row['difference'] = price - quantity
csv_writer.writerow(row)
```
Yo añadí una columna más de descuentos, los productos mayores de 300 dólares se les da un descuento del 20%.
Aqui dejo mi código...
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?