<jupyter_start><jupyter_text>Parametros read.csv Puede que alguna información salga de manera incorrecta. Cargar una columna todo o con los heads hechos un desastre<jupyter_code>'''read.csv(filepath="",sep=",", dtype={"a":np.float64,"b":np.int32},header=0,names={"ingresos","edad"},skiprows=None,
        index_col=None,skip_blank_lines=False,na_filter=False) '''<jupyter_output><empty_output><jupyter_text>**filepathPara** ruta absoluta.**Sep** es para el delimitador en csv se separan por comas pero se pueden decir cuales (|,(,etc).**dtype** sirve para darle un formato a columnas en particular (a lo mejor hay fechas que no son de tipo date). Entonces columna "a" puede ser float64.**Header** indica cual fila va a ser la cabecera.**names** nombres de las columnas sin nombre o mal nombradas, etc(Se debe generar array o lista de nombres).**Skiprows** salta las lineas que se leen por ejemplo si skiprows=12 saltara 12 filas para leer.**index_col** -> Permite indicar que alguna columna sea el identificador de la tabla.**skip_blank_lines** Valor booleano. Las lineas en blanco en el fichero se saltan en vez de ponerles NaN. **na_filter** Detecta valores que falten(marcadores NaN,null) y se carga toda la fila. Booleano.  Casos de uso CSV<jupyter_code>url = "Customer Churn Model.txt" #Ahorra escribir todo de nuevo
df1 = pd.read_csv(url)
df1.head()<jupyter_output><empty_output><jupyter_text>Tal vez queremos renombrar algunas columnas<jupyter_code>df1.columns.values #Da los nombres de las columnas
#Nuevo df para cambiar nombre columnas 
df1_columnas = pd.read_csv("Customer Churn Columns.csv") #Df del csv con nombre de columnas
df1_columnas.head()
df1_columnas_list = df1_columnas["Column_Names"].tolist() #Se genera lista de nuevos nombres para re-etiquetar
df1_columnas_list
df1 = pd.read_csv("Customer Churn Model.txt",header=None,names=df1_columnas_list) #Suprimo el header actual y
#names re-nombro
df1.head()<jupyter_output><empty_output><jupyter_text>Listo!  Metodo open para carga manual de datos.Cuando se hace la lectura de información con read se suele saturar la RAM debido a que se descarga todo el DF (Cuando son Df's grandes). **Open** lee el data set linea por linea o por trozos. Y permite almacenar estos pedazos en diferentes partes del codigo. O distribuyendolo en computadoras.<jupyter_code>df2 = open("Customer Churn Model.txt",'r') #Modo de lectura
cols = df2.readline().strip().split(",") #Dado que readline me da un solo string 
# Strip elimina los espacios en blanco al inicio y final en la linea.lo que se le indique.
#Split divide la linea de texto por las comas y devuelve al final una array  
n_cols = len(cols) #Tamaño de columnas
n_cols<jupyter_output><empty_output><jupyter_text>Numero de filas<jupyter_code>counter = 0
main_dict = {}
for col in cols:
    main_dict[col] = []
main_dict #Generamos un diccionario vacio para rellenar cada una de las columnas con su respectivo valor
for line in df2: #For para avanzar la lectura de lineas
    values = line.strip().split(",")
    for i in range(len(cols)): #i es el la columna donde se insertaran los datos
        main_dict[cols[i]].append(values[i]) #main_dict[columna(i)] se agregan los valores de la linea 
    counter += 1
print("El data set tiene %d filas y %d columnas" % (counter, n_cols)) #El contador es para ver cuantas veces se
#hizo la operacion o sea cuantas lineas se leyeron y ese es el numero de filas
main_dict #Es el diccionario ya lleno<jupyter_output><empty_output><jupyter_text>Luego esto se convierte en un dataFrame. Dado que se leyo eficientemente como un archivo y se le dio el tratamiento correspondiente. Esta opcion de carga manual o por partes, es util cuando varios equipos tienen cargas de trabajos distribuidos(uno lee el archivo, otro convierte, otro analiza, asi es mas eficiente).<jupyter_code>df3 = pd.DataFrame(main_dict)
df3.head()<jupyter_output><empty_output><jupyter_text>Leer y escribir un fichero  A veces el separador de elementos no es con comas (,). Si el delimitador es otro objeto, a veces pueden ser los /t. Ejemplo de escritura:<jupyter_code>in_file = "Customer Churn Model.txt"
out_file = "Tab Customer Churn Model.txt"

with open(in_file) as infile1: #Abro el archivo de entrada
    with open(out_file,"w") as outfile1: #Abro el de salida en modo escritura
        for line in infile1: #Por cada linea en in_file
            fields = line.strip().split(",") #Genera el array de elementos
            outfile1.write("\t".join(fields)) #Despues los en un archivo con /t
            outfile1.write("\n")#Se generan saltos de linea
df3 = pd.read_csv(out_file,sep = "\t")
df3.head()<jupyter_output><empty_output><jupyter_text>Leer datos desde una URL La informacion a veces esta en la nube<jupyter_code>url_winter = "http://winterolympicsmedals.com/medals.csv"
medals_data = pd.read_csv(url_winter)
medals_data.head()<jupyter_output><empty_output><jupyter_text>Librerias para gestionar CSV o URL's<jupyter_code>import csv
import urllib3
#Una forma de poder obtener info de un servidor
http = urllib3.PoolManager()
r = http.request('GET',url_winter)
r.status #200 si si funciono
response = r.data.decode("utf-8") #Este no es un DF por lo que se puede tratar para que si lo sea
type(response) #UTF-8 decodifica de byte a str
response
#Usando csv
cr = csv.reader(response.strip().split("\n")) #Genera la separacion por \n 
cr 
colum_names = cr.__next__()
df_csv = pd.DataFrame(cr,columns=colum_names)
df_csv
colum_names
len(colum_names)<jupyter_output><empty_output><jupyter_text>Carga de datos desde una hoja de calculo xlsx y xls<jupyter_code>path = "titanic3.xls"
path2 = "titanic3.xlsx"<jupyter_output><empty_output><jupyter_text>La diferencia con un Excel es que este tiene pestañas en el documento, con nombres distintos. Solo se deben especificar los nombres.<jupyter_code>titanicDF = pd.read_excel(path,"titanic3") #Titanic3 es el nombre de la pestaña de Excel de donde se extrae.
titanicDF2 = pd.read_excel(path2,"titanic3")<jupyter_output><empty_output><jupyter_text>Crear CSV o Excel con lo que he trabajado<jupyter_code>titanicDF2.to_csv("titanicCSV.csv")
'''titanicDF2.to_json("titanicJ.json")
titanicDF2.to_excel("titanicEx.xls")'''<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup