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,
Manejo de Archivos JSON (CLASE NUEVA)
32/63Recursos
¿Cómo leer archivos JSON en Python?
JSON, que significa JavaScript Object Notation, es un formato liviano de intercambio de datos. Es crucial para trabajar con datos en aplicaciones web y APIs. Aprender a manejarlo con Python es esencial para desarrolladores que buscan eficiencia y flexibilidad.
Para leer un archivo JSON en Python, sigue estos sencillos pasos:
-
Importar la librería JSON: Primeramente, debes importar el módulo JSON de Python.
import json -
Abrir el archivo JSON: Utiliza la función
openpara acceder al archivo. Asegúrate de especificar el modo de lectura.with open('Products.json', 'r') as file: products = json.load(file) -
Iterar sobre el contenido: Una vez cargados los datos, puedes iterar sobre ellos como si fueran una lista de diccionarios.
for product in products: print(product)
Cada producto se imprimirá con sus claves y valores gracias a la estructura de diccionario que utiliza JSON.
¿Cómo extraer claves específicas de un archivo JSON?
En JSON, puedes extraer información específica iterando sobre las claves deseadas. Imagina que quieres solo los nombres y precios de los productos:
-
Iterar y extraer claves: Usa bucles para acceder a la información específica que necesitas.
for product in products: print(f"Product: {product['name']}, Price: ${product['price']}")
Al ejecutar este fragmento, obtendrás los nombres y precios de cada producto. Esta técnica es útil si trabajas con grandes volúmenes de datos.
¿Cómo añadir información a un archivo JSON?
Añadir información a un archivo JSON es tan sencillo como leerlo. Supongamos que quieres añadir un nuevo producto:
-
Crear el nuevo producto: Define el producto que deseas agregar en forma de diccionario.
new_product = {
"name": "Wireless Charger",
"price": 75,
"quantity": 100,
"brand": "ChargeMaster",
"category": "Accessories",
"entry_date": "2024-07-01"
}
-
Abrir y modificar el archivo: Primero, lee los datos existentes y luego añade el producto nuevo al final de la lista.
with open('Products.json', 'r') as file: products = json.load(file) products.append(new_product) with open('Products.json', 'w') as file: json.dump(products, file, indent=4) -
Ejecutar y verificar: Tras ejecutar el código, verifica que el nuevo producto se haya añadido correctamente al archivo JSON.
Manipular archivos JSON es una habilidad poderosa y esencial para cualquier desarrollador. Te permite conservar la estructura y legibilidad del archivo mientras gestionas información de manera eficaz. Además, la práctica constante y el aprendizaje con ejercicios adicionales, como convertir archivos entre CSV y JSON, potenciarán tus habilidades en el manejo de datos. ¡Sigue aprendiendo y ampliando tus conocimientos!
Aportes 75
Preguntas 2
Ordenar por:
Buenas tardes, a estas alturas del curso, creo que uno llega con la energía de reserva, empezó bien y entendible pero a medida que avanzó se fue tornando ladrilludo y monótono, no tanto por los temas en sí, sino por la forma de transmitirlos, la persona a cargo del curso no está explicando los conceptos, está contando lo que está haciendo y es muy diferente explicar a contar, ya que cuando te cuentan algo, siempre quedan dudas y muchos vacíos del origen de las cosas. Y más en estos cursos que se requiere tanta explicación. Por favor si pudieran manejar una metodología más de enfoque educativo, seria mejor para próximas ocasiones. gracias.
# hello folks
Les comparto mi código, la verdad hice un poco de trampa porque le pregunte a chat GPT por como pasar un archivo csv a formato json con python y viceversa, así que me dio el código para los dos casos.
```js
# Este programa toma un archivo csv y crea un nuevo archivo json modificado
# luego a portir del joson modificado se crea un nuevo archivo csv
import csv, json
old_csv_file = 'products_updated.csv'
new_json_fle = 'newproducts_json.json'
new_csv_file = 'newproducts_csv.csv'
new_product = {
"name": "Bluetooth Speaker",
"price": "120",
"quantity": "40",
"brand": "SoundVibes",
"category": "Audio",
"entry_date": "2024-07-20",
"total_value": "4800.0"
}
# 1. pasar del archivo csv a un nuevo archivo json ---------------------------------
# abrir archivo csv
with open(old_csv_file, mode='r') as csvFile:
csv_reader = csv.DictReader(csvFile)
# convertir las filas a una lista de diccionarios
filas = list(csv_reader)
# Guardar en un archivo JSON
with open(new_json_fle, mode='w') as newJsonFile:
json.dump(filas, newJsonFile, indent=4)
pass
# 2. modificar el nuevo archivo json -------------------------------------------------
with open(new_json_fle, mode='r') as newJsonFile:
products = json.load(newJsonFile)
# añadimos el nuevo producto la lista de productos
products.append(new_product)
# esribimos las modificaciones en el archivo json
with open(new_json_fle, mode='w') as newJsonFile:
json.dump(products, newJsonFile, indent=4)
pass
# 3. pasar el archivo json a un nuevo archivo csv --------------------------------------
with open(new_json_fle, mode='r') as jsonFile:
products = json.load(jsonFile)
with open(new_csv_file, mode='w', newline='') as csvFile:
csv_writer = csv.DictWriter(csvFile, fieldnames=products[0].keys())
csv_writer.writeheader()
csv_writer.writerows(products)
pass
```
Me gustaría que dieran una clase estructurada con teoría y ejemplos, porque desde que entramos a POO nos pusieron ejercicios sin tener las bases del conocimiento y esto hace más difícil que se cree lógica y coherencia, al menos en mi caso.
Codigo de CSV a JSONimport csvimport json
file\_csv='products.csv'new\_json\_file='new\_json.json'
data=\[]
with open(file\_csv,'r') as fileCSV: csvreader=csv.DictReader(fileCSV) for row in csvreader: data.append(row)
with open(new\_json\_file,mode='w') as file: json.dump(data,file,indent=4)
```js
import csv
import json
file_csv='products.csv'
new_json_file='new_json.json'
data=[]
with open(file_csv,'r') as fileCSV:
csvreader=csv.DictReader(fileCSV)
for row in csvreader:
data.append(row)
with open(new_json_file,mode='w') as file:
json.dump(data,file,indent=4)
```
Se que aqui se estan dando pasos de gigante de tema en tema, para esos como yo que estan sufriendo en saltar temas, les recomiendo agarrar el codigo de la clase cuyo tema sea dificil y ponerse a buscar que significa cada termino o como funciona, y luego aplicar lo que enseñan en clase para absorber bien lo investigado, entiendo la frustración de muchos al no entender lo que se muestra, pero no se rindan.
El trabajo del programador tambien es de indigar en los temas que no conocemos.
Estuve desarrollando un script en Python que, iba a un programada de afiliados mendiante un API, y verificaba al momento mas de 1000 Tokens (Al API teniamos accesso por ser clientes de esa plataforma) entonces podiamos ir manualmente o mediante la API: Yo cree ese script y el API devolvia los datos en JSON, de forma que el mismo Script era capaz de decodificar el JSON y crearme un reporte o en CSV o en XLSX con toda la informacion descargada de la plataforma.
El equipo antes se tardaba 3 horas diarias, con este desarrollo ahora se tardan 2 minutos.
no se entiende, en cuál de todos los archivos lo estás agregando, ni a qué hora creaste eso, deberías explicar mejor, en vez de estar haciendo clases rápidas, que al final los alumnos no van a comprender, y yo siendo programador hago esta queja, no me imagino a alguien que sea completamente nuevo en esto
Buen día, comparto mi aporte del ejercicio, inicialmente realice la conversión usando lo explicado por la profesora, luego de indagar veo que la librería pandas facilita bastante la lectura y conversión de este tipo de archivos:
\# convert json a csv usando PANDAS
import pandas as pd
with open('Muestras/products.json', mode='r') as input:
df = pd.read\_json(input)
df.to\_csv('Muestras/jonaCsvPandas.csv', encoding='utf-8',index=False)
\# Covert csv a json
import pandas as pd
df = pd.read\_csv('Muestras/products.csv')
df.to\_json('Muestras/archivo.json', orient='records',lines=True, indent=4)
```python
file_path_csv = "products.csv"
file_path_csv_to_json = "products_csv_to_json.json"
with open(file_path_csv, mode="r") as csvfile:
csv_reader = csv.DictReader(csvfile) #aqui se lee el archivo csv
filds = list(csv_reader) #aqui se convierte el archivo csv a una lista de diccionarios
with open(file_path_csv_to_json, mode="w") as jsonfile: #aqui se guarda el archivo csv en un archivo json
json.dump(filds, jsonfile, indent=4) #aqui se convierte el archivo csv a un archivo json
file_path_json = "products.json"
file_path_json_to_csv = "products_json_to_csv.csv"
with open(file_path_json, mode="r") as jsonfile:
products = json.load(jsonfile) #aqui se lee el archivo json
with open(file_path_json_to_csv, mode="w", newline="") as csvfile: #aqui se guarda el archivo json en un archivo csv
csv_writer = csv.DictWriter(csvfile, fieldnames=products[0].keys()) #aqui se convierte el archivo json a un archivo csv
csv_writer.writeheader() #aqui se escribe la cabecera del archivo csv
csv_writer.writerows(products) #aqui se escribe los datos del archivo csv
```
Que opinan de mi solución.
CSV A JSON
JSON A CSV
Aquí dejo mi aporte por favor antes de finalizar, felicitaciones estimada profe.
\#Convert csv to jsonimport <u>csv</u>, <u>json</u>
\#Convertidor de csv a jsonwith open('products.csv', *mode*='r') as file: reader = <u>csv</u>.<u>DictReader</u>(file) products = \[row for row in reader] with open('new\_convert\_products.json', *mode*='w') as file: <u>json</u>.dump(products, file, *indent*=4)
\#Convertidor de json a csvwith open('new\_convert\_products.json', *mode*='r') as file: products = <u>json</u>.load(file) with open('new\_convert\_products.csv', *mode*='w') as file: writer = <u>csv</u>.<u>DictWriter</u>(file, *fieldnames*=\['name', 'price', 'quantity', 'brand', 'category', 'entry\_date']) writer.writeheader() for product in products: writer.writerow(product)
Mi aporte al ejecicio de conversion de archivos csv <==> json
<https://gist.github.com/drincast/610d133ee976275cbe06751ed7b7882d>
**CONVERTIR DE JSON A CSV**
**CODIGO 💚:**
```python
import json
import csv
file_path = 'file_json.json'
file_csv = 'file.csv'
with open(file_path, mode='r')as file:
motos = json.load(file)
with open(file.csv, mode='w', newline='')as file:
csv_writer = csv.DictWriter(file,
fieldnames=motos[0].keys())
csv_writer.writeheader()
csv_writer.writerows(motos)
```**BONUS 🚀:**
*En el código uso la parte del codigo*
```python
fieldnames=motos[0].keys()
```*el cual hace referencia a que las columnas serán las claves del diccionario en el i \[0] de la lista del json*
```js
import csv
import json
file_path = 'new_file_motos.csv'
file_json = 'file_json.json'
with open(file_path, mode='r')as file:
reader = csv.DictReader(file)
datas = list(reader)
with open(file_json, mode='w')as file:
json.dump(datas, file, indent=4)
```
```python
import csv
import json
path_csv = 'products.csv'
path_json = 'products.json'
path_csv2 = 'products_updated.csv'
# csv a json
with open(path_csv,mode='r') as file1:# se abre el csv a copiar
csv_reader = csv.DictReader(file1)#Crea un objeto que convierte cada fila en un diccionario
dictson = [row for row in csv_reader]#Creación de una lista de los diccionarios
with open(path_json, mode='w') as file2:#se abre el archivo json para escribir
json.dump(dictson, file2, indent=4)#Escribe el contenido de la lista en el archivo json con una identación de 4 espacios
# json a csv
with open(path_json,mode='r') as file3:# se abre el json a copiar
products=json.load(file3)# se guarda el contenido del archivo en una lista
with open(path_csv2,mode='w',newline='') as file4:#se abre el archivo csv para escribir
csv_writer = csv.DictWriter(file4, fieldnames = products[0].keys())
csv_writer.writeheader()#Escritura del encabezado (primera fila de campos)
for row in products:
csv_writer.writerow(row)#Se escribe cada elemento de la lista en una fila del archivo csv
```
La verdad que Carli enseña muy bien es solo prestar más atencion a lo que esta haciendo, y también leer la descripcion de la clase, que de hecho hay viene como hacerlo (en parte) lo demás pues se trata de investigarlo probar o incluso preguntar al ChatGPT y pedir explicación en fin yo siento que si estoy aprendiendo bien con Carli y también con ayuda de la IA cuando me trabo en alguna parte del codigo o cuando no estoy podiendo resolver un error de mi codigo
```js
import csv
import json
# Leer el archivo json
with open('products2.json', mode='r') as json_file:
json_reader = json.load(json_file)
# Se convierte en archivo csv
with open('products3.csv', mode = "w", newline ='') as csv_file:
writer = csv.writer(csv_file)
writer.writerow(json_reader[0].keys())
for item in json_reader:
writer.writerow(item.values())
```import csvimport json# Leer el archivo jsonwith open('products2.json', mode='r') as json\_file: json\_reader = json.load(json\_file)# Se convierte en archivo csvwith open('products3.csv', mode = "w", newline ='') as csv\_file: writer = csv.writer(csv\_file) writer.writerow(json\_reader\[0].keys()) for item in json\_reader: writer.writerow(item.values())
No puedo ni abrir el archivo json, python no lo encuentra y eso de que esta en la misma carpeta y tambien ya verifique que tenga el mismo nombre
aqui el codigo para convertir csv a json con python
import csvimport json
\# Leer el archivo CSV y convertirlo a una lista de diccionarioscsv\_file = "products.csv"json\_file = "products.json"
with open(csv\_file, mode='r', encoding='utf-8') as file: csv\_reader = csv.DictReader(file) data = \[row for row in csv\_reader] # Convertir a lista de diccionarios
\# Guardar la lista como un archivo JSONwith open(json\_file, mode='w', encoding='utf-8') as file: json.dump(data, file, indent=4, ensure\_ascii=False)
print(f"Archivo JSON guardado como {json\_file}")
Para los que a esta altura de la clase sienten que esta complejo, les recomiendo ver el curso de programación basica.
No se habla de python pero se pueden familiarizar con todo el entorno de desarrollo más facil y super explicado al detalle con lenguajes faciles de entender como Javascript, para cuando lleguen acá ya tengan una base un poco más solida.
Hola a todos, les dejo una versión del ejercicio final de la clase, optimizado y explicado por chatgpt:
```js
#Convertir archivo de CSV a JSON
#1. Importación de módulos
import csv
import json
#2. Función de csv_to_json
def csv_to_json(csv_path, json_path):
with open(csv_path, mode="r") as csvfile:
csv_reader = csv.DictReader(csvfile)
fields = [{key:(int(value) if value.isdigit() else value) for key, value in row.items()} for row in csv_reader]
with open(json_path, mode="w") as jsonfile:
json.dump(fields, jsonfile, indent=4)
#Recibe la ruta de un archivo CSV (csv_path) y la ruta donde se guardará el archivo JSON (json_path)
#Abre el archivo CSV en modo lectura ("r")
#DictReader convierte cada fila del CSV en un diccionario donde las claves son los nombres de las columnas
#Recorre cada row del csv_reader y crea un diccionario, convierte valores numéricos a enteros y si no es nùmero, lo deja como string.
#for row in csv_reader: Itera sobre cada fila del CSV
#{...} crea un nuevo diccionario con valores convertidos
#[...] agrupa todos los diccionarios en una lista
#Abre el archivo json en modo escritura
#Guarda los datos convertidos con una indentación de 4 para que sea legible.
#3. Función de json_to_csv
def json_to_csv(json_path, csv_path):
with open(json_path, mode="r") as jsonfile:
products = json.load(jsonfile)
with open(csv_path, mode="w", newline="") as csvfile:
csv_writer = csv.DictWriter(csvfile, fieldnames=products[0].keys())
csv_writer.writeheader()
csv_writer.writerows(products)
#Recibe la ruta del JSON (json_path) y la ruta donde se guardará el CSV (csv_path)
#Abre el archivo json en modo lectura
#Carga el contenido del JSON en products, que es una lista de diccionarios
#Abre el CSV en modo escritura y evita lineas en blanco.
#DictWriter permite escribir diccionarios en el CSV.
#csvfile es el archivo donde se va a escribir
#fieldnames define los nombres de las columnas que tendrá el archivo
#products[0].keys():
#products [0] accede al primer diccionario. Como todos los diccionarios tienen la misma estructura, tienen las mismas llaves.
#.keys() obtiene solo las claves del diccionario
#Usa las claves del primer diccionario de products como nombres de la columna
#Escribe la fila del encabezado en el CSV
#Escribe todas las filas de products en el CSV
#Paths de los archivos
csv_file = "Material/products.csv"
json_file= "Material/products.json"
csv_output_file = "products_json_to_csv.csv"
#Conversiones
csv_to_json(csv_file, json_file)
json_to_csv(json_file, csv_output_file)
``` Espero les sirva para continuar motivados y decididos.
Mi aporte con ayuda de Deepseek:
### Explicación del código:
1. `csv.DictReader`: Lee el archivo `.csv` y convierte cada fila en un diccionario, donde las claves son los nombres de las columnas.
2. `json.dump`: Escribe la lista de diccionarios en un archivo `.json` con un formato legible (`indent=4`).
3. `ensure_ascii=False`: Permite que los caracteres no ASCII (como acentos o caracteres especiales) se guarden correctamente.
import csvimport json
file\_path\_csv = "products.csv"file\_path\_json = "products.json"
data =\[]
with open(file\_path\_csv, mode="r", encoding="utf-8") as file\_csv: reader\_csv = csv.DictReader(file\_csv)
for row in reader\_csv: data.append(row)
with open(file\_path\_json, mode="w", encoding="utf-8") as file\_json: json.dump(data, file\_json, indent=4, ensure\_ascii=False)
print(f"Los datos se han convertido coreectamente en {file\_path\_json}")
Primero mi conversion de JSON a CSV explicada
```python
import json
import csv
# Abrimos y Cargamos el JSON
json_file_path = '22.json_files/products.json'
with open(json_file_path, 'r') as json_file:
data = json.load(json_file) # Cargamos los datos JSON en un objeto python
# Abrimos un archivo CSV para escribir
csv_file_path = '22.json_files/products.csv'
with open(csv_file_path, 'w', newline='') as csv_file:
# Creamos un CSV writer
csv_writer = csv.writer(csv_file)
# Escribimos los encabezados (las primeras keys en el objeto JSON)
header = data[0].keys()
csv_writer.writerow(header)
# Escribir el resto de filas
for item in data:
csv_writer.writerow(item.values())
```Las cosas mas notables que puedes ver es la linea que dice:
`header = data[0].keys()`
Esto lo que hace es qe agarra las **keys** de el primer elemento dentro del archivo JSON, las cuales serian las mismas que cualquier otra, almenos en este caso.
Y eso es lo que usara para especificar el encabezado del CSV
Y la otra linea seria:
`csv_writer.writerow(item.values())`
si te fijas **item** es solo una referencia al elemento **data** por lo tanto solo estoy haciendo referencia a los valores de data, los cuales cambian segun vaya iterando por filas, a diferencia de los encabezados que siempre son los mismos.
Te dejo la otra conversion en el siguiente comentario
```python
import csv, json
csv_file = 'products_updated2.csv'
json_file = 'products.json'
csv_newFile = 'products_1.csv'
json_newFile = 'products_updated2.json'
# Convertir csv a json
#Leer csv
with open(csv_file, mode='r') as file:
csv_reader = csv.DictReader(file)
data_csv = list(csv_reader) #convierte el iterador csv.DictReader() en una lista para poder reutilizar los datos
#escribir csv en json
with open(json_newFile, mode='w') as file:
json.dump(data_csv, file, indent=4)
#convertir json a csv
#leer json
with open(json_file, mode='r') as file:
json_reader = json.load(file)
fieldnames = json_reader[0].keys()
#escribir json en csv
with open(csv_newFile, mode='w', newline='') as file:
csv_writer = csv.DictWriter(file, fieldnames=fieldnames)
csv_writer.writeheader()
csv_writer.writerows(json_reader)
```Mi aporte :)
hice que chat GPT me cree 2 archivos uno csv y otro json e hice los cambios, mi aporte del reto :)
```js
import json
#-----------Agregando información a un JSON -----------
# Ruta del archivo JSON
file_path = 'python-JSON/products.json'
#Nuevo producto
new_product = {
'name': 'Cargador inalambrico',
'price': 75,
'quantity':100,
'brand': 'Cargador master',
'category': 'Accesorios',
'entry_date': '2024-07-01'
}
# Abriendo el archivo en modo lectura ('r')
with open(file_path, mode='r') as file:
products = json.load(file)
#Agregando producto al documento
products.append(new_product)
#Abriendo archico en modo escritura ('w')
with open(file_path, mode='w') as file:
#Añadiendo la información, se añade el producto, se añade el archivo y se añade la identación
json.dump(products, file, indent=4)
```
Quiero compartir la forma como hice la de mostrar los productos, manipulando un poco la data y aplicando un poco lo que hemos aprendido, lo demás busqué cómo hacerlo.
```js
import json
file_path = 'python-JSON/products.json'
with open(file_path, mode='r') as file:
#Cargando el archivo para poder leerlo
products = json.load(file)
# print("Products: ", products)
def mostrar_productos():
contador = 0
keys = list(products[0].keys())
#Comprensión de lista para mayúsculas
keys_mayusculas = [key.upper() for key in keys]
#Contatenación de cadenas con un separador
keys_mayusculas = " | ".join(keys_mayusculas)
#Separando de los demas print
print("")
print("*TABLA PRODUCTOS:")
#Mostrando emcabezados tipo tabla
print("N° |", keys_mayusculas)
for producto in products:
contador += 1
print(f" { contador } | { producto['name'] } | { producto['price'] } | { producto['quantity'] } | { producto['brand'] } | { producto['category'] } | { producto['entry_date'] } ")
#Mostrando los productos
mostrar_productos()
```import json
file\_path = 'python-JSON/products.json'
with open(file\_path, mode='r') as file:
*#Cargando el archivo para poder leerlo* products = json.load(file) *# print("Products: ", products)*
def mostrar\_productos(): contador = 0 keys = list(products\[0].keys())
*#Comprensión de lista para mayúsculas* keys\_mayusculas = \[key.upper() for key in keys]
*#Contatenación de cadenas con un separador* keys\_mayusculas = " | ".join(keys\_mayusculas) *#Separando de los demas print* print("") print("\*TABLA PRODUCTOS:")
*#Mostrando emcabezados tipo tabla* print("N° |", keys\_mayusculas)
for producto in products: contador += 1 print(f" { contador } | { producto\['name'] } | { producto\['price'] } | { producto\['quantity'] } | { producto\['brand'] } | { producto\['category'] } | { producto\['entry\_date'] } ")
*#Mostrando los productos*mostrar\_productos()
Después de preguntar a Chat GPT ya no doy con la respuesta.
El ejercicio me aparece bien ejecutado en consola, me añade el dato, pero 9 veces y no me lo vuelca en el archivo .json
Socorro!!!!!
para transformar los csv a json
```js
import csv, json
with open('csv/products.csv', 'r') as file:
csv_reader = csv.DictReader(file)
data = []
for row in csv_reader:
data.append(row)
data_str = json.dumps(data)
with open('json/products.json', 'w') as json_file:
json_file.write(data_str)
```
Csv a Json:
```python
json_path = 'to_json.json'
csv_path = '../csv/products.csv'
data = []
#leer y agregar los datos en formato de diccionario dentro de array data
with open(csv_path, 'r') as file:
csv_reader = csv.DictReader(file)
for row in csv_reader:
print(row)
data.append(row)
with open(json_path, 'w') as file:
json.dump(data, file, indent=4)
```Json a CSV:
```python
json_path = 'to_json.json'
csv_path = 'to_csv.csv'
with open(json_path, 'r') as file:
data = json.load(file)
headers = data[0].keys()
with open(csv_path, 'w') as filecsv:
csv_writer = csv.DictWriter(filecsv, fieldnames=headers)
csv_writer.writeheader()
for row in data:
csv_writer.writerow(row)
```
### What is the best Python library for reading JSON files?
> The json module, which comes built-in with Python, is widely used and efficient for reading and writing JSON data. For more advanced features and utilities, libraries like pandas or requests can also handle JSON effectively.
### Deserialize a JSON String to an Object in Python
Deserialization of JSON means converting JSON objects into their respective Python objects. The load()/loads() method is used for this. If you have used JSON data from another program or obtained it in string format, then it can easily be deserialized with load()/loads(), which is usually used to load from string. Otherwise, the root object is in a list or dict. See the table below.
**JSON is JavaScript Object Notation.** It means that a script (executable) file which is made of text in a programming language, is used to store and transfer the data. Python supports JSON through a built-in package called JSON. To use this feature, we import the JSON package in Python script. The text in JSON is done through quoted-string which contains the value in key-value mapping within { }. It is similar to the dictionary in Python. JSON shows an API similar to users of Standard Library marshal and pickle modules and Python natively supports JSON features. For example:
Hola. Me puse a buscar como crear el json desde el csv, y en <https://www.geeksforgeeks.org/convert-csv-to-json-using-python/> encontre esta idea. Obviamente no es copiar y pegar, sino reescribir el codigo interpretando y comprendiendo que sucede. Funciono a la tercera!.
```python
import csv
import json
source_file = 'products.csv'
destination_file = 'products.json'
def generate_json(source_file, destination_file):
data = {} #new dictionary
with open(source_file, mode='r') as origin:
csv_reader = csv.DictReader(origin)
for rows in csv_reader:
#first key
key = rows['name'] #Defino el nombre de la primera columna
data[key] = rows
with open(destination_file, mode='w') as destination:
destination.write(json.dumps(data, indent=4))
generate_json(source_file, destination_file)
```
seria chevere que se explique como seria el manejo de archivos PDF.
Alguna vez lo trabaje con ayuda de la libreria externa a weasyprint, pero tengo entendido que hay como hacerlo de otra forma.
Me costó porque tenía unerror en mi archivo JSON que generé con IA y me había cambiado una clave. Bueno, me sirvió para entender mejor, jajaja
```python
# Convierte un archivo JSON a csv
# El archivo CVS de salida (articulos_csv_modif.csv) se ve así:
"""nombre,color,cantidad,precio
Lapiz,Negro,12,0.50
Borrador,Blanco,5,0.25
Goma de borrar,Rosa,2,0.30
Sacapuntas,Azul,1,1.00
Regla,30 cm,1,1.50
Compas,Plastico,1,2.00
Tijeras,Pequenas,1,2.50
Cuaderno,100,3,3.00
Marcadores,Variados,12,5.00
Mochila,Azul,1,30.00"""
# El archivo de entrada JSON(articulos.json) luce así:
"""[
{
"nombre": "Lápiz",
"color": "Negro",
"cantidad": 12,
"precio": 0.50
},
{
"nombre": "Borrador",
"color": "Blanco",
"cantidad": 5,
"precio": 0.25
},
{
"nombre": "Goma de borrar",
"color": "Rosa",
"cantidad": 2,
"precio": 0.30
},
{
"nombre": "Sacapuntas",
"color": "Azul",
"cantidad": 1,
"precio": 1.00
},
{
"nombre": "Regla",
"color": "Azul",
"cantidad": 1,
"precio": 1.50
},
{
"nombre": "Compás",
"color": "verde",
"cantidad": 1,
"precio": 2.00
},
{
"nombre": "Tijeras",
"color": "amarillo",
"cantidad": 1,
"precio": 2.50
},
{
"nombre": "Cuaderno",
"color": "azul",
"cantidad": 3,
"precio": 3.00
},
{
"nombre": "Marcadores",
"color": "Variados",
"cantidad": 12,
"precio": 5.00
},
{
"nombre": "Mochila",
"color": "Azul",
"cantidad": 1,
"precio": 30.00
}
]
"""
import csv
import json
file_path = 'articulos.json'
csv_file_path = 'articulos_csv_modif.csv'
#Leer el JSON
with open(file_path, mode='r') as file:
articulos = json.load(file)
with open(csv_file_path, mode='w', newline='') as csv_file_path:
csv_writer = csv.DictWriter(csv_file_path, fieldnames = articulos[0].keys())
csv_writer.writeheader()
csv_writer.writerows(articulos)
```
Les comprato mi código para convertir un CSV a JSON:
```python
# Convierte un archivo cvs a JSON
# El archivo CVS (articulos.cvs) se ve así:
"""nombre,color,cantidad,precio
Lapiz,Negro,12,0.50
Borrador,Blanco,5,0.25
Goma de borrar,Rosa,2,0.30
Sacapuntas,Azul,1,1.00
Regla,30 cm,1,1.50
Compas,Plastico,1,2.00
Tijeras,Pequenas,1,2.50
Cuaderno,100,3,3.00
Marcadores,Variados,12,5.00
Mochila,Azul,1,30.00"""
# El archivo de salida JSON(articulos_updated.json) luce así:
"""[
{
"nombre": "Lapiz",
"color": "Negro",
"cantidad": "12",
"precio": "0.50"
},
{
"nombre": "Borrador",
"color": "Blanco",
"cantidad": "5",
"precio": "0.25"
},
{
"nombre": "Goma de borrar",
"color": "Rosa",
"cantidad": "2",
"precio": "0.30"
},
{
"nombre": "Sacapuntas",
"color": "Azul",
"cantidad": "1",
"precio": "1.00"
},
{
"nombre": "Regla",
"color": "30 cm",
"cantidad": "1",
"precio": "1.50"
},
{
"nombre": "Compas",
"color": "Plastico",
"cantidad": "1",
"precio": "2.00"
},
{
"nombre": "Tijeras",
"color": "Pequenas",
"cantidad": "1",
"precio": "2.50"
},
{
"nombre": "Cuaderno",
"color": "100",
"cantidad": "3",
"precio": "3.00"
},
{
"nombre": "Marcadores",
"color": "Variados",
"cantidad": "12",
"precio": "5.00"
},
{
"nombre": "Mochila",
"color": "Azul",
"cantidad": "1",
"precio": "30.00"
}
]
"""
import csv
import json
file_path = 'articulos.csv'
json_file_path = 'articulos_updated.json'
#Leer el CVS
with open(file_path, mode='r') as file:
csv_reader = csv.DictReader(file)
articulos = []
for row in csv_reader:
articulos.append(row)
print(articulos)
with open(json_file_path, mode='w', newline='') as file:
json.dump(articulos, file, indent=4)
```
```js
import csv
import json
csvfile1='product.csv'
new_json_file='new_products111 _json.json'
new_csv_file='csvfilenew.csv'
new_product_json={
"column1": "Audinuevoo",
"column2": "A6ssss",
"column3": "2021",
"column4": "White",
"column5": "Sedan",
"column6": "Gasolinesss"
}
with open(csvfile1,mode='r') as file:
csv_reader=csv.DictReader(file)
filas=list(csv_reader)
print(filas)
with open(new_json_file,mode='w') as jsonfile:
json.dump(filas,jsonfile,indent=4)
pass
with open(new_json_file,mode='r') as file:
products=json.load(file)
products.append(new_product_json)
with open(new_json_file, mode='w') as file:
json.dump(products,file,indent=4)
pass
with open(new_json_file,mode='w') as file:
products=json.load(file)
with open(new_csv_file,mode='w') as file:
csv_writer=csv.DictWriter(file,fieldnames=products[0].keys())
csv_writer.writeheader()
csv_writer.writerows(products)
pass
```
Hola! Comparto mi código para converetir de csv a json, cualquier comentario o crítica me sirve mucho. Gracias!
```python
# obtengo los datos del archivo CSV y los guardo en una variable
with open(path_csv, mode='r') as file:
csv_data = csv.DictReader(file)
# casteo la variable csv_data al mismo tipo de dato 'lista' que la variable
# json que voy a traer más adelante
converted_csv_type = list(csv_data)
print(type(converted_csv_type))
# abro el archivo json para cargar sus datos en un diccionario
with open(path_json, mode='r') as file:
json_data = json.load(file)
json_data.append(converted_csv_type)
print(type(json_data))
# compruebo que tienen el mismo tipo de dato
if type(json_data) == type(converted_csv_type):
print("Mismo tipo de dato")
# escribo los datos en el archivo json
with open(path_json, mode='w') as file:
json.dump(json_data, file, indent=4)
print("Conversión exitosa")
else:
print("Las variables tienen distinto tipo de dato")
```*# obtengo los datos del archivo CSV y los guardo en una variable*with open(path\_csv, *mode*='r') as file: csv\_data = csv.DictReader(file)
*# casteo la variable csv\_data al mismo tipo de dato 'lista' que la variable* *# json que voy a traer más adelante* converted\_csv\_type = list(csv\_data)
print(type(converted\_csv\_type))
*# abro el archivo json para cargar sus datos en un diccionario*with open(path\_json, *mode*='r') as file: json\_data = json.load(file)
json\_data.append(converted\_csv\_type)
print(type(json\_data))
*# compruebo que tienen el mismo tipo de dato*
if type(json\_data) == type(converted\_csv\_type): print("Mismo tipo de dato") *# escribo los datos en el archivo json* with open(path\_json, *mode*='w') as file: json.dump(json\_data, file, *indent*=4) print("Conversión exitosa")else: print("Las variables tienen distinto tipo de dato")
import csv import json # Abrir el archivo CSV with open('mi\_archivo.csv', 'r') as csvfile: reader = csv.DictReader(csvfile) data = \[] for row in reader: data.append(row) # Escribir el resultado en un archivo JSON with open('mi\_archivo.json', 'w') as jsonfile: json.dump(data, jsonfile, indent=4)
```js
import csv
import json
# Read the CSV file
file_path = 'products.csv'
with open(file_path, mode='r') as file:
reader = csv.DictReader(file)
products = list(reader)
# Write the JSON file
file_path_json = 'products_de_csv.json'
with open(file_path_json, mode='w') as file:
json.dump(products, file, indent=4)
```import jsonimport csv
\#Leer el archivo JSONfile\_path = 'products.json'
with open(file\_path, mode='r') as file: products = json.load(file)
\#Escribir el archivo csvfile\_path\_csv = 'products\_de\_json.csv'
with open(file\_path\_csv, mode='w', newline='') as update\_file: #Obtener los encabezados desde las claves del ´primer diccionario fieldnames = products\[0].keys() csv\_writer = csv.DictWriter(update\_file, fieldnames=fieldnames) csv\_writer.writeheader() csv\_writer.writerows(products)```js
import json
import csv
#Leer el archivo JSON
file_path = 'products.json'
with open(file_path, mode='r') as file:
products = json.load(file)
#Escribir el archivo csv
file_path_csv = 'products_de_json.csv'
with open(file_path_csv, mode='w', newline='') as update_file:
#Obtener los encabezados desde las claves del ´primer diccionario
fieldnames = products[0].keys()
csv_writer = csv.DictWriter(update_file, fieldnames=fieldnames)
csv_writer.writeheader()
csv_writer.writerows(products)
```
Cambiar un archivo csv a json
Cambiar un archivo de json a csv
Estuvo algo complicado, al menos para mi pues es mi primera vez usando python, pero logre hacerlo y sin usar IA (Es algo con lo que muchos trampean hoy en día).
**CSV a JSON**
```python
import csv
import json
path_csv = 'C:/Users/crist/Desktop/Curso Python/Lectura_y_Escritura_de_archivos/customers-100_Update.csv'
path_json = 'C:/Users/crist/Desktop/Curso Python/Lectura_y_Escritura_de_archivos/customers-100_csv_to_json.json'
# Leer el contenido del csv
with open(path_csv, mode='r', encoding='utf-8') as csv_file:
csv_reader = list(csv.DictReader(csv_file))
with open(path_json, mode='w') as json_file:
json.dump(csv_reader, json_file, indent=4)
```**JSON a CSV**
```python
import json
import csv
path_json = 'C:/Users/crist/Desktop/Curso Python/Lectura_y_Escritura_de_archivos/productos.json'
path_csv = 'C:/Users/crist/Desktop/Curso Python/Lectura_y_Escritura_de_archivos/productos_json_to_csv.csv'
# JSON to CSV
with open(path_json, mode='r') as json_file:
productos_reader = json.load(json_file)
headers = productos_reader['productos'][0].keys()
with open(path_csv, mode='w', newline='') as csv_file:
csv_writer = csv.DictWriter(csv_file, fieldnames=headers) # Esto es la declaracion de las cabeceras
csv_writer.writeheader() # Aqui se plasman las cabeceras en el archivo.
csv_writer.writerows(productos_reader['productos']) # Aqui se escriben los datos del json en el csv
# Visualizamos el archivo csv para ver como a quedado.
with open(path_csv, mode='r', encoding='utf-8') as csv_file:
csv_reader = csv.DictReader(csv_file)
for row in csv_reader:
print(f"| Producto: {row['nombre']} - Categoria: {row['categoria']} - Precio: {row['precio']} - Disponibilidad: {row['stock']} |")
```
```python
import csv, json
#Pasar de CSV a JSON
with open('documents/csv/products_updated.csv', mode='r') as file:
csv_reader = csv.DictReader(file)
data = list(csv_reader)
with open('documents/challenge/products_updated.json', mode='w') as file:
json.dump(data, file, indent=4)
#Pasar de JSON a CSV
with open('documents/challenge/products_updated.json', mode='r') as file:
data = json.load(file)
with open('documents/challenge/products_updated.csv', mode='w', newline='') as file:
fieldnames = data[0].keys()
csv_writer = csv.DictWriter(file, fieldnames=fieldnames)
csv_writer.writeheader()
csv_writer.writerows(data)
```Reto resuelto.
Código de la clase:
```js
import json
file_path = 'products.json'
new_product = {
"name": "Wireless Charger",
"price": 75,
"quantity": 100,
"brand": "ChargeMaster",
"category": "Accessories",
"entry_date": "2024-07-01"
}
with open(file_path, mode='r') as file:
products = json.load(file)
products.append(new_product)
with open(file_path, mode='w') as file:
json.dump(products, file, indent=4)
```
El parámetro `indent` en `json.dump()` controla la cantidad de espacios que se utilizan para la identación en el archivo JSON resultante. Por ejemplo, si usas `indent=4`, cada nivel de anidación en el JSON se representará con 4 espacios, lo que hace que el archivo sea más legible para los humanos. Este parámetro no afecta la estructura de los datos en sí, solo su presentación visual. Asegúrate de usarlo cuando necesites que el JSON sea fácil de leer en formato de texto.
import csvimport json
def csv\_a\_json(archivo\_csv, archivo\_json): with open(archivo\_csv, mode='r') as csv\_file: csv\_reader = csv.DictReader(csv\_file) datos = list(csv\_reader)
with open(archivo\_json, mode='w') as json\_file: json.dump(datos, json\_file, indent=4)
csv\_a\_json('productos.csv', 'productos.json')
En todo caso, dentro de los requisitos del curso, solamente aparece: "Programación básica".
Por lo tanto concuerdo, en que falta un poco de didáctica en el curso.
```js
import csv
import json
#1. convertir el archivo data.cvs a json
with open('data.csv', mode = 'r') as file:
csv_readar = csv.DictReader(file)
data_json = []
for row in csv_readar:
data_json.append(row)
with open('data_in_json.json', mode='w') as file:
json.dump(data_json, file, indent=4 )
#2. convertir el archivo data2.json en csv
with open('data2.json', mode = 'r') as file:
#csv_reader = csv.DictReader(file)
info = json.load(file)
with open('data2.csv', mode = 'w', newline='') as file:
file.write('\n')
headers = info.keys() #if isinstance(info, list) else info.keys()
writer = csv.DictWriter(file, fieldnames= headers)
writer.writeheader()
writer.writerow(info)
```import csvimport json
\#1. convertir el archivo data.cvs a json
with open('data.csv', mode = 'r') as file: csv\_readar = csv.DictReader(file) data\_json = \[] for row in csv\_readar: data\_json.append(row)
with open('data\_in\_json.json', mode='w') as file: json.dump(data\_json, file, indent=4 )
\#2. convertir el archivo data2.json en csv
with open('data2.json', mode = 'r') as file: #csv\_reader = csv.DictReader(file) info = json.load(file)
with open('data2.csv', mode = 'w', newline='') as file: file.write('\n') headers = info.keys() #if isinstance(info, list) else info.keys() writer = csv.DictWriter(file, fieldnames= headers) writer.writeheader() writer.writerow(info)
Vasandome en los comentarios (con los vídeos no queda clara la forma de realizar el reto), este es mi reto:
```js
import csv
import json
# Traductor de archivo CSV con headers a JSON
with open('original.csv', mode='r') as csv_file:
csv_reader = csv.DictReader(csv_file)
# Convierte el lector de CSV en un diccionario de objetos, donde la primera fila corresponde al nombre de cada atributo de los objeto y el resto de fila corrresponde a los valoresprint(list(csv_reader))
filas = list(csv_reader)
with open('new.json', 'w') as json_file:
json.dump(filas, json_file, indent = 4)
# Traductor de archivo JSON a CSV con headers
with open('original.json', 'r') as json_file:
products = json.load(json_file)
with open('new.csv', 'w', newline = '') as csv_file:
csv_writer = csv.DictWriter(csv_file, fieldnames = products[1].keys())
csv_writer.writeheader()
csv_writer.writerows(products)
```import csvimport json
\# Traductor de archivo CSV con headers a JSONwith open('original.csv', mode='r') as csv\_file: csv\_reader = csv.DictReader(csv\_file) # Convierte el lector de CSV en un diccionario de objetos, donde la primera fila corresponde al nombre de cada atributo de los objeto y el resto de fila corrresponde a los valoresprint(list(csv\_reader)) filas = list(csv\_reader) with open('new.json', 'w') as json\_file: json.dump(filas, json\_file, indent = 4) # Traductor de archivo JSON a CSV con headerswith open('original.json', 'r') as json\_file: products = json.load(json\_file) with open('new.csv', 'w', newline = '') as csv\_file: csv\_writer = csv.DictWriter(csv\_file, fieldnames = products\[1].keys())
csv\_writer.writeheader() csv\_writer.writerows(products)
```python
import json
import csv
print("\n------------ conver json to csv")
# Leer archivo
json_path = "JSON/products.json"
file_path = "csv/products_2.csv" # Ruta y nombre del archivo csv de salida
# Leer archivo json
json_path = "JSON/products.json"
with open(json_path, mode='r') as my_file:
products = json.load(my_file)
# Obtener los nombres de las columnas del archivo CSV a partir de las claves del primer diccionario
fieldnames = products[0].keys()
# Guardar los datos en un archivo CSV
with open(file_path, mode='w', newline='') as csv_file: # Usar 'w' para sobrescribir en cada ejecución
csv_writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
csv_writer.writeheader() # Escribir encabezado en el CSV
csv_writer.writerows(products) # Escribir todas las filas
print(f"Archivo CSV '{file_path}' creado exitosamente con el contenido del JSON.")
```
Aquí mi aporte al ejercicio.
Convertir csv a json fue más sencillo
```python
import csv
import json
# Valores de entrada y salida de los archivos csv y json
csv_file_path = 'products1.csv'
json_file_path = 'products1.json'
# Aquí leemos los datos del csv y añadimos los datos a una lista
# Nota de que el primer archivo solo abrimos como lectura para ya que no necesitamos modificar nada solo copiar los datos
products1 = []
with open(csv_file_path, mode='r') as csv_file:
csv_reader = csv.DictReader(csv_file)
for row in csv_reader:
products1.append(row)
# Aquí escribimos los datos en un archivo.json
# y aquí abrimos como escritura de que creamos el nuevo archivo
with open(json_file_path, mode='w') as json_file:
json.dump(products1, json_file, indent=4)
```
Hola, me costó un poco entender el método para agregar nuevos elementos al archivo products.json.
Lo entendí de la siguiente manera:
la línea de comando:
products.append(new\_product)
lo que hace es agregar, con el método append un nuevo elemento al objeto Python.
La instrucción :
json.dump(products, file, indent=4)
transforma el objeto de Puython en un archivo json.
Espero haber sido de ayuda.
Atenramente
Cristian
Hola, esta es una prueba
Mi aporte de Convertir CSV a JSON
```js
#Convertir de CSV a Json
csv_path = 'inventario.csv'
csv_to_json = 'inventario_to_json.json'
with open(csv_path, mode='r', encoding='UTF-8') as file:
csv_inventario = csv.DictReader(file)
new_data = []
for row in csv_inventario:
#print(row)
new_data.append(row)
with open(csv_to_json, mode='w', encoding='UTF-8') as new_file:
json.dump(new_data,new_file,indent=4)
```*#Convertir de CSV a Json*csv\_path = 'inventario.csv'csv\_to\_json = 'inventario\_to\_json.json'
with open(csv\_path, mode='r', encoding='UTF-8') as file: csv\_inventario = csv.DictReader(file) new\_data = \[] for row in csv\_inventario: *#print(row)* new\_data.append(row) with open(csv\_to\_json, mode='w', encoding='UTF-8') as new\_file: json.dump(new\_data,new\_file,indent=4)
Mi aporteimport csvimport jsonimport loggingimport os
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
def csv\_a\_json(ruta\_csv, ruta\_json): try: with open(ruta\_csv, mode='r', encoding='utf-8') as file\_csv: lector\_csv = csv.DictReader(file\_csv) datos = list(lector\_csv) with open(ruta\_json, mode='w', encoding='utf-8') as file\_json: json.dump(datos, file\_json, indent=4, ensure\_ascii=False) logging.info(f'Conversión de CSV a JSON completada: {ruta\_csv} -> {ruta\_json}') except Exception as e: logging.error(f'Error al convertir CSV a JSON: {e}')
def json\_a\_csv(ruta\_json, ruta\_csv): try: with open(ruta\_json, mode='r', encoding='utf-8') as file\_json: datos = json.load(file\_json) encabezados = datos\[0].keys() with open(ruta\_csv, mode='w', encoding='utf-8', newline='') as file\_csv: escritor\_csv = csv.DictWriter(file\_csv, fieldnames=encabezados) escritor\_csv.writeheader() escritor\_csv.writerows(datos) logging.info(f'Conversión de JSON a CSV completada: {ruta\_json} -> {ruta\_csv}') except Exception as e: logging.error(f'Error al convertir JSON a CSV: {e}')
ruta\_csv = 'products.csv'ruta\_json = 'products.json'
if not os.path.exists(ruta\_csv) and os.path.exists(ruta\_json): json\_a\_csv(ruta\_json, ruta\_csv)elif not os.path.exists(ruta\_json) and os.path.exists(ruta\_csv): csv\_a\_json(ruta\_csv, ruta\_json)else: logging.info('Ambos archivos existen o ninguno de los archivos existe.')
```js
import csv
import json
import logging
import os
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
def csv_a_json(ruta_csv, ruta_json):
try:
with open(ruta_csv, mode='r', encoding='utf-8') as file_csv:
lector_csv = csv.DictReader(file_csv)
datos = list(lector_csv)
with open(ruta_json, mode='w', encoding='utf-8') as file_json:
json.dump(datos, file_json, indent=4, ensure_ascii=False)
logging.info(f'Conversión de CSV a JSON completada: {ruta_csv} -> {ruta_json}')
except Exception as e:
logging.error(f'Error al convertir CSV a JSON: {e}')
def json_a_csv(ruta_json, ruta_csv):
try:
with open(ruta_json, mode='r', encoding='utf-8') as file_json:
datos = json.load(file_json)
encabezados = datos[0].keys()
with open(ruta_csv, mode='w', encoding='utf-8', newline='') as file_csv:
escritor_csv = csv.DictWriter(file_csv, fieldnames=encabezados)
escritor_csv.writeheader()
escritor_csv.writerows(datos)
logging.info(f'Conversión de JSON a CSV completada: {ruta_json} -> {ruta_csv}')
except Exception as e:
logging.error(f'Error al convertir JSON a CSV: {e}')
ruta_csv = 'products.csv'
ruta_json = 'products.json'
if not os.path.exists(ruta_csv) and os.path.exists(ruta_json):
json_a_csv(ruta_json, ruta_csv)
elif not os.path.exists(ruta_json) and os.path.exists(ruta_csv):
csv_a_json(ruta_csv, ruta_json)
else:
logging.info('Ambos archivos existen o ninguno de los archivos existe.')
```
```python
import json
with open( 'products.json', mode= 'r') as file:
products = json.load(file)
#mostra contenido
for product in products:
#print(product)
print(f"product:{product['name']} price:{product["price"]} quantity:{product["quantity"]}")
```Le agg que diera la información de la cantidad al momento de solicitarle la informacion del archivo json
El manejo de archivos JSON en Python es muy útil para almacenar y recuperar datos de forma estructurada, como si fuera un diccionario de Python.
El manejo de archivos JSON**** implica leer, escribir y modificar archivos en formato JSON.
JSON es un formato de texto ligero y muy utilizado para intercambiar datos
```js
#######################################
#CONVERTIR ARCHIVO JSON EN ARCHIVO CVC #
########################################
import json
import csv
# Función para convertir JSON a CSV
def json_to_csv(json_file_path, csv_file_path):
# Abrir el archivo JSON y leer los datos
with open(json_file_path, mode='r', encoding='utf-8') as json_file:
data = json.load(json_file)
# Obtener las claves (nombres de columnas) del primer elemento en el JSON
keys = data[0].keys()
# Abrir el archivo CSV y escribir los datos
with open(csv_file_path, mode='w', newline='', encoding='utf-8') as csv_file:
csv_writer = csv.DictWriter(csv_file, fieldnames=keys)
# Escribir los encabezados (nombres de las columnas)
csv_writer.writeheader()
# Escribir las filas
csv_writer.writerows(data)
# Ruta de entrada del archivo JSON y salida del archivo CSV
json_file_path = 'productos.json'
csv_file_path = 'productos-nuevo.csv'
# Llamar la función para convertir el archivo
json_to_csv(json_file_path, csv_file_path)
```
```js
##########################################
# CONVERTIR ARCHIVOS CSV A ARCHIVOS JSON #
##########################################
import csv
import json
# Función para convertir CSV a JSON
def csv_to_json(csv_file_path, json_file_path):
data = []
# Abrir el archivo CSV y leerlo
with open(csv_file_path, mode='r', encoding='utf-8') as csv_file:
csv_reader = csv.DictReader(csv_file)
# Convertir cada fila del CSV a diccionario y añadirla a la lista
for row in csv_reader:
data.append(row)
# Guardar los datos en formato JSON
with open(json_file_path, mode='w', encoding='utf-8') as json_file:
json.dump(data, json_file, indent=4)
# Ruta de entrada del archivo CSV y salida del archivo JSON
csv_file_path = 'productos.csv'
json_file_path = 'productos_nuevo.json'
# Llamar la función para convertir el archivo
csv_to_json(csv_file_path, json_file_path)
```
Hola con todos, les comparto mi codigo usando lo proporcionado en la clase:
```js
import csv
import json
# CONVERTIR DE CSV A JSON
file_path_csv = 'products_updated.csv'
file_path_json = 'products.json'
data = []
with open(file_path_csv, mode= 'r') as file :
csv_reader = csv.DictReader(file)
# En el siguiente código una fila iterar sobre el csv_reader, y se agregara dentro de la lista data:
for row in csv_reader:
data.append(row)
with open(file_path_json, mode= 'w') as file_json:
json.dump(data, file_json, indent= 4 )
# CONVERTIR DE JSON A CSV
file_path_csv = 'products_upd.csv'
file_path_json = 'products.json'
datacsv = []
with open(file_path_json, mode= 'r') as file_json:
json_file = json.load(file_json)
for row in json_file:
datacsv.append(row)
with open(file_path_csv, mode= 'w', newline= '') as file:
csv_writer = csv.DictWriter(file, fieldnames= json_file[0].keys())
csv_writer.writeheader()
for row in datacsv:
csv_writer.writerow(row)
```import csvimport json
\# CONVERTIR DE CSV A JSON
file\_path\_csv = 'products\_updated.csv'file\_path\_json = 'products.json'data = \[]
with open(file\_path\_csv, mode= 'r') as file : csv\_reader = csv.DictReader(file) # En el siguiente código una fila iterar sobre el csv\_reader, y se agregara dentro de la lista data: for row in csv\_reader: data.append(row)
with open(file\_path\_json, mode= 'w') as file\_json: json.dump(data, file\_json, indent= 4 ) # CONVERTIR DE JSON A CSV
file\_path\_csv = 'products\_upd.csv'file\_path\_json = 'products.json'datacsv = \[]
with open(file\_path\_json, mode= 'r') as file\_json: json\_file = json.load(file\_json) for row in json\_file: datacsv.append(row)
with open(file\_path\_csv, mode= 'w', newline= '') as file: csv\_writer = csv.DictWriter(file, fieldnames= json\_file\[0].keys()) csv\_writer.writeheader() for row in datacsv: csv\_writer.writerow(row)
Bueno, esto fue más sencillo, aprendi una nueva cosa que es el encoding, para no tener problemas con el uso de caracteres especiales, existen varios, pero en este caso que era una lista de pc's pues era necesario solo el utf-8.
Les dejo mi codigo, si lo quieren ver:
```python
import csv, json
file_path = 'Archivos\JSON\pc.csv'
new_file_path = 'Archivos\JSON\pc.json'
with open(file_path, 'r', encoding='utf-8') as csv_file:
csv_reader = csv.DictReader(csv_file) # Se crea un objeto csv_reader
data = [row for row in csv_reader] # Se crea una lista con los datos del archivo csv
json_data = json.dumps(data, indent=7) # Se convierte la lista en un objeto json con indentación de 4 espacios
with open(new_file_path, mode='w', encoding='utf-8') as json_file:
json_file.write(json_data) # Se escribe la información en el archivo json
```
```js
import csv,json
FILE = 'products_2.csv'
json_fle = 'products2.json'
with open(FILE, mode='r') as csvFile:
csv_reader = csv.DictReader(csvFile)
# convertir las filas a una lista de diccionarios
filas = list(csv_reader)
# Guardar en un archivo JSON
with open(json_fle, mode='w') as newJsonFile:
json.dump(filas, newJsonFile, indent=4)
pass
```import csv,json
FILE = 'products\_2.csv'json\_fle = 'products2.json'
Como tal lo que se hizo fue reemplazar todo el json inicial por otro con el fin de agregar un elemento, sobrescribimos todo el archivo, **¿**cierto?. No sé si me equivoco.
**¿**No puede implementarse para los archivos json un modo 'a', de forma semejante a como se hizo con los archivos csv?. Acá son pocos elementos, pero supongo que si llegan a ser muchísimos más, seguir el procedimiento tal como lo hicimos en clase afectaría el performance.
Primero intenté hacer el código yo misma y tuve algunos errores así que le dije a ChatGPT que corrigiera mi código y me solucionó todo. 😅
De csv a json:
import csv
import json
file_path = "products.csv"
updated_file_path = "products_json.json"
with open(file_path, mode="r") as file:
csv_reader = csv.DictReader(file)
products = [row for row in csv_reader]
with open(updated_file_path, mode="w") as file:
json.dump(products, file, indent=3)
De json a csv:
import csv
import json
file_path = "products.json"
updated_file_path = "products_csv.csv"
with open(file_path, mode="r") as file:
products = json.load(file)
fieldnames = products[0].keys()
with open(updated_file_path, mode="w", newline="") as file:
csv_writer = csv.DictWriter(file, fieldnames=fieldnames)
csv_writer.writeheader()
csv_writer.writerows(products)
reto:
```js
import csv
import json
leer = 'products_updated.csv'
info = 'reto.json'
with open(leer, 'r') as file:
reader = csv.DictReader(file)
data = []
for i in reader:data.append(i)
with open(info, 'w') as file:
json.dump(data, file, indent=4)
```
Disfrute mucho de realizar este reto, intente aplicar todo lo que hemos ido aprendiendo en el curso, también utilice la librería "OS" para obtener la ruta del proyecto ya que en mi caso guardo los archivos de recursos en un directorio diferente a los de código.
```python
#CSV input file
"""
Brand,Model,Year,Price in dolars
Toyota,Corolla,2020,20000
Honda,Civic,2019,22000
Ford,Mustang,2021,30000
Chevrolet,Camaro,2018,25000
BMW,X5,2022,50000
"""
import os
import csv
import json
os.system('cls' if os.name == 'nt' else 'clear')
filePath = os.path.join(os.getcwd(), "Resources", "autos.csv")
newfilePath = os.path.join(os.getcwd(), "Resources", "autos.json")
exchange_Rate_USD_To_CRC = 526
#Convert US dollars To Costa Rican Colones
def ConvertUSDToCRC(value):
return f"{float(value) * exchange_Rate_USD_To_CRC:.2f}"
def CSV_TO_JSON():
try:
#Open CSV file
with open(filePath, mode='r') as csvFile:
csv_reader = csv.DictReader(csvFile)
#csv_reader to object list
data = list(csv_reader)
#Add new column
data = list(map(lambda row:{ **row, 'Price in colones': ConvertUSDToCRC(row['Price in dolars']) if 'Price in dolars' in row else None }, data))
#Save as new Json file
with open(newfilePath, mode='w',encoding='utf-8') as jsonFile:
json.dump(data, jsonFile,indent=4,ensure_ascii=True)
print(f"Listo, puede consultar el resultado en:{newfilePath}")
except:
print("Error en la conversion")
CSV_TO_JSON()
```#CSV input file
"""
Brand,Model,Year,Price in dolars
Toyota,Corolla,2020,20000
Honda,Civic,2019,22000
Ford,Mustang,2021,30000
Chevrolet,Camaro,2018,25000
BMW,X5,2022,50000
"""
import os
import csv
import json
os.system('cls' if os.name == 'nt' else 'clear')
filePath = os.path.join(os.getcwd(), "Resources", "autos.csv")
newfilePath = os.path.join(os.getcwd(), "Resources", "autos.json")
exchange\_Rate\_USD\_To\_CRC = 526
\#Convert US dollars To Costa Rican Colones
def ConvertUSDToCRC(value):
return f"{float(value) \* exchange\_Rate\_USD\_To\_CRC:.2f}"
def CSV\_TO\_JSON():
try:
\#Open CSV file
with open(filePath, mode='r') as csvFile:
csv\_reader = csv.DictReader(csvFile)
\#csv\_reader to object list
data = list(csv\_reader)
\#Add new column
data = list(map(lambda row:{ \*\*row, 'Price in colones': ConvertUSDToCRC(row\['Price in dolars']) if 'Price in dolars' in row else None }, data))
\#Save as new Json file
with open(newfilePath, mode='w',encoding='utf-8') as jsonFile:
json.dump(data, jsonFile,indent=4,ensure\_ascii=True)
print(f"Listo, puede consultar el resultado en:{newfilePath}")
except:
print("Error en la conversion")
CSV\_TO\_JSON()
```js
import csv
import json
def csv_a_json(csv_file, json_file):
# Leer archivo CSV
with open(csv_file, mode='r') as archivo_csv:
lector_csv = csv.DictReader(archivo_csv)
filas = list(lector_csv)
# Escribir archivo JSON
with open(json_file, mode='w') as archivo_json:
json.dump(filas, archivo_json, indent=4)
# Uso de la función
csv_a_json('archivo.csv', 'archivo.json')
```
**convertir de Json a csv**
```js
import json
import csv
def json_a_csv(json_file, csv_file):
# Leer archivo JSON
with open(json_file, mode='r') as archivo_json:
datos = json.load(archivo_json)
# Obtener los nombres de las columnas
columnas = datos[0].keys()
# Escribir archivo CSV
with open(csv_file, mode='w', newline='') as archivo_csv:
escritor_csv = csv.DictWriter(archivo_csv, fieldnames=columnas)
escritor_csv.writeheader()
escritor_csv.writerows(datos)
# Uso de la función
json_a_csv('archivo.json', 'archivo.csv')
```
\# Escribir archivo CSV
with open(csv\_file, mode='w', newline='') as archivo\_csv:
escritor\_csv = csv.DictWriter(archivo\_csv, fieldnames=columnas)
escritor\_csv.writeheader()
escritor\_csv.writerows(datos)
\# Uso de la función
json\_a\_csv('archivo.json', 'archivo.csv')
RETO:
```js
# CSV A JSON
import csv
import json
file_csv='clase32/products.csv'
reto_csv_to_json='clase32/reto_csv_to_json.json'
data=[]
with open(file_csv,'r') as fileCSV:
csvreader=csv.DictReader(fileCSV)
for row in csvreader:
data.append(row)
with open(reto_csv_to_json,mode='w') as file:
json.dump(data,file,indent=4)
print(data[0:3])
# [{'name': 'Laptop', 'price': '1200', 'quantity': '4', 'brand': 'BrandName', 'category': 'Electronics', 'entry_date': '2024-01-05'}, {'name': 'Mouse', 'price': '45', 'quantity': '120', 'brand': 'TechGear', 'category': 'Accessories', 'entry_date': '2024-02-10'}, {'name': 'Keyboard', 'price': '70', 'quantity': '60', 'brand': 'KeyMasters', 'category': 'Accessories', 'entry_date': '2024-02-12'}]
# JSON A CSV
import csv
import json
file_json ='clase32/products.json'
reto_json_to_csv ='clase32/reto_json_to_csv.csv'
with open(file_json, 'r') as file:
data = json.load(file)
headers = data[0].keys()
with open(reto_json_to_csv, mode='w', newline='') as file:
csv_writer = csv.DictWriter(file, fieldnames=headers)
csv_writer.writeheader()
csv_writer.writerows(data)
for row in data:
print(row)
# {'name': 'Laptop', 'price': 1200, 'quantity': 4, 'brand': 'BrandName', 'category': 'Electronics', 'entry_date': '2024-01-05'}
# {'name': 'Mouse', 'price': 45, 'quantity': 120, 'brand': 'TechGear', 'category': 'Accessories', 'entry_date': '2024-02-10'}
# {'name': 'Headphones', 'price': 150, 'quantity': 25, 'brand': 'SoundMax', 'category': 'Audio', 'entry_date': '2024-03-15'}
```
1\) .csv a .json:
import csv import json#se debe colocar las dos extensiones, debido a que se encadena el paso de informacion de un archivo a otrofile\_csv= 'csv2json.csv' #Archivo principal, donde se estrae la info .csvfile\_json= 'myfile.json.json' #Archivo nuevo que se crea y donde cae la info .csv
with open(file\_json, mode="r") as data: #se debe de abrir como datos, no como libro. json= json.load(data) #busca la carga de datos segun la extension.
fieldname=json\[0].keys() #organiza los campos en formato jsonwith open('datos.csv', mode="w", newline=('')) as file\_csv: #se indica la apertura del archivo para sobreescribirse csv\_writer= csv.DictWriter(file\_csv, fieldnames=fieldname) #se indica al escritor la extension en que debe de sobreescribirse csv\_writer.writeheader() #ejecuta la escritura en csv for row in json: #para cada linea en el archivo, se aplicara: csv\_writer.writerow(row) #se escribira cada linea en .csv.
2\) .json a .csv:
import csvimport json#se debe colocar las dos extensiones, debido a que se encadena el paso de informacion de un archivo a otro
file\_csv= 'csv2json.csv' #Archivo principal, donde se estrae la info .csvfile\_json= 'myfile.json.json' #Archivo nuevo que se crea y donde cae la info .csv
with open("csv2json.csv", mode= "r") as data: #se debe de abrir como datos, no como libro. csv\_reader= csv.DictReader(data) #se indica la lectura en forma de diccionario y en extension .csv products= list(csv\_reader) #se indica que los productos se lea en lista con la extension .csv
with open('myfile.json.json', mode="w") as file\_json: #se abre el archivo json en modo escritura json.dump(products, file\_json, indent=4) #se escribe la lista de diccionarios en el archivo JSON con una indentación de 4 espacios para mayor legibilidad.
Codigo de JSON a CSV
```js
import csv
import json
file_json='products_json.json'
new_csv_file='new_csv.csv'
with open(file_json,'r') as filejson:
data=json.load(filejson)
headers=data[0].keys()
with open(new_csv_file,mode='w',newline='') as filecsv:
csv_writer=csv.DictWriter(filecsv,fieldnames=headers)
csv_writer.writeheader()
csv_writer.writerows(data)
```
### 3. Archivos JSON (JavaScript Object Notation)
* **Propósito**: Intercambio y almacenamiento de datos estructurados.
* **Usos**: APIs web, configuraciones de aplicaciones, almacenamiento de datos con estructura jerárquica.
* **Ventajas**: Estructura flexible, legible por humanos, nativo en JavaScript, soportado en muchos lenguajes.
* **Aplicaciones**: Comunicación cliente-servidor en aplicaciones web, configuraciones de aplicaciones, almacenamiento de datos con estructura compleja.
```python
# Ejemplo 3: Archivo JSON (JavaScript Object Notation)
# Crear y leer información de una receta
import json
def ejemplo_json():
# Crear un archivo JSON con datos de una receta
receta = {
"nombre": "Tortilla Española",
"tiempo_preparacion": "30 minutos",
"ingredientes": [
{"nombre": "Huevos", "cantidad": "4 unidades"},
{"nombre": "Patatas", "cantidad": "2 medianas"},
{"nombre": "Cebolla", "cantidad": "1 pequeña"},
{"nombre": "Aceite de oliva", "cantidad": "3 cucharadas"}
],
"pasos": [
"Pelar y cortar las patatas y la cebolla",
"Freír a fuego lento hasta que estén tiernas",
"Batir los huevos y mezclar con las patatas",
"Cuajar a fuego medio-bajo por ambos lados"
]
}
with open("receta.json", "w", encoding="utf-8") as archivo:
json.dump(receta, archivo, indent=4, ensure_ascii=False)
# Leer el archivo JSON
print("\n--- Contenido del archivo JSON ---")
with open("receta.json", "r", encoding="utf-8") as archivo:
datos = json.load(archivo)
print(f"Receta: {datos['nombre']}")
print(f"Tiempo de preparación: {datos['tiempo_preparacion']}")
print("Ingredientes:")
for ingrediente in datos["ingredientes"]:
print(f"- {ingrediente['nombre']}: {ingrediente['cantidad']}")
```
Buenas tardes,
Adjunto el reto, donde le adicione el menú para que el programa nos de las opciones de csv a json o viceversa.
El programa se encuentra alojado en mi cuenta github:
<https://github.com/rapolan2050/converjsontocsv.git>
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?