Funciones

Principio DRY

Las funciones nos ayudan a cumplir con uno de los principios más importantes de la programación como lo es el principio DRY (don’t repeat yourself) o (no te repitas).

Al tener la lógica en una función evitas tener que escribir la misma lógica una y otra vez, de modo que tienes un código más limpio y más escalable.

Mi aporte:

print('Hola, Platzinauta') 
#Agregando una funcion print

def greeting(text):
# Aquí estamos agregando una funcion y su sintaxis.
# Junto con sus parametros en este caso 'text'
  print('This is my print')
  print('This is my print 2')
  print(text)

greeting('parametro')
#  Una manera de llamar a la función
greeting('Texto ejemplo, llamando a la función desde su parametro. ' * 2)
#Aquí otro ejemplo con suma
def suma(a,b):
  print(a + b)
#  Imprimimos el resultado a consola
suma(200, 100) 
# llamamos a la función con parametros

mi aporte

el aporte es el juego de piedra papel o tijera hecho en el anterior curso

# Imports
import random
import time
import getpass

# Write animation
def write_fx(frase):
    for letra in frase:
        print(letra, end='', flush=True)
        time.sleep(0.010)
    
# game
def play(num1, num2, cpu_cs):
     
    empty = 0

    computer_wins = 0

    user_wins = 0

    rounds = 0


    while True:
        
        num2 = random.choice(cpu_cs)


        if num1 == num2:
            time.sleep(1)
            result = '\n    [*] Nadie gana'
            empty += 1
            rounds += 1

        elif num1 =='tijeras' and num2 == 'piedra' or num1 == 'papel' and num2 == 'tijeras' or num1 == 'piedra' and num2 == 'papel':
            time.sleep(1)
            result = '\n    [*] La maquina gana'
            computer_wins += 1
            rounds += 1

        elif num1 == 'piedra' and num2 == 'tijeras' or num1 == 'tijeras' and num2 == 'papel' or num1 == 'papel' and num2 == 'piedra':
            time.sleep(1)
            result = '\n    [*] El jugador gana'
            user_wins += 1
            rounds += 1

        if user_wins == 2:
            write_fx(f'''   
    Resultado de Partida numero {rounds}   
                
            {result}

    La seleccion de la maquina fue {num2}''')
            table('EL Usuario :D', rounds, user_wins, computer_wins, empty)
            break

        elif computer_wins == 2:
            write_fx(f'''   
    Resultado de Partida numero {rounds}   
                
            {result}

    La seleccion de la maquina fue {num2}''')
            table('La Maquina :D', rounds, user_wins, computer_wins, empty)
            break

        else:
            write_fx(f'''   
    RESULTADO DE PARTIDA NUMERO {rounds}   
                
            {result}

    La seleccion de la maquina fue {num2}''')

                
            write_fx(f'''
            
    vuelve a escoger entre 
            
    [*] Piedra
    [*] Papel
    [*] Tijeras
            
    para la siguiente ronda: ''')
            
            num1 = input('').lower().replace(' ','')

            if num1 not in cpu_cs:
                write_fx('\n    Comando no valido')
                time.sleep(1)
                
                write_fx(f'''
            
    vuelve a escoger entre 
            
    [*] Piedra
    [*] Papel
    [*] Tijeras
            
    para la siguiente ronda: ''')
                num1 = input('').lower().replace(' ','')
                continue

# User Interface
def table(nom, var1, var2, var3, var4):
    time.sleep(1)
    write_fx(f'''
    
     ________________________________________________________________
    | Partidas | ganadas por usuario | ganadas por maquina | Empates |
    |------------------------------------------------------|---------|
    |     {var1}    |         {var2}           |         {var3}           |    {var4}    |
     ----------------------------------------------------------------
    
    El ganador de la ronda es  {nom} 

                        
                        
                         ██████╗   ██████╗
                        ██╔════╝  ██╔════╝
                        ██║░░██╗  ██║░░██╗
                        ██║░░╚██╗ ██║░░╚██╗
                        ╚██████╔╝ ╚██████╔╝
                         ╚═════╝   ╚═════╝

    ''')


def home():
    choices = ('piedra', 'papel', 'tijeras')

    write_fx ('''
    
    Bienvenido a piedra, papel o tijeras

    El juego es en partidas, el primero en ganar
    2 partidas gana la ronda.

    [*] Piedra
    [*] Papel
    [*] Tijeras
    
    Escribe cual va a escoger aca --> ''')

    user_cs = input('').lower().replace(' ','')

    comp_cs = random.choice(choices)

    if user_cs not in choices:
        write_fx('\n    Comando no valido')
        time.sleep(1)
        home()

    else:
        play(user_cs, comp_cs, choices)

        write_fx(f'\n\n    Preciona enter para volver a jugar')
        getpass.getpass(' ')
        home()

if __name__ == '__main__':
    home()

Funciones

Una función es un grupo de declaraciones relacionadas que realizan una tarea específica.

Las funciones ayudan a dividir nuestro programa en partes más pequeñas y modulares. A medida que nuestro programa crece más y más, las funciones lo hacen más organizado y manejable.

Además, evita la repetición y hace que el código sea reutilizable.

def function_name(parameters):
	"""docstring"""
	statement(s)

yo practiqué las funciones creando un pequeño algoritmo para convertir fahrenheit a celsius, de esta manera:
def Celsius():
fahrenheit = float(input('what is the Fahrenheit temp? '))
celcius = (fahrenheit - 32) * 5/9
rounded_celcius = (round(celcius, 1))
print(rounded_celcius)

Celsius()

Me encanto haber aprendido las funciones. Me siento un Pythonista más

def my_print(text):
  print(text * 3)

my_print('This is my text ')

def operation(a, b):
  print(a + b)

operation(10,5)
operation(6,9)

👨‍💻 Función = 📦🔨
🔨 Se definen con "def"
📥 Pueden recibir parámetros
📤 Pueden devolver valores
💡 Ayudan a simplificar y organizar el código
👥 Permiten modularidad y reutilización.

Increible clase.
Había tomado antes varios cursos de programación y hasta ahora me quedan claro las funciones.

La función dir(): Nos dice todos los métodos que podemos utilizar dentro de un objeto.`

#ejemplo con una lista

>>> list = ['col', 'mex', 'bol', 'pe']
>>> dir(list)
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> 

Hola!

Les comparto el código de la clase

# Funciones
# https://www.w3schools.com/python/python_functions.asp

print("Hola")

# Definir funcion de impresion
def my_print(text):
  print(text * 2)

# Llamado a la funcion
my_print("This is my text")
my_print("Hola")

# Funcion de suma
a = 10
b = 90
def sum(a, b):
  print(a + b)

sum(a, b)
sum(10, 5)

porque me sale muchismos mensajes de esos ahi mas de los que salen en la imagen, no entendi poruqe se multiplico todas esas veces mas de 50 sale

quedo entendido con este pequeño ejercicio

def suma(a,b):
    print(a+b)

def resta(a,b):
    print(a-b)

def multiplicacion(a,b):
    print(a*b)

def division(a,b):
    print(a/b)

if __name__ == '__main__':
    a = int(input("Escribe un primer numero"))
    b = int(input("Escribe un segundo numero"))
    repetir = 's'
    while repetir =='s' or repetir =='S':

        menu = """ Operaciones basicas
        1.suma
        2.resta
        3.multiplicacion
        4.Division"""

        print(menu)
        opc = (int(input("seleccione una opcion")))

        if opc == 1:
            suma(a,b)
        elif opc ==2:
            resta(a,b);
        elif opc==3:
            multiplicacion(a,b);
        elif opc ==4:
            print("el resultado es :"+str(division(a,b)))
        else:
            print("Opcion no valida")
        repetir = input("escriba s para seleccionar otra operacion")

""" function """
print("The life in the world")

def suma(x, y):
  res = x + y
  print(res)

def multiplicacion(x, y):
  res = x * y
  print(res)

suma(3, 4)
suma(4, 8)
multiplicacion(3, 4)
multiplicacion(4, 8)

Coloquialmente al Parámetro Formal le decimos “parámetro” y al Parámetro Real le decimos “argumento”, peeero…

 
En informática, un parámetro formal es un nombre de variable declarado en la definición de una función para representar el valor que se pasa a la función cuando se llama. Los parámetros formales también se conocen como parámetros de entrada, parámetros de referencia o parámetros de marcador.
 
Un parámetro real es el valor que se pasa a una función cuando se llama. Los parámetros reales también se conocen como parámetros de salida, parámetros de valor o operandos.
 

Relación entre parámetros formales y reales

La relación entre los parámetros formales y reales es la siguiente:
 

• Cuando se llama a una función, los valores de los parámetros reales se asignan a los parámetros formales correspondientes en el cuerpo de la función.
• Los valores asignados se utilizan por la función para realizar sus cálculos o operaciones.
• La función devuelve un valor, que está determinado por los valores de los parámetros reales y los cálculos u operaciones realizados por la función.

Hola compas, les queria comentar que se puede crear una funcion para x cantidad de argumentos, es decir si una ves haces una suma con tres digitos, y luego una con cuatro y va variando, puede usar la siguiente linea de codigo o funcion:
def suma(*args):
print(sum(args))
suma(1,2,6,0)
suma(5,2,8,5,3,9,3)

donde *args es una palabra CREO que reservada para que los argumentos sean variables, es decir x cantidad.

Me sorprende el uso de las funciones de su forma basica y como esta se implementa con el resto de sus ejercicios. Estoy aprendiendo bastante. A continuar.

✅

Que tal, asi le hice yo:

nombre = input("Digite su nombre\n")

def saludo(nombre):
    print('Saludos', nombre)

saludo(nombre)

def sumar(a, b):
    print(a, "+", b, "=",a+b)

primerValor = input("Digite un numero para sumar\n")
segundoValor = input("Digite otro numero para sumar\n")

a = int(primerValor)
b = int(segundoValor)
sumar(a,b)

Las funciones en Python son bloques de código reutilizables que realizan una tarea específica cuando se llaman. Las funciones son una parte fundamental de la programación en Python y te permiten escribir código modular y reutilizable. Aquí hay una descripción general de cómo definir y usar funciones en Python:

Definir una Función

Para definir una función en Python, puedes utilizar la palabra clave def, seguida del nombre de la función y paréntesis que pueden contener los parámetros de la función. A continuación, se encuentra la sintaxis básica de una función:

pythonCopy code
def nombre_de_la_funcion(parametro1, parametro2, ...):
    # Cuerpo de la función
    # Puedes realizar operaciones y cálculos aquí
    return resultado  # Opcional: puedes devolver un valor utilizando la declaración return

• nombre_de_la_funcion: Es el nombre que le das a la función. Debe seguir las convenciones de nombres de variables de Python (generalmente en minúsculas con palabras separadas por guiones bajos).
• parametro1, parametro2, …: Son los parámetros de la función. Son valores que la función acepta como entrada. Puedes tener cero o más parámetros.
• return: Es una declaración opcional que se utiliza para devolver un valor desde la función. Si no se proporciona, la función puede simplemente realizar un cálculo o una tarea y no devolver ningún valor.

Llamar a una Función

Para llamar a una función en Python, simplemente escribe su nombre seguido de paréntesis y proporciona los argumentos necesarios si la función tiene parámetros. Aquí tienes un ejemplo:

pythonCopy code
resultado = nombre_de_la_funcion(argumento1, argumento2, ...)

• nombre_de_la_funcion: Es el nombre de la función que deseas llamar.
• argumento1, argumento2, …: Son los valores que proporcionas como entrada a la función. Deben coincidir en número y orden con los parámetros de la función.

Ejemplo de Función

Aquí hay un ejemplo de una función simple que suma dos números y devuelve el resultado:

pythonCopy code
def suma(a, b):
    resultado = a + b
    return resultado

# Llamamos a la función
resultado_suma = suma(3, 5)
print(resultado_suma)  # Esto imprimirá 8

Este es un ejemplo básico de cómo definir y usar funciones en Python. Las funciones pueden ser mucho más complejas y realizar una variedad de tareas, desde cálculos matemáticos hasta procesamiento de datos y manipulación de archivos. Son una herramienta esencial para organizar y modularizar tu código.

Hola buenas noches 😃
Envio mis apuestes muy detallados :

#funciones: Son líneas de código que se utilizan repetidas veces y para optimizar código.

#salida de string
print('Hola')

#funcion nom_funcion(#parámetro)
def my_print(text):
  #se define el comportamiento de la funcion , imprime 1 vez, 2 veces..
  print(text * 2)  #toma el parámetro del texto y lo multiplca por 2.
  #Si recibe un int los multiplica * 2
  #Si recibe un texto lo duplica
my_print('Esto es una funcion')

#Funcion Suma
#tradicional
a = 10
b = 20

c = a + b
#con función.
#Además podemos utilizar una función dentro de otra
def suma(a, b):
  my_print(a + b)

suma(10, 3)  #13

Cuando dijo que haríamos nuestra propia versión de print, pensé que íbamos a hacer la función desde cero 🤣

def suma( numero, numero2 , numero3):
print (numero + numero2 + numero3)
suma ( 25, 56, 57)

Operaciones básicas en funciones.

import random

#Funcion que recibe dos parametros y calcula las operaciones básicas con esos números.
def my_print(num_a, num_b):
  print("\nNúmeros:", num_a, "y", num_b)
  print("Suma: ", num_a + num_b)
  print("Resta: ", num_a - num_b)
  print("Multiplicacion: ", num_a * num_b)
  print("División: ", num_a / num_b)
  print("\n")

#Declaro los números
num_a = random.randint(1, 50)
num_b = random.randint(1, 50)
my_print(num_a, num_b)

Mi aporte con impresión personalizada

# Definición de la función my_print que recibe un argumento llamado 'text'.
def my_print(text):

  # Estas son líneas de comentarios que no afectan la ejecución del código.
  # print('This is my print')
  # print('This is my print 2')

  # Aquí se imprime una cadena de texto que se forma a través de una f-string.
  # La f-string permite insertar valores dentro de la cadena usando las llaves {}.
  print(f'Multiplicado por dos: {(text + " - ") * 2}'.rstrip(" -"))

# Se llama a la función my_print con el argumento 'Este es mi texto'.
my_print('Este es mi texto')

# Se llama a la función my_print con el argumento 'Hola'.
my_print('Hola')

Ojalá les sirva!
Saludos.

# print es una funcion
print("Hola")

# def definir una funcion

def texto(text):
    print(text)
texto(" este es mi texto ")
texto(" Juan camilo salazar hernandez ")

a= 0
b =0
c= a+b
def operacion(a,b):
    print(a+b)
operacion(1,5)
operacion(10,4)

def my_function(fname, lname):
print(fname + " " + lname)

my_function(“Emil”) en este caso entonces no afecta nada solo imprime un argumento

Yo aquí intentado conectar conceptos de list comprehension y funciones.

![](

Quizas el ejemplo de la práctica que hice este medio Godín, pero aqui va mi ejercicio:

def myprint(mensaje):
  print("Hola este es el mensaje: ", mensaje)

def iva (base):
  impuesto = base * 0.16
  return impuesto
  
importe= float(input("Cual es el monto neto del producto?"))
iva16= iva(importe)
mensaje= "Te tocará pagar un total de " + str(iva16) + " por concepto de IVA"
myprint(mensaje)

Funciones: asiganar un nombre a un conjunto de instrucciones para luego utilizarlas sin la necesidad de re escribir o copiar su código código.

Las funciones en Python son útiles por varias razones:

• Promueven la reutilización de código, ya que puedes definir una función una vez y llamarla múltiples veces en diferentes partes del programa.

• Ayudan a organizar y modularizar el código, dividiendo tareas complejas en bloques más pequeños y manejables.

• Mejoran la legibilidad y mantenibilidad del código, ya que los bloques de código se encapsulan en funciones con nombres descriptivos.

• Permiten la abstracción de la lógica, lo que facilita el entendimiento del código sin preocuparse por los detalles internos de cómo se realiza una tarea.

Super buena la explicación, python hace entender mejor el concepto.

se me ocurrio imprimir los 2 resultados como numeros consecutivos y para esto necesito modificar la funcion suma y transformar la variable en un string, asi quedo

def suma(a, b):
  result = a + b
  print(result)
  my_print(str(result))

Hice una función que me de un par ordenado. Seguro se puede hacer mejor de muchas formas, solo fue lo primero que se me ocurrió:

# primera idea para crear un par ordenado
# python reconoce qué tipo de argumento de le está dando, no se tiene que especificar el tipo como en otros lenguajes

def par_ordenado():
  par = []
  while len(par) < 2:
      try:
        entrada = float(input ("Escribe las cordenadas del punto "))
        par.append(entrada)
      except ValueError:
        print("No me has dado un número ")
  vector = tuple(par)
  print(vector)

par_ordenado()

# crea el par ordenado con una función de dos parámetros a ver como te sale :)

print('Hola')

def my_print(text):
  print(text * 2)

my_print('Este es my texto')
my_print('Hola')

a = 10
b = 48

c = a + b

def suma(a, b):
  my_print(a + b)

suma(3, 48)
suma(3, 51)
  

Como concejo, traten de hacer todos los ejemplos pero háganlos a su manera llenen los textos que ustedes quieran eso te lleva mas allá de transcribir lo que hace el que te enseña y por ende tu mente lo asimila muy diferente, peace que alcancen el sueño.

¿Parámetros o Argumentos?

Los términos parámetro y argumento se pueden usar basicamente para lo mismo: información que se pasa a una función.
Visto desde el criterio de una función: Un parámetro es la variable que aparece entre paréntesis en la definición de la función:

def mi_funcion(nombre, apellido):
  print( nombre + " " + apellido )

Un argumento es el valor que se envía a la función cuando se llama:

mi_funcion("Fernando", "Botero")

creo que cuando se empieza a familiarizar con la terminologia de programacion, como parametros, argumentos o constructores, se debe esplicar como tal.

dos parametros

Excelente concepto, intentaré reescribir el juego de Piedra, Papel o Tijeras con funciones

De tanto intentar, por fin lo logre!

mi código, fallo por no cuadrar bien la identación.

import os


def sum():
    x = float(input('Enter the number for x:\t'))
    y = float(input('Enter the number for y:\t'))
    print(f'Result: {x+y}')
    input('Press enter to continue...')    

def rest():
    x = float(input('Enter the number for x:\t'))
    y = float(input('Enter the number for y:\t'))
    print(f'Result: {x-y}')
    input('Press enter to continue...')
    
def multi():
    x = float(input('Enter the number for x:\t'))
    y = float(input('Enter the number for y:\t'))
    print(f'Result: {x*y}')
    input('Press enter to continue...')
    
def div():
    x = float(input('Enter the number for x:\t'))
    y = float(input('Enter the number for y:\t'))
    print(f'Result: {x/y}')
    input('Press enter to continue...')


def main():
    option = 0
    while True:
        os.system('clear') # linux / mac os
        print('================================================================')
        print('\n1. Sum')
        print('\n2. Rest')
        print('\n3. Multi')
        print('\n4. Div')
        print('\n0. Finish')
        option = input('\nPlease enter your choice...\t')
        
        match option:
            case '1':
                sum()
            case '2':
                rest()
            case '3':
                multi()
            case '4':
                try:
                    div()
                except ZeroDivisionError:
                    print('Zero division failed. Try again...')
                    input('Press enter to continue...')
            case '0':
                pass
            case _:
                print('Invalid option')
                input('Press enter to continue...')             
        
        if option == '0':
            break
        

main()

QUE ES UNA FUNCION EN UN PARRAFÓ

Una función en Python es un bloque de código que realiza una tarea específica y se puede llamar desde otros lugares del código para reutilizar la misma funcionalidad sin tener que escribir el mismo código varias veces.

Podemos documentar lo que hace nuestra función por medio de los docstring de python (ayuda a entender lo que hace la función a personas externas a nuestro código). También podemos especificar el tipo de dato que va recibir nuestra función al ser llamada.
Para poder visualizar la documentación de nuestra función se hace por medio del atributo my_print.doc

def my_print(text: str):
    """
    Simple function to print any kind of text
    :param text: Any kind of str python type
    return: printed text in terminal
    """
    print(text)


any_phrase = "Mi aporte platzi"
print(my_print.__doc__)
my_print(any_phrase)

Hola!!! Les dejo mi codigo espero ayude

'''
Funciones

def namefunct():
  code

funcion(argumento)
'''
# Funcion parahacer una linea de = para dividir en la consola 
def jumpline():
  print('='*25)
# print() es una funcion y de argumento tiene 'hola'
print('Hola')

# Defino mi funcion de prueba
def my_print():
  print('This is my print')
  print('This is a second print()')
my_print()
jumpline()

# Puedo darle parametros a mis funciones
def my_print(text):
  print(text * 2)
my_print('This is my text')
jumpline()

# Cuando le doy un parametro le asigno un lugar a mi codigo para que me lo devuelvan como un armgumento
my_print('Hola este es mi texto ')
jumpline()

# Normalmente para hacer una suma con dos variables tendriamos que escribir todo asi
a = 10
b = 90
c = a + b

# Pero si tengo que usar una suma varias veces uso las funciones
def suma(a, b):
  print(a + b)
  jumpline()
suma(90, 10) # 100 
suma(30, 71) # 101
suma(33, 753) # 786

# Tambien una funcion puede tener otra
def suma(a, b):
  my_print(a + b)
  jumpline()
suma(90, 10) # 200
suma(30, 71) # 202
suma(33, 753) # 1572

Para crear una función en Python, se utilizan los siguientes pasos:

1. Definir el nombre de la función y sus parámetros entre paréntesis.
2. Escribir el código que realizará la función.
3. Utilizar la palabra clave return para devolver un resultado (opcional).

def sumar(a, b):
    resultado = a + b
    return resultado

Algunas de las funciones más comunes incluyen:

1. Funciones de impresión: Estas funciones se utilizan para imprimir mensajes o resultados en la consola print().
2. Funciones matemáticas: Estas funciones se utilizan para realizar operaciones matemáticas. Python proporciona una amplia variedad de funciones matemáticas integradas, como: sum(), abs(), pow(), etc.
3. Funciones de cadenas: Estas funciones se utilizan para manipular cadenas de texto. Algunos ejemplos comunes incluyen len(), upper(), lower(), replace(), etc.
4. Funciones de listas: Estas funciones se utilizan para manipular listas de objetos. Algunos ejemplos comunes incluyen append(), extend(), pop(), sort(), etc.
5. Funciones de archivos: Estas funciones se utilizan para leer o escribir en archivos. Algunos ejemplos comunes incluyen open(), read(), write(), close(), etc.

Modularización del piedra papel o tijera del curso anterior:

import random

def get_bars():
  return '|' * 10

def check_should_play(user_iterations_win, pc_iterations_win, total_iterations):
  max_iterations = 3
  min_wins = 2
  return user_iterations_win < min_wins and pc_iterations_win < min_wins and total_iterations < max_iterations

def print_init_iteration(total_iterations):
  if total_iterations == 0:
    print(f'{get_bars()}\n')

  print(f'Partida {total_iterations + 1}')

def input_user_option():
  return (input('Piedra, papel o tijera?\nElección: ')).lower()

def get_user_option(options):
  user_option = input_user_option()
  while not user_option in options:
    print('Input no correcto')
    user_option = input_user_option()
    
  return user_option

def get_pc_option(options):
  return random.choice(options)

def show_choices(user_option, pc_option):
  print(f'Elegiste {user_option.upper()}')
  print(f'PC elige {pc_option.upper()}')

def play_iterations():
  battle_options = {
    'piedra': {
      'tijera': True,
      'papel': False
    },
    'papel': {
      'tijera': False,
      'piedra': True,
    },
    'tijera': {
      'papel': True,
      'piedra': False
    }
  }
  
  total_iterations = 0
  user_iterations_win = 0
  pc_iterations_win = 0
  
  while check_should_play(user_iterations_win, pc_iterations_win, total_iterations):
    print_init_iteration(total_iterations)
    
    user_option = get_user_option(options)
    pc_option = get_pc_option(options)
    
    show_choices(user_option, pc_option)
  
    if user_option == pc_option:
      print('Empate en esta partida')
    else:
      user_win = battle_options[user_option][pc_option];
      
      if user_win:
        user_iterations_win += 1
        print('Ganaste esta partida')
      else:
        print('Perdiste esta partida')
        pc_iterations_win += 1

    total_iterations += 1
    print(get_bars())

  return {
    'pc_iterations_win': pc_iterations_win,
    'user_iterations_win': user_iterations_win,
    'total_iterations': total_iterations,
  }

def print_result(results):
  print('\nRESULTADO FINAL')
  if results['user_iterations_win'] > results['pc_iterations_win']:
    print('Ganaste! :D')
  elif results['pc_iterations_win'] > results['user_iterations_win']:
    print('Perdiste :(')
  else:
    print('Empate')

def print_resume(results):
  print('\nGanaste ' + str(results['user_iterations_win']))
  print('Perdiste ' + str(results['pc_iterations_win']))
  print('Empataste ' + str(results['total_iterations'] -results['user_iterations_win'] - results['pc_iterations_win']))

options = ('piedra', 'papel', 'tijera')

results = play_iterations()

print_result(results)
print_resume(results)

Recomendaciones? Cosas que podría mejorar? Espero que sirva.

Calc básica con pyCharm

Aquí les presento mi versión de una calculadora básica, en la que tiene como entrada dos números y un operador, y te imprime el resultado de la operación:

Función para validar si un número es múltiplo de otro

def multiplo(a, b):
    mensaje = 'es múltiplo'
    """Comprueba si un numero es multiplo de otro

    Args:
        a (int): numero base
        b (int): numero multiplo

    Returns:
        str: Si es True; retorna un mensaje, sino un False
    """
    if a % b == 0:
        return f'{a} {mensaje} de {b}'  
    else: 
        False

ejemplo = multiplo(12, 6)
print(ejemplo)

Una aproximación de cómo puede ser print original de Python

import sys

def my_print(txt):
    txt = str(txt)
    sys.stdout.write(txt)
    sys.stdout.write('\n')

my_print(f'Hello, this is my own print function!')
>>>Hello, this is my own print function!

my_print(24+5)
>>>29

El video se pausa y se pega varias veces, no corre fluido, a pesar de que tengo una muy buena conexión a internet, esto pasa con todos los navegadores.

#funciones. un ejemplo de funcion es la funcion print que recibe un parametro, es este caso la cadena que va a imprimir
print ( " " * 20)
print (“VERSION 1: Esto es un texto pasado por parametro”)
print ( " " * 20)

#defino una funcion que haga lo mismo que la funcion ya nativa print
cadena = input ("VERSION 2: ingrese una cadena a imprimir -> ")
def imprimir (cadena):
print ( " " * 20)
print (cadena)
print ( " " * 20)

imprimir(cadena)

Mi aporte:

def parity(a):
  if a % 2 == 0:
    print(a," is even")
  else:
    print(a," is odd")

parity(5)
parity(4)

Los resultados son:
5 is odd
4 is even

print('Hola')

def my_print(text):
  print(text * 2)
  
my_print('Este es my texto ')
my_print('Hola ')

a = 10
b = 90

c = a +b

def suma(a, b):
  my_print(a + b)

suma(1, 5) # 6
suma(10, 4) # 14

para nosotros los nuevos, nos enreda qwue coloque todo en ingles, si es bueno p’orqwue asi deberia de ser, pero para un nuevo eso confunde muchisiimo

no pude hacer que los datos que pedía se trasladaran de función en función pero dejo esto XD

a=0
b=0
def programa(a,b):
print(‘Bienvenido al calculador de operaciones basicas’)
a=int(input(“Ingresa el primer numero entero:”))
b=int(input(“Ingresa el segundo numero entero:”))
return(a,b)
def multiplicaion(a,b):
print(“La multipicacion de los numeros ingresados es:”,a*b)
def division(a,b):
print(“La division de los numeros ingresados es:”,a/b)
def potencia(a,b):
print(“la potencia es:”,a**b)

programa(5,3)
multiplicaion(5,3)
division(5,3)
potencia(5,3)

Hice una fucion con una calculadora de dos dijitos

#Funciones 

def my_Print(texto):

  print(texto)

my_Print('hola funciones')


def suma(num1, num2):
  print ('suma: ')
  print(num1 + num2)

def resta(num1, num2):
  print ('resta: ')
  print(num1 - num2)

def multipli(num1,num2):
  print ('multiplicacion: ')
  print(num1 * num2)

def divi(num1, num2):
  print ('division: ')
  print(num1/num2)



def calculadora2Numeros(num1, num2, opc):
  if opc == 1 :
    suma(num1, num2)
  elif opc == 2 :
    resta(num1, num2)
  elif opc == 3 :
    multipli(num1, num2)
  elif opc == 4 :
    divi(num1, num2)

calculadora2Numeros(15,3,1)
calculadora2Numeros(15,3,2)
calculadora2Numeros(15,3,3)
calculadora2Numeros(15,3,4)

Este es el resultado
suma:
18
resta:
12
multiplicacion:
45
division:
5.0

Funciones

#----------------Funciones--------------------

#funcion de impresion
def my_print():
  print('This is my print')

my_print()
--> This is my print

#funcion de impresion con parametros
def my_print2(text):
  print(text * 2)

my_print2('hola mundo')
--> hola mundohola mundo

#funcion suma. Varios parametros
def suma(a, b):
  print(a + b)

suma(15,10) 
--> 25

#funcion dentro de otra funcion
def suma2(a, b):
  my_print2(a + b)

suma2(4, 5)
--> 18

otras funciones
que veras en el camino del aprendizaje

Funciones Built-in

A
abs()
aiter()
all()
any()
anext()
ascii()

B
bin()
bool()
breakpoint()
bytearray()
bytes()

C
callable()
chr()
classmethod()
compile()
complex()

D
delattr()
dict()
dir()
divmod()

E
enumerate()
eval()
exec()

F
filter()
float()
format()
frozenset()

G
getattr()
globals()

H
hasattr()
hash()
help()
hex()

I
id()
input()
int()
isinstance()
issubclass()
iter()
L
len()
list()
locals()

M
map()
max()
memoryview()
min()

N
next()

O
object()
oct()
open()
ord()

P
pow()
print()
property()




R
range()
repr()
reversed()
round()

S
set()
setattr()
slice()
sorted()
staticmethod()
str()
sum()
super()

T
tuple()
type()

V
vars()

Z
zip()

_
__import__()

Pequeño aporte :3

def multiplicacion(a,b):
    print(f"{a} * {b} = {a * b}")
multiplicacion(5,2);

print('Hola')

def my_print(text):
  print(text * 2)
  print('This is my print 2')

my_print('Este es mi texto ')
my_print('Hola ')

a = 10
b = 90
c = a + b

def suma(a,b):
  print(a+b)
  my_print(a+b)

suma(70,46) # 116
suma(1,5) # 6
suma(10 ,4) # 14

No sé por qué en la función ‘my_print’ pensé en decoradores hahahah