Integrando Python con Excel

Felipe C. R. dos Santos

1 Integrando Python con Excel

La importancia de Excel actualmente es innegable, además de formar parte, junto a Word
y el Power Point, de tríplicemais populardo Office, su uso vem se tornando
casi que una necesidad no solo para el uso doméstico sino también el cuerpo
rativo y el académico. El programador, técnico en computación, analista de sistemas
ou profissional de qualquer outro ramo da TI que nunca utilizou o Excel que
ataque la primera piedra. El profesional de la contabilidad, administración, recursos
humanos o gerencia que nunca lo utilizó, que arroje las dos primeras piedras.
Su popularidad, además de ser altamente perceptible, es fácilmente explicable: tra-
Los trabajos que se quedarían por hacer exigían un alto nivel de cuidado, como hacer el informe.
El fiscal de una empresa se convierte en una tarea de pocas horas y con una seguridad
enorme.
Pero todo lo bueno... Puede mejorar, ¿no es así?
Con Excel no es diferente. Imagina tomar esta tarea de pocas horas.
transformar em tarefa depoucos minutos!
A través de la programación puedes de forma simple automatizar toda la
creación y gestión de una hoja de cálculo.
Y hablando de programación de forma simple... Imposible no recordar de
¡Python!
Pensé en cómo sería bueno si solo configurando una única vez un autom
atizador de planillas, que vaya hasta la fuente de tus datos, lo recupere, ya efectuando
toda la análisis necesario, y los inserta en la hoja de cálculo, lograste prácticamente
¿computerizar todo tu trabajo? Además de evitar perder tiempo con tareas
repetitivas, básicamente estarías recibiendo tu salario solo por quedarte analizado
isando la ejecución de su software y, si es necesario, hacer una actualización u otra
no código.
En este curso te enseñaremos todo lo necesario para construir desde cero una
planilla completa y bien profesional en Excel, que pueda atender sus de-
mandas e te ayudar a automatizar tu trabajo.
Entonces, sin más preámbulos, ¿vamos a empezar?
1.1 Python + Excel = OpenPyXL
OpenPyXL es una biblioteca de Python para leer/escribir archivos de Excel
xlsx/xlsm/xltx/xltm. Nació de la falta de una biblioteca existente para leer/escribir en-
tivamente de Python en formato Office Open XML.
En resumen, de la necesidad de la manipulación de archivos Excel en Python,
surgió OpenPyXL.
OpenPyXL puede manipular tanto Workbooks como Worksheets de
forma completa y muy fácil, por lo tanto, lo utilizaremos durante este curso.
Para instalarlo, basta usar el comando: > pip install openpyxl

1.2 Workbooks e Worksheets

NoExcelumaWorksheetesuna hoja de cálculo única, compuesta por filas y columnas.
Un Workbook (Libro de Trabajo) es un conjunto de Worksheets.
Siempre que creamos un nuevo archivo en Excel en realidad no estamos
creando una Hoja de Cálculo, pero sí, un Libro de Trabajo. Así que, creamos un
Workbooke no unWorsheet.
Por lo tanto, en Python no sería diferente, primero creamos un Workbook y den-
A partir deste objeto, criamos nossa hoja de cálculo.
Por convención de OpenPyXL utilizamos los siguientes nombres en las variables:
[Link]=>workbook [Link]=>worksheet
Sin embargo, para una mejor didáctica y comprensión, usaremos los nombres de carpeta.
planilla (respectivamente) en este libro.

2 Importando la biblioteca
Para poder usar la biblioteca, primero necesitamos importarla en nuestro pro-
jeto, para isso podemos usar:
importar openpyxl
Sin embargo, como lo que usaremos mayoritariamente es solo la clase Workbook
podemos importarlo de la siguiente forma:
de openpyxl importar Workbook
De esta forma, podemos usarla directamente (sin necesidad de usar open-
[Link])
from openpyxl import Workbook
3 Creando nuestro primer libro de trabajo
Para criar um workbook é bem simples, bastainstanciarmos(criarmos) um novo
objeto(variável) do tipoWorkbook.
Para eso, solo hay que ejecutar el constructor de la clase Workbook, como en el código a continuación:

pasta=Workbook()

4 Salvando um arquivo
Sería muy triste si no pudiéramos guardar nuestro trabajo con OpenPyXL,
¿no?
Felizmente, tenemos una forma muy sencilla de guardar todo lo que hicimos en un ar-
[Link].
Para esto, solo necesitamos llamar a la función save() de nuestro Workbook (libro de trabajo)
balho) y pasar como parámetro (valor entre los paréntesis) el nombre de nuestro ar-
quivo con la extensión xlsx (obligatoriamente).
[Link]('[Link]')

5 Abrindo planilhas já existentes

Muchas veces ya tenemos un archivo previamente hecho y queremos utilizarlo, al in-
vez de crear una nueva desde cero.
Para eso, necesitamos cargar un libro de trabajo, ¿cierto? Entonces nada más justo
que un método llamado justamente eso, en casoload_workbook().
Então, primeiramente, precisamos importar nosso método responsável por car-
regar libros de trabajo:

de openpyxl importar cargar_libro_de_trabajo

fromopenpyxlimportarload_workbook
Ahora solo hay que llamar a la función load_workbook(), donde pasamos como parámetro
el camino y nombre de nuestro archivo existente.
Recordando que si el archivo está en la misma carpeta que tu proyecto, tú
puedes simplemente dar su nombre.
pasta_existemte=load_workbook('arquivo_existente.xlsx')
6Trabajando con hojas de cálculo

6.1 Creando nuestra primera hoja de cálculo

Siempre es bueno saber que un libro de trabajo ya viene con una hoja de cálculo estándar creada.
llamada de hoja.
Sin embargo, también tenemos la opción de crear nuevas hojas de cálculo, a través del método
crear_hoja().
Este método tiene dos parámetros, que son:

[Link]: nome (título) da planilha => Obrigatório;

[Link]: índice (posição) onde queremos inserir nossa planilha => Opcional.

Si no enviamos el parámetro índice, la hoja será insertada al final, como

la última no workbook.
pasta.crear_hoja("Creando Hoja");
Además, el método create_sheet() es retornable, por lo que podemos
atribuir esta hoja de cálculo que creamos a una variable y usarla después:
planilha=pasta.create_sheet("Mi Hoja")
planilha=pasta.create_sheet("Planilha Indice",1)# Inserta no␣
,→índice 1

6.2 Nombre de la hoja de cálculo

También podemos recuperar el título (nombre) de la hoja de cálculo, a través de la propiedad
title.
nome=[Link]
print("El nombre de la Hoja es:", nombre)

El nombre de la Hoja es: Hoja Índice

6.3 Renombrando nuestra hoja de cálculo

Podemos também atribuir um valor para a propriedadetitleda planilha, dessa
forma, conseguimos renombrar la hoja.
[Link]='Planilha Criada'
6.4 Listando planilhas
Para enumerar todas las hojas de cálculo, podemos usar la propiedad
hojas de trabajo en nuestra carpeta (libro de trabajo).

Esta propiedad nos devolverá una lista con elementos del tipo worksheet.
então podemos utilizá-las para editar a planilha futuramente.
planilhas=[Link]
imprimir(planilhas)

["<Hoja \"Hoja\">","<Hoja \"Planilha Criada\">"]

,→<Hoja de trabajo "Criando
Planilha">, <Worksheet "Minha Planilha">]
Podemos también listar el nombre de todas las hojas de cálculo, a través de la propiedad
nombres de hojas
Esta vez, no se devolverán elementos del tipo worksheet, solo cadenas.
contiendo el nombre de la hoja de cálculo incluso.

nombres_hojas=[Link]
imprimir(nomes_planilhas)

[Output]:['Sheet','Planilha Criada','Criando Planilha','Minha␣

,→Hoja de cálculo

6.5 Recuperando la hoja de cálculo activa (seleccionada)

Podemos también saber cuál será la hoja de cálculo que estará activa (seleccionada) en Excel, o
sea, en caso de que tengamos más de una hoja de cálculo en nuestra carpeta, podemos informal al
Excel, cuál de ellas estará seleccionada al abrir el archivo.
Para eso podemos usar la propiedad activa.
planilha_atual=[Link]
imprimir(planilha_atual)

[Output]:<Worksheet "Sheet">
6.6 Obtención de hojas de cálculo

6.6.1 Obtendo planilhas por nome

También podemos obtener una hoja de cálculo de nuestra carpeta, es decir, buscamos una
planilla en nuestra carpeta y devolvemos esta planilla buscada.
Para eso podemos buscar en nuestra carpeta de la siguiente forma:

pasta[‘nome_da_planilha’]

Donde el nombre de la hoja se pasa como cadena (entre comillas).

planilha=pasta['Planilha Criada']
imprimir(planilha)

[Output]:<Worksheet "Planilha Criada">

6.6.2 Obtendo planilhas por nome de forma segura

Sin embargo, si intentamos recuperar una hoja de cálculo que no existe, obtendremos un error.
do tipo KeyError, ou seja, a chave que estamos buscando (nome da planilha) não
existe en nuestra carpeta.
planilha=pasta['Planilha']

KeyError: 'La hoja de cálculo Planilha no existe.'

Para esto, primero podemos verificar si la carpeta contiene una hoja de cálculo con eso.
nombre (a través de las propiedades sheetnames, ¿recuerdas?)
Si existe, entonces obtendremos la hoja de cálculo en la carpeta. De lo contrario, avisamos que
no existe tal hoja de cálculo.
si 'Planilha' en pasta.nombres_de_hojas:
planilha=pasta['Planilha']
sino:
No hay ninguna hoja de cálculo con ese nombre

No hay ninguna hoja de cálculo con ese nombre

6.6.3 Obteniendo hojas por índice
También podemos obtener la hoja de cálculo a través del índice (posición) de la misma en nuestra carpeta.
Para esto, podemos usar la propiedad worksheets e informar el índice que
queremos, como por exemplo:
planilha = [Link][0]

Donde 0 es el índice que queremos recuperar.

indice= 1
planilha=[Link][indice]

imprimir(planilha)

[Output]:<Worksheet "Planilha Criada">

6.6.4 Obteniendo hojas de cálculo por índice de forma segura

También podemos enfrentar errores debido a que el índice buscado es inválido, ya sea él
menor que 0 o mayor que el máximo.
indice= 10
[Link][indice]

[Output]:IndexError: list index out of range

Para contornar isso, podemos primeiro checar se o índice está entre o intervalo
mínimo o máximo (tamaño - 1)
indice= 10
si indice < len([Link]) y indice >= 0:
[Link][indice]
sino:
Índice no está dentro del intervalo válido. Mínimo: 0␣
,→| Máximo:

El índice no está dentro del rango válido.

Mínimo: 0 | Máximo: 3

6.7 Mudando a planilha ativa (selecionada)

También podemos cambiar la carpeta activa (seleccionada) en Excel.
Así como usamos la propiedad active para recuperar la hoja de cálculo seleccionada.
cionada, podemos también usarla para alterar la hoja de cálculo actualmente activa.

[Link]=pasta['Minha Planilha']
print([Link])

[Output]:<Worksheet "Minha Planilha">

6.8 Copiando hojas de cálculo
También podemos crear una copia de una hoja de cálculo (todos sus valores de cada
célula) y pasar a otra hoja de cálculo.
Para esto podemos usar el método copy() y enviar como parámetro la hoja de cálculo.
ser copiada.
original=pasta['Minha Planilha']
copia=pasta.copy_worksheet(original)

imprimir(copia.título)

Minha Planilha Copy

6.9 Alterando el color de fondo de la pestaña de la hoja de cálculo

Por fin, también podemos editar las propiedades de las hojas de cálculo, como por ejemplo
cambiar el color de la pestaña de la hoja de cálculo, que se encuentra en la esquina inferior de Excel.

Para eso, accedemos a propertiesheet_properties.tabColorda la hoja de cálculo y

atribuir a esta propriedade o valor hexadecimal da nossa cor.
planilha.sheet_properties.tabColor='34EBB7'

7Trabajando con celdas

7.1 Recuperando células
7.1.1 Recuperando uma célula
Así como podemos obtener una hoja de cálculo a través de la carpeta usando una clave
para pesquisa (igual em um objeto do tipo dicionário), podemos fazer o mesmo
con las celdas, pasando una clave correspondiente a ella en nuestra hoja de cálculo.
Para ello, trabajar con la clave igual a Excel, ejemplos:
1. CélulaA1=> Chave =A1;
2. CélulaB3=> Clave =B3;
3. CélulaD7=> Clave =D7.
Es decir, una letra para representar la columna y un número para representar la
línea.
De esta manera, podemos tomar la célula de la siguiente manera:

celula = planilha[‘CHAVE’]

celula=planilha['A1']
imprimir(celula)

<Celda 'Planilha Criada'.A1>

7.1.2 Recuperando una celda por el índice
Podemos también obtener por el índice de la celda, donde informamos el valor de la fila
(row) e coluna (colum).
Recordatorio que para facilitar, los índices de ambas comienzan en 1.
De esta forma:
1. Columna 1 x Fila 1 = A1
2. Coluna 3 x Linha 4 = C4
3. Columna 2 x Fila 5 = B5
Ahora, para tomar esta celda, vamos a usar la función cell() en nuestra hoja de cálculo,
donde pasamos dos parámetros: fila (línea) y columna.
celula=[Link](row=4, column=2)# Columna 2 = B Fila 4 =␣
,→4 => Célula = B4
imprimir(celula)

<Célula' fórmula'.B4>

7.1.3 Recuperando el valor de una celda

Para recuperar el valor de una celda podemos usar la propiedad valor de
célula.
Revisando que: En caso de no tener nada devuelve None.
Como hasta ahora en el tutorial no hemos inicializado ningún valor para la celda, el valor
entonces será el patrón (Ninguno).

celula=planilha['B4']
valor=[Link]
imprimir(valor)

Ninguno

Ahora en la próxima etapa ya hemos asignado el valor de 10 a la celda (verás

esto pronto).
¿Vamos a ver el código para recuperar el valor de nuevo entonces?
valor=[Link]
imprimir(valor)

[Output]:10
7.1.4 Recuperando o valor de uma célula pelo índice
También podemos recuperar una celda a través de su índice (como vimos antes)
riormente) y como el retorno también será un objeto del tipo celda, podemos igual-
mente recuperar o valor da propriedade value.
celula=[Link](row=4, column=2)Columna 2 = B Fila 4 = 4ª␣
,→linha => Célula = B4
print([Link])

10

7.2 Insertando valores

7.2.1 Insertando un valor en una celda
Ya para asignar un valor a una celda, podemos nuevamente tomar apr-
propiedadevalor y asignar un valor a esto.
Como por ejemplo:

planilha[‘Chave’].value= ‘valor’

planilha['A1'].value='Soy el A1'
imprimir(planilha['A1'].valor)

Soy A1
Maaaas. . . Podemos também fazer de uma forma maisresumida.
Para ello, podemos simplemente tomar la celda y asignar un valor directamente a ella.
objetocell, sin necesidad de tomar la propiedad value.
Es decir... Para insertar un valor, podemos atribuirlo directamente en
variable y automáticamente este valor será insertado en la propiedad value:

planilha[‘Chave’] = ‘valor’

planilha['B3']= 3
imprimir(planilha['B3'].valor)

[Output]:3

7.2.2 Inserindo um valor em uma célula pelo índice

También podemos usar el método cell() (que ya usamos anteriormente para recu-
preparar una hoja de cálculo) y usar un tercer parámetro, llamado value. El valor pas-
sado en este parámetro se insertará como valor para la celda:
celula=[Link](row=4, column=2, value='Bê Quatro')
print([Link])

Bê Cuatro
7.3 Recuperando células en un intervalo
7.3.1 Intervalo entre células
Además de recuperar el valor de una sola celda, podemos obtener los valores
de un intervalo de celda de una sola vez.
Por ejemplo, en lugar de tomar el valor de las celdas A1, A2, A3, A4, B1, B2,
B3 y B4, podemos tomar de una vez todas las celdas del rango entre A1 y B4,
que daría lo mismo y sería mucho más práctico.
Para eso, podemos usar la función defatiardo python, que toma solo una
fatia (parte) de nuestra secuencia.
Las rebanadas en Python funcionan de la siguiente manera: [ 'Posición Inicial' : 'Posición
Final’ ]
Es decir, para tomar entre el intervalo A1 y B2, comenzando en A1 y terminando
emB2, tenemos lo siguiente:

[ ‘A1’ :‘B2’]

Entonces, para obtener este intervalo de celdas, solo podemos pedirle a Python
para retornar esa porción de la hoja de cálculo:

intervalo_celulas = planilhas[ ‘A1’ : ‘B2’ ]

intervalo_celulas=planilha['A1':'B2']
imprimir(intervalo_celulas)

Planilla Creada
,→B1>), (<Celda 'Hoja

Criada'.A2>, <Celda'Planilha Criada'.B2>))

7.3.2 Intervalo entre líneas

Podemos también en lugar de usar la clave que representa la celda (Columna y Fila,
ex: A1,B2,C3. . .) para fatiar, podemos usar el valor que representa las líneas que
queremos recuperar, de esta forma, podemos tomar todas las células en estas líneas.
Como las líneas están representadas por números, para obtener todas las celdas de
líneas 2 y 3 usamos:

intervalo_linhas = planilha[‘2’:‘3’]

intervalo_linhas=planilha['2':'3']
imprimir(intervalo_linhas)

[Salida]:((<Celda 'Planilha Criada'.A2>, <Celda 'Planilha Criada'.

,→B2>), (<Celda'Planilla

Criada'.A3>, <Celda'Planilha Criada'.B3>

Como alternativa, también podemos iterar filas, usando la función iter_rows(),
donde tenemos los siguientes 4 parámetros:

1.min_row: A linha inicial (linha mínima)

2.min_col: A coluna inicial (coluna mínima)

3.max_row: A linha final (linha máxima)

4.max_col: La columna final (columna máxima)

Siendo así, para obtener entre el intervalo A1 y C4 necesitamos obtener entre las
célulasColuna1 x Linha1eColuna3 x Linha4.
De esta forma:

1.min_row: 1

2.min_col: 1

3.max_row: 4

4.max_col: 3

forlinhainplanilha.iter_rows(min_row=1, min_col=1, max_row=4,

,→max_col=3):

print("Linha: ",linha)

Línea: (<Celda 'Planilla Creada'.A1>, <Celda 'Planilla

,→Criada'.B1>, <Celda

Planilla creada
Línea: (<Celda 'Planilla Creada'.A2>, <Celda 'Planilla Creada'.B2>,
,→<Celda

Hoja creada
Línea: (<Celda 'Hoja Creada'.A3>, <Celda 'Hoja Creada'.B3>,
,→<Celda>

'Planilha Criada'.C3>)
Línea: (<Cell 'Planilla Creada'.A4>, <Cell 'Planilla Creada'.B4>,
,→<Celda

Hoja de cálculo creada

7.3.3 Intervalo entre columnas
Así como hicimos con las filas, también podemos dividir las columnas, es decir,
podemos pegar todas las celdas de un determinado intervalo de columnas.
La única diferencia es que las columnas son letras, así que la primera columna vale A, la
segunda valeB, a terceiraCe por assim vai.. .
Caso queira pegar todas as células das colunas de A até C, podemos usar:

intervalo_colunas = planilha[ ‘A’ : ‘C’ ]

intervalo_colunas=planilha['A':'C']
imprimir(intervalo_colunas)

[Salida]:((<Celda'formula'.A1>, <Celda'formula'.A2>, <Celda␣

,→'fórmula'.A3>, <Celda

'fórmula'.A4>), (<Celda'fórmula'.B1>, <Celda'fórmula'.B2>, <Celda␣

,→'fórmula'.B3>

<Celda'fórmula'.B4>), (<Celda'fórmula'.C1>, <Celda'fórmula'.C2>, ␣

,→<Celda

'fórmula'.C3>, <Celda'fórmula'.C4>

También podemos usar el método iter_cols() para iterar las columnas, así
como oiter_rows() para las líneas (igual que hicimos anteriormente), incluyendo teniendo
los mismos parámetros:
Veunejemplo:
forcolunainplanilha.iter_cols(min_row=1, min_col=1, max_row=4,
,→max_col=3):

imprimir("Columna: ", columna)

Columna: (<Celda 'Planilha Criada'.A1>, <Celda 'Planilha

,→Criada'.A2>, <Celda

'Planilla Creada'.A3>, <Celda 'Planilla Creada'.A4>)

Columna: (<Celda 'Planilha Criada'.B1>, <Celda 'Planilha Criada'.B2>,
,→<Celda>

'Planilha Criada'.B3>, <Cell'Planilha Criada'.B4>)

Columna: (<Celda 'Planilha Criada'.C1>, <Celda 'Planilha Criada'.C2>,
,→<Celda

'Planilla Creada'.C3>, <Celda'Planilla Creada'.C4>)

7.3.4 Todas las células de una fila

Ya para obtener todas las celdas de una sola fila, podemos tomar como clave de
investiga justamente aquella línea que queremos, como por ejemplo:
intervalo_celulas_coluna=planilha['2']
imprimir(intervalo_celulas_coluna)

[Output]:(<Cell'Planilha Criada'.A2>, <Cell'Planilha Criada'.B2>,␣

,→<Celda'Planilla

Criada'.C2>)

7.3.5 Todas las celdas de una columna

De la misma manera, podemos tomar todas las celdas de una sola columna, también pas-
sando só achave de pesquisadessa coluna, como por exemplo:
intervalo_celulas_coluna=planilha['A']
imprimir(intervalo_celulas_coluna)

[Output]:(<Cell'Planilha Criada'.A1>, <Cell'Planilha Criada'.A2>,␣

,→Celda 'Planilha

Criada'.A3>, <Celda'Planilha Criada'.A4>)

7.3.6 Todas las líneas de una hoja de cálculo

Ahora, si queremos una lista de todas las líneas de una hoja de cálculo, podemos usar
[Link], criando uma lista (ou tupla, caso queira) a partir deste
generador, mira un ejemplo:
intervalo_todas_linhas=list([Link])
imprimir(intervalo_todas_linhas)

[Salida]:[(<Celda 'Planilha Criada'.A1>, <Celda 'Planilha Criada'.

,→B1>, <Celda 'Planilla

Criada'.C1>), (<Celda'Planilla Criada'.A2>, <Celda'Planilla Criada'.

,→B2>, <Celda
'Hoja Creada'.C2>), (<Celda'Hoja Creada'.A3>, <Celda␣
,→Planilla

Criada'.B3>, <Cell'Planilha Criada'.C3>), (<Cell'Planilha Criada'.

,→A4>, <Celda
'Planilha Criada'.B4>, <Celda'Planilha Criada'.C4>)]
7.3.7 Todas las columnas de una hoja de cálculo

Ahora, si queremos una lista de todas las columnas de una hoja de cálculo, podemos usar el
[Link], creando una lista (o tuple, si lo prefieres) a partir de esto
generador, mira un ejemplo:
intervalo_todas_colunas=list([Link])
imprimir(intervalo_todas_colunas)

Planilha Criada
,→A2>, <Celda'Planilla

Criada'.A3>, <Celda 'Planilha Criada'.A4>), (<Celda 'Planilha Criada'.

,→B1>, <Celda

'Hoja creada'.B2>, <Celda'Hoja creada'.B3>, <Celda'Hoja

Criada'.B4>), (<Cell'Planilha Criada'.C1>, <Cell'Planilha Criada'.
,→C2>, <Celda

'Planilha Criada'.C3>, <Celda'Planilha Criada'.C4>)]

7.3.8 Todos los valores de una hoja de cálculo

También podemos recoger todos los valores de una hoja de cálculo, es decir, no recogemos
de hecho la celda, sino el valor de ella.
Para eso, podemos usar la propiedad values de la hoja de cálculo.
Recordando que si alguna posición aún no tiene un valor asignado, el
seu valor seráNone.
[Link]:
forvalorinlinha:
imprimir(valor)

1
Ninguno
C1
A2
2
Ninguno
Tres
B
C3
Ninguno
None
:)
7.3.9 De forma tabelada
Aprovechando la propiedad values de la hoja de cálculo para obtener los valores de todas las
células, podemos notar que al imprimir los valores tenemos algo muy extraño y
feo, siendo difícil de entender.
Sin embargo... Hay una manera fácil de sortear este problema, podemos establecerlo
salida a través de la formateación de la cadena.
Usando el método format de la clase string, podemos usar '{:<25}' para alinear
has a o dado a esquerda usando um tamanho fijo de 25 caracteres.
[Link]:
forvalorinlinha:
si valor==None: valor='None'
print('{:<25}'.format(valor),end=' ')
print()

[Output]:
1 None C1
A2 2 Ninguno
Três B C3
Ninguno Ninguno :)

7.4 ‘Condição’ de existencia de una célula

Cuando creamos una nueva hoja de cálculo, viene vacía, es decir, no existe ninguna
célula nela.
Las células comienzan a existir tan pronto como son accedidas, llega para recu-
valor perarum o valor paraatribuirum.
Es decir... Si accedemos a la celda B3, la hoja se 'creará' hasta allí, entonces
comenzará a tener las células:

A1, A2, A3, B1, B2 y B3.

Ahora, si accedemos a la celda C4, notaremos que la fila 4 no existe, así como
la columna 3, de esta manera necesitamos crearlas. Así que pasaremos a tener:

A1, A2, A3, A4, B1, B2, B3, B4, C1, C2, C3 y C4

Por lo tanto, es necesario tener un cuidado extra a la hora de acceder a celdas sin pre-
Cisar, pues si accedemos a la celda J10, necesitaremos almacenar en nuestra memoria.
10 filas y 10 columnas, es decir, 100 celdas serán almacenadas en nuestra memoria.
 nova_pasta=Workbook()
nova_planilha=nova_pasta.active
Imprimir(f"Líneas: {len(list(nova_planilha.rows))} x Colunas:
,→{len(list(nova_planilha.columns))}

celula=nova_planilha['B3']
Imprimir(f"Líneas: {len(list(nova_planilha.rows))} x Colunas:␣
,→{len(list(nueva_hoja.columns))}

nova_planilha['C4']='A'
print(f"Filas: {len(list(nueva_hoja.filas))} x Columnas:␣ ")
,→{len(lista(nueva_hoja.columnas))})

[Output]:
Líneas: 0 x Columnas: 0
Filas: 3 x Columnas: 2
Linhas: 4 x Colunas: 3

7.5 Mesclar e separar células

7.5.1 Mezclar
Podemos también fusionar y separar celdas, lo que resulta útil para agrupar
mento de dados ou criação de títulos com fontes de grande tamanho.
Para esto podemos usar el método merge_cells() y pasar como parámetro una
stringcontendo el intervalo (trozo) a fusionar.
Por ejemplo:

planilha.unir_células('A2:D2')

Para fusionar las celdas entre A2 y D2.

PS: Necesitamos notar que ahora no es de hecho una porción pasada por parámetro
(formato ['A2':'D2']), pero sí, una cadena representando esa porción (formato
‘A2:D2’.
planilha.unir_células('A2:D2')

7.5.2 Separar (desfazer mesclagem)

Para deshacer esta mezcla, podemos usar el método unmerge_cells(), que puede
ser utilizado de la misma manera que el método merge_cells(), siendo los mismos
parámetros y formato, la única diferencia es que ahora estamos separando los
células previamente mezcladas.
planilha.descombinar_células('A2:D2')
7.6 Modificando el tipo del valor numérico
También podemos modificar el tipo de valor numérico, es decir, la forma de formatear.
ese dado.
De esta manera, podemos hacer que una celda sea unadata(formato
aaaa-mm-dd h:mm:ss), o que noExcelnos mostrará 2019-09-03 para el día 3 de
septiembre de 2019.
Además, podemos crear formatos personalizados, como por ejemplo, ‘#
##0.000'o que hará el número '1234.5' ser mostrado como '1 2345.500'.
Por defecto, todos los números se inician en el formato 'General'.
importardatetime
planilha['A4']=[Link](2019,9,3)
print(planilha['A4'].formato_numerico)

planilha['A5']= 2.05
imprimir(planilha['A5'].formato_numerico)

planilha['A7']= 1245.25
planilha['A7'].formato_número='# ##0.000'1 234.500
imprimir(planilha['A7'].formato_número)

aaaa-mm-dd h:mm:ss
General
# ##0.000

7.7 Insertando Imágenes

Además de datos textuales y numéricos (que queramos o no son caracteres, igual
a los textos) también podemos tener imágenes insertadas en nuestras hojas de cálculo.
En primer lugar, necesitamos importar la clase que controlará esta imagen
para usarmos, para isso, podemos importar Imagen de [Link]:

from*[Link]**importarImagen

from [Link] import Image

Pronto, ahora podemos usar las imágenes, para eso, primero vamos a instanciar
un objeto del tipo Imagen, pasando como parámetro la ruta a una imagen
y luego usar el método add_image(), pasando como parámetro (respectivo-
mente) la imagen y la clave (posición Columna y Fila) de la celda para insertar,
como por ejemplo:
imagem=Image('c:\\[Link]')
planilha.agregar_imagen(imagen,'D5')
7.8 Creando un gráfico
¿Una hoja de cálculo matemática sin gráficos? ¡Entonces no es una hoja de cálculo matemática!
Sabiendo esto, OpenPyXL obviamente nos trae la posibilidad de crear grá-
fiscos e inserí-los nas nossas planilhas.
Entre los principales tipos de gráficos tenemos:

1. Bar => Barras;

2. Column => Colunas;

3. Line => Linhas;

4. Pie => Pizza (setores);

5. Surface => Superfície.

Si desea ver todos los demás tipos, puede consultar la documentación:

[Link]
Para crear los gráficos primero importa:

1. El tipo de gráfico que queremos => en este ejemplo queremos un gráfico de

barras, por lo tanto, importaremosBarChart;

2. Referencias => Que servirá para definir el intervalo que tomaremos para
creamos nuestra serie, importaremosReferencias;

3. Series => Ahora sí, nuestra serie de hecho, la que se insertará en el gráfico,
importaremosSeries.

Importaremos todo esto de [Link], siendo así:

de [Link] importar BarChart, Reference, Series
Para este ejemplo, crearemos una nueva hoja de cálculo y la poblaremos (insertar datos)
nela):
planilha=pasta.create_sheet('Gráficos')

#Popular 10 linhas da planilha com 1 valor em cada uma (crescente).

,→

foriinrango(10):
[Link]([i])
 Ahora, para crear el gráfico haremos los procedimientos a seguir:

1. Crear el gráfico:
1.1 Para esto usaremos el constructor de BarChart, por ser nuestra elección de
gráfico.
2. Crear la serie (datos a insertar):
2.1 Para eso, tomaremos esta serie a partir de una referencia que tiene los
parâmetros:
2.1.1 hoja de trabajo: la planilla de donde tomaremos la referencia;
2.1.2 min_col: coluna inicial (mínima); 2.1.3 max_col: coluna máxima (final);
2.1.4 min_row: linha inicial (mínima); 2.1.5 max_row: linha final (máxima);
3. Añadir la serie a nuestro gráfico:
3.1 A través del método add_data() de nuestro gráfico, pasando nuestra serie por
parámetro.
4. Añadir el gráfico en la hoja de cálculo:
4.1 A través del método add_char() pasando por parámetro (respectiva-
mente) o gráfico a ser inserido e a chave da célula (coluna e linha).

Veamoselejemplo:
grafico=BarChart()

serie=Reference(planilha, min_col=1, min_row=1, max_col=1, ␣

,→max_row=10)

grafico.agregar_datos(serie)

planilla.agregar_grafico(grafico,'E15')
Podemos también tener gráficos más completos, con títulos y ejes nombrados.
De inicio, crearemos otra hoja de cálculo. Observa que esta vez los datos tienen
una primera línea que será utilizada como título para estos datos y las demás
líneas con valores numéricos:
planilha=pasta.create_sheet('Gráfico completo')

Creamos los datos para el gráfico

dados=[
('Número original','Quadrado','Cubo'),
(1,1,1)
(2,4,8)
(3,9,27)
(4,16,64)
(5,25,125)
]

# Inserimos os dados de cada linha no gráfico

forlinhaindados:
[Link](linha)
 Ahora editaremos mejor el gráfico cambiando:

1. El título (propiedadetitle);
2. El título de su eje_x (propiedadex_axis.title);
3. El título de su eje_y (propiedad eje_y.titulo).

Creamos un gráfico de barras y configuramos su nombre y título de␣

,→ejes (X e Y)

grafico=BarChart()
[Link]="Numero ao Quadrado e Cubo"
grafico.y_axis.title='Valor resultado'
grafico.x_axis.title='Numero original'
Ahora configuraremos la serie, configurando las referencias y las categorías
Referencias: Establecemos las referencias (posiciones en la hoja de cálculo de los valores para el
gráfico e categorías):

1. En este caso, los valores son los cuadrados (1,4,9,16 y 25) y cubos (1,8,27,64,125);

2. Las categorías son los números 'bases' de los cuales estos valores son el
quadrado/cubo (1,2,3,4,5).
3. Los valores son los mostrados en las barras del gráfico (eje Y);
1.1 Entonces comenzamos a partir de la segunda columna (eliminar las categorías).

4. Las categorías son las que se muestran en la parte inferior del gráfico (eje X);
2.2 Então pegamos só da primeira coluna, que é onde estão as categorias.

valores=Reference(planilha, min_col=2, min_row=1, max_row=6, ␣

,→max_col=3)# Colunas 2 e 3, da linha 1 até 6

categorias=Reference(planilha, min_col=1, min_row=2, max_row=6, ␣

,→max_col=1)Apenas columna 1, de la línea 1 hasta 6

Por fin, iremos a configurar los ados en el gráfico, configurando los valores, los títulos.
los e as categorías.
Analizando los datos tenemos que:

1. Tenemos los números base (los cuales vamos a elevar al cuadrado y al cubo)
=> categoria (ficará na parte de baixo);

2. Los números cuadrados => Un tipo de valor a ser analizado;

3. Os números ao cubo => Outro tipo de valor a ser analisado.

Es decir:
Tanto los números cuadrados como los cúbicos son los valores y el primero
cada uno tiene un título, así que usaremos esas líneas como tí-
tulo, a través del parámetro titles_from_data siendo establecido como Trueno médoto
agregar_datos().
 Por fin, para las categorías tenemos el métodoset_categoriesen nuestro gráfico,
donde enviamos las categorías como parámetro.
grafico.agregar_datos(valores, titulos_desde_datos=True)
grafico.set_categories(categorias)
Por fin, para ya probar todo lo que hemos insertado, vamos a guardar el archivo:
[Link]('[Link]')

7.9 Usando fórmulas

También podemos usar las fórmulas disponibles en Excel, como la de suma, por
ejemplo.
Desafortunadamente, tenemos una limitación en OpenPyXL donde solo acepta fórmulas.
mules in English.
De esta manera, la suma que es '=SOMA(1,5)' se convierte en '=SUM(1,5'.
Para inserir uma fórmula uma célula, basta alterar o seu valor para ser uma
cadena que contiene tal fórmula, como por ejemplo:
planilla=pasta.create_sheet('formula')
planilha['C3']="=SUM(1,5)"

8 Trabajando con estilos

Completando nuestro aprendizaje, vamos a aprender cómo estilizar celdas, mu-
dando su llenado, borde, alineación, fuente y colores.
Para eso importaremos las siguientes clases:

1. PatternFill;

2. Frontera;

3. Lado;

4. Alineación;

5. Protección;

6. Font;

7. Color.

Todo esto en el namespace [Link], de la siguiente forma:

from [Link] import PatternFill, Border, Side, Alignment,
,→Protection, Font, Color
8.1 Propiedades two styles
Todos los estilos deben ser creados, no es posible editar uno ya existente.
De esta forma, necesitamos, por ejemplo, crear una nueva fuente para asignarla
como la fuente actual de una hoja de cálculo específica.
Todas las clases mencionadas arriba tienen un constructor propio donde
se pueden pasar todas sus propiedades.

8.1.1 Fuente
Para customizarmos uma fonte temos as seguintes propriedades:

1. name => Nome da fonte;

2. size =>Tamanho da fonte;

3. bold => Se há ou não negrito;

4. itali => Se há ou não itálico;

5. vertAlign => Alinhamento vertical;

6. subrayar => Si hay un trazado debajo de la celda (subrayar);

7. strike => Se há um traçado no meio da célula;

8. color => Cor da fonte (hexadecimal).

Por defecto, las fuentes tienen la siguiente configuración, donde solo necesitas
enviar por parámetro las configuraciones que quiera editar:
fuente=Fuente(nombre='Calibri',
size=11,
bold=False,
cursiva=False
vertAlign=None,
underline='none',
strike=False,
color='FF000000')
8.1.2 Relleno por defecto
Para personalizar un relleno tenemos las siguientes propiedades:

1. fill_type => tipo do preenchimento => ex: ‘solid’;

2. fgColor => cor do foreground (plano da frente);

3. bgColor => cor do background (plano de fundo).

Por defecto, los rellenos tienen la siguiente configuración, donde solo tu

es necesario enviar por parámetro las configuraciones que desea editar:
llenar=PatternFill(fill_type=None,
fgColor='FFFFFFFF',
bgColor='FF000000')

8.1.3 Borda
Ya para personalizar el borde es un poco diferente...
Primero deberemos decidir qué parte del borde vamos a editar, que son:

1. left => Esquerda;

2. right => Direita;

3. top => Cima;

4. bottom => Baixo;

5. diagonal => Diagonal;

6. outline => Contorno;

7. vertical =>Vertical;

8. horizontal => Horizontal;

9. diagonal_direction => Direção da Diagonal.

Con excepción de la 'diagonal_direction' que es un entero que define la dirección de

diagonal, tenemos que pasar un objeto del tipo Side, que a su vez tiene:

1. border_style => Estilo da borda;

2. color => Cor (em Hexadecimal).

 Por defecto, los bordes tienen la siguiente configuración, donde solo necesitas
enviar por parâmetro as configurações que queira editar:
borde=Borde(izquierda=Lado(estilo_de_borde=Ninguno,
color='FF000000'),
derecha=lado(estilo_borde=None,
color='FF000000'),
arriba=Costado(border_style=None,
color='FF000000'),
bottom=Side(border_style=None,
color='FF000000'),
diagonal=Side(border_style=None,
color='FF000000')
diagonal_direction=0,
outline=Side(border_style=None,
color='FF000000'),
vertical=Side(border_style=None,
color='FF000000'),
horizontal=Side(border_style=None,
color='FF000000')
)

8.1.4 Alineamiento
Para personalizar un relleno tenemos las siguientes propiedades:

1. horizontal => tipo do preenchimento => ex: ‘solid’;

2. vertical => color del primer plano;

3. text_rotation => cor do background (plano de fundo);

4. wrap_text => quebrar linha automaticamente (não ultrapassar limite hori-

zontal);

5. shrink_to_fit => enconlher a fonte para caber na célula;

6. indent => identar a célula.

Por defecto, los rellenos tienen la siguiente configuración, donde solo usted
es necesario enviar por parámetro las configuraciones que desea editar:
alignment=Alignment(horizontal='general',
vertical='bottom',
text_rotation=0,
wrap_text=False,
shrink_to_fit=False,
indent=0)
8.1.5 Formato Numérico
Este ya es conocido aquí del curso, usamos solo la propiedad number_format
para definirnos el tipo de formateo para aquel número.
Así como ya vimos, el patrón es 'General'.
number_format='General'

8.1.6 Protección
Para personalizar la 'protección' tenemos las siguientes propiedades:

1. locked => se a célula é bloqueada à edição;

2. hidden => se a célula é oculta.

Por defecto, las protecciones tienen la siguiente configuración, donde solo usted pre-
cisa enviar por parámetro las configuraciones que quiera editar:
protection=Protection(locked=True,
oculto=False)

8.2 Estilizando células

Antes de estilizar las celdas, primero necesitamos tener una variable/objeto
de esa célula. Para eso, ya sabemos cómo hacerlo, es solo asignar el valor
de una celda para una variable determinada (obtener una hoja de cálculo).
Ahora podemos acceder a las propiedades de estilo (como el tipo de letra) y alterarlas
atribuyendo el valor de alguna personalización nuestra, ex:

fonte = Font(color=‘FFBB00’)
preenchimento = PatternFill(fill_type=‘solid’, fgColor=‘FFFF00FF’)

De esta forma, creamos una nueva fuente y un nuevo relleno.

Ahora vamos a establecer estas personalizaciones:

celula_a1.fill = preenchimento
celula_a1.font = fonte
celula_a1=planilha['A1']
celula_b3=planilha['B3']
celula_c4=planilha['C4']

fonte=Font(color='FFBB00')
preenchimento=PatternFill(fill_type='solid', fgColor='FFFF00FF')

celula_a1.fill=preenchimento
celula_a1.font=fonte
celula_b3.font=fonte
celula_c4.font=Font(color='FFBBFF', italic=True)

celula_a1.value="Testando"
celula_b3.value="nossos"
celula_c4.value="estilos"

8.3 Copiando estilos

Crear estilos es aburrido, lo sabemos... Aún más cuando el cambio es mínimo.
Por suerte, tenemos la posibilidad de copiar un estilo a partir de otro.
Para eso, primero necesitamos importar el método copy() del espacio de nombres de
mismo nombre (copia)
fromcopyimportcopy
Ahora solo necesitamos llamar al método copy() y enviar como parámetro el estilo que
queremos copiar. Tal método tendrá como retorno un estilo del mismo tipo que fue
pasado como parámetro, ej:
Si pasamos una fuente como parámetro, tendremos una fuente como retorno:

fonte2 = copy(fonte1)

fonte1=Font(name='Verdana',size=16,color='FFBB00')
fonte2=copy(fonte1)
[Link]=True

print('\n Fuente:\'\n',fonte2)
print('\n Fonte2:')\n',fonte2
[Output]: Fonte1:

<[Link] objeto>
Parámetros:
nombre='Verdana', conjunto_de_caracteres=None, familia=None, negrita=False, cursiva=False,
,→strike=None,

outline=None, shadow=None, condense=None, color=<[Link].

,→[Link]

objeto
Parámetros:
rgb='00FFBB00', indexed=None, auto=None, theme=None, tint=0.0,␣
,→tipo='rgb',

extend=None, sz=16.0, u=None, vertAlign=None, scheme=None

Fonte2:

<[Link] objeto>
Parámetros:
name='Verdana', charset=None, family=None, b=True, i=False,␣
,→strike=None,

outline=None, shadow=None, condense=None, color=<[Link].

,→[Link]

objeto
Parámetros:
rgb='00FFBB00', indexed=None, auto=None, theme=None, tint=0.0,␣
,→tipo='rgb'

extend=None, sz=16.0, u=None, vertAlign=None, scheme=None

8.4 Estilizando Intervalos

8.4.1 Estilizando determinadas columnas
También podemos estilizar directamente un cierto rango de columnas, como por
ejemplo, todas las celdas de la columna A.
Para esto, solo hay que llamar a la propiedad column_dimensions y pasar como
clave o valor de la columna (letra), como por ejemplo:

columna_a = planilha.column_dimensions[‘A’]

Agora vamos atribuir uma font para toda essa coluna:

coluna_a.font = Font(negrita=True)

coluna_a=planilha.column_dimensions['A']
coluna_a.font=Font(bold=True)
8.4.2 Estilizando determinadas líneas
También podemos estilizar directamente un cierto rango de líneas, como por
ejemplo, todas las celdas de la fila1.
Para eso solo hay que llamar a la propiedad row_dimensions y pasar como clave el
valor de la línea (número), como por ejemplo:

linha_1 = planilha.row_dimensions[‘1’]

Ahora vamos a asignar una fuente a toda esta columna:

linha_1.font = Font(bold=True)

linha_1=planilha.row_dimensions[1]
linha_1.font=Font(underline="single")

9 Configurações de impressão
Por fim, vamos aprender a configurar a impressão da nossa planilha.
Aunque no es muy habitual imprimir hojas de cálculo, a veces lo necesitaremos... Eim-
imprimir 150 líneas y 200 columnas para mostrar solo 5 celdas además de exagero
tornemos a la visualización horrible, ¿entonces vamos a aprender a configurar impresiones?

9.1 Opções de alinhamento

La primera configuración que veremos son las opciones de alineación, que tenemos
duas

1. print_options.horizontalCentered => Se a impressão será centralizada

horizontalmente na folha;

Se la impresión será centralizada verticalmente

mente en la hoja;

planilha.print_options.horizontalCentered=True
planilha.print_options.verticalCentered=True
9.2 Encabezados y Pies de Página

Agora temos os rodapés e capeçalhos para definir.

Primero vamos a definir los tipos de encabezados y pies de página:

1. Cabeçalhos:
• oddHeader => Cabeçalho de páginas ímpares;

• evenHeader => Cabeçalho de páginas pares;

• firstHeader => Cabeçalho da primeira página.

2. Rodapés:
• oddFooter => Rodapé de páginas ímpares;

• evenFooter => Rodapé de páginas pares;

• firstFooter => Rodapé da primeira página.

Ahora vamos a ver las posiciones que tenemos:

1. left => Esquerda;

2. right => Direita;

3. center => Central.

¡Pronto! Pero... ¿cuál es el motivo de aprender esto?

Bueno... para editar los encabezados y pies de página necesitamos la combinación de
ambos, siendo primero el tipo a ser editado y el segundo la posición.
Supongamos que queremos los encabezados de las páginas pares en la posición es-
izquierda, entonces tendremos la propiedad [Link] de nuestra hoja de cálculo.
Agora, nós podemos editar as propriedades deste cabeçalho, sendo eles:

texto

2. size => tamanho da fonte;

3. font => nome da fonte;

4. color => cor da fonte.

[Link]="Isso é uma página par"

[Link]= 14
[Link]="Tahoma,Bold"
[Link]="FFE9FF"
9.3 Área de Impresión
Por fin, tenemos el área de impresión, que nos informa cuáles serán las celdas que irán
aparecer en la impresión.
Todas las celdas fuera de este intervalo no aparecerán a la hora de imprimir.
Para esto editaremos la propiedad print_area de nuestra hoja de cálculo, donde iremos
atribuir una cadena especificando la 'porción' de la hoja de cálculo a cortar como, por ejem-
plo,‘A1:F10’para el intervalo entre A1 y F10.
Veaelejemploacontinuación:
planilha.print_area='A1:F10'
10 Desafío - Hoja de Cálculo Completa desde Cero

¡Finalmente!
¡Después de mucho esfuerzo y dedicación, hemos llegado al final del libro!
Ahora, ¿qué tal si creamos una hoja de cálculo utilizando buena parte de lo que hemos aprendido?
En el código a continuación vamos a crear una nueva carpeta (workbook), crear algunos
hojas de cálculo, editar los colores de las pestañas de la hoja de cálculo, insertar valores en las celdas, insertar
imágenes, trabajar con gráficos y guardar nuestro archivo.
¿Vamos allí?
# Hacemos las importaciones necesarias
from [Link] import Workbook
[Link]
from [Link] import BarChart, Reference, Series

Creamos un nuevo Libro de Trabajo

pasta=Workbook()

# Renomeamos a planilha inicial e mudamos suas cores

planilla_numeros=[Link][0]
planilha_numeros.title='Numeros'
planilha_numeros.sheet_properties.tabColor='8334EB'

Crearemos otras hojas de cálculo y también cambiaremos sus colores

planilha_bylearn=pasta.create_sheet('ByLearn')
planilha_bylearn.sheet_properties.tabColor='34EBB7'

planilha_imagem=pasta.create_sheet('Imagem')
planilha_imagem.sheet_properties.tabColor='80BF82'

planilha_grafico=pasta.create_sheet('Graficos')
planilha_grafico.sheet_properties.tabColor='CF9A4C'

Insertando valores comenzando por uno y aumentando en dos cada uno␣

,→célula

# 10 números por líneas, Durante 5 líneas

i= 0
forlinhainrange(5):
forcolunainrange(10):
Para cada célula en las 10 columnas y 5 filas que queremos,␣
,→vamos setar um valor crescente

celula=planilha_numeros.cell(row=linha+1, ␣
,→columna=coluna+1, valor=i)

i += 2;

# Creamos los encabezados

planilha_bylearn['A1']='Rede Social'
planilha_bylearn['B1']='Link'

# Las listas (todas válidas, pueden seguirnos allí :D)

[["Facebook","@ByLearn"]]
["Insta","@ByLearn"]
["Youtube","@ByLearn"]
["Blog","[Link]"]

Agregamos una sublista a la vez, una para cada línea

forlinhainlista:
planilha_bylearn.append(linha)

Cargamos una imagen del disco e insertamos en la posición A1

imagem=Image('c://[Link]')
planilha_imagem.agregar_imagen(imagen,'A1')

Creamos los datos para el gráfico

dados=[
('Prova','Competidor1','Competidor2'),
Fútbol
('Basquete',40,60),
('Vôlei',50,70),
('Baseball',20,10),
Corrida
('Balonmano',50,30)
]

# Inserimos os dados de cada linha no gráfico

forlinhaindados:
planilha_grafico.append(linha)

Creamos un gráfico de barras y establecemos su nombre y título de␣

,→ejes (X e Y)

grafico=BarChart()
[Link]="Competição Esportiva"
grafico.y_axis.title='Pontuação'
grafico.x_axis.title='Prova'

Establecemos las referencias (posiciones en la hoja de cálculo de los valores para el␣
,→gráfico de categorías

valores=Reference(planilha_grafico, min_col=2, min_row=1, ␣

,→max_row=7, max_col=3)

categoria_jogos=Reference(planilha_grafico, min_col=1, ␣
,→min_row=2, max_row=7, max_col=1)
 Configuramos los valores del gráfico y que debe tomar los␣
,→títulos a través de esos valores (primera posición de cada uno)

grafico.agregar_datos(valores, titulos_de_datos=True)

# Establecemos las categorías

grafico.set_categories(jogos)

Ahora es solo agregar en la hoja de cálculo

planilha_grafico.agregar_grafico(grafico, "A10")

Por fin, guardamos el archivo

[Link]('arquivo_final.xlsx')

11 Documentação Oficial
El aprendizaje nunca debe terminar y una gran fuente de estudio a partir de
ahora será la documentación oficial.
Con toda la enseñanza que has aprendido hasta ahora en el curso, entenderás fácilmente
mente tudo o que estiver lá na documentação.
Link: [Link]
12 Extra: Contenidos diarios gratuitos
Por fin, antes de terminar nuestro libro, necesitamos hablarte sobre los contenidos
diarios que creamos para ti, unByLearner!
Temos vídeos, blogs, explicações de códigos, curiosidades, lives, minicursos,
encuestas y mucho más... Incluyendo nuestrosDrops.
Caso você ainda não saiba o que é um Drops da ByLearn, é simples:
A través de nuestra didáctica rápida y directa, preparamos un contenido bien
legal de una forma muy interesante para que lo veas en tu tiempo libre.
- Sabes cuando estás en face/insta y aparece un video chido de 1 minutito en tu
¿alimentar? ¿O cuando aparece una imagen muy llamativa y creativa?
- Entonces... Ahora imagina si este video tan genial fuera educativo, o si este
una imagen creativa te enseñaría a programar. . . - Eso es exactamente lo que es unDrops.
Nuestro enfoque es conseguir el interés del alumno y proporcionar un conocimiento
nuevo en cualquier momento del día!

12.1 Para eso nos puedes encontrar en:

Facebook:@ByLearn
Instagram:@ByLearn
Youtube:@Bylearn
Twitter:@ByLearn
LinkedIn:@ByLearn
Github:@ByLearn
Bueno... ¿Entendiste, verdad? Es todo @ByLearn, búscalo allí [U+2764].

12.2 Para encontrar nossos cursos:

Accede a nuestro sitio en: [Link]

¡Muchas gracias por todo! Nos vemos en el próximo.

curso
Fue un placer enorme crear este libro para ustedes y enseñárselo durante todo este
curso.
Esperamos que haya disfrutado y que el contenido le haya sido útil.