Leer un CSV

En este momento me doy cuenta que me gusta y prefiero Pandas jajajaja

Para transformar el iterable en un diccionario también se puede hacer:

country_dict = dict(iterable)

Muy buena la clase y muy bien explicado, pero vaya que no es fácil familiarizarse con todos esos conceptos así de primera

me pareció que es mas simple si si omitimos lo del for para crear el diccionario y simplemente hacerlo de esta forma, por si alguien le sirve
import csv

def reader_csv(path):
with open(path, ‘r’) as csvfile:
reader = csv.reader(csvfile, delimiter= ‘,’)
header = next(reader)
data = []
for row in reader:
iterable = zip(header, row)
prueba =dict((iterable))
data.append(prueba)
return data
if name == ‘main’:
data = reader_csv(‘d:\prueba\propython\world_population.csv’)
print (data)

no es por nada pero hay un método que ya resuelve lo de pasar los datos a diccionarios:

fileCSV = csv.DictReader(file,delimiter=',')

Leer un csv

#----- modulo para leer el acrhivo csv --------
import csv

# funcion abrir archivo
def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')

    #nombre de las columnas se encuentra en la primera fila
    header = next(reader)
    
    data = []
    for row in reader:
      iterable =zip(header, row) # une los valores de la listas en tuplas
      country_dict = {key:value for key, value in iterable}
      data.append(country_dict)
      print(country_dict)

    return data

# correr archivo como script desde la terminal
if __name__ == '__main__':
  data = read_csv('./app/data.csv')
  print(data)

No se si alguien tiene esta duda, pero capaz ayuda a alguno
Si alguien no entiende por qué hace next una sola vez y luego muestra las columnas acá te lo intento explicar un poco

Si empezamos a leer el CSV desde Excel, por ejemplo, se nos mostrará en la primera fila los nombres para que nos guíemos a la hora de leerlo. La primera fila NO tiene países, es solo de guía. Es por eso que hace el next() una vez.

¿Qué es un archivo CSV?

• Un archivo CSV es un tipo de archivo que se utiliza para almacenar datos en una forma tabular estructurada (fila / columna). Es un archivo de texto plano y, como su nombre lo indica, almacena los valores separados por una coma.

• En este artículo, tendremos una discusión detallada sobre cómo leer, escribir y analizar un archivo CSV en Python.

Fuente del archivo CSV

• El concepto de tener un archivo CSV nació de la necesidad de exportar grandes cantidades de datos de un lugar a otro (programas). Por ejemplo, importando datos de una hoja de cálculo de gran tamaño y exportándolos a una base de datos. Asimismo, podemos exportar grandes cantidades de datos a programas.

• Los diferentes lenguajes usan diferentes formatos para almacenar datos, por lo que cuando los programadores necesitan exportar datos de un programa a otro, sienten la necesidad de tener algún tipo de archivo universal con el cual transferir grandes cantidades de datos; Un tipo de archivo que cualquier programa puede leer y analizar en su propio formato.

Excelente clase, deberiamos separar en otra función la lógica de obtener la lista de diccionarios de el csv.
.
Podriamos tener como reto crear esa función 4 veces utilizando todos los métodos usados en el curso:

1. Método de iteración: ya lo hizo el profe en la clase
2. Método de loop: con ciclos for con vanilla python
3. Método de list comprehensions
4. Método de list y dict mapping

Siento que cada clase la entiendo, de hecho escribo el código durante la clase, pero al otro día si me dan hoja en blanco es muy dificil acordarse la estructura 😥

mismo codigo que el del profesor pero aplicando mas el paradigma funcional

si tienen alguna opinión de como apegarse mas al paradigma por favor compártelo

import csv


def dict_whit_data(clave, value):
    """funcion que nos permite retornar un diccionario a partir de los valores de dos listas

    Args:
        clave (list): clave que tendra el diccionario
        value (list): valores que tendra el diccionario

    Returns:
        dict: diccionario con datos de las listas
    """
    iterable = zip(clave, value)
    country_dict = {clave : value for clave, value in iterable}
    return country_dict

def read_csv(path):
    with open(path, 'r') as csvfile:
        reader = csv.reader(csvfile)
        header = next(reader)
        # le pasamos las claves desde el escope de las funcion read_csr devido a que si se lo paso a la map esta estaria enviando a la funcion dict_whit_data cada valor dentro del array lo que queremos es el array completo
        
        data = list(map(lambda value: dict_whit_data(header, value) ,reader))

        return data
if __name__ == '__main__':
    path = 'world_population.csv'
    data = read_csv(path)
    print(data[0])

Estoy viendo dos veces la clase para entender mejor. Primero escribo el código mientras escucho a Nicolás para ir entendiendo cada línea. Luego repito la clase y analizo cada línea sin tener que preocuparme por escribir

yo lo que hice fue esto

import csv


def read_csv(path):
    with open(path, 'r') as csvfile:
        reader = csv.reader(csvfile, delimiter=',')
        header = next(reader)
        format_dict = lambda header, row: {header[i]: row[i] for i in range(0, len(header))}
        data = [format_dict(header, row) for row in reader]
        print(data)
        
            
if __name__ == '__main__': 
    read_csv('./11_app/data.csv')

• Puedes convertir los datos de un archivo CSV a un diccionario utilizando la librería estándar csv junto con la función DictReader de la librería.

• La función DictReader devuelve un objeto iterable que tiene cada fila como un diccionario, donde las claves son los nombres de las columnas y los valores son los valores de las filas.

import csv

def csv_to_dict(file_name):
    with open(file_name, newline='') as csvfile:
        reader = csv.DictReader(csvfile)
        data = [row for row in reader]
    return data

data = csv_to_dict("nombre_del_archivo.csv")
print(data)

- 

• En este ejemplo, se utiliza el método open para abrir el archivo. El argumento newline=’’ es necesario para evitar problemas de compatibilidad en diferentes sistemas operativos.

• Luego se utiliza el método csv.DictReader para crear un objeto iterable. Este objeto se construye con el archivo abierto y se usa quotechar=’"’ para indicar que las comillas simples se usan para encerrar textos.

• Luego se itera sobre el objeto para acceder a cada fila, que es un diccionario, donde las claves son los nombres de las columnas y los valores son los valores de las filas.

• En este caso creé la lista con cada una de las filas

De esta forma se puede realizar sn el list comprehesion

import csv

def read_csv(path):
with open(path, ‘r’) as csvfile:
reader = csv.reader(csvfile, delimiter=’,’)
header = reader.next()
print(header)
data = []
for row in reader:
data.append(dict(zip(header, row)))

if name == ‘main’:
data = read_csv(‘world_population.csv’)
print(data[0])

Hola, este es mi código, no quise utilizar la función zip, ya que me pareció un poco engorrosa

def read_csv(path):
    with open(path, 'r') as csvfile: 
        reader = csv.reader(csvfile, delimiter=';') 
        header = next(reader) # Imprime la primera lista, es decir los encabezados que son las llaves para los diccionarios
        data = []
        for row in reader: 
            population = {header[i]:row[i] for i in range(len(row))} # Creación de diccionario con sintaxis reducida, se usa la cabecera como la llave, y cada línea es el contenido
            data.append(population) # Se añade el contenido a una lista vacía.
        return data

if __name__ == '__main__':
    info = read_csv('./conceptos/data.csv') # Imprime la información en forma de lista
    print(info)

Recibo cualquier comentario, gracias 😄

Si lo que quieres es buscar tu pais, simplemente cambias la ultima linea de código por esta lambda

search = list(filter(lambda country: country['Country/Territory'] == 'Venezuela', data))
print(search)

Mi cerebro va a explotar jajaja

Hola!

Les comparto el código de la clase

# Leer un CSV

# https://www.w3schools.com/python/python_file_open.asp
# https://www.kaggle.com/
# https://www.kaggle.com/datasets/iamsouravbanerjee/world-population-dataset

import csv
'''
def read_csv(path):
  with open(path, "r") as csvfile:
    reader = csv.reader(csvfile, delimiter = ",")
    # Convertir lista de registro a diccionario
    header = next(reader)
    print(header)
    for row in reader:
      print("***" * 5)
      print(row)
'''
# Convertir lista de registro a diccionario
def read_csv(path):
  with open(path, "r") as csvfile:
    reader = csv.reader(csvfile, delimiter = ",")
    # Convertir lista de registro a diccionario
    header = next(reader)
    data = []
    for row in reader:
      iterable = zip(header, row)
      #print(list(iterable))
      # Generar diccionario
      country_dict = {key: value for key, value in iterable}
      data.append(country_dict)
    return data

if __name__ == '__main__':
  data = read_csv('./app/world_population.csv')
  print(data[0])

Les dejo mi resolución para convertir mi objeto reader compuesto de listas a una lista de diccionarios que luego imprimo por consola:

import csv

def read_csv(path):
    new_list = []
    new_list_dict = []
    dict_line = {}
    with open(path, 'r') as csvfile:
        reader = csv.reader(csvfile, delimiter=',')
        # Agrego cada lista de mi objeto reader a new_list:
        for row in reader:
            new_list.append(row)    
        # Construyo un dict con clave = primer valor de new_list, 
        # valor = cada uno de los siguiente valores de mi lista
        # luego agrega mi dict a una lista de dict:
        for i in range(1,len(new_list)):
            for j in range(0,len(new_list[i])):
                dict_line[new_list[0][j]] = new_list[i][j]
            new_list_dict.append(dict_line)
            dict_line = {}
        # Itero mi lista de dict para imprimir cada linea con el
        # formato deseado: 
        for dict in new_list_dict:
            print("***" * 5)
            print(dict)

if __name__ == '__main__':
    read_csv('./world_population.csv')

Cualquier feedback es bienvenido.

Saludos,
Marian.

Hola, un pequeño aporte, en el codigo que muestra el profe en el video hay un error. El return que cierra la funcion está a nivel del for, y debe estar al nivel del def de la funcion.

En esa posición solo permite correr una iteracion y envia la salida de la funcion, asi se obtiene solo la info del primer pais

hedeeeeer, heeeedeeeeeeer

Solución Usando dict()

• Modularicé la funcionalidad para parsear el csv a un lista de objetos a una función diferente
• En vez de usar Dictionary Comprehension, usa la función dict() que crea un dictonary desde un tuple, la cual la obtengo usando la función zip()
• En vez de usar un for utilizo Array Comprehension para recorrer las columnas y aplicarle la funcionalidad explicada arriba

import csv


def csv_reader_parser(reader):
    headers = next(reader)
    # zip() creates a tuple zipping two arrays
    # dict() creates a dictonary from a tuple
    return [dict(zip(headers, row)) for row in reader]


def read_csv(path):
    with open(path) as csv_file:
        reader = csv.reader(csv_file, delimiter=',')
        population = csv_reader_parser(reader)

        print(population)

La capital de Bolivia es La Paz (administrativa) y Sucre (constitucional). La Paz es la sede del gobierno y el centro político y económico del país, mientras que Sucre es la sede del Poder Judicial y la Constitución establece que es la capital constitucional de Bolivia.

Hola, creo que en la clase se vieron unas cuantas cosas que no habíamos visto antes, así que voy a dejar el código explicando esas cosas.

import csv

def read_csv(path):
    with open(path, 'r') as csvfile:
    #csvfile es el tipo de archivo con el que trabajamos (csv)
        reader = csv.reader(csvfile, delimiter= ',')
        """
        Vamos a crear un lector del csv, 
        csv es un módulo de python, y tiene la función reader que lee las líneas del csvfile proporcionado.
        
        delimited es la forma en la que vienen separados los datos del archivo, en este caso son comas
        """
        header = next(reader)
        data = []
        for row in reader:
        #row es la cantidad de filas que tiene el documento
            iterable =zip(header, row)
            #zip es un iterador que intercala los elementos de dos interables y los devulve como tuplas.
            country_dict = {key:value for key, value in iterable}
            data.append(country_dict)
        return data
if __name__ == '__main__':
    data = read_csv('./WorldPopulation/data.csv')

Aquí un pequeño aporte, el código comentado paso a paso

import csv 

#definimos la funcion de lectura de csv
def read_csv(path): 
  #abrimos el archivo
  with open(path, 'r') as csvfile: 
    #ejecutamos la lectura para obtener un iterable por columna
    reader = csv.reader(csvfile, delimiter=',') 
    #Iteramos manualmente la primera fila para obtener los encabezados
    header = next(reader) 
    #Generamos la lista donde almacenaremos la info de cada columna que iteremos, como diccionarios
    data = [] 
    #Iteramos cada fila restante del documento, estos seran nuestros "value" de los dicc.
    for row in reader: 
      #Generamos un arreglo con una tupla por cada par "encabezado:columna"
      iterable = zip(header, row) 
      #Generamos diccionarios por cada lista del arreglo, con una entrada de diccionario por cada tupla (encabezado, columna)
      country_dic = {key: value for key, value in iterable} 
      #agregamos cada iteracion en a lista "data"
      data.append(country_dic) 
  #Obtenemos el retorno de la función, al nivel de identación de la apertura de la función
  return data

if __name__ == "__main__":
  data = read_csv("./app/data.csv")
  print(data)
  

Le agregué al codigo un filter para que elijan el pais del cual quieran ver información. Aquí el código:

import csv

def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    data = []
    for row in reader:
      iterable = zip(header, row)
      country_dict = {colum: value for (colum, value) in iterable}
      data.append(country_dict)
    return data

if __name__ == '__main__':
  data = read_csv('./app/data.csv')
  country = input('Choose country ==> ')
  
  result = list(filter(lambda x: x['Country/Territory'] == country, data))
  print(result)

si tengo un concepto equivocado me gustaria que me corrijan. mucha gracias

Yo lo hice de esta manera:

Para los que están en VScode y les aparece el siguiente error (FileNotFoundError), en el Entry point, solamente especifiquen el nombre del CSV, no toda la ruta completa.

import csv

def read_csv(path):
    with open(path, 'r') as csvfile:
        reader = csv.reader(csvfile, delimiter = ',')
        for i in reader:
            print('***' * 5)
            print(i)

if __name__ == '__main__':
    read_csv('./world_population.csv')

No se si en otros editores de código suceda lo mismo, pero al menos en VScode nos simplifica el trabajo de escribir toda la ruta, a mi me funcionó así.

Tengo una duda, a veces me pasa que al ejecutar directamente en la consola de visual studio code el programa si me corre, pero al intentar ejecutarlo desde una terminal externa me aparece un error que ya fue solucionado. Pieso que puede ser un error de memoria. ¿A alguien le ha pasado algo similar?

jugando con el codigo me doy cuenta que de esta manera me da el mismo resultado ,

array = []
def read(path):
    with open (path, "r+") as file:
        read = csv.reader(file, delimiter=",")
        head = next(read)
        for row in read:
            element = zip(head, row)
            array.append(dict(element))
            print(array)



read("../manipulation_files_and_errors/date.csv")

Para que el resultado se vea como queria el profesor en el minuto 8:27, se puede utilizar el modulo “pprint”, les comparto imagen para que vean como se utiliza, es muy sensillo

Playground 38 tampoco sirve, redirecciona a home del curso

Hola chicos, dejo mi pequeño aporte. Adicional a lo que hice el profe, quise crear una funciòn màs que me permita guardar la lista con los diccionarios en un archivo .json, para esto usè el modulo json, cree un archivo .json en la misma carpeta que estamos trabajando este script, y cree la funciòn que recibe como parametro el arreglo de diccionarios a insertar y el archivo .json. Si quieres ver un poco màs sobre como usar el modulo json y los mètodos que tiene y en los cuales me base para esta pequeña mejora, te dejo el link aquì.

Aquì el script:

import csv
import json

def read_csv(path):
    with open(path, 'r') as csvfile:
        reader = csv.reader(csvfile, delimiter=',')
        header = next(reader)
        data = []
        for row in reader:
            iterable = zip(header, row)
            country_dict = {key:value for key,value in iterable}
            data.append(country_dict)

        return data

def convert_json(dict, path):
    with open(path, 'w') as file:
        json.dump(dict, file)


def main():
    data = read_csv('main/app/data.csv')
    convert_json(data, 'main/app/data.json')

if __name__ == '__main__':
    main()

Y aquì una pequeña parte del contenido del json que genera:

[
    {
        "Rank": "36",
        "CCA3": "AFG",
        "Country/Territory": "Afghanistan",
        "Capital": "Kabul",
        "Continent": "Asia",
        "2022 Population": "41128771",
        "2020 Population": "38972230",
        "2015 Population": "33753499",
        "2010 Population": "28189672",
        "2000 Population": "19542982",
        "1990 Population": "10694796",
        "1980 Population": "12486631",
        "1970 Population": "10752971",
        "Area (km\u00b2)": "652230",
        "Density (per km\u00b2)": "63.0587",
        "Growth Rate": "1.0257",
        "World Population Percentage": "0.52"
    },
    {
        "Rank": "138",
        "CCA3": "ALB",
        "Country/Territory": "Albania",
        "Capital": "Tirana",
        "Continent": "Europe",
        "2022 Population": "2842321",
        "2020 Population": "2866849",
        "2015 Population": "2882481",
        "2010 Population": "2913399",
        "2000 Population": "3182021",
        "1990 Population": "3295066",
        "1980 Population": "2941651",
        "1970 Population": "2324731",
        "Area (km\u00b2)": "28748",
        "Density (per km\u00b2)": "98.8702",
        "Growth Rate": "0.9957",
        "World Population Percentage": "0.04"
    }
]

¡Nunca pares de aprender! 😄

funcionan mucho los archivos csv! que genial

EXPLICACIÓN PASO A PASO

import csv
# Abre el archivo CSV en modo lectura
def read_csv(ruta_file):
    with open(ruta_file, mode='r') as csvfile:
        lector_csv = csv.reader(csvfile, delimiter=',')
        data = []
        # Lee la primera fila como las claves
        claves = next(lector_csv)
        for fila in lector_csv:
            # Crea un diccionario utilizando las claves y los valores de la fila actual
            iterable = zip(claves, fila)
            country_dict = {key: value for key, value in  iterable}
            data.append(country_dict)
        return data

if __name__ == '__main__':
    resultado = read_csv('./data.csv')
    print(resultado[0])

Aquí tienes una explicación paso a paso del código:

1. Importar la biblioteca csv:

   import csv
   

   Se importa la biblioteca csv, que proporciona funcionalidades para trabajar con archivos CSV en Python.

2. Definir una función read_csv:

   def read_csv(ruta_file):
   

   Se define una función llamada read_csv que toma como argumento ruta_file, que es la ruta al archivo CSV que se va a leer.

3. Abrir el archivo CSV en modo lectura:

   with open(ruta_file, mode='r') as csvfile:
   

   Se abre el archivo CSV especificado en modo lectura ('r') utilizando la función open. La declaración with se utiliza para garantizar que el archivo se cierre correctamente después de su uso.

4. Crear un lector CSV:

   lector_csv = csv.reader(csvfile, delimiter=',')
   

   Se crea un lector CSV utilizando la función csv.reader. El argumento delimiter=',' especifica que las columnas en el archivo CSV están separadas por comas.

5. Inicializar una lista data:

   data = []
   

   Se inicializa una lista llamada data que se utilizará para almacenar los datos del archivo CSV.

6. Leer la primera fila como claves:

   claves = next(lector_csv)
   

   Se utiliza next(lector_csv) para leer la primera fila del archivo CSV, que generalmente contiene las claves o nombres de las columnas. Estas claves se almacenan en la variable claves.

7. Iterar a través de las filas del archivo:

   for fila in lector_csv:
   

   Se inicia un bucle for que itera a través de las filas del archivo CSV después de la primera fila.

8. Crear un diccionario para cada fila:

   iterable = zip(claves, fila)
   country_dict = {key: value for key, value in  iterable}
   

   Para cada fila, se crea un diccionario utilizando las claves (nombres de columnas) de la primera fila y los valores de la fila actual. Esto se hace utilizando la función zip para combinar las claves y los valores en pares, y luego se utiliza una comprensión de diccionario para crear el diccionario country_dict.

9. Agregar el diccionario a la lista de datos:

   data.append(country_dict)
   

   El diccionario country_dict, que representa una fila de datos, se agrega a la lista data.

10. Devolver la lista de datos:

    return data
    

    Finalmente, la función read_csv devuelve la lista data que contiene todos los datos del archivo CSV.

11. Llamada a la función desde el bloque principal:

    if __name__ == '__main__':
        resultado = read_csv('./data.csv')
        print(resultado[0])
    

    El código en este bloque principal verifica si el script se está ejecutando como un programa independiente (if __name__ == '__main__':). Luego, llama a la función read_csv con la ruta del archivo CSV “data.csv” y muestra la primera fila de datos en la lista resultante.

En resumen, este código define una función read_csv que lee un archivo CSV, convierte sus datos en diccionarios y los almacena en una lista. Luego, muestra la primera fila de datos recuperada del archivo CSV. Esto es especialmente útil cuando deseas trabajar con datos tabulares almacenados en archivos CSV en Python.

Yo hice el codigo para tener el archivo csv en un diccionarios dentro de un array de la siguiente forma.

import csv 
my_finally_data = []
def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    for sec in reader:
      my_dict = {keys:data for keys in header for data in sec}
      my_finally_data.append(my_dict)

if __name__ == '__main__':
  read_csv('./app/data.csv')
  print(my_finally_data)

Yo lo hice de varias formas, pero el que más me gusto fue esta:

def read_csv():
    with open("app/data/data.csv", mode="r") as data_csv:
        lector_csv = csv.DictReader(data_csv, delimiter=',')
        data = []
        for i in lector_csv:
            data.append(i)
        print(data[0])

Mi código:

import csv

#Creamos funcion para leer csv
def read_csv(path):
    #usamos metodo 'open' para abrir el archivo, le damos permiso de lectura y usamos el csv con el nombre de 'csv_file'
    with open(path, 'r') as csv_file:
        #creamos la variable 'reader', donde llamamos al metodo reader de la libreria csv. Este es un metodo que itera registro por registro.
        #Separa cada campo por una ',' o ';' depende el csv
        reader = csv.reader(csv_file, delimiter=',')
        #Como itera el csv, accedemos al primer registro para tener los valores del 'header'
        columns = next(reader)
        #creamos array vacio para llenarlo despues y que sea una lista de diccionarios
        dict_countrys = []

        #Iteramos el reader para crear nuestra lista de diccionarios
        for row in reader:

            #creamos una comprehension function para matchear los clave valor del header, con cada fila que itera nuestro for
            #para machearlos, es importante que itere dentro del 'zip(columns, row) ya que asi se crean las parejas en tuplas(clave, valor)'
            #ejemplo: ('country': 'Argentina')
            iteration_rows_with_keys = {key:value for key, value in zip(columns, row)}

            #Por cada iteracion, lo metemos dentro de la lista, para que se cree nuestra lista de dictionarys [{},{}...]
            dict_countrys.append(iteration_rows_with_keys)
    #retornamos la lista
    return dict_countrys

#hacemos print y accedemos al diccionario posicionado en el 0
print(read_csv('./data.csv')[0])

estuve leyendo y hay formas mas faciles de hacerlo y es con La librería Pandas, solo toca instalarla con pip

Investigando un poco, el modulo csv tiene el recurso csv.DictReader(). Y la funcion me quedo mas corta.

Asi

def reas_csv2(path):
    with open(path, "r") as csv_file:
        reader = csv.DictReader(csv_file, delimiter=",")
        data = list(reader)
    return data

o asi:

def reas_csv2(path):
    with open(path, "r") as csv_file:
        reader = list(csv.DictReader(csv_file, delimiter=","))
    return reader

Les comparto 2 funciones que hice para ayudarte a ver los resultados de forma visual

• muestra de forma parecida a un json una lista de diccionarios

# muestra de forma parecida al formato json una LISTA DE DICCIONARIOS
def printListDic(data):
    for dic in data:
        print('{')
        for key, value in dic.items():
            print(' ', key, ":", value)
        print("}")

• muestra de forma parecida a formato json un DICCIONARIO

# muestra de forma parecida a un json un diccionario
def printDic(data):
    print('{')
    for key, value in data.items():
        print(' ', key, ":", value)
    print('}')

def read_csv(path):
    with open(path, "r") as csv_file:
        reader = csv.reader(csv_file, delimiter=",")
        titles_keys = next(reader)
        # print(titles_keys)
        # print(type(titles_keys))
        data = []
        for row in reader:
            iterable = zip(titles_keys, row)
            country_dic = {key: value for key, value in iterable}
            # print('***'*5)
            # printDic(country_dic)
            data.append(country_dic)
    return data

if __name__ == "__main__":
    data = read_csv('./files/data.csv')
    #ejemplo de uso de las funcions printDic(dictionary) - printListDic(ListDictionary])
    # printDic(data[1])
    printListDic(data)

#----- modulo para leer el acrhivo csv --------
import csv

# funcion abrir archivo
def read_csv(path):
  with open(path, 'r') as csvfile:
    #Nota: Reader es Iterable.
    reader = csv.reader(csvfile, delimiter=',')
    cabecera = next(reader)
    data = []
    #print(cabecera)
    #1. Para leer un archivo, primero hay que leerlo linea por linea con un for. 
    for row in reader:
      #2. Se itera la cabecera junto con la fila, en una Tupla.
      iterable = zip(cabecera,row)
      print('***' * 5)
      #print(row)
      #print(list(iterable))
      #3. Crear el diccionario
      country_dicty = {llave: valor for llave, valor in iterable}
      #Agregar el diccionario a una lista vacia creada data para crear una lista de diccionarios
      data.append(country_dicty)
    return data
# correr archivo como script desde la terminal
if __name__ == '__main__':
  data = read_csv('./app/data.csv')
  print(data)

Esta fue mi manera de solucionarlo, que opinan:

import csv


def read_csv(path):
    my_list = []
    with open(path) as csv_file:
        reader = csv.reader(csv_file, delimiter=',')
        next(reader)

        for row in reader:
            my_list.append({
                'country': row[2],
                'population': row[5],
                'world_population_percentage': row[-1],
            })
    return my_list


if __name__ == '__main__':
    data = read_csv('./data.csv')
    print(data)

Mi aporte:
Lo que hice fue que en lugar de un dict comprehension hice directamente un list comprehension de diccionarios (campo : territorio)

import csv

def openFileCSV(path):
    with open(path, "r") as csvfile:
        archivoCSV = csv.reader(csvfile, delimiter=",")
        header = next(archivoCSV)
        listaDiccionarios = [dict(zip(header, row)) for row in archivoCSV]
        # listaDiccionarios = []
        # for row in archivoCSV:
        #     listaDiccionarios.append(dict(zip(header, row)))
    return listaDiccionarios

Decidi intentar hacer algo diferente, aqui el resultado:

from pathlib import Path
import matplotlib.pyplot as plt
import os

def get_data(csv_path:Path, required_headers:list = None)->list:
    data = []
    if os.path.exists(csv_path):
        with open(csv_path, 'r') as csv:
            headers = next(csv)
            headers = headers.split(',')
            hdrs = get_required_headers_with_index(headers, required_headers)
            for row in csv:
                row_list = row.split(',')
                element:dict = {}
                for index, value in enumerate(row_list):
                    if index in hdrs.keys():
                        head = hdrs[index]
                        element[head] = value
                data.append(element)
                del element
                        
    else:
        raise Exception(' -- csv not found -- ')
    return data




def get_required_headers_with_index(headers:list = None, required_headers:list = None)->dict:
    result:dict = {}
    if headers is None:
        raise Exception('headers is required')
    if required_headers is not None:
        for index, value in enumerate(headers):
            if value in required_headers:
                result[index] = value
    else:
        for index, value in enumerate(headers):
            result[index] = value
    return result




if __name__=='__main__':
    print('\n\n\n')
    data = get_data(
        csv_path='./data.csv', 
        required_headers=['Country', 'Capital', 'Continent', '2022 Population']
        )
    print(len(data))
    print(data[0])
    print(data[1])
    print(data[2])
    print(data[230])

A mi me sucede algo curioso.
Yo en todo el proyecto he estado trabajando con pycharm.
Sin embargo, me da error al poner un directorio con ruta relativa: ‘./app/data.csv’.

Para corregir esto, tuve que poner la ruta absoluta:
Así:

import csv

def read_csv(path):
    with open(path, 'r') as csvfile:
        reader = csv.reader(csvfile, delimiter=',')  # definimos el delimitador que tiene el archivo
        for row in reader:
            print('***' * 5)
            print(row)

if __name__ == '__main__':
    data_file = 'G:/Mi unidad/_Cursos Digitales/@Platzi/Data Scientist con Python/02-Curso de Python - Comprehensions, Funciones y Manejo de Errores/platzi_curso_python_p2/app/data.csv'
    read_csv(data_file)

BUSQUE UNOS EJEMPLOS DE LEER UN CSV

import csv

# Ruta al archivo CSV
ruta_archivo = 'archivo.csv'

# Abrir el archivo CSV en modo lectura
with open(ruta_archivo, 'r') as archivo_csv:
    # Crear un objeto lector de CSV
    lector_csv = csv.reader(archivo_csv)

    # Iterar sobre cada fila del archivo CSV
    for fila in lector_csv:
        # Acceder a los datos de cada columna en la fila actual
        columna1 = fila[0]
        columna2 = fila[1]
        # ... y así sucesivamente

        # Hacer algo con los datos, por ejemplo, imprimirlos
        print(columna1, columna2)

Si quieren leer las columnas de una manera mas ordenada en la consola, pueden importar el modulo pprint.

from pprint import pprint

Cuando impriman data con mucha información, tendran un output mas legible

***************
['63',
 'ZMB',
 'Zambia',
 'Lusaka',
 'Africa',
 '20017675',
 '18927715',
 '16248230',
 '13792086',
 '9891136',
 '7686401',
 '5720438',
 '4281671',
 '752612',
 '26.5976',
 '1.028',
 '0.25']
***************
['74',
 'ZWE',
 'Zimbabwe',
 'Harare',
 'Africa',
 '16320537',
 '15669666',
 '14154937',
 '12839771',
 '11834676',
 '10113893',
 '7049926',
 '5202918',
 '390757',
 '41.7665',
 '1.0204',
 '0.2']

Excelente clase, muy util.
Para los que quieran configurar el kaggle en el WSL y descargarlos desde la consola
https://github.com/Kaggle/kaggle-api

Me encantó! Muy bueno! Es re interesante como se maneja la data 😎

No creo que haya quedado claro de donde sale el “import csv”, acá les dejo un enlace por si quieren profundizar a detalle: link

import csv

def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    data = []
    print(header)
    for row in reader:
      iterable = zip(header, row)
      country_dict = {key: value for key, value in iterable}
      print(country_dict)
      data.append(country_dict)
    return data

if __name__ == '__main__':
  data = read_csv('./app/data.csv')
  print(data)
  

Con este codigo pueden filtrar por nombre de pais o por numero de posicion en el rango:

import csv

def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    # print(header)
    data = []
    for row in reader:
      iterable = zip(header, row)
      # print(list(iterable))
      country_dict = {key: value for key, value in iterable}
      # print(country_dict)
      data.append(country_dict)
    return data

if __name__ == '__main__':
  data = read_csv('python 102\\app_readcsv\\data.csv')

  #Filtro de entrada
  filter_type = input("¿Qué tipo de filtro deseas utilizar? ('Rank' o 'Country'): ")

  if filter_type == 'Rank':
    try: 
      position = int(input("Ingresa el valor que deseas imprimir? (1 - 234): "))
      filtered_data = [rank for rank in data if int(rank['Rank']) == position]
    except:
      print('Debes ingresar un número (entre 1 y 234)')
      exit()
  elif filter_type == 'Country':
    try:
      country_name = input("Ingresa el país que deseas filtrar: ")
      filtered_data = [country for country in data if country['Country'] == country_name]
      if len(filtered_data) == 0:
        raise ValueError('No se encontraron países con ese nombre')
    except ValueError as error:
      print(str(error))
      exit()
  else:
    print("Ingresa un tipo de filtro válido")
    exit()

  print(filtered_data)

Genial eso de convertir un CSV en un diccionario de python, muy útil.

profe con su respeto:
header es Jeder no Jider
iterable es irerabol no itereibol

en la clase 27 estan los archivos de estas clases…

Excelente clase pero mucha info junta, tendré que repasar conceptos vistos en las clases anteriores!

Por si alguien tiene duda como yo sobre los iterables: En Python, un iterable es cualquier objeto que puede ser “recorrido” o “iterado” mediante un ciclo. Es decir, que se puede utilizar en un ciclo for para obtener sus elementos uno por uno.

Por ejemplo, una lista en Python es un iterable, porque puedes acceder a sus elementos uno por uno utilizando un ciclo for. Otros ejemplos de objetos iterables en Python son las tuplas, los diccionarios y los conjuntos.

La ventaja de los iterables es que nos permiten trabajar con grandes cantidades de datos de manera eficiente, sin tener que cargar todos los datos en memoria al mismo tiempo. En su lugar, los datos se cargan en la memoria según se necesitan, lo que ahorra recursos y mejora el rendimiento de nuestros programas.

Al final de nuestro codigo de la clase le agrege lo siguiente:

• Cree un nuevo archivo llamado “new_world_population.csv” y le agrege permisos de escritura +, como este archivo no existe en mi directorio lo que hace es crear un nuevo archivo con dicho nombre

• usando el metodo .writer() transformar nuestro archivo de csv en un objeto de escritura, una vez hecho esto podemos pasarle nuestra lista de diccionarios usando .writerow()

Esto da como resultado que guardaramos la nuesva data ordenada en un nuevo archivo csv

with open("/new_world_population.csv","w+") as new_file:
         writer =csv.writer(new_file)
         writer.writerow(final_data)

No me funciono el data, me salía error de NameError, no entendiendo porque, convertí la variable en global

import csv

def reead_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter = ',')
    header = next(reader) # Como reader es un iterable y la primera iteracion es el nombre de las columnas, estas se pueden guardar como encabezados
    print(header)
    global data
    data = []
    for row in reader:
      iterable = zip(header, row) # zip visto anteriormente, une los valores de cada una de las listas, de manera ordenada, es decir, primer valor de lista uno, con primer valor de lista dos, asi hasta que la lista uno se acabe, esta función asigna a los encabezados, los valores.
      # print(list(iterable))
      country_dict = {key: value for key, value in iterable}
      data.append(country_dict)
    return data
      # print('*****'*5)
      # print(row)

if __name__ == '__main__':
  reead_csv('./app/data.csv') 
  print(data[0])

Usando dict para el diccionario

<#modulo para leer archivos csv
import csv
#path se usa para darle la dirección y nombre al programa, la ruta
def read_csv(path):
  with open(path, "r") as csvfile:
  #delimiter es sobre el caracter que separa los datos
    reader = csv.reader(csvfile,delimiter = ",")
#Se pone next porque la primera fila esta vacia, y se usa para tener la info del titulo
    header = next(reader)
    data = []
    for row in reader:
#Como el header y la row son arrays, son iterables, por ende los unimos con zip para tener tuplas
      iterable = zip(header, row)
#Volvemos el iterable en un diccionario
      country_dict = dict(iterable)
#otro modo para volverlo dict es {key: value for key, value in iterable}
      data.append(country_dict)
    return data

if __name__ == "__main__":
  data = read_csv("./app/data.csv")
  print(data[0])
#Path es donde se encuentra el css> 

Podemos a partir de esa función buscar países por sus atributos, yo lo hice por nombres.

#Muestra la informacion de un país pasado por parametro
def get_country_info(path, country):
    try:
        result = list(filter(lambda x : x['Country'] == country, get_csv_info(path)))

        for key, value in result[0].items():
            print(f' {key}: {value} ')
    except IndexError:
        print('El pais que ingresaste no se encuentra en la lista')
        

Excelente clase!!!

Es mucho mejor hacerlo:

import pandas as pd
df = pd.read_csv(“file.csv”)

Y listo, nos ahorramos como mil líneas de código haha

Modularizando el codigo en funciones mas chicas.

import csv


def read_csv(path):
    with open(path, 'r') as file:
        reader = csv.reader(file)
        for row in reader:
            yield row


def transforming_data(path):
    data_countries = []
    data_csv = read_csv(path)
    columns = next(data_csv)
    for row in data_csv:
        country = dict(zip(columns, row))
        data_countries.append(country)
    return data_countries


if __name__ == '__main__':
    path = './data.csv'
    data = transforming_data(path)

Me gustaria graficar:
Country
2022 popultaion
Area
Density
Growth Rate
Word Population Perentage

Excelente clase

Con la lectura de csv, y la edicion de archivos podemos generar una data transformada e incluso hasta un log

with open('data.csv', 'r', encoding='cp1252') as f:
    header = list(next(f).strip().split(','))   # método readline del objeto file
    data = []
    for line in f.readlines():  # método readlines del objeto file
        data.append(dict(zip(header, line.strip().split(','))))

print(data[0])

Comprendiendo las características del objeto file (_io.TextIOWrapper) me parece más económico este código que el de a librería csv, bueno hasta esta clase, seguimos adelante.

Excelente clase!, con esta clase confirme mi pasión por la data science.

utilizando csv.DictReader se puede mostrar directamente a un diccionario:

import csv

with open('./world_population.csv', mode= 'r') as csv_file:
    reader = csv.DictReader(csv_file, delimiter=',')
    for row in reader:
        print(row)

import csv

def read_csv(path):
    with open(path,"r") as csvfile:
        reader=csv.reader(csvfile,delimiter=",")
        #reader es un iterable
        header=next(reader)
        data=[]
        print(header)
        for fila in reader:
            iterable=zip(header,fila)
            country_dict={llave:valor for llave,valor in iterable}
            data.append(country_dict)
        return data
            
if __name__ == "__main__":
    data=read_csv("./Platzi/Funciones Comprehensions y Manejo de errores/Modulos/app/world_population.csv")
    #Nos dara una lista, pero queremos diccionarios
    print(data)

¡Me encantó esta clase y la manera cómo Nicolás nos condujo hasta aquí! 👌

¡Qué clase!
De las mejores del curso. Se ponen a prueba varios de los conceptos vistos anteriormente. ¡Brutal!

Consulte chat-GPT3, y me entrego unas funciones muy utiles, donde csv.DictReader(), automáticamente, toma las claves según el encabezado, y el valor de las siguientes líneas y va haciendo pares, de forma que se realiza un diccionario de manera mucho más rápida al usar archivos CSV.
import csv
def data_csv_a_diccionario(path):
data = open(path)
data_en_diccionario = list(csv.DictReader(data))
print(data_en_diccionario[0])

data_csv_a_diccionario(’./world_population.csv’)

creo que esta clase se pudo hacer mas pausada y en 2 partes xd

Esta clase te soluciona 1hr de trabajo, muy orientada a data. Muy bien

Wow, los argentinos somos 45.000.000?, recien tomo conciencia de esto.

cuando le di a data = [ ] me aparecia que el name data is not defined

Pandas lejos

import csv

def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    data = []
    for row in reader:
      iterable = zip(header, row)
      #print(list(iterable))
      country_dict = {key: value for key, value in iterable}
      #print(country_dict)
      data.append(country_dict)
    return data
      #print('***' * 5)
      #print(row)

if __name__ == '__main__':
  data = read_csv('./archive/world_population.csv')
  print(data[0])

Interesante este tema. Comenzando a conocer python, estaba esperando llegar a este punto.

clase de estadio

No logre hacer que funcionara con una variable para el pais en la parte del if ‘Venezuela’ in x,
si alguien me puede resolver esa duda.

Me gustó este tema. Un poco complicado apenas se empieza, pero bastante interesante.

import os
os.system('clear')