En Este Tutorial

En este tutorial, aprenderemos a desarrollar interfaces gráficas de usuario
(GUI del inglés Graphics User Interfaces) escribiendo algunos ejemplos de la

GUI de Python usando el paquete Tkinter.
El paquete Tkinter está incluido en Python como un paquete estándar, por lo

que no es necesario instalar nada para usarlo.
El paquete Tkinter es un paquete muy poderoso. Si ya ha instalado Python,

puede usar IDLE, que es el IDE integrado que se envía con Python. Este IDE
se ha escrito utilizando Tkinter. ¡Suena grandioso!
Usaremos Python 3.6, por lo que si está utilizando Python 2.x, se recomienda
encarecidamente que cambie a Python 3.x a menos que sepa los cambios en
el lenguaje para que pueda ajustar el código y se ejecute sin errores.Aprende
a desarrollar aplicaciones de GUI utilizando el paquete Python Tkinter. En
este tutorial, aprenderás cómo crear interfaces gráficas escribiendo
ejemplos de GUI de Python
Asumo que tienes conocimientos de Python básico que te ayudará a

entender lo que estamos haciendo.
Comenzaremos por crear una ventana, luego aprenderemos cómo agregar
widgets como botones, cuadros combinados, etc., luego jugaremos con sus
propiedades. Así que comencemos.
Table of Contents [hide]

 1 Crear tu primera aplicación GUI
 2 Crear un widget label (etiqueta)
o 2.1 Establecer tamaño de fuente de etiqueta
o 2.2 Establecer el tamaño de una ventana
 3 Agregar un widget button
o 3.1 Cambiar los colores de fondo y primer plano de un botón
o 3.2 Manejar el evento click de un botón
 4 Entrada de datos usando la clase Entry (Tkinter textbox)
o 4.1 Establecer el foco en el widget de entrada
o 4.2 Deshabilitar el widget de entrada
 5 Agregar un widget combobox
 6 Agregar un widget Checkbutton (Tkinter checkbox)
o 6.1 Establecer el estado de un Checkbutton
 7 Agregar widgets radio button
o 7.1 Obtener el valor del radio button (opción seleccionada)
 8 Adicionar un widget ScrolledText (Tkinter textarea)
o 8.1 Establecer el contenido del scrolledtext
o 8.2 Borrar/limpiar el contenido de un scrolledtext
 9 Crear un MessageBox
o 9.1 Mostrar mensajes de error y de advertencia
o 9.2 Mostrar diálogos de pregunta-respuesta
 10 Agregar un SpinBox (widget de números)
o 10.1 Establecer el valor por defecto del Spinbox
 11 Adicionar el widget Progressbar
o 11.1 Cambiar el color de un Progressbar
 12 Adicionar un diálogo para archivos (elegir archivo y directorio)
o 12.1 Especificar los tipos de archivo (filtro por la extensión del
archivo)
 13 Adicionar una barra de menú
 14 Adicionar un widget Notebook (control de pestañas)
o 14.1 Agregar widgets a las pestañas
 15 Adicionar espacio para los widgets (separación o padding)
Crear tu primera aplicación GUI

Primero, importaremos el paquete Tkinter y crearemos una ventana y
estableceremos su título:
1 from tkinter import *

2
3 window = Tk()
4
5 window.title("Welcome to LikeGeeks app")
6
7 window.mainloop()
El resultado debe verse como esto:
¡Increíble! Nuestra aplicación funciona.
La última línea llama a la función mainloop. Esta función llama al ciclo sin fin
de la ventana, por lo que la ventana esperará cualquier interacción del
usuario hasta que la cerremos.
Si olvidas llamar a la función mainloop, no aparecerá nada al usuario.
Crear un widget label (etiqueta)

Para agregar una etiqueta a nuestro ejemplo anterior, crearemos una
etiqueta usando la clase label de la siguiente manera:
lbl = Label(window, text="Hello")
Luego estableceremos su posición en el formulario utilizando la
función grid con su ubicación, de esta manera:
lbl.grid(column=0, row=0)
Entonces el código completo se verá de esta manera:

2
3 window = Tk()
4
6
7 lbl = Label(window, text="Hello")
8
9 lbl.grid(column=0, row=0)
10
11 window.mainloop()
Y este es el resultado:
Sin llamar a la función grid para label, la etiqueta no aparecerá.

Establecer tamaño de fuente de etiqueta
Puedes establecer la fuente de la etiqueta para agrandarla o quizá, colocarla
en negrita. También puedes cambiar el estilo de fuente.
Para hacerlo, puedes pasar el parámetro font de esta manera:

lbl = Label(window, text="Hello", font=("Arial Bold", 50))
Debes tener en cuenta que el parámetro font se puede pasar a cualquier

widget para cambiar su fuente, no solo a etiquetas.
Genial. Pero, la ventana es tan pequeña que incluso no podemos ver el título.
¿Cómo se establece el tamaño de la ventana?
Establecer el tamaño de una ventana

Podemos establecer el tamaño predeterminado de ventana, usando la
función geometry, de esta manera:
window.geometry('350x200')
La línea anterior establece el ancho de la ventana en 350 píxeles y la altura
en 200 píxeles.
Intentemos agregar más widgets como botones y ver cómo manejar el

evento de click de un botón.
Agregar un widget button
Comencemos agregando un botón a la ventana. El botón se crea y se agrega a
la ventana de la misma manera que la etiqueta:
1 btn = Button(window, text="Click Me")

2
3 btn.grid(column=1, row=0)
Entonces, el código de la ventana se verá así:

2
3 window = Tk()
4
6
7 window.geometry('350x200')
8
10
12
13 btn = Button(window, text="Click Me")
14
16
Y el resultado se verá así:
Hay que tener en cuenta que colocamos el botón en la segunda columna de
la ventana, que es la 1. Si olvidas eso y colocas el botón en la misma columna
(en este caso la 0), se mostrará el botón solamente, ya que el botón estará
por encima de la etiqueta.
Cambiar los colores de fondo y primer plano de

un botón
Puedes cambiar el color de frente del botón o de cualquier otro widget
usando la propiedad fg.
También, puedes cambiar el color de fondo de cualquier widget usando la
propiedad bg.
btn = Button(window, text="Click Me", bg="orange", fg="red")
Ahora, si trataste de hacer click en el botón, no pasó nada, porque el

evento click del botón aún no está programado.
Manejar el evento click de un botón
Primero, escribiremos la función que necesitamos ejecutar cuando se haga
click en el botón:
1 def clicked():
2
3 lbl.configure(text="Button was clicked !!")
Luego la cablearemos con el botón especificando la función de esta manera:
1 btn = Button(window, text="Click Me", command=clicked)

Fíjate que, escribimos clicked simplement y no clicked() con paréntesis.
Ahora el código completo se verá de esta manera:

2
3 window = Tk()
4
6
8
10
12
13 def clicked():
14
16
18
20
Y cuando hacemos click en el botón, el resultado es el esperado:
¡Buenísimo!
Entrada de datos usando la clase Entry

(Tkinter textbox)
En los ejemplos anteriores de Python GUI, vimos cómo agregar widgets
simples, ahora intentemos obtener una entrada del usuario utilizando la
clase Tkinter Entry (cuadro de texto de Tkinter).
Puedes crear un cuadro de texto usando la clase Tkinter Entry de esta

manera:
txt = Entry(window,width=10)
Luego, puedes agregar el widget a la ventana usando la función grid, como
siempre.
Entonces nuestra ventana será así:

2
3 window = Tk()
4
6
8
10
12
13 txt = Entry(window,width=10)
14
15 txt.grid(column=1, row=0)
16
17 def clicked():
18
20
22
24
Y el resultado será el siguiente:
Ahora, si haces click en el botón, se mostrará el mismo mensaje anterior.

¿Qué tal si se muestra el texto ingresado en el widget de entrada?
Primero, podemos obtener texto de entrada usando la función get. Entonces

podemos escribir este código en nuestra función clicked, de esta manera:
1 def clicked():
2
3 res = "Welcome to " + txt.get()
4
5 lbl.configure(text= res)
Si haces click en el botón y hay un texto en el widget de entrada, se mostrará
“Welcome to ” concatenado con el texto ingresado.
Y este es el código completo:

2
3 window = Tk()
4
6
8
10
12
13 txt = Entry(window,width=10)
14
15 txt.grid(column=1, row=0)
16
17 def clicked():
18
19 res = "Welcome to " + txt.get()
20
21 lbl.configure(text= res)
22
24
26
Ejecuta el código anterior y verifica el resultado:
¡Increíble!
Cada vez que ejecutamos el código, tenemos que hacer click en el widget de
entrada para establecer el foco para escribir el texto, ¿qué pasa si
configuramos el foco automáticamente?
Establecer el foco en el widget de entrada

Eso es súper fácil, todo lo que tenemos que hacer es llamar a la
función focus de esta manera:
txt.focus()
Y cuando ejecutes el código, notarás que el widget de entrada tiene el foco
para que puedas escribir el texto de inmediato.
Deshabilitar el widget de entrada

Para deshabilitar el widget de entrada, puedes configurar la
propiedad state como deshabilitada (disabled):
txt = Entry(window,width=10, state='disabled')
Ahora, ya no podrás ingresar ningún texto.
Agregar un widget combobox

Para agregar un widget combobox, puedes usar la clase Combobox de la
librería ttk, de esta manera:
1 from tkinter.ttk import *
2
3 combo = Combobox(window)
Luego puedes agregar los valores al combo.

2
4
5 window = Tk()
6
8
10
11 combo = Combobox(window)
12
13 combo['values']= (1, 2, 3, 4, 5, "Text")
14
15 combo.current(1) #set the selected item
16
17 combo.grid(column=0, row=0)
18
Como puedes ver, agregamos los elementos del combobox usando una tupla
de valores.
Para configurar el elemento seleccionado, puedes pasar el índice del

elemento deseado a la función actual.
Para obtener el elemento seleccionado, puedes usar la función get, como se
muestra a continuación:
combo.get()
Agregar un widget Checkbutton (Tkinter

checkbox)
Para crear un widget Checkbutton, puedes usar la clase Checkbutton de esta
manera:
chk = Checkbutton(window, text='Choose')
Además, puedes configurar el estado checked pasando el valor de activación
al Checkbutton, de esta manera:

2
4
5 window = Tk()
6
8
10
11 chk_state = BooleanVar()
12
13 chk_state.set(True) #set check state
14
15 chk = Checkbutton(window, text='Choose', var=chk_state)
16
17 chk.grid(column=0, row=0)
18
Verifica el resultado:
Establecer el estado de un Checkbutton
Aquí creamos una variable de tipo BooleanVar que no es una variable Python
estándar, es una variable Tkinter. Luego la pasamos a la
clase Checkbutton para establecer el estado de verificación como la línea
resaltada en el ejemplo anterior.
Puedes establecer el valor booleano en falso para desactivarlo.
Además, puedes usar IntVar en lugar de BooleanVar y establecer el valor en 0

o 1.
1 chk_state = IntVar()
2
3 chk_state.set(0) #uncheck
4
5 chk_state.set(1) #check
Estos ejemplos dan el mismo resultado que con BooleanVar.
Agregar widgets radio button

Para agregar radio buttons, simplemente puedes usar la clase RadioButton,
de esta manera:
rad1 = Radiobutton(window,text='First', value=1)
Ten en cuenta que, debes establecer el valor para cada botón de opción con
un valor diferente; de lo contrario, no funcionarán.
2
4
5 window = Tk()
6
8
10
11 rad1 = Radiobutton(window,text='First', value=1)
12
13 rad2 = Radiobutton(window,text='Second', value=2)
14
15 rad3 = Radiobutton(window,text='Third', value=3)
16
17 rad1.grid(column=0, row=0)
18
20
22
El resultado del código anterior se ve así:
Además, puedes configurar el command de cualquiera de estos botones de

opción para una función específica, de modo que si el usuario hace click en
alguno de ellos, ejecuta el código de la función asignada.
Aquí un ejemplo:
1 rad1 = Radiobutton(window,text='First', value=1, command=clicked)
2
3 def clicked():
4
5 # Do what you need
¡Bastante simple!
Obtener el valor del radio button (opción

seleccionada)
Para obtener el botón de opción actualmente seleccionado o el valor del
botón de opción, puedes pasar un parámetro variable a los botones de
opción y más adelante puede obtener su valor.

2
4
5 window = Tk()
6
8
9 selected = IntVar()
10
11 rad1 = Radiobutton(window,text='First', value=1, variable=selected)
12
13 rad2 = Radiobutton(window,text='Second', value=2, variable=selected)
14
15 rad3 = Radiobutton(window,text='Third', value=3, variable=selected)
16
17 def clicked():
18
19 print(selected.get())
20
22
24
26
28
30
Cada vez que seleccione un botón de opción, el valor de la variable cambiará

al valor de la opción seleccionada.
Adicionar un widget ScrolledText (Tkinter

textarea)
Para adicionar un widget ScrolledText, puedes usar la clase ScrolledText, de
esta manera:
1 from tkinter import scrolledtext

2
3 txt = scrolledtext.ScrolledText(window,width=40,height=10)
Aquí especificamos el ancho y el alto del widget ScrolledText, de lo contrario,
rellenará toda la ventana.

2
3 from tkinter import scrolledtext
4
5 window = Tk()
6
8
10
11 txt = scrolledtext.ScrolledText(window,width=40,height=10)
12
13 txt.grid(column=0,row=0)
14
Puedes ver el resultado:
Establecer el contenido del scrolledtext

Para establecer el contenido del scrolledtext, puedes usar el método insert,
de esta manera:
txt.insert(INSERT,'You text goes here')
Borrar/limpiar el contenido de un scrolledtext
Para borrar el contenido de un widget scrolledtext, puedes usar el método
delete, de esta manera:
txt.delete(1.0,END)
¡Grandioso!
Crear un MessageBox
Para mostrar un cuadro de mensaje usando Tkinter, puedes usar la
librería messagebox, de esta manera:
1 from tkinter import messagebox
2
3 messagebox.showinfo('Message title','Message content')
¡Bastante simple!
Vamos a mostrar un cuadro de mensaje cuando el usuario haga click en un

botón.

2
4
5 window = Tk()
6
8
10
11 def clicked():
12
13 messagebox.showinfo('Message title', 'Message content')
14
15 btn = Button(window,text='Click here', command=clicked)
16
17 btn.grid(column=0,row=0)
18
Cuando hagas click en el botón, un cuadro de mensajes informativo

aparecerá.
Mostrar mensajes de error y de advertencia

Puede mostrar un mensaje de advertencia o mensaje de error de la misma
manera. Lo único que debe cambiarse es la función message.
1 messagebox.showwarning('Message title', 'Message content') #shows warning message

2
3 messagebox.showerror('Message title', 'Message content') #shows error message
Mostrar diálogos de pregunta-respuesta

Para mostrar una caja de mensaje del tipo si/no al usuario, puedes usar uno
de las siguientes funciones messagebox:

2
3 res = messagebox.askquestion('Message title','Message content')
4
5 res = messagebox.askyesno('Message title','Message content')
6
7 res = messagebox.askyesnocancel('Message title','Message content')
8
9 res = messagebox.askokcancel('Message title','Message content')
10
11 res = messagebox.askretrycancel('Message title','Message content')
Puedes elegir el estilo de mensaje apropiado, de acuerdo a tus necesidades.
Simplmente reemplaza la función showinfo en el código anterior y ejecútalo.
También puedes revisar qué botón hizo click el usuario, usando la
variable result.
Si haces click en OK o yes o retry, devolverá el valor True; pero, si
eliges no o cancel, retornará False.
La única función que devuelve uno de tres valores es la
función askyesnocancel, que devuelve True o False o None.
Agregar un SpinBox (widget de números)

Para crear un widget Spinbox, puedes usar la clase Spinbox, de esta manera:
spin = Spinbox(window, from_=0, to=100)
Aquí creamos un widget Spinbox y pasamos los parámetros from_ y to para
especificar el rango de números del Spinbox.
Además, puedes especificar el ancho del widget usando el parámetro width:
spin = Spinbox(window, from_=0, to=100, width=5)
Verifiquemos el ejemplo completo:

2
3 window = Tk()
4
6
8
9 spin = Spinbox(window, from_=0, to=100, width=5)
10
11 spin.grid(column=0,row=0)
12
Puedes especificar números para el Spinbox en lugar de usar todo el rango,

de esta manera:
spin = Spinbox(window, values=(3, 8, 11), width=5)

Aquí, el widget Spinbox solamente muestra 3 números: 3, 8 y 11.
Establecer el valor por defecto del Spinbox

Para colocar el valor por defecto del Spinbox, puedes pasar el valor al
parámetro textvariable, de esta manera:
1 var =IntVar()
2
3 var.set(36)
4
5 spin = Spinbox(window, from_=0, to=100, width=5, textvariable=var)
Ahora, si corres el programa, el Spinbox te mostrará el valor 36 por defecto.
Adicionar el widget Progressbar

Para crear una barra de progreso, puedes usar la clase progressbar, de esta
manera:
1 from tkinter.ttk import Progressbar

2
3 bar = Progressbar(window, length=200)
Puedes establecer el valor de la barra de progreso, de esta manera:
bar['value'] = 70
Puedes establecer este valor según el proceso que desees, como descargar
un archivo o completar una tarea.
Cambiar el color de un Progressbar

Cambiar el color de un Progressbar es un poco complicado al principio, pero
muy fácil en realidad.
Primero, crearemos un estilo, luego en dicho estilo estableceremos el color

de fondo; y, finalmente, asignaremos el estilo al Progressbar.
Revisa el siguiente ejemplo:

2
3 from tkinter.ttk import Progressbar
4
5 from tkinter import ttk
6
7 window = Tk()
8
10
12
13 style = ttk.Style()
14
15 style.theme_use('default')
16
17 style.configure("black.Horizontal.TProgressbar", background='black')
18
19 bar = Progressbar(window, length=200, style='black.Horizontal.TProgressbar')
20
21 bar['value'] = 70
22
23 bar.grid(column=0, row=0)
24
Y el resultado quedará así:
Adicionar un diálogo para archivos (elegir

archivo y directorio)
Para crear un diálogo de archivos (para elegir archivos) puedes usar la
clase filedialog, de esta manera:
1 from tkinter import filedialog

2
3 file = filedialog.askopenfilename()
Después de que escojas un archivoy hagas click en abrir, la
variable file tendrá la ruta del archivo.
También puedes elegir multiples archivos de la siguiente manera:
files = filedialog.askopenfilenames()
Especificar los tipos de archivo (filtro por la
extensión del archivo)
Puedes especificar los tipos de archivo usando el parámetro filetypes, que,
precisamente especifica la extensión en tuplas.
file = filedialog.askopenfilename(filetypes = (("Text files","*.txt"),("all

files","*.*")))
Puedes solicitar el directorio a usar con el método askdirectory:
dir = filedialog.askdirectory()
Puedes especificar el directorio inicial del diálogo especificando el initialdir,
de esta manera:
1 from os import path

2
3 file = filedialog.askopenfilename(initialdir= path.dirname(__file__))
¡Fácil!
Adicionar una barra de menú

Para agregar una barra de menú, puedes usar la clase menu, de esta manera:
1 from tkinter import Menu
2
3 menu = Menu(window)
4
5 menu.add_command(label='File')
6
7 window.config(menu=menu)
Primero, creamos el menú. Luego, añadimos nuestra primera etiqueta.
Finalmente, asignamos el menú a la ventana.
Puedes agregar los elementos del menú, en cualquir menú, con la

función add_cascade(), de esta manera:
menu.add_cascade(label='File', menu=new_item)
Entonces, nuestro código quedará así:

2
4
5 window = Tk()
6
8
10
11 new_item = Menu(menu)
12
13 new_item.add_command(label='New')
14
15 menu.add_cascade(label='File', menu=new_item)
16
18
De esta manera, puedes agregar tantos elementos como quieras.

2
4
5 window = Tk()
6
8
10
11 new_item = Menu(menu)
12
13 new_item.add_command(label='New')
14
15 new_item.add_separator()
16
17 new_item.add_command(label='Edit')
18
19 menu.add_cascade(label='File', menu=new_item)
20
22
Aquí agregamos otro elemento del menú llamado «Edit» con un separador
de menú.
Puedes notar una línea punteada al principio, bueno, si haces click en esa
línea, mostrará los elementos del menú en una pequeña ventana separada.
Puedes deshabilitar esta característica, deshabilitando la

característica tearoff, de esta manera:
new_item = Menu(menu, tearoff=0)
Simplemente reemplaza el new_item en el ejemplo anterior con éste y ya no
mostrará la línea punteada.
No es necesario que recordarte que puedes escribir cualquier código que
funcione cuando el usuario haga click en cualquier elemento del menú,
especificando la propiedad command.
new_item.add_command(label='New', command=clicked)
Adicionar un widget Notebook (control de

pestañas)
Para crear un control de pestañas, se deben seguir tres pasos.
 Primero, crear un control de pestaña usando la clase Notebook

 Crear la pestaña usando la clase Frame.
 Adicionar la pestaña al control de pestañas.
 Empaquetar el control de pestañas para que sea visible en la ventana.
2
4
5 window = Tk()
6
8
9 tab_control = ttk.Notebook(window)
10
11 tab1 = ttk.Frame(tab_control)
12
13 tab_control.add(tab1, text='First')
14
15 tab_control.pack(expand=1, fill='both')
16
De igual manera, puedes añadir tantas pestañas como quieras.
Agregar widgets a las pestañas
Después de crear las pestañas, puedes colocar widgets dentro de ellas,

asignado la propieda parent con la pestaña deseada.

2
4
5 window = Tk()
6
8
9 tab_control = ttk.Notebook(window)
10
12
14
15 tab_control.add(tab1, text='First')
16
17 tab_control.add(tab2, text='Second')
18
19 lbl1 = Label(tab1, text= 'label1')
20
21 lbl1.grid(column=0, row=0)
22
23 lbl2 = Label(tab2, text= 'label2')
24
25 lbl2.grid(column=0, row=0)
26
27 tab_control.pack(expand=1, fill='both')
28
Adicionar espacio para los widgets

(separación o padding)
Puedes añadir separación a tus controles para que se vean bien organizados,
usando las propiedades padx y pady.
Simplemente pasa padx y pady a cualquier widget y dáles un valor.
lbl1 = Label(tab1, text= 'label1', padx=5, pady=5)
¡Así de simple!
En este tutorial, vimos muchos ejemplos de Python GUI que utilizan la

biblioteca Tkinter y vimos lo fácil que es desarrollar interfaces gráficas para
usarlo.
Este tutorial cubre los aspectos principales del desarrollo de la GUI de

Python no todos. No hay tutorial o un libro pueda cubrir todo.
Espero que encuentres estos ejemplos útiles. Mantente con nosotros.
Gracias.
Tutorial De Kivy – Construye Aplicaciones Con
Interfaces Gráficas Usando Python
2019-01-21 Comment(0)
En los tutoriales anteriores, vimos cómo crear aplicaciones GUI

utilizando Tkinter y PyQt5, en este tutorial, continuaremos creando
aplicaciones con interfaces gráficas de escritorio, pero esta vez utilizando
Kivy.
Kivy es una biblioteca de código abierto de Python que se utiliza para crear
aplicaciones en Windows, Linux, MacOS, Android e iOS.
Aprenderás como trabajar con los Kivy buttons, los labels, las recycle views,
las scroll views, el Kivy Canvas y otros widgets para familiarizarte con la
biblioteca.
Puedes diseñar widgets de Kivy usando un lenguaje intermedio llamado

lenguaje Kv lo cual exploraremos mas adelante.
Antes de comenzar con Kivy, necesitas conocimientos de los conceptos

básicos de programación en Python. Ahora, comencemos desde la
instalación.
 1 Instalación
 2 Interfaces gráficas Kivy
 3 Kivy Button
o 3.1 Cambiar el color del botón kivy
o 3.2 Deshabilitar el botón Kivy
o 3.3 Cambia el tamaño y la posición de un botón
o 3.4 Insertar una imagen en un botó Kivy
o 3.5 Cargar un string o archivo Kv
 4 Kivy Label (Etiqueta)
o 4.1 Cambiar el tamaño de la fuente
o 4.2 Añadiendo estilo al texto en el label
 5 Kivy RecycleView
 6 Kivy ScrollView
 7 Kivy Clear text input
 8 Kivy Clock
 9 Kivy Canvas
 10 Canvas Image
 11 Kivy vs PyQt
Instalación
Si tiene varias versiones de Python instaladas en tu computadora, entonces
tendrá que instalar Kivy en la versión que deseas usar para el desarrollo.
Suponiendo que Python está instalado, debes seguir los siguientes pasos:
1. Los paquetes de python se pueden instalar usando pip. Como Kivy

necesita compilarse cuando se instala con pip, necesitaras wheels, lo cual
es una distribución precompilada de un paquete ya compilado. También
puede usar git para instalar Kivy, pero en este tutorial utilizaremos wheel.
Ejecuta el siguiente comando para instalar pip y wheel:
python -m pip install --upgrade pip wheel setuptools
2. Ahora tenemos que instalar las dependencias. Ejecuta los siguientes

comandos:
python -
m pip install docutils pygments pypiwin32 kivy.deps.sdl2kivy.deps.glew
Luego:
python -m pip install kivy.deps.gstreamer
3. Después de instalar las dependencias para Kivy, instala Kivy usando el

siguiente comando:
python –m pip install kivy
Interfaces gráficas Kivy
En esta sección, vas a aprender cómo crear y ejecutar un programa con Kivy
y cómo construir una interfaz básica.
Vamos a crear un archivo con extensión .py.
Para crear una interfaz Kivy, primero debes importar el módulo de la

aplicación Kivy en nuestro programa usando la siguiente sentencia:
from kivy.app import App

Ahora importa Label desde kivy.uix.label:
from kivy.uix.label import Label

Llegó el momento de escribir nuestro programa principal.
1 class FirstKivy(App):
3 def build(self):
5 return Label(text="Hello Kivy!")
En el fragmento de código anterior, una clase se hereda de la clase App.

Luego, para compilar la aplicación, tenemos que devolver un widget en la
función build (). En el código anterior, hemos devuelto una etiqueta con el
texto “Hello Kivy”.
El último paso es llamar a esta función. Puedes crear un objeto de la clase o

simplemente escribir la siguiente declaración:
FirstKivy().run()
El archivo completo de python se estructura de la siguiente forma:
1 from kivy.app import App
3 from kivy.uix.label import Label

4
7 def build(self):
9 return Label(text="Hello Kivy!")
10
11 FirstKivy().run()
El resultado de este código será así:
¡Felicidades! Tu primera aplicación con Kivy se ejecutó con éxito.

Kivy Button
En esta sección, aprenderás cómo crear un botón, cambiar el color del
mismo, habilitarlo / deshabilitarlo, agregar una imagen en el botón y
cambiar su tamaño y su posición.
En el último programa, utilizamos el label (etiqueta). Para crear un botón,

importa Button en lugar de Label de la siguiente manera:
3 from kivy.uix.button import Button
7 def build(self):
9 return Button(text="Welcome to LikeGeeks!")
10
11 FirstKivy().run()
La salida completa será la siguiente:

El botón llena la ventana, no te preocupes, cambiaremos su tamaño más
adelante.
Cambiar el color del botón kivy

El color predeterminado de un botón Kivy es gris. El color se puede cambiar
especificando la propiedad background_color en el formato (r, g, b, a). En el
código puedes observarlo a continuación:
4
5 class KivyButton(App):
7 def build(self):
9 return Button(text="Welcome to LikeGeeks!", background_color=(155,0,51,53))
10
11 KivyButton().run()
Cuando ejecutas el programa, se crea el siguiente botón:
Deshabilitar el botón Kivy

Para deshabilitar un botón, debes establecer la propiedad disabled en True.
1 mybtn.disabled = True
Considera el siguiente código para deshabilitar un botón después de

presionarlo:
5 from functools import partial
9 def disable(self, instance, *args):
10
11 instance.disabled = True
12
13 def update(self, instance, *args):
14
15 instance.text = "I am Disabled!"
16
17 def build(self):
18
19 mybtn = Button(text="Click me to disable")
20
21 mybtn.bind(on_press=partial(self.disable, mybtn))
22
23 mybtn.bind(on_press=partial(self.update, mybtn))
24
25 return mybtn
26
En el código anterior, importamos una función partial de functools para

poder usar la función bind().
Se crea una clase KivyButton () con 2 métodos personalizados. El primer
método disabled(). Puedes nombrarlo como quieras
Luego tenemos el método update() para actualizar el texto de nuestro botón
después de hacer clic en él. Además, puedes nombrar tu función como
quieras.
La siguiente función es build (). Este método se ejecuta automáticamente
cuando se crea un botón. Luego llamamos al método disable() usando la
función partial. De manera similar, se llama al método update() para
actualizar el texto del botón después de que se deshabilita.
El valor de retorno de la función disable () está vinculado a la
función on_press de nuestro botón. Por lo tanto, cuando se presiona el botón,
primero se desactiva y luego se actualiza el texto.
La salida es la siguiente:
Cambia el tamaño y la posición de un botón

Usando la propiedad pos y size_hint del widget button, puedes cambiar
fácilmente la posición y el tamaño de un botón respectivamente. Puedes
cambiar el tamaño y la posición de un botón Kivy de la siguiente manera:
7 def build(self):
9 return Button(text="Welcome to LikeGeeks!", pos=(300,350), size_hint = (.25, .18))
10
La salida será así:
El parámetro pos especifica la posición del botón, mientras que el

parámetro size_hint especifica el tamaño del botón.
Insertar una imagen en un botó Kivy
En esta sección, aprenderás a agregar una imagen en un botón. Usaremos el
lenguaje Kv por primera vez para crear nuestros widgets propios en lugar de
crear una instancia de ellos desde el código.
A continuación se muestras las librerias de Kivy que vamos a importar:
3 from kivy.uix.boxlayout import BoxLayout
5 from kivy.lang import Builder
BoxLayout se utiliza para colocar los widgets de modo que se puedan

colocar juntos de manera organizada. En Kivy, hay varios diseños que
pueden usarse para organizar los widgets, por ejemplo, diseño de cuadro,
diseño de ancla, diseño flotante, etc.
Cargar un string o archivo Kv

De forma predeterminada, Kivy intenta cargar el archivo Kv con el mismo
nombre que su clase pero sin la palabra App y en minúscula.
Si tu clase es TestApp, entonces el programa buscara un archivo Test.kv en

el mismo directorio para importar los widgets de ahi.
La otra manera es carga un archivo Kv utilizando el Kivy Builder
Kivy Builder es utilizado para cargar widgets de archivos o cadenas Kv. Por
ejemplo si quieres crear un widget, puede utilizar lo de la siguiente manera:
Builder.load_string(""" """)
Dentro de las comillas triples, los widgets necesarios se agregan junto con
sus propiedades. En el siguiente ejemplo, hemos agregado una clase
KivyButton.
Primero, se establecen el texto y el tamaño del botón, luego la imagen se

especifica en el atributo source y por ultimo las coordenadas de la imagen.
La imagen se coloca en el mismo directorio, por lo que la ruta de la imagen
está bien por los momentos.
1 Builder.load_string("""
3 <KivyButton>:
5 Button:
7 text: "Hello Button!"
9 size_hint: .12, .12
10
11 Image:
12
13 source: 'images.jpg'
14
15 center_x: self.parent.center_x
16
17 center_y: self.parent.center_y
18
19 """)
Ahora, importemos esta definición y ejecutemos nuestra clase:
2
7 Builder.load_string("""
9 <KivyButton>:
10
11 Button:
12
13 text: "Hello Button!"
14
15 size_hint: .12, .12
16
17 Image:
18
20
21 center_x: self.parent.center_x
22
23 center_y: self.parent.center_y
24
25 """)
26
27 class KivyButton(App, BoxLayout):
28
29 def build(self):
30
31 return self
32
La salida generada se ve así:

De manera similar, puedes cargar el string Kv desde un archivo separado
usando el método load_file de la siguiente forma:
1 Builder.load_file("myfile.kv")
Este archivo contiene todas las definiciones de los widgets de Kivy.
Kivy Label (Etiqueta)

En nuestra primera aplicación de con interfaz gráfica, vamos a agregar un
label a nuestro formulario, pero jugaremos con las propiedades de la
etiqueta.
Un label se utiliza para agregar texto a nuestra GUI. Las cadenas de
caracteres ASCII y Unicode son compatibles con un label Kivy.
Cambiar el tamaño de la fuente

El tamaño de la fuente de la etiqueta también se puede cambiar usando la
propiedad font_size:
3 from kivy.uix.button import Label
7 def build(self):
9 return Label(text="Hello Label", font_size='30')
10
Añadiendo estilo al texto en el label
En esta sección, cambiaremos los estilos del texto en el label.
Por ejemplo, negrita, cursiva, cambiar de color, subrayar y mucho más

utilizando el marcado. Considera la siguiente sentencia:
Label(text='[u][color=ff0066][b]Better days[/b][/color] are coming; They

are called [i][color=ff9933]Saturday[/i] and
[i]Sunday[/color][/i][/u]',markup = True)
Donde [u][/u] se utiliza para subrayar, [b][/b] es para la fuente en
negrita, [i][/i] indica que la fuente estar en cursiva, y [color][/color] se
utiliza para colorear la fuente.

2
3 from kivy.uix.button import Label
5 class KivyLabel(App):
7 def build(self):
9 return Label(text='[u][color=ff0066][b]Welcome[/b][/color] To [i][color=ff9933]Like[/i]Geeks[/color][/u]',

markup = True)
10
11
KivyLabel().run()
Este es el resultado:
Kivy RecycleView
Haz la suposición de que tienes una gran cantidad de widgets para mostrar
en pantalla los cuales pueden afectar el rendimiento.
El objetivo de RecycleView es organizar los grupos de vistas en la pantalla.

RecycleView es eficiente en memoria ya que carga los contenidos en
memoria de acuerdo con el tamaño de la pantalla, a diferencia de ListView,
donde todos los elementos se cargan en memoria.
Una de las características clave de RecycleView es que soporta animaciones.

RecycleView puede crear una lista desplazable interactiva y eficiente.
Antes de comenzar a codificar, hay dos conceptos principales en los que

tienes que centrarte:
1. View Holder el cual sostiene una vista y ayuda al reciclaje.

2. El adapter que se utiliza para adaptar los datos a mostrar en la lista..
Para utilizar RecycleView, debemos importar RecycleView del módulo
recycleview de la siguiente manera:
from kivy.uix.recycleview import RecycleView

En el siguiente ejemplo, crearemos una lista vertical de botones. Por lo tanto,
los elementos de vista que queremos colocar son los botones:
El primer paso es definir el diseño y la clase de vista de nuestro reciclaje:
1 Builder.load_string('''
3 <ExampleRV>:
5 viewclass: 'Button'
7 RecycleBoxLayout:
9 size_hint_y: None
10
11 height: self.minimum_height
12
13 orientation: 'vertical'
14
15 ''')
Ahora tenemos que definir nuestra clase de recicleview:
1 class ExampleRV(RecycleView):
3 def __init__(self, **kwargs):
5 super(ExampleRV, self).__init__(**kwargs)
7 self.data = [{'text': str(x)} for x in range(20)]
Este __init__ es el constructor de la clase con ** kwargs, lo que significa que

cualquier número arbitrario de argumentos o argumentos de palabras
claves son aceptables. Ahora llamamos a la clase anterior:
1 class RecycleApp(App):
3 def build(self):
5 return ExampleRV()
7 RecycleApp().run()
Entonces el código completo será el siguiente:

3 from kivy.uix.recycleview import RecycleView
7 Builder.load_string('''
9 <ExampleRV>:
10
11 viewclass: 'Button'
12
13 RecycleBoxLayout:
14
15 size_hint_y: None
16
17 height: self.minimum_height
18
20
21 ''')
22
23 class ExampleRV(RecycleView):
24
26
27 super(ExampleRV, self).__init__(**kwargs)
28
29 self.data = [{'text': str(x)} for x in range(20)]

30
31 class RecycleApp(App):
32
33 def build(self):
34
35 return ExampleRV()
36
37 RecycleApp().run()
Entonces el código completo será el siguiente:
Kivy ScrollView
El ScrollView en Kivy proporciona una vista desplazable. Usando scrollview,
podemos desplazarnos a través del eje x así como el eje y en la pantalla.
Primero, importaremos una nueva función llamada runTouchApp(). Esta

función hará que nuestro scrollview touch esté habilitado.
from kivy.base import runTouchApp

Definiremos el scrollView de la siguiente manera:
1 from kivy.base import runTouchApp
5 root = Builder.load_string(r'''
7 ScrollView:
9 Label:
10
11 text: 'Scrollview Example' * 100
12
13 font_size: 30
14
15 size_hint_x: 1.0
16
17 size_hint_y: None
18
19 text_size: self.width, None
20
21 height: self.texture_size[1]
22
23 ''')
24
25 runTouchApp(root)
La salida será de la siguiente manera:
Kivy Clear text input

En esta sección, crearemos un campo de texto y un botón para borrar el
contenido del campo de texto.
Para el campo de texto, necesitas importar el módulo de entrada de texto:
from kivy.uix.textinput import TextInput

Vamos a crear un BoxLayout para agregar nuestros widgets dentro de
nuestra clase.
self.box = BoxLayout(orientation='horizontal', spacing=20, pos=(0,550))

Ahora vamos a crear un input field:
self.txt = TextInput(hint_text="Write here",size_hint=(.5,.1))

Después del input field, tenemos que crear un botón que borre el texto.
Para esto, crearemos un método clearText que asigna cadena vacía de texto
al campo y lo llamaremos cuando se presione el botón, es decir, utilizando la
propiedad on_press del botón.
Por lo tanto, cuando pulsamos el botón se borrará el texto.
self.btn = Button(text='Clear All', on_press=self.clearText,size_hint=(.1,.1))

Ahora tenemos que agregar nuestros widgets (el input filed y el button) al
boxlayout:
1 self.box.add_widget(self.txt)
3 self.box.add_widget(self.btn)
El método ClearText se muestra a continuación:
1 def clearText(self, instance):
3 self.txt.text = ''
El código completo es el siguiente:

5 from kivy.uix.textinput import TextInput
9 class ClearApp(App):
10
11 def build(self):
12
13 self.box = BoxLayout(orientation='horizontal', spacing=20)
14
15 self.txt = TextInput(hint_text='Write here', size_hint=(.5,.1))
16
17 self.btn = Button(text='Clear All', on_press=self.clearText, size_hint=(.1,.1))
18
19 self.box.add_widget(self.txt)
20
21 self.box.add_widget(self.btn)
22
23 return self.box
24
25 def clearText(self, instance):
26
27 self.txt.text = ''
28
29 ClearApp().run()
El resultado de la salida es este:
Kivy Clock
El objeto Kivy Clock se utiliza para programar la llamada de una función
después de intervalos específicos.
En esta sección, crearemos un botón. El texto del botón cambiará después de

cada 2 segundos.
Debes importar los siguientes módulos primero:

3 from kivy.clock import Clock
Ahora, crea una clase e inicialice una variable de contador de la siguiente

manera:
1 class ClockExample(App):
3 i=0
Luego, crea un botón y usando clock.schedule_interval llamaremos una

función cada 2 segundos. Cada vez que se llama a la función, el valor de la
variable del contador se incrementará en 1, lo cual se imprimirá en el botón.
1 def build(self):
3 self.mybtn = Button(text='Number of Calls')
5 Clock.schedule_interval(self.Clock_Callback, 2)
7 return self.mybtn
8
9 def Clock_Callback(self, dt):
10
11 self.i = self.i+1
12
13 self.mybtn.text = "Call = %d"%self.i
El argumento dt se usa para transcurrir el tiempo entre la programación y la

llamada de la función. Si no se pasa ningún argumento, se generará el cual
dice que la función toma 1 argumento posicional pero se dieron 2.
El código completo se ve así:
5 from kivy.clock import Clock
7 class ClockExample(App):
9 i=0
10
11 def build(self):
12
13 self.mybtn = Button(text='Number of Calls')
14
15 Clock.schedule_interval(self.clock_callback, 2)
16
17 return self.mybtn
18
19 def clock_callback(self, dt):

20
21 self.i+= 1
22
23 self.mybtn.text = "Call = %d" % self.i
24
25 ClockExample().run()
Cada 2 segundos, el texto del botón cambiará como se espera.
Kivy Canvas
La representación gráfica de un widget está representada con Kivy Canvas.
Puedes dibujar lo que quieras dentro de un lienzo (canvas).
En esta sección, aprenderá a crear un canvas y cómo dibujar un rectángulo
dentro de este.
Vamos a crear un canvas dentro de un boxlayout y luego agregar un

rectángulo dentro del canvas.
Importa los siguientes módulos:
1 import kivy
Observa el siguiente código para crear un canvas:
1 kvWidget = """
3 MyWidget:
7 canvas:
9 Color:
10
11 rgb: (255, 0, 0)
12
13 Rectangle:
14
15 size: self.size
16
17 pos: self.pos
18
19 """
20
21 class MyWidget(BoxLayout):
22
24
25 super().__init__(**kwargs)
En este código, tenemos una clase BoxLayout llamada MyWidget. Ahora la

cadena kv de widgets define un canvas con una propiedad de color y un
rectángulo con el mismo tamaño y posición del BoxLayout.
El código se muestra a continuación:
7 kvWidget = """
9 MyWidget:
10
12
13 canvas:
14
15 Color:
16
17 rgb: (255, 128, 0)
18
19 Rectangle:
20
21 size: self.size
22
23 pos: self.pos
24 """
25
27
29
31
32 class CanvasApp(App):
33
34 def build(self):
35
36 return Builder.load_string(kvWidget)
37
38 CanvasApp().run()
La salida será así:

Canvas Image
Para agregar una imagen al canvas, crearemos un rectángulo igual al tamaño
del canvas y luego agregaremos una imagen dentro del rectángulo.
La cadena kvWidget se verá como la siguiente:

4
7 kvWidget = """
9 MyWidget:
10
12
13 canvas:
14
15 Rectangle:
16
17 size: self.size
18
19 pos: self.pos
20
22
23 """
24
26
28
30
31 class CanvasApp(App):
32
33 def build(self):
34
35 return Builder.load_string(kvWidget)
36
37 CanvasApp().run()
Este sera el resultado:
Kivy vs PyQt
Como Kivy, PyQt también se usa para crear aplicaciones GUI, pero PyQt es
más conocido por aplicaciones de escritorio.
Aunque hablamos de Kivy aquí para crear aplicaciones de escritorio, Kivy se

usa comúnmente para aplicaciones móviles debido a las capacidades de los
widgets de Kivy en multitouch.
La biblioteca PyQt está disponible en otros lenguajes de programación como

C ++, mientras que Kivy solo está disponible en Python.
Kivy usa interfaces OpenGL para dibujar widgets directamente en la

pantalla, de modo que también puedes crear juegos con buenos gráficos.
Espero que encuentres el marco GUI de Python adecuado para construir lo
que necesitas.
Por fin, discutimos muchos ejemplos para Kivy y previamente Tkinter,

PyQt5. ¿Cuál prefieres para construir tus interfaces gráficas?
Tutorial De Python Pandas: Iniciando Con
DataFrames
2019-02-21 Comment(0)
Pandas es una biblioteca de código abierto de Python que proporciona

análisis y manipulación de datos en la programación en Python.
Es una biblioteca muy prometedora de representación de datos, filtrado y
programación estadística. La pieza más importante en pandas es el
DataFrame donde almacena y juega con los datos.
En este tutorial, aprenderás qué es un DataFrame, cómo crearlo desde

diferentes fuentes, cómo exportarlo a diferentes resultados y cómo
manipular sus datos.

 1 Instalar pandas
 2 Leer un archivo de Excel
 3 Importar archivo CSV
 4 Leer un archivo de texto
 5 Leer SQL
 6 Seleccionar columnas
 7 Seleccionar filas por valor
 8 Seleccionar fila por índice
 9 Cambiar tipo de columna
 10 Aplicar una función a columnas / filas
 11 Ordenar valores / ordenar por columna
 12 Quitar / Eliminar duplicados
 13 Eliminar duplicados por columna
 14 Borrar una columna
 15 Eliminar filas
 16 Sumar una columna
 17 Contar valores únicos
 18 Filas de subconjuntos
 19 Escribir a un Excel
 20 Escribir a un archivo CSV
 21 Escribir a SQL
 22 Escribir a JSON
 23 Escribir en un archivo HTML
Instalar pandas
Puedes instalar pandas en Python usando pip. Ejecuta el siguiente comando
en cmd:
pip install pandas
Además, puedes instalar pandas usando conda así:
conda install pandas
Leer un archivo de Excel

Puedes leer desde un archivo de Excel usando el método read_excel () de
pandas. Para esto, necesitas importar un módulo más llamado xlrd.
Instala xlrd usando pip:
pip install xlrd

El siguiente ejemplo muestra cómo leer de una hoja de Excel:
1. Creamos una hoja de Excel con los siguientes contenidos:
2. Importa el módulo de pandas.

import pandas
3. Pasaremos el nombre del archivo de Excel y el número de hoja del que
necesitamos leer los datos al método read_excel ().
pandas.read_excel('pandasExcel.xlsx', 'Sheet1')
El fragmento anterior generará el siguiente resultado:
Si verificas el tipo de salida usando la palabra clave de type, te dará el
siguiente resultado:
<class 'pandas.core.frame.DataFrame'>
¡Este resultado es llamado DataFrame! Esa es la unidad básica de pandas
con la que vamos a tratar hasta el final del tutorial.
El DataFrame es una estructura de 2 dimensiones etiquetada donde
podemos almacenar datos de diferentes tipos. DataFrame es similar a una
tabla SQL o una hoja de cálculo de Excel.
Importar archivo CSV

Para leer un archivo CSV, puedes usar el método read_csv () de pandas.
Importa el módulo de pandas:
import pandas
Ahora llama al método read_csv () de la siguiente manera:
pandas.read_csv('Book1.csv')
Book1.csv tiene el siguiente contenido:
El código generará el siguiente DataFrame:
Leer un archivo de texto

También podemos usar el método read_csv de pandas para leer desde un
archivo de texto; Considera el siguiente ejemplo:
1 import pandas
3 pandas.read_csv('myFile.txt')
El myFile.txt tiene el siguiente formato:

La salida del código anterior será:
Este archivo de texto se trata como un archivo CSV porque tenemos

elementos separados por comas. El archivo también puede usar otro
delimitador, como un punto y coma, un tabulador, etc.
Supongamos que tenemos un delimitador de tabulador y el archivo se ve así:

Cuando el delimitador es una un tabulador, tendremos el siguiente
resultado:
Como pandas no tiene idea del delimitador, traduce el tabulador a \ t.
Para definir el carácter de tabulación como un delimitador, pase el

argumento delimiter de esta manera:
pandas.read_csv('myFile.txt', delimiter='\t')
Ahora la salida será:
Parece correcto ahora.
Leer SQL
Puede usar el método read_sql () de pandas para leer desde una base de
datos SQL. Esto se demuestra en el siguiente ejemplo:
1 import sqlite3
3 import pandas
5 con = sqlite3.connect('mydatabase.db')
7 pandas.read_sql('select * from Employee', con)
En este ejemplo, nos conectamos a una base de datos SQLite3 que tiene una
tabla llamada “Empleado”. Usando el método read_sql () de pandas, pasamos
una consulta y un objeto de conexión al método read_sql (). La consulta
recupera todos los datos de la tabla.
Nuestra tabla de empleados se parece a la siguiente:
Cuando ejecutes el código anterior, la salida será como la siguiente:
Seleccionar columnas
Supongamos que tenemos tres columnas en la tabla Empleado de esta
manera:
Para seleccionar columnas de la tabla, pasaremos la siguiente consulta:
select Name, Job from Employee

La sentencia del código de pandas será la siguiente:
pandas.read_sql('select Name, Job from Employee', con)
También podemos seleccionar una columna de una tabla accediendo al

DataFrame a. Considera el siguiente ejemplo:
1 x = pandas.read_sql('select * from Employee', con)
3 x['Name']
El resultado será el siguiente:
Seleccionar filas por valor

Primero, crearemos un DataFrame desde el cual seleccionaremos filas.
Para crear un DataFrame, considera el siguiente código:
1 import pandas
3 frame_data = {'name': ['James', 'Jason', 'Rogers'], 'age': [18, 20, 22], 'job': ['Assistant', 'Manager', 'Clerk']}
4
5 df = pandas.DataFrame(frame_data)
En este código, creamos un DataFrame con tres columnas y tres filas usando
el método DataFrame () de pandas. El resultado será el siguiente:
Para seleccionar una fila de acuerdo a su valor, ejecute la siguiente sentencia
df.loc[df['name'] == 'Jason']
df.loc [] o DataFrame.loc [] es una arreglo booleano que se puede usar para
acceder a filas o columnas mediante valores o etiquetas. En el código
anterior, se buscará la fila donde el nombre es igual a Jason.
La salida será:
Seleccionar fila por índice

Para seleccionar una fila por su índice, podemos usar el operador de
segmentación (:) o el arreglo df.loc [].
Considera el siguiente código:

1 >>> frame_data = {'name': ['James', 'Jason', 'Rogers'], 'age': [18, 20, 22], 'job': ['Assistant', 'Manager', 'Clerk']}
3 >>> df = pandas.DataFrame(frame_data)
Creamos un DataFrame. Ahora vamos a acceder a una fila usando df.loc []:
>>> df.loc[1]
Como puedes ver, recuperamos una fila. Podemos hacer lo mismo usando el
operador de segmentación de la siguiente manera:
>>> df[1:2]
Cambiar tipo de columna

El tipo de datos de una columna se puede cambiar usando el atributo astype
() de DataFrame. Para verificar el tipo de datos de las columnas, usamos el
atributo dtypes de DataFrame.
>>> df.dtypes
La salida será:
Ahora para convertir el tipo de datos de uno a otro:
>>> df.name = df.name.astype(str)

Buscamos la columna ‘name’ de nuestro DataFrame y cambiamos su tipo de
datos de objeto a cadena de caracteres.
Aplicar una función a columnas / filas

Para aplicar una función en una columna o fila, puedes usar el método apply
() de DataFrame.
Considere el siguiente ejemplo:
1 >>> frame_data = {'A': [1, 2, 3], 'B': [18, 20, 22], 'C': [54, 12, 13]}
Creamos un DataFrame y agregamos valores de tipo entero en las filas. Para

aplicar una función, por ejemplo, la raíz cuadrada en los valores,
importaremos el módulo numpy para usar la función sqrt de esta manera:
1 >>> import numpy as np
3 >>> df.apply(np.sqrt)
La salida será la siguiente:
Para aplicar una función de suma, el código será:

>>> df.apply(np.sum)
Para aplicar la función a una columna especifica, puedes especificar la

columna de la siguiente forma:
>>>df['A'].apply(np.sqrt)
Ordenar valores / ordenar por columna

Para ordenar los valores en un DataFrame, utiliza el método sort_values ()
del DataFrame.
Crea un DataFrame con valores enteros:
1 >>> frame_data = {'A': [23, 12, 30], 'B': [18, 20, 22], 'C': [54, 112, 13]}
Ahora para ordenar los valores:
>>> df.sort_values(by=['A'])
La salida será:
El método sort_values () tiene un atributo “by” que es necesario. En el código
anterior, los valores se ordenan por la columna A. Para ordenar por varias
columnas, el código es el siguiente:
>>> df.sort_values(by=['A', 'B'])

Si desea ordenar en orden descendente, establece el atributo ascending de
set_values en False de la siguiente manera:
>>> df.sort_values(by=['A'], ascending=False)

La salida será:
Quitar / Eliminar duplicados

Para eliminar filas duplicadas de un DataFrame, usa el método
drop_duplicates () del DataFrame.
Considera el siguiente ejemplo:
>>> frame_data = {'name': ['James', 'Jason', 'Rogers', 'Jason'], 'age': [18, 20, 22, 20], 'job': ['Assistant', 'Manager',
1
'Clerk', 'Manager']}
2
3
>>> df = pandas.DataFrame(frame_data)
Aquí creamos un DataFrame con una fila duplicada. Para verificar si hay filas
duplicadas en el DataFrame, usa el método duplicated () del DataFrame.
>>> df.duplicated()
El resultado será:
Se puede ver que la última fila es un duplicado. Para eliminar esta fila,
ejecuta la siguiente línea de código:
>>> df.drop_duplicates()
Ahora el resultado será:
Eliminar duplicados por columna

A veces, tenemos datos en los que los valores de las columnas son los
mismos y deseamos eliminarlos. Podemos eliminar una fila por columna al
pasar el nombre de la columna que debemos eliminar.
Por ejemplo, tenemos el siguiente DataFrame:
>>> frame_data = {'name': ['James', 'Jason', 'Rogers', 'Jason'], 'age': [18, 20, 22, 21], 'job': ['Assistant', 'Manager',
1
'Clerk', 'Employee']}
2
3
>>> df = pandas.DataFrame(frame_data)
Aquí puedes ver que Jason esta dos veces. Si desea eliminar duplicados por
columna, simplemente pasa el nombre de la columna de la siguiente manera:
>>> df.drop_duplicates(['name'])
El resultado será como el siguiente:
Borrar una columna

Para eliminar una columna o fila completa, podemos usar el método drop ()
del DataFrame especificando el nombre de la columna o fila.
>>> df.drop(['job'], axis=1)

En esta línea de código, estamos eliminando la columna llamada “job”. El
argumento del eje es necesario aquí. Si el valor del eje es 1 significa que
queremos eliminar columnas, si el valor del eje es 0 significa que la fila se
eliminará. En valores de eje, 0 es para índice y 1 para columnas.
El resultado será:
Eliminar filas
Podemos usar el método drop () para eliminar una fila al pasar el índice de
la fila.
Supongamos que tenemos el siguiente DataFrame:
Para eliminar una fila con el índice 0 donde el nombre es James, la edad es
18 y el trabajo es asistente, utiliza el siguiente código:
>>> df.drop([0])
Vamos a crear un DataFrame donde los índices son los nombres:

3 >>> df = pandas.DataFrame(frame_data, index = ['James', 'Jason', 'Rogers'])
Ahora podemos eliminar una fila con un cierto valor. Por ejemplo, si
queremos eliminar una fila donde el nombre es Rogers, entonces el código
será:
>>> df.drop(['Rogers'])
La salida será:
También puedes eliminar un rango de filas de la siguiente forma:
>>> df.drop(df.index[[0, 1]])

Esto eliminará las filas del índice 0 a 1 y solo quedará una fila ya que nuestro
DataFrame se compone de 3 filas:
Si deseas eliminar la última fila del DataFrame y no sabe cuál es el número

total de filas, puede utilizar la indexación negativa como se muestra a
continuación:
>>> df.drop(df.index[-1])
-1 borra la última fila. Similarmente -2 borrará las últimas 2 filas y así
sucesivamente.
Sumar una columna

Puede usar el método sum () del DataFrame para sumar los elementos de la
columna.
Supongamos que tenemos el siguiente DataFrame:
1 >>> frame_data = {'A': [23, 12, 12], 'B': [18, 18, 22], 'C': [13, 112, 13]}
Ahora para sumar los elementos de la columna A, usa la siguiente línea de

código:
>>> df['A'].sum()
También puedes usar el método apply () del DataFrame y pasar el método

de suma de numpy para sumar los valores.
Contar valores únicos

Para contar valores únicos en una columna, puedes usar el método nunique
() del DataFrame.
Supongamos que tenemos un DataFrames como a continuación:
1 >>> frame_data = {'A': [23, 12, 12], 'B': [18, 18, 22], 'C': [13, 112, 13]}
Para contar los valores únicos en la columna A:
>>> df['A'].nunique()
Como puedes ver, la columna A tiene solo 2 valores únicos 23 y 12 y el otro

12 es un duplicado, por eso tenemos 2 en la salida.
Si desea contar todos los valores en una columna, puedes usar el método
count () de la siguiente manera:
>>> df['A'].count()
Filas de subconjuntos
Para seleccionar un subconjunto de un DataFrame, puedes usar los
corchetes.
Por ejemplo, tenemos un DataFrame que contiene algunos enteros. Podemos

seleccionar o buscar el subconjunto de una fila de esta forma:
df.[start:count]
El punto de inicio se incluirá en el subconjunto, pero el punto de parada no
se incluye. Por ejemplo, para seleccionar 3 filas a partir de la primera fila,
escribirás:
>>> df[0:3]
La salida será:
Ese código significa comenzar desde la primera fila que es 0 y selecciona 3

filas.
Del mismo modo, para seleccionar las primeras 2 filas, escribirás:
>>> df[0:2]
Para seleccionar o buscar un subconjunto con la última fila, usa la indexación

negativa:
>>> df[-1:]
Escribir a un Excel
Para escribir un DataFrame en una hoja de Excel, podemos usar el método
to_excel ().
Para escribir en una hoja de Excel, tiene que abrir la hoja y para abrir una
hoja de Excel, tendremos que importar el módulo openpyxl.
Instala openpyxl usando pip:
pip install openpyxl

1 >>> import openpyxl
7 >>> df.to_excel("pandasExcel.xlsx", "Sheet1")
El archivo de Excel se verá como el siguiente:

Escribir a un archivo CSV
De manera similar, para escribir un DataFrame en CSV, puede usar el
método to_csv () como se muestra en la siguiente línea de código.
>>> df.to_csv("pandasCSV.csv")
El archivo de salida será como el siguiente:
Escribir a SQL
Para escribir datos en SQL, podemos usar el método to_sql ().
1 import sqlite3
3 import pandas
5 con = sqlite3.connect('mydatabase.db')
7 frame_data = {'name': ['James', 'Jason', 'Rogers'], 'age': [18, 20, 22], 'job': ['Assistant', 'Manager', 'Clerk']}
8
9 df = pandas.DataFrame(frame_data)
10
11 df.to_sql('users', con)
En este código, creamos una conexión con una base de datos sqlite3. Luego
creamos un DataFrame con tres filas y tres columnas.
Finalmente, utilizamos el método to_sql de nuestro DataFrame (df) y

pasamos el nombre de la tabla donde se almacenarán los datos junto con el
objeto de conexión.
La base de datos SQL se verá de la siguiente forma:
Escribir a JSON
Puede usar el método to_json () del DataFrame para escribir en un archivo
JSON.
Esto se demuestra en el siguiente ejemplo:
>>> df.to_json("myJson.json")
En esta línea de código, el nombre del archivo JSON se pasa como un
argumento. El DataFrame se almacenará en el archivo JSON. El archivo
tendrá el siguiente contenido:
Escribir en un archivo HTML

Puede usar el método to_html () del DataFrame para crear un archivo HTML
con el contenido del DataFrame.
>>> df.to_html("myhtml.html")
El archivo de resultados tendrá el siguiente contenido:
Cuando abras el archivo HTML en el navegador, se verá así:
Trabajar con pandas es muy fácil. ¡Es como trabajar con hojas de Excel!
Pandas DataFrame es una biblioteca muy flexible que puedes usar.
Espero que encuentres el tutorial útil. Vuelve pronto.

En Este Tutorial

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

En Este Tutorial

Cargado por

Copyright:

Formatos disponibles

En este tutorial, aprenderemos a desarrollar interfaces gráficas de usuario

(GUI del inglés Graphics User Interfaces) escribiendo algunos ejemplos de la

El paquete Tkinter está incluido en Python como un paquete estándar, por lo

El paquete Tkinter es un paquete muy poderoso. Si ya ha instalado Python,

Asumo que tienes conocimientos de Python básico que te ayudará a

Table of Contents [hide]

Crear tu primera aplicación GUI

1 from tkinter import *

Crear un widget label (etiqueta)

1 from tkinter import *

Sin llamar a la función grid para label, la etiqueta no aparecerá.

Para hacerlo, puedes pasar el parámetro font de esta manera:

Debes tener en cuenta que el parámetro font se puede pasar a cualquier

Establecer el tamaño de una ventana

Intentemos agregar más widgets como botones y ver cómo manejar el

1 btn = Button(window, text="Click Me")

1 from tkinter import *

Cambiar los colores de fondo y primer plano de

Ahora, si trataste de hacer click en el botón, no pasó nada, porque el

1 btn = Button(window, text="Click Me", command=clicked)

1 from tkinter import *

Entrada de datos usando la clase Entry

Puedes crear un cuadro de texto usando la clase Tkinter Entry de esta

1 from tkinter import *

Ahora, si haces click en el botón, se mostrará el mismo mensaje anterior.

Primero, podemos obtener texto de entrada usando la función get. Entonces

1 from tkinter import *

Establecer el foco en el widget de entrada

Deshabilitar el widget de entrada

Ahora, ya no podrás ingresar ningún texto.

Agregar un widget combobox

1 from tkinter import *

Para configurar el elemento seleccionado, puedes pasar el índice del

Agregar un widget Checkbutton (Tkinter

1 from tkinter import *

Además, puedes usar IntVar en lugar de BooleanVar y establecer el valor en 0

Agregar widgets radio button

Además, puedes configurar el command de cualquiera de estos botones de

Obtener el valor del radio button (opción

1 from tkinter import *

Cada vez que seleccione un botón de opción, el valor de la variable cambiará

Adicionar un widget ScrolledText (Tkinter

1 from tkinter import scrolledtext

1 from tkinter import *

Establecer el contenido del scrolledtext

Vamos a mostrar un cuadro de mensaje cuando el usuario haga click en un

1 from tkinter import *

Cuando hagas click en el botón, un cuadro de mensajes informativo

Mostrar mensajes de error y de advertencia

1 messagebox.showwarning('Message title', 'Message content') #shows warning message

Mostrar diálogos de pregunta-respuesta

1 from tkinter import messagebox

Agregar un SpinBox (widget de números)

1 from tkinter import *

Puedes especificar números para el Spinbox en lugar de usar todo el rango,

spin = Spinbox(window, values=(3, 8, 11), width=5)

Establecer el valor por defecto del Spinbox

Adicionar el widget Progressbar

1 from tkinter.ttk import Progressbar

Cambiar el color de un Progressbar

Primero, crearemos un estilo, luego en dicho estilo estableceremos el color

Revisa el siguiente ejemplo:

Adicionar un diálogo para archivos (elegir