DEV Community: Wilson Gutiérrez L

Git, iniciando con main

Wilson Gutiérrez L — Tue, 16 Feb 2021 05:39:16 +0000

Mi experiencia con GIT ha sido mínima, cuando me aparece un error reviso que escribí mal y si no encuentro el origen de la falla me remito a buscar por internet. Hoy quiero aprovechar que quiero iniciar un proyecto nuevo para empezar casi desde cero. Digo casi porque no incluyo la instalación que la realice en linux.

Hace algunos meses, no recuerdo bien la fecha y no quiero buscar, Github realizó unos cambios en su plataforma, uno de ellos y con el cual he tenido que lidiar un poco es que antes todas las ramas principales se trabajaban sobre master pero ahora, con el cambio, la rama principal en para cualquier proyecto nuevo es main.

Cuando quiero comenzar un proyecto que quiero subir a GITHUB debo inicializar GIT dentro del proyecto y para hacerlo el comando a ejecutar en la consola o terminal es:

git init

Pasa que si no tienes bien configurado a GIT entonces el sistema intentará inicializar el proyecto con la rama master la cual ya se encuentra en desuso y además mostrará mensajes de advertencia:

La solución la brindan las mismas alertas, se debe realizar una configuración global donde indicaremos cual es el nombre de la rama principal que va a quedar por defecto con el comando que aparece en la siguiente imagen:

Conociendo que en la configuración ya especificamos la rama principal por defecto, procedemos a inicializar el proyecto:

y con git status lo compruebo:

Espero que este artículo haya servido para alguien. Por favor compartelo si crees que es útil o dejame tus comentarios.

Reto día 14/100 con Python

Wilson Gutiérrez L — Tue, 09 Feb 2021 19:20:20 +0000

Ejercicio

Realizar un programa que enseñe al usuario el nombre y tipo de dos Pokémon y elija cual cree que tiene mayor experiencia base.
Si acierta gana 10 puntos. Si falla o empata no obtiene nada.
El usuario escoge si desea seguir jugando después de cada desafío.
Al final si decide no seguir se le mostrará el puntaje final

Este ejercicio se realiza con el fin de afianzar un poco más el uso de los diccionarios. Para ello los datos del pokémon deben ir almacenados en diccionarios, dentro de una lista, donde almacenamos el nombre, tipo y base de experiencia.

pokemon_random = [
    {
        "name":"pikachu",
        "type":"electric",
        "base_experience": 112
    },
    {
        "name":"charmander",
        "type":"fire",
        "base_experience":62
    },
    {
        "name":"bulbasaur",
        "type":"grass",
        "base_experience":64
    },
    {
        "name":"pidgeotto",
        "type":"flying",
        "base_experience":122
    },
    {
        "name":"zubat",
        "type":"flying",
        "base_experience":49
    },
    {
        "name":"mankey",
        "type":"fighting",
        "base_experience":61
    }
]

Para darle un poco más de funcionalidad este diccionario se crea en un archivo aparte que nos va a servir como un módulo para el programa principal.

El programa principal debe comenzar mostrando solo dos datos de cada pokémon y solo se va a pedir que se decida por uno de ellos

print(f"Pokemon del equipo 'a', su nombre es: {poke_a['name']} y es de tipo {poke_a['type']}")
print(f"Pokemon del equipo 'b', su nombre es: {poke_b['name']} y es de tipo {poke_b['type']}")

opcion = input("Escoja 'a' o 'b' cual tiene mas base experiencia\t")
print(winner_pokemon(opcion))

Del anterior código se puede observar que para mostrar los datos se pueden obtener de una lista llamada poke_a y poke_b, cada una me debe traer un pokémon diferente:

poke_a = choice_pokemon()
poke_b = choice_pokemon()

while poke_a == poke_b:
    poke_b = choice_pokemon()

La función que se esta invocando dos veces para obtener el pokémon hace esta elección de manera aleatoria con el método choice del módulo random

import data as d
import random as r
def choice_pokemon():
    return r.choice(d.pokemon_random)

El módulo data es el archivo que creamos inicialmente con la lista de pokémon. Pero volviendo al menú inicial donde se le solicita al usuario que se decida por alguno de los dos pokémon presentados aleatoriamente, se hace uso del método local winner_pokemon el cual va a comparar la base de experiencia de cada uno y si el jugador acierta se le asigna un puntaje.


def asignar_puntaje():
    global score
    score += 10
    return score

def winner_pokemon(op):
    experience_a = poke_a["base_experience"]
    experience_b = poke_b["base_experience"]

    if experience_a > experience_b:
        if op == 'a':
            asignar_puntaje()
            return f"El ganador es {poke_a['name']} con experiencia {experience_a} y usted obtiene 10 puntos"            
        elif op == 'b':
            return f"El ganador es {poke_a['name']} con experiencia {experience_a} y usted no obtiene puntos"
    elif experience_a < experience_b:
        if op == 'a':
            return f"El ganador es {poke_b['name']} con experiencia {experience_b} y usted no obtiene puntos"
        elif op == 'b':
            asignar_puntaje()
            return f"El ganador es {poke_b['name']} con experiencia {experience_b} y usted obtiene 10 puntos"
    else:
        return "No hay ganador, es empate"

El ejercicio completo lo pueden descargar del repositorio Github

Reto día 13/100 con Python

Wilson Gutiérrez L — Sun, 07 Feb 2021 04:22:50 +0000

Mínimo Común Múltiplo y Máximo Común Divisor

Ejercicio 1:

Crear un programa que permita elegir al usuario si desea calcular el m.c.m. o el m.c.d.
El usuario solo puede ingresar dos números para calcular la opción elegida.
El programa debe mostrar el resultado final.

Nota: Durante el desarrollo del ejercicio se observó que existen varias maneras de calcular tanto el m.c.m como el m.c.d. y se trató de realizar el código con menos líneas, sin embargo podría reducirse más ya que python tiene una función dentro del módulo math llamado gcd() el cual calcula el m.c.d. sin embargo solo ahorraría 2 líneas teniendo en cuenta que puedo calcular primero el m.c.m. y con ello luego el m.c.d.; también existe una función llamada lcm() para calcular el m.c.m. que también recibe dos números pero solo esta disponible a partir de la versión 3.9 de python y actualmente este programa funciona con la versión 3.8

La idea con este ejercicio es poder practicar el uso de funciones. Por eso para hallar el m.c.m. primero creo una función destinada a ello que recibe dos parámetros. La lógica utilizada en su desarrollo se basó en las hojas de excel donde al colocar ambos números desde la misma fila y aplicar una fórmula donde se vaya sumando la casilla siguiente hacia abajo con la primera que contiene el valor original se va a crear una secuencia acumulativa en donde en algún punto ambos números coincidiran en el valor del múltiplo:

Siguiendo esa lógica se harán sumas a ambas variables hasta que por primera vez coincidan, para este ejemplo ambas coincidieron en el valor 1620, sin embargo, cada una lo logró en una fila diferente. En cada iteración entonces solo voy a sumar el valor original al acumulado cuando sea menor que la otra variable. Al final regresará el valor final que coincidieron el cual sería el mínimo común múltiplo. A la función le doy el nombre de encontrar_mcm(m,n)

def encontrar_mcm(m,n):
    m_max=m
    n_max=n
    mcm = 0
    while m_max != n_max:
        if n_max < m_max:
            n_max += n
        elif m_max < n_max:
            m_max += m
    if m_max == n_max:
        mcm = m_max
    return mcm

En cuanto a encontrar el máximo común divisor no puedo aplicar la misma regla o lógica ya que es un caso contrario donde en lugar de ir aumentando tengo que ir disminuyendo el valor hasta encontrar el número más alto que divida a ambos números. Encuentro en su lugar que si yo divido el m.c.m. entre cualquiera de los dos números que entrega el usuario, obtengo un resultado que me sirve para dividir el otro número ingresado y de esa forma obtengo el valor que estoy buscando m.c.d. y llamo a este método encontrar_mcd(m,n):

def encontrar_mcd(m,n):
    mcm = encontrar_mcm(m,n)
    mcd = m/(mcm/n)
    return mcd

Números primos

Ejercicio 2:

Programa que permita conocer los factores primos que pertenecen a un número entregado por el usuario y cuantas veces se repite cada uno.
Para realizar este ejercicio se toma en cuenta que los números primos son aquellos que solo son divisibles entre 1 y el mismo número, por lo que si llega a ser divisible por otro número menor a él mismo entonces no es primo.
Se mostrará en pantalla cada factor con su correspondiente exponente

Este ejercicio resulta un poco más largo que el anterior. Inicialmente quería partir de este código para poder encontrar el mínimo común múltiplo ya que dentro del campo de las matemáticas el método para hacerlo es descomponer los dos números en sus factores primos, sin embargo me pareció algo largo y por eso decidí dejar este para lo último. Todavía desconozco si python tiene alguna función propia que determine este resultado pero la idea de realizar este ejercicio es practicar el uso de la lógica para solucionar problemas mediante algoritmos trabajados en código.

La solución sigue el siguiente orden de métodos:

evaluar_primos(numero) - determina si un número dado es o no primo. Si ya hemos revisado la teoría de los números primos sabremos que un número primo es aquel que solo se divide por 1 y por sí mismo, pero inicialmente partiendo del número más pequeño después del 1, siguen en su orden los números 2 y 3 que también se clasifican de la misma manera. A partir de ahí ya hay saltos y no hay primos tan seguidos. Por lo tanto la condición que permite saber si lo es o no es que siendo mayor de 3 no sea divisible por otro número iterando el divisor de uno en uno hasta llegar al número anterior al valor final. El resultado debe retornar True si es primo, False si no lo es:
```
def evaluar_primos(numero):            
for evalua_primo in range(2,numero):
    if numero > 3 and numero % evalua_primo == 0:            
        return False                        
return True
```
lista_primos(numero_dividendo) - método encargado de obtener los factores primos únicos que dividen a un número. Estos serían los factores primos base. Estos factores los voy guardando en una lista a medida que los identifique si el numero_dividendo es 2 o mayor y al dividirlo entre determinado número su residuo es igual a cero (0) evaluamos, llamando al método evaluar_primos(numero_divisor) si es primo para almacenarlo en la lista de la función. Este método retorna una lista primos. Esto se maneja mediante una iteración que parte desde el número 2 hasta que el numero_dividendo sea exactamente el valor que ingreso el usuario.
```
def lista_primos(numero_dividendo):
    primos=[]
    for numero_divisor in range(2, numero_dividendo+1):
        if numero_dividendo >= 2 and numero_dividendo % numero_divisor == 0 :            
            if evaluar_primos(numero_divisor):
                primos.append(numero_divisor)
    return primos
```
divisores_primos(numero_dividendo) - al igual que el anterior método entrega una lista de números primos pero los entrega todos con repetición. Por ejemplo al averiguar los factores primos del número 8 obtenemos que los factores primos que lo dividen son 2*2*2 = 8, por lo que la lista de este método nos aparecerá [2,2,2], mientras que en el anterior método aparecerá una lista [2]. El objetivo es diferente para cada lista. En la primera tengo el primo base y en la lista de este método obtengo el número de veces que aparece cada factor que al contarlos serían lo mismo que el exponente.

Para obtener esta lista procedo de la siguiente forma:
- numero_cociente tendrá iniciamente el valor de numero_dividento
- Creo una lista vacía para los factores primos que vaya encontrando.
- Itero desde el número 2 hasta que sea igual al número entregado por el usuario.
- Dentro de la iteración resuelvo mientras que el numero_dividendo dividido entre el iterador numero_divisor tengan un residuo igual a cero (0)
- Mientras que la anterior afirmación del ciclo se cumpla voy guardando el valor del numero_divisor en la lista del método.
- Encuentro el siguiente número cociente dividiendo numero_cociente entre numero_divisor.
- Con el resultado anterior reviso que si el numero_cociente al dividirlo entre numero_divisor tiene un residuo diferente de cero
- Si se cumple la anterior condición salgo de este ciclo y cambio el valor del número divisor para volver a comenzar un nuevo ciclo, pero si no se cumple la condición quiere decir que el numero_divisor también es factor primo para el nuevo numero_cociente y toca guardarlo en la lista.
- Cuando el numero_cociente tenga un valor igual a cero dejará de ejecutarse el iterador y quedaría completada toda la lista de factores primos.
```
def divisores_primos(numero_dividendo):
    numero_cociente = numero_dividendo
    lista_primos = []
    for numero_divisor in range(2,numero_dividendo+1):
        while numero_dividendo % numero_divisor == 0:
            lista_primos.append(numero_divisor)
            numero_cociente = numero_cociente / numero_divisor
            if numero_cociente % numero_divisor != 0:
                break
        if numero_cociente == 0:
            break
    return lista_primos
```
factores_primos(numero_dividendo) - Método encargado de guardar los resultados de las dos listas anteriores en un diccionario. No tiene mayor explicación. La clave guardará los valores de la lista de factores unicos, mientras que el valor del diccionario almacenará el exponente del factor primo contando cuantos factores del mismo valor aparecen en la lista entregada por el método divisores_primos(numero_dividendo).
```
def factores_primos(numero_dividendo):
    factores_unicos = lista_primos(numero_dividendo)
    total_factores = divisores_primos(numero_dividendo)
    cantidad_factores = {}    
    for factor in factores_unicos:
        cantidad_factores[factor] = total_factores.count(factor)
    return cantidad_factores     
```

Pueden revisar el código completo en Github

El código mostrado es de mi autoría por lo que siendo principiante estoy seguro que se puede mejorar este código. Por favor dime como piensas que puedo mejorarlo.

Reto día 12/100 con Python

Wilson Gutiérrez L — Wed, 03 Feb 2021 04:06:44 +0000

Adivine el número

Continuo con mi aporte explicando un ejercicio muy sencillo donde se debe crear un juego de adivinar un número que el computador va a escoger entre 1 y 100.

La explicación del código se realizará de acuerdo a la lógica para resolverlo. No se pretende explicar la parte técnica del código. La presente publicación estará dividido en la Descripción del problema donde indicaré las reglas del programa, el pseudocodigo creado para guia del código y finalmente el desarrollo donde se van entregando los pedazos de codigo creados para el funcionamiento del programa. Al final entregaré el enlace al repositorio donde pueden descargar el código completo.

Descripción del problema:

El usuario o jugador debe adivinar un número entre 1 y 100.
Existen dos niveles de dificultad: Fácil y Difícil.
El nivel fácil tendrá 10 oportunidades para adivinar el número.
El nivel difícil tendrá solo 5 oportunidades para adivinar el número.

Pseudocódigo

Inicio
Obtener un número aleatorio entre 1 y 100 y asignarlo a la variable adivinar_numero.
Dar la bienvenida al juego.
Solicitar al usuario que elija uno de los dos niveles.
Asignar a la variable modo_juego la opción escogida por el usuario.
Solicitar al usuario que ingrese un número.
Asignar a la variable numero_jugador el número ingresado por el usuario.
Si el usuario escogió fácil, tendrá un máximo de 10 oportunidades para adivinar.
Si no el usuario tendrá un máximo de 5 oportunidades para adivinar.

Validar:

Para i = 1 hasta que i = intentos, incrementa en 1
   Si numero_jugador = adivinar_numero entonces
     Escribir: "Has adivinado el número"
   SinoSi adivinar_numero > numero_jugador
     Escribir: "Muy bajo"
   SinoSi adivinar_numero < numero_jugador
     Escribir: "Muy Alto"
   FinSi
   Si adivinar_numero != numero_jugador AND intentos<10:
     Escribir: "Adivina de nuevo"
   SinoSi adivinar_numero != numero_jugador AND intentos=10:
     Escribir: "Se acabaron las adivinanzas, Perdiste."
   FinSi
FinPara

FinPrograma

Desarrollo

Punto 2: Se importa la libreria random para poder utilizar una de sus funciones llamada randrange() que permite obtener un número entero aleatorio entre un rango; para nuestro caso de 1 a 100. Haciendo uso de esta función asignamos el valor a una variable llamada adivinar_numero

import random as r

adivinar_numero = r.randrange(1,100)

Punto 3, 4 y 5: Se imprime en pantalla el texto de bienvenida al juego y luego, mediante un input se solicita al jugador que escoja la dificultad fácil o difícil y su opción se guarda en la variable modo_juego, así mismo el programa decidirá si brinda 5 o 10 oportunidades:

print("Welcome to the Number Guessing Game!")
print("I'm thinking of a number between 1 and 100")
modo_juego = input("Choose a difficulty. Type 'easy' or 'hard':\t")

# Dependiendo de la dificultad se llama a la función adivinar para que tenga en cuenta el número de oportunidades.
def dificultad():
    if modo_juego == 'easy':
        adivinar(10)
    elif modo_juego == 'hard':
        adivinar(5)
    else:
        "Option wrong"

Punto 6, 7, 8 y 9: Se crea la función adivinar para que ejecute la lógica principal de adivinar el número. Primero el usuario debe escribir el número con el que espera adivinar que queda almacenado en la variable numero_jugador. Luego mediante la variable x que contiene el número máximo de intentos, validamos si tenemos intentos disponibles para validar si el jugador adivinó el número con el uso de condicionales if y elif. Dependiendo de cual de las condicionales cumple se desplegará un mensaje en la pantalla. Si en algun momento adivina despliega el mensaje de felicitaciones y termina el ciclo for, pero si por el contrario no adivina dira una pista mencionando si el número ingresado por el jugador es más alto o mas bajo que el número que tiene que adivinar y le pedirá que lo intente de nuevo. Cuando finalicen los intentos el mensaje cambiara mostrando que ha perdido.

def adivinar(x):
    numero_jugador = 0    
    for intentos in range(0,x):
        print(f"You have {x-intentos} attempts remaining to guess the number.")
        numero_jugador = int(input("Make a guess:\t"))
        if intentos < x:
            if adivinar_numero == numero_jugador:
                print(f"You got it! The answer was {adivinar_numero}.")
                break
            elif adivinar_numero > numero_jugador:
                print("Too low")                
            elif adivinar_numero < numero_jugador:
                print("Too high")                
            if adivinar_numero != numero_jugador and intentos < x-1:
                print("Guess again")
            elif adivinar_numero != numero_jugador and intentos == x-1:
                print("You've run out of guesses, you lose.")

Repositorio Github

Reto día 11/100 con Python

Wilson Gutiérrez L — Wed, 27 Jan 2021 22:15:11 +0000

Saludos a todos los que estén leyendo este post. Antes de empezar quiero solicitarles el favor que si ven que lo que yo esté realizando se puede hacer de otra manera más efectiva me dejen su retroalimentación por favor. Además aclarar que aunque el post menciona el día 11 de los cien que dura el reto, va a resultar que termine desarrollándolo por partes y me demore unos días en finalizarlo ya que no me queda mucho tiempo para hacer estrictamente todo en un solo día. Por lo tanto voy a ir editando este post, agregando más contenido en el mismo a medida que vaya avanzando.

Repositorio Github

Juego de Black Jack

Bueno las condiciones o reglas del juego son las siguientes:

La baraja tiene un tamaño ilimitado.
No hay jokers.
La Jota / Reina / Rey cuentan como 10.
El As puede contar como 11 o 1.
Usa la siguiente lista como baraja de cartas:

cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]

Las cartas de la lista tienen la misma probabilidad de ser robadas.
Las cartas no se quitan de la baraja a medida que se roban.
La computadora es el distribuidor.

Consejos y pasos

Crear una función llamada deal_card() que use la lista a continuación y retorna una carta. El 11 es un As: cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]

Solución:

Se entiende que de la lista se debe entregar un número de carta aleatorio, lo que quiere decir que se debe tener en cuenta una función de random por lo que lo primero es importar el módulo random.

Al crear la función se debe aplicar un return para que cada vez que se utilice la función, ella entregue un número aleatorio.

import random as r

def deal_card():
    cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
    return r.choice(cards)

Pasar al usuario y al computador 2 cartas cada uno usando la función deal_card() y append() . Para retener las cartas se deben usar dos listas, una por cada jugador.

user_cards = []
computer_cards = []

Solución:

Tal como se mencionó arriba primero se declaran las dos variables de tipo lista vacía. Luego debo realizar un ciclo o iteración que se ejecute dos veces, donde por cada iteración almacene en las variables uno de los números de la lista cards de forma aleatoria. Esto con el fin de que apenas comience el juego cada jugador tenga en su mano dos cartas.

user_cards = []
computer_cards = []

#Con este script se almacena en cada lista dos cartas.
for i in range(2):
    user_cards.append(deal_card())
    computer_cards.append(deal_card())

Nota: Al final del ejercicio colocaré el código completo uniendo cada uno de los pasos que se están realizando.

Crear una función llamada calculate_score() que toma una lista como entrada y retorna el puntaje. Esta función sirve para calcular el puntaje de cada jugador. Uso la función sum() de python para poder sumar de manera simple los elementos de la lista.

score_user = 0
score_computer = 0

def calculate_score(hand):
    score = 0
    if sum(hand) > 21 and 11 in hand:
        hand.remove(11)
        hand.append(1)
        score = sum(hand)
    elif sum(hand) == 21 and len(hand) == 2:
        score = 0
    else:
        score = sum(hand)
    return score

score_user = calculate_score(user_cards)
score_computer = calculate_score(computer_cards)

Lo que primero debe hacer es revisar si el jugador ha sumado en sus cartas un puntaje mayor a 21 y si tiene un As entre las cartas, ya que esta carta puede ser tratada como un 11 o un 1, si el puntaje supera al 21 debe ser tratada como un 1 para poder seguir jugando. Si el puntaje es exactamente 21 y el número de cartas en su mano es de dos, quiere decir que obtuvo un BlackJack, en ese caso convertimos el puntaje en 0, así se representará el BlackJack. Por último si las anteriores condiciones no fueron cumplidas solo se sumará la mano retornando el valor total.

Los puntajes de cada jugador se deben guardar en variables y luego mostrar en pantalla la primera mano con sus puntajes, solo que la que tiene el computador se observará solo una carta. Si ninguno de los jugadores tiene BlackJack o no ha superado el puntaje a 21 entonces se deberá preguntar al usuario si desea otra carta y seguira haciendolo hasta que el jugador decida parar. Cada vez que el jugador acepte otra carta entonces el computador entregará al azar otra carta.

user_cards = []
computer_cards = []
game_over = False

while not game_over:
    cl.clean_screen()
    score_user = calculate_score(user_cards)
    score_computer = calculate_score(computer_cards)
    print(a.logo)
    print(f"    Your Cards: {user_cards}, current score {score_user} ")
    print(f"    Computer first card: {computer_cards[0]}")

    if score_user == 0 or score_computer == 0 or score_user > 21:
        game_over = True
    else:
        end_game = input("Other Card? Type 'y' or 'n' to pass\t")
        if end_game == 'y':
            user_cards.append(deal_card())
        else:
            game_over = True

Cuando le corresponda al computador jugar, este debe obtener más cartas solo hasta que tenga un puntaje de 17 o menos.

while score_computer != 0 and score_computer <= 17:
    computer_cards.append(deal_card())
    score_computer = calculate_score(computer_cards)

Después de obtener los dos puntajes, se deben comparar para saber quien es el ganador

def compare(score_user, score_computer):
    if score_user == score_computer:
        message = """
        ============================================
        =       DRAW                               =
        ============================================
        """
        return message
    elif score_computer == 0:
        message = """
        ============================================
        =       You Lose, opponent has BlackJack   =
        ============================================
        """
        return message
    elif score_user == 0:
        message = """
        ============================================
        =       You win, with a BlackJack          =
        ============================================
        """
        return message
    elif score_user > 21:
        message = """
        ============================================
        =       You went over. You lose            =
        ============================================
        """
        return message
    elif score_computer > 21:
        message = """
        ============================================
        =       Opponent went over. You win        =
        ============================================
        """
        return message
    elif score_user > score_computer:
        message = """
        ============================================
        =       You win                            =
        ============================================
        """
        return message
    else:
        message = """
        ============================================
        =       You lose                           =
        ============================================
        """
        return message

El juego debe permitir al jugador elegir, después de obtener el jugador, si quiere volver a jugar o, por el contrario, terminar el juego.

while input("Do you want to play a game BlackJack? Type 'y' or 'n': ") == 'y':
    play_game()

Como se observa, dentro del ciclo se llama a la función play_game(). Esta función contendrá a los ciclos while arriba mencionados y la ejecución de la función compare().

La unión de todo el código se puede revisar y/o descargar del repositorio Reto 100 dias en la carpeta dia_11.

Iniciando mi camino con Python

Wilson Gutiérrez L — Wed, 27 Jan 2021 20:58:30 +0000

Mi nombre es Wilson, de 40 años que para muchos es muy viejo pero yo todavía no siento esa edad. Estoy finalizando en la universidad la carrera de ingeniería de software. La verdad son muchas cosas básicas que enseñan pero poco que quede como conocimiento consciente.

Hace muchos años he querido hacer parte del gremio de desarrolladores, no importa que lenguaje y siempre me he quejado por que para empezar piden al menos dos años de experiencia y ninguna empresa brinda la oportunidad de empezar desde cero a menos que alguien te ayude. Sin embargo, eso cambió desde hace unos meses, ¿Qué ha cambiado? mi forma de pensar. Llegué a la conclusión que nunca tuve asesoría de nadie, ni un profesor, ni un amigo, ni un extraño.

Si alguien me lo hubiera dicho en ese entonces estoy seguro que hace rato estaría metido en ese mundo. Dicen que si no programas a diario no te gusta la programación y en eso difiero, simplemente no ha sido consciente de como funcionan las cosas.

No, todavía no he ingresado pero estoy dispuesto a seguir esos consejos que he escuchado durante los últimos meses que dicen que si no tienes experiencia en una empresa entonces hay que comenzar a crearla uno mismo con proyectos propios y por eso estoy aquí.

Hace ya algunas semanas he comenzado a estudiar desde cero la programación con Python, ya había tenido algo de experiencia académica con Java e hice un proyecto sencillo en php hace un par de años y debo decir que la experiencia con Python ha sido agradable.

Dentro de la búsqueda de cursos encontré uno que tiene como objetivo realizar código durante 100 días y me ha gustado mucho por que diariamente estoy intentando crear algo que, aunque muy básico, me ha logrado retar varias veces mentalmente.

Con los próximos blogs empezaré a publicar los ejercicios básicos que he realizado. No voy a empezar con los primeros pero voy a dejar más abajo el repositorio donde se encuentra alojado por si alguien se anima a brindarme ideas de como mejorar alguno de ellos.

Para finalizar, resumo que mi objetivo con estos blogs es ir publicando ejercicios que voy realizando y subiendo a mi repositorio github y los explicaré según como los entiendo de la mejor manera para ayudarme a reforzar los temas vistos. Espero que salgan más cosas buenas de esto y si alguien ha leído esto hasta el final muchas gracias por la paciencia.

Repositorio 100 días de Código