├── imagenes
    └── conjuntos_ejemplo.png
├── comentarios.py
├── booleans.py
├── bucle-while.py
├── bucle-for.py
├── lambdas.py
├── numbers_1.py
├── tiposDatos.py
├── condicionales.py
├── tuplas.py
├── variables.py
├── operadores.py
├── diccionarios.py
├── strings.py
├── funciones.py
├── listas.py
└── sets.py


/imagenes/conjuntos_ejemplo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sergiecode/curso-python-desde-cero/HEAD/imagenes/conjuntos_ejemplo.png


--------------------------------------------------------------------------------
/comentarios.py:
--------------------------------------------------------------------------------
 1 | # Comentario linea simple
 2 | """
 3 | Comentario
 4 | multilínea
 5 | """
 6 | 
 7 | print("Hola mundo") # Comentario
 8 | 
 9 | def funcion():
10 |     """
11 |     Comentario
12 |     mutilinea
13 |     dentro
14 |     de
15 |     una
16 |     funcion
17 |     """


--------------------------------------------------------------------------------
/booleans.py:
--------------------------------------------------------------------------------
 1 | ### Tipo de dato que toma dos valores Verdadero o Falso (True o False)
 2 | 
 3 | a = True
 4 | b = False
 5 | 
 6 | ### Nos ayudarán a tomar decisiones
 7 | 
 8 | ### Estructuras que devuelven verdadero (las que tienen contenido)
 9 | string = bool("No se olviden de suscribirse al canal")
10 | num = bool(2022)
11 | lista = bool(['Naranja', 'Manzana'])
12 | dict = bool({"nombre": "Sergie Code"})
13 | 
14 | ### Estructuras que devuelven falso (todas están vacías de contenido)
15 | string2 = bool("")
16 | num2 = bool(0)
17 | lista2 = bool([])
18 | dict2 = bool({})
19 | none = bool(None)
20 | 
21 | 


--------------------------------------------------------------------------------
/bucle-while.py:
--------------------------------------------------------------------------------
 1 | ## BUCLES: estructura que se repite mientras la condición sea verdadera
 2 | ## BUCLE WHILE: 
 3 | 
 4 | x = 1
 5 | 
 6 | while x <= 10:
 7 |     print(f"Hola a todos estoy dentro de un bucle y x vale {x}")
 8 |     x += 1
 9 | 
10 |     if x == 5:
11 |         break # Esto hace que salga del bucle
12 | 
13 |     if x == 15:
14 |         continue # saltea las líneas de acá en adelante
15 | 
16 | else:
17 |     print(f"Ya no se cumplió la condición del bucle porque x es {x}")
18 | 
19 | 
20 | 
21 | ## EJEMPLO PRACTICO
22 | 
23 | while True:
24 |     print("No te olvides de suscribirte a mi canal @sergiecode")
25 |     respuesta = input("¿Desea salir? (s/n)").strip().lower()
26 |     if respuesta == 's':
27 |         break


--------------------------------------------------------------------------------
/bucle-for.py:
--------------------------------------------------------------------------------
 1 | ## BUCLES: estructura que se repite mientras la condición sea verdadera
 2 | ## BUCLE FOR:
 3 | 
 4 | tecnologias = ['Python', 'JavaScript', 'Java', 'C#', 'Angular', 'React', 'NodeJS', 'Ruby', 'R', 'Django'] # esto es una lista
 5 | x = 1
 6 | 
 7 | # ¿Cómo iterar una estructura de datos (lista, tupla, etc)
 8 | for tecnologia in tecnologias:
 9 |     print(f"{x}. {tecnologia}")
10 |     x += 1
11 | else:
12 |     print("Esas fueron todas las tecnologias que sabe Pedrito")
13 | 
14 | # ¿Cómo iterar un string (texto)?
15 | for letra in "Python":
16 |     print(letra)
17 | 
18 | # ¿Cómo iterar un rango de números? 
19 | for x in range(5): # Range imprime desde cero al número que colocamos sin incluirlo
20 |     print(x)
21 | 
22 | for x in range(2,7): # Range imprime desde el primer número al segundo número sin incluirlo
23 |     print(x)
24 | 
25 | for x in range (2,11,2): # El tercer parámetro nos sirve para poner intervalos
26 |     print(x)
27 | 
28 | letras = ['a','b','c']
29 | numeros = [1,2,3]
30 | 
31 | for l in letras:
32 |     for n in numeros:
33 |         print(l,n)
34 | 
35 | # a1, a2, a3, b1, b2, b3, c1, c2, c3


--------------------------------------------------------------------------------
/lambdas.py:
--------------------------------------------------------------------------------
 1 | # Funciones Lambda: son funciones anónimas y cortas (de una sola línea de código)
 2 | 
 3 | # SINTAXIS:
 4 | # lambda arg1, arg2, etc : retorno
 5 | 
 6 | def suma(a,b):
 7 |     return a + b
 8 | def resta(a,b):
 9 |     return a - b
10 | def multiplicacion(a,b):
11 |     return a * b
12 | def division(a,b):
13 |     return a // b
14 | 
15 | 
16 | 
17 | # Ejemplos (aunque no deberíamos asignar a una variable una lambda como buena práctica)
18 | suma_lambda = lambda a,b : a + b 
19 | resta_lambda = lambda a,b : a - b 
20 | multiplicacion_lambda = lambda a,b : a * b 
21 | division_lambda = lambda a,b : a // b 
22 | 
23 | 
24 | # Ejemplo más realista [ Constructor de funciones ]
25 | 
26 | def creador_funciones_multiplicacion(n):
27 |     return lambda a : a * n
28 | 
29 | duplicador = creador_funciones_multiplicacion(2)
30 | triplicador = creador_funciones_multiplicacion(3)
31 | cuadriplicador = creador_funciones_multiplicacion(4)
32 | 
33 | print(duplicador(5))
34 | print(triplicador(5))
35 | print(cuadriplicador(5))
36 | 
37 | # Ejemplo práctico de lambda en filter
38 | 
39 | numeros = [1,2,3,4,5,6,7,8,9,10]
40 | pares = list(filter(lambda x: x % 2 == 0,  numeros))
41 | print(pares)


--------------------------------------------------------------------------------
/numbers_1.py:
--------------------------------------------------------------------------------
 1 | ####### NUMBERS
 2 | 
 3 | # int (Integer): Número entero
 4 | numero_entero = 10
 5 | 
 6 | # float: Número decimal
 7 | numero_decimal = 5.75
 8 | 
 9 | # complex: numero complejo (parte entera y otra parte imaginaria)
10 | numero_complejo = 5 + 2j
11 | 
12 | print(numero_entero) #
13 | print(type(numero_entero)) # int
14 | 
15 | print(numero_decimal) #3.14
16 | print(type(numero_decimal)) #float
17 | 
18 | print(numero_complejo)  # (5+2j)
19 | print(type(numero_complejo))  # complex
20 | 
21 | ###### CASTEO
22 | 
23 | decimal_desde_entero = float(numero_entero)
24 | entero_desde_decimal = int(numero_decimal)
25 | complejo_desde_entero = complex(numero_entero)
26 | complejo_desde_decimal = complex(numero_decimal)
27 | 
28 | print(decimal_desde_entero)
29 | print(entero_desde_decimal)
30 | print(complejo_desde_entero)
31 | print(complejo_desde_decimal)
32 | 
33 | ####### RANDOM
34 | 
35 | import random
36 | 
37 | aleatorio = random.randrange(1,10) # El número de stop no es incluyente
38 | aleatorio_par = random.randrange(2,11,2) # Número par del 2 al 10 (incluído)
39 | aleatorio_impar = random.randrange(1,10,2) #Número impar del 1 al 9 (incluído)
40 | 
41 | print(aleatorio)
42 | print(aleatorio_par)
43 | print(aleatorio_impar)


--------------------------------------------------------------------------------
/tiposDatos.py:
--------------------------------------------------------------------------------
 1 | # str (string): Texto o cadena de caracteres
 2 | comillasSimples = 'Este es un texto'
 3 | comillasDobles = "Este es un texto"
 4 | comillasTriples = """Este es un texto"""
 5 | comillasTriplesSimples = '''Este es un texto'''
 6 | 
 7 | # int (Integer): Número entero
 8 | numero_entero = 1
 9 | 
10 | # float: Número decimal
11 | numero_decimal = 3.14
12 | 
13 | # complex: numero complejo (parte entera y otra parte imaginaria)
14 | numero_complejo = 5 + 2j
15 | 
16 | # list[]: Colección ordenada y mutable de elementos (cada elemento tendrá un índice)
17 | lista = [0,1,2,3,4,5,5,5]
18 | 
19 | # tuple(): Colección ordenada e inmutable de elementos (cada elemento tendrá un índice)
20 | tupla = ("a", "b", "c")
21 | 
22 | # range: Es una secuencia de números generada dentro de un rango
23 | rango = range(1,10)
24 | 
25 | # dict (dictionary){}: Colección de pares clave-valor(key-value) desordenada y mutable
26 | diccionario = {"nombre": "Sergie Code"}
27 | 
28 | # set{}: Coleccion desordenada de elementos únicos y mutables
29 | conjunto = {1,1,2,2,3}
30 | 
31 | # frozenSet([]): Colección desordenada de elemento únicos e inmutables
32 | conjunto_inmutable = frozenset([1,2,3,3,3])
33 | 
34 | # bool (booleanos): valor verdadero o falso (true/false)
35 | booleanoVerdadero = True
36 | booleanoFalso = False


--------------------------------------------------------------------------------
/condicionales.py:
--------------------------------------------------------------------------------
 1 | ### CONDICIONALES (if, elif, else)
 2 | # Es la estructura que nos permite tomar un flujo u otro según una condición
 3 | 
 4 | # La palabra reservada if es obligatoria en la estructura condicional pero elif y else son opcionales
 5 | 
 6 | a = 5
 7 | b = 9
 8 | c = 7
 9 | 
10 | if a > b: # Si cumple esta condición hace 
11 |     print(f"{a} es mayor que {b}") # estas lineas de código
12 | elif c > b: # Si no cumple la primera condición pero cumple esta realiza:
13 |     print(f"{c} es mayor que {b}") # estas otras líneas de código
14 | else: # Si no cumplió ninguna de las condiciones anteriores
15 |     print(f"{a} es menor que {b} y {c} es menor que {b}") # realiza estas últimas líneas de código
16 | 
17 | 
18 | ### Ejemplo:
19 | 
20 | # Objetivo entrar al boliche
21 | 
22 | edad = 61
23 | 
24 | if edad >= 18 and edad <= 60:
25 |     print("Puedes entrar al boliche")
26 | else: 
27 |     if edad < 18:
28 |         print("No tienes la edad suficiente para ingresar al boliche")
29 |     else:
30 |         print("Este boliche sólo admite personas hasta 60 años")
31 | 
32 | 
33 | ### SHORTHANDS
34 | 
35 | a = 5
36 | b = 2
37 | 
38 | if a > b: print(f"{a} es mayor que {b}") ## Shorthand del If solo
39 | 
40 | # Ejecución si es verdadero | condición | Ejecución si es Falso
41 | print("B es mayor que A") if b > a else print("A es mayor que B") ## Shorthand de If + Else 
42 | 
43 | 


--------------------------------------------------------------------------------
/tuplas.py:
--------------------------------------------------------------------------------
 1 | # TUPLA: colección (array) que permite almacenar múltiples elementos en una sola variable
 2 | # Característica: Colección ordenada e inmutable de elementos (cada elemento tendrá un índice)
 3 | 
 4 | # indices:       0          1        2        3           4       5
 5 | vehiculos = ("Bicicleta", "Moto", "Auto", "Camioneta", "Avion", "Barco")
 6 | 
 7 | longitud = len(vehiculos) # con len podemos saber la longitud de la tupla
 8 | tipo = type(vehiculos) # nos indica que es de tipo <class 'tuple'>
 9 | tuplaConstructor = tuple(("Esta", "es", "una", "tupla")) # con el constructur de tupla podemos iniciar una
10 | 
11 | # Acceso a través de indices:
12 | elemento1 = vehiculos[1]
13 | elemento2 = vehiculos[-4]
14 | rango = vehiculos[3:5]
15 | desdeInicio = vehiculos[:3]
16 | hastaFinal = vehiculos[3:]
17 | 
18 | # ¿Cómo puedo hacer para obtener una tupla con las características que yo necesito? [Truco para modificar tupla]
19 | 
20 | listaVehiculos = list(vehiculos) # en una nueva variable volcar la tupla como lista
21 | listaVehiculos[3] = "Camión" # hacer el cambio que queríamos hacer
22 | listaVehiculos.append("Crucero")
23 | vehiculos = tuple(listaVehiculos) # asignar a la tupla la lista modificada convertida en tupla
24 | 
25 | # Desempaquetamiento:
26 | (a,b,c,d,e,f,g) = vehiculos # se asignará cada elemento a una variable correspondiente a la posicion
27 | (bici,moto, *cuadroRuedas, avion, barco, crucero) = vehiculos # con el asterisco podemos agrupar parte del desempaquetamiento 
28 | 
29 | # Recorrer las tuplas con bucles
30 | 
31 | for vehiculo in vehiculos:
32 |     print(vehiculo)
33 | 
34 | for i in range(len(vehiculos)): # De esta forma podemos tener el índice del elemento iterable al recorrer la tupla 
35 |     print(f"{i+1}. {vehiculos[i]}")
36 | 
37 | [print(tecnologia) for tecnologia in vehiculos] # Este sería el shorthand para una impresión de tupla iterable
38 | 
39 | # Join de tuplas (unir tuplas)
40 | 
41 | citricos = ("naranja", "limon", "pomelo")
42 | tropical = ("papaya", "coco")
43 | 
44 | frutas = citricos + tropical # con esto unimos las dos tuplas en una nueva tupla
45 | 
46 | 


--------------------------------------------------------------------------------
/variables.py:
--------------------------------------------------------------------------------
 1 | # Variables:
 2 | # Es un contenedor para almacenar valores de datos.
 3 | # Este contenedor va a tener un nombre.
 4 | # Es creada la primera vez que se le asigna un valor
 5 | 
 6 | # NOMBRES ADMITIDOS DE VARIABLES
 7 | 
 8 | # 1. Puede empezar con una letra o un guión bajo (underscore)
 9 | mivariable = "texto"
10 | _mivariable = "otro texto"
11 | 
12 | # 2. No puede iniciar con un número
13 | ### 5variable = "texto"
14 | 
15 | # 3. Sólo pueden contener caracteres alfanuméricos y guiones bajos (A-z 0-9 _)
16 | miVariable123_ = "texto"
17 | _123miVariable_123 = "texto"
18 | 
19 | # 4. CaseSensitive (no solo al comienzo sino en general)
20 | 
21 | miVariable = "otro texto"
22 | MiVariable = "otro texto"
23 | 
24 | # 5. No se puede utilizar palabras reservadas de Python (keywords)
25 | 
26 | asd123 = "informacion"
27 | 
28 | #####################
29 | 
30 | # Convenciones de escritura de variables
31 | 
32 | # Camel Case
33 | camelCase = "Comienza con minúscula y cada palabra siguiente comenzará con mayúscula"
34 | 
35 | # Pascal Case
36 | PascalCase = "Comienza con mayúscula y cada palabra siguiente comenzará con mayúscula"
37 | 
38 | # Snake Case
39 | snake_case = "Se usan las palabras en minúscula y las palabras son separadas con guiones bajos"
40 | 
41 | #####################
42 | 
43 | # Multiasignación
44 | 
45 | x, y, z = 5, 7, 9
46 | a = b = c = "Sergie Code"
47 | 
48 | # Desde colecciones
49 | frutas = ["naranja", "banana", "mandarina"]
50 | m, n, o = frutas
51 | 
52 | # Uso de print y salidas:
53 | 
54 | txt = "Curso"
55 | txt2 = "de "
56 | txt3 = "Python"
57 | 
58 | num1 = 2
59 | num2 = 4
60 | num3 = 6
61 | 
62 | # Variables globales vs Variables de Scope
63 | 
64 | variableGlobal = "Esta variable va a estar disponible para todo el programa"
65 | 
66 | def funcion():
67 |     global variableDeScope
68 |     variableDeScope = "Esta variable sólo estará disponible dentro del alcance de la función"
69 |     variableGlobal = "Este valor es sólo para dentro de la función y luego recupera su valor"
70 |     print(variableGlobal)
71 |     print(variableDeScope)
72 | 
73 | funcion()
74 | 
75 | print(variableGlobal)
76 | print(variableDeScope)


--------------------------------------------------------------------------------
/operadores.py:
--------------------------------------------------------------------------------
 1 | ##### OPERADORES: símbolos que nos permitirán hacer operaciones sobre variables y valores
 2 | 
 3 | ## Operadores aritméticos (+,-,*,/,%,**,//)
 4 | 
 5 | a = 10
 6 | b = 5
 7 | 
 8 | suma = a + b
 9 | resta = a - b
10 | multiplicacion = a * b
11 | division = a / b # devuelve flotante (con decimales)
12 | floorDivision = a // b  # devuelve un entero
13 | resto = a % b # Resto de la división 
14 | exponenciacion = a ** b 
15 | 
16 | ## Operadores de asignación
17 | 
18 | x = 10 # El = es el operador de asignación más básico
19 | x += 3 # El += le suma el valor al valor anterior
20 | x -= 2 # El -= le resta el valor al valor anterior
21 | x *= 2 # El *= le multiplica el valor al valor anterior
22 | x /= 2 # El /= le dividie el valor al valor anterior
23 | x //= 2 
24 | x %= 1
25 | x **= 2
26 | 
27 | ## Operadores de comparación (nos devolverán True o False)
28 | 
29 | num1 = 6
30 | num2 = 5
31 | igualdad = num1 == num2 # Devuelve True si son iguales
32 | distintos = num1 != num2 # Devuelve True si son distintos
33 | mayor = num1 > num2 # Devuelve True si es Mayor
34 | menor = num1 < num2 # Devuelve True si es Menor
35 | mayorOIgual = num1 >= num2 # Devuelve True si es Mayor o Igual
36 | menorOIgual = num1 <= num2 # Devuelve True si es Menor o Igual
37 | 
38 | ## Operadores lógicos (and, or, not)
39 | edad = 17
40 | tramite = edad >= 18 and edad <= 65 ## Devuelve True si cumplimos las las 2 condiciones dadas
41 | semaforo = "Rojo"
42 | cruzar = semaforo == "Verde" or semaforo == "Amarillo" # Devuelve True si cumplimos al menos una de las dos condiciones
43 | verdad = True
44 | negacion = not verdad # Niega la estructura siguiente
45 | 
46 | ## Operadores de identidad (is, is not)
47 | nombre = "Sergie Code"
48 | profesor = "Sergie Code"
49 | alumno = "Pedrito"
50 | sonElMismo = nombre is profesor # Nos devuelve True si son iguales
51 | sonDistintos = profesor is not alumno # Nos devuelve True si son distintos
52 | 
53 | ## Operadores de pertencia (in, not in)
54 | palabra = "Mundo"
55 | palabra2 = "Mercurio"
56 | texto = "Hola Mundo"
57 | pertenece = palabra in texto # Nos devuelve True si pertenece
58 | noPertenece = palabra2 not in texto # Nos devuelve True si no está presente
59 | 
60 | 


--------------------------------------------------------------------------------
/diccionarios.py:
--------------------------------------------------------------------------------
 1 | # DICCIONARIO: colección (array) que permite almacenar múltiples elementos en una sola variable
 2 | # Características: Colección de pares clave-valor(key-value) desordenada y mutable
 3 | 
 4 | diccionario = {
 5 |     "nombre": "Sergie Code",
 6 |     "youtube": "www.youtube.com/@sergiecode",
 7 |     "tecnologias": ["Python", "Javascript"],
 8 |     "edad": 34,
 9 |     "direccion": {"calle": "Av Argentina", "numero": 123, "ciudad": "Londres"},
10 | }
11 | 
12 | tipo = type(diccionario) # Nos indica el tipo de dato <class 'dict'>
13 | longintud = len(diccionario) # Nos indica la cantidad de claves-valor que tiene el diccionario
14 | contructorDiccionario = dict(nombre = "Sergie Code", youtube = "www.youtube.com/@sergiecode") # Se puede crear con constructor
15 | 
16 | # ¿Cómo accedo a cada propiedad?
17 | 
18 | nombre = diccionario["nombre"]
19 | youtube = diccionario.get("youtube")
20 | keys = diccionario.keys() # el tipo de dato que devuelve se llama <class 'dict_keys'>
21 | values = diccionario.values() # el tipo de dato que devuelve se llama <class 'dict_values'>
22 | 
23 | items = diccionario.items() # nos devuelve tuplas de clave-valor en una lista // <class 'dict_items'>
24 | 
25 | # if "tecnologias" in diccionario: # Con esto podemos comprobar si una key existe pero no un valor
26 | #     print("Sí, existe esta key")
27 | 
28 | # CAMBIO de valores en un diccionario
29 | 
30 | diccionario["tecnologias"] = ['Python', 'JavaScript', 'Java', 'Node']
31 | diccionario.update({"direccion": {"calle": "Liverpool Street", "numero": 123, "ciudad": "Londres"},})
32 | 
33 | # AGREGAR ITEMS:
34 | 
35 | diccionario["profesion"] = "Programador"
36 | diccionario.update({ 'Comida Favorita': ' Milanesa'})
37 | 
38 | # ELIMINAR ITEMS:
39 | 
40 | diccionario.pop("Comida Favorita") # Eliminar un elemento puntual
41 | diccionario.popitem() # Eliminaría última característica agregada
42 | del diccionario["edad"]
43 | diccionario.clear() # esto deja vacío el diccionario
44 | 
45 | # BUCLES (LOOPS ) para diccionarios:
46 | 
47 | curso_python = {
48 |     "nombre": "Python desde Cero",
49 |     "duracion": 6,
50 |     "dificultad": "media",
51 | }
52 | 
53 | # for key in curso_python: # el bucle for común hará un recorrido de las keys
54 | #     print(f"{key.capitalize()}: {curso_python[key]}")
55 | 
56 | # for values in curso_python.values(): # este bucle recorrerá solo los valores
57 | #     print(values)
58 | 
59 | # for key, value in curso_python.items(): #desempaqueto la tupla de cada uno de los elementos de la lista que devuelve items
60 | #     print(key, value)
61 | 
62 | # COPIAS de diccionarios:
63 | 
64 | copia = curso_python.copy() #copia exacta pero apuntando a otra dirección de memoria
65 | copia2 = dict(curso_python) #copia usando constructor
66 | 
67 | # DICCIONARIOS ANIDADOS:
68 | 
69 | hijo1 = {
70 |     "nombre" : "Pedro",
71 |     "edad" : 5
72 | }
73 | hijo2 = {
74 |     "nombre" : "Alan",
75 |     "edad" : 7
76 | }
77 | hijo3 = {
78 |     "nombre" : "Enzo",
79 |     "edad" : 9
80 | }
81 | 
82 | familia = {
83 |     "hijo1": hijo1,
84 |     "hijo2": hijo2,
85 |     "hijo3": hijo3,
86 | }
87 | 
88 | nombreHijo1 = familia["hijo1"]["nombre"]
89 | 
90 | for x,obj in familia.items():
91 |     print(x)
92 |     for y in obj:
93 |         print(f"{y.capitalize()}: {obj[y]}")


--------------------------------------------------------------------------------
/strings.py:
--------------------------------------------------------------------------------
 1 | ####### STRING (Cadena de texto)
 2 | texto = "Este es un curso de Python por Sergie Code"
 3 | 
 4 | # str (string): Texto o cadena de caracteres
 5 | comillasSimples = 'Este es un texto'
 6 | comillasDobles = "Este es un texto"
 7 | comillasTriples = """Este es un texto"""
 8 | comillasTriplesSimples = '''Este es un texto'''
 9 | 
10 | ###### TYPE
11 | print(type(comillasSimples))
12 | 
13 | ###### Arrays de caracteres
14 | caracter = texto[4] # Podemos seleccionar un caracter por índice
15 | print(caracter)
16 | 
17 | # Len (Length) (Saber el largo)
18 | amplitud = len(texto)
19 | print(amplitud)
20 | 
21 | # In: para saber si está incluído algo en el texto
22 | print("Python" in texto) # devuelve un True o False según corresponda
23 | 
24 | # Not in : con la palabra reservada not podemos negar y pedir un resultado negativo
25 | print("JavaScript" not in texto) # devuelve un True o False según corresponda
26 | 
27 | # Slice (cortar) una parte del texto
28 | print(texto[11:16]) # Se imprimirá el fragmento que vaya desde el índice 11 al 16 (no incluído)
29 | print(texto[:5]) # Se imprimirá el fragmento que vaya desde el comienzo al índice 5 (no incluído)
30 | print(texto[38:]) # Se imprimirá el fragmento que vaya desde el índice 38 hasta el final
31 | print(texto[-4:]) # Se imprimirá el fragmento que vaya desde 4 índices antes del final hasta el final
32 | print(texto[:-37]) # Se imprimirá el fragmento desde el comienzo hasta el final 37 caracteres antes del final
33 | 
34 | # Modificadores de texto (mayúsculas, minúsculas, etc)
35 | texto_con_espacios = "          hola mundo       "
36 | texto_con_comas = "No/ se/ olviden/ de/ suscribirse"
37 | 
38 | mayusculas = texto.upper() # Obtendré el texto en mayúsculas
39 | minusculas = texto.lower() # Obtendré el texto en minúsculas
40 | sin_espacios = texto_con_espacios.strip() # Eliminará los espacios del comienzo y el final
41 | reemplazo = texto_con_espacios.replace("mundo", "universo") # Reeamplazará mundo por universo
42 | separar_por_comas = texto_con_comas.split("/") # Separará el texto por comas y nos devolverá una lista
43 | 
44 | # Métodos más usados
45 | texto_a_modificar = "este es UN texto A MODIFICAR"
46 | capitalizado = texto_a_modificar.capitalize() # Sólo quedará la primera letra como mayúscula
47 | estaComenzando = texto_a_modificar.startswith("este")
48 | estaFinalizando = texto_a_modificar.endswith("MODIFICAR")
49 | titulo = texto_a_modificar.title() # Pone en mayúscula cada palabra
50 | contador = texto_a_modificar.count("e") # Cuantas veces aparece la e en el texto
51 | encontrador = texto_a_modificar.find("texto") # Nos devuelve el índice donde comienza la palabra buscada
52 | 
53 | # Concatenar
54 | a = "Hola"
55 | b = "Mundo"
56 | c = a + " " + b
57 | print(c) # Imprimirá concatenado
58 | 
59 | # F-Strings (template strings)
60 | num = 5
61 | nombre = "Pedrito"
62 | variable = "edad"
63 | txt = f"La {variable} de {nombre} es de {num:.2f}" # Nos permite utilizar variables en texto y formatearlas
64 | 
65 | resultado = f"El resultado de 69 x 75 es {69*75}"
66 | 
67 | # Escapes \ (backslash - barra invertida)
68 | escape = "Mi país favorito es \"Lituania\" por que me dio la ciudadanía europea"
69 | directorio = "El directorio donde está almacenado mi mayor secreo es c:\\secreto\\archivo.txt"
70 | salto_de_linea = "Quiero hacer un \nsalto de linea"
71 | 
72 | 


--------------------------------------------------------------------------------
/funciones.py:
--------------------------------------------------------------------------------
  1 | # Función es un bloque de código autónomo que se ejecuta cuando lo llamamos
  2 | # Nos va a servir para atomizar y reutilizar código optimizando el mismo
  3 | 
  4 | # Parámetros son la lista de variables dentro de los paréntesis
  5 | # Argumentos son los valores que le enviamos a la función cuando es llamada
  6 | 
  7 |              # parámetros = variables
  8 | def funcion(profesor, curso, femenino):
  9 |     profesion = "el profesor"
 10 |     if femenino:
 11 |         profesion = "la profesora"
 12 |     print(f"El curso de {curso} lo dará {profesion} {profesor}")
 13 | 
 14 |           # Argumetos = valores
 15 | funcion("Sergie Code", "Python desde Cero", False)
 16 | funcion("Pedrito", "Cocina", False)
 17 | funcion("Marina", "Manejo", True)
 18 | funcion("Mercedes", "Bajo", True)
 19 | 
 20 | # Variables por defecto / Esto nos dará la posibilidad de NO enviar ese argumento (opcional)
 21 | 
 22 | def decir_pais(pais = "Argentina"):
 23 |     print(f"El nombre de mi país es {pais}")
 24 | 
 25 | decir_pais("México")
 26 | decir_pais()
 27 | 
 28 | # Retornar valores
 29 | 
 30 | def suma(a,b):
 31 |     return a + b
 32 | def resta(a,b):
 33 |     return a - b
 34 | def multiplicacion(a,b):
 35 |     return a * b
 36 | def division(a,b):
 37 |     return a // b
 38 | 
 39 | resultado_suma = suma(3,2)
 40 | resultado_resta = resta(5,3)
 41 | resultado_multiplicacion = multiplicacion(5,5)
 42 | resultado_division = division(10,2)
 43 | 
 44 | print(resultado_suma)
 45 | print(resultado_resta)
 46 | print(resultado_multiplicacion)
 47 | print(resultado_division)
 48 | 
 49 | # Argumentos Arbitrarios (mandar múltiples argumentos según dependa)
 50 | # Hay que tener cuidado de que esté bien manejado para no dar errores
 51 | 
 52 | def llamar_alumnos(*alumnos):
 53 |     print(f"Mi mejor alumno es {alumnos[0]}")
 54 |     print(f"Mi alumna más divertida es {alumnos[2]}")
 55 | 
 56 | llamar_alumnos("Ricardo", "Antonieta", "Beatriz", "Lionel")
 57 | 
 58 | # Argumento clave / key arguments
 59 | 
 60 | def cursos(curso1, curso2, curso3):
 61 |     print(f"El primer curso que daré será el de {curso1}")
 62 |     print(f"el siguiente será el curso de {curso2}")
 63 |     print(f"y para finalizar daré el curso de {curso3}")
 64 | 
 65 | cursos(curso3 = "Java", curso2 = "CSS", curso1 = "HTML") # Indicaremos a que paráemtro corresponde cada argumento
 66 | 
 67 | # Argumentos claves arbitrarios
 68 | 
 69 | def llamar_alumno(**alumno):
 70 |     print(f"El apellido del alumno es {alumno["apellido"]}, y su nombre es {alumno["nombre"]}")
 71 | 
 72 | llamar_alumno(apellido = "Perez", nombre = "Tobías", edad = 34)
 73 | 
 74 | 
 75 | # Otros tipos de datos que podríamos pasar:
 76 | 
 77 | lista = ['JavaScript', 'Python', True, 65]
 78 | number = 33
 79 | 
 80 | def usar_tipos_de_datos(lista, number):
 81 |     print(lista)
 82 |     print(number)
 83 | 
 84 | usar_tipos_de_datos(lista, number)
 85 | 
 86 | # Recursión (recursividad) de una función [Se puede considerar en cierta forma un bucle]
 87 | 
 88 | # Ejemplo del factorial 
 89 | # 0! = 1
 90 | # n! = n * (n-1) para n > 0
 91 | 
 92 | def factorial(n):
 93 |     # Caso base 0! = 1
 94 |     if n == 0:
 95 |         return 1
 96 |     else:
 97 |         return n * factorial(n-1)
 98 | 
 99 | numero = 3
100 | print(f"El factorial de {numero} es {factorial(numero)}")


--------------------------------------------------------------------------------
/listas.py:
--------------------------------------------------------------------------------
 1 | # LISTAS: colección (array) que permite almacenar múltiples elementos en una sola variable
 2 | # Características: ordenada (podemos ingresar a un elemento por índice) y es mutable
 3 | 
 4 | # indices:     0         1        2        3
 5 | frutas = ["Naranja", "Manzana", "Pera", "Pera"]  # Permite duplicados
 6 | longitud = len(frutas)  # saber la cantidad de elementos que
 7 | 
 8 | listaStrings = ["alfa", "beta", "gamma"]
 9 | listaNumbers = [0, 1, 2, 3, 4]
10 | listaBooleans = [True, True, False]
11 | listaMixta = ["alfa", 1, False]
12 | 
13 | tipo = type(listaBooleans) # Esto nos indicará  que tipo de datos es: "list"
14 | 
15 | listaDesdeConstructor = list(('Beta', 2, True)) # Hay que utilizar el constructor list y doble paréntesis
16 | 
17 | # Acceder a los datos:
18 | 
19 | naranja = frutas[0]
20 | parteLista = frutas[1:3] # Desde el 1(manzana) hasta el 3 (no inclusive)
21 | desdeComienzo = frutas[:-2] # Desde el comienzo hasta el dos no inclúido
22 | hastaFinal = frutas[2:] # Desde el dos hasta el final
23 | 
24 | # Verificar si existe un elemento
25 | 
26 | if "Manzana" in frutas: # Utilizando la palabra "in" podemos saber si un elemento está presente
27 |     print("Sí, está incluído")
28 | 
29 | # Como cambiar los datos de la lista
30 | # indices:        0          1        2         3         4 
31 | tecnologias = ['Python', 'Django', 'Flask', 'ReactPy', 'Pandas']
32 | 
33 | tecnologias[3] = 'TensoFlow' # Reemplazar el elemento de un índice particular
34 | tecnologias[2:4] = ['NumPy', 'Scrapy'] # Reemplazar una parte de la lista
35 | 
36 | # Agregar elementos:
37 | tecnologias.insert(2, 'Flask') # Insertar un nuevo elemento en un índice específico
38 | tecnologias.append('TensorFlow') # Agregamos un elemento nuevo al final de la lista
39 | 
40 | frontend = ('Angular', 'React', 'Vue')
41 | tecnologias.extend(frontend) # Agregar cualquier tipo de colección a un lista (fusión)
42 | 
43 | # Quitar elementos:
44 | tecnologias.remove('Vue') # Se remueve el elemneto que coincida con lo que pasemos como argumetno
45 | tecnologias.pop() # Podemos eliminar un elemento de un índice específico y si no especificamos se eliminará el último
46 | del tecnologias[7] # Usando la palabra del podemos especificar el elemento a eliminar
47 | 
48 | listaABorrar = ['Python', 'Django', 'Flask', 'ReactPy', 'Pandas']
49 | listaABorrar.clear() # Vaciaría la lista
50 | 
51 | # Recorrer listas 
52 | 
53 | for tecnologia in tecnologias:
54 |     print(tecnologia)
55 | 
56 | for i in range(len(tecnologias)): # De esta forma podemos tener el índice del elemento iterable al recorrer la lista
57 |     print(f"{i+1}. {tecnologias[i]}")
58 | 
59 | [print(tecnologia) for tecnologia in tecnologias] # Este sería el shorthand para una impresión de lista iterable
60 | 
61 | # Ejemplo práctico:
62 | 
63 | listaConY = []
64 | 
65 | for tecnologia in tecnologias:
66 |     if "y" in tecnologia:
67 |         listaConY.append(tecnologia)
68 | #              lo que se agrega  |  el bucle                    | la condición
69 | lista2conY = [tecnologia.upper() for tecnologia in tecnologias if "y" in tecnologia] # Shorthand del ejemplo de arriba
70 | 
71 | # Ordenar una lista:
72 | tecnologias.sort() # En caso de no especificar ordenara alfabéticamente o de forma asc
73 | numeros = [7,9,5,3,8,6,4,2]
74 | numeros.sort(reverse=True) # En este caso ordenara de forma DESC
75 | tecnologias.reverse() # Ordenar exactamente al revés tal cual estaba la lista
76 | 
77 | # Copiar una lista:
78 | 
79 | meses = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo']
80 | meses2 = ['Junio','Julio','Agosto','Septiembre']
81 | copiaMeses = meses.copy()
82 | copiaMeses2 = list(meses) # usando el costructor
83 | 
84 | joinMeses = meses + meses2 # Podemos juntar la listas (JOIN) utilizando el símbolo +
85 | meses.extend(meses2) # Junta las dos listas en la lista mencionada
86 | 


--------------------------------------------------------------------------------
/sets.py:
--------------------------------------------------------------------------------
 1 | # SETS: colección (array) que permite almacenar múltiples elementos en una sola variable
 2 | # Características: coleccion desordenada de elementos únicos (no ordenados)
 3 | # * Se pueden agregar y eliminar elementos pero los elemetos nos son "cambiables" ya que no tienen un orden
 4 | 
 5 | conjunto = {1, 1, 2, 2, 3}  # los elementos que estén duplicados serán omitidos
 6 | 
 7 | longitud = len(conjunto)  # la longitud o cantidad de elmentos del conjunto (no tomará en cuenta los duplicados)
 8 | tipo = type(conjunto)  # para saber el tipo <class 'set'>
 9 | conjuntoConstructor = set(("Este", "es", "un", "conjunto")) # creamos un conjunto usando el contructor
10 | 
11 | # if "conjunto" in conjuntoConstructor: # podemos usar IN para saber si un elemento está presente
12 | #     print("Sí está la palabra")
13 | 
14 | # if "Python" not in conjuntoConstructor: # not in para saber si un elemento no está presente
15 | #     print("Python no se encuentra en el conjunto")
16 | 
17 | # Agregar elementos a un conjunto (SET)
18 | 
19 | telefonos = {'Xiaomi', 'Samsung', 'Motorola'}
20 | telefonos2 = ['Huawei', 'OnePlus', 'Nokia', 'Xiaomi' ] #puede ser cualquier colección
21 | 
22 | telefonos.add("Iphone") # Agregar un elemento
23 | 
24 | telefonos.update(telefonos2) # Con update sumamos otra colección(puede ser cualquier colección) a nuestro conjunto
25 | 
26 | # Eliminar elementos (al no tener órden especifico hay que tener mucho cuidado en el borrado)
27 | 
28 | autos = { 'Ford', 'Peugeot', 'Fiat', 'Renault', 'Ferrari' }
29 | 
30 | autos.remove('Ferrari') # Se borra un elemento que coincida exactamente con lo pasado por argumento (Da un error si no existe)
31 | autos.discard('Fiat') # Se borra un elemento que coincida exactamente con lo pasado por argumento (no da un error si no existe)
32 | 
33 | autos.pop() # Eliminará uno de forma aleatoria
34 | 
35 | autos.clear() # borrar todos los elementos presentes en el conjunto
36 | 
37 | # Recorrer los elementos con bucles
38 | 
39 | # tecnologias = { 'Python', 'C#', 'Java', 'Node'}
40 | 
41 | # for tecnologia in tecnologias:
42 | #     print(tecnologia)
43 | 
44 | # [print(tecnologia) for tecnologia in tecnologias] # Este sería el shorthand para una impresión de conjunto iterable
45 | 
46 | 
47 | # Join de conjuntos (Teoría de conjuntos de la matemática)
48 | 
49 | a = {1,2,3,4,5}
50 | b = {1,3,5,7,9}
51 | 
52 | booleanos = {True, False}
53 | 
54 | # Union: devuelve todos los elementos de ambos conjuntos  (a diferencia del update no modifica el conjunto original)
55 | u = a.union(b) # acepta varias colecciones (pueden ser listas o tuplas)
56 | u2 = a | b # es exactamente lo mismo que usar union
57 | 
58 | # a.update(b) # update modifica el conjunto original
59 | 
60 | # Intersección: va a devolver los elementos que tengan en común ambos conjuntos
61 | i = a.intersection(b)
62 | i2 = a & b # esto es exactamente lo mismo que usar intersection
63 | 
64 | # a.intersection_update(b) # Intersection update modifica el conjunto original
65 | 
66 | # Comportamiento con booleanos:
67 | booleanos_union = a.union(booleanos) # True y 1 se consideran el mismo valor por lo cual solo se agregará False
68 | booleanos_intersection = a.intersection(booleanos) # La única intersección es True ya que se considera igual a 1
69 | 
70 | # Diferencias: devolver los elementos del primer conjunto que no estén presentes en el otro conjunto
71 | 
72 | d1 = a.difference(b)
73 | d2 = a - b # es exactamente lo mismo que usar difference
74 | 
75 | # a.difference_update(b) # Difference update modifica el conjunto original
76 | 
77 | # Diferencia simétrica: developer los elementos que no estén presentes en ambos conjuntos
78 | 
79 | ds1 = a.symmetric_difference(b)
80 | ds2 = a ^ b # es exactamente igual que usar symmetric_difference
81 | 
82 | # a.symmetric_difference_update(b) # symmetric difference update modifica el conjunto original
83 | 
84 | 


--------------------------------------------------------------------------------