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

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

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

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)

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 😥

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.

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

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])

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')

Mi cerebro va a explotar jajaja

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! 😄

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 😄

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)

• 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])

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

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)

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

funcionan mucho los archivos csv! que genial

Mi optimizacion del codigo para dejarlo como list comprehension, ya que el append se vuelve mas lento cuanto mas iteraciones hacemos.

import csv

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


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

No sabia este formato en como trabajarlo. Es algo interesante ese csv porque acabo de aprender bastante. El codigo si que es inmenso. Falta mucho todavia por aprender.

# Leer un CSV

# https://www.w3schools.com/python/python_file_open.asp

# DB: https://www.kaggle.com/datasets/iamsouravbanerjee/world-population-dataset

import csv

# Se crea una funcion para abrir el archivo csv en forma de diccionario para hacer consultas más precisas
def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',') # Lector del archivo    
    header = next(reader) # Primera fila, corresponde al nombre de las columnas
    data = []
    for row in reader:
      iterable =zip(header, row) # Une los valores en un array en forma de tuplas
      country_dict = {key:value for key, value in iterable} 
      data.append(country_dict) # Se genera un array de diccionarios
      print(country_dict)
    return data

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

import csv

def read_csv(path):
    data = []
    try:
        with open(path, 'r') as csvfile:
            reader = csv.DictReader(csvfile, delimiter=',')
            for row in reader:
                data.append(row)
    except FileNotFoundError:
        print(f'El archivo {path} no existe.')
    except csv.Error as e:
        print(f'Error al leer el archivo {path}: {e}')
    return data

if __name__ == '__main__':
    data = read_csv('data.csv')
    print(f'El primer elemento de la lista es: {data[0]}')

Paso 1: Importar el módulo CSV (import csv)
En este paso, estás importando la biblioteca csv, que proporciona funciones para trabajar con archivos CSV en Python.

import csv

Paso 2: Definir la función read_csv(path)
Aquí defines una función llamada read_csv que acepta un argumento path, que es la ruta del archivo CSV que quieres leer.

def read_csv(path):

Paso 3: Abrir el archivo CSV (with open(path, 'r') as csvfile)
En este paso, abres el archivo CSV en modo de lectura ('r') utilizando el contexto with. El archivo se abrirá y se cerrará automáticamente después de usarlo.

    with open(path, 'r') as csvfile:

Paso 4: Crear un lector de CSV (csv.reader(csvfile, delimiter=','))
Aquí creas un lector de archivos CSV usando la función csv.reader(). Le pasas el archivo que acabas de abrir (csvfile) y especificas el delimitador que se utiliza en el archivo CSV (en este caso, la coma ,).

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

Paso 5: Leer la cabecera (header = next(reader))
Utilizas next(reader) para leer la primera fila del archivo CSV, que generalmente es la cabecera que contiene los nombres de las columnas. Almacenas esta cabecera en la variable header.

        header = next(reader)

Paso 6: Crear una lista para almacenar datos (data = [])
Aquí creas una lista vacía llamada data que se utilizará para almacenar los datos del archivo CSV.

        data = []

Paso 7: Iterar a través de las filas (for row in reader)
Comienzas a iterar a través de las filas del archivo CSV utilizando un bucle for. Cada row representa una fila de datos en el archivo.

        for row in reader:

Paso 8: Combinar nombres de columnas con valores (iterable = zip(header, row))
Aquí combinas los nombres de las columnas (que obtuviste en el paso 5) con los valores de la fila actual usando la función zip(). Esto crea un iterable que relaciona cada nombre de columna con su valor correspondiente en la fila.

            iterable = zip(header, row)

Paso 9: Crear un diccionario (country_dict = {key: value for key, value in iterable})
Utilizas una comprensión de diccionario para crear un diccionario llamado country_dict que mapea los nombres de columna a sus valores correspondientes en la fila.

            country_dict = {key: value for key, value in iterable}

Paso 10: Agregar el diccionario a la lista de datos (data.append(country_dict))
Añades el diccionario country_dict a la lista data. Esto se hace en cada iteración del bucle, por lo que al final de la iteración, data contendrá todos los datos del archivo CSV.

            data.append(country_dict)

Paso 11: Retornar la lista de datos (return data)
Finalmente, retornas la lista data que contiene todos los datos del archivo CSV como resultado de la función read_csv.

        return data

Paso 12: Llamar a la función read_csv
Dentro de un bloque if __name__ == '__main__':, llamas a la función read_csv pasando la ruta del archivo CSV como argumento.

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

Paso 13: Imprimir el primer elemento de la lista
Imprimes el primer elemento de la lista data, que es el primer diccionario de datos leído desde el archivo CSV.

    print(data[0])

¡¡¡Chicos llegó nuestro momento!!!

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

#----- 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)