DEV Community: Manuel Duarte 💛💙

Tuplas en Python (tuple)

Manuel Duarte 💛💙 — Sat, 12 Jun 2021 04:43:26 +0000

Las tuplas en Python son un tipo o estructura de datos que permite almacenar datos de una manera muy parecida a las listas, con la salvedad de que son inmutables.

Crear una tupla en Python

Las tuplas en Python o tuples son muy similares a las listas, pero con dos diferencias. Son inmutables, lo que significa que no pueden ser modificadas una vez declaradas, y en vez de inicializarse con corchetes se hace con (). Dependiendo de lo que queramos hacer, las tuplas pueden ser más rápidas.

  tupla = (1, 2, 3) 
  print(tupla) #(1, 2, 3)

También pueden declararse sin (), separando por , todos sus elementos.

  tupla = 1, 2, 3
  print(type(tupla)) #<class 'tuple'> 
  print(tupla) #(1, 2, 3)

Operaciones con tuplas

Como hemos comentado, las tuplas son tipos inmutables, lo que significa que una vez asignado su valor, no puede ser modificado. Si se intenta, tendremos un TypeError.

  tupla = (1, 2, 3) 
  #tupla[0] = 5 # Error! TypeError

Al igual que las listas, las tuplas también pueden ser anidadas.

   tupla = 1, 2, ('a', 'b'), 3 
   print(tupla) #(1, 2, ('a', 'b'), 3) 
   print(tupla[2][0]) #a

Y también es posible convertir una lista en tupla haciendo uso de al función tuple().

   lista = [1, 2, 3] 
   tupla = tuple(lista) 
   print(type(tupla)) #<class 'tuple'> 
   print(tupla) #(1, 2, 3)

Se puede iterar una tupla de la misma forma que se hacía con las listas.

  tupla = [1, 2, 3] 
  for t in tupla: 
      print(t) #1, 2, 3

Y se puede también asignar el valor de una tupla con n elementos a n variables.

   l = (1, 2, 3) 
   x, y, z = l 
   print(x, y, z) #1 2 3

Aunque tal vez no tenga mucho sentido a nivel práctico, es posible crear una tupla de un solo elemento. Para ello debes usar , antes del paréntesis, porque de lo contrario (2) sería interpretado como int.

  tupla = (2,) 
  print(type(tupla)) #<class 'tuple'>
  Métodos tuplas
  count(<obj>)

El método count() cuenta el número de veces que el objeto pasado como parámetro se ha encontrado en la lista.

  l = [1, 1, 1, 3, 5] 
  print(l.count(1)) #3
  index(<obj>[,index])

El método index() busca el objeto que se le pasa como parámetro y devuelve el índice en el que se ha encontrado.

  l = [7, 7, 7, 3, 5] 
  print(l.index(5)) #4

En el caso de no encontrarse, se devuelve un ValueError.

   l = [7, 7, 7, 3, 5] 
   #print(l.index(35)) #Error! ValueError

El método index() también acepta un segundo parámetro opcional, que indica a partir de que índice empezar a buscar el objeto.

   l = [7, 7, 7, 3, 5] 
   print(l.index(7, 2)) #2

Learn Go in 8 minutes

Manuel Duarte 💛💙 — Tue, 01 Jun 2021 20:36:31 +0000

Learning the basics of Go and how it works. I chose Go as a starting language here because of its ease of use and performance.

Why Go

Go is a language that was designed at 2009 at Google by Robert Griesemer, Rob Pike, and Ken Thompson. It was created in order to address performance issues of other languages and to take advantage of the multi-core CPUs by providing concurrency out-of-the-box.

It is used to code backend components that are small, efficient with concurrency in mind. Almost all components in the Cloud-native ecosystem are written in Go (Docker, Kubernetes, Istio, Helm, Prometheus, etcd, Knative to name a few) which makes it a perfect fit for integrating with those components.

Code Style Formatting

Go language has built-in code style formatting.

VSCode has built-in integration of Go which supports formatting on-save.

Quick Language Overview

For quick language overview check this Go Programming Language Tutorial 6h video that explains all basic concepts of Go.

Below are some of those concepts:

Hello World

package main

import "fmt"

func main() {
    fmt.Println("Hello World!")
}

Type go run hello.go to execute.

Variables & Constants

package main

import "fmt"

func main() {
    // A constant is a variable with a value that can't be changed
    const pi float64 = 3.14159265359
    // You can declare multiple variables like this
    var (
        varA = 2
        varB = 3
    )
    fmt.Println(varA, varB)

    // Strings are a series of characters between " or `
    var Name string = "John Wick"

    // Get string length
    fmt.Println(len(Name))
}

Data Types

Numeric
int (uint8, uint16, uint32, uint64, int8, int16, int32, int64)
float
String
Boolean
true
false
Derived
Pointer
Array
Structure
Map
Interface

package main

import "fmt"

func main() {
    // Variable assignment with specific type
    var a int = 5
    var b float32 = 4.32
    const pi float64 = 3.1415139475

    // Variable assignment with auto type
    c := 1

    // Variable reassignment (should be same type as first assignment)
    c = 5

    // Multiple variables assignment
    var (
        d="hello"
        e="there"
    )
    f,g:=14,15

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(pi)
    fmt.Println(c)
    fmt.Println(d)
    fmt.Println(e)
    fmt.Println(f)
    fmt.Println(g)
}

Operators

Arithmetic
addition (+)
subtraction (-)
multiplication (*)
division (/)
modulus (%)
Relational
greater than (>)
lesser than (<)
greater than or equal (>=)
equivalence (==)
not equals (!=)
Logical
and (&&)
or (||)
negation (!)

package main

import "fmt"

func main() {
    // Arithmetic
    x,y:=5,6
    fmt.Println("x + y =", x + y)
    fmt.Println("x - y =", x - y)
    fmt.Println("x * y =", x * y)
    fmt.Println("x / y =", x / y)
    fmt.Println("x % y =", x % y)

    isBool := true
    hate := false

    fmt.Println(isBool && hate)
    fmt.Println(isBool || hate)
    fmt.Println(!isBool)
}

Pointers

package main

import "fmt"

func main() {
    x := 5

    fmt.Println(x)
    fmt.Println(&x)
}

Pass by value:

package main

import "fmt"

func main() {
    x := 10

    changeValue(x) // pass by value
    fmt.Println(x) // Prints 10
}

func changeValue(x int) {
    x=7
}

Pass by reference:

package main

import "fmt"

func main() {
    x := 10

    changeValue(&x) // pass by reference
    fmt.Println(x) // prints 7
}

func changeValue(x *int) {
    *x = 7
}

Printf

package main

import "fmt"

func main() {
    var name string = "John Wick"
    const pi float64 = 3.16412732
    x := 5
    isbool := true

    fmt.Printf("%f \n", pi)     // print float: 3.16412732
    fmt.Printf("%.3f \n", pi)   // print float: 3.164
    fmt.Printf("%T \n", name)   // print type: string
    fmt.Printf("%t \n", isbool) // print boolean: true
    fmt.Printf("%d \n", x)      // print int: 5
    fmt.Printf("%b \n", 25)     // print binary: 11001
    fmt.Printf("%c \n", 33)     // print character: !
    fmt.Printf("%x \n", 15)     // print hexcode: f
}

Loops

normal for loop:

package main

import "fmt"

func main() {
    for i := 1; i < 10; i++ {
        fmt.Println(i)
    }
}

while style loop:

package main

import "fmt"

func main() {
    i := 1
    for i < 10 {
        fmt.Println(i)
        i++
    }
}

nested loops:

package main

import "fmt"

func main() {
    for i := 1; i < 10; i++ {
        for j := 1; j < i; j++ {
            fmt.Printf("*")
        }
        fmt.Println()
    }
}

Decision Making

package main

import "fmt"

func main() {
    age := 18

    if age >= 18 {
        fmt.Println("you can van vote")
    } else {
        fmt.Println("you cannot vote")
    }
}

package main

import "fmt"

func main() {
    age := 18

    switch age {
    case 16:
        fmt.Println("Prepare for college")
    case 18:
        fmt.Println("Don't run after girls")
    case 20:
        fmt.Println("Get yourself a job!")
    default:
        fmt.Println("Are you even alive?")
    }
}

Arrays

package main

import "fmt"

func main() {
    var EvenNum [5]int
    EvenNum[0] = 0
    EvenNum[1] = 2
    EvenNum[2] = 4
    EvenNum[3] = 6
    EvenNum[4] = 8

    fmt.Println(EvenNum[2]) // prints: 4
}

package main

import "fmt"

func main() {
    EvenNum := [5]int{0, 2, 4, 6, 8}
    fmt.Println(EvenNum[2]) // prints: 4
}

package main

import "fmt"

func main() {
    EvenNum := [5]int{0, 2, 4, 6, 8}
    for _, value := range EvenNum {
        fmt.Println(value)
    }
}

slices:

package main

import "fmt"

func main() {
    EvenNum := [5]int{0, 2, 4, 6, 8}
    for i, value := range EvenNum {
        fmt.Println(value, i)
    }

    numSlice := []int{5, 4, 3, 2, 1}
    sliced := numSlice[3:5]
    fmt.Println(sliced)        // prints: [2, 1]
    fmt.Println(numSlice[3:])  // prints: [2, 1]
    fmt.Println(numSlice[:])   // prints: [5, 4, 3, 2, 1]
    fmt.Println(numSlice[0:1]) // prints: [5]

    slice2 := make([]int, 5, 10)
    copy(slice2, numSlice) // copies numSlice to slice2
    fmt.Println(slice2)    // prints [5, 4, 3, 2, 1]

    slice3 := append(numSlice, 3, 0, -1)
    fmt.Println(slice3) // prints [5, 4, 3, 2, 1, 3, 0, -1]
}

Maps

package main

import "fmt"

func main() {
    StudentAge := make(map[string]int)

    StudentAge["John"] = 23
    StudentAge["Bob"] = 27
    StudentAge["Anna"] = 21
    StudentAge["Alice"] = 19
    StudentAge["Carl"] = 42
    StudentAge["Maria"] = 22

    fmt.Println(StudentAge["maria"]) // not found (case-sensitive) returns: 0
    fmt.Println(StudentAge["Maria"]) // found returns: 22
    fmt.Println(len(StudentAge))     // returns 6 (number of elements)
}

map in a map:

package main

import "fmt"

func main() {
    superhero := map[string]map[string]string{
        "Superman": map[string]string{
            "RealName": "Clar Kent",
            "City":     "Metropolis",
        },
        "Batman": map[string]string{
            "RealName": "Bruce Wayne",
            "City":     "Gotham City",
        },
    }

    if temp, hero := superhero["Superman"]; hero {
        fmt.Println(temp["RealName"], temp["City"], hero)
    }
}

Functions

package main

import "fmt"

func main() {
    x, y := 5, 6
    fmt.Println(add(x, y)) // prints: 11
}

func add(num1, num2 int) int {
    return num1 + num2
}

recursion:

package main

import "fmt"

func main() {
    x := 5
    fmt.Println(factorial(x)) // ( factorial(5) = 5x4x3x2x1 ) prints: 120
}

func factorial(num int) int {
    if num == 0 {
        return 1
    }
    return num * factorial(num-1)
}

Defer, Recover, Panic

Control Structure:

Defer: Defer statement defers the execution of a function until the surrounding function returns. (e.g. cleanup resources)
Recover: Helps regain ther normal flow of execution after a panic.
Panic: Panic is similar to throwing exception like other language.

defer:

package main

import "fmt"

func main() {
    defer firstRun() // It will execute last, after secondRun() function
    secondRun()
}

func firstRun() {
    fmt.Println("I executed first")
}

func secondRun() {
    fmt.Println("I executed second")
}

panic & recover:

package main

import "fmt"

func main() {
    fmt.Println(div(3, 0))
    fmt.Println(div(5, 3))
    demPanic()
}

func div(num1, num2 int) int {
    defer func() {
        fmt.Println("div Recovered: ", recover())
    }()
    solution := num1 / num2 // (This will panic if num2 is 0)
    return solution
}

func demPanic() {
    defer func() {
        fmt.Println("demPanic Recovered:", recover())
    }()
    panic("Paniced")
}

Structures & Interfaces

structures:

package main

import "fmt"

func main() {
    rect1 := Rectangle{height: 10, width: 5}
    rect2 := Rectangle{10, 5}

    fmt.Println(rect1.height) // returns: 10
    fmt.Println(rect1.width)  // returns: 5
    fmt.Println(rect2)        // returns {10, 5}
    fmt.Println(rect1.area()) // returns: 50
}

// Rectangle a rectangle with dimensions
type Rectangle struct {
    height float64
    width  float64
}

func (rect *Rectangle) area() float64 {
    return rect.height * rect.width
}

interfaces:

package main

import (
    "fmt"
    "math"
)

func main() {
    rect1 := Rectangle{50, 60}
    circ := Circle{7}

    fmt.Println(getArea(rect1)) // returns: 3000
    fmt.Println(getArea(circ))  // returns: 52.1415926535898
}

// Shape interface of a shape
type Shape interface {
    area() float64
}

// Rectangle a rectangle with dimensions
type Rectangle struct {
    height float64
    width  float64
}

// Circle a circle
type Circle struct {
    radius float64
}

func (r Rectangle) area() float64 {
    return r.height * r.width
}

func (c Circle) area() float64 {
    return math.Pi + math.Pow(c.radius, 2)
}

func getArea(shape Shape) float64 {
    return shape.area()
}

File I/O

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

func main() {
    file, err := os.Create("sample.txt")
    if err != nil {
        log.Fatal(err)
    }

    file.WriteString("Hi my name is John Wick and this file was created using GO!!")
    file.Close()

    stream, err := ioutil.ReadFile("sample.txt")
    if err != nil {
        log.Fatal(err)
    }
    s1 := string(stream)
    fmt.Println(s1)
}

Webserver

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", handler)
    http.HandleFunc("/hello", handler2)
    http.ListenAndServe(":8080", nil)
}

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "welcome to my home page")
}

func handler2(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello world")
}

¿Como hacer un Deploy a Firebase Hosting?

Manuel Duarte 💛💙 — Thu, 13 May 2021 17:13:41 +0000

Ir a https://console.firebase.google.com e iniciar sesión, si no posees una cuenta, debes registrar un usuario con tu correo gmail.
Una vez accedas a Firebase console podrás observar las apps que tienes disponible, si deseas crear otra app, ve a la opción crear aplicacion. En nuestro caso usaremos “ThanosLanguages”
Ir a la terminal del sistema operativo e instalar las Firebase Tools con el siguiente comando: npm install -g firebase-tools, si en caso usas yarn, debes usar yarn add -g firebase-tools
Luego debes iniciar sesión desde tu terminal con el comando: firebase login, si en caso ya estás logeado, verás un mensaje similar a “you are logged as 'correo’”, caso contrario te abrirá el navegador, e inicias sesión con tu cuenta de Firebase. (si en caso estás logueado y deseas cerrar sesión usa: firebase logout).
Inicializar el proyecto en la ruta raíz con el comando: firebase init.
Se listara serie de opciones en nuestro caso usaremos la opción hosting (con arrow up/arrow down mover entre opciones y space key para seleccionar opción, luego enter).
Se listara los proyectos disponibles a tu usuario Firebase, en nuestro caso debemos seleccionar CocomioLanguages, y luego enter
Opciones:

What to you want to use as public directory: dist
configure as a single page app(y/N) y

Se creará la carpeta dist (puedes borrarla es opcional). .
Compilar la app desde la raíz del proyecto, usando uno de los siguientes comandos:

npm run build
yarn build

Se debe subir lo que esta en la carpeta build, por lo tanto debemos abrir el archivo “firebase.json” y dejar con una estructura como:

{“hosting”:{

   “public”: “build” /*solo cambiar dist por build */,

     …

  }

}

Ejecutar el comando: firebase deploy

Recibirás un mensaje de éxito, y podrás ver la Url e ir a la Url y listo

Instalación de Docker en Ubuntu

Manuel Duarte 💛💙 — Mon, 10 May 2021 20:46:48 +0000

¿Cuales son las alternativas?

Docker Desktop: Una herramienta que permite manejar Docker y los contenedores de manera fácil, solo funciona en Windows y Mac.
Docker Engine: Esta pensado para usarse en servidores Linux, sin embargo, se puede usar en un computador local. Solo para Linux.
Play with Docker: Plataforma web, permite correr Docker sin instalar nada, a través de una interfaz Web.

Instalación:

En Windows y Mac, esta docker Desktop, se descarga el instalador y siguen los pasos que da el mismo programa.
En Linux corresponde Docker Engine, a como es en este caso.

Instalación con Ubuntu:

Requerimientos: Tener una versión de Ubuntu entre la 16.04 y la 20.10. Otra dato muy importante, es que se necesita Ubuntu 64-bits.

Por ser un sistema operativo Linux, corresponde Docker Engine. En el caso que se tenga una versión vieja de Docker, se debe remover, eso se hace copiando el código de abajo en la terminal:sigue la instalación de Docker Engine para Ubuntu.

sudo apt-get remove docker docker-engine docker.io containerd runc

Ya hecho lo anterior (si no se tuvo que hacer lo anterior, se comienza desde acá), se actualizan los repositorios:

sudo apt-get update

Actualizado los repositorios, se instalan estas dependencias que necesita Docker para funcionar. Puede pedir contraseña del dispositivo para acceder como Super-usuario y cuando pida que se elija entre Y/N, escriban "Y", significa "Yes":

sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

A continuación, se descarga la llave GPG, esta llave su mayor utilidad es permitir bajar los repositorios y paquetes que se van a utilizar al instalar Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Una vez agregada la llave, es verificar que haya sido instalado de manera completa:

sudo apt-key fingerprint 0EBFCD88

Procedemos a la instalación del repositorio de Docker, en este caso el de Ubuntu, es solo copiar los comandos, a la hora de copiar los comandos automáticamente se actualizan los otros paquetes del sistema:

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

Instalando el Docker Engine como tal, aprovechando que se tienen todas las dependencias y repositorios listos, el primer comando para actualizar los paquetes y el segundo para instalar no solo Docker, también otras dependencias, son 85mb:

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io

El siguiente paso seria descargar una versión especifica de Docker, en el caso del curso, no es necesario. Sin embargo, si es necesario verificar que el Docker Engine esté instalado:

sudo docker run hello-world

Si en la salida se ve "Hello from Docker!", ¡Yeah!, la instalación de Docker en Ubuntu a sido terminada.

Diccionarios en Python

Manuel Duarte 💛💙 — Sun, 21 Mar 2021 07:36:21 +0000

- ¿Qué es un Diccionario de datos?

Un diccionario en Python es una colección de elementos, donde cada uno tiene una llave key y un valor value. Los diccionarios se pueden crear con paréntesis {} separando con una coma cada par key: value.

1 - Para definir un diccionario, se encierra el listado de valores entre llaves. Las parejas de clave y valor se separan con comas, y la clave y el valor se separan con dos puntos.

diccionario = {'nombre' : 'Manuel', 'edad' : 28, 'cursos': ['Python','Django','Kotlin'] }

2 - Podemos acceder al elemento de un Diccionario mediante la clave de este elemento, como veremos a continuación:

print diccionario['nombre'] #Carlos
print diccionario['edad']#22
print diccionario['cursos'] #['Python','Django','Kotlin']

3 - También es posible insertar una lista dentro de un diccionario. Para acceder a cada uno de los cursos usamos los índices:

print diccionario['cursos'][0]#Python
print diccionario['cursos'][1]#Django
print diccionario['cursos'][2]#Kotlin

4 - Para recorrer todo el Diccionario, podemos hacer uso de la estructura for:

for key in diccionario:
  print key, ":", diccionario[key]

Métodos que se pueden usar en los Diccionarios

dict ()

1 - Recibe como parámetro una representación de un diccionario y si es factible, devuelve un diccionario de datos.

dic =  dict(nombre='manuel', apellido='Duarte', edad=22)

dic → {‘nombre’ : 'manuel', ‘apellido’ : 'Duarte', ‘edad’ : 22}

zip()

2 - Recibe como parámetro dos elementos iterables, ya sea una cadena, una lista o una tupla. Ambos parámetros deben tener el mismo número de elementos. Se devolverá un diccionario relacionando el elemento i-esimo de cada uno de los iterables.

dic = dict(zip('abcd',[1,2,3,4]))

dic →   {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

items()

3 - Devuelve una lista de tuplas, cada tupla se compone de dos elementos: el primero será la clave y el segundo, su valor.

dic =   {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
items = dic.items()

items → [(‘a’,1),(‘b’,2),(‘c’,3),(‘d’,4)]

keys()

4 - Retorna una lista de elementos, los cuales serán las claves de nuestro diccionario.

dic =  {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
keys= dic.keys()

keys→ [‘a’,’b’,’c’,’d’]

values()

5 - Retorna una lista de elementos, que serán los valores de nuestro diccionario.

dic =  {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
values= dic.values()

values→ [1,2,3,4]

clear()

6 - Elimina todos los ítems del diccionario dejándolo vacío.

dic 1 =  {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
dic1.clean()

dic1 → { }

copy()

7 - Retorna una copia del diccionario original.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
dic1 = dic.copy()

dic1 → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

fromkeys()

8 - Recibe como parámetros un iterable y un valor, devolviendo un diccionario que contiene como claves los elementos del iterable con el mismo valor ingresado. Si el valor no es ingresado, devolverá none para todas las claves.

dic = dict.fromkeys(['a','b','c','d'],1)

dic →  {‘a’ : 1, ’b’ : 1, ‘c’ : 1 , ‘d’ : 1}

get()

9 - Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
valor = dic.get(‘b’) 

valor → 2

pop()

10 - Recibe como parámetro una clave, elimina esta y devuelve su valor. Si no lo encuentra, devuelve error.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
valor = dic.pop(‘b’) 

valor → 2
dic → {‘a’ : 1, ‘c’ : 3 , ‘d’ : 4}

setdefault()

11 - Funciona de dos formas. En la primera como get

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
valor = dic.setdefault(‘a’)

valor → 1

Y en la segunda forma, nos sirve para agregar un nuevo elemento a nuestro diccionario.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
valor = dic.setdefault(‘e’,5)

dic → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4 , ‘e’ : 5}

update()

12 - Recibe como parámetro otro diccionario. Si se tienen claves iguales, actualiza el valor de la clave repetida; si no hay claves iguales, este par clave-valor es agregado al diccionario.

dic 1 = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
dic 2 = {‘c’ : 6, ’b’ : 5, ‘e’ : 9 , ‘f’ : 10}
dic1.update(dic 2)

dic 1 → {‘a’ : 1, ’b’ : 5, ‘c’ : 6 , ‘d’ : 4 , ‘e’ : 9 , ‘f’ : 10}

Estos son algunos de los métodos más útiles y utilizados en los Diccionarios con python.