├── Pruebas
├── holaMundo.py
├── listaPalabrotas.txt
├── palabrotas.py
├── mulMatrices.py
└── pruebas.py
├── Imagenes
├── Input.png
└── MisionTic_Clase1.jpg
├── RetosUNAL
├── P21
│ ├── reto5
│ │ ├── 5P21.docx
│ │ └── libros.py
│ ├── problemas_Clase
│ │ ├── files
│ │ │ ├── notas.Json
│ │ │ ├── persona1.Json
│ │ │ ├── persona2.Json
│ │ │ ├── newJSON.Json
│ │ │ └── EstructuraJSON.Json
│ │ ├── sesion18.py
│ │ ├── sesion23.py
│ │ └── sesion19.py
│ ├── reto_3
│ │ ├── Descripción.md
│ │ └── conteoModelos.py
│ ├── reto_4
│ │ ├── catalogoComputo.py
│ │ └── Descripción.md
│ ├── reto_1
│ │ └── reto1_Ingrid.py
│ ├── ejercicios_Ingrid.py
│ ├── reto_2
│ │ └── reto2_Ingrid.py
│ └── retox_Ingrid.py
├── P37
│ ├── reto-3
│ │ ├── enunciado.PNG
│ │ └── reto3.py
│ └── reto-4
│ │ ├── enunciado.PNG
│ │ └── reto4.py
├── P30
│ ├── reto_4
│ │ ├── solucion1.py
│ │ └── README.org
│ ├── reto_2
│ │ ├── solucion1.py
│ │ └── README.org
│ ├── reto_1
│ │ ├── solucion1.py
│ │ └── README.org
│ ├── reto_3
│ │ ├── solucion1.py
│ │ └── README.org
│ ├── reto_5
│ │ ├── solucion_1.py
│ │ └── README.org
│ └── README.org
├── P83
│ ├── reto-4
│ │ ├── solucion2.py
│ │ ├── solucion1.py
│ │ └── Readme.md
│ ├── reto-2
│ │ ├── solucion2.py
│ │ ├── solucion1.py
│ │ └── Readme.md
│ ├── reto-3
│ │ ├── solucion2.py
│ │ ├── solucion1.py
│ │ └── Readme.md
│ ├── reto-1
│ │ ├── solucion1.py
│ │ ├── solucion2.py
│ │ └── Readme.md
│ └── reto-5
│ │ ├── solucion1.py
│ │ └── Readme.md
├── P81
│ └── reto-4
│ │ ├── solucion1.py
│ │ └── README.md
├── P2
│ ├── reto4.py
│ ├── reto2.py
│ ├── reto3.py
│ └── reto1.py
└── laboratorio_de_pruebas.py
├── .vscode
└── settings.json
├── NotasDeClase
├── problemas.py
└── general.py
├── RetoMisionTic
├── holaMisionTic.py
├── UNorte.py
└── nodulosTiroideos.py
└── README.md
/Pruebas/holaMundo.py:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/Imagenes/Input.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ingrid-E/MisionTic2022-Ciclo1/HEAD/Imagenes/Input.png
--------------------------------------------------------------------------------
/Imagenes/MisionTic_Clase1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ingrid-E/MisionTic2022-Ciclo1/HEAD/Imagenes/MisionTic_Clase1.jpg
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto5/5P21.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ingrid-E/MisionTic2022-Ciclo1/HEAD/RetosUNAL/P21/reto5/5P21.docx
--------------------------------------------------------------------------------
/RetosUNAL/P37/reto-3/enunciado.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ingrid-E/MisionTic2022-Ciclo1/HEAD/RetosUNAL/P37/reto-3/enunciado.PNG
--------------------------------------------------------------------------------
/RetosUNAL/P37/reto-4/enunciado.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ingrid-E/MisionTic2022-Ciclo1/HEAD/RetosUNAL/P37/reto-4/enunciado.PNG
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/files/notas.Json:
--------------------------------------------------------------------------------
1 | {
2 | "Munira":[1.0,2.0,3.0,3.5,5],
3 | "Lissa":[2.0,3.0,3.0,4.5,5],
4 | "Darrell":[4.0,4.0,5.0,5,5],
5 | "Carmen":[3.0,2.0,1.0,2.5,1.5]
6 | }
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/files/persona1.Json:
--------------------------------------------------------------------------------
1 | {
2 | "nombre":"Jonh Doe",
3 | "profesion":"Programador",
4 | "edad":25,
5 | "lenguajes":["PHP","Javascript","Dart"],
6 | "disponibilidadParaViajar":true,
7 | "rangoProfesional": {
8 | "aniosDeExperiencia": 12,
9 | "nivel": "Senior"
10 | }
11 | }
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/files/persona2.Json:
--------------------------------------------------------------------------------
1 | {
2 | "nombre":"Sarah Lee",
3 | "profesion":"Programador",
4 | "edad":20,
5 | "lenguajes":["Java","C++","Javascript"],
6 | "disponibilidadParaViajar":true,
7 | "rangoProfesional": {
8 | "aniosDeExperiencia": 12,
9 | "nivel": "Semi-Senior"
10 | }
11 | }
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/files/newJSON.Json:
--------------------------------------------------------------------------------
1 | {
2 | "Futbol": [
3 | "jadiazcoronado"
4 | ],
5 | "Ajedrez": [
6 | "jadiazcoronado",
7 | "dmlunasol"
8 | ],
9 | "Gimnasia": [
10 | "jadiazcoronado",
11 | "dmlunasol"
12 | ],
13 | "Baloncesto": [
14 | "dmlunasol"
15 | ]
16 | }
--------------------------------------------------------------------------------
/RetosUNAL/P37/reto-4/reto4.py:
--------------------------------------------------------------------------------
1 | import json
2 |
3 | productos: dict = json.loads(input())
4 | requeridos = (input()).split()
5 | encontrados = []
6 | total = 0
7 |
8 | for producto in requeridos:
9 | if producto in productos:
10 | total += productos[producto]
11 | encontrados.append(producto)
12 |
13 | print(total)
14 | print(' '.join(encontrados))
15 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_4/solucion1.py:
--------------------------------------------------------------------------------
1 | # Author: [Gabriel Morales](https://github.com/xgabrielmorales)
2 |
3 | import json
4 |
5 | lista_plaza = json.loads(input())
6 | lista_ingre = input().replace(" ", "")
7 |
8 | suma, ingre_dispo = int(), str()
9 |
10 | for ingre in lista_ingre:
11 | if ingre in lista_plaza:
12 | suma += lista_plaza[ingre]
13 | ingre_dispo += f"{ingre} "
14 |
15 | print(suma)
16 | print(ingre_dispo)
17 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_2/solucion1.py:
--------------------------------------------------------------------------------
1 | # Author: [Gabriel Morales](https://github.com/xgabrielmorales)
2 |
3 | J, K = input(), input()
4 | letters = input()
5 |
6 | J_points, K_points = int(), int()
7 |
8 | for letter in letters:
9 | J_points += 1 if letter in J else 0
10 | K_points += 1 if letter in K else 0
11 |
12 | # Tricotomía
13 | if J_points < K_points: print("K", end="")
14 | if J_points == K_points: print("L", end="")
15 | if J_points > K_points: print("J", end="")
16 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_1/solucion1.py:
--------------------------------------------------------------------------------
1 | # Author: [Gabriel Morales](https://github.com/xgabrielmorales)
2 |
3 | IV = int(input())
4 |
5 | f1 = lambda x : round(x)
6 | f2 = lambda x : (2 * x) + 4
7 | f3 = lambda x, y : (x + y) // 5
8 |
9 | FR1 = f1(IV)
10 | FR2 = f2(FR1)
11 | FR3 = f3(FR1, FR2)
12 |
13 | print(f"{FR1} {FR2} {FR3}")
14 |
15 | if ( 0 <= FR3 <= 20): print("uno")
16 | if (21 <= FR3 <= 30): print("dos")
17 | if (31 <= FR3 <= 50): print("tres")
18 | if (FR3 > 50): print("Cuatro")
19 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-4/solucion2.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @blasanti258
3 | Github: @santigp258
4 | """
5 | import json
6 |
7 | entrada1 = input()
8 | entrada2 = input()
9 |
10 |
11 | def calculate(catalogo, fichas):
12 | fichas = fichas.split(" ")
13 | catalogo= json.loads(catalogo)
14 | total = 0
15 | fichas_pend = []
16 | for x in fichas:
17 | if x in catalogo:
18 | fichas_pend.append(x)
19 | total += catalogo[x]
20 | print(f"{total}\n {' '.join(str(e) for e in fichas_pend)}")
21 |
22 |
23 | calculate(entrada1, entrada2)
--------------------------------------------------------------------------------
/RetosUNAL/P37/reto-3/reto3.py:
--------------------------------------------------------------------------------
1 | # Antonio Gonzalez Restrepo - github.com/antorpo/
2 |
3 | cadena = (input()).split()
4 | resultados = []
5 | cuenta = 0
6 |
7 | for i in range(len(cadena)):
8 |
9 | if i == 0:
10 | resultados.append([cadena[i], 1])
11 | elif resultados[cuenta][0] == cadena[i]:
12 | resultados[cuenta][1] += 1
13 | else:
14 | resultados.append([cadena[i], 1])
15 | cuenta += 1
16 |
17 | simbolos = ' '.join(x[0] for x in resultados)
18 | frecuencia = ' '.join(str(x[1]) for x in resultados)
19 |
20 | print(simbolos)
21 | print(frecuencia)
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-4/solucion1.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @g1_alexander
3 | Github: @g1alexander
4 | """
5 |
6 | import json
7 |
8 | entrada1 = input()
9 | entrada2 = input()
10 |
11 |
12 | def jet(catalogo, laminas):
13 | laminas_count = 0
14 | laminas_jet = ""
15 | catalogo = json.loads(catalogo)
16 | laminas = laminas.split(" ")
17 | for lamina in laminas:
18 | if lamina in catalogo:
19 | laminas_jet += f"{lamina} "
20 | laminas_count += catalogo[lamina]
21 | print(f"""{laminas_count}
22 | {laminas_jet[:-1]}""")
23 |
24 |
25 | jet(entrada1, entrada2)
26 |
--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | "cSpell.language": ",es",
3 | "cSpell.words": [
4 | "AXDDMNMCSSDFMPBLNBPHRANB",
5 | "Back",
6 | "Dias",
7 | "Echeverri",
8 | "Equilatero",
9 | "Ingrid",
10 | "KLMNP",
11 | "Montoya",
12 | "Tuplas",
13 | "categoria",
14 | "composicion",
15 | "ecogenicidad",
16 | "floculante",
17 | "interes",
18 | "numeros",
19 | "palindroma",
20 | "palindromo",
21 | "pepito",
22 | "while",
23 | "zeros"
24 | ],
25 | "python.formatting.provider": "yapf"
26 | }
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/files/EstructuraJSON.Json:
--------------------------------------------------------------------------------
1 | {
2 | "jadiazcoronado": {
3 | "nombres": "Juan Antonio",
4 | "apellidos": "D ́ıaz Coronado",
5 | "edad": 19,
6 | "colombiano": true,
7 | "deportes": [
8 | "Futbol",
9 | "Ajedrez",
10 | "Gimnasia"
11 | ]
12 | },
13 | "dmlunasol": {
14 | "nombres": "Dorotea Maritza",
15 | "apellidos": "Luna Sol",
16 | "edad": 25,
17 | "colombiano": false,
18 | "deportes": [
19 | "Baloncesto",
20 | "Ajedrez",
21 | "Gimnasia"
22 | ]
23 | }
24 | }
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-2/solucion2.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @blasanti258
3 | Github: @santigp258
4 | """
5 | JUNIOR = input("Junior \n")
6 | KATERINE = input("Katerine \n")
7 | CUENTA = input("Apellidos \n")
8 |
9 | count_JUN = 0
10 | count_KAT = 0
11 | final_string = ""
12 |
13 | for i in CUENTA:
14 | if i in JUNIOR:
15 | count_JUN = count_JUN + 1
16 | if i in KATERINE:
17 | count_KAT = count_KAT + 1
18 | if (count_JUN > count_KAT):
19 | final_string = final_string + "J"
20 | elif (count_KAT > count_JUN):
21 | final_string = final_string + "K"
22 | else:
23 | final_string = final_string + "L"
24 |
25 | print(final_string)
--------------------------------------------------------------------------------
/Pruebas/listaPalabrotas.txt:
--------------------------------------------------------------------------------
1 | Atolondrado
2 | Atulampado
3 | Baboso
4 | Balurdo
5 | Bazofia
6 | Bobalicón
7 | Bobalicon
8 | Bobo
9 | Cacorro
10 | Cochino
11 | Corroncho
12 | Coscorria
13 | Calienta huevos
14 | Cara e monda
15 | Fufa
16 | Fufurufa
17 | Garbimba
18 | Gonorrea
19 | Gonorriento
20 | Guache
21 | Guaricha
22 | Guisa
23 | Guiso
24 | Gurrupleta
25 | Hijueputa
26 | Hueputa
27 | HP
28 | Hueva
29 | Weva
30 | Idiota
31 | Imbécil
32 | Imbecil
33 | Lambón
34 | Lambon
35 | Lerdo
36 | Mamerto
37 | Malparido
38 | Mierda
39 | Maricon
40 | Manco
41 | Mediocre
42 | Ñero
43 | Nero
44 | Pendejo
45 | Pendeja
46 | Perra
47 | Pichurria
48 | Pirobo
49 | Piroba
50 | Sapo
51 | Tontarron
52 | Zorra
53 | Zuripanta
--------------------------------------------------------------------------------
/Pruebas/palabrotas.py:
--------------------------------------------------------------------------------
1 | palabrotas = []
2 | i = 0
3 |
4 | with open('listaPalabrotas.txt', mode = 'r') as lista_Palabrotas:
5 | for palabra in lista_Palabrotas.readlines():
6 | palabrotas.append(palabra.strip('\n').upper())
7 | palabrotas = tuple(palabrotas)
8 |
9 | def contienePalabrota(texto):
10 | comentario = texto.split(' ')
11 | palabrota = False
12 | for palabra in comentario:
13 | if palabra.upper() in palabrotas:
14 | palabrota = True
15 | if palabrota:
16 | print("Tu texto a sido censurado por contener una palabra ofensiva")
17 | else:
18 | print(texto)
19 |
20 | contienePalabrota("Esto es una mierda")
21 |
22 |
23 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_3/solucion1.py:
--------------------------------------------------------------------------------
1 | # Author: [Gabriel Morales](https://github.com/xgabrielmorales)
2 |
3 | register = input().replace(" ", "")
4 | reporte, num_reporte = str(), str()
5 | contador = -1
6 |
7 | def crear_reporte(cliente, num_ingresos):
8 | global reporte, num_reporte
9 | reporte += f"{cliente} "
10 | num_reporte += f"{num_ingresos} "
11 |
12 | for index in range(len(register)):
13 | if index == len(register) - 1:
14 | crear_reporte(register[index], index - contador)
15 | break
16 | if register[index] != register[index + 1]:
17 | crear_reporte(register[index], index - contador)
18 | contador = index
19 |
20 | print(reporte)
21 | print(num_reporte)
22 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-3/solucion2.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @blasanti258
3 | Github: @santigp258
4 | """
5 |
6 | CADENA = input("ingrese una cadena\n").replace(" ", "")
7 | cad = ""
8 | count_cad = ""
9 | count = 0
10 | for index in range(len(CADENA)):
11 | if (CADENA[index] not in cad):
12 | cad = cad + " " + CADENA[index]
13 | elif (CADENA[index - 1] != CADENA[index]):
14 | cad = cad + " " + CADENA[index]
15 | if (CADENA[index - 1] == CADENA[index]):
16 | count += 1
17 | else:
18 | if (count != 0):
19 | count_cad = count_cad + " " + str(count)
20 | count = 1
21 | if (index + 1 == len(CADENA)):
22 | count_cad = count_cad + " " + str(count)
23 |
24 | print(f"{cad}\n{count_cad}")
--------------------------------------------------------------------------------
/RetosUNAL/P81/reto-4/solucion1.py:
--------------------------------------------------------------------------------
1 | import json
2 |
3 | catalogue = '{"312": 1230, "94": 1545, "50": 1378, "360": 2240, "1": 1228, "37": 2009, "240": 1493}'
4 | stickers = '312 5 57 82 500 37 1'
5 |
6 | # catalogue = str(input())
7 | # stickers = str(input())
8 |
9 | def searchStickers(catalogue, stickersNeeded):
10 | price = 0
11 | stickersFound = []
12 |
13 | catalogue = json.loads(catalogue)
14 | stickersNeeded = stickersNeeded.split(' ')
15 |
16 | for sticker in stickersNeeded:
17 | if sticker in catalogue:
18 | price += catalogue[sticker]
19 | stickersFound.append(sticker)
20 |
21 | return price, stickersFound
22 |
23 | price, stickersFound = searchStickers(catalogue, stickers)
24 |
25 | print(price)
26 | print(' '.join(stickersFound))
27 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-3/solucion1.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @g1_alexander
3 | Github: @g1alexander
4 | """
5 |
6 | cadena = input()
7 | cadena = cadena.split(" ")
8 | newcadena = []
9 | countList = []
10 | count = 0
11 |
12 | for n in range(len(cadena)):
13 | if cadena[n] not in newcadena:
14 | newcadena.append(cadena[n])
15 | elif cadena[n - 1] != cadena[n]:
16 | newcadena.append(cadena[n])
17 |
18 | if cadena[n - 1] == cadena[n]:
19 | count += 1
20 | else:
21 | if count != 0:
22 | countList.append(count)
23 | count = 1
24 | else:
25 | count += 1
26 |
27 | if (n == len(cadena) - 1):
28 | countList.append(count)
29 |
30 | countList = [str(x) for x in countList]
31 | print(f"""
32 | {" ".join(newcadena)}
33 | {" ".join(countList)}""")
34 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-1/solucion1.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @g1_alexander
3 | Github: @g1alexander
4 | """
5 |
6 |
7 | def categorias(puntuacion):
8 | if puntuacion < 0:
9 | return "no puntuacion no puede ser menor a 0"
10 | if puntuacion >= 0 and puntuacion <= 20:
11 | return "uno"
12 | elif puntuacion > 20 and puntuacion <= 30:
13 | return "dos"
14 | elif puntuacion > 30 and puntuacion <= 50:
15 | return "tres"
16 | elif puntuacion > 50:
17 | return "cuatro"
18 |
19 |
20 | intentos = int(input())
21 | seg_puntuacion = intentos + intentos + 4
22 | ter_puntuacion = (intentos + seg_puntuacion) // 5
23 |
24 | if intentos < 0:
25 | print("no puedes tener '-' intentos")
26 | else:
27 | print(
28 | f"""{intentos} {seg_puntuacion} {ter_puntuacion}
29 | {categorias(ter_puntuacion)}"""
30 | )
31 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-5/solucion1.py:
--------------------------------------------------------------------------------
1 | def filtrar_laminas(laminas):
2 | filtro_laminas = []
3 | for n in range(len(laminas)):
4 | if laminas[n] not in filtro_laminas:
5 | filtro_laminas.append(laminas[n])
6 | return filtro_laminas
7 |
8 |
9 | def validar_tipo(indices, laminas, tipo):
10 | validar_tipo = []
11 | for i in indices:
12 | if laminas[i] == tipo:
13 | validar_tipo.append(i)
14 | return validar_tipo
15 |
16 |
17 | def listar_faltantes(lista_usuario, lista_intercambiables):
18 | listar_faltantes = []
19 | for n in range(len(lista_usuario)):
20 | if lista_usuario[n] not in lista_intercambiables:
21 | listar_faltantes.append(lista_usuario[n])
22 | return listar_faltantes
23 |
24 |
25 | def numero_intercambiables(lista_usuario, lista_intercambiables):
26 | return len(listar_faltantes(lista_intercambiables, lista_usuario))
27 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-1/solucion2.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @blasanti258
3 | Github: @santigp258
4 | """
5 | import math
6 |
7 | def validacion(puntos):
8 | try:
9 | int(puntos)
10 | return True
11 | except:
12 | return False
13 |
14 |
15 | def categoria(puntuacion):
16 | if 0 <= puntuacion <= 20:
17 | return "uno"
18 | elif 21 <= puntuacion <= 30:
19 | return "dos"
20 | elif 31 <= puntuacion <= 50:
21 | return "tres"
22 | else:
23 | return "cuatro"
24 |
25 | puntuacion = input("Puntuación\n")
26 |
27 | check = validacion(puntuacion)
28 | while (check == False):
29 | puntuacion = input("Ingrese un valor entero \n")
30 | check = validacion(puntuacion)
31 |
32 | #puntuacion
33 | primera = int(puntuacion)
34 | segunda = (primera * 2) + 4
35 | tercera = math.floor((primera + segunda) / 5)
36 |
37 | cat = categoria(tercera)
38 | print(f"{primera} {segunda} {tercera} {cat}")
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto_3/Descripción.md:
--------------------------------------------------------------------------------
1 | # Reto 3: Grupo P21
2 |
3 | Una tienda de celulares, va a determinar el modelo estrella, definido como aquel que se vende más veces de forma seguida en un período de una semana. Para el efecto identifican con un número de un solo dígito, a 10 modelos preferidos. En el sistema se registra el número que identifica a los modelos que se ha vendido, y en el orden que ocurren (los números quedan separados por un espacio en blanco).
4 |
5 | Su tarea es hacer el programa para el conteo de modelos vendidos, es decir, muestre en un renglón los datos de la entrada, separados por un espacio (cuando un modelo se vende varias veces en forma seguida, se muestra el número del modelo una sola vez) y en el segundo renglón muestre el número de veces seguidas que ocurrieron las ventas de ese modelo.
6 |
7 | **Ejemplo:**
8 | Entrada:
9 | 4 4 0 4 5 5 5 7
10 | Salida:
11 | 4 0 4 5 7
12 | 2 1 1 3 1
13 |
14 |
15 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto_4/catalogoComputo.py:
--------------------------------------------------------------------------------
1 | '''
2 | Ingrid Echeverri
3 | Github: @Ingrid-E
4 | Twitter: @Ingrid_E_
5 |
6 | Reto 4 P21 UNAL
7 | '''
8 | import json
9 |
10 | proveedor = json.loads(input('Proveedor: '))
11 | equiposSolicitados = input('Equipos: ').split(' ')
12 |
13 | def valorEquipos(productos, compras) -> None:
14 | '''
15 | Imprime el valor total de los precios de los productos requeridos en
16 | la lista de productos y los productos disponibles para comprar.
17 |
18 | @productos -> dict con los productos y precios
19 | @compras -> lista con los productos que se quieren comprar.
20 | '''
21 | valorTotal = 0;
22 | disponibles = []
23 | for producto in compras:
24 | if producto in productos:
25 | valorTotal += productos.get(producto)
26 | disponibles.append(producto)
27 | print(valorTotal)
28 | print(*disponibles)
29 |
30 | valorEquipos(proveedor, equiposSolicitados)
31 |
32 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_5/solucion_1.py:
--------------------------------------------------------------------------------
1 | # Author: [Gabriel Morales](https://github.com/xgabrielmorales)
2 |
3 | def pedidos(tipos_pizzas_pedidas):
4 | restantes = list()
5 | [restantes.append(tipo) for tipo in tipos_pizzas_pedidas if tipo not in restantes]
6 | return restantes
7 |
8 | def debo_llevar(cod_rep_dispo, tipo_pizza_reserv, tipo_pizz_llevar):
9 | rep_dispo = list()
10 | for codigo_rep in cod_rep_dispo:
11 | if tipo_pizza_reserv[codigo_rep] == tipo_pizz_llevar:
12 | rep_dispo.append(codigo_rep)
13 | return rep_dispo
14 |
15 | def faltan_repartidores(cod_rep_total, cod_rep_ocup):
16 | return [rep for rep in cod_rep_total if rep not in cod_rep_ocup]
17 |
18 | def posible_intercambio(cod_rep_dispo, cod_rep_aux):
19 | inter_1 = len([rep for rep in cod_rep_aux if rep not in cod_rep_dispo])
20 | inter_2 = len([rep for rep in cod_rep_dispo if rep not in cod_rep_aux])
21 | return min(inter_1, inter_2)
22 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-4/Readme.md:
--------------------------------------------------------------------------------
1 | # Reto #4
2 |
3 | #### Solución #1 realizada por: [@g1alexander](https://github.com/g1alexander)
4 | #### Solución #2 realizada por: [@santigp258](https://github.com/santigp258)
5 | ---
6 |
7 | La tienda oficial de la Universidad Nacional tiene un catálogo en formato JSON con algunas láminas del álbum de la chocolatina Jet que tiene disponible para su venta, realice un programa que permita a un cliente calcular cuánto le cuesta comprar del catálogo de la universidad las fichas que le sirven y cuáles puede conseguir tomando como entradas el diccionario con el catálogo disponible por parte de la universidad y las fichas pendientes por parte del cliente.
8 |
9 | **Ejemplo:**
10 |
11 | | Entrada | Salida |
12 | | ----------------------------------------------------------------------- | ------------ |
13 | | {"34": 1190, "12": 728, "210": 1174, "56": 1085, "78": 841, "74": 1078} | 4178 |
14 | | 122 78 30 210 74 56 | 78 210 74 56 |
15 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto_1/reto1_Ingrid.py:
--------------------------------------------------------------------------------
1 | # Reto 1: Grupo P21
2 |
3 | # Planta de tratamiento de agua potable, adicionan cada dia 3 quimicos.
4 | # Tanque B: Kilos de floculante
5 | # Tanque C: Kilos de cal
6 | # Tanque Salida: Litros de cloro
7 |
8 | # KC - 4 = 2(KF)
9 | # KC + KF = 5(LC)
10 |
11 | # Dependiendo del dia de la semana, el consumo de agua varia.
12 | # 4 categorías:
13 | # uno : Cloro <= 20 litros
14 | # dos : 20 < Cloro >= 30
15 | # tres : 30 < Cloro >= 50
16 | # cuatro : cloro > 50
17 |
18 | # Entrada: Kilos de floculante
19 | # Salida:
20 | # - 3 números enteros, números de KF, KC, LC
21 | # - Categoría del cloro
22 |
23 | kilos_floculante = int(input())
24 | kilos_cal = 2 * kilos_floculante + 4
25 | litros_cloro = (kilos_cal + kilos_floculante) // 5
26 |
27 |
28 | def categoria_cloro(cloro):
29 | if cloro <= 20:
30 | print("uno")
31 | elif cloro > 20 and cloro <= 30:
32 | print("dos")
33 | elif cloro > 30 and cloro <= 50:
34 | print("tres")
35 | else:
36 | print("cuatro")
37 |
38 |
39 | print(kilos_floculante, kilos_cal, litros_cloro)
40 | categoria_cloro(litros_cloro)
41 |
42 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto_3/conteoModelos.py:
--------------------------------------------------------------------------------
1 | '''
2 | Ingrid Echeverri
3 | Github: @Ingrid-E
4 | Twitter: @Ingrid_E_
5 |
6 | Reto 3 P21 UNAL
7 | '''
8 |
9 | modelos_vendidos = input('Modelos Vendidos:').split(' ')
10 | '''
11 | Función que cuenta cada cuanto se repite un numero en secuencia
12 | '''
13 | def conteoModelos(modelos):
14 | #Lista que contiene los numeros sin repetirse en secuencia
15 | #y la cantidad de veces que se repite en secuencia
16 | secuenciaModelos = [[],[]]
17 | cantidadEnSecuencia = 0; #Contador de repetición
18 | for modelo in range(len(modelos)):
19 | cantidadEnSecuencia += 1;
20 | if modelo == len(modelos)-1 or modelos[modelo] != modelos[modelo+1] :
21 | secuenciaModelos[0].append(modelos[modelo]) #Valor
22 | secuenciaModelos[1].append(cantidadEnSecuencia) #Cantidad de veces que se repite
23 | cantidadEnSecuencia = 0 #Reiniciar suma
24 |
25 | print(" ".join(x for x in secuenciaModelos[0]))
26 | print(" ".join(str(x) for x in secuenciaModelos[1]))
27 |
28 | conteoModelos(modelos_vendidos)
29 |
30 |
31 | lista = ['a', 'b', 'c']
32 |
33 | for x in lista:
34 | print(x)
35 |
36 |
--------------------------------------------------------------------------------
/NotasDeClase/problemas.py:
--------------------------------------------------------------------------------
1 | '''
2 | Desarrollar un algoritmo que reciba dos cadenas de caracteres y
3 | determine si la primera está incluida en la segunda.
4 |
5 | Se dice que una cadena está incluida en otra si todos los caracteres
6 | con repeticiones de la cadena esta en la segunda cadena sin tener en cuenta
7 | el orden de los caracteres.
8 |
9 | Ejemplo:
10 | -"prosa" esta incluida en la cadena "la profesora de idiomas"
11 | -"pepito" no esta incluido en "un pedazo de tierra" falta una p
12 | -"pepito" si esta incluido en "tijeras o papel"
13 | '''
14 |
15 | '''
16 | Invertir una cadena y decir si es palindroma
17 | '''
18 |
19 | cadena = "hola" #aloh
20 |
21 | def invertirCadena(palabra) -> str:
22 | invertida = ""
23 | for i in range ((len(palabra)-1),-1,-1):
24 | invertida += palabra[i]
25 | return invertida
26 |
27 | def palindromo(palabra):
28 | if invertirCadena(palabra).upper() == palabra.upper():
29 | print(palabra,"Es palindroma")
30 | else:
31 | print(palabra,"No es palindroma")
32 |
33 | palindromo("hola")
34 | palindromo("Arepera")
35 | palindromo("Sábado")
36 | palindromo("Amor a Roma")
37 |
38 |
39 |
40 |
41 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-2/solucion1.py:
--------------------------------------------------------------------------------
1 | """
2 | Twitter: @g1_alexander
3 | Github: @g1alexander
4 | """
5 | # variables -----
6 | count_j = 0
7 | count_k = 0
8 | resultado = ""
9 |
10 | # entradas -----
11 | junior = input().upper()
12 | kathe = input().upper()
13 | pacientes = input().upper()
14 |
15 |
16 | for letra in pacientes:
17 | for j in junior:
18 | for k in kathe:
19 | if j == letra and k == letra:
20 | pacientes = pacientes.replace(letra, "l")
21 |
22 | for letra in pacientes:
23 | for j in junior:
24 | if j == letra:
25 | pacientes = pacientes.replace(letra, "j")
26 |
27 | for letra in pacientes:
28 | for k in kathe:
29 | if k == letra:
30 | pacientes = pacientes.replace(letra, "k")
31 |
32 | for letra in pacientes:
33 | if letra == "j":
34 | count_j += 1
35 | elif letra == "k":
36 | count_k += 1
37 | elif letra == "l":
38 | count_k += 1
39 | count_j += 1
40 | if count_j > count_k:
41 | resultado += "J"
42 | if count_j < count_k:
43 | resultado += "K"
44 | if count_j == count_k:
45 | resultado += "L"
46 |
47 | print(resultado)
48 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/README.org:
--------------------------------------------------------------------------------
1 | * P30
2 | Bienvenido al repositorio de retos del grupo P30, aquí encontraras un
3 | listado de los retos propuestos por ciclos y sus soluciones
4 | dadas por los estudiantes. Siéntete libre de navegar entre
5 | archivos.
6 |
7 | Las soluciones a los retos poseen autoría, sin embargo, son de libre
8 | uso. Si deseas contribuir con tu solución a cualquiera de los retos
9 | recuerda añadir un comentario al inicio del archivo con tu nombre y
10 | enlace a tu GitHub. Por ejemplo:
11 |
12 | #+BEGIN_SRC python
13 | # Author: [Gabriel Morales](https://github.com/xgabrielmorales)
14 | #+END_SRC
15 |
16 | ** Listado de Retos por Ciclo
17 | *** Ciclo 1 - Python
18 | En el ciclo 1 se impartieron los fundamentos de la programación
19 | utilizando utilizando Python, partiendo desde los tipos de datos,
20 | funciones, estructuras condicionales y ciclos hasta estructuras de
21 | datos básicas y librerías. Los retos fueron diseñados de tal manera que
22 | se pudiera realizar con los conocimientos aprendidos durante el
23 | transcurso del ciclo.
24 |
25 | - [[file:./reto_1][Reto 1]]
26 | - [[file:./reto_2][Reto 2]]
27 | - [[file:./reto_3][Reto 3]]
28 | - [[file:./reto_4][Reto 4]]
29 | - [[file:./reto_5][Reto 5]]
30 |
31 | *** Ciclo 2 - Java
32 | El ciclo 2 aun no se encuentra documentado, estará aquí próximamente.
33 |
--------------------------------------------------------------------------------
/RetosUNAL/P81/reto-4/README.md:
--------------------------------------------------------------------------------
1 | # Reto4
2 |
3 |
4 | #### Solución #1 realizada por: [@Juan Motta](https://github.com/Juan-Motta)
5 |
6 | ---
7 |
8 | Una familia colecciona las laminas de Panini de los mundiales, curiosamente del 2018 le quedaron unas láminas pendientes y están buscando lugares que tengan catálogo de ellas para poder comprarlas y llenar el álbum. En la tienda de la Universidad Nacional se puede ver el catálogo de las láminas disponibles en formato JSON donde muestra el numero de la lámina y su respectivo precio asociado; realice un programa que dado el diccionario de láminas disponibles y la lista de láminas pendientes de la familia entregue como salida el costo total de comprar las láminas en la tienda de la universidad y la lista de las láminas conseguidas, las cuales le ayudarán a la familia a saber cuánto le cuesta conseguir las láminas la tienda y cuáles van a conseguir.
9 |
10 | **Entrada:**
11 | Catalogo de laminas disponibles con su precio correspondiente y numero de laminas necesitadas
12 |
13 | **Salida:**
14 | Precio total de las laminas conseguidas y laminas conseguidas
15 |
16 | **Ejemplo:**
17 |
18 | | Entrada | Salida |
19 | | ------- | -------------- |
20 | | {"312": 1230, "94": 1545, "50": 1378, "360": 2240, "1": 1228, "37": 2009, "240": 1493} | 4467 |
21 | | 312 5 57 82 500 37 1 | 312 37 1 |
22 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/sesion18.py:
--------------------------------------------------------------------------------
1 | '''
2 | Dado el archivo de texto files/SalesJan2009.csv, procese el archivo
3 | para obtener las compras realizadas en un país dado. Ejemplo:
4 |
5 | Entrada: United Kingdom
6 | Salida: 100
7 | '''
8 | import csv
9 | salesJan2009 = []
10 | with open('files/SalesJan2009.csv', 'r') as ventas:
11 | descripcion = ventas.readline().split(',')
12 | archivo = csv.reader(ventas)
13 | for datos in archivo:
14 | count = 0
15 | Dict = {}
16 | #print(datos[0])
17 | for i in datos:
18 | Dict[descripcion[count]] = i
19 | count += 1
20 | salesJan2009.append(Dict)
21 |
22 | def contarCantidad(dato:str, tipo:str)->int:
23 | cantidad = 0;
24 | for fila in salesJan2009:
25 | if fila[tipo] == dato:
26 | cantidad += 1
27 | return cantidad
28 |
29 | def todosLosPaises(dato, tipo):
30 | cantidad = []
31 | contador = {pais['Country']:0 for pais in salesJan2009}
32 | for fila in salesJan2009:
33 | if(fila[tipo] == dato):
34 | contador[fila['Country']] += 1
35 | print("Cantidad de veces que los paises usaron", dato)
36 | print(contador)
37 |
38 |
39 | print(contarCantidad('United Kingdom', 'Country'))
40 | print(contarCantidad('Visa', 'Payment_Type'))
41 | todosLosPaises('Visa', 'Payment_Type')
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_3/README.org:
--------------------------------------------------------------------------------
1 | * Reto #3 - P30
2 | ** Descripción
3 | El gobernante de la ciudad de Nuncalandia quiere implementar un
4 | sistema de vigilancia epidemiológico en cada establecimiento, con el
5 | fin de poder rastrear a todas las personas que ingresan al mismo. Para
6 | ello, ubica una cámara inteligente que registra cuantas veces ingresa
7 | una persona al establecimiento. Al final del día, la cámara tiene
8 | registro de todas las personas que ingresaron al establecimiento.
9 |
10 | ** Tarea
11 | Elaborar un programa que permita, dado el registro de personas que
12 | ingresaron al establecimiento, conocer la cantidad de veces que una
13 | persona ingreso al establecimiento antes de que el sistema registrara
14 | el ingreso otra persona.
15 |
16 | ** Entrada
17 | Una cadena de caracteres separada por espacios que representa las
18 | personas que ingresaron al establecimiento.
19 |
20 | ** Salida
21 | Dos cadenas de caracteres. La primera cadena que representa las
22 | personas que van ingresando al establecimiento y la segunda representa
23 | la cantidad de veces que ingresaron a este, antes de que el sistema
24 | registrara a otra persona.
25 |
26 | *** Entrada Ejemplo
27 | #+BEGIN_SRC
28 | D D D D T T T D A A T T T A A A U Y U U U
29 | #+END_SRC
30 |
31 | *** Salida Ejemplo
32 | #+BEGIN_SRC
33 | D T D A T A U Y U
34 | 4 3 1 2 3 3 1 1 3
35 | #+END_SRC
36 |
--------------------------------------------------------------------------------
/RetosUNAL/P2/reto4.py:
--------------------------------------------------------------------------------
1 | # Por estos días, se juega la Copa América de Fútebol en donde participan todos los países suramericanos.
2 |
3 | # Muchos coleccionistas y aficionados están completando el álbum de la Copa América de Futebol de Panini ¡El original!.
4 |
5 | # Ellos cuentan con una lista con la inicial de los jugadores de las fichas faltantes y encontraron innumerables tiendas virtuales en internet en donde pueden comprarlas a un precio dado. Para esto ellos quisieran saber que láminas pueden comprar y el precio total por la compra.
6 |
7 | # Para esto, le piden su ayuda para que realice un programa que dado un diccionario (en formato JSON) que tiene las parejas inicial_ficha:precio de todas las láminas vendidas por la tienda, y que dada la lista de iniciales de los jugadores faltantes (separados por espacios), imprima el precio total de las fichas que pueden comprar en esta tienda y las iniciales de las láminas compradas (separadas por espacio):
8 |
9 | import json
10 |
11 | #input
12 | fichas = json.loads(input())
13 | mis_fichas = str(input())
14 |
15 | precio_total = 0
16 | fichas_disponibles = []
17 | for i in mis_fichas.split(" "):
18 | precio_ficha = fichas.get(i)
19 | if precio_ficha:
20 | precio_total += precio_ficha
21 | fichas_disponibles.append(i)
22 |
23 | #output
24 | print(precio_total)
25 | print(' '.join(str(f) for f in fichas_disponibles))
26 |
27 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto5/libros.py:
--------------------------------------------------------------------------------
1 | def autores(listaAutores):
2 | sinRepetir = []
3 | for autor in listaAutores:
4 | if autor not in sinRepetir:
5 | sinRepetir.append(autor)
6 | return sinRepetir
7 |
8 |
9 | def mefaltandeunautor(librosFaltantes, listaAutores, autor):
10 | librosAutor = []
11 | for libro in librosFaltantes:
12 | if listaAutores[libro] == autor:
13 | librosAutor.append(libro)
14 | return librosAutor
15 |
16 | def losnecesito(librosIntercambio,misRepetidos):
17 | librosFaltantes = []
18 | for libro in librosIntercambio:
19 | if libro not in misRepetidos:
20 | librosFaltantes.append(libro)
21 | return librosFaltantes
22 |
23 | def puedocambiar(susRepetidos, misRepetidos):
24 |
25 | interesan = [[],[]]
26 | for libro in susRepetidos:
27 | if libro not in misRepetidos:
28 | interesan[0].append(libro)
29 | for libro in misRepetidos:
30 | if libro not in susRepetidos:
31 | interesan[1].append(libro)
32 | print(interesan[0], interesan[1])
33 | if len(interesan[0]) > len(interesan[1]):
34 | return len(interesan[1])
35 | else:
36 | return len(interesan[0])
37 |
38 | print(puedocambiar([6, 36, 37, 27, 14, 21, 23, 39, 26, 29, 9, 20, 8, 28, 25],[9, 3, 16, 35, 23, 21, 20, 8, 28, 34, 30, 11, 19, 2, 12, 31, 33, 24]))
39 |
40 |
41 |
42 |
43 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_4/README.org:
--------------------------------------------------------------------------------
1 | * Reto #4 - P30
2 |
3 | ** Descripción
4 | El chef de la pizzeria “Mominos” sale todas las mañanas a la plaza de
5 | mercado a comprar los ingredientes para sus pizzas. Como él tiene una
6 | lista con los ingredientes que le hacen falta, quieren saber los
7 | ingredientes que puede comprar y el precio a pagar por dicha compra,
8 | dada la disponibilidad de productos en la plaza.
9 |
10 | ** Tarea
11 | Elaborar un programa que permita, dada la disponibilidad de productos
12 | que tiene la plaza de mercado y la lista de ingredientes que le faltan
13 | al chef, conocer los ingredientes que compro y el precio total que
14 | pago por su compra.
15 |
16 | ** Entrada
17 | Dos cadenas de caracteres. La primera cadena representa un diccionario
18 | (en formato JSON) que tiene las parejas ingrediente:precio de todos
19 | los ingredientes disponibles en la plaza de mercado, y la segunda
20 | representa la lista de ingredientes (separados por espacio) que
21 | necesita el chef para preparar sus pizzas.
22 |
23 | ** Salida
24 | Dos cadenas de caracteres, que representan el precio total de los
25 | ingredientes y los ingredientes (separados por espacio) que pudo
26 | comprar.
27 |
28 | *** Entrada Ejemplo
29 | #+BEGIN_SRC python
30 | { "t": 66, "u": 72, "d": 90, "r": 84, "j": 36, "g": 50, "s": 94, "q": 62, "f": 35 }
31 | d p h u i e t q
32 | #+END_SRC
33 |
34 | *** Salida Ejemplo
35 | #+BEGIN_SRC python
36 | 290
37 | d u t q
38 | #+END_SRC
39 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-3/Readme.md:
--------------------------------------------------------------------------------
1 | # Reto #3
2 |
3 | #### Solución #1 realizada por: [@g1alexander](https://github.com/g1alexander)
4 |
5 | #### Solución #2 realizada por: [@santigp258](https://github.com/santigp258)
6 |
7 | ---
8 |
9 | En el Ciclo 1 de programación, un profesor quiere validar lo aprendido por sus estudiantes sobre los temas vistos del curso y decide plantearles el siguiente ejercicio para resolver en casa durante el fin de semana:
10 |
11 | Realice un programa que reciba como entrada una cadena de caracteres (separada por espacios) por consola, y como salida imprima una lista con la misma cadena de caracteres excluyendo los repetidos consecutivos y otra lista con el número de veces seguidas que se encontró dicho caracter, cada una de las listas separadas por un espacio.
12 |
13 | Como recomendación, el profesor les dice que primero realicen el algoritmo en una hoja de papel para clarificar el flujo del problema y cuando tengan claro paso a paso de como resolver el ejercicio, ahí si se dediquen a codificar la solución.
14 |
15 | Realice un programa que solucione el programa descrito anteriormente.
16 |
17 | **Ejemplo:**
18 |
19 | | Entrada | Salida |
20 | | --------------------------------------------------- | ------------------- |
21 | | 9 9 9 9 h h o o o h h 9 9 9 9 & 9 2 2 2 2 u u u 9 9 | 9 h o h 9 & 9 2 u 9 |
22 | | | 4 2 3 2 4 1 1 4 3 2 |
23 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto_4/Descripción.md:
--------------------------------------------------------------------------------
1 | # Reto 4:Grupo 21
2 |
3 | Los proveedores de equipo de cómputo, normalmente identifican los bienes que tienen para la venta en un catálogo mediante parejas en **formato JSON**.
4 |
5 | Una empresa va a adquirir varios equipos de cómputo de varias marcas (servidores, estaciones de trabajo, computadores de escritorio, portátiles, tabletas, enrutadores, switches, Access points), para todas sus sedes. Y hace una licitación publicando una relación de los equipos que requiere, identificados mediante de códigos estándar de una letra.
6 |
7 | Uno de los proveedores de equipo requiere un programa para **cruzar la lista de equipos solicitados por licitación contra su propio catalogo** ya que quiere saber cuáles equipos puede ofrecer y cuál sería el valor total de la oferta, si de cada equipo se compra una unidad.
8 |
9 | Entrada:
10 | * parejas en formato JSON del catálogo del proveedor
11 | * Relación total de letras que identifican los equipos solicitados por licitación. En este caso los equipos se identifican por letras del alfabeto, separados por espacio.
12 |
13 |
14 | Salida:
15 | * valor total de los equipos solicitados y que el proveedor puede ofrecer, representado por un número entero.
16 | * relación de códigos que identifican los equipos que el proveedor puede ofrecer y que son solicitados en la licitación.
17 |
18 | Ejemplo:
19 |
20 | |Entrada|Salida|
21 | |---|---|
22 | |{"v": 45, "s": 32, "c": 45, "g": 29, "z": 45, "d": 46}|168|
23 | |s v c d y f t|s v c d|
--------------------------------------------------------------------------------
/RetoMisionTic/holaMisionTic.py:
--------------------------------------------------------------------------------
1 | #El reto consiste en escribir en un programa en el lenguaje de programación Python
2 | #que utilice variables y operadores el siguiente mensaje:
3 | #"Hola Misión TIC 2022... soy "
4 |
5 | #Funcion que imprime el saludo de mision tic
6 | def saludoMisionTic(nombre):
7 | print("Hola Misión TIC 2022, Yo soy", nombre)
8 | if nombre == "Ingrid":
9 | universidad = [
10 | "██╗░░░██╗███╗░░██╗██╗██╗░░░██╗███████╗██████╗░░██████╗██╗██████╗░░█████╗░██████╗░",
11 | "██║░░░██║████╗░██║██║██║░░░██║██╔════╝██╔══██╗██╔════╝██║██╔══██╗██╔══██╗██╔══██╗",
12 | "██║░░░██║██╔██╗██║██║╚██╗░██╔╝█████╗░░██████╔╝╚█████╗░██║██║░░██║███████║██║░░██║",
13 | "██║░░░██║██║╚████║██║░╚████╔╝░██╔══╝░░██╔══██╗░╚═══██╗██║██║░░██║██╔══██║██║░░██║",
14 | "╚██████╔╝██║░╚███║██║░░╚██╔╝░░███████╗██║░░██║██████╔╝██║██████╔╝██║░░██║██████╔╝",
15 | "░╚═════╝░╚═╝░░╚══╝╚═╝░░░╚═╝░░░╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝╚═════╝░╚═╝░░╚═╝╚═════╝░",
16 |
17 | "███╗░░██╗░█████╗░░█████╗░██╗░█████╗░███╗░░██╗░█████╗░██╗░░░░░",
18 | "████╗░██║██╔══██╗██╔══██╗██║██╔══██╗████╗░██║██╔══██╗██║░░░░░",
19 | "██╔██╗██║███████║██║░░╚═╝██║██║░░██║██╔██╗██║███████║██║░░░░░",
20 | "██║╚████║██╔══██║██║░░██╗██║██║░░██║██║╚████║██╔══██║██║░░░░░",
21 | "██║░╚███║██║░░██║╚█████╔╝██║╚█████╔╝██║░╚███║██║░░██║███████╗",
22 | "╚═╝░░╚══╝╚═╝░░╚═╝░╚════╝░╚═╝░╚════╝░╚═╝░░╚══╝╚═╝░░╚═╝╚══════╝"
23 | ]
24 | for x in universidad:
25 | print(x)
26 |
27 | if __name__ == "__main__":
28 | name = input("Cual es tu nombre: ")
29 | saludoMisionTic(name)
30 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-2/Readme.md:
--------------------------------------------------------------------------------
1 | # Reto#2
2 |
3 | #### Solución #1 realizada por: [@g1alexander](https://github.com/g1alexander)
4 | #### Solución #2 realizada por: [@santigp258](https://github.com/santigp258)
5 |
6 | ---
7 |
8 | Junior y Katherine fueron a acompañar a su abuela Luisa al Centro Médico a que le apliquen la vacuna del Covid19; se dieron cuenta tarde que se les olvidó cargar su celular y se quedaron sin batería para distraerse mientras esperan el turno asignado. Para poner la espera interesante se les ocurrió un juego en donde el que pierda debe gastar la ronda de helados de regreso a casa.
9 |
10 | Cado uno debe escribir una serie de letras y comparar si alguna ellas corresponde a la inicial del Apellido de cada paciente que van llamando hasta antes que le toque a su abuela. La forma para tener las cuentas claras es la siguiente:
11 |
12 | En caso de que la inicial del apellido corresponda a alguna de las letras, cada uno obtiene un punto; posteriormente comparan con el acumulado de puntos para ver quien va ganando. Si Junior va ganando escriben una ‘J’, si Katherine va ganando escriben una ‘K’ y en caso de empate colocan ‘L’. Esta operación la realizan por cada paciente que vayan llamando hasta llegar a su abuela.
13 |
14 | Realice un programa que permita recibir los grupos de letras de los dos nietos, la serie de iniciales de apellidos respectiva e imprima como resultado la cadena de caracteres correspondiente donde llevan las cuentas.
15 |
16 | **Ejemplo:**
17 |
18 | | Entrada | Salida |
19 | | -------------------------- | -------------------------- |
20 | | SDAHA | LKLLLKKKKKKKKKKKKKKKKKKKKK |
21 | | SHBJA | |
22 | | ABDAABSSAAAAJSADSAAAJDASAA | |
23 |
--------------------------------------------------------------------------------
/Pruebas/mulMatrices.py:
--------------------------------------------------------------------------------
1 | '''
2 | Multiplicación de dos matrices.
3 |
4 | Para multiplicar las matrices con tamaño columnas*filas:
5 | -Las filas de la primera matriz deben ser igual a las columnas de la segunda matriz,
6 | si no, la multiplicación no es valida.
7 |
8 | La multiplicación de una matriz es:
9 | Elementos_Columna * Elementos_Fila
10 | (b_00) * (a_00, a_01, a_02) = (a_00*b_00)+(a_01*b_00)+(a_02*b_00)
11 | '''
12 |
13 | def multiplicarMatrices(A,B):
14 | resultado = []
15 | #Tamaño de la matriz A
16 | filasA = len(A); columnasA = len(A[0])
17 | #Tamaño de la matriz B
18 | filasB = len(B); columnasB = len(B[0])
19 |
20 | if columnasA == filasB: #Condición para saber si son multiplicables.
21 | for fila in range(filasA): #Recorre cada fila de la matriz A
22 | nuevaFila = []
23 | for columna in range(columnasB): #Recorre cada columna de la matriz B
24 | sumElm = 0;
25 | for elemento in range(columnasA): #Recorre cada elemento de fila A, y columna B
26 | sumElm += A[fila][elemento] * B[elemento][columna]
27 | nuevaFila.append(sumElm)
28 | resultado.append(nuevaFila)
29 | else:
30 | print('Error: La filas de la matriz A no son iguales a las columnas de la matriz B')
31 |
32 | return resultado
33 |
34 | matrizA = [
35 | [12, 7, 3],
36 | [ 4, 5, 6],
37 | [ 7, 8, 9]
38 | ]
39 |
40 | matrizB = [
41 | [ 5, 8, 1, 2],
42 | [ 6, 7, 3, 0],
43 | [ 4, 5, 9, 1]
44 | ]
45 |
46 | print(multiplicarMatrices(matrizA, matrizB))
47 |
48 |
49 | A = [[12, 7, 3],
50 | [4 ,5, 6],
51 | [7,8, 9]]
52 |
53 | B = [[5, 8, 1, 2],
54 | [6, 7, 3, 0],
55 | [4, 5, 9, 1]]
56 |
57 |
58 |
59 |
--------------------------------------------------------------------------------
/RetosUNAL/laboratorio_de_pruebas.py:
--------------------------------------------------------------------------------
1 | # El Centro Comercial Unaleño desea comenzar a crear un carrito de compras. Para esto se requiere una tarea que será de gran utilidad a futuro: Leer y clasificar la información sobre un producto.
2 |
3 | # En esta ocasión se deberá leer el nombre de un producto, el costo unitario, el precio de venta al público y la cantidad de unidades disponibles. Dada esta lectura se debe imprimir el valor total que puede ganar el centro comercial por dicho producto.
4 |
5 | # Entrada: Los valores de cada producto en una línea de código diferente. En el siguiente orden:
6 |
7 | # El nombre del producto
8 | # El costo unitario CU
9 | # El precio de venta al público PVP
10 | # La cantidad de unidades disponibles
11 |
12 |
13 | # Salida: Se debe mostrar lo siguiente:
14 |
15 | # El texto “Producto” sin comillas acompañado del nombre del producto
16 | # El texto “CU:” sin comillas acompañado del costo unitario del mismo
17 | # El texto “PVP:” sin comillas acompañado del precio de venta al público
18 | # El texto “Unidades Disponibles:” acompañado de las unidades disponibles
19 | # El texto “Ganancia:” acompañado del cálculo de la ganancia por ese producto.
20 |
21 |
22 | #############################
23 | # Input #
24 | #############################
25 |
26 | producto = input("Nombre del producto: ")
27 | cu = int(input("CU: "))
28 | pvp = int(input("PVP: "))
29 | unidades_disponibles = int(input("Unidades disponibles: "))
30 |
31 | print("Producto: " + producto)
32 |
33 | print(f"CU: ${cu}")
34 |
35 | print(f"PVP: ${pvp}")
36 |
37 | print(f"Unidades Disponibles: {unidades_disponibles}")
38 |
39 | #############################
40 | # Output #
41 | #############################
42 |
43 |
44 | ganancia = (pvp - cu)*unidades_disponibles
45 | print(f"Ganancia: ${ganancia}")
--------------------------------------------------------------------------------
/RetosUNAL/P21/ejercicios_Ingrid.py:
--------------------------------------------------------------------------------
1 | import math
2 | '''
3 | Conocidos los tres lados de un triàngulo,
4 | determine su respectivo tipo.
5 |
6 | 3. Equilatero: 3 lados iguales.
7 | 2. Isósceles: 2 lados iguales.
8 | 1. Escaleno: Ningún lado igual
9 |
10 | '''
11 | lados_Triangulo = input("Introduce los lados del triàngulo: ").split()
12 | a = lados_Triangulo[0]
13 | b = lados_Triangulo[1]
14 | c = lados_Triangulo[2]
15 |
16 | def tipoTriangulo():
17 | if a != b or a != c or b != c:
18 | print("Escaleneo")
19 | elif a == b and b==c:
20 | print("Equilatero")
21 | else:
22 | print("Isósceles")
23 |
24 | tipoTriangulo()
25 |
26 | '''
27 | Haga una expresión que devuelva el N de días que tiene
28 | el mes m (30 días trae nov, abril,junio y septiembre.
29 | 28 solo 1, los demás 31), donde bisiesto = 1, si el
30 | año es bisiesto o 0 si no es bisiesto.
31 |
32 | '''
33 | mes = input("El numero del mes ")
34 | bisiesto = input("El año es bisiesto? 1- Si, 0- No ")
35 |
36 | def numero_Dias():
37 | treinta_Dias = 30*(mes==11 or mes == 4 or mes == 6 or mes == 9)
38 | veintiocho_Dias = (28+bisiesto)*(mes == 2)
39 | treintaYUno_Dias = 31*(mes ==1 or mes ==3 or mes==5 or mes==7 or mes ==8 or m==10 or mes ==12)
40 | return treinta_Dias + veintiocho_Dias+ treinta_Dias
41 |
42 | print(numero_Dias())
43 |
44 | '''
45 | Decir si un nro entero m es exactamente divisible entre
46 | otro numero entero n. 1 significa que si es divisible, 0
47 | que no lo es.
48 | '''
49 | numeros = input("Ingresa los números: ").split()
50 | m = numeros[0]
51 | n = numeros[1]
52 |
53 | def divisible():
54 | if(m%n == 1):
55 | print("Divisible")
56 | else:
57 | print("No Divisible")
58 |
59 | divisible()
60 |
61 | '''
62 | Determine si un año es bisiesto.
63 | 1: Si es bisiesto
64 | 0: No es bisiesto
65 |
66 | Un año bisiesto si es divisible entre 4, pero
67 | no es divisible entre 100, o si es divisible entre
68 | 400
69 | '''
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_2/README.org:
--------------------------------------------------------------------------------
1 | * Reto #2 - P30
2 | ** Descipción
3 | El gobernante del país de Nuncalandia debe vacunar a la población de
4 | su país, pero lamentablemente solo tiene vacunas para la mitad de
5 | ellos. Mientras planeaba como hacerlo, vio en su biblioteca el juego
6 | de Scrabble y se le ocurrió su propio juego para determinar a quién
7 | vacunar. El juego consiste en lo siguiente:
8 |
9 | - Se eligen aleatoriamente dos personas =J= y =K= para competir en el
10 | juego.
11 |
12 | - El gobernante elige aleatoriamente un conjunto de letras del
13 | Scrabble.
14 |
15 | - Cada persona escoge diferentes letras del Scrabble con las cuales
16 | competirá en el juego.
17 |
18 | - El juego consiste en =m= confrontaciones, que dependen de la
19 | cantidad de letras elegidas por el gobernante.
20 |
21 | - Para cada confrontación, se compara la letra del gobernante con las
22 | letras de las personas, y si la letra del gobernante es una de las
23 | escogidas por la persona, ella se lleva un punto. Al final de cada
24 | confrontación, el gobernante escribía en su libreta la persona que
25 | llevaba más puntos. Si la persona =J= llevaba más puntos escribía la
26 | letra “J”, si =K= llevaba más puntos escribía “K”, y si llevaban los
27 | mismos puntos escribía “L”.
28 |
29 | - Al final, la persona con más puntos es quien tiene acceso a la
30 | vacuna.
31 |
32 | ** Tarea
33 | Elabora un programa que muestre, dadas las letras con las que juega la
34 | persona =J=, las letras con las que juega la persona =K=, y las letras
35 | del gobernante (como cadena de caracteres), una cadena de caracteres
36 | que represente quien lleva más puntos al final de cada confrontación.
37 |
38 | ** Entrada
39 | Tres cadenas de caracteres. La primera representa las letras escogidas
40 | por la persona =J=, la segunda las letras escogidas por la persona
41 | =K=, y la tercera el conjunto de letras escogidas por el gobernante.
42 |
43 | ** Salida
44 | Una cadena de caracteres con los símbolos (=J=, =K=, =L=) que
45 | representa los puntos al final de cada confrontación.
46 |
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-1/Readme.md:
--------------------------------------------------------------------------------
1 | # Reto1
2 |
3 | #### Solución #1 realizada por: [@g1alexander](https://github.com/g1alexander)
4 | #### Solución #2 realizada por: [@santigp258](https://github.com/santigp258)
5 | ---
6 |
7 | El gobierno de un país con el fin de incrementar las oportunidades laborales de la nación decidió ofrecer cursos de programación para todos. Dentro de uno de los cursos existe un profesor que quiere categorizar a sus estudiantes según su nivel académico para crear grupos de trabajo que tengan un mismo nivel. Para poder categorizarlos, les manda 2 ejercicios que deben resolver en la plataforma de programación de la clase (Replit); a partir del número total de intentos que cada estudiante tuvo a la hora de resolver los ejercicios, el profesor le dará a cada uno 3 puntuaciones le asignará su categoría.
8 |
9 | La primera puntuación que le asigna es igual al número de intentos realizados, la segunda puntuación es el doble de la primera más un coeficiente de ayuda de 4 puntos, finalmente la tercera puntuación la obtiene a partir de sacar la quinta parte a la suma de los dos factores anteriores.
10 |
11 | Para decirle a sus estudiantes en qué categoría quedó, el profesor se basa en la tercera puntuación obtenida. Si la puntuación está entre 0 y 20, el estudiante quedará en el grupo uno; entre 21 y 30, en el grupo dos; entre 31 y 50, en el grupo tres y en caso de que tenga más de 50 le asignará el grupo cuatro.
12 |
13 | Realice un programa que permita al profesor obtener las puntuaciones y su grupo asociado a partir del número total de intentos de cada estudiante en la resolución de los ejercicios de clase.
14 |
15 | Nota: En caso de obtener decimales en alguna puntuación tome como valor solo el entero correspondiente (función piso).
16 |
17 | **Entrada:**
18 | Número de intentos totales por estudiante.
19 |
20 | **Salida:**
21 | Las tres puntuaciones que el profesor requiere y el grupo al que asigna al estudiante.
22 | **Ejemplo:**
23 |
24 | | Entrada | Salida |
25 | | ------- | -------------- |
26 | | 58 | 58 120 35 tres |
27 | | 26 | 26 56 16 uno |
28 |
--------------------------------------------------------------------------------
/RetosUNAL/P2/reto2.py:
--------------------------------------------------------------------------------
1 | # Reto 2: Grupo P2
2 | # Límite de entrega: Monday, 14 de June de 2021, 23:59
3 | # Número máximo de ficheros: 1
4 | # Tipo de trabajo: Individual
5 |
6 | # Felipe y su amigo francés, Chandler, están recorriendo la ciudad de Rolotá conociendo
7 | # las calles más famosas. Ellos fueron recorriendo las calles e iban adivinando
8 | # la primera letra de la placa en las direcciones que veían por los sitios. Para ello,
9 | # cada uno definió las letras con las que jugaría. Al ver la dirección, miraban si esta
10 | # empezaba con una letra que ellos habían seleccionado, y anotaban un punto en su agenda.
11 | # Cada que veían una nueva dirección, veían quien acumulaba más puntos, si Felipe llevaba
12 | # más puntos se escribía un 'F', si por el contrario Chandler tenía más puntos, se escribía
13 | # una ‘C’, pero si había igualdad de puntos se escribía una ‘J’
14 |
15 | # Aquí necesitan de su ayuda como programador, para realizar un programa que reciba las
16 | # letras con los que participan Felipe y Chandler y una cadena de caracteres con las letras
17 | # de las direcciones vistas en la ciudad y les muestre como iba el resultado cada vez que
18 | # llegaban a un nuevo sitio.
19 |
20 |
21 | #################
22 | # Input #
23 | #################
24 |
25 | #Felipe
26 | felipe = input()
27 |
28 |
29 | #Chandler
30 | chandler = input()
31 |
32 | #Calles
33 | calles = input()
34 |
35 | #Output
36 |
37 | #String salida
38 | salida = ""
39 |
40 | #0:Felipe 1:Chandler
41 | puntos = [0, 0]
42 |
43 | #Para cada letra de calles
44 | for i in calles:
45 |
46 | #Si la letra está en las que adivina felipe sumarle un punto
47 | if i in felipe:
48 | puntos[0] += 1
49 | #Si la letra está en las que adivina chandler sumarle un punto
50 | if i in chandler:
51 | puntos[1] += 1
52 |
53 |
54 | #Si Chandler tiene mas puntos que Felipe añadir la letra a salida
55 | if puntos[0] < puntos[1]:
56 | salida += "C"
57 | #Si Felipe tiene mas puntos que Chandler añadir la letra a salida
58 | elif puntos[0] > puntos[1]:
59 | salida += "F"
60 | #Si están empatados sumar la letra J
61 | else:
62 | salida += "J"
63 |
64 |
65 | #############
66 | # Salida #
67 | #############
68 |
69 | print(salida)
70 |
--------------------------------------------------------------------------------
/RetosUNAL/P2/reto3.py:
--------------------------------------------------------------------------------
1 | # Por estos días, se juega la Copa América de Fútbol en donde participan
2 | # todos los países suramericanos. Entre ellos está la selección de Colombia
3 | # y se quiere saber, cuántas veces se ha enfrentado a las diferentes selecciones
4 | # en el torneo desde la primera edición. Para esto se utilizará la letra inicial
5 | # del país, por ejemplo:
6 |
7 | # Brasil
8 |
9 | # Chile
10 |
11 | # Brasil
12 |
13 | # Venezuela
14 |
15 | # Argentina
16 |
17 | # Brasil
18 |
19 | # Perú
20 |
21 | # Perú
22 |
23 | # Chile
24 |
25 | # Así, para este ejemplo se pudo encontrar la siguiente secuencia, cada letra va
26 | # separada por un espacio: B C B V A B P P C
27 |
28 | # Como se sabe la Copa América de Fútbol, se ha realizado en innumerables ediciones,
29 | # se desea saber cuántas veces ha enfrentado consecutivamente la selección de
30 | # Colombia en las ediciones anteriores a otros equipos. Para esto, la Conmebol
31 | # decidió contratarlo para que desarrolle este programa en el que recibirá como
32 | # entrada la inicial de cada país separada por un espacio en blanco, y
33 | # deberá imprimir dos líneas, la primera deberá ser la inicial de los países
34 | # representados y en la segunda línea se debe imprimir el conteo de enfrentamientos
35 | # entre Colombia y las demás selecciones (Todos van separados por espacios en blanco).
36 |
37 | entrada_usuario = input()
38 | entrada_lista = entrada_usuario.split(" ")
39 |
40 | salida_letra = ""
41 | salida_numero = ""
42 |
43 | contador = 1
44 |
45 | letra_actual = ""
46 |
47 | # Para cada letra de la entrada
48 | for i in range(len(entrada_lista)):
49 |
50 | if i == 0:
51 | #Si es 0 empezar con esa letra
52 | letra_actual = entrada_lista[0]
53 | elif entrada_lista[i] == letra_actual:
54 | #Si la letra actual es igual a la entrada
55 | contador += 1
56 | if i == len(entrada_lista) - 1:
57 | #Si es la ultima letra
58 | salida_letra += f"{letra_actual}"
59 | salida_numero += f"{contador}"
60 |
61 | else:
62 | #Si no es igual
63 | salida_letra += f"{letra_actual} "
64 | salida_numero += f"{contador} "
65 |
66 | contador = 1
67 | letra_actual = entrada_lista[i]
68 |
69 | print(salida_letra)
70 | print(salida_numero)
--------------------------------------------------------------------------------
/RetoMisionTic/UNorte.py:
--------------------------------------------------------------------------------
1 | # Selección de becas para minorías
2 |
3 | #Recive variable de entrada y calcula un puntaje para selecionar
4 | #nuevos becarios
5 |
6 | #Salario mínimo 2021-> 908.526
7 |
8 | #El calculo se toma de la siguiente forma:
9 | #Multiplicar cada variable por su peso correspondiente, sumarlos
10 | #y dividirlo entre la suma del los pesos.
11 |
12 | # ((x*p_1)+(y*p_2)+(z*p_3))/(p_1+p_2+p_3)
13 |
14 | # puntaje < 0.5 no apto
15 | # puntaje >= 0.5 es apto continua el proceso
16 |
17 | # Variable de salida: El candidato continua en el proceso de seleccion
18 | # o "El candidato no continua en el proceso de seleccion"
19 | #Cualquier valor no tabulado el programa sera "Se presento un error"
20 |
21 | #Ejemplos:
22 | # afrodescendiente 1 400000 -> El candidato continua en el proceso de ..
23 | # [(0.2*2)+(1*3)+(1*5)]/(2+3+5)= (0.4+3+5)
24 | # gitano 4 4542630 -> El candidato no continua en el proceso de ....
25 |
26 | candidato = input().split()
27 | etnia = candidato[0]
28 | estrato = candidato[1]
29 | ingresos = candidato[2]
30 |
31 | reconocimientoEtnico = {
32 | "sinReconocimiento": 0,
33 | "afrodescendiente": 0.2,
34 | "indigena": 0.4,
35 | "raizal": 0.6,
36 | "palenquero": 0.8,
37 | "gitano": 1
38 | }
39 |
40 | estratoSocioEconomico = {
41 | "1": 1,
42 | "2": 0.8,
43 | "3": 0.5,
44 | "4": 0.2,
45 | "5": 0,
46 | "6": 0
47 | }
48 |
49 | def ingresoNucleoFamiliar(ingresos):
50 | salarioMinimo = 908526
51 | ingreso = int(ingresos)
52 | if ingreso < salarioMinimo :
53 | return 1
54 | elif ingreso >= 1 | ingreso < (2*salarioMinimo):
55 | return 0.8
56 | elif ingreso >= (2*salarioMinimo) | ingreso < (4*salarioMinimo):
57 | return 0.6
58 | elif ingreso >= (4*salarioMinimo) | ingreso < (5*salarioMinimo):
59 | return 0.2
60 | elif ingreso >= (5*salarioMinimo):
61 | return 0
62 |
63 | def puntajeCandidato():
64 | sumatoriaPesoVariables = (reconocimientoEtnico[etnia]*2)+((estratoSocioEconomico[estrato])*3)+(ingresoNucleoFamiliar(ingresos)*5)
65 | sumatoriaPeso = 2+3+5
66 | resultado = sumatoriaPesoVariables/sumatoriaPeso
67 |
68 | if resultado < 0.5 :
69 | print("El candidato no continua en el proceso de seleccion")
70 | elif resultado >= 0.5 :
71 | print("El candidato continua en el proceso de seleccion")
72 |
73 |
74 |
75 |
76 |
--------------------------------------------------------------------------------
/Pruebas/pruebas.py:
--------------------------------------------------------------------------------
1 | from typing import Counter
2 | import matplotlib.pyplot as plt
3 | import numpy as np
4 | import pandas as pd
5 | import datetime
6 |
7 | dictc = {"country": ["Brazil", "Russia", "India",
8 | "China", "South Africa", "Colombia"],
9 | "capital": ["Brasilia", "Moscow", "New Dehli",
10 | "Beijing", "Pretoria", "Bogot ́a"],
11 | "area": [8.516, 17.10, 3.286, 9.597, 1.221, 1.142],
12 | "population": [200.4, 143.5, 1252, 1357, 52.98, 49.65] }
13 |
14 | brics = pd.DataFrame(dictc)
15 | # country capital area population
16 | #0 Brazil Brasilia 8.516 200.40
17 | #1 Russia Moscow 17.100 143.50
18 | #2 India New Dehli 3.286 1252.00
19 | #3 China Beijing 9.597 1357.00
20 | #4 South Africa Pretoria 1.221 52.98
21 | #5 Colombia Bogot ́a 1.142 49.65
22 |
23 | ventasPaises = pd.read_csv("SalesJan2009.csv")
24 | ventasPaises.head(3)
25 | # Transaction_date Product Price ... Last_Login Latitude Longitude
26 | # 0 1/2/2009 6:17 Product1 1200 ... 1/2/2009 6:08 51.500000 -1.116667
27 | # 1 1/2/2009 4:53 Product1 1200 ... 1/2/2009 7:49 39.195000 -94.681940
28 | # 2 1/2/2009 13:08 Product1 1200 ... 1/3/2009 12:32 46.188060 -123.830000
29 | # 3 1/3/2009 14:44 Product1 1200 ... 1/3/2009 14:22 -36.133333 144.750000
30 | # 4 1/4/2009 12:56 Product2 3600 ... 1/4/2009 12:45 33.520560 -86.802500
31 | # .. ... ... ... ... ... ... ...
32 | # 992 1/22/2009 14:25 Product1 1200 ... 3/1/2009 3:37 54.583333 -5.933333
33 | # 993 1/28/2009 5:36 Product2 3600 ... 3/1/2009 4:40 -20.360278 57.366111
34 | # 994 1/1/2009 4:24 Product3 7500 ... 3/1/2009 7:21 42.946940 -76.429440
35 | # 995 1/8/2009 11:55 Product1 1200 ... 3/1/2009 7:28 52.083333 0.433333
36 | # 996 1/12/2009 21:30 Product1 1200 ... 3/1/2009 10:14 43.073060 -89.401110
37 | #[997 rows x 12 columns]
38 | cantidadPais = Counter(ventasPaises["Country"])
39 | print(cantidadPais) # diccionario con la cantidad de veces que aparece
40 | # un pais en el archivo
41 | print(cantidadPais.most_common(3)) #[('United States', 462), ('United Kingdom', 100), ('Canada', 76)]
42 |
43 | ventasPaises["Transaction_date"] = pd.to_datetime(ventasPaises["Transaction_date"])
44 | A = (ventasPaises['Transaction_date']
45 | .dt.floor("d")
46 | .value_counts()
47 | .rename_axis("date")
48 | .reset_index(name="num ventas"))
49 |
50 | G = A.plot(x="date", y="num ventas", color="green", title="Ventas por fecha")
51 | plt.show()
--------------------------------------------------------------------------------
/RetoMisionTic/nodulosTiroideos.py:
--------------------------------------------------------------------------------
1 | #Clasificación de nódulos tiroideos y acciones a tomar
2 |
3 | #TI-RADS prueba de clasificación de nódulos tiroideos.
4 | #Desarrollar un programa para la emisión de alertas tempranas
5 | #segun la tablas.
6 |
7 | #El programa debe leer las variables de cada caracteristica.
8 | #Debe decir el nivel de sospecha y si requiere AAF
9 |
10 | #Nota: para los focos ecogénicos utilice 4 variables y las
11 | #que no apliquen deben tener valor de 0 y las que apliquen
12 | #valor de 1.
13 |
14 | #Ejemplos:
15 | # C1 E1 F2 M3 0 1 0 0 2 -> Moderadamente sospechoso, AAF
16 | # C1 E1 F1 M1 0 1 1 0 1 -> Levemente sospechoso, seguimiento
17 | # C1 E1 F1 M1 1 0 0 0 2 -> Benigno, no AAF
18 |
19 | variables = input().split()
20 | composicion = variables[0]
21 | ecogenicidad = variables[1]
22 | forma = variables[2]
23 | margen = variables[3]
24 | focosE = [variables[4],variables[5],variables[6],variables[7]]
25 | aaf = variables[8]
26 |
27 | composiciones = {
28 | "C1": 0,
29 | "C2": 0,
30 | "C3": 0.5,
31 | "C4":1
32 | }
33 |
34 | ecogenicidades = {
35 | "E1": 0,
36 | "E2": 0.5,
37 | "E3": 1,
38 | "E4": 1.5
39 | }
40 |
41 | formas = {
42 | "F1": 0,
43 | "F2": 1.5
44 | }
45 |
46 | margenes = {
47 | "M1": 0,
48 | "M2": 0,
49 | "M3": 1,
50 | "M4": 1.5
51 | }
52 |
53 | focosErcogenicos = [0,0.5,1,1.5]
54 |
55 | def sumatoriaFocos():
56 | sumatoria = 0
57 | for x in range (0,len(focosE)):
58 | if focosE[x] == "1":
59 | sumatoria = sumatoria + focosErcogenicos[x]
60 | return sumatoria
61 |
62 | def clasificacion():
63 |
64 | puntaje = composiciones[composicion] + ecogenicidades[ecogenicidad] + formas[forma] + margenes[margen] + sumatoriaFocos()
65 | if puntaje == 0 and puntaje < 1:
66 | print("Benigno, no AAF")
67 | elif puntaje >= 1 and puntaje < 1.5:
68 | print("No sospechoso, no AAF")
69 | elif puntaje >= 1.5 and puntaje < 2:
70 | calificacionAAF("Levemente sospechoso")
71 | elif puntaje >= 2 and puntaje <= 3:
72 | calificacionAAF("Moderadamente sospechoso")
73 | elif puntaje > 3:
74 | calificacionAAF("Altamente sospechoso")
75 |
76 | def calificacionAAF(tipo):
77 |
78 | if tipo == "Levemente sospechoso":
79 | if int(aaf) >= 2.5: print(tipo + ", AAF")
80 | elif int(aaf) <2.5: print(tipo + ", seguimiento")
81 | elif tipo == "Moderadamente sospechoso":
82 | if int(aaf) >= 1.5: print(tipo + ", AAF")
83 | elif int(aaf) < 1.5: print(tipo + ", seguimiento")
84 | elif tipo == "Altamente sospechoso":
85 | if int(aaf) >=1: print(tipo + ", AAF")
86 | elif int(aaf) < 1: print(tipo + ", seguimiento")
87 |
88 | clasificacion()
89 |
90 |
91 |
92 |
93 |
94 |
95 |
--------------------------------------------------------------------------------
/RetosUNAL/P2/reto1.py:
--------------------------------------------------------------------------------
1 | # Reto 1.Grupo P2: Profesor Juan Esteban Caicedo Palacio
2 | # Límite de entrega: Wednesday, 2 de June de 2021, 12:00
3 | # Número máximo de ficheros: 1
4 | # Tipo de trabajo: Individual
5 | # Juan, Pedro y Camila son estudiantes del colegio municipal “Mis Tapitas”. Al recibir las calificaciones de la asignatura de matemáticas, encontraron que su profesor les había puesto un acertijo para calcular la nota de cada uno.
6 |
7 | # Para esto, el profesor definió las siguientes condiciones:
8 |
9 | # Se conoce la calificación obtenida por Juan como número entero
10 |
11 | # La calificación obtenida por Juan es igual, a la nota obtenida por Pedro menos cuatro, todo esto divido entre dos
12 |
13 | # La nota de Pedro es igual a cinco veces la nota de Camila menos la nota obtenida por Juan
14 |
15 | # Además, el profesor definió un escalafón de acuerdo a la calificación obtenida:
16 |
17 | # Si obtiene una nota entre 0 y 20 se encontrará en el rango ‘uno’
18 |
19 | # Si obtiene una nota entre 21 y 30 se encontrará en el rango ‘dos’
20 |
21 | # Si obtiene una nota entre 31 y 50 se encontrará en el rango ‘tres’
22 |
23 | # Si obtiene una nota mayor a 50 se encontrará en el rango ‘cuatro’.
24 |
25 | # De esta manera, ellos acuden a usted como programador de Misión TIC 2022 para que les ayude a crear un programa en el cual puedan calcular fácilmente la nota y el rango en el que se encuentra la nota de Camila.
26 |
27 |
28 |
29 | # Entrada:
30 |
31 | # La entrada será la calificación obtenida por Juan.
32 |
33 | # Salida:
34 |
35 | # Tres enteros que representan las calificaciones de los tres estudiantes. Además, se debe imprimir en la siguiente línea el rango en la que se encuentra la nota de Camila.
36 |
37 |
38 |
39 | # Entrada Salida
40 |
41 | #32 32 68 20
42 | # uno
43 |
44 | #29 29 62 18
45 | # dos
46 |
47 |
48 | #Solución
49 |
50 | #La entrada es la calificación de Juan
51 |
52 | print("== Entrada ==")
53 | calificacion_juan = int(input())
54 |
55 | #Con los datos del enunciado se llega a
56 | #calificacion_juan = (calificacion_pedro - 4)/2
57 |
58 | calificacion_pedro = (calificacion_juan*2) + 4
59 |
60 | #calificacion_pedro = 5*calificacion_camila - calificacion_juan
61 |
62 | calificacion_camila = int((calificacion_pedro + calificacion_juan)/5)
63 |
64 |
65 | #Salida
66 | print("== Salida ==")
67 |
68 | print(f"{calificacion_juan} {calificacion_pedro} {calificacion_camila}")
69 |
70 | def calcular_rango(nota):
71 | if(nota >= 0 and nota <= 20):
72 | print("uno")
73 | elif(nota <= 30):
74 | print("dos")
75 | elif(nota <= 50):
76 | print("tres")
77 | else:
78 | print("cuatro")
79 |
80 | calcular_rango(calificacion_camila)
--------------------------------------------------------------------------------
/RetosUNAL/P83/reto-5/Readme.md:
--------------------------------------------------------------------------------
1 | # Reto #5
2 |
3 | #### Solución #1 realizada por: [@g1alexander](https://github.com/g1alexander)
4 |
5 |
6 |
7 | ---
8 |
9 | La tienda oficial de la Universidad Nacional decide crear una librería que le permite a la persona que atiende interactuar mucho más rápido con los usuarios que para van a comprar láminas del álbum de la chocolatina Jet. Esta librería debe permitirle a la persona que atiende poder filtrar láminas repetidas de un usuario, validar un tipo de lámina de un conjunto de láminas, verificar cuales láminas no se tienen en comparación con otro grupo de láminas y obtener el número de láminas que se pueden intercambiar de entre dos grupos. Se le ha pedido a usted que construya la librería para la tienda universitaria que tenga las cuatro (4) funciones mencionadas anteriormente. Nota: Esta librería no debe pedir entradas ni retornar valores de salida ya que estas se colocan como parámetros y retornos de las funciones.
10 |
11 | - Función # 1: filtrar_laminas: A partir de una lista de láminas, retorna una nueva con los números de las láminas que solo se encuentras una vez.
12 |
13 | | Entrada | Salida |
14 | | ------------------------------------------------------ | ------------------ |
15 | | [3, 4, 6, 2, 1, 3, 3, 1, 1, 6, 6, 4, 1, 5, 5, 2, 5, 4] | [3, 4, 6, 2, 1, 5] |
16 |
17 | - Función # 2: validar_tipo: Dada una lista de índices, una lista de láminas, y un tipo de láminas, retorna la lista de índices filtrada en donde se dejan los índices en donde coincida en la lista de láminas el tipo de lámina que se busca.
18 | | Entrada | Salida |
19 | | ------------------------------------------------------ | ------------------ |
20 | | [13, 10, 17, 0, 6, 18, 16, 3, 2] #indices | [10, 6, 16] |
21 | | [1, 5, 4, 1, 2, 4, 3, 3, 1, 1, 3, 1, 1, 1, 1, 4, 3, 5, 2] | |
22 | | #laminas | |
23 | | 3 # tipo | |
24 |
25 | - Función # 3: listar_faltantes: Dadas la lista del usuario y la lista de intercambiables de la tienda, la función debe retornar una lista con las láminas que no estén dentro de la lista de intercambiables de la tienda.
26 | | Entrada | Salida |
27 | | ------------------------------------------------------ | ------------------ |
28 | | [16, 6, 0, 14, 8, 5, 22, 19, 25, 26, 9, 13] # lista_usuario | [16, 0, 5, 22, 26, 9] |
29 | | [25, 14, 7, 3, 4, 1, 8, 17, 6, 19, 13] # lista_intercambiables | |
30 |
31 | - Función # 4: numero_intercambiables: Dadas las listas de un usuario y la lista de intercambiables de la tienda, la función debe decir el número de láminas que puede se pueden intercambiar entre el usuario y la tienda (Puede ayudarse de la función listar_faltantes).
32 | | Entrada | Salida |
33 | | ------------------------------------------------------ | ------------------ |
34 | | [3, 4, 19, 11, 1, 16, 0, 6, 17, 9]| 5|
35 | | [5, 6, 1, 14, 4, 20, 13, 12] | |
36 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_1/README.org:
--------------------------------------------------------------------------------
1 | * Reto #1 - P30
2 |
3 | Plan de Vacunación para el COVID-19 en Polombia
4 |
5 | ** Descripción
6 | Se quiere priorizar la vacunación de la ciudadanía y se estructuraron
7 | una serie de fases de vacunación (*Fase 1*, *Fase 2*, *Fase 3*, *Fase
8 | 4*). La asignación de las personas a cada una de las fases está basada
9 | en una serie de factores de riesgo, los cuales al ser calculados
10 | permitirían dar la fase de vacunación en la cual estará.
11 |
12 | Los valores de cada factor de riesgo serán obtenidos de la siguiente
13 | manera:
14 |
15 | - El primer factor de riesgo (FR-1) está asociado a un Índice de
16 | Vulnerabilidad propuesto por el instituto de planeación ADNE. Este
17 | índice es construido de acuerdo con parámetros como: comorbilidad,
18 | hacinamiento, densidad poblacional, entre otros. Este Índice de
19 | Vulnerabilidad es transformado a factor de riesgo utilizando la
20 | función de parte entera ~int~, la cual toma un número real (Índice de
21 | Vulnerabilidad) y devuelven el número entero más próximo (FR-1).
22 |
23 | - El segundo factor de riesgo (FR-2) es construido usando la siguiente
24 | relación: el doble del valor del primer factor de riesgo (FR-1) es
25 | igual al valor del segundo factor de riesgo (FR-2) menos cuatro.
26 |
27 | - El tercer factor de riesgo (FR-3) es tomado como relación de FR-1 y
28 | FR-2 como sigue: cinco veces el valor del tercer factor de riesgo
29 | (FR-3) es igual a la suma de los valores obtenidos en el primer y
30 | segundo factor de riesgo, FR-1 y FR-2 respectivamente.
31 |
32 | - La fase de vacunación de la persona estará dada por el valor
33 | obtenido del tercer factor de riego FR-3. Si el valor de FR-3 está
34 | entre 0 y 20, la persona estará priorizado para la fase 1. Si el
35 | valor se encuentra entre 21 y 30, la persona estará priorizado para
36 | la fase 2. En caso de que el valor de FR-3 este entre 31 y 50, su
37 | priorización será la fase 3. Finalmente, si el valor de FR-3 es
38 | mayor a 51, la persona será priorizada para la fase 4.
39 |
40 | ** Tarea
41 | Elabora un programa que permita, dado el Índice de Vulnerabilidad de
42 | la persona, conocer los valores obtenidos en los diferentes factores
43 | de riesgo (FR-1, FR-2, FR-3), así como la fase de vacunación en la que
44 | se encuentra cada persona.
45 |
46 | *Nota*: Los factores de riesgo son números enteros, en caso de
47 | necesitarlo se puede usar la función de parte entera ~int~.
48 |
49 | ** Entrada
50 | La entrada es un número que representa el Índice de Vulnerabilidad de
51 | la persona.
52 |
53 | ** Salida
54 | Tres enteros separados por espacio que representan las valores para
55 | cada uno de los factores de riesgo FB-1, FB-2 y FB-3. En la siguiente
56 | línea en letras la fase de vacunación en la cual se encuentra la
57 | persona.
58 |
59 | *** Ejemplo Entrada
60 | #+BEGIN_SRC
61 | 178
62 | #+END_SRC
63 | *** Ejemplo Salida
64 | #+BEGIN_SRC
65 | 178 360 107
66 | cuatro
67 | #+END_SRC
68 |
--------------------------------------------------------------------------------
/RetosUNAL/P30/reto_5/README.org:
--------------------------------------------------------------------------------
1 | * Reto #5 - P30
2 | ** Descipción
3 | Ahora la pizzería "Mominos" quiere implementar pedidos a domicilio
4 | para sus clientes. Para ello, la pizzería requiere un sistema que
5 | permita hacer control de las pizzas que deben llevar los repartidores
6 | y la cantidad de repartidores necesarios para cumplir la demanda del
7 | día.
8 |
9 | ** Tarea
10 | Se debe desarrollar una librería llamada =control_pizzeria=. Esta
11 | librería debe contener las siguientes funcionalidades:
12 |
13 | - _(Vale 1)_ Una función llamada *pedidos*, que resume en una lista
14 | los diferentes tipos de pizza que han solicitado los clientes.
15 |
16 | *Argumento*: Lista de tipos de pizza que los clientes pidieron, -
17 | =["M", "V", "P", "P", "H", "H", "M", "M", "P", "C"]=
18 |
19 | *Salida*: Lista que resume los diferentes tipos de pizza. - =["M",
20 | "V", "P", "H", "C"]=
21 |
22 | - _(Vale 1)_ Una función *debo_llevar*, que dada una lista de códigos
23 | de repartidores disponibles en el día, el listado de pizzas que la
24 | pizzería debe repartir ese día, y el tipo de pizza a llevar,
25 | consulte cuales repartidores están disponibles para llevar ese tipo
26 | de pizza.
27 |
28 | *Nota*: a cada repartidor se le asigna un único tipo de pizza, el
29 | identificador del repartidor indica la posición dentro del listado
30 | de pizzas que él puede entregar.
31 |
32 | *Argumento*:
33 | 1. Lista de los códigos de los repartidores disponibles. - =[1, 3,
34 | 6, 8]=.
35 | 2. Lista de tipos de pizzas que los clientes reservaron. - =["M",
36 | "V", "P", "P", "H", "H", "M", "M", "P", "C"]=.
37 | 3. Cadena de texto con el tipo de pizza a llevar. - ='P'=.
38 |
39 | *Salida*: Lista de repartidores disponibles para llevar este tipo de
40 | pizza. - =[3, 8]=.
41 |
42 | - _(Vale 1)_ Una función llamada *faltan_repartidores*, que dada la
43 | lista de todos los repartidores disponibles en la pizzería y los
44 | repartidores que ya tienen una entrega asignada, consulte cuales
45 | repartidores aún están disponibles para hacer domicilios.
46 |
47 | *Argumento*:
48 | 1. Lista de los códigos de los repartidores. - =[3, 5, 7, 10, 15,
49 | 16]=.
50 | 2. Lista de los códigos de los repartidores que ya tienen un una
51 | entrega asignada. - =[4, 10, 5, 8]=.
52 |
53 | *Salida*: Lista de repartidores disponibles para hacer domicilios. -
54 | =[3, 7, 15, 16]=.
55 |
56 | - _(Vale 1)_ Una función *posible_intercambio*, que dada la lista de
57 | todos los repartidores disponibles en la pizzería y otra lista con
58 | los repartidores auxiliares que tiene la pizzería, consulte la
59 | cantidad de repartidores auxiliares que NO están trabajando en este
60 | momento en la pizzería.
61 |
62 | *Argumento*:
63 | 1. Lista de los códigos de los repartidores disponibles. - =[3, 5,
64 | 7, 10, 15, 16]=
65 | 2. Lista de los códigos de los repartidores auxiliares que tiene
66 | la pizzería. - =[4, 10, 5, 8]=
67 | *Salida*: Cantidad de repartidores que No están trabajando en este
68 | momento en la pizzería. - =2=. Los 2 repartidores auxiliares que No
69 | están trabajando en la pizzería en este momento serían =[4, 8]=.
70 |
71 | Este programa no requiere entradas para su ejecución en la plataforma
72 | de pruebas, ni generará salidas. Debe cumplir el desarrollo antes
73 | mencionado, prestando especial atención a los nombres de las funciones
74 | indicadas en cada caso.
75 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/sesion23.py:
--------------------------------------------------------------------------------
1 | '''
2 | Modele mediante una función matemática y diseñe un
3 | programa recursivo que calcule la suma de los primeros
4 | n cuadrados de los números naturales
5 | '''
6 |
7 | def alCuadrado(n):
8 | if(n == 0):
9 | return 0
10 | return n**2 + alCuadrado(n-1)
11 |
12 | #print(alCuadrado(2))
13 |
14 | '''
15 | Modele mediante una funcion matematica y disene un programa
16 | recursivo sin cadenas, tuplas o listas que determine la cantidad de
17 | dıgitos que componen un n ́umero natural n. Por ejemplo,
18 | longitud(1230321) = 7.
19 | '''
20 |
21 | def longitud(numero):
22 | if(numero/10 == 0):
23 | return 0
24 | return 1 + longitud(int(numero/10))
25 |
26 | print(longitud(1356))
27 |
28 | '''
29 | Modele mediante una funcion matematica y disene un programa sin
30 | cadenas, tuplas o listas que retorne el ́ultimo dıgito de un numero
31 | natural n (le ́ıdo de izquierda a derecha). Por ejemplo,
32 | ultimo(13579) = 9.
33 | '''
34 |
35 | def ultimo(numero):
36 | size = longitud(numero)-1 #Len para numeros
37 | eliminar = 10**size
38 | if size == 0:
39 | return numero
40 | else:
41 | return ultimo(numero-eliminar)
42 |
43 | print(ultimo(4569))
44 |
45 | '''
46 | Modele mediante una funcion matematica y disene un programa
47 | recursivo sin cadenas, tuplas o listas que dado un numero natural
48 | nelimine el ́ultimo dıgito del numero. Por ejemplo,
49 | elimina ult(654321) = 65432.
50 | '''
51 |
52 | def eliminaUlt(numero):
53 | if(numero == 0):
54 | return 0
55 | size = 10**(longitud(numero)-2)#Len para numeros
56 | sumar = int(numero/(size*10))*size
57 | if(sumar == 0):
58 | return 0
59 | restar = int(numero/(size*10))*(size*10)
60 | return int(int(numero/(size*10))*size + eliminaUlt(numero-restar))
61 |
62 | print(eliminaUlt(10))
63 |
64 | '''
65 | Modele mediante una funcion matematica y disene un programa
66 | recursivo sin cadenas, tuplas o listas que calcule la suma de los dıgitos
67 | que componen un n ́umero natural n. Por ejemplo,
68 | suma digitos(123456) = 21.
69 | '''
70 |
71 | def sumaDigitos(numero):
72 | size = 10**(longitud(numero)-1)
73 | if(size == 1):
74 | return numero
75 | resta = int(numero/size)*size
76 | return int(numero/size) + sumaDigitos(numero-resta)
77 |
78 | print(sumaDigitos(4545))
79 |
80 | '''
81 | Modele mediante una funcion matematica y disene un programa
82 | recursivo sin cadenas, tuplas o listas que retorne el primer dıgito de
83 | un numero natural n (le ́ıdo de izquierda a derecha). Por ejemplo,
84 | primero(86420) = 8.
85 | '''
86 |
87 | def primerNumero(numero):
88 | size = 10**(longitud(numero)-1)
89 | return int(numero/size)
90 |
91 | print(primerNumero(4))
92 |
93 | '''
94 | Modele mediante una funcion matematica y disene un programa
95 | recursivo sin cadenas, tuplas o listas que dado un numero natural n
96 | elimine el primer dıgito del n ́umero. Por ejemplo,
97 | elimina pri(654321) = 54321.
98 | '''
99 |
100 | def eliminaPrimero(numero):
101 | size = 10**(longitud(numero)-1)
102 | eliminar = (int(numero/size))*size
103 | return numero - eliminar
104 |
105 | print(eliminaPrimero(654321))
106 |
107 | '''
108 | Modele mediante una funcion matematica y disene un programa
109 | recursivo sin cadenas, tuplas o listas que dado un n ́umero natural n
110 | inserte un dıgito al comienzo del numero. Por ejemplo,
111 | inserta(7, 654321)
112 | '''
113 |
114 | def insertar(n, numero):
115 | size = 10**(longitud(numero))
116 | sumar = n * size
117 | return sumar + numero
118 |
119 | print(insertar(7, 654321))
120 |
121 | '''
122 | Modele mediante una funcion matematica y disene un programa
123 | recursivo sin cadenas, tuplas o listas que invierta la cifras de un
124 | numero n dado. Por ejemplo, inversa(654321) = 123456.
125 | '''
126 |
127 | def inversa(numero, n=0):
128 | if(longitud(numero) == 0):
129 | return 0
130 | size = 10**(longitud(numero)-1)
131 | eliminar = int(numero/size)*size
132 | return int(numero/size)*(10**n) + inversa((numero-eliminar), n+1)
133 |
134 | print(inversa(654321))
135 |
136 | '''
137 | Modele mediante una funcion matematica y disene un programa
138 | recursivo sin cadenas, tuplas o listas que determine si un numero es
139 | capicua. Un numero se dice palındromo si al leerlo de izquierda a
140 | derecha es lo mismo que leerlo de derecha a izquierda. Por ejemplo,
141 | capicua(1) = V, capicua(1234321) = V, capicua(123421) = F.
142 | '''
143 |
144 | def capicua(numero):
145 | if(numero == inversa(numero)):
146 | return True
147 | else:
148 | return False
149 |
150 | print(capicua(123421))
--------------------------------------------------------------------------------
/RetosUNAL/P21/reto_2/reto2_Ingrid.py:
--------------------------------------------------------------------------------
1 | '''
2 | Ingrid Echeverri Montoya
3 | *Github: @IngridE
4 | *Twitter: @Ingrid_E_
5 |
6 | Reto 2: Ciclos
7 | Resumen:
8 | Un casino quiere implementar un juego con 2 jugadores.
9 | Cada jugador escoge un conjunto de letras.
10 | La maquina escoge al azar un conjunto de letras.
11 |
12 | Por cada letra del jugador, que sale en la maquina, gana un punto.
13 | La maquina imprime con cada letra quien va ganando.
14 | P - Jugador 1
15 | S - Jugador 2
16 | E - Empate.
17 |
18 | Input:
19 | -Letras Jugador 1
20 | -Letras Jugador 2
21 | -Letras Maquina
22 | Output:
23 | -Resultado del juego
24 |
25 | Ejemplo:
26 |
27 | Input:
28 | Jugador 1 -> HBKM
29 | Jugador 2 -> MFZK
30 | Maquina -> EOBZYFYUFRRCHGO
31 | Output:
32 | -> EEPEESSSSSSSSSS
33 |
34 | '''
35 |
36 | def isString(string:str) -> None:
37 | '''
38 | Revisa si la cadena contiene solo letras del alfabeto y no contiene
39 | numeros, símbolos, etc.. Se llama recursivamente hasta que el input solo
40 | contenga letras.
41 |
42 | @param string: Cadena que se revisa
43 | '''
44 | containsNumbers = False
45 | for i in string:
46 | if not str(i).isalpha():
47 | containsNumbers = True
48 | if containsNumbers == True:
49 | print("Incorrect Input, use only letters!")
50 | string = input("->")
51 | isString(string)
52 |
53 | #Llamada por consola de las variables
54 | #playerOne = input("Player 1: ").upper()
55 | #isString(playerOne)
56 | #playerTwo = input("Player 2: ").upper()
57 | #isString(playerTwo)
58 | #machine = input("Machine: ").upper()
59 | #isString(machine)
60 |
61 | #Donde se guardara el puntaje y resultado final.
62 | puntaje = [0, 0]
63 | resultado = ""
64 |
65 |
66 | def wordGame() -> None :
67 | '''
68 | Compara las palabras de los jugadores con la palabra de la maquina, calcula
69 | su puntaje y resultado. Utiliza 2 ciclos for para comparar cada letra de la maquina,
70 | con todas las letras de la palabra de los jugadores.
71 | '''
72 | for i in machine:
73 | for j in range(len(playerOne)):
74 | if i == playerOne[j]:
75 | puntaje[0] += 1
76 | if i == playerTwo[j]:
77 | puntaje[1] += 1
78 | if puntaje[0] == puntaje[1]:
79 | resultado += "E"
80 | elif puntaje[0] > puntaje[1]:
81 | resultado += "P"
82 | else:
83 | resultado += "S"
84 |
85 | #wordGame()
86 |
87 | #print(resultado)
88 |
89 | '''
90 | Ingrid Echeverri Montoya
91 | *Github: @IngridE
92 | *Twitter: @Ingrid_E_
93 |
94 | Reto 2: Grupo P21
95 | Resumen:
96 | Se va a elegir el consejo de administración, a partir de dos planchas, cada uno con
97 | n candidatos que se identifica con una letra única. Con cada voto el programa incrementa
98 | un contador.
99 |
100 | Entrada:
101 | - Serie de letras integrantes plancha 1
102 | - Serie de letras integrantes plancha 2
103 | - Serie de letras de los votos.
104 |
105 | Con cada letra de voto, se imprime quien va ganando.
106 | P = Plancha 1
107 | N = Plancha 2
108 | I = Empate
109 |
110 | Salida:
111 | -Letra de quien va ganando por cada voto.
112 | '''
113 |
114 | def isString(string:str) -> None:
115 | '''
116 | Revisa si la cadena contiene solo letras del alfabeto y no contiene
117 | numeros, símbolos, etc.. Se llama recursivamente hasta que el input solo
118 | contenga letras.
119 |
120 | @param string: Cadena que se revisa
121 | '''
122 | containsNumbers = False
123 | for i in string:
124 | if not str(i).isalpha():
125 | containsNumbers = True
126 | if containsNumbers == True:
127 | print("Input incorrecto, porfavor ingresa solo letras!")
128 | string = input("->")
129 | isString(string)
130 |
131 | plancha1 = "ADFBC"
132 | isString(plancha1)
133 | plancha2 = "KLMNP"
134 | isString(plancha2)
135 | votos = "AXDDMNMCSSDFMPBLNBPHRANB"
136 | isString(votos)
137 |
138 | puntaje = [0,0]
139 |
140 |
141 | def resultadoVotacion() -> str :
142 | '''
143 | Revisar cada uno de los votos, y ver quien va ganando.
144 | @returns string: Resultado de quien iba ganando por cada voto.
145 | '''
146 | resultado = ""
147 | for i in votos:
148 | if i in plancha1:
149 | puntaje[0] += 1
150 | if i in plancha2:
151 | puntaje[1] += 1
152 |
153 | if puntaje[0] == puntaje[1]:
154 | resultado += "I"
155 | elif puntaje[0] > puntaje[1]:
156 | resultado += "P"
157 | else:
158 | resultado += "N"
159 | return resultado
160 |
161 | print(resultadoVotacion())
162 |
163 |
164 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/retox_Ingrid.py:
--------------------------------------------------------------------------------
1 | '''
2 | Ingrid Echeverri Montoya
3 | *Github: @IngridE
4 | *Twitter: @Ingrid_E_
5 |
6 | Contamos con x millones de pesos para invertir en 2 proyectos.
7 | 1- Comprar un apartamento
8 | * 360 millones de pesos
9 | * Cada año su valor sube t1%
10 | * Prestamo de 120 cuotas mensuales con tasa de interés t2%
11 | 2- Invertir todo en un proyecto
12 | * 120 meses retornan t3% del valor invertido.
13 | * 120 meses en arriendo por valor D
14 | * Cada año el arriendo sube t4%
15 |
16 | Teniendo:
17 | * 80 millones <= C <= 100 millones
18 | * 0.2 <= t1 <= 3.0
19 | * 3.5 <= t2 <= 6.5
20 | * 40 <= t3 <= 60
21 | * 1.0 <= t4 <= 3.0
22 | * 600 <= D <= 1500.000
23 |
24 | Elaborar un programa que reporte si comprar vivienda o invertir en
25 | el proyecto es más rentable.
26 |
27 | -> "Es más rentable invertir en vivienda con una diferencia de:
28 | $" + valor de ganancia (con dos decimales)
29 | -> "Es más rentable el proyecto, con una diferencia de:
30 | $" + valor de ganancia (con dos decimales)
31 |
32 | El arriendo y sus incrementos se realizan anticipado y el préstamo mas
33 | vencido al igual que la valoración del apartamento.
34 |
35 |
36 | Entrada:
37 | Valor c
38 | Valor t1
39 | Valor t2
40 | Valor t3
41 | Valor t4
42 | Valor D
43 |
44 | Salida:
45 | Es más rentable invertir en vivienda con una diferencia de: $500000.0
46 | o
47 | Es más rentable el proyecto, con una diferencia de: $500000.0
48 |
49 | Ejemplos:
50 | 1- Entrada:
51 | 80000000
52 | 0.2
53 | 3.5
54 | 40
55 | 1.0
56 | 600000
57 | Salida:
58 | Es más rentable el proyecto, con una diferencia de: $80136907.05
59 |
60 | 2- Entrada:
61 | 100000000
62 | 3.0
63 | 6.5
64 | 60
65 | 3.0
66 | 1500000
67 | Salida:
68 | Es más rentable invertir en vivienda con una diferencia de: $80850950.00
69 |
70 | Como obtener esa diferencia?
71 |
72 | * Ganancias Apartamento = Prestamo Total - Valor Apartamento Final
73 | * Ganancias Proyecto = Total Arriendo - Proyecto Final
74 | * Ganancias Apartamento - Ganancias Proyecto
75 |
76 | Calcular Mensual Vigente = [(1+t2/100)^(30/360)]-1
77 | Prestamo Mensual = Valor Pendiente
78 | Interés Mensual = Prestamo Mensual * Mensual Vigente
79 | Cuota Mensual = P_I*(MV*(1+MV^(120)))/((1+MV^(120))-1)
80 | Valor Pendiente Mensual = Prestamo Mensual + Interés Mensual - Cuota Mensual
81 | Valor Apartamento Anual = Valor Apt Anterior + ((Valor Apt Anterior * t1)/100)
82 | Valor Arriendo Anual = ((Valor Arriendo Anterior * t4)/100)+t4
83 | Proyecto al final = Valor Proyecto + ((Valor Proyecto * t3)/100)
84 | '''
85 |
86 | tests = [[80000000,0.2,3.5,40,1.0,600000],[100000000,3.0,6.5,60,3.0,1500000],[95000000,1.3,5,55,2,1268175.65]]
87 |
88 | #Entradas:
89 | dinero = float(input("C:")) #C
90 | interes_apartamento = float(input("t1:")) #t1
91 | interes_prestamo = float(input("t2:")) #t2
92 | interes_proyecto = float(input("t3:")) #t3
93 | interes_arriendo = float(input("t4:")) #t4
94 | arriendo = float(input("D:")) #D
95 |
96 | arriendo_total = 0.0
97 |
98 | mensual_vigente = ((1+interes_prestamo/100)**(30/360))-1
99 | valor_apartamento = 360000000
100 | prestamo_Inicial = -dinero+ valor_apartamento
101 | valor_pendiente = prestamo_Inicial
102 | cuota_Total = 0
103 |
104 | def prestamo_Mensual()->float:
105 | prestamo = valor_pendiente
106 | return prestamo
107 |
108 | def interes_Mensual()-> float:
109 | interes = prestamo_Mensual() * mensual_vigente
110 | return interes
111 |
112 | def cuota_Mensual()-> float:
113 | mensual = (mensual_vigente+1)**120
114 | cuota = prestamo_Inicial*(mensual_vigente*mensual)/(mensual-1)
115 | return cuota
116 |
117 | def valor_Pendiente_Mensual()->None:
118 | global valor_pendiente
119 | valor_pendiente = prestamo_Mensual() + interes_Mensual() - cuota_Mensual()
120 |
121 | def valor_Apartamento_Anual()->None:
122 | global valor_apartamento
123 | valor_apartamento = valor_apartamento + ((valor_apartamento * interes_apartamento)/100)
124 |
125 | def arriendo_Anual()->None:
126 | global arriendo, arriendo_total
127 | arriendo = arriendo+((arriendo*interes_arriendo)/100)
128 |
129 | def valor_Proyecto()->float:
130 | proyecto = dinero + ((dinero * interes_proyecto)/100)
131 | return proyecto
132 |
133 | def resultado():
134 | global arriendo_total
135 | for i in range(0,120+1):
136 | if i%12 == 0 and i!=0:
137 | arriendo_Anual()
138 | valor_Apartamento_Anual()
139 | arriendo_total += arriendo
140 | prestamo_Mensual()
141 | interes_Mensual()
142 | cuota_Mensual()
143 | valor_Pendiente_Mensual()
144 |
145 | cuota_Total = cuota_Mensual()*120+dinero
146 | ganancias_apartamento = valor_apartamento - cuota_Total
147 | ganancias_proyecto = valor_Proyecto()-arriendo_total
148 |
149 | if ganancias_apartamento > ganancias_proyecto:
150 | print("Es más rentable invertir en vivienda, con una diferencia de: $",round(ganancias_apartamento-ganancias_proyecto,2), sep='')
151 | elif ganancias_proyecto > ganancias_apartamento:
152 | print("Es más rentable el proyecto, con una diferencia de: $",round(ganancias_proyecto-ganancias_apartamento,2), sep='')
153 | else:
154 | print("Los dos proyectos son rentables")
155 | resultado()
156 |
157 |
--------------------------------------------------------------------------------
/RetosUNAL/P21/problemas_Clase/sesion19.py:
--------------------------------------------------------------------------------
1 | import json
2 | from os import sep
3 |
4 | '''Archivo JSON'''
5 | with open('files/EstructuraJSON.Json', 'r', encoding='utf-8') as archivo:
6 | estructuraJSON = json.load(archivo)
7 |
8 | '''
9 | Imprima los nombres completos (nombre y apellidos) de las personas
10 | que practican el deporte ingresado por el usuario.
11 | '''
12 | def practicanDeporte(deporte):
13 | personas = []
14 | for persona in estructuraJSON:
15 | if deporte.title() in estructuraJSON[persona]['deportes']:
16 | personas.append(persona)
17 | return personas
18 |
19 | #deporte = input('Deporte: ')
20 | #print(*practicanDeporte(deporte), sep="\n")
21 |
22 | '''
23 | Imprima los nombres completos (nombre y apellidos) de las personas
24 | que est ́en en un rango de edades dado por el usuario.
25 | '''
26 | def rangoDeEdades(rango):
27 | personas = []
28 | for persona in estructuraJSON:
29 | edad = estructuraJSON[persona]['edad']
30 | if edad >= int(rango[0]) and edad <= int(rango[1]):
31 | personas.append(persona)
32 | return personas
33 |
34 | #rangoEdad = input("Rango de edad, escribirlo como: 0 10\n").split()
35 | #print(*rangoDeEdades(rangoEdad))
36 | '''
37 | Cree un JSON de deportes como sigue:
38 | {
39 | "Ajedrez": ["jadiazcoronado",...,"dmlunasol"],
40 | "Futbol": ["jadiazcoronado",...],
41 | "Gimnasia": ["jadiazcoronado",...,"dmlunasol"],
42 | ....
43 | "Baloncesto": ["dmlunasol"...],
44 | }
45 | '''
46 | def deportePersona():
47 | deportes = {}
48 | for persona in estructuraJSON:
49 | personas = []
50 | deporte = estructuraJSON[persona]['deportes']
51 | for x in deporte:
52 | if x not in deportes.keys():
53 | deportes[x] = []
54 | deportes[x].append(persona)
55 | with open('files/newJSON.Json', 'w', encoding="utf-8") as newArchive:
56 | json.dump(deportes, newArchive, indent= 4)
57 |
58 | #deportePersona()
59 | '''
60 | Desarrolle un programa que lea dos archivos JSON, y encuentre los
61 | componentes clave:valor que son iguales en ambos. Genere un nuevo
62 | archivo JSON con las coincidencias exactas entre los dos archivos.
63 | '''
64 |
65 | def valoresIguales(archivo1, archivo2):
66 | with open(archivo1, 'r', encoding="utf-8") as a, open(archivo2, 'r',encoding="utf-8") as b:
67 | file1 = json.load(a)
68 | file2 = json.load(b)
69 |
70 | return checkDict(file1, file2)
71 |
72 | def checkDict(dic1, dic2):
73 | claves1 = list(dic1.keys());valores1 = list(dic1.values())
74 | claves2 = list(dic2.keys());valores2 = list(dic2.values())
75 | valoresIguales = {}
76 | for x in range(len(claves1)):
77 | clave = claves1[x]
78 | if clave in claves2:
79 | y = claves2.index(clave)
80 | if isinstance(valores1[x], dict) and checkDict(valores1[x],valores2[y]) != 0:
81 | valoresIguales[clave] = checkDict(valores1[x],valores2[y])
82 | if isinstance(valores1[x], list):
83 | valoresIguales[clave] = checkList(valores1[x],valores2[y])
84 | elif valores1[x] == valores2[y]:
85 | valoresIguales[clave] = valores1[x]
86 | if len(valoresIguales) == 0:
87 | return 0
88 | return valoresIguales
89 |
90 |
91 | def checkList(list1, list2):
92 | iguales = []
93 | for valor in list1:
94 | if valor in list2:
95 | iguales.append(valor)
96 | return iguales
97 |
98 |
99 | print(valoresIguales('files/persona1.Json', 'files/persona2.Json'))
100 |
101 | '''
102 | Desarrolle un programa que lea un archivo JSON, en el cual se
103 | encuentran las notas de los estudiantes del curso. Cada llave
104 | corresponde al código de cada estudiante, y su valor es una lista con
105 | las notas obtenidas en las actividades del curso. Se debe generar un
106 | nuevo archivo JSON que para uno de los estudiantes solo guarde el
107 | promedio de las notas obtenidas.
108 | '''
109 | def promedioNotas(archivo):
110 | with open(archivo, 'r', encoding="utf-8") as file:
111 | notasEstudiantes = json.load(file)
112 |
113 | promedio = {}
114 | for estudiante in notasEstudiantes:
115 | sumaNotas = 0
116 | cantidad = len(notasEstudiantes.get(estudiante))
117 | for notas in notasEstudiantes.get(estudiante):
118 | sumaNotas += notas
119 | promedio[estudiante] = sumaNotas/cantidad
120 | return promedio
121 |
122 | #print(promedioNotas('files/notas.Json'))
123 | '''
124 | Desarrollar un programa que lea un archivo JSON que contiene una
125 | serie de cadenas de caracteres en minúscula, cada una con su propia
126 | llave. Estas llaves tienen una codificación, a forma de encriptación, en
127 | donde las vocales est ́an descritas como otros símbolos: $ en vez de a,
128 | # en vez de e, * en vez de i, ¬ en vez de o, y + en vez de u. Una vez
129 | le ́ıdo el archivo, realice una desecriptación de todas las cadenas, es
130 | decir, convierta los símbolos a sus vocales correspondientes (si la
131 | cadena de entrada es ”h¬l$”, la cadena resultante ser ́ıa ”hola”), y
132 | guarde el resultado en un nuevo archivo JSON.
133 | '''
134 | #Sin terminar aun
135 | def encriptacion():
136 | codificacion = json.dumps({'$':'a', '#':'e', '*':'i', '¬':'o', '+':'u'})
137 | encriptacion = {'n¬mbr#':['s$r$', 'm$r*n'],'#st+d*¬s':['s*c¬l¬g*$','n+tr*c*¬n'],'#mpr#s$s':['h¬sp*t$l','cl*n*c$'],'c+mpl#$ñ¬s':['#n#r¬','01']}
138 |
139 | for clave in encriptacion:
140 | for valor in encriptacion.get(clave):
141 | for letra in valor:
142 | nombre = ''
143 | if letra in codificacion:
144 | nuevaLetra = codificacion.get(letra)
145 | nombre += nuevaLetra
146 | print(valor)
147 | encriptacion()
148 |
--------------------------------------------------------------------------------
/NotasDeClase/general.py:
--------------------------------------------------------------------------------
1 | from math import pi
2 | # pi es una variable global
3 | # pi = 3.141592653589793
4 |
5 | '''
6 | Las variables globales son muy útiles
7 | '''
8 |
9 | def volEsfera(r1):
10 | return (4/3)*pi*(r1**3)
11 |
12 | # Ciclos While
13 |
14 | def min_maquina():
15 | Xo = 1.0
16 | Xi = Xo / 2.0
17 | while Xi > 0.0:
18 | Xo = Xi
19 | Xi = Xo / 2.0
20 | return Xo
21 |
22 | #print("El minimo numero positivo", end=" ")
23 | #print("en esta maquina es", min_maquina())
24 |
25 | # Ejemplos de while
26 |
27 |
28 | i = 1
29 | anterior = 1
30 | nuevo = 1/2
31 |
32 | while nuevo < anterior:
33 | penultimo = anterior
34 | anterior = nuevo
35 | i+=1
36 | nuevo = 1/2**i
37 |
38 | #print(i-2,penultimo)
39 |
40 | #Ejemplo de for
41 | '''
42 | for i in range(10, 0,-1): #El tercer valor es el incremento
43 | print(i)
44 | '''
45 | #Calcular 2**n utilizando multiplicaciones sucesivas = 2 . 2 .2 . 2 ....n veces
46 |
47 | def dosElevado(n):
48 | prod = 1
49 | for i in range (1, n+1):
50 | prod*= 2
51 | return prod
52 | n = 5
53 |
54 | #print("2 elevado a la", n, "=", dosElevado(n))
55 |
56 | '''
57 | Pasos dosElvedo(n)
58 |
59 | Si queremos el resultado de 2^5 llamamos la función con 5.
60 |
61 | dosElevado(5):
62 | prod = 1
63 | for i in range (1,5+1): #Repetir 5 veces
64 | prod = 1 * 2 -> 2 # 1
65 | prod = 2 * 2 -> 4 # 2
66 | prod = 4 * 2 -> 8 # 3
67 | prod = 8 * 2 -> 16 # 4
68 | prod = 16 * 2 -> 32 #5 <- Stop
69 | return prod
70 |
71 | # Como prod = 35, entonces nos retorna 35
72 |
73 | '''
74 |
75 | #Cadenas
76 | print("Cadena con un tabulado \t y una nueva \n linea")
77 | nombre = "Ingrid"
78 | apellido = "E"
79 |
80 | print(nombre + ' ' + apellido)
81 |
82 | print('ab' < 'ba')
83 | print('Rosas' > 'Rojas')
84 | print("Rojas" is "Rojas")
85 |
86 | nombre = "Ingrid E"
87 | for i in nombre:
88 | print (i, end=' ')
89 | print()
90 | palabra = "MisionTic 2022"
91 | print(palabra[0]) # M
92 | print(palabra[:5]) # Misio
93 | print(palabra[0:7]) # MisionT
94 | print(palabra[6:10]) # Tic
95 | print(palabra[:: 2]) # MsoTc22
96 |
97 | palabra = "Hola amigos buenos dias, Hola"
98 | print('primera:', palabra.find("Hola"))
99 | print('ultima:', palabra.rfind("Hola"))
100 |
101 | txt = "-----hola----+"
102 | x = txt.strip('-+')
103 | print(x)
104 |
105 | obj = "The avengers"
106 | print(obj.count('e'), end="; ")
107 | print(obj.count('e',4,len(obj)))
108 |
109 | cad = 'abcabcabcabcabc'
110 | print(cad.count('abc'))
111 |
112 | string = "Cien años de soledad"
113 | print(string) # Cien años de soledad
114 | replace = string.replace('Cien', 'Setenta')
115 | print(replace)
116 | replace = string.replace('años', 'dias')
117 | print(replace)
118 | replace = string.replace('a','#')
119 | print(replace)
120 |
121 | x = 3
122 | n = -2
123 |
124 | def potencia(x,n) -> float:
125 | p = 1.0
126 | if n > 0:
127 | for i in range(1,n+1):
128 | p *= x
129 | elif n < 0:
130 | for i in range(1,-n+1): #(1,-(-n)+1)
131 | p *= x
132 | p = 1.0/p
133 | return p
134 |
135 | print(potencia(x,n))
136 |
137 | print("Tabla de multiplicar de 1 al 9")
138 |
139 | for i in range(1, 10):
140 | print(i, ':', end='')
141 | for j in range(1,10):
142 | prod = i * j
143 | print('\t', prod, end='')
144 | print('', end='\n')
145 |
146 | print("TUPLAS")
147 | print()
148 |
149 | tupla = (10,9,8,7,6,5)
150 | print(tupla[::-1])
151 | print(tupla.index(10), tupla.index(8), tupla.index(5))
152 |
153 |
154 | repetidos = (1,1,1,1,3,2,3,2)
155 | print(repetidos.count(1))
156 | print(repetidos.count(2))
157 | print(repetidos.count(3))
158 | print(repetidos.count(4))
159 |
160 | print(max(tupla), min(tupla)) # 10 5
161 |
162 | nombre = "Ingrid"
163 | tupla_Nombre = tuple(nombre)
164 | print(tupla_Nombre)
165 |
166 | tipos_tuplas= ("holaa" ,122, 0.456)
167 |
168 | cadena1 = "23" #
169 | numero = 1234 #
170 | cadena = int(cadena1) + numero # Los dos tiene que ser tipo str para concatenar
171 |
172 | print(cadena) # Numero: 1234
173 | print(type(cadena)) #
174 |
175 | print("Listas")
176 | print()
177 |
178 | numList = [0,1,2,3]
179 | letterList = ['A','B','C']
180 |
181 | print(numList*3) # [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
182 | print(letterList * 2) # ['A', 'B', 'C', 'A', 'B', 'C']
183 |
184 | print(["Rojas", 123] < ["Rosas", 123]) # True
185 | print(["Rosas", 123] == ["rosas", 123]) # False
186 | print(["Rosas", 123] > ["Rosas", 23]) # True
187 | print(["Rosas", "123"] > ["Rosas", "23"]) # False
188 | #print(("Rosas", "123") > ("Rosas", 23)) #Error str > int no funciona
189 |
190 |
191 | text = ["cien", "años", "de", "soledad"]
192 | if "años" in text:
193 | print("Si esta en la lista")
194 | else:
195 | print("No esta en la lista")
196 |
197 | if "hola" not in text:
198 | print("No esta en la lista")
199 | else:
200 | print("Si esta en la lista")
201 |
202 |
203 | print("Ejercicios")
204 | print()
205 |
206 | # Leer una lista y convertir sus dígitos numéricos a enteros.
207 |
208 | def leerLista(texto):
209 | return input(texto).split(' ')
210 |
211 | #ll = leerLista('su lista: ') print(ll)
212 |
213 | '''
214 | Calcular el producto punto de dos puntos
215 | Producto v con w (v.w)
216 |
217 | Formula de Producto Punto
218 | v = (a1,b1,c1)
219 | u = (a2,b2,c2)
220 |
221 | producto_punto = (a1*a2)+(b1*b2)+(c1*c2)
222 | '''
223 |
224 | '''
225 | Punto directo vectores multiplicados
226 | v = (a1,b1,c1)
227 | u = (a2,b2,c2)
228 | [a1*a2,b1*b2,c1*c2]
229 | '''
230 |
231 |
232 | '''
233 | Hallar la mediana de un arreglo
234 | '''
235 |
236 | def mediana(A):
237 | A.sort()
238 | middle = int(round(len(A)/2, 0))
239 | print(A[middle])
240 |
241 | #mediana([6,-3,4,5,3,2])
242 |
243 |
244 | '''
245 | colocar los 0 al final del arreglo
246 | '''
247 |
248 | def zerosBack(list):
249 | for i in list:
250 | if i == 0:
251 | list.remove(i)
252 | list.append(i)
253 | print(list)
254 |
255 | zerosBack([0,0,0,5,6,0,7,-3,8,0,-2,0])
256 |
257 |
258 |
259 |
260 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # MisionTic2022
2 |
3 | ## Clase #1
4 | [Notas](/NotasDeClase/Clase1.md)
5 | 
6 |
7 | ## Input
8 |
9 | 
10 |
11 |
12 | ## Introducción
13 |
14 | ### Problemas
15 |
16 | La resolución de problemas es una habilidad muy importante de un programador.
17 |
18 | **Problema**: Cuando se desea encontrar uno o varios objetos desconocidos.
19 |
20 | Para solucionar un problema debemos saber que objetos conocemos y las relaciones entre ellos. Un programador no puede resolver un problema que no entiende.
21 |
22 | **Divide y vencerás**
23 | - Descomponer un problema en subproblemas. Resolver los subproblemas y se combinan para tener la solución general.
24 |
25 | #### Tipos de problemas:
26 | * Condicionado: Información necesaria para la solución.
27 | * Mal Condicionados: Sin información necesarias o respuesta sujeta a opinión.
28 | * Sentimientos, emociones, cultura, etc....
29 | * Relación no bien dada.
30 | * Computables: Secuencia de pasos, para definir la relación entre Entrada y Salida.
31 | * Sin solución: Indecibles o no Computables.
32 | * Tratables: Solución Finita.
33 | * Intratables: Crecimiento exponencial.
34 | * Solucionables: Salida valida para entrada dada.
35 | * No Solucionable: Se tiene claro la relación pero no es posible encontrar la salida.
36 |
37 | Analizar para entender y descomponer para resolver.
38 |
39 | "Todos en este país deberían aprender a programar una computadora, porque enseña como pensar" - Steve Jobs
40 |
41 | ### Algoritmos
42 |
43 | Problemas con secuencia finita de tareas bien definidas, para que desde una entrada se pueda generar una salida. Secuencia de pasos para llegar a la solución final.
44 |
45 | Un algoritmo de programación se escribe y puede ejecutarse en cualquier lenguaje que requiera.
46 |
47 | **Programado**: Descripción de la secuencia finita para que el computador solucione el problema.
48 |
49 | #### Caracteristicas de un algoritmo:
50 | * Precisión: Definido
51 | * Determinismo
52 | * Finitud
53 |
54 | #### Esta conformado por:
55 | * Datos: Información
56 | * Instrucciones: Las acciones
57 | * Estructuras de control: El orden de ejecución
58 |
59 | #### Recursos
60 | * Tiempo: Tiempo definido para ejecutar la operación.
61 | * Tiempo = tiempo * operaciones básicas
62 | * Espacio: Memoria que debe mantener
63 | * S = numero de bytes * variables del algoritmo
64 |
65 | Los programas necesitan ser ejecutados de manera rápida, para esto necesitan algoritmos ágiles que no tengan mucho tiempo de espera.
66 |
67 | Los algoritmos son una parte esencial de la programación.
68 |
69 | # Ciclos
70 | -15 de Junio 2021
71 |
72 | **Ciclos While**
73 |
74 | Estructura general
75 | ```python
76 | while(condición): # Una condición que en algún momento es falsa, oh se detiene en algún momento.
77 | código...
78 | break # Nos sirve para detener ciclos.
79 | ```
80 | **Ejemplos:**
81 |
82 | 1-
83 | ```python
84 | i = 0
85 | while (i<=6):
86 | print(i)
87 | i += 1 # Cuando la i > 6 la condición se vuelve falsa.
88 | ```
89 | 2-
90 | ```python
91 | i=2
92 | j=25
93 | while i < j:
94 | print(i,j,sep=", ") # Que hace sep=", " ?
95 | i *= 2
96 | j+= 10
97 | print("the end")
98 | print(i,j,sep=", ")
99 | ```
100 |
101 | Como encontrar el mínimo número positivo representable por la máquina:
102 |
103 | ```python
104 |
105 | def min_maquina():
106 | Xo = 1.0
107 | Xi = Xo / 2.0
108 | while Xi > 0.0:
109 | Xo = Xi
110 | Xi = Xo / 2.0
111 | return Xo
112 |
113 | print("El mínimo numero positivo", end=" ")
114 | print("En Esta maquina es", min_maquina())
115 | ```
116 | ```
117 | El minimo numero positivo en esta maquina es 5e-324
118 | ```
119 |
120 | El ciclo do while no existe como tal en Python. Pero se puede recrear.
121 | Es mejor intentar no usar break, en ciclos while.
122 |
123 | Mas Ejemplos:
124 |
125 | ```python
126 | dato = 1
127 | suma = 0
128 | i = 0
129 |
130 | while(dato !=0):
131 | dato = int(input("Ingrese un numero entero: "))
132 | suma += dato
133 | i += 1
134 | i -=1 # fuera del cuerpo del while
135 | promedio = suma/i
136 |
137 | print(i, suma, promedio)
138 | print(type(promedio))
139 |
140 | ````
141 |
142 |
143 | ```python
144 | i = 1
145 | anterior = 1
146 | nuevo = 1/2
147 |
148 | while nuevo < anterior:
149 | penultimo = anterior
150 | anterior = nuevo
151 | i+=1
152 | nuevo = 1/2**i
153 |
154 | print(i-2,penultimo)
155 |
156 | ```
157 |
158 | **Estudiar los incrementos de range en for**
159 |
160 |
161 | ```python
162 |
163 |
164 | for i in range(0, 3): #El incremento por default es 0
165 | print(i, end=" ") #-> 0 1 2
166 |
167 | for i in range(3, 0):
168 | print(i, end=" ") # Nada
169 |
170 | for i in range(-3, 0):
171 | print(i, end=" ") #-> -3 -2 -1
172 |
173 | for i in range(-6, 0, 2): #El tercer valor es el incremento
174 | print(i, end=" ") #-> -6 -4 -2
175 |
176 | for i in range(0, 6, 2):
177 | print(i, end=" ") #-> 0 2 4
178 |
179 | for i in range(10, 0, 2):
180 | print(i, end=" ") #-> Nada
181 |
182 | for i in range(10, 0, -2):
183 | print(i, end=" ") #-> 10 8 6 4 2
184 |
185 |
186 | for i in range(-10, 0, -2):
187 | print(i, end=" ") #Nada
188 |
189 | for i in range(-10, 0, 2):
190 | print(i, end=" ") # -> -10 -8 -6 -4 -2
191 |
192 | ```
193 |
194 | Podemos usar estos ciclos for para sacar los numeros impares o pares:
195 |
196 | ```python
197 | for i in range (1, 99+1, 2): # Numeros impares hasta el 99
198 | print("impar", i)
199 |
200 | for i in range(2,100+1,2): #Numeros pares hasta el 100
201 | print("pares", i)
202 | ```
203 |
204 | Calculas 2^n utilizando multiplicaciones sucesivas.
205 |
206 | ```python
207 | def dosElevado(n):
208 | prod = 1
209 | for i in range (1, n+1):
210 | prod*= 2
211 | return prod
212 | n = 5
213 |
214 | print("2 elevado a la", n, "=", dosElevado(n))
215 | ```
216 | ```
217 | 2 elevado a la 5 = 35
218 | ```
219 | Como funciona dosElevado?
220 |
221 | Si queremos el resultado de 2^5 llamamos la función con 5.
222 | -> dosElevado(5)
223 |
224 | **Pasos de la función:**
225 |
226 | dosElevado(5):
227 | * prod = 1
228 | * for i in range (1,5+1): **Repetir 5 veces**
229 | * prod = 1 * 2 = 2 *- Paso 1*
230 | * prod = 2 * 2 = 4 *- Paso 2*
231 | * prod = 4 * 2 = 8 *- Paso 3*
232 | * prod = 8 * 2 = 16 *- Paso 4*
233 | * prod = 16 * 2 = 32 *- Paso 5* **STOP**
234 | * return **prod**
235 |
236 | Como prod = 35, entonces nos retorna **35**
237 |
238 | ## Cadenas
239 |
240 | * \t = tabulado
241 | * \n = nueva linea
242 | * \u01F4 = carácter unicode especifico
243 |
244 | **Ejemplo**
245 | ```python
246 | print("Cadena con un tabulado \t y una nueva \n linea")
247 | ```
248 | ```
249 | Cadena con un tabulado y una nueva
250 | linea
251 | ```
252 |
253 | Para concatenar palabras utilizamos el operador +
254 | ```python
255 | nombre = "Ingrid"
256 | apellido = "E"
257 |
258 | print(nombre + ' ' + apellido)
259 | ```
260 | ```
261 | Ingrid E
262 | ```
263 | **Comparar cadenas**
264 | * == : Comparar si son iguales
265 | * < : Ver que palabra es mayor o menor según el código de la letra.
266 |
267 |
268 | ```python
269 | '''
270 | El codigo ASCCI de 'a' = 97
271 | 'b' = 98
272 | '''
273 | print('a' < 'b') #True
274 |
275 | print('Rosas' == 'a') #False no son iguales
276 |
277 | '''
278 | R-82-o-111-s-115-a-97-s-115 = 529
279 | R-82-o-111-j-106-a-97-s-115 = 511
280 | '''
281 | print('Rosas' > 'Rojas') #True
282 |
283 | print("Rojas" is "Rojas") #True
284 | ```
285 |
286 | Las cadenas de palabras str se pueden utilizar como arrays
287 |
288 | Si tenemos la variable
289 |
nombre = "Hola Mundo"
290 | Cada letra tiene una **posición**
291 | * nombre[0] = 'H'
292 | * nombre[1] = 'O'
293 | * nombre[2] = 'L'
294 | * nombre[3] = 'A'
295 |
296 | ```python
297 | nombre = "Ingrid E"
298 | for i in range(0,8):
299 | print(nombre[i], end=' ')
300 |
301 | #-> I n g r i d E
302 |
303 | for i in nombre:
304 | print (i, end=' ')
305 |
306 | #-> I n g r i d E
307 | ```
308 |
309 | El metodo *len()* nos permite obtener el largo de las palabras str
310 | * len("hola") = 4
311 |
312 | También, podemos usar las listas para sacar subcadenas de las palabras
313 |
314 | ```python
315 | palabra = "MisionTic 2022"
316 | print(palabra[0]) # M
317 | print(palabra[:5]) # Misio
318 | print(palabra[0:7]) # MisionT
319 | print(palabra[6:10]) # Tic
320 | '''
321 | Si utilizamos el :: nos devuelve la palabra por intervalos.
322 | Si es negativo el intervalo va desde atrás.
323 | Si es positivo va normal.
324 | '''
325 | print(palabra[::-1]) # 2202 ciTnoisiM
326 | print(palabra[::-2]) # 20 inii
327 | print(palabra[:: 2]) # MsoTc22
328 | ```
329 |
330 | **Método count**
331 |
Retorna el numero de veces que se encuentra una subcadena en una cadena.
332 | * obj.count(subcadena, ini,fin)
333 |
334 | ```python
335 | obj = "The avengers"
336 | print(obj.count('e')) # 3
337 | print(obj.count('e',4,len(obj))) #2
338 |
339 | cad = 'abcabcabcabcabc'
340 | print(cad.count('abc')) # 5
341 |
342 | ```
343 |
344 |
345 | **Método find/rfind()**
346 |
347 | Nos permite encontrar partes de las palabras. find sirve para encontrar la primera, y rfind para encontrar la ultima.
348 |
349 |
350 | ```python
351 | palabra = "Hola amigos buenos dias, Hola"
352 | print('primera:', palabra.find("Hola")) # primera: 0
353 | print('ultima:', palabra.rfind("Hola")) # ultima: 25
354 | ```
355 |
356 | **Método mayúsculas y minúsculas**
357 |
358 | * .lower() = cadena en minúsculas
359 | * .upper() = cadena en mayúsculas
360 | * .capitalize() = primera letra Mayúscula
361 | * .title() = primera letra de cada palabra mayúscula
362 | * .swapcase() = intercambia Mayúsculas y minúsculas
363 |
364 | **Método strip/lstrip/strip()***
365 |
Sirve para recortar o eliminar caracteres deseados.
366 | * .lstrip('-+') : Elimina los especificado desde la izquierda.
367 | * .strip('-+') : Elimina lo especificado al principio y final del string.
368 | * .rstrip('-+') : Elimina los especificado desde la derecha.
369 |
370 | Si no se pone nada el default es espacios.
371 |
372 | ```python
373 | txt = " banana "
374 | x = txt.lstrip()
375 |
376 | print("of all fruits", x, "is my favorite") # of all fruits banana is my favorite
377 |
378 | txt = ",,,,,rrttgg.....banana....rrr"
379 | x = txt.strip(",.grt")
380 |
381 | print(x) # banana
382 |
383 | txt = " banana "
384 | x = txt.rstrip()
385 |
386 | print("of all fruits", x, "is my favorite") # of all fruits banana is my favorite
387 |
388 | ```
389 |
390 | **Método split**
391 |
Divide la cadena en una subcadena delimitadora
392 |
393 | ```python
394 | sdate = "01-06-2021"
395 | spi = sdate.split("-")
396 | print(sp1) # -> ['01','06', '2021']
397 | print('dia: ', sp1[0], 'mes:', sp1[1], 'año', sp1[2])
398 | ```
399 |
400 | **Métodos para justificar**
401 | * .ljust(15,"-"): Añade '-' a el lado derecho de la cadena hasta que la cadena mas los '-' tengan un largo de 15.
402 | * .rjust(15,"-"): Lo mismo que ljust pero agrega los - en la izquierda.
403 | * .center(15,"-"): Agrega '-' en los dos lados hasta que el largo sea 15 y quede centrado.
404 | * .zfill(15): Agrega 0 en la izquierda hasta que tenga el largo 15
405 |
406 | **Método replace**
407 |
--- Remplaza una subcadena x por otra.
408 |
409 | ```python
410 | string = "Cien años de soledad"
411 | print(string) # Cien años de soledad
412 | replace = string.replace('Cien', 'Setenta')
413 | print(replace) # Setenta años de soledad
414 | replace = string.replace('años', 'dias')
415 | print(replace) # Cien dias de soledad
416 | replace = string.replace('a','#')
417 | print(replace) # Cien #ños de soled#d
418 | ```
419 | **Método para revisar tipo**
420 |
Utilizamos estos métodos para Determinar si la cadena contiene un valor.
421 |
422 | * .endswith('.') : Determinar si termina con '.'
423 | * .startswith('B') : Determinar si empieza con 'B'
424 | * .isaplha() : Determinar si contiene letras unicamente.
425 | * .isdigit() : Determinar si contiene solo numeros.
426 | * .isspace() : Determinar si una cadena es un titulo
427 | * .islower() : Si todos su caracteres están en minúscula.
428 | * .isupper() : Si todos su caracteres están en mayúscula.
429 |
430 | **Código ASCII**
431 |
432 | * ord('x') : Retorna el numero ASCII que representa la 'x'
433 |
434 | ```python
435 |
436 | codigo = ord(input("ingrese un solo char: ")) #-> 7
437 | print(codigo)
438 | print(48 <= codigo <= 57) #True
439 |
440 | ```
441 | **Ejemplos:**
442 |
443 | Determinar si un numero entero corresponde a una vocal minúscula.
444 |
445 | ```python
446 | d = int(input("numero entero: "))
447 |
448 | if d == 96 or d == 101 or d == 111 or d==117:
449 | print(True)
450 | else
451 | print(False)
452 |
453 | print(chr(d))
454 | ```
455 |
456 | Implementar una función potencia sin utilizar el operador **, ni la función logarítmica.
457 |
458 | Entrada: Numero (x), Potencia(n)
459 | Salida: Resultado Potencia (p)
460 |
461 | p = x * x * x * x ..... n veces.
462 |
463 | Casos a tener en cuenta:
464 | si n == 0 entonces x = 1
465 | si n < 0 entonces 1/(x^n)
466 |
467 | ```python
468 |
469 | x = 3
470 | n = -2
471 |
472 | def potencia(x,n) -> float:
473 | p = 1.0
474 | if n > 0:
475 | for i in range(1,n+1):
476 | p *= x
477 | elif n < 0:
478 | for i in range(1,-n+1): #(1,-(-n)+1)
479 | p *= x
480 | p = 1.0/p
481 | return p
482 |
483 | print(potencia(x,n)) #0.1111111
484 |
485 | ```
486 |
487 | Generar las tablas de multiplicación del 1 al 9
488 |
489 | ```python
490 |
491 | for i in range(1, 10):
492 | print(i, ':', end='')
493 | for j in range(1,10):
494 | prod = i * j
495 | print('\t', prod, end='')
496 | print('', end='\n')
497 | ```
498 |
499 | ```
500 | Tabla de multiplicar de 1 al 9
501 |
502 | 1 : 1 2 3 4 5 6 7 8 9
503 | 2 : 2 4 6 8 10 12 14 16 18
504 | 3 : 3 6 9 12 15 18 21 24 27
505 | 4 : 4 8 12 16 20 24 28 32 36
506 | 5 : 5 10 15 20 25 30 35 40 45
507 | 6 : 6 12 18 24 30 36 42 48 54
508 | 7 : 7 14 21 28 35 42 49 56 63
509 | 8 : 8 16 24 32 40 48 56 64 72
510 | 9 : 9 18 27 36 45 54 63 72 81
511 | ```
512 |
513 | ## Tuplas
514 |
515 | Declaraciónes de tuplas.
516 |
517 | * tuple_1 = 1,2,3
518 | * tuple_2 = (0,1,2,3)
519 | * tuple_3 = (tuple_1,tuple_2)
520 |
521 | Podemos tener 2 tuplas en 1 sola tupla, pero si queremos que las dos se combinen
522 | en una sola tupla entonces usamos el operador +.
523 |
524 | El operador *n utilizado con tuplas, no permite repetir la tulpa n cantidad de veces.
525 |
526 | ``` python
527 | tuple_1 = 1,2,3
528 | tuple_2 = ('A','B','C')
529 | tuple_3 = (tuple_1,tuple_2)
530 |
531 | print(tuple_1) # (1, 2, 3)
532 | print(tuple_2) # ('A', 'B', 'C')
533 | print(tuple_3) # ((1, 2, 3), ('A', 'B', 'C'))
534 | print(tuple_1+tuple_2) # (1, 2, 3, 'A', 'B', 'C')
535 | print(tuple_2 * 2) # ('A', 'B', 'C', 'A', 'B', 'C')
536 | ```
537 |
538 | Para comparar tuplas, utilizamos los operadores de comparación.
539 |
540 | ``` python
541 | tuple_1 = 'Rojas',123
542 | tuple_2 = 'Rosas',123
543 | tuple_3 = 'Rosas', 23
544 | tuple_4 = 'Rojas', 23
545 |
546 | print(tuple_1 < tuple_2) # True
547 | print(tuple_1 == tuple_2) # False
548 | print(tuple_3 > tuple_4) # True
549 | print(tuple_3 < tuple_4) # False
550 | ```
551 |
552 | El operador **is** sirve para determinar si dos tuplas referencia al mismo objeto.
553 |
554 | ``` python
555 | tuple_1 = 'Rojas',123
556 | tuple_2 = "Rojas",123
557 | tuple_3 = 'Rojas',
558 | tuple_4 = 123,
559 | tuple_5 = tuple_3 + tuple_4
560 |
561 | print(tuple_1 == tuple_2) #True
562 | print(tuple_1 is tuple_2) #True
563 | print(tuple_1 == tuple_5) #True
564 | print(id(tuple_1)) #1801309591232
565 | print(id(tuple_2)) #1801309591232
566 | ```
567 |
568 | Para aceder a elementos en una tupla utilizamos [indice]
569 |
Cuando es un signo negativo se considera un recorrido desde la inversa
570 |
571 | ```python
572 | colores = ("Rojo", "Azul", "Verde", "Morado")
573 |
574 | print(colores[2]) #Verde
575 | print(colores[-2]) #Verde
576 | ```
577 |
578 | Ciclos for con tuplas
579 | ``` python
580 | colores = ("Rojo", "Azul", "Verde", "Morado")
581 |
582 | for color in colores:
583 | print(color,end=', ') # Rojo, Azul, Verde, Morado,
584 | ```
585 | **Asignarle valores a la tuplas**
586 |
587 | Podemos asignarle variables a la tuplas.
588 |
589 | ``` python
590 | colores = ("Rojo", "Azul", "Verde", "Morado")
591 |
592 | r,a,v,m = colores
593 |
594 | print(r) #Rojo
595 | print(v) #Verde
596 | print(a) #Azul
597 | print(m) #Morado
598 |
599 | tupla = (10,9,8,7,6,5)
600 | a,b,c,d = [tupla[i] for i in (1,2,3,4)]
601 | print(a,b,c,d) # 9 8 7 6
602 | a,b,c,d = [tupla[i] for i in (1,1,2,2)]
603 | print(a,b,c,d) # 9 9 8 8
604 | a,b,c = [tupla[i] for i in range(0,6,2)]
605 | print(a,b,c) # 10 8 6
606 | ```
607 | Mas metodos para tuplas
608 |
609 | ``` python
610 | tupla = (10,9,8,7,6,5)
611 | print(tupla[::-1]) # (5, 6, 7, 8, 9, 10)
612 |
613 | print(tupla.index(10), tupla.index(8), tupla.index(5)) # 0 2 5
614 |
615 | print(max(tupla), min(tupla)) # 10 5
616 |
617 | repetidos = (1,1,1,1,3,2,3,2)
618 |
619 | print(repetidos.count(1)) # 4
620 | print(repetidos.count(2)) # 2
621 | print(repetidos.count(3)) # 2
622 | print(repetidos.count(4)) # 0
623 | ```
624 |
625 | Podemos volver una palabra en una tupla facilmente usando el metodo tuple()
626 |
627 | ``` python
628 | nombre = "Ingrid"
629 | tupla_Nombre = tuple(nombre)
630 | print(tupla_Nombre) #('I', 'n', 'g', 'r', 'i', 'd')
631 | ```
632 | ## Listas
633 | 22/06/2021
634 |
635 | Donde podemos almacenar datos como: int, float, str, tuple, dicc, etc..
636 | En una lista separamos los datos con una '**,**'
637 | La **diferencia** que tiene con la tuplas es que, las listas son mutables es decir que se pueden modificar.
638 |
639 | [ ] Una lista vaciá, las listas pueden contener diferentes tipos de datos.
640 |
641 | Se pueden crear listas que tengan listas como elementos:
642 |
643 | ```python
644 | numList = [0,1,2,3]
645 | letterList = ['A','B','C']
646 | combinationList = [numList, letterList]
647 | print(combinationList) #[[0, 1, 2, 3], ['A', 'B', 'C']]
648 | print(combinationList[0]) #[0, 1, 2, 3]
649 | print(combinationList[1]) #['A', 'B', 'C']
650 | print(combinationList[0][1]) #1
651 | print(numList + letterList) # [0, 1, 2, 3, 'A', 'B', 'C']
652 | ```
653 |
654 | Existe el método extend para agregar una lista al final de otra lista.
655 | ```python
656 | numList = [0,1,2,3]
657 | letterList = ['A','B','C']
658 |
659 | numList.extend(letterList) # [0, 1, 2, 3, 'A', 'B', 'C'] sirve similar que +
660 | print(numList)
661 | ```
662 |
663 | Similar a la tuplas podemos crear una lista con múltiples copias de una lista.
664 |
665 | ```python
666 | numList = [0,1,2,3]
667 | letterList = ['A','B','C']
668 |
669 | print(numList*3) # [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
670 | print(letterList * 2) # ['A', 'B', 'C', 'A', 'B', 'C']
671 | ```
672 |
673 | Los operadores de comparación se utilizan usando el orden lexicógrafo cuando es posible.
674 | Se puede realizar mientras uno a uno de los elementos de la lista sean del mismo tipo.
675 |
676 | ```python
677 | print(["Rojas", 123] < ["Rosas", 123]) # True
678 | print(["Rosas", 123] == ["rosas", 123]) # False
679 | print(["Rosas", 123] > ["Rosas", 23]) # True
680 | print(["Rosas", "123"] > ["Rosas", "23"]) # False
681 | print(("Rosas", "123") > ("Rosas", 23)) #Error str > int no funciona
682 | ```
683 |
684 | **Subíndice [ ]**
685 |
686 | Se puede aceder a los elementos dentro de la lista empezando desde [0]. Si es [-1] entonces se considera como la posición desde el final.
687 |
688 |
689 | ```python
690 | avengers = ["Ironman", "Thor", "Ant-man", "Hulk"]
691 | print(avengers[0]) # IronMan
692 | print(avengers[3]) # Hulk
693 | print(avengers[-1]) # Hulk
694 | print(avengers[-3]) # Thor
695 | ```
696 |
697 | **IN**
698 | Utilizamos el operador in para determinar si un elemento se encuentra en una lista.
699 |
700 | Si queremos saber si no se encuentra en la lista utilizamos not in
701 |
702 | ```python
703 | text = ["cien", "años", "de", "soledad"]
704 | if "años" in text:
705 | print("Si esta en la lista")
706 | else:
707 | print("No esta en la lista")
708 |
709 | if "hola" not in text:
710 | print("No esta en la lista")
711 | else:
712 | print("Si esta en la lista")
713 |
714 | #Si esta en la lista
715 | #No esta en la lista
716 | ```
717 |
718 | **For**
719 |
720 | Podemos iterar una lista utilizando el método for
721 | ```python
722 | s = ["hola", "amigos", "mios"]
723 | for palabra in s: # para cada palabra de la lista
724 | print(palabra, end = ", ")
725 |
726 | # hola, amigos, mios
727 | ```
728 |
729 | Se puede crear una lista utilizando un for adentro.
730 | ``` python
731 | d = 10
732 | desplaza = [d + x for x in range(5)]
733 | print(desplaza) # [10,11,12,13,14]
734 | potencias = [3 ** x for x in range(2, 6)]
735 | print(potencias) # [9,27,81,243]
736 | ```
737 |
738 | Igualmente como las tuplas se le puede agregar variables
739 | ``` python
740 | lista = [1, -2, 3]
741 | a, b, c = lista
742 | # a = 1
743 | # b = -2
744 | # c = 3
745 |
746 | lista = [11, 9, -2, 3, 8, 5]
747 | var1, var2, var3 = [lista[i] for i in (1, 3, 5)]
748 | print("var1 =", var1, ", var2 =", var2, ", var3 =", var3)
749 | #var1 = 9 , var2 = 3 , var3 = 5
750 | var1, var2, var3 = [lista[i] for i in range(0, 6, 2)]
751 | print("var1 =", var1, ", var2 =", var2, ", var3 =", var3)
752 | # var1 = 11 , var2 = -2 , var3 = 8
753 | ```
754 |
755 | Las listas tambien contienen estos metodos:
756 | * Len(lista) = Longitud de la lista
757 | * .append(valor) _= Agrega un elemento al final de la lista
758 | * .insert(posicion, valor) = Agrega un elemento en una posicion especifica
759 | * .remove(valor) = elimina donde encuentre primero el valor de izquierda a derecha
760 | * .count(valor) = Retorna las n veces que se repite un numero
761 | * .index(valor) = Retorna la posicion del valor si se repite coje el primero.
762 | * max(lista) = Retorna el Maximo valor
763 | * min(lista) = Retorna el Min Valor
764 | * .sort() = De menor a mayor
765 | * .sort(reverse = True) = De mayor a menor
766 | * list(valor) = Para volver un elemento a una lista
767 | * .pop(posicion/default ultima posicion) = Elimina un elemento en la posicion
768 |
769 | ## Archivos
770 | 29/06/2021
771 | Existen 4 operaciónes que se pueden realizar con archivos desde un programa:
772 | * Crear
773 | * Abrir
774 | * Cerrar
775 | * Eliminar
776 | Modos de abrir archivos en **Python** son:
777 | * w : Escribir en el archivo, creandolo si no existe y si si sobreescribiendolo.
778 | * w+ : Borra cualquier dato que existe en el archivo y lo deja como nuevo
779 | * r+ : Leer el archivo y escribir en el archivo desde el principio
780 | * a+ : Leer el archivo y escribir al final del archivo (append)
781 | * -x : Crear archivos
782 | * b : Leer archivos binarios, se agrega al final de los otros modificadores:
783 | * wb,ab,r+b,a+b
784 |
785 | Para abrir archivos utilizamos el metodo
786 | open(ruta del archivo, 'r')
787 |
788 | ```python
789 | def leerArch(path):
790 | modo = 'r'
791 | with open(path, modo) as f:
792 | data = f.read()
793 | data = f.read(6) #Especificamos que queremos leer en la
794 | # segunda linea 6 bytes
795 | return data
796 | path = 'files/data.txt' #Relativo al ejemplo mostrado
797 | data = leerArch(path)
798 | print(data)
799 |
800 | with open(path, 'w') as f:
801 | data = "Escribiendo en el archivo 123"
802 | f.write(data) #Esto se escribe en el archivo 3 veces
803 | f.write(data)
804 | f.write(data)
805 | ```
806 |
807 | Podemos especificar el tipo de codificación para la lectura del archivo.
808 | with open(ruta del archivo, modo, encoding="utf-8") as f:
809 |
810 | El metodo **readline()** sirve para leer el contenido de cada linea por individual. Las lunes se pueden cargar como un archivo si se utiliza el comando readlines().
811 |
812 | ```python
813 | with open("files/data1.txt", 'r', enconding="utf-8") as f:
814 | print("Nombre del archivo: ", f.name)
815 | lista = f.readlines()
816 | print(lista) # Nos devuelve una lista con las lineas.
817 | ```
818 |
819 | La forma mas eficiente de abrir y procesar un archivo es leerlo linea por linea:
820 |
821 | ```python
822 | with open("files/data1.txt", 'r', enconding="utf-8") as f:
823 | for line in f:
824 | print(line, end="")
825 | ```
826 |
827 | Si queremos escribir datos en un archivo que no son cadenas de texto, podemos hacer.
828 |
829 | ```python
830 | values = [1,2,3,4, False]
831 |
832 | with open(path, 'w+') as f:
833 | for value in values:
834 | str_value = str(value)
835 | f.write(str_value)
836 | f.write('\n')
837 | ```
838 |
839 | El metodo seek nos permite ubicar el puntero en la posición que deseemos dentro del archivo
840 |
841 | Si tenemos un archivo con:
842 |
843 | Las quince letras
844 | 12345
845 | 5678
846 |
847 |
848 | ```python
849 | with open(path, 'r', enconding='utf-8') as f:
850 | f.seek(11,0) # <- Empezamos a leer la info desde aqui
851 | for line in f:
852 | print(line)
853 | ```
854 |
855 | Este metodo nos retorna:
856 |
857 | letras
858 | 12345
859 | 5678
860 |
861 | El metodo **tell** nos permite obtener la longitud de un archivo o la posición donde se encuentra.
862 |
863 | ```python
864 | with open(path, 'a+') as f:
865 | print(f.tell()) # Retorna 29 con el archivo anterior
866 |
867 | ```
868 |
869 | Para **editar** un archivo dado es utilizando list.insert(i, x), que permite insertar nuevos datos a la lista. Una vez creada se puede unir con **join** y escribirlo sobre el archivo.
870 |
871 | Si tenemos el archivo:
872 | Esta es la linea 1: abcabcabcabc
873 | Esta es la linea 2: abcabcabcabc
874 | Esta es la linea 3: abcabcabcabc
875 |
876 | Primero abrimos el archivo en modo lectura y luego leemos sus lineas, lo guardamos, lo modificamos y lo abrimos de nuevo para guardar la nueva linea.
877 |
878 | ```python
879 | # Abre el archivo en modo de s ́olo lectura
880 | with open("files/data5.txt", "r", encoding="utf-8") as f:
881 | list_content = f.readlines()
882 | list_content.insert(1, "Esta es la l ́ınea 1.5: jajaja\n")
883 |
884 | # Re-abre el archivo en modo de s ́olo escritura
885 | # para sobreescribir la versi ́on anterior de ́este
886 | with open("files/data5.txt", "w", encoding="utf-8") as f:
887 | contenido = "".join(list_content)
888 | f.write(contenido)
889 | ```
890 |
891 | La archivo queda como:
892 | Esta es la linea 1: abcabcabcabc
893 | Esta es la linea 1.5: jajajaja
894 | Esta es la linea 2: abcabcabcabc
895 | Esta es la linea 3: abcabcabcabc
896 |
897 | Existen muchas mas funciones que nos ayudan con la lectura de archivos en python:
898 |
899 | Si utilizamos **import os** podemos aplicar funciones de esa libreria
900 |
901 | * os.scandir()
902 | * pathlib.Path()
903 |
904 | ```python
905 | import os
906 | entries = os.scandir("files/")
907 | for entry in entries:
908 | print(entry.name + ", es directorio: " + str(entry.is_dir()) + "size" + str(entry.stat().st_size) + " bytes.")
909 |
910 | #salidas:
911 | data.txt, es directorio: False, size: 17 bytes.
912 | data1.txt, es directorio: False, size: 95 bytes.
913 | data2.txt, es directorio: False, size: 131 bytes.
914 | data3.txt, es directorio: False, size: 32 bytes.
915 | data4.txt, es directorio: False, size: 31 bytes.
916 | data5.txt, es directorio: False, size: 128 bytes.
917 | sample_data, es directorio: True, size: 4096 bytes.
918 | ```
919 |
920 | Guardar estructuras de **datos**
921 |
922 | Cuando queremos guardar objetos en python como diccionarios ó listas, utilizamos el módulo pickle y su metodo dump nos permite serializar objetos.
923 |
924 | El siguiente código permite crear dos listas y un diccionario.
925 |
926 |
927 | ```python
928 | import pickle
929 |
930 | name = ['mohit', 'bhaskar', 'manish']
931 | skill = ['Python', 'C++', 'Java']
932 | dict1 = dic([(k,v) for k,v in zip(name, skill)])
933 |
934 | with open("files/programming_powers.pkl", "wb") as p_file:
935 | pickle.dump(name, p_file)
936 | pickle.dump(skill, p_file)
937 | pickle.dump(dict1, p_file)
938 | ```
939 |
940 | Con esto se crea un archivo que se lee en binario y no es leible para nosotros.
941 |
942 | Para cargar estas estructuras lo hacemos de forma simple
943 |
944 | ```python
945 | import pickle
946 |
947 | with open("files/programming_powers.pkl", "rb") as p_file:
948 | list1 = pickle.load(p_file)
949 | list2 = pickle.load(p_file)
950 | dict1 = pickle.load(p_file)
951 |
952 | print(list1) #['mohit', 'bhaskar', 'manish']
953 | print(list2) #['Python', 'C++', 'Java']
954 | print(dict1) # {'mohit': 'Python', 'bhaskar': 'Pyhon', 'manish':'Java'}
955 | ```
956 |
957 | Una imagen de tipo .jgp es un archivo de tipo binario: Con cierto procesamiento es posible crear una copia de la imagen de la siguiente manera:
958 |
959 |
960 | ```python
961 | with open("files/discurso.jpg", "rb") as imagen:
962 | data = imagen.read()
963 | with open("files/copy.jpg", "wb") as f:
964 | f.write(data)
965 | ```
966 |
967 | **Problemas Sesion 18**
968 | ||LINK EJERCICIO||
969 |
970 | ## JSON
971 | 30 de junio 2021
972 |
973 | Javascript Object Notation, intercambio de información entre aplicaciones. Se puede utilizar en diferentes lenguajes de programación.
974 |
975 | Es un diccionario donde cada item esta delimitado por comillas dobles " y el valor puede ser cualquier tipo de dato.
976 |
977 | **Ejemplo:**
978 | ```JSON
979 | {
980 | "Nombre": "Ingrid",
981 | "Apellido": "E",
982 | "PasaTiempos": ["Pintar", "Programmar", "Cantar"],
983 | "Edad": 19,
984 | "Empleado": false,
985 | "Jefe": null,
986 | "Hijos": [
987 | {"Nombre": "Alice", "Edad":16},
988 | {"Nombre": "Bob", "Edad":8}
989 | ]
990 | }
991 | ```
992 |
993 | No todos los diccionarios de Python es un objeto JSON ya que en python las claves pueden ser numeros, cadenas, tuplas...etc. En JSON solo se permite cadenas de caracter delimitadas por comillas dobles.
994 |
995 | |Tipo en Python| Tipo en JSON|
996 | |---|---|
997 | |dict|object|
998 | |tuple,list|array|
999 | |str|string|
1000 | |int,float|number|
1001 | |False|false|
1002 | |True|true|
1003 | |None|null|
1004 |
1005 | En python podemos importar el modulo de JSON con
1006 | **import JSON**
1007 |
1008 | Los archivos de JSON se pueden serializar. En la libreria de JSON encontramos el metodo
1009 | dump() que permite escribir datos en un archivo.
1010 |
1011 | Si tenemos:
1012 | ```JSON
1013 | data = {
1014 | "cientifico":{
1015 | "nombre": "Alan Mathison Turing",
1016 | "edad": "41"
1017 | }
1018 | }
1019 | ```
1020 | Se puede **serializar** en un archivo asi:
1021 | ```python
1022 | with open("json/data_file.json", "w") as write_file:
1023 | json.dump(data_write_file)
1024 | ```
1025 |
1026 | Se crea un archivo que contiene:
1027 | {"cientifico": {"nombre": "Alan Mathison Turing", "edad": "41"}}
1028 |
1029 | Tambien se puede asignar a un string y nos devuelve lo mismo que contiene el archivo.
1030 | * json.dump(data, indent=n) : Podemos especificar la cantidad de espacios con n en indent
1031 | * json.load(archivo) : Cargar JSONs desde archivos o desde strings si estan dentro de 3 comillas simples.
1032 | * pprint : Imprimir de forma bonita
1033 |
1034 | **Ejemplo**
1035 | ```python
1036 | import json
1037 | from pprint import pprint
1038 | strjson = '''{
1039 | "boolean1: null,
1040 | "diccionario": {"papa":2000, "arroz": 5000},
1041 | "intValue": 0,
1042 | "myList": [],
1043 | "myList2": ["info1", "info2"],
1044 | "littleboolean": false,
1045 | "myEmptyList": null,
1046 | "text1": null,
1047 | "text2": "hello",
1048 | "value1":null,
1049 | "value2:" null}
1050 | '''
1051 | data = json.load(strjson)
1052 | pprint(data)
1053 | ```
1054 |
1055 | ```
1056 | {
1057 | "boolean1: null,
1058 | "diccionario": {"papa":2000, "arroz": 5000},
1059 | "intValue": 0,
1060 | "myList": [],
1061 | "myList2": ["info1", "info2"],
1062 | "littleboolean": false,
1063 | "myEmptyList": null,
1064 | "text1": null,
1065 | "text2": "hello",
1066 | "value1":null,
1067 | "value2:" null}
1068 | ```
1069 |
1070 | Para revisar un dato en especifico solo ponemos data["test2"] -> hello
1071 | JSONPlaceholder para practicar peticiones.
1072 |
1073 | import requests para leer archivos JSON desde la web
1074 | response = request.get(url)
1075 | y con json.loads(response.text) se carga
1076 |
1077 | Para obtener registos del JSON:
1078 | nombreJSON[:2] los dos primeros valores
1079 |
1080 | **Info de [w3schools](https://www.w3schools.com/python/python_json.asp)**
1081 |
1082 | JSON es una sintaxis para guardar e intercambiar datos. En python utilizamos la libreria **import json** para trabajar con datos de JSON.
1083 |
1084 |
1085 | ## Librerias
1086 |
1087 | Podemos importar una gran cantidad de librerias en Python que nos permiten realizar funciones de todo tipo
1088 |
1089 | ### **Numpy**
1090 |
1091 | **import numpy as np**
1092 |
1093 | Se utiliza para computación científica en Python. Contiene arreglos en varias dimensiones, con herramientas para manipularlos.
1094 |
1095 | Metodos:
1096 | * np.array(list) : Crea un array con ""
1097 | * np.shape : Retorna el tamaño del array
1098 | * np.zeros(tamaño): columna x fila o solo filas, de zeros tipo float
1099 | * np.dtype : Retorna el tipo de los elementos dentro del array
1100 | * np.sqrt(array): Aplica raiz cuadrada a cada elemento de la lista
1101 | * np.add(array1, array2): Suma los valores de cada lista
1102 | * np.linspace(start,stop, num, endpoint, retstep, stype, axis): Retorna numeros separados por espacios segun un intervalo especificado.
1103 | * start : Inicio de la secuencia
1104 | * stop: Final de la secuencia si endpoint es TRUE
1105 | * num: Cantidad para generar no puede ser negativo
1106 | * endpoint: Si finaliza o no
1107 | * retstep: Si es true retorna los pasos entre datos
1108 |
1109 | Si creamos una variable con elementos de otro array a[0,1] los valores que cambien en esa variable se cambiaran tambien en el array general.
1110 |
1111 | Dos arrays se pueden sumar utilizando el operador + o **np.add(array1, array2)** si son del mismo tamaño. Tambien se puede hacer x("array") + 3 y se le sumara 3 a todos los valores de la lista.
1112 |
1113 | ```python
1114 | import numpy as np
1115 |
1116 | lista = list(range(1,5)) #[1,2,3,4]
1117 | a = np.array(lista) # [1 2 3 4]
1118 | print(a.shape) # (4,)
1119 | print(a[0], a[1], a[2]) # 1 2 3
1120 |
1121 | bidimensional = np.array([[1,2,3,4,5],[4,5,6,7,8]])
1122 | #Tienen que ser del mismo tamaño o da error
1123 | print(bidimensional)
1124 | # [[1 2 3 4 5]
1125 | # [4 5 6 7 8]]
1126 | print(bidimensional[0,0], bidimensional[1,0]) # 1 4
1127 |
1128 | print("---------")
1129 | #Arreglo de diferente tipo
1130 |
1131 | a = np.zeros((3,4)) #Devuelve una array de x tamaño lleno de 0
1132 | #[[0. 0. 0. 0.]
1133 | # [0. 0. 0. 0.]
1134 | # [0. 0. 0. 0.]]
1135 | print(a.shape) # (3,4)
1136 |
1137 | a = np.zeros((2,3,4)) #Devuelve una array de x tamaño lleno de 0
1138 | #[[0. 0. 0. 0.]
1139 | # [0. 0. 0. 0.]
1140 | # [0. 0. 0. 0.]]]
1141 | print(a.shape) # (2,3,4)
1142 |
1143 | print("---------")
1144 | a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]]) # Tamaño 3x4
1145 | b = a[:2, 1:3]
1146 | #[[2 3]
1147 | # [6 7]]
1148 | b[0,0] = -11
1149 | print(b,a, sep="\n")
1150 | #[[-11 3]
1151 | # [ 6 7]]
1152 | #[[ 1 -11 3 4]
1153 | # [ 5 6 7 8]
1154 | # [ 9 10 11 12]]
1155 | print("---------")
1156 |
1157 | x = np.array([5,-4])
1158 | print(x.dtype) # int32
1159 | x = np.array([1.0,-2.0])
1160 | print(x.dtype) # float64
1161 | x = np.array([5,-4], dtype=np.float64)
1162 | print(x.dtype) # float64
1163 |
1164 | print("---------")
1165 | x = np.array([[1,2,5],[3,4,6]], dtype=np.float64)
1166 | y = np.array([[5,6,-1],[7,8,-6]], dtype=np.float64)
1167 | print(np.add(x,y))
1168 | #Suma:
1169 | # [[ 6. 8. 4.]
1170 | # [10. 12. 0.]]
1171 | print(np.sqrt(x))
1172 | #[[1. 1.41421356 2.23606798]
1173 | # [1.73205081 2. 2.44948974]]
1174 | print("---------")
1175 |
1176 | print(np.linspace(2,3,num=10, endpoint=True, retstep=False))
1177 | #[2. 2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
1178 | # 2.66666667 2.77777778 2.88888889 3. ]
1179 | print(np.linspace(2,3,num=10, endpoint=True, retstep=True))
1180 | #(array([2. , 2.11111111, 2.22222222, 2.33333333, 2.44444444,
1181 | # 2.55555556, 2.66666667, 2.77777778, 2.88888889, 3. ]), 0.1111111111111111)
1182 | ```
1183 |
1184 | ### **Matplotlib**
1185 | **import matplotlib.pyplot as plt**
1186 |
1187 | Utilizada para crear visualizaciones estáticas o animadas en Python. Se puede graficar un área con uno o más ejes x,y o x,y,z. La forma mas facil de crear una figura con ejes es utilizar **pyploy**
1188 |
1189 | ```python
1190 | plt.plot([1,2,3,4],[1,4,2,3]) # x,y
1191 | #plt.show() #Muestra la gráfica
1192 |
1193 | x = np.linspace(0,2,50)
1194 | fig, ax = plt.subplots() #Crear la figura y ejes
1195 | ax.plot(x, x, label="linear") #Dibujando datos
1196 | ax.plot(x, x**2, label="quadratic")
1197 | ax.plot(x,x**3, label="cubic")
1198 | ax.set_xlabel("X") #Poner el nombre a el eje x
1199 | ax.set_ylabel("Y") #Poner el nombre a el eje y
1200 | ax.set_title("Figura de prueba\nIngrid-E") #Titulo a la figura
1201 | ax.legend() #Muesta los labels
1202 | #plt.show() #Muestra la gráfica
1203 | names = ["grupo_A", "grupo_B", "grupo_C"]
1204 | values = [3.4, 50.4, 23]
1205 |
1206 | plt.subplot(131) #No entiendo que hace
1207 | plt.bar(names, values) #Grafica de barras
1208 | plt.subplot(132)
1209 | plt.scatter(names, values) # De puntos
1210 | plt.subplot(133)
1211 | plt.plot(names, values) #De lineas
1212 | plt.suptitle("Categorical Plotting")
1213 | plt.show()
1214 | ```
1215 |
1216 | ## **Panda**
1217 | **import pandas as pd**
1218 | Permite manipular datos de alto nivel, se utiliza para manipulación y análisis de datos.
1219 |
1220 | ```python
1221 | from typing import Counter
1222 | import matplotlib.pyplot as plt
1223 | import numpy as np
1224 | import pandas as pd
1225 | import datetime
1226 |
1227 | dictc = {"country": ["Brazil", "Russia", "India",
1228 | "China", "South Africa", "Colombia"],
1229 | "capital": ["Brasilia", "Moscow", "New Dehli",
1230 | "Beijing", "Pretoria", "Bogot ́a"],
1231 | "area": [8.516, 17.10, 3.286, 9.597, 1.221, 1.142],
1232 | "population": [200.4, 143.5, 1252, 1357, 52.98, 49.65] }
1233 |
1234 | brics = pd.DataFrame(dictc)
1235 | # country capital area population
1236 | #0 Brazil Brasilia 8.516 200.40
1237 | #1 Russia Moscow 17.100 143.50
1238 | #2 India New Dehli 3.286 1252.00
1239 | #3 China Beijing 9.597 1357.00
1240 | #4 South Africa Pretoria 1.221 52.98
1241 | #5 Colombia Bogot ́a 1.142 49.65
1242 |
1243 | ventasPaises = pd.read_csv("SalesJan2009.csv")
1244 | ventasPaises.head(3)
1245 | # Transaction_date Product Price ... Last_Login Latitude Longitude
1246 | # 0 1/2/2009 6:17 Product1 1200 ... 1/2/2009 6:08 51.500000 -1.116667
1247 | # 1 1/2/2009 4:53 Product1 1200 ... 1/2/2009 7:49 39.195000 -94.681940
1248 | # 2 1/2/2009 13:08 Product1 1200 ... 1/3/2009 12:32 46.188060 -123.830000
1249 | # 3 1/3/2009 14:44 Product1 1200 ... 1/3/2009 14:22 -36.133333 144.750000
1250 | # 4 1/4/2009 12:56 Product2 3600 ... 1/4/2009 12:45 33.520560 -86.802500
1251 | # .. ... ... ... ... ... ... ...
1252 | # 992 1/22/2009 14:25 Product1 1200 ... 3/1/2009 3:37 54.583333 -5.933333
1253 | # 993 1/28/2009 5:36 Product2 3600 ... 3/1/2009 4:40 -20.360278 57.366111
1254 | # 994 1/1/2009 4:24 Product3 7500 ... 3/1/2009 7:21 42.946940 -76.429440
1255 | # 995 1/8/2009 11:55 Product1 1200 ... 3/1/2009 7:28 52.083333 0.433333
1256 | # 996 1/12/2009 21:30 Product1 1200 ... 3/1/2009 10:14 43.073060 -89.401110
1257 | #[997 rows x 12 columns]
1258 | cantidadPais = Counter(ventasPaises["Country"])
1259 | print(cantidadPais) # diccionario con la cantidad de veces que aparece
1260 | # un pais en el archivo
1261 | print(cantidadPais.most_common(3)) #[('United States', 462), ('United Kingdom', 100), ('Canada', 76)]
1262 |
1263 | ventasPaises["Transaction_date"] = pd.to_datetime(ventasPaises["Transaction_date"])
1264 | A = (ventasPaises['Transaction_date']
1265 | .dt.floor("d")
1266 | .value_counts()
1267 | .rename_axis("date")
1268 | .reset_index(name="num ventas"))
1269 |
1270 | G = A.plot(x="date", y="num ventas", color="green", title="Ventas por fecha")
1271 | plt.show()
1272 | ```
1273 | ## Funciones
1274 | 8/07/2021
1275 |
1276 | Existen dos tipos de funciones:
1277 | * Incluidas en el lenguaje
1278 | * Definidas por el usuario
1279 |
1280 | Las funciones pueden tener o no argumentos y retornar o no valores
1281 |
1282 |
1283 |
--------------------------------------------------------------------------------