Python, te lo explico con peras y manzanas

Python, Te lo explico con Peras y Manzanas
# 1. LOS TIPOS DE DATOS
# ============================================================================ #
# str: string o cadenas de caracteres se encierran entre ' ' o " "
"Hola Covid-19"
'esta es un string'
""" También es posible usar 3 comillas dobles
o 3 comillas simples al principio y fin de la cadena
para hacerla multilineas """
"si ocupas usar 'comilla simple' dentro de la cadena"
'y si necesitas que tenga "comillas dobles" ..así '
# ============================================================================ #
# int: Números enteros
13 # Así de pelada... no hay que explicar más
# ============================================================================ #
# float: Números de coma flotante, reales... con decimal pues'n
13.45
# ============================================================================ #
# bool: Booleanos Verdadero y Falso
True # 1 puede ser considerado verdadero
False # 0, None, "", (), {}, [], set(), range(0)
# ============================================================================ #
# No me pregunten por números complejos... no los explicaré aquí...
# Con éstos son más que suficientes para empezar
Síguenos en el Grupo de Facebook 1. TIPOS DE DATOS en pastebin Peras y Manzanas en Repl.it

# 2. VARIABLES, OPERADORES de comparación y lógicos
# ============================================================================ #
# Las variables son nombres de objetos que residen en la memoria
# Una variable puede ser nombrada como gustes a excepción de:
# El primer caracter no puede ser un número
# No usar símbolos especiales !, @, #, $, %, etc.
# No debe ser nombrada igual que una palabra reservada
# A las variables hay que asignarle un tipo de datos con el signo =
# La variable asignada deberá ir al lado izquierdo del = y el valor a asignar al lado derecho
MiVariable = "hola" # Se le ha asignado una cadena con valor "hola"
Edad = 44 # Esta variable tiene un valor numérico entero de 44
MiVariable = 44 # Puede cambiar la variable de tipo de dato
MiVariable = Edad # Puedes asignarle el valor de otra variable
MiLista = [1, 2, 3, 4, 5] # Una variable con valor de una lista
aprobado = True # Una variable booleana
aprobado = promedio >= 6 # Una variable con una condición si otra variable es mayor a 6
# Python sugiere que los nombres de variables sean de tipo snake_case, esto es… nombres en minúsculas
con separador entre palabras por un guión bajo _ , por ejemplo nombre_estudiante = “Luis Urbalejo”
# Soy más del tipo CamelCase donde los nombres de variables inician con mayúscula en cada palabra..
por ejemplo NombreEstudiante = “Luis Urbalejo”
# Cada quien es libre de usar el tipo de variable, yo hasta las mezclo jeje…. Mientras el código sea limpio
y entendible…
# Nombres de mis variables....
# Utilizo UpperCamelCase y antepongo:
# str para variables de cadena: strNombre, strArchivo
# int para variables de tipo entero: intNumero, intEdad
# flt para flotantes
# bol para booleanos True y False
# lst para Listas
# tpl para tuplas
# dic para diccionarios
# Y así.... capicci?
# Operadores de Comparación
# ============================================================================ #
# Para realizar comparaciones lógicas se utilizan operadores de comparación. Estos son
# == igual a
# > mayor que Operadores Lógicos
# < menor que #=========================================#
# != diferente a Se utilizan para agrupar operaciones con lógica booleana
# >= mayor o igual a not (no) and ( y ) or (o)
# <= menor o igual a
Síguenos en el Grupo de Facebook 2.VARIABLES en pastebin Peras y Manzanas en Repl.it

# 3. Función print()
# ============================================================================ #
# La función print() dará una salida a la consola
# Su sintáxis:
# print(objetos, sep='separador', end='n', file=file, flush=flush)
# end="n" Si no se especifica, al final hace un salto de línea
# Los últimos 2 file y flush no los veremos
# Ejemplos
print("Hola Mundo!") # >>> Hola Mundo!
# 2 objetos separados por coma
print("Hola", "Mundo!") # >>> Hola Mundo!
# usando un separador entre objetos
print("Hola", "Mundo!", sep="<->") # >>> Hola<->Mundo!
# Usando un end="" no hace un salto de línea
print("Hola", end="")
# entonces "Mundo!" se imprime seguido
print("Mundo!") # >>> HolaMundo!
# Concatenado (uniendo) cadenas
x = "Hola"
y = "Mundo!"
z = x + " " + y
print(x, y, z) # >>> Hola Mundo! Hola Mundo!
x = 3
y = 5
# Se puede imprimir operaciones aritméticas
print(x + y) # >>> 8
# Se puede formatear una cadena anteponiendo f" " y entre {} las variables
z = f"{x} + {y} = {x + y}"
print(z) # >>> 3 + 5 = 8
Síguenos en el Grupo de Facebook 3.Función print() en pastebin Peras y Manzanas en Repl.it

# 4. String, Cheat Codes
# ============================================================================ #
# Una cadena de caracteres (str-ing) es un tipo de datos que representa texto
# Se definen encerrando el valor entre comillas dobles “ “
strNombre = “Luis Urbalejo”
# o entre comillas simples ‘ ‘
strGrupo = ‘Python en español (principiantes)’
# También es posible una cadena de texto de varias líneas encerrándola entre triple comillas
strMultilineas = “””Esta cadena tiene varias líneas
esta es la segunda línea
una línea más… “””
print(strMultilineas)
# >>> Esta cadena tiene varias líneas
# >>> esta es la segunda línea
# >>> una línea más…
# Se pueden concatenar con +
print(strNombre + strGrupo) # >>> Luis UrbalejoPython en español (principiantes)
# Multiplicar *
print(strNombre * 2) # >>> Luis UrbalejoLuis Urbalejo
# Obtener un caracter encerrando el índice entre [ ]
print(strNombre[ 5 ]) # >>> U
# Obtener un rango de caracteres <string>[índice_inicio : índice_final + 1]
print(strNombre[ 5 : 9 ] # >>> Urba
# Buscar una subcadena y regresar True si la encuentra
print(“Urb” in strNombre) # >>> True
# Métodos
#Convierte el 1er carácter de la cadena en mayúscula
print(“luis Antonio”.capitalize()) # >>> Luis Antonio
# Centrar una cadena <string>.center(longitud, carácter_de_llenado)
print(“*”.center(10,”-“)) # >>> ----*-----
Síguenos en el Grupo de Facebook 4. String, Cheat Codes en pastebin Peras y Manzanas en Repl.it

# Contar número de subcadenas en una cadena <string>.count(subcadena, inicio, long)
print(strGrupo.count(“e”)) # >>> 3
# Busca una subcadena y regresa la posición o -1 si no la encuentra <string>.find(subcadena, inicio, long)
print(strNombre.find(“Urba”)) # >>> 5
# True si la cadena contiene solo letras y/o números
print(“abc 123”.isalnum()) # >>> False # Hay un espacio :/
# True si la cadena son solo letras
print(“Luiggi”.isalpha()) # >>> True
# True si la cadena son solo números
print(“2019”.isdigit()) # >>> True
# True si la cadena contiene solo minúsculas
print(“luis2019”.islower()) # >>> True
# True si la cadena contiene solo mayúsculas
print(“LUIS2019”.isupper()) # >>> True
# Unir una lista como cadena
lstLista = [ “Luis”, “Antonio”, “Urbalejo” ]
print(“ “.join(lstLista)) # >>> Luis Antonio Urbalejo
print(“,“.join(lstLista)) # >>> Luis,Antonio,Urbalejo
# Convertir una cadena en una lista
print(strGrupo.split(sep=” “) # >>> [ ‘Python’, ‘en’, ‘español’, ‘(principiantes)’ ]
# Devuelve la longitud de la cadena
print(len(strGrupo)) # >>> 33
# Convierte las mayúsculas a minúsculas
print(strGrupo.lower()) # >>> python en español (principiantes)
# Convierte las minúsculas a mayúsculas
print(strGrupo.upper()) # >>> PYTHON EN ESPAÑOL (PRINCIPIANTES)
# Elimina el carácter especificado del lado izquierdo y derecho (espacios si no se especifica)
print(“xxxxxHolaxxxMundo!xxxxx”.strip(“x”)) # >>> HolaxxxMundo!
# Invierte mayúsculas y minúsculas
print(strNombre.swapcase()) # >>> lUIS uRBALEJO
Síguenos en el Grupo de Facebook 4. String, Cheat Codes en pastebin Peras y Manzanas en Repl.it

# 5. Función input()
# ============================================================================ #
# Función input() entrada / captura de datos por teclado
# Es utilizada para solicitar datos del usuario por medio del teclado
# Siempre retorna una cadena (string)… si el usuario captura números, deberemos convertir esa caden
de números en un tipo de datos entero o flotante para hacer operaciones aritméticas sise requiere.
# Su sintáxis:
# input(objeto opcional)
# Normalmente, al retornar una cadena debemos asignarlo a una variable.
# Ejemplos
strNombre = input("Cómo te llamas? ")
print("Hola", strNombre)
# >>> Cómo te llamas? Luis
# >>> Hola Luis
# También es válido de la siguiente manera... mismo resultado
print("Hola", input("Cómo te llamas? "))
# >>> Cómo te llamas? Luis
# >>> Hola Luis
intEdad = input("Edad: ")
# Aquí, realmente lo que capturamos será una cadena
# y como esperamos un valor entero, ponemos la función int()
# quedando así:
intEdad = int(input("Edad: "))
# Si no se captura un número entero se generará un error...
# para eso están las excepciones... luego las veremos
# Es muy común, en los principiantes, no convertir el valor de retorno correcto
# por ejemplo la cadena “13.65” que contiene un punto decimal, convertirla a tipo entero generará un
error…
# int(“13.65”) # ERROR!!
# Para solucionar este inconveniente, si deseamos que el dato del usuario sea entero y capturó “13.65”
(supongamos)… ocuparíamos convertir primero esa cadena a tipo flotante y después a entero
# int( float( “13.65” ) ) # CORRECTO!
Síguenos en el Grupo de Facebook 5. Función input() en pastebin Peras y Manzanas en Repl.it

# 6. Por fin!!! Algo del pinche ejemplo ¬¬
# ============================================================================ #
# En capítulos anteriores en CSI...
# Bueno.. se trata de ir armando un programa que pida datos del alumno
# pida sus calificaciones, calcule el promedio y muestre (NO) aprobado
# Ya vimos print() e input() ...Pues empecemos!
strAlumno = input("Introduzca nombre del alumno: ")
print("Hola", strAlumno)
print("Por favor, capture sus 4 calificaiones")
intCalificacion_1 = int(input("Calificación 1: "))
# Esto será más o menos así
# >>> Introduzca nombre del alumno: Luis Urbalejo
# >>> Hola Luis Urbalejo
# >>> Por favor, capture sus 4 calificaiones
# >>> Calificación 1: 9
# Bueno, ya tenemos el nombre del alumno en la variable strAlumno
# y las 4 calificaciones en intCalificacion_1, intCalificacion_2,
# intCalificacion_3 y intCalificacion_4
# (Para los que estén pensando que se puede hacer con listas.. awantaaa.jpg)
# Ya podemos hacer una operación para calcular el promedio (media)
# Sumar las 4 calificaciones y después dividirlas entre 4
intSumaCalificaciones = intCalificacion_1 + intCalificacion_2
+ intCalificacion_3 + intCalificacion_4
# Aaahh si.. no les dije de como quebrar una linea... pues así con
fltPromedio = intSumaCalificaciones /4
print(fltPromedio)
# >>> 9.0
Síguenos en el Grupo de Facebook 6. Por fin!!! Algo del ejemplo en pastebin Peras y Manzanas en Repl.it

# 7. Indentación y Condicional if, elif, else
# ============================================================================ #
# El condicional if se utiliza para ejecutar una instrucción en caso de que una y/o más condiciones se
cumplan... esto es cuando la decisión sea True
# elif se usa después de usar if y es opcional. Se pueden usar tantos elif como uno desee
# else, es opcional y se usa al final de todas las condiciones echas con if … se ejecuta cuando no se
cumplen las condiciones anteriores
# Sintáxis:
# if condiciones:
# instrucciones si condición fue verdadera
# elif condiciones: <--- Opcional, puede haber más de un elif
# instrucciones si condición fue verdadera
# else: <---- Opcional
# instrucciones si no se cumplen las condiciones anteriores
# En python no existe begin o end explícitos, ni llaves que marquen dónde empieza o termina un ciclo,
bucle, función o serie de instrucciones.
# El único delimitador son dos puntos (:) y el sangrado del código.
# El sangrado o indentación pueden ser de 3 a 5 espacios normalmente
# Ejemplos
intEdad = int(input("Edad: "))
if intEdad >= 18: # Condición si el valor de intEdad es mayor igual a 18
# dos puntos significa que habrá un bloque de instrucciones para if
# a continuación... deberá estar indentadas
print("Es mayor de edad")
elif intEdad < 1: # Condición si el valor de intEdad es menor que 1
# Se indenta el bloque de instrucciones para el elif
print("Edad no debe ser menor a 1")
else: # Si no se cumplen las anteriores entra al else
# Se indenta el bloque de instrucciones para el else
print("Es menor de edad")
# <-- Al volver a la indentación anterior sale del if
# >>> Edad: 44
# >>> Es mayor de edad
# Volvámos al ejercicio de las calificaciones...
# calculamos el promedio en fltPromedio
if fltPromedio >= 6:
print("APROBADO!!")
else:
print("NO APROBADO!!!")
Síguenos en el Grupo de Facebook 7. Indentación y Condicional en pastebin Peras y Manzanas en Repl.it

# 8. LISTAS .append() y función len()
# ============================================================================ #
# Una lista es una variable / objeto que puede contener N elementos de datos de cualquier tipo,
incluyendo listas dentro de listas
# Imagínala como un archivero con N cajones...cada cajón, de abajo hacia arriba está enumerado,
iniciando del 0 el primer cajón, 1 el segundo... y así...
# En cada cajón puedes almacenar un valor (numérico, string, lista, etc.)
lstArchivero = [ ] # Inicializamos la lista vacía
print(lstArchivero) # Mostramos la lista
# >>> [ ]
print("Cajones:",len(lstArchivero)) # len( ) podemos saber la cantidad de cajones
# >>> Cajones: 0
# Agreguemos un cajón al Archivero
lstArchivero.append("Luis")
print("El archivero contiene:", lstArchivero)
# >>> El archivero contiene: ['Luis']
print("No. de cajones:", len(lstArchivero))
# >>> No. de cajones: 1
# Agreguemos un cajón más
lstArchivero.append(2020)
# >>> El archivero contiene: ['Luis', 2020]
# Podemos agregar el valor de una variable
lstDatos = ["Puedes INICIALIZAR", "una lista", "con cajones", "en lugar de", 0 ]
lstArchivero.append(lstDatos)
# >>> El archivero contiene: ['Luis', 2020, ['Puedes INICIALIZAR', 'una lista', 'con cajones', 'en lugar de',
0]]
# Para ver el valor de un elemento pones el nombre de la lista y su [ indice ]
print(lstArchivero[1]) # Muestra el segundo cajón
# >>> 2020
# Así igual puede modificarse el valor del cajón
lstArchivero[1] = "este valor era numérico y ahora es una cadena"
print(lstArchivero[1])
# >>> este valor era numérico y ahora es una cadena
# >>> El archivero contiene: ['Luis', 'este valor era numérico y ahora es una cadena', ['Puedes
INICIALIZAR', 'una lista', 'con cajones', 'en lugar de', 0]]
Síguenos en el Grupo de Facebook 8. LISTAS .append() y función len() en pastebin Peras y Manzanas en Repl.it

# 9. LISTAS copiar una lista, editar, borrar, insertar un valor de la lista
# ============================================================================ #
# Ya vimos como agregar datos a una lista
lstLista = [2, 4, 6, 7, 8, 10, 12, 13] # Si, el 7 y el 13 los puse a propósito
lstNoCopia = lstLista # Esto NO es una copia sino una referencia a lstLista
lstCopia = lstLista.copy() # Con .copy() podemos hacer una copia de una lista
lstCopia = lstLista[:] # Otra manera de hacer una copia es con slice
lstCopia = lstLista[0:len(lstLista)] # es lo mismo que la anterior
# Para imprimir toda la lista
print(lstCopia) # >>> [2, 4, 6, 7, 8, 10, 12, 13]
# Si queremos que no salgan los [ ]
print(*lstCopia) # >>> 2 4 6 7 8 10 12 13
# Para imprimir el valor de un elemento lista[indice]
print(lstCopia[3]) # >>> 7 ya que corresponde al indice 3 (empieza de 0)
# Para imprimir un rango se usa el slice, esto es lista[indice : indice + elementos]
print(lstCopia[4:7]) # >>> [8, 10, 12] es confuso el slice [4:7] pero 7-4 = 3
# Vamos a modificar un valor en la lista lista[indice] = Nuevo Valor
lstCopia[3] = 0
print(lstCopia) # >>> [2, 4, 6, 0, 8, 10, 12, 13]
lstCopia[-1] = 14 # -1 empieza de derecha a izquierda [<--... -4, -3, -2, -1]
print(lstCopia) # >>> [2, 4, 6, 0, 8, 10, 12, 14]
# Para borrar un elemento.. por ejemplo ese 0 el indice 3
lstCopia.remove(0) # lista.remove(valor) el primer valor encontrado de izq a der
print(lstCopia) # >>> [2, 4, 6, 8, 10, 12, 14]
lstCopia = lstLista.copy() # Restauramos la lista para volverlo a borrar
print(lstCopia.pop(3)) # >>> 7 Retorna el valor eliminado del indice 3
print(lstCopia) # >>> [2, 4, 6, 8, 10, 12, 13]
# Otro método para borrar elementos de la lista es con slicing
lstCopia = lstCopia[:3] + lstCopia[4:] # toma del [0:3] = [2, 4, 6] y del [4: al final] = [8, 10, 12, 13]
print(lstCopia) # >>> [2, 4, 6, 8, 10, 12, 13]
# Así puedes agregar un valor al final... como el lstCopia.append(16)
lstCopia = lstCopia + [16]
print(lstCopia) # >>> [2, 4, 6, 8, 10, 12, 13, 16]
# o insertar un valor en la lista.. como lstCopia.insert(4, 9)
lstCopia = lstCopia[:4] + [9] + lstCopia[4:]
print(lstCopia) # >>> [2, 4, 6, 8, 9, 10, 12, 13, 16]
del lstCopia[3] # Borramos el elemento de la lista con índice 3
print(lstCopia) # >>> [2, 4, 6, 8, 10, 12, 13]
del lstCopia # hemos borrado la lista completa!!!
print(lstCopia) # >>> NameError: name 'lstCopia' is not defined
Síguenos en el Grupo de Facebook 9. LISTAS copiar, editar, borrar e insertar en pastebin Peras y Manzanas en Repl.it

# 10. LISTAS contar, ordenar, devolver valor mínimo y máximo
# ============================================================================ #
# Tenemos una lista con los siguientes valores
lstLista = [8, 2, 5, 7, 2, 9, 5, 7, 2, 3, 8, 1, 4, 6, 1]
# Hay valores repetidos y desordenados
# Vamos a contar cuántos valores 8 hay en la lista
print(lstCopia.count(8)) # >>> 2 (en el índice 0 y 10) .. 0 si no encuentra
print(lstCopia.index(8)) # >>> 0 Regresa el primer índice encontrado el valor
# en lista.index(valor) si no encuentra el valor en la lista dará error
# Para saber si un valor se encuentra en la lista podemos usar <valor> in <lista>
if 10 in lstCopia:
print(lstCopia.index(10)) # No entra al if porque no existe ese valor
# Para ordenar listas podemos usar la función sorted(<lista>) que no la altera
print(sorted(lstCopia)) # >>> [1, 1, 2, 2, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9]
print(lstCopia) # [8, 2, 5, 7, 2, 9, 5, 7, 2, 3, 8, 1, 4, 6, 1]
# o <lista>.sort() que si afecta el orden de la lista
print(lstCopia.sort()) # >>> None No retorna nada
print(lstCopia) # >>> [1, 1, 2, 2, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 9]
# ordenamiento de mayor a menor con <lista>.reverse() afectará <lista>
print(lstCopia.reverse()) # >>> None No retorna nada
print(lstCopia) # >>> [9, 8, 8, 7, 7, 6, 5, 5, 4, 3, 2, 2, 2, 1, 1]
# Para saber el valor mínimo o máximo de la lista puedes ordenar la lista
lstCopia.sort() # Aquí se ordena de menor a mayor
print(lstCopia[0]) # >>> 1 Así que sabemos que el primero es el menor
print(lstCopia[-1]) # >>> 9 Y el último el mayor
# Pero para qué reinventar la rueda? Si ya están las funciones min() y max() para eso…
lstCopia = lstLista.copy() # Restauramos la lista original
print(min(lstCopia)) # >>> 1
print(max(lstCopia)) # >>> 9
Síguenos en el Grupo de Facebook 10. LISTAS contar, ordenar en pastebin Peras y Manzanas en Repl.it

# 11. LISTAS eliminar repetidos con conjuntos set()
# ============================================================================ #
# Un conjunto es una colección no ordenada de objetos únicos.
# Se crean entre { }, como los diccionarios pero no tienen key... luego vemos eso
# El caso es que, como los valores son únicos… no se repiten
lstLista = [8, 2, 5, 7, 2, 9, 5, 7, 2, 3, 8, 1, 4, 6, 1]
# Vamos a eliminar repetidos
# La peladita es convertir la lista a conjunto con set(<lista>)
# y luego convertir el conjunto en lista nuevamente... con list(<objeto>)
print(set(lstCopia)) # >>> {1, 2, 3, 4, 5, 6, 7, 8, 9} Ordena y elimina repetidos
print(lstCopia) # [8, 2, 5, 7, 2, 9, 5, 7, 2, 3, 8, 1, 4, 6, 1] pero no la cambia
# Haremos lo siguiente <lista> = list( set ( <lista> ) )
lstCopia = list ( set ( lstCopia ))
# lstCopia <--asignamos convierteAlista( convierteAconjunto( lista repetidos))
print(lstCopia) # >>> [1, 2, 3, 4, 5, 6, 7, 8, 9] Uy que fácil!....
# Otra manera de eliminar repetidos se utiliza el bucle for que lo explicaré en el 12
Síguenos en el Grupo de Facebook 11. LISTAS eliminar repetidos con set() en pastebin Peras y Manzanas en Repl.it

# 12. El blucle for
# ============================================================================ #
# El bucle o ciclo for se usa para recorrer los elementos de un objeto iterable (string, lista, tupla,
conjunto, diccionario, rango, etc.)
# Sintaxis:
# for <objetos> in <iterable>:
# <ciclo de sentencias>
# break Opcional para romper y salir del ciclo for
# continue Opcional para ir a la siguiente iteración
# else:
# Código que siempre se ejecutará al final si no hubo un break
# Ejemplos
lstLista = [8, 2, 5, 7, 2, 9, 5, 7, 2, 3, 8, 1, 4, 6, 1]
for i in lstLista:
print(i, end="..")
# >>> 8..2..5..7..2..9..5..7..2..3..8..1..4..6..1..
print()
# range(min=0, máx, step=1) Crea una secuencia numérica iterable
# Imprimir los números pares de 0 a 12
for i in range(13):
if i % 2 == 1: # El operador aritmetico % regresa residuo de la división
# Si el residuo es 1 de la div entre 2 .. es impar
continue # entonces va a la siguiente iteración
print(i, end=", ")
# >>> 0, 2, 4, 6, 8, 10, 12,
print()
# imprimir los pares de lstLista
for i in lstLista:
if i % 2 == 1:
continue
print(i, end =", ")
# >>> 8, 2, 2, 2, 8, 4, 6,
print()
# Encontrar el número 3 en lstLista
for valor in lstLista:
if valor == 3:
print("valor encontrado!")
break # Rompe el for
else: # Si no hubo break, entra al else
print("No se encontró el número 3")
# >>> valor encontrado!
Síguenos en el Grupo de Facebook 12. El bucle for en pastebin Peras y Manzanas en Repl.it

# 13. LISTAS eliminar repetidos usando for
# ============================================================================ #
lstLista = [8, 2, 5, 7, 2, 9, 5, 7, 2, 3, 8, 1, 4, 6, 1]
# Ahora vamos a eliminar valores que se repitan
lstNoRepetidos =[ ] # Inicializamos una lista donde pondremos valores únicos
for elemento in lstCopia:
if elemento not in lstNoRepetidos: # Si no existe en la lista no repetidos
# También puede usarse la condición lstNoRepetidos.count(elemento) == 0:
lstNoRepetidos.append(elemento) # Agregamos el elemento
print(lstCopia) # >>> [8, 2, 5, 7, 2, 9, 5, 7, 2, 3, 8, 1, 4, 6, 1]
print(lstNoRepetidos) # >>> [8, 2, 5, 7, 9, 3, 1, 4, 6]
print(sorted(lstNoRepetidos)) # >>> [1, 2, 3, 4, 5, 6, 7, 8, 9] Ordenados con sorted()
# Ordenar la lista por el método burbuja
for i in range(len(lstNoRepetidos)):
for j in range(i + 1, len(lstNoRepetidos)):
if lstNoRepetidos[i] > lstNoRepetidos[j]:
lstNoRepetidos[i], lstNoRepetidos[j] = lstNoRepetidos[j], lstNoRepetidos[i]
print(lstNoRepetidos) # >>> [1, 2, 3, 4, 5, 6, 7, 8, 9]
Síguenos en el Grupo de Facebook 13. LISTAS eliminar repetidos con for en pastebin Peras y Manzanas en Repl.it

# 14. Volvemos al ejercicio… usando listas y for
# ============================================================================ #
# Se acuerdan que estábamos haciendo un ejercicio de calificaciones (6.)
# Perfecto.. ya vimos listas y el for... vamos a utilizarlas
strAlumno = input("Introduzca nombre del alumno: ") # >>> Introduzca nombre del alumno: Luis
print("Hola", strAlumno) # >>> Hola Luis
print("Por favor, capture sus 4 calificaiones") # >>> Por favor, capture sus 4 calificaiones
lstCalificaciones = [ ] # Inicializamos la lista par calificaciones
for i in range(4):
lstCalificaciones.append(int(input("Calificacion " + str(i + 1) + ": ")))
# Pudo ser así:
# intCalificacion = int(input("Calificacion " + str(i + 1) + ": "))
# lstCalificaciones.append(intCalificacion)
# >>> Calificacion 1: 10
# Hay una función para sumar listas.. sum(<lista>)
fltPromedio = sum(lstCalificaciones) / len(lstCalificaciones)
print("Promedio", fltPromedio, end =" ")
print("APROBADO!!!")
else:
# >>> Promedio 8.75 APROBADO!!!
Síguenos en el Grupo de Facebook 14. Volvemos al ejercicio…listas y for en pastebin Peras y Manzanas en Repl.it

# 15. El guail… el bucle while pues!
# ============================================================================ #
# Un bucle while permite repetir la ejecución de un grupo de instrucciones
# mientras se cumpla una condición (mientras la condición tenga el valor True).
# Sintaxis:
# while <condición verdadera>:
# <sentencias del ciclo>
# break Opcional, para quebrar el ciclo
# continue Opcional, para volver al inicio del while
# else: Se ejecuta cuando no hace un break
# <sentencias del else>
# Ejemplos
# Imprimir los números del 1 al 10
intContador = 1 # Inicializamos un contador en 1
while intContador < 11: # Mientras el contador sea menor que 11:
print(intContador, end=" ") # Imprime el contador, con terminación un espacio
intContador += 1 # Incrementamos el contador
else: # Si no hubo un break ejecutar el else
print("nfin del while") # Imprimir con salto de linea "fin del while"
# >>> 1 2 3 4 5 6 7 8 9 10
# >>> fin del while
# Hay que tener mucho cuidado de no hacer un ciclo infinito donde nunca salga
# Por ejemplo, si no incrementamos el contador dentro del while NUNCA SALDRÍA!
# Otro Ejemplo, ahora un ciclo infinito (-pero si dijiste que no lo hiieramos!!!)
# Quién me entiende pues?... es que este ciclo infinito tendrá un break
while True: # <--- Siempre se cumplirá la condición.. ciclo infinito
strNombre = input("Nombre (escriba fin para salir): ")
if strNombre == "fin": # Si se captura 'fin'
break # quiebra el ciclo while
print(f"Hola {strNombre}, es un placer")
print("Fin del ciclo.. no es necesario el else: porque nunca se ejecutaría")
Síguenos en el Grupo de Facebook 15. El bucle while en pastebin Peras y Manzanas en Repl.it

# 16. Ejercicio Alumno con while
# ============================================================================ #
# Sobre el ejercicio del episodio XIV ....
# Hace mucho tiempo, en una galaxia muy, muy lejana.... estabamos
# haciendo un ejercicio de un alumno en el que capturabamos las 4
# calificaciones en una lista, con un for y mostrabamos su promedio
# Pues ahora modificaremos para "n" alunmos con while
# Dejaremos el código igual.. solo añadiremos el ciclo while y daremos
# sangrado al código ya hecho para que sea parte del ciclo
while True: # - Neta loco..chingas! con los ciclos infinitos...NO!!!
# + Si, como chingados qué no?... saldremos con break
# Daremos indentación --> al código que ya teníamos
strAlumno = input("Introduzca nombre del alumno (fin para salir): ")
# >>> Introduzca nombre del alumno (fin para salir): Luis
# Y Añadimos este extra para salir si se escribe "fin" o "FIN" o "FiN "
if strAlumno.lower().strip() == "fin": # .lower() a minúsculas y
break # quiebra el ciclo # .strip() quita espacios <-->
print("Hola", strAlumno)
# >>> Hola Luis
print("Por favor, capture sus 4 calificaiones")
# >>> Por favor, capture sus 4 calificaiones
lstCalificaciones = [ ] # Inicializamos la lista par calificaciones
for i in range(4):
lstCalificaciones.append(int(input("Calificación " + str(i + 1) + ": ")))
# Hay una función para sumar listas.. sum(<lista>)
fltPromedio = sum(lstCalificaciones) / len(lstCalificaciones)
print("Promedio", fltPromedio, end =" ")
print("APROBADO!!!")
else:
# >>> Promedio 8.75 APROBADO!!!
Síguenos en el Grupo de Facebook 16. Ejercicio Alumno con while en pastebin Peras y Manzanas en Repl.it

# 17. Receso
# ============================================================================ #
# Que solo acepte un valor entero entre 10 y 20
while True: # Ciclo infinito hasta que se capture un valor correcto
strNumero = input("Numero entre 10 y 20: ")
if strNumero.isdigit(): # Si se capturaron números
intNumero = int(strNumero) # Convertimos a número entero
if 10 <= intNumero <= 20: # Rango entre 10 y 20
break # rompe el ciclo para continuar con el programa
else:
print("Escribe un número entre 10 y 20")
else:
print("Error! solo se aceptan números en captura")
print("El número es", intNumero)
# >>> Numero entre 10 y 20: 4
# >>> Escribe un número entre 10 y 20
# >>> Numero entre 10 y 20: fasd
# >>> Error! solo se aceptan números en captura
# >>> Numero entre 10 y 20: 16
# >>> El número es 16
if intNumero == 16:
print("correcto!")
else:
print("incorrecto!")
# Se puede hacer en una sola línea if else ... 3 maneras a continuación
print("correcto!") if intNumero == 16 else print("incorrecto!")
print("correcto!" if intNumero == 16 else "incorrecto!")
print(("in" if intNumero !=16 else "") + "correcto!" )
Síguenos en el Grupo de Facebook 17. Receso en pastebin Peras y Manzanas en Repl.it

# 18. Diccionarios…
# ============================================================================ #
# Es hora de hablar de diccionarios.. qué son?
# Un diccionario es una colección no ordenada de objetos que tienen
# una llave (key) para identificar un valor separados por dos puntos
# y cada elemento key:value separados por coma...todo encerrado { }
# Ejemplo:
dicColores = {"verde":"green", "blanco":"white", "rojo":"red"}
# Podemos obtener el valor con <diccionario>.get(<key>)
print(dicColores.get("verde")) # >>> green
# O de la forma <diccionario>[key]
print(dicColores["rojo"]) # >>> red
# Agregar o modificar un valor <diccionario>[key] = <valor>
dicColores["negro"] = "Nigga" # Ups...
print(dicColores)
# >>> {'verde': 'green', 'blanco': 'white', 'rojo': 'red', 'negro': 'Nigga'}
dicColores["negro"] = "black" #same shit dicColores.update({"negro":"black"})
print(dicColores)
# >>> {'verde': 'green', 'blanco': 'white', 'rojo': 'red', 'negro': 'black'}
# Podemos Devolver un valor y eliminarlo con <diccionario>.pop(<key>
print(dicColores.pop("negro")) # >>> black
print(dicColores) # >>> {'verde': 'green', 'blanco': 'white', 'rojo': 'red' }
print("blanco" in dicColores.keys()) # >>> True
print("green" in dicColores.values()) # >>> True
# Los keys pueden ser cualquier tipo de datos pero se usan string o int
# Los valores pueden ser cualquier objeto...listas, diccionarios, etc
dic = { 1:"Usuario 1", "lenguajes": ["python", "c++", "JS"], "pares":[2, 4, 6]}
Síguenos en el Grupo de Facebook 18. Diccionarios…. En pastebin Peras y Manzanas en Repl.it

Por el momento es todo… pero aún falta el ejercicio con diccionarios, funciones, clases….
Si les ha gustado este documento favor de dejar comentarios en la publicación Peras y Manzanas del
Grupo de Facebook
Se agradecerá cualquier sugerencia… Se ocupa mejorar este documento... es su versión 1.0
Luis Urbalejo, 15 de Junio del 2020

Python, te lo explico con peras y manzanas

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (11)

Similar a Python, te lo explico con peras y manzanas

Similar a Python, te lo explico con peras y manzanas (20)

Último

Último (20)

Python, te lo explico con peras y manzanas