Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
14 Días
13 Hrs
32 Min
26 Seg
Manejo de Archivos CSV (CLASE NUEVA)
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 48
Preguntas 2
Ordenar por:
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
```
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 :)!
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)
```
```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)
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.
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??
```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?