Practicando el tipado estático

Yo lo quise hacer de la manera mas profesional posible integrando pruebas unitarias para testear los metodos, y seria de la siguiente forma:

Archivo palindrome.py:

"""Python module to know if a string is palindrome"""


def is_palindrome(string: str) -> bool:
    """Returns if the string is palindrome (True or False)"""
    string = string.lower()
    string = string.replace(' ', '')
    return (string == string[::-1])


def run():
    print(is_palindrome('Hola mundo!'))


if __name__ == '__main__':
    run()

Archivo prime_number:

"""Python module to know if a number is prime"""


def is_prime(number: int) -> bool:
    """Returns True if number is prime or False if the number is not prime"""
    results_list = [x for x in range(2, number) if number % x == 0]
    return len(results_list) == 0


def run():
    number: int = 73
    number_is_prime: bool = is_prime(number)
    print(f'Is {number} a prime number? {number_is_prime}')


if __name__ == '__main__':
    run()

Y aqui el archivo test.py:

"""Testing the methods"""


import unittest
from unittest import TestCase
from palindrome import is_palindrome
from prime_number import is_prime


class TestingFunctions(TestCase):
    """Tests to know if the methods works well"""
    
    def test_is_palindrome(self):
        """Testing is_palindrome method"""
        self.assertEqual(is_palindrome('Ligar es ser agil'), True)
        self.assertEqual(is_palindrome('Arepera'), True)
        self.assertEqual(is_palindrome('Esto no es un palindromo'), False)
        self.assertEqual(is_palindrome('ESto tampoco es un palindromo'), False)
        self.assertEqual(is_palindrome('Ana'), True)

    def test_is_prime(self):
        """Testing is_prime method"""
        self.assertEqual(is_prime(100), False)
        self.assertEqual(is_prime(200), False)
        self.assertEqual(is_prime(53), True)
        self.assertEqual(is_prime(23), True)
        self.assertEqual(is_prime(45), False)
        self.assertEqual(is_prime(32), False)
        self.assertEqual(is_prime(142), False)


if __name__ == '__main__':
    unittest.main()

Y por ultimo los resultados de los tests:

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

Una herramienta muy útil para validar código antes de subirlo a un repositorio git es pre-commit. Para usarlo con mypy pueden revisar artículo.
Dejo un artículo con varias reglas de pre-commit para python enlace

Modulo mypy

El modulo mypy se complementa con el modulo typing ya que permitirá mostrar los errores de tipado débil en Python.

Para revisar si algún archivo contiene errores de tipado ejecutamos en la línea de comandos lo siguiente:

mypy archivo.py --check-untyped-defs

Como resultado nos mostrará si existe algún error de compatibilidad de tipos.

Practice the static type

• Following the tips of intermediate python course, from terminal:

1. mkdir new_folder
2. git init
3. py -m venv venv
4. touch .gitignore
   type in .gitignore file

# Ignore the enviroment files when you push to github.
venv

1. avenv (alias to activate venv: .\venv\Scripts\activate)
2. pip install mypy
3. pip list (to check mypy)
4. touch palindrome-py
5. code palindrome-py
6. Make your code!!!
7. mypy palindrome-py --check-untyped-defs

Mi aporte en código 😄
.
¡Hola a todos! De esta forma realice el reto. SI tienen alguna sugerencia es más que bienvenida 😃
(

Espero les sirva ¡Nunca paren de aprender!

Para preparar nuestro entorno de trabajo se siguió el siguiente procedimiento:

• Se crea una carpeta para el desarrollo del proyecto.
• Se inicializó un repositorio de git con “git init”.
• Se creó un ambiente virtual con “python3 -m venv venv”.
• Se creó un archivo .gitignore con “touch .gitignore”.
• Dentro del archivo .gitignore se coloca la carpeta venv mediante la siguiente línea código: “venv/”
• Se activó el ambiente virtual con “.\venv\Scripts\activate”.
• Se instaló mypy mediante “pip install mypy”.
• Se creó el archivo palindrome. py.

Recomiendo mucho el linter de python pylint es super exigente en la escritura de código, te ayuda escribir código de calidad:a

pip install pylint

Luego generan el archivo de configuración de pylint si quieren omitir algunas reglas o modificarlas:

pylint --generate-rcfile > .pylintrc

Luego no se les olvide que una vez teniendo todos los módulos instalados deben generar sus requirements.txt.

pip freeze > requirement.txt

Reto 1

def is_primo(num:int)->bool:
    result=[i for i in range(1,num+1) if num%i==0]
    return len(result)==2

def run():
    print(is_primo(13))

if __name__=='__main__':
    run()

Este es mi aporte, traté de usar la menor cantidad de líneas de código considerando lo siguiente:

• Como no se necesita dividir entre el número 1 y el mismo que estamos trabajando, NO los incluyo dentro del rango.
• En caso de que el número sea 1 NO entra en el ciclo for y se declara de inmediato que no es primo.
• En caso de que se encuentre un sólo módulo igual a cero salimos del ciclo inmediatamente, ya que no es necesario seguir buscando (con un contraejemplo basta).

def prime_number(number: int) -> bool:
    for i in range(2,number):
        if number % i == 0:
            return False
        return True
    return False

def run():
    n: int = int(input('Escribe un número'))
    if prime_number(n):
        print("Es primo")
    else:
        print("No es primo")

if __name__ == '__main__':
    run()

Para los que estamos utilizando WSL2 y nos dio problemas inicializar el entorno virtual aca dejo el comando

. venv/bin/activate

Practicando el tipado estático

• Para checar que el código respeta el tipado que especificamos, debemos correrlo con mypy <nombre>.py --check-untyped-defs 👀. El módulo mypy nos arroja errores de tipado, por ejemplo:

  palindrome.py:9: error: Argument 1 to "is_palindrome" has incompatible type "int"; expected "str"
  Found 1 error in 1 file (checked 1 source file)
  

• Solución al reto:

  def is_prime(number: int) -> bool:
      for i in range(2, number):
          if number % i == 0:
              return False
      return True
  
  def main():
      # print(is_prime('Hola'))
      print(is_prime(5))
  
  if __name__=='__main__':
      main()
  

Esta es mi solucion al reto, tambien puse a prueba mi creatividad para hacer el codigo lo mas efectivo posible y consegui un time complexity de O(sqrt(n))

from math import sqrt

def is_prime(n: int) -> bool:

    if n == 0 or n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    # Revisamos si el numero esta compuesto por
    # un numero primo diferente de 2 y 3.
    for i in range(5, int(sqrt(n)) + 1):
        if n % i == 0 or n % (i + 2) == 0:
            return False
    return True


def main():
    if is_prime(4):
        print("El numero es primo")
    else:
        print("El numero NO es primo")


if __name__ == '__main__':
    main()

Si estas usando powershell y no puedes activar el entorno virtual prueba con esto:

1. Abre powershell en modo administrador
2. ejecuta el siguiente comando

Set-ExecutionPolicy Unrestricted -Force 

Puedes encontrar mas información en https://docs.microsoft.com/en-us/powershell/…

Solución del reto con el teorema de Wilson:

def isPrime(number: int) -> bool:
    """
    Function that applyes the Wilson's Theorem 
    to determine if a number is prime.
    """
    factorial = number -1
    for i in range(2, number-1):
        factorial *= i
    
    return (factorial + 1) % number == 0


def run():
    print(isPrime(18))


if __name__ == '__main__':
    run()

ahora que lo pienso no se si debí importar typing pero bueno…acá está

from typing import *

def is_prime(num: int)-> bool:
    if num == 2:
        return True
    elif num == 1 or num % 2 == 0:
        return False
    else:
        return True

if __name__ == "__main__":
    print(is_prime(4))

Aquí les dejo mi código del reto de la clase. Estoy usando el Teorema de Wilson para la prueba de primalidad.

def is_prime(number: int) -> bool:
    factorial = 1
    if number == 0:
        return false
    for i in range(1, number):
        factorial = factorial * i
    factorial += 1
    if factorial % number == 0 and number > 1:
        return True
    else:
        return False

def primo(numero:int)->bool:
    acum=0
    for i in range(1,numero):
        if numero%i==0:
            acum+=1

    return acum==1 and numero%numero==0
def run():
    print(primo(7))

if __name__=='__main__':
    run()

def is_prime(number: int) -> bool:
    n = 0
    for num in range(1, number + 1):   
        if number % num == 0:
            n += 1
    return n == 2


def run():
    print(is_prime(5))


if __name__ == '__main__':
    run()

def is_prime(number: int) -> bool:
    if number > 1:
        for i in range(2, number//2):
            if (number % i) == 0:
                return False
            else:
                return True
        return False
    else:
        return False

if __name__ == "__main__":
    print(is_prime(13))

Una herramienta muy útil para revisar posibles errores en Python, como por ejemplo el tipo de datos, es utilizar Unit Testing.

Estos dos videos lo explican muy bien:
https://www.youtube.com/watch?v=1Lfv5tUGsn8
https://www.youtube.com/watch?v=6tNS--WetLI

A mi se me hizo muy fácil resolver el reto haciendo una lista de múltiplos para preguntar si el número es divisible solo por la unidad. Queda bastante corto y eficiente:

def is_prime(number: int) -> bool:
    my_list = [i for i in range(1, number+1) if number % i == 0]
    return [my_list == [1]]


def run():
    print(is_prime(1000))


if __name__ == '__main__':
    run()

Dejo mi aporte del tipado estático 😄

El modulo de Pruebas y Debugging del Curso “Introducción al Pensamiento Computacional con Python”, esta muy bien para complementar.

https://platzi.com/clases/1764-python-cs/25250-pruebas-de-caja-negra/

def is_prime(n: int) -> bool:
    return n > 1 and not any(list(map(lambda x: x == False, [n%x for x in list(range(2,n))])))

def run():
    print(is_prime(5))

if __name__ == "__main__":
    run()

Reto:

def CheckIfIsPrime(Number: int) -> bool:
    if Number == 0:
        return False
    Division = Number / 2
    if Number == 2:
        return True
    if (Division - round(Division)) != 0:
        return True
    else:
        return False

def run():
    Number = 11
    print(CheckIfIsPrime(Number))


if __name__ == '__main__':
    run()

Mi reto, de los números primos:

def es_primo(num):
    for n in range(2, num):
        if num % n == 0:
            print("No es primo", n, "es divisor")
            return False
    print("Es primo")
    return True

def run():
    numero:int = int(input("Ingrese un numero: ")
    es_primo(numero)

if __name__=='__main__':
    run()

mi aporte al reto del profesor:

def primalidad(n: int)  ->  bool:
    raiz: int =int(n**0.5) + 1
    divisores : list[int] = [i for i in range(2, raiz) if n % i == 0]
    esPrimo : bool = len(divisores) == 0
    return esPrimo
        

if __name__=="__main__":
    n: int =int(input("escriba un numero para saber si es primo: "))
    primo: bool = primalidad(n)
    if primo == True:
        print("es un numero primo!!")
    else:
        print("No es primo")

Este es mi aporte.
Quise tomar buenas prácticas mediante el manejo de errores.
Cualquier critica es bienvenida

def is_prime(number: int) -> bool:
    if not number % 2 == 0:
        return True
    else:
        return False


def run():
    while True:

        try:
            number = int(input('Ingresa un número entero -> '))
            assert number > 0, 'Ingresa un número mayor a cero'
            print(f'{number} es primo') if is_prime(number) else print(f'{number} No es primo')
            break

        except ValueError:
            print('Ingresa un número Valido. Intenta de nuevo por favor')

        except AssertionError as ae:
            print(ae)


if __name__ == '__main__':
    run()

Challenge

def factorial(number: int) -> int:
    if (number == 1):
        return 1
    return number * factorial(number - 1)


def is_prime(number: int) -> bool:
    multiple = (factorial(number - 1) + 1) % number
    if number != 1 and multiple == 0:
        return True
    else:
        return False    


def run():
    try:
        number: int = int(input('Input a number 🎰: '))
        if is_prime(number):
            print('Is a prime number ✌')
        else:
            print('Is not a prime number 😒')
    except ValueError:
        print('You must input a number 😎')


if __name__ == '__main__':
    run()

Aporte

Les comparto mi versión de la práctica.

"""
A simple module to validate palindromes.

Author: Jose Noriega <[email protected]>
"""

import re
from unidecode import unidecode


def is_palindrome(value: str) -> bool:
    """Checks if the given value is palidrome.

    Time complexity: O(n) where n is the length of the given string.
    
    Returns:
        bool: Result of the comparation.
    """

    assert isinstance(value, str), 'Value must be an instance of Str'

    # Normalize value
    normalized_value: str
    normalized_value = re.sub(r'[ ,.;:]+', '', value).lower()
    normalized_value = unidecode(normalized_value)

    value_length: int = len(normalized_value)
    if value_length <= 1:
        return True

    left_pointer: int = 0
    right_pointer: int = value_length - 1

    while left_pointer < right_pointer:
        if normalized_value[left_pointer] != normalized_value[right_pointer]:
            return False

        left_pointer += 1
        right_pointer -= 1

    return True

if __name__ == '__main__':
    import unittest

    from ddt import ddt  # type: ignore
    from ddt import data  # type: ignore
    from ddt import unpack  # type: ignore


    @ddt
    class IsPalindromeTestCase(unittest.TestCase):

        @data(
            ('A luna ese anula.', True),
            ('A la catalana banal, atácala.', True),
            ('A ti no, bonita.', True),
            ('Ají traga la lagartija', True),
            ('Amad a la dama.', True),
            ('Amo la pacífica paloma.', True),
            ('Amor a Roma.', True),
            ('Ana lava lana.', True),
            ('Ana lleva al oso la avellana.', True),
            ('Anita lava la tina.', True),
            ('Atar a la rata.', True),
            ('Platzi.', False),
            ('Javascript.', False),
            ('Python.', False),
            ('Typings.', False),
            ('John Doe.', False),
        )
        @unpack
        def test_is_palindrome(self, value: str, expected_result: bool):
            result: bool = is_palindrome(value)
            self.assertEqual(result, expected_result)

    unittest.main(verbosity=1)

Tipado Estatico

El modulo mypy se complementa con el modulo typing ya que permitirá mostrar los errores de tipado débil en Python.

1. mkdir new_folder
2. git init
3. py -m venv venv
4. touch .gitignore
5. type in .gitignore file
6. Ignore the enviroment files when you push to github.

venv

1. avenv (alias to activate venv: .\venv\Scripts\activate)
2. pip install mypy
3. pip list (to check mypy)
4. touch palindrome-py
5. code palindrome-py
6. Make your code!!!
7. mypy palindrome-py --check-untyped-defs

def prime_numbers(num: int) -> bool:
    counter: int = 0
    if num == 1:
        return False
    for i in range(1, num + 1):
        if i == 1 or i == num:
            continue
        if num % i == 0:
            counter += 1

    if counter == 0:
        return True
    else:
        return False


def is_palindrome(word: str) -> bool:
    # The strip() method removes any spaces at the beginning and at the end
    word = word.replace(" ", "").lower()
    print(word)
    # it returns the word from back to front
    return word == word[::-1]


def run():
    number: int = int(input("Ingresa un numero: "))
    is_prime: bool = prime_numbers(number)
    if is_prime == True:
        print(f"The number {number} is a prime number")
    else:
        print(f"The number {number} is not a prime")


if __name__ == "__main__":
    run()

Reto

def primo(num: int) -> bool:
 if num < 2: #si es menor a 2 no es primo
   return False
 for i in range(2, num): 
   if num % i == 0: 
    return False
 return True 

def run():
     print(primo(5))

if __name__ == '__main__':
    run()

numeros_primos_tipado.py

def is_primo (numero: int) -> bool:
    for i in range(2,numero):
        if numero % i == 0:
            # print(f"{numero} mod {i} ==",str(numero%i))
            return False
    return True


def run():
    print(is_primo(13))
    print(is_primo(45))


if __name__ == "__main__":
    run()

Dejo mi reto con el argumento tipo string a propósito.

def prime_number(number: int) -> bool:
    if number > 1:
        for i in range(2, int(number/2) + 1):
            if number % i == 0:
                return False
                break

        else:
            return True

    else:
        return False

def run():
    print(prime_number('Eduarda'))

if __name__ == '__main__':
    run()

My code 😁

def palidrome(string: str) -> bool:
    """Returns if the a word is a palinfrome or not"""
    return string == string[::-1]

def run():
    """Main code"""
    word = str(input('Insert a word or phrase: '))
    #Ternary if
    print(f'The word {word} is palindrome') if palidrome(word.lower()) else print(f'The word {word} is not a palindrome')

if __name__ == '__main__':
    """Excecute the main code"""
    run() 

Aquí una pequeña muestra de lo que hice con un one liner. 😀

def even_or_odd(number: int) -> str:
    initial: str = "- The number entered is "
    return "".join([initial, "Even"]) if number % 2 == 0 else "".join([initial, "Odd"])


def run():
    print("\n", even_or_odd(int(input("\nInsert a number to check: "))))


if __name__ == "__main__":
    run()

Y aquí la muestra de su ejecución:

def prime_number(number: int) -> bool:
    for num in range(1, number+1):
        if num == 1 or num == number:
            continue
        if number % num == 0:
            # No es primo
            return False
    # Es primo
    return True        
def run():
    n: int = int(input("Pon un numero: "))
    print("True = Es Primo. False = NO es primo")
    print(prime_number(n))
if __name__ == '__main__':
    run()
    

Mi codigo del reto

def is_prime(number: int) -> bool:
    if number % 2 == 0 or number < 0:
        return False

    for test in range(3, number // 2, 2):
        print(test)
        if number % test == 0:
            return False
    else:
        return True


def run():
    result: bool = is_prime(79)
    print(result)


if __name__ == "__main__":
    run()

def es_primo(numero: int) -> bool:
    contador: int = 0

    for i in range(1, numero + 1):
        if i == 1 or i == numero:
            continue 
        if numero % i == 0:
            contador +=1
    if contador == 0:
        return True
    else:
        return False


def run() -> str:
    numero: int = int(input('escribe un numero: '))
    if es_primo(numero):
        print('es primo')
    else:
        print('no es primo')


if __name__ == '__main__':
    run()

Mi solución

def is_prime(number:int)->bool:
    """
    This function returns True if the number is prime.
    """
    if number < 2:
        return False
    for i in range(2, number):
        if number % i == 0:
            return False
    return True

def primeNumbers(n:int) -> list:
    """
    This function returns a list of prime numbers up to n.
    """
    primes = [number for number in range(2, n+1) if is_prime(number)]
    return primes

def main() -> None:
    """
    This is the main function.
    """
    print(primeNumbers(100))

if __name__ == '__main__':
    main()

Mi propuesta

def is_prime(number: int) -> bool:
    """It returns True when number is only divisible by 1 and by the same number"""

    for i in range(2,number):
        if number % i == 0:
            return False
    return True


def run():
    print(is_prime(1))


if __name__ == '__main__':
    run()

El reto del número primo

def is_prime(number: int) -> bool:
    try: 
        if number <= 1:
            return False
        for n in range(2, number):
            if number % n == 0:
                return False
        return True
    except TypeError as err:
        print(f'El parametro no es un entero. Descripcion error: {err}')
        return False


def run():
    print(is_prime(100))

 
if __name__ == '__main__':
    run()

La línea que reemplaza los espacios vacíos es útil en casos muy específicos como los espacios intermedios en una oración, pero no para los espacios abundantes al inicio o fin de una cadena, entonces se podría reemplazar o agregar la siguiente línea para ese caso:

# '   hola  ' -> 'hola'
string = string.strip()

Comprobar si un número es primo

def is_prime(num: int) -> bool:
    if num > 1:
        for i in range(2, num):
            if num % i == 0:
                return False
        return True
    return False

Aplicando el teorema que un amigo me explicó de un libro para que sea lo más eficiente posible.

import math

def is_prime(number : int) -> bool:
    search_range : int = math.ceil(number / 2) + 1
    if number == 2 or number == 1:
        return True
    else:
        for x in range(2, search_range):
            if(number / x < x):
                return True
    return False

def run():
    if(is_prime(143)):
        print("It's prime!")
    else:
        print("Nope")

if __name__ == "__main__":
    run()   

def primo(number: int):
    result= len([x for x in range(2, number+1) if number % x == 0]) == 1
    if result == True:
        print(number, "Es primo mi rey")
    else:
        print(number, "No es primo mi pai")

def run():
    number = int(input("ingrese un número: "))
    if number >=1:
        primo(number)
    else:
        print("números negativos no recibo papi")

👾

Mi aporte
así fue como yo resolví el reto de tipado estático

def primalidad(num: int) -> bool:
    checador: int=0
    for i in range(2, num):
        if num%i==0:
            checador+=1
    if checador==0:
        return True
    else:
        return False

def run():
    print(primalidad(17))

if __name__=="__main__":
    run()

Espero les sirva y le entiendan

Aquí el reto 😄

def is_prime(number: int) -> bool:
    result_factorial: int = 1
    for i in range(1, number):
        result_factorial *= i
    return (result_factorial + 1) % number  == 0

def run(): 
    print(is_prime(9))

if __name__ == "__main__":
    run()

Mi solución al problema:

def is_prime(number: int) -> bool:      #Returns true if the given number is prime. Otherwise returns false.
    for i in range(2, number // 2):     #For prime checking It just try to divide the given number and 2 ... number // 2
        if number % i == 0:             #It's not prime thus It returns False.
            return False
    return True

def run():
    print(is_prime(13))

if __name__ == "__main__":
    run()
    

mi pequeño aporte

def numero_primo(num:int) ->bool:
    cont:int = 0
# sacar rais del numero
    rais:int = num**(0.5)

# validar si numero es par o 2 
    if num% 2 == 0 and num != 2:
        return False    
    else:
# validar numeros desde i hasta la raiz del numero 
        for i in range(1, int(rais)+1):
            if i == 1 or i == num :
                continue
            elif num % i == 0:
                cont +=1
# retorna True si es primo y false si no es primo 
    if cont == 0 and num != 1: 
            return True
    else:
            return False

    

def run():
    num:int = int(input("ingresa un numero para validar si es primo: "))
    if numero_primo(num):
        print('Es primo')
    else:
        print('No es primo')
    
    
    

if __name__ == "__main__":
    run()```

Este es mi codigo:

saludos,

def is_prime(number: int) -> bool:
    return number % 2 == 0 or number % 3 == 0 or number % 5 == 0 or number % 7 == 0 

def run():
    
    number: int = 98
    if is_prime(number):
        print(f'not is prime {number}') 
    else:
         print(f"is prime {number}")   

if __name__ == "__main__":
    run()

Aquí mi aporte del Reto:

def is_primo(n: int) -> bool:
    if n < 2:
        return False
    primo = [x for x in range(2, n) if n % x == 0]
    print(primo)
    if len(primo) >= 1:
        return False
    return True

def run():
    n: int = int(input('Digite um número: '))
    if is_primo(n):
        print('Es primo')
    else:
        print('No es primo')


if __name__ == '__main__':
    run()

def is_prime(number: int) -> bool:
result_list = [x for x in range(2, number + 1) if number % x == 0]
return len(result_list) == 0

def run():
number: int = 15
if is_prime(number):
print(“Es primo”)
else:
print(“No es primo”)

if name == ‘main’:
run()

def is_prime(number: int) -> bool:
    for x in range(2, number):
        if (number%x == 0):
            return False
    return True

def run():
    print(is_prime(9))

if __name__ == "__main__":
    run()

Estamos

def is_primal(num: int) -> bool:
    counter = 0
    for i in range(1, num + 1):
        if num % i == 0:
            counter += 1
    if counter > 2:
        return False
    else:
        return True


def run():
    print(is_primal('10'))


if __name__ == '__main__':
    run()

OK ahi va el mio:

def primality_check(num: int):
    if num > 1:
        for i in range(2,num):
            if (num % i) == 0:
                print(str(num), " No es un numero primo")
                break
        else:
            print(str(num), " SI ES UN NUMERO PRIMO")


def run():
    counter: bool = True
    while counter:
        try:
            num: int = int(input("Ingresa un número a verificar: "))
            assert num > 0, "No se pueden ingresar numeros negativos"
            primality_check(num)
        except ValueError:
            print("Debes ingresar un número\n-----------------------------")
        try:
            opt: int = int(input("\nQuieres seguir intentando?: \n 1 SI\n 2 NO\nRespuesta: "))
            if opt == 1:
                pass
            elif opt == 2:
                counter = False
            else:
                print("Respuesta no valida")
        except ValueError:
            print("Debes ingresar una opción válida\n-----------------------------")
                

if __name__ == '__main__':
    run()

Les dejo mi solucion al reto

def is_prime(num: int) -> bool:
    counter = 0
    for n in range(2, num + 1):
        if num % n == 0:
            counter += 1
            if counter > 1:
                return False
    return True

def run():
    print(is_prime(11))

if __name__ == "__main__":
    run()

Aporte

def is_prime(number: int) -> bool:
    i = 0
    if number % 2 == 0:
        return False
    else:
        for x in range(2,number):
            if number % x == 0:
                i = i + 1
        return i == 0

def run():
    print(is_prime(137))



if __name__=='__main__':
    run()

Mi aporte del reto de la clase:

def is_prime(number: int) -> bool:
    base = number - 1
    n = 1
    for i in range(base, 1, -1):
        n = n * i
    n = n + 1
    if n % number == 0:
        return True
    else:
        return False

def run():
    print(is_prime(7))

if __name__ == "__main__":
    run()

Utilicé una fórmula del teorema de Wilson, es problema es que entre más grande el número más tardado será el programa.

Hola a todos aqui les comparto mi aporte al reto de la clase

def number_prime(number: int) -> bool:
    count: int = 0
    for i in range(1, number+1):
        if number % i == 0:
            count += 1
    return count == 2
                 

def run():
    num = int(input("Ingresa un numero: "))
    if number_prime(num):
        print(f"El numero {num} es primo")
    else:
        print(f"El numero {num} no es primo")

if __name__ == '__main__':
    run()

Les comparto mi código: Espero que sea de vuestro ayuda.
P.D: Con muchas ganas recibo Feedback.

def is_prime(number: int) -> int:
   if number <= 1:
      return True
   midle: int = number // 2
   is_prime: bool = True
   for i in range(2, midle +1):
      if (number % i == 0):
         is_prime = False
         break
   return is_prime

def run():
   # here we have an error before run the python module with module mypy
   number: int = (input("Enter a number: "))
   print(is_prime(number))

if __name__ == '__main__':
   run()

Reto

def isPrime(number: int) -> bool:
    if number < 1:
        return False
    elif number == 2:
        return True
    else:
        for i in range(2, number):
            if number % i == 0:
                return False
        return True            

def app():
    number: int = int(input('Write a number: '))
    result: bool = isPrime(number)
    print(result)

if __name__ == '__main__':
    app()

pip install mypy
mypy filename.py --check-untyped-defs

def run():
    
    def numeroPrimo (number: int) -> bool:
        result_list = [x for x in range(2,number+1)if number %x ==0]
        result_final = len(result_list)==1
        if result_final ==True:
            print("el nyumero es primo")
        else:
            print("el numero no es primo sus divisores son "+str(result_list))

    num=int(input("ingrese un numero"))
    if num>=1:
        numeroPrimo(num)
    else:
        print("Debe ser un numero entero positivo")

if __name__ == '__main__':
    run()

Para abrir el directorio actual con VS Code se puede utiliza el comando:
code .

Mi reto resuelto:

def is_prime(number: int) -> bool:
    prime = True
    for i in range(2,number):
        if number % i == 0:
            prime = False
            break
    return prime

def run():
    print(is_prime(11))

if __name__ == '__main__':
    run()

import math
"""
Función para calcular si un número es primo.
Esta función primeramente calcula la raíz cuadrade del número ingresado, y se hace el recorrido únicamente hasta este valor, con la cual para número grandes 
no es necesario recorrer hasta dicho número. Ejm para el número 10601, únicamente recorremos hasta su raíz más 1, osea hasta 103
"""
def es_primo(numero: int ) ->bool:
  es_primo: bool = True
  raiz: int = round(math.sqrt(numero))
  for i in range(1, raiz + 1):
    if i == 1 or i == numero:
      continue
    if (numero % i) == 0:
      es_primo = False
      break

  return es_primo

def run():
  numero: int = int(input("Ingrese un numero: "))
  if (es_primo(numero)):
    print(f"el numero {numero} es primo")
  else:
    print(f"el numero {numero} NO es primo")  

if __name__ == '__main__':
  run()

Que clase tan productiva la verdad, retomamos conceptos mientras aprendemos unos nuevos 👾

❤️

puedes utilizar mypy y pylint con visual studio code para que te marque los errores solo tienes que instalar los modulos con el gestor de paquetes pip y agregas este codigo al json de tu visual studio code

"python.defaultInterpreterPath": "C:\\Users\\MairenaMontoyaJordyJ\\AppData\\Roaming\\Python\\Python310\\python.exe", // path de tu instalacion de python generalmente es la misma solo le cambias  el user
    "mypy.dmypyExecutable": "C:\\Users\\MairenaMontoyaJordyJ\\AppData\\Roaming\\Python\\Python310\\Scripts\\dmypy.exe", // ubicacion de demon de mypy es un archivo .exe llamado dmypy.exe este se te crea al instalar el modulo con pip install mypy
    "mypy.runUsingActiveInterpreter": false,
    "python.linting.enabled": true,
    "python.linting.pylintEnabled": true,
    "python.linting.pylintArgs": [

        "--disable=W0611"
    ],
    "python.linting.mypyEnabled": true,
    "python.linting.mypyCategorySeverity.error":"Warning",
    "python.linting.mypyArgs": [
        "--ignore-missing-imports",
        "--follow-imports=silent",
        "--show-column-numbers",
        "--disallow-untyped-defs",
        "--disallow-untyped-calls"
    ],

adicionalmente recomiendo instalar las siguientes extensiones:
autoDocstring - Python Docstring Generator v0.6.1
Doxygen Documentation Generator v1.4.0
Mypy v0.2.2
Path Intellisense v2.8.0
Trailing Spaces v0.3.1
Python Type Hint v1.4.1
Pylance v2022.5.2
Code Runner v0.11.7

bueno ese es mi setup de visual studio code para programar con python espero les guste y les sea de utilidad

Compañeros buenas tardes, comparto mi aporte

def primalidad(num:int) -> bool:
    conteo = 0
    for i in range(1,num+1):
        #print(i)
        if(num%i == 0 or num==1):
            conteo+=1
        else:
            continue
    if conteo>2:
        #print("No es primo")
        return False
    else:
        #print("Si es primo !!!")
        return True

def run():
    #num = int(input("Ingresa un numero: "))
    #primalidad(num)

    print(primalidad(29))



if __name__=='__main__':
    run()

¡Hola!
MI aporte de reto:

RETO

def primos(number: int)->bool:
    for i in range(2,number):
        if number%i==0:
            print("No es primo")
            return False
    print("Es primo")
    return True

def run():
    print(primos(7))


if __name__=='__main__':
    run()

Hola a todos. Les dejó mi código del reto, mi código está basado en el archivo anteriormente hecho de primalidad.
Espero que los ayude.
Saludos.

Para activar el venv desde mac con terminal zsh lo pueden hacer de la siguiente forma

$ source <venv>/bin/activate

Buenas, aquí mi resolución del reto:

# Make a program to verify if a number is prime or not, but do it with
#static typing.

def is_prime_or_not(num: int)->bool:
        num = num % 2 !=0
        return num != 0
             

def run():
    print(is_prime_or_not(10))


if __name__ == '__main__':
    run()

Este es mi aporte sobre la tarea

def is_primo( numero : int) -> bool:
    for n in range(numero-1, 1, -1):
        if numero % n == 0: 
            return False
    
    return True

def run():
    numero : int = int(input("digite un numero primo: ")) 
    print(is_primo(numero))

if __name__  == '__main__':
    run()

#Para probar en la consola ejecute:
# $ mypy primos.py --check-untyped-defs

Mi aporte alreto propuesto es:

def is_prime(number: int) -> bool:
    '''
    Function to check if a number is prime
    '''
    if number < 2:
        return False
    for i in range(2, number):
        if number % i == 0:
            return False
    return True

def es_primo(primo: int)->int:
#primo=primo
for n in range(2, primo):
if primo % n == 0:
return primo

def run():
num=int(input("Digite un número: "))
if es_primo(num):
print(“No es primo”)
else:
print(“Es primo”)

if name ==‘main’:
run()

def is_prime(number: float) -> bool: 
    """
    Verifies if is a number is prime or not 
    
    Parameters
    ----------
    number : float
        The number to be verified
    """
    is_prime: bool = False
    if number % 2 == 0 and number != 2.0: 
        is_prime = False        

    lim = range(1, int(number + 1))
    division_counts = 0

    for num in lim: 
        if (number / num).is_integer():
            division_counts += 1

    if division_counts == 2: is_prime = True

    return is_prime

def ask_number() -> float:
    """
    Ask for a number using the standard input
    """
    is_number: bool = False
    number: float = 0
    while not is_number: 
        try: 
            number = float(input("Enter a number: "))
            is_number = True
        except (TypeError, ValueError) as error: 
            is_number = False
    return number

def run():
    number_input = ask_number()
    if is_prime(number_input): print("Is prime")
    else: print("Not prime")
    

if __name__ == "__main__":
    while True:
        run()

Aunque sinceramente valide el curso de Python Básico, hice el ejercicio de números primos. Acá esta mi resultado:

#!/usr/bin/python3

def is_prime (number: int) -> bool:
    prime_number_base: tuple[int, ...] = (2, 3, 5, 7)
    number_is_prime = True

    for prime_number in prime_number_base:
        if number % prime_number == 0:
            number_is_prime = False
            break

    return number_is_prime

def check_prime_numbers (num_numbers: int) -> tuple[int, ...]:
    prime_numbers: list[int] = []
    
    for i in range(num_numbers):
        if is_prime(i + 1):
            prime_numbers.append(i + 1)

    return tuple(prime_numbers)

if __name__ == "__main__":
    prime_numbers: tuple[int, ...] = check_prime_numbers(50)
    print(prime_numbers)

Si quieren que mypy les indique en que linea de código tuvieron el error de una mejor forma, pueden agregar la flag --pretty al comando. Y, aunque inecesario, pueden agregar --no-pretty para el resultado común.

$ mypy archivo.py --check-untyped-defs --pretty

def is_prime(number:int) -> bool:
    div_list = []
    for i in range(number):
        if number%(number-i) == 0:
            div_list.append(1)
    if len(div_list) <= 2:
        return True
    else:
        return False

def run():
    print(is_prime(4))

if __name__ == '__main__':
    run()

Hi

def primesheck(integer:int)-> bool:
    factorial=1    
    for i in range(1,integer):
        factorial *= i
    return (factorial +1) % integer == 0

def run():
    integer=int(input('Type the positive integer:'))
    print(primesheck(integer))

if __name__ == '__main__':
    run()    

def is_prime_number(number: int) -> bool:
    if number < 2:
        return False
    for i in range(2, number):
        if number % i == 0:
            return False
    return True

def run():
    print(is_prime_number(int(input("Enter a number: "))))

if __name__ == "__main__":
    run()

CODIGO (Reto 1):

def is_primo(number: int) -> bool:
    if number > 1:
        for n in range(2, number):
            if (number % n) == 0:
                return False
            else:
                return True
    else:
        return False

        
def run():
    number = int(input("Ingrese un numero entero positivo: "))
    if is_primo(number):
        print(number, "is a prime number")
    else:
        print(number, "is not prime number")


if __name__ == '__main__':
    run() 

RESULTADOS (Reto 1):

Ingrese un numero entero positivo: 17
17 is a prime number

Process finished with exit code 0 

Ingrese un numero entero positivo: 12
12 is not prime number

Process finished with exit code 0 

Buen reto

aquí mi humilde código:

def es_primo(entero: int) -> bool:
    f: int = 0
    for i in range(1, entero+1):
        if entero == 1:
            f = 2
        elif entero % i == 0:
            f = f + 1
    return f == 2


def run():
    numero = input("Ingrese un número: ")
    print(es_primo(int(numero)))

if __name__ == '__main__':
    run()

Mi aporte, con algunas modificaciones intentando mantener las mejores prácticas posibles.

El reto

from numpy import true_divide

def run():
    try:
        numero = int(input("Escribe un número: "))
        if es_primo(numero):
            print("Es primo")
        else:
            print("No es primo")
    except ValueError as ve:
        print("Deber introducir un número entero")
        run()    
        

def es_primo(numero: int) -> bool:
    i = 0
    for i in range(1, numero + 1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            return False
    return True    


if __name__ == '__main__':
    run()

Una buena práctica es mantener una inmutabilidad en las variables, en el ejemplo se reasigna el valor de la misma variable para hacerle la limpieza de espacios, pero se lee mejor cuando se define una nueva variable, así quedo mi ejercicio:

def is_palindrome(word: str) -> bool:
    clean_word = word.strip().lower()   # Para limpiar los espacios de un string es mejor usar `strip` 👀
    return clean_word == clean_word[::-1]

Al final de la ejecución el el garbage collector limpiara ambas variables definidas en el scope de la funcion 😃

def prime_num(num: int):
    for n in range(2, num):
        if num % n == 0:
            print(num, "is a not a prime number is divisible by", n)
            return False
    print(num, " is a prime number")
    return True


def run():
    prime_num(81)


if __name__ == '__main__':
    run()

Esta es mi versión del código:

def is_palindrome(word: str) -> bool:
    '''
    This function tells if a word is a palindrome or not
    input:
        word -> string
    output:
        True / False -> bool
    '''
    try:    
        word = str(word)
        word = word.lower()
    except:
        print('The word you entered cannot be converted to string')
    inversed_word = word[::-1]
    if word == inversed_word:
        return True
    return False

def run():
    test_word = 'ana'
    print(is_palindrome(test_word))

if __name__ == '__main__':
    run()```

def es_primo(numero: int)-> bool:
    return numero%2 != 0


def run():
    print(es_primo(7))


if __name__ == '__main__':
    run()

Mi solución

def is_numeroprimo(integrer: int) -> bool:
    if integrer < 2:
        return False
    elif integrer % 2 == 0:
        return False
    else:
        return True

def run():
    print(is_numeroprimo(44))


if __name__ == "__main__":
    run()

RETO
Me entro la curiosidad de provar cual función para encontrar los números primos era mejor, una utilizando for e if ó una utilizando list comprehension, así que esto fue lo que encontre:

El código es el siguiente:

import time


def is_prime(number: int) -> bool:
    """This function evaluates if a number is a prime or not

    Args:
        number (int): any number integer positive

    Returns:
        bool: Returs True if is prime and False if is not prime
    """
    for factor in range(2, number):
        if number % factor == 0:
            return False
    return True


def is_prime_v2(number: int) -> bool:
    """This function evaluates if a number is a prime or not

    Args:
        number (int): any number integer positive

    Returns:
        bool: Returs True if is prime and False if is not prime
    """
    factors_list = [factor for factor in range(
        2, number) if number % factor == 0]

    return len(factors_list) == 0


def run():
    # Test for function V_1 (for and ifs)
    print("\nFor function V_1 (for and ifs)")
    t0 = time.time()
    # print(is_prime(5780107))   #Number that is not prime
    print(is_prime(7919))  # Number that is prime
    t1 = time.time()
    print("Time elapsed: ", t1 - t0)  # CPU seconds elapsed (floating point)

    # Test for function V_2 (List comprenhensions)
    print("\nFor function V_2 (List comprenhensions)")
    t0 = time.time()
    # print(is_prime_v2(5780107))    #Number that is not prime
    print(is_prime_v2(7919))  # Number that is prime
    t1 = time.time()
    print("Time elapsed: ", t1 - t0)  # CPU seconds elapsed (floating point)


if __name__ == '__main__':
    run()

Los resultados que obtuve utilizando un número primo grande fueron los siguientes:

Consola…

╰─ python3 prime_static_typing.py

For function V_1 (for and ifs)
True
Time elapsed:  0.00039315223693847656

For function V_2 (List comprenhensions)
True
Time elapsed:  0.000408172607421875

Y para un número que no es primo grande:

Consola…

╰─ python3 prime_static_typing.py

For function V_1 (for and ifs)
False
Time elapsed:  2.7179718017578125e-05

For function V_2 (List comprenhensions)
False
Time elapsed:  0.27687954902648926

Conclusiones, la función 1 es más “eficiente”, ya que no es necesario que evalue todos los posibles factores de nuestro número en cuestion, pues al encontrar el primero se entiende que ya no es un número primo.
Pero si resultara que sí es un número primo entonces ambas funciones son iguales de veloces, aunque la segunda función es mucho mas compacta que la primera.
¡Hasta aquí mi reporte, Joaquin!