Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso Básico de Python

Curso Básico de Python

Facundo García Martoni

Facundo García Martoni

Proyecto: palíndromo

20/32
Recursos

En este ejemplo, aprenderemos a detectar si una palabra es palíndromo en Python. Para el ejemplo utilizaremos “Luz azul”.

Vamos a definir la función utilizando def:

def esPalindromo(palabra):
	palabra = str(palabra).strip().lower()
	palabra and print(palabra == palabra[::-1])
esPalindromo(luzazul) # va a imprimir True.

¿Qué acaba de ocurrir?

En la primera línea de la función, convertimos el valor recibido a string, eliminamos los espacios indeseados aplicando strip y formateamos a minúscula con lower.

¿Por qué? Porque si ejecutamos esPalindromo(True) nuestro programa mostraría un error, ya que no se pueden ejecutar métodos strip y lower sobre datos de tipo booleano.

En la segunda línea, ejecutando palabra and, lo que le decimos al programa es que si la variable palabra es Truty, ejecute el código después del and.

Esta es una forma mucho más corta de correr el siguiente código:

if palabra == True:
	ejecutar.....

Pero, ¿qué es un valor truty?

En programación, un valor truty es cualquier valor que, sin ser explícitamente un booleano True, la computadora lo interpreta como un true. Por ejemplo: cualquier número mayor a 0 o cualquier string que no este vacío.

Luego, dentro del print() no es necesario hacer un if que retorne true o false, al hacer la comparación.

# if palabra == palabra[::-1]:
#	return True
# else:
#	return False

palabra == palabra[::-1]

Si la comparación es correcta, va a imprimir True, de lo contrario devolvera False.

Aporte creado por: Alejandro Barrios

Aportes 663

Preguntas 156

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Soy muy fanático de simplificar las cosas, espero pueda ser legible.

def es_palindromo(palabra):
    palabra = palabra.replace(' ', '').lower()
    
    if palabra[::] == palabra[::-1]:
        return True
    
    else:
        return False


def run():
    palabra = input('Ingrese una palabra: ')
    if es_palindromo(palabra):
        print('Es palindromo')

    else:
        print('No es palindromo')


if __name__ == "__main__":
    run()

Aquí unos Palindromos, por si quieren poner en practica:
“Oí lo de mamá: me dolió”

“Sometamos o matemos”

“Yo dono rosas, oro no doy”

“Isaac no ronca así”

“Lavan esa base naval”

“No traces en ese cartón”

“¿Será lodo o dólares?”

“Logra Casillas allí sacar gol”

😄

Me quedé con la duda de por que se utiliza esto: if name == “main”:
Encontré que Python asigna variables especiales antes de correr el código. A la variable name le asigna el string “main”. Esto pasa siempre que corras el programa directamente de Python. Si tienes esta condicional en tu programa y decides importarlo desde un programa distinto, NO va a correr, por que al importarlo, ya no está corriendo directo desde el programa original. Hice mi mejor esfuerzo por explicarlo, pero si no me entendiste, Aquí está el video explicando.

Buenas prácticas
[Dejar dos espacios (líneas de código) entre las funciones]
[Crear una función principal]

Esta línea de código:
if __name__ == "__main__": main() //es el punto de entrada de un programa de Python. Una vez que se encuentra Python con esta línea de código, empieza a ejecutar todo lo qué esté abajo, cómo en este ejemplo, la función "main".

Muchachos no se si las pasa, pero yo tome el anterior curso básico de python, pero me perdi mucho. Nunca entendí porque poniamos la linea if name==‘main’:
run()
Lo terminé dejando a la mitad.
Ahora me siento mas tranquilo voy entendiendo las cosas y me emociona ir avanzando. Tal vez es solo imprensión mia pero siento a este curso mejor 😃

Si usan VSCode y dan clic derecho en el código y luego en Format Document aparecerá una ventana para instalar autopep8 que sirve para formatear el código y que cumpla los estándares. Le dan a yes y se instalará. Una vez instalado dan clic derecho y Format Document y el código se acomoda.

algunos creen que mientras mas pequeño es su archivo .py , o mejor dicho; mientras menos líneas de código tiene un programa, se es mas eficiente o mejor programador. Si uno llega a trabajar en un lugar con otros programadores que deban revisar su código, sencillamente les va a llover muchas críticas , ojo con eso!

La movie TENET aborda el tema de los palíndromos de manera implícita y extiende su trama más allá de los límites de la física

Me parece una excelente clase, tomar todo lo aprendido y plasmarlo en este pequeño proyecto, para alguien que esta aprendiendo con facundo, es muy importante ver toda esta estructura clásica de la programación.
No me parece un buen inicio comenzar un curso básico de Python y empezar a resumir código y simplificar la estructura del profesor, si lo que se busca es plasmar todo lo aprendido de forma amigable y didáctica para tener buenas bases en el futuro, ahora si ya sabes todo esto y puedes hacerlo en una línea…“creo que tomaste el nivel de curso equivocado”.
Me pregunto… Qué pasa sí el profesor viene y explica en dos líneas esta clase? seguramente pensamos que el profesor no explica bien, que es un pirata y ese curso de Python no sirve.!
Que complejo somos Gente…!

Un truco para evitar los if excesivos y hacer tu codigo mucho mas corto

def esPalindromo(palabra):
	palabra = str(palabra).strip().lower()
	palabra and print(palabra == palabra[::-1])

esPalindromo(luzazul) # va a imprimir True.

Que hice???
En la primera linea de la funcion convertimos el valor recibido a string, eliminamos los espacios indeseados y formateamos a minuscula.
.
por que? porque si ejecutamos esPalindromo(True) nuestro programa daria error ya que no se pueden ejecutar metodos strip y lower sobre datos de tipo booleano.
.
En la segunda linea ejecutando palabra and lo que le decimos al programa es que si la variable palabra es Truty, ejecute el codigo despues del and.
es una forma mucho mas corta de hacer

if palabra == True:
	ejecutar.....

pero y que es un valor truty?
.
En la programacion, un valor truty es cualquier valor que sin ser explicitamente un booleano True, la computadora lo interpreta como un true. por ejemplo: cualquier numero mayor a 0 o cualquier string que no este vacio.
.
luego, dentro del print() NO es necesario hacer un if que retorne true o false, al hacer la comparacion

# if palabra == palabra[::-1]:
#	return True
# else:
#	return False

palabra == palabra[::-1]

si la comparacion es correcta, va a imprimir True, de lo contrario devolvera False, y ademas, queda mucho mas lindo 😉
.
esto podemos es solo un ejemplo, y pueden adaptarlo para que haga return en vez de imprimir por consola, espero les sirva.

Varias personas han preguntado (incluyéndome):

El tema de colores que Facundo está usando en Visual Studio code, según yo, es :
Atom One Dark y la extensión Bracket Pair Colorizer 2 (links abajo)

https://marketplace.visualstudio.com/items?itemName=akamud.vscode-theme-onedark

https://marketplace.visualstudio.com/items?itemName=CoenraadS.bracket-pair-colorizer-2

Dejo mi aporte con el código comentado

https://alvarohurtado.es/2020/11/16/que-hace-if-name-main-en-python/

Para los que al igual que yo se enreden un poco con el:

if __name__ == '__main__':

no me funcionaba mi código pero me di cuenta que la palabra “True” y “False” van con letra mayúscula al inicio y eso era mi error no lo tenia en cuenta pero espero ayude a alguien mas también si tiene el mismo problema 😃

name=input("Ingresa una palabra o frase: ")
name=name.strip().lower().replace(" ","")
print(name)
name_backward=(name[::-1])
print(name_backward)
if name==name_backward:
    print("Felicidades, esto es un palíndromo")
else:
    print("Esta vez no lograste encontrar un palíndromo, sigue intentando!")
if __name == "__main__":
run()

Esta condicional se encarga, de ejecutar las funciones principales, como podemos ver en este caso tenemos dos funciones.

1.- palindromo(): Esta funcion es una funcion que se encarga de transformar los caracteres de linea de texto, entonces quiere decir que pasaria a categorizarse como una funcion alternativa
2.- run(): Esta es la funcion es la que se encarga de obtener los datos de la funcion palindromo y trabajar con ello mas los datos ingresados por el usuario, por ende esta pasaria a ser la funcion principal, y como funcion principal es la que debe ir dentro del condicional if __name == “main”:


IMPORTANTE Como dice el profesor siempre es buena buena practica no solamente para Python, tener claro una jerarquia entre las clases para tener clara su funcion ademas hace el codigo mas elegante y legible para ti y otras personas.

Estuve investigando sobre el operador ternario en Python, y encontré que se usa así.

True if expresion == expresion else False

Se interpreta como, haz esto si se cumple esta condición, si no haz esto.

def palindromo(palabra):
    palabra = palabra.replace(' ', '').lower()
    return True if palabra == palabra[::-1] else False

def run():
    palabra = input('Escribe una palabra: ')
    if palindromo(palabra) == True:
        print('Es palíndromo')
    else:
        print('No es palíndromo')


if __name__ == '__main__':
    run()

¿Porque en mi editor no se colocan los comandos, palabras, signos, en colores? algunos sí, otros no.
Como le puedo hacer para que se pongan en color igual sino siento que voy mal jajaja,

Aqui mi aporte con analisis semantico y esp (entrada, proceso y salida)

# OBJETIVO
# Crear un programa que identifique si una cadena de texto es palindroma o no 
# ej. luz azul = luzazul --> es palindroma

# ANALISIS SEMANTICO 
# cadena de texto --> conocida en ingles como string estas son caracteres simbolicos compuestos por letras o signos
# palindromo --> que se lee igual de derecha a izquierda y vice versa

# ANALISIS EPS
# E --> strings

# P --> a) leer string
#       b) eliminar todos los espacio innecesarios
#       c) cambiar letras a minuscula
#       d) cambiar orden de lectura (derecha a izquierda)
#       e) si cambi = palabra: 
#          return true (O es palintromo)
#          si no: 
#          return false (O no es palindromo) 

# S --> comparar 

# funcion que corre el programa, realiza paso a
def run():
    palabra = input("Ingrese un string: ")
    cambiar(palabra)


# funcion para realizar paso b, c, d
def cambiar(palabra):
    palabra = palabra.replace(" ", '').lower() # b y c
    cambio_orden = palabra[::-1] # d
    comparar(palabra, cambio_orden)


# funcion para realizar paso e
def comparar(palabra, cambio_orden):
    if palabra == cambio_orden:
        print(palabra + " es un palindromo")
    else:
        print(palabra + " no es palindromo")

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

Os dejo mis apuntes sobre buenas prácticas.

Código de buenas practicas:

  1. Crear una función principal la llamaremos “Main o Run

  2. Crear el punto de entrada o “entry point
    If__name__== ’main’:
    Pass
    3.Dejar dos espacios (verticales) entre funciones y también con el entry point
    4.Si se invoca una función a mitad del script se tiene que declarar antes de que se invoque.

Es valido utilizar un código más simple que arroje el mismo resultado?

Para los que no entiendan lo de name==“main”: tratare de explicarlo con lo que encontré en internet.
La variable name toma el valor de main cuando lo ejecutas como principal, y toma el valor de module si lo están importando, osea lo están invocando en otro script o código.
Este condicional se usa para comprobar si un módulo de python está siendo ejecutado directamente o está siendo importado, ya que puede ser que algún script lo quieras utilizar como principal pero que no se ejecute cuando este sea importado.

Voy a compartirles algo que me paso durante esta clase.
Si por alguna razón el programa no les inicia, o inicia pero no pregunta la palabra la razon es muy simple, en la parte de :

if name == " main" :

Los guiones bajo deben ser dobles, en el vídeo no se alcanza a ver con claridad así que es normal la confusión xd

A un amigo le pusieron a hacer este proyecto en un examen de la universidad 😮
Facundo lo hizo en 10 minutos, además con explicación muy buena. Crack!!!

👾 Determina si una palabra o texto es un palíndromo.

def palindromo(palabra):
    palabra = palabra.replace(" ", "")
    palabra = palabra.upper()
    palabra_invertida = palabra[::-1]
    if palabra == palabra_invertida:
        return True
    else:
        return False


def run():
    palabra = input("Ingresa una palabra: ")
    es_palindromo = palindromo(palabra)
    if es_palindromo == True:
        print("Es palíndromo")
    else:
        print("No es palíndromo")


if __name__ == "__main__":
    run()

Me da que Luz azul no es palindromo y no encuentro el error

def palindromo(palabra):
    palabra = palabra.replace(" ", " ")
    palabra = palabra.lower()
    palabra_invertida = palabra[::-1]
    if palabra == palabra_invertida:
        return True
    else:
        return False


def run(): 
    palabra = input ("Escribe una palabra: ")
    es_palindromo = palindromo(palabra)
    if es_palindromo == True:
        print("Es palindromo")
    else:
        print ("No es palindromo")

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

My code:

def is_palindrome(word):
    clean_word = word.lower().replace(" ", "")
    return clean_word == clean_word[::-1]


def run():
    word = input("Write a word: ")
    if is_palindrome(word):
        print("Is palindrome")
    else:
        print("Is not palindrome")


if __name__ == '__main__':
    run()

def palindromo(palabra):
palabra = palabra.replace(" “,”")
palabra = palabra.lower()
palabra_invertida = palabra[::-1]
if palabra == palabra_invertida:
return True
else:
return False

def run():
palabra = input("Escribe una palabra: ")
es_palindromo = palindromo(palabra)
if es_palindromo == True:
print(‘Es palindromo’)
else:
print(‘No es palindromo’)

if name == “main”: #Esta linea simepre se escribe al iniciar codigo en pyhon
run()

palabra = input("ingresa la palabra : ")
palabra = palabra.lower()
palabra = palabra.replace(" ", "")

if palabra == palabra[::-1]:
    print("es palindromo")
else:
    print("NO es palindromo")

Simpliflique un poco los metodos y puse directamente la condicional de palabra

def palindromo(palabra):
    palabra = palabra.replace(' ', '').lower()
    if palabra == palabra[::-1]:
        return True
    else:
        return False


def run():
    palabra = input('Escribe una palabra: ')
    es_palindromo = palindromo(palabra)
    if es_palindromo == True:
        print('Es palíndromo')
    else:
        print('No es palíndromo')


if __name__ == '__main__':
    run()

Al principio me daba error porque puse.

if name = (un igual ) “main” :

jajaja y aparte, si dice “igual” min 3:23.
mi error de principiante

creo que no puede ser mas simple 😛

palabra = input("di una palabra: ")

if palabra == palabra[::-1]:
    print("es un palindromo")

else:
    print("no es un palindromo")``````
frase = input("ingrese una palabra o frase: ") 
sin_espacios = frase.replace(' ','').lower()
al_reves = sin_espacios[::-1]

if sin_espacios == al_reves:
    print("la frase: '", frase, "' es un palindromo" )
else:
    print("la frase: '", frase , "' no es palindromo")```

Si a alguien le sirve, he encontrado el tema más parecido que utiliza el profesor en su VS Code, búsquenlo en extensiones como: Sublime Material Theme. A mi me parece mucho mejor este theme que el que viene por default en VS Code.

Hola,

No me queda tan claro para que sirve el if name == ‘main’:
Alguien me podría explicar por favor?

Gracias!

Les comparto mi código por si a alguien le sirve, añadi una función adicional que usa un diccionario para eliminar acentos en las vocales y otros signos de puntuación para evitar “falsos negativos”

words = { ' ': '', 'á': 'a', 'é': 'e', 'í': 'i', 'ó': 'o', 'ú': 'u', '¿': '?', '¡': '!', ',': '', '.': '', ':': '', ';': '' }


def replace_group (text, words):
    for i, j in words.items():
        text = text.replace(i, j)
    return text

Usa un ciclo for para buscar coincidencias del diccionario y en el caso de encontrarlas reemplazarla o eliminarla segun sea el caso.


def palindromo(frase):
    frase_inversa = frase[::-1]

    if frase == frase_inversa:
        return True
    else:
        return False


def run():
    frase = input('Ingresa la frase para saber si es un palindromo: ').lower().strip()

    frase = replace_group(frase, words)

    if palindromo(frase) == True:
        print('Es un palindromo')
    else:
        print('No es un palindromo')


if __name__ == '__main__':
    run()

✌ Hola. Versión simplificada sin usar “True” o “False”:

def palindromo_creator():
    palabra_ingresada = input("Escriba una palabra: ").lower().replace(" ","")
    if palabra_ingresada == palabra_ingresada[::-1]:
        print("Es palíndromo")
    else:
        print("No es palíndromo")

if __name__ == "__main__":
    palindromo_creator() 
def palindrome(string):
        if string == string[::-1]:
           return ("Felicidades! tu palabra es un palindromo")
        else:
            return ("Tu palabra no es un palindromo")


print("""
Hola! Quieres saber si una palabra es un palindromo o no?
""")

respuesta = input("Elige SI o NO: ")
respuesta = respuesta.lower()

if respuesta == "si":
     print(palindrome(input("Elige una palabra: ")))

elif respuesta == "no":
    print("Que malo eres :(")

else:
    print("Elige una opcion valida")

Analice el uso del operador ternario o primitivo en Python y me ayudo mucho para poder realizar mi código a un “estilo declarativo” y no tener que utilizar una sola variable.

El cual dice:
[haz esto…] SI [la operación da verdadero] DE LO CONTRARIO [haz esto…]

True if expresion == expresion else False

Dejo mi aporte de como quedo mi código por si alguien gusta implementarlo y/o analizarlo 😃

def palindromo(palabra):
    return 'Es palindromo' if palabra.replace(' ','').lower() == palabra[::-1].replace(' ','').lower() else 'No es palindromo'
    

def main():
    print(palindromo(input('Escribe una palabra: ')))


if __name__ == '__main__':
    main()

Hola hola,
Aquí esta mi código:

def palindrome(string):
    string = string.lower().replace(' ', '')
    return string == string[::-1]

def main():
    is_palindrome = palindrome(input('Your string: '))

    print("Yep it's palindrome" if is_palindrome else "No it's not palindrome")

if __name__ == '__main__':
    main()
<def palindromo(palabra):
        palabra = palabra.replace(" ", "")
        palabra = palabra.lower()
        dato = palabra == palabra[::-1]
        return dato   

def run():
    palabra = input("escribe una palabra: ")
    es_palindromo = palindromo(palabra)
    if es_palindromo == True:
        print("Es Palindromo")
    else:
        print("No es palindromo")
if __name__ == "__main__":
    run()> 

Actividad Palindromo

def palindromo(palabra):
palabra = palabra.replace(’ ', ‘’)
palabra = palabra.lower()
palabra_invertida = palabra[::-1]
if palabra == palabra_invertida:
return True
else:
return False

def run():
palabra = input(‘EScribre Una Palabra :’)
es_palindromo = palindromo(palabra)
if es_palindromo == True:
print(‘Es Palindromo…!’)
else:
print('No es Palindromo 😦 ')

if name == ‘main’:
run()

Creo que quedo contento con el resultado. Aunque tuve que patinar un ratico para acomodar todo antes de ver el capitulo jeje

def es_palindromo(palabra):
        palabra = palabra.upper()
        palabra = palabra.replace(' ','')
        palabra_reves = palabra[::-1]

        if palabra == palabra_reves:
                return True
        else:
                return False


def run():
        palabra = str(input("Hola, por favor escriba una palabra para verificar si es un palindromo: "))
        verificacion = es_palindromo(palabra)
        largo = str(len(palabra.replace(' ','')))

        if verificacion == True:
                print(palabra + " es un palindromo y tiene " + largo + " caracteres")
        else:
                print(palabra + " no es un palindromo, por favor intenta con otra palabra.")


if __name__ == '__main__':
        run()

Un saludo 😉

Palíndromo

def run():
    texto = input('Escribe un/a palabra/frase:')
    texto = texto.replace(' ', '')
    texto = texto.upper()
    texto_invertido = texto[::-1]
    if texto == texto_invertido:
        print('Es palindromo')
    else:
        print('No es palindromo')


if __name__ == '__main__':
    run()

Palíndromo simplificado

def run():
    texto = input('Escribe un/a palabra/frase:').replace(' ', '').upper()
    if texto == texto[::-1]:
        print('Es palindromo')
    else:
        print('No es palindromo')


if __name__ == '__main__':
    run()

Palíndromo con función extra

def palindromo(texto):
        texto = texto.replace('  ', ' ').upper()
        texto_invertido = texto[::-1]
        return True

def run():
    texto = input('Escribe un/a palabra/frase:')     
    if palindromo(texto):
        print('Es palindromo')
    else:
        print('No es palindromo') 


if __name__ == '__main__':
    run()
def palindromo(palabra):
    palabra = palabra.replace(' ','').lower()
    return palabra == palabra[::-1]


def run():
    palabra = input("Escribe una palabra: ")
    if palindromo(palabra):
        print("Es palindromo")
    else:
        print("No es palindromo")


if __name__ == '__main__':
    run()
palabra = input('Escibe una palabra : ')
palabra = palabra.lower().replace(' ','')

if palabra == palabra[::-1] :
    print('Es palindromo')
else :
    print ('No es palindromo')

Me quedo así.


def palindrome(word: str):
    word = word.replace(" ", "").lower()
    return word == word[::-1]


def main():
    if palindrome(input("word:")):
        print("is palindromo")
    else:
        print("isnt palindromo")


if __name__ == "__main__":
    main()

Pequeño aporte

def palindromo(palabra):
    if palabra == palabra[::-1]:
        return "Es una palindromo"
    else:
        return "No es un palindromo"

print("Bienvenido al detectos de palindromos, si deseeas detener el programa escribe fin")

while True:
    palabra = input("Por favor ingresa una palabra: ")
    if palabra == "fin":
        break
    else:
        print(palindromo(palabra.lower().replace(' ', '')))

Comparto mi código.

me codigo es el siguiente:
creen que cometí alguna mala practica?
hice asi por que pensé que no era necesario una funcion en este caso.

Un código eficiente es aquel que cae entre optimo y legible

Buena practica: dejar doble espacio entre funciones

Hola, vengo de futuro (de algunas clases más adelante), existe una forma de escribir (en VSCode) la estructura del programa principal, es decir:

def run()
	pass

if __name__ == '__main__':
	run()

¡Con una sola palabra!
.
Para ello debes ir a Archivo->Preferencias->Snippets de Usuario (File->Preferencias->User Snippets), luego te aparece una barra superior con muchos lenguajes de programación, busca el que diga ‘Python’ y dale click.
.
Una vez ahí te debe aparecer algo como esto:

{
	// Place your snippets for python here. Each snippet is defined under a snippet name and has a prefix, body and 
	// description. The prefix is what is used to trigger the snippet and the body will be expanded and inserted. Possible variables are:
	// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. Placeholders with the 
	// same ids are connected.
	// Example:
	// "Print to console": {
	// 	"prefix": "log",
	// 	"body": [
	// 		"console.log('$1');",
	// 		"$2"
	// 	],
	// 	"description": "Log output to console"
	// }
}

¡No te asustes! Aquí podrás configurar atajos de palabras para crear funciones o estructuras en Python, solo copia y pega el siguiente código del cual me basé:

"Creates main Python structure": {
        "prefix": "pymain",
        "body": [
            "def run():",
            "\tpass$0\n\n",
            "if __name__ == '__main__':",
            "\trun()"
        ]
    }

De esta manera, el archivo ‘Python.json’ debe aparecer así:

{
	// Place your snippets for python here. Each snippet is defined under a snippet name and has a prefix, body and 
	// description. The prefix is what is used to trigger the snippet and the body will be expanded and inserted. Possible variables are:
	// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. Placeholders with the 
	// same ids are connected.
	// Example:
	// "Print to console": {
	// 	"prefix": "log",
	// 	"body": [
	// 		"console.log('$1');",
	// 		"$2"
	// 	],
	// 	"description": "Log output to console"
	// }

	"Creates main Python structure": {
        "prefix": "pymain",
        "body": [
            "def run():",
            "\tpass$0\n\n",
            "if __name__ == '__main__':",
            "\trun()"
        ]
    }
}

¡Listo! Ahora cada vez que escribas ‘pymain’ en cualquier archivo de Python te debe aparecer la opción para crear la estructura, solo debes presionar la tecla Tab o Enter y ya te debe escribir la estructura.

Ya se empieza a poner bueno XD
Por cierto ¿para qué están estudiando Python?😄

Fun fact: “Arepera” es palindromo xd

Código simplificado:

def palindrome(word):
    word = word.replace(' ', '').lower()
    print("It's Palindrome") if word == word[::-1] else print("Isn't Palindrome")


def run():
    palindrome(input('Write a word: '))


if __name__ == '__main__':
    run()

Mi código simplificado un poco para que elimine espacios vacíos, elimine comas y pase todo el texto a minúsculas (para que la comprobación no sea “CaseSentive

def palindromo(palabra):
    palabra = palabra.replace(" ","").replace(",","").lower()
    if(palabra[::-1] == palabra):
        print("SÍ es palíndromo")
        return
    print("NO es palíndromo")


def run():
    palabra = input("Ingres su palabra")
    palindromo(palabra)


if __name__ == "__main__":
    run()

Intento previo antes de ver la resolución del maestro García:
(serían ocho líneas pero en los comentarios pude observar que se pueden juntar los métodos en la misma variable 😄)

1 palabra = (input(welcome)).replace(’ ‘,’’)
2 palabra2 = palabra.replace(’ ‘,’’)
3 palabra2 = palabra2[::-1]
4 if palabra == palabra2:
5 print(‘Tu palabra es un palíndromo 😄.’)
6 else:
7 print(‘Nop, no es un palíndromo.’)

Éxitos!

Para las personas que no les quedo claro el funcionamiento de if name == ‘main’, aqui les dejo una buena explicacion: https://stackoverflow.com/questions/419163/what-does-if-name-main-do.

El **entry point **

<'__name__'== '__main__':> 

es muy importante en python, la razón es que en python podemos ejecutar nuestros archivos como un script o como un modulo que se importa:

1. Script: Cuando se ejecuta como un script se ejecuta todo el código que hemos elaborado, en el caso del ejemplo sería todo el código del archivo de palindromo.

2. Modulo: Cuando se ejecuta un archivo de código como modulo, lo que estamos haciendo es importar las funciones y los objetos definidos en nuestro archivo para usar solo los que necesitemos.

Para que python identifique esta distinción, que es muy importante para todos los que programamos en python, es muy importante definir este entry point.

Espero les guste de esta manera

frase = input("Ingresa la frase palíndroma: ")

def run():
    frase_modificada = frase.replace(" ","").upper()
    if frase_modificada == frase_modificada[::-1]:
        palindromo("sí")
    else :
        palindromo("no")

def palindromo(cambio):
    print("La frase: ("+frase+") "+cambio+" es palíndromo")

if __name__ == "__main__":
    run()

def main():
palabra = input('Inserte la palabra: ')

def palindromo(texto):
    texto = texto.replace(' ','')
    texto_slice = texto[::-1]
    if (texto == texto_slice):
        print(f'La palabra o frase {palabra} es un palíndromo...')
    else:
        print(f'La palabra o frase {palabra} no es un palíndromo...')

palindromo(palabra)

if name == ‘main’:
main()

Por norma se tienen que dejar dos espacios cada que se crea una funcion nueva

puntualmente no sabía cómo se denotaba el entry point, hasta hoy me vine a enterar, todos los días sr aprende algo nuevo 😃

"Anita lava la tina"
Besto palindromo.

Mi código acortando sin usar booleanos

![](

Logre comprimir el código hasta 5 líneas!

palabra = input('Elige una palabra: ').replace(' ', '').upper()
if palabra == palabra[::-1]:
    print('Esa palabra es un palindromo')
else:
    print('Esa palabra no es un palindromo')

Este video es muy bueno para entender el concepto de entry point o punto de entrada (“estudien el curso de ingles” diria fredy 😂)
https://www.youtube.com/watch?v=_u-3pwdbHeg

Versión más simplificada

def palindromo(palabra):
    palabra = palabra.replace(' ', '').lower()
    return palabra[::-1] == palabra

def run():
    palabra = input("Escribe una palabra: ")
    if palindromo(palabra):
        print("Es palindromo")
    else:
        print("No es palindromo")

if __name__ == '__main__':
    run()

Actividad:

El palíndromo

Mi versión, espero que también les ayude.

def palindromo(cadena):
    es_palindromo = 0
    cadena = cadena.lower().replace(' ','') 
    if cadena == cadena[::-1]:
        es_palindromo = 1
    return es_palindromo

inicio = """
Benvenido

Vamos a averiguar si tu cadena es un palíndromo.

Favor de ingresar una cadena: 
"""

cadena = input(inicio)

if palindromo(cadena):
    print('Tu cadena \'' + cadena + '\' sí es un palíndromo')
else:
    print('Tu cadena \''+ cadena+'\' no es un palíndromo')
def es_palindromo(phrase):
    phrase = phrase.lower().replace(' ','');
    return phrase == phrase[::-1]

print( es_palindromo("Luz azul") )
 

entry point = punto de entrada a nuestro programa:
if name == ‘main’:

La palabra palíndromo es de hecho de origen griego y viene de la construcción “palin dromein”, es decir, volver atrás, recorrer a la inversa, porque se trata precisamente de eso, de palabras o frases simétricas que se pueden transitar en ambos sentidos.

Aquí mi código:

entrada = input("Escriba la frase: ")
entrada = entrada.replace(" ", "")
palindromo = entrada[::-1]
if entrada == palindromo:
    print("La entrada es un palindromo")
else:
    print("la entrada no es palindromo")

aquí mi humilde código

def limpiar_palabra(palabra):
      return palabra.lower().replace(" ","").replace(":","").strip()

def es_palindromo(palabra):
      palabra = limpiar_palabra(palabra)
      if palabra == palabra[::-1]:
            return True
      else:
            return False

def main():
      palabra = input("ingrese una palabra: ")
      if es_palindromo(palabra):
            print("es un palindromo")
      else:
            print("no es un plindromo")


if __name__ == "__main__":
      main()

Concepto
La palabra palíndromo es de hecho de origen griego y viene de la construcción “palin dromein”, es decir, volver atrás, recorrer a la inversa, porque se trata precisamente de eso, de palabras o frases simétricas que se pueden transitar en ambos sentidos. Los palíndromos numéricos también existen, aunque se conocen como capicúa: 1331, 8008, 353.

Ejemplos: Luz azul, Somos o no somos, Isaac no ronca así, Sé verlas al revés, Amó la paloma, Anita lava la tina, Luz azul, Yo hago yoga hoy, Ana lava lana…

Código de la clase

Fantastic class! everything was clear, teacher Facundo explains very well and has a good energy. 👨🏻‍💻🦾

return palabra==palabra_invertida


Explicación del código

  1. Primero escribimos el [[punto de entrada en Python]] →
    if __name__ == "__main__":
    Esto hará que Python lea en primer lugar esta línea de código y ejecutará todo lo contenga debajo, es decir, ejecutará la función run().

  2. Python leerá la función run() en dónde se ejecutará todo el código dentro de la función.

    1. Escribimos dentro de la función run() una variable llamada palabra donde guardaremos un input() que contenga la entrada del usuario.

    2. Escribimos una variable llamada es_palindromo dónde guardaremos una función llamada palindromo() y dentro de esa función escribimos el parámetro palabra, que es la entrada del usuario para ser comparada en la función palindromo.

    3. Escribimos if es_palindromo == True:, dónde se verificará si la comparación de la variable palabra dentro de la función es_palindromo se retorna True si es realmente un palíndromo o False si no lo es.

  3. Dentro de función palindromo incluyendo el parámetro palabra (entrada del usuario) para realizar la comparación, se verificará si la entrada por el usuario guardada en la variable palabra es o no un palíndromo:

    1. Escribimos la variable palabra en la que guardaremos la propia variable con 2 metódos, el método .replace(" ", "") dónde se guardará la entrada del usuario eliminandose cualquier espacio porque los espacios en blanco son caracteres que se cuentan, y sino se piensa en ello arrojará un resultado erróneo en la comparación.

      Después escribimos el método .lower() para convertir todo el string en minúscula, ya que las palabras mayúsculas y minúsculas son caracteres distintos entre sí, y sino se tiene en cuenta arrojará un resultado erróneo en la comparación

    2. Escribimos una nueva variable llamada palabra_invertida dónde guardaremos la anterior variable palabra con todos los métodos aplicados y mencionando entre corchetes los índices [::-1], dichos índices convertirán todo el string de la variable palabra y se guardará en la variable con el string invertido.

    3. Escribimos if palabra == palabra_invertida: para realizar la comparación de la variable palabra (entrada del usuario con los métodos aplicados (.replace y .lower())).

      • Si ambas variables son iguales escribimos return True

      • Si ambas variables son diferentes escribimos return False

  4. Finalmente la función principal run() ejecutará el if dónde se compara si la variable es_palindromo es igual a True, si es así se imprimirá en consola Es palíndromo

    De lo contrario será False y se imprimirá en consola No es palíndromo

Intento escribir los códigos antes de ver el vídeo, y así lo hice con éste. Luego de ver el vídeo agregué lo que enseñó el profesor y así quedó.

def palindrom(palabra):
    palabra = palabra.replace(" ", "").lower()
    reves = palabra[::-1]
    if palabra == reves:
        print("Es un palindromo")
    else:
        print("No es un palindromo")


def run():
    print ("¿Quiere conocer si una palabra es un palindromo?")
    palindrom(input("Ingrese una palabra: "))


if __name__ == "__main__":
    run()

def comparar(palabra):
palabra = palabra.replace(" “,”")
palabra = palabra.lower()
validador = palabra[::-1]
if validador == palabra:
return True
else:
return False

def run():
palabra = input("Escribe una palabra o frase: ")
if comparar(palabra) == True:
print(“La palabra es palindroma”)
else:
print(“La palabra NO es palindroma”)

if name == ‘main’:
run()

Información resumida de esta clase
#EstudiantesDePlatzi

  • Palíndromo = Palabra que se lee igual al derecho y al revés

  • Una buena práctica en Python es tener una función principal que va a correr el programa al principio, por lo general es llamada main o run

  • Es buena práctica dejar 2 espacios entre cada función

  • Esta línea de código es el punto de entrada de un programa de Python y es una buena práctica ponerla:
    if name = main:

  • Las funciones debemos crearlas siempre por encima del lugar donde fueron invocadas

  • Replace es una función importante a saber usar

palabr = input('ingresa una palabra').lower().replace(' ','')
if palabr == palabr[::-1]:
    print('es palindromo')
else:
    print('no es palindromo')

Usé regex para borrar todos los espacios

from re import sub

def is_palindrome(word):
    typed_word = sub('\s', '', word)
    
    if typed_word == typed_word[::-1]:
        print(word + " es palindromo")

    else:
        print(word + " no es palindromo")

def run():
    user_input = input("Escribe una palabra: ")
    is_palindrome(user_input.lower())

if __name__ ==  '__main__':
    run()

Comparto mi ejercicio xd

Me gusta que aparezca la variable en los print que mando

def run():
    nombre = input('Ingresa un palindromo:\n')
    nombre_nomal = nombre.replace(" ","").upper()
    nombre_invertido =nombre_nomal[::-1]
    if nombre_invertido == nombre_nomal:
        print(nombre + ', es un palindromo ✅')
    else:   
        print(nombre + ', no es un palindromo ❌')


if __name__ == '__main__':
    run()

Primer aporte 😃

def palindromo(palabra):
    palabra = palabra.replace(' ', '')
    palabra = palabra.lower()
    palabra_invertida = palabra[::-1]
    if palabra == palabra_invertida:
        return True
    else:
        return False

def main():
    palabra = input("Escribe una palabra: ")
    es_palindromo = palindromo(palabra)
    if es_palindromo == True:
        print("Es palindromo")
    else:
        print("No es_palindromo")


if __name__ == '__main__':
    main()
def palindromo(word):
    backward = word.replace(' ', '')
    return True if word == backward[::-1] else False


def run():
    message = 'No es palindromo'
    word = input('Digite la frace....!\n')
    if word:
        es_palindromo = palindromo(word.lower())
    if es_palindromo:
        message = 'Si, es palindromo'
    print(message)


if __name__ == '__main__':
    run()

Creo que es otra opcion simplificada

def palindromo(palabra):
    palabra = palabra.lower().replace(' ', '')
    if palabra == palabra[::-1]:
        return True


def run():
    palabra = input("Escribe una palabra: ")
    es_palindromo = palindromo(palabra)
    print("El resultado es: ", 'Correcto' if es_palindromo else 'Fallido')


if __name__ == '__main__':
    run()

En mi caso, lo optimizo asi!

💚

"""
Palindrome
"""


def is_palindrome(value):
    formatted_sentence = value.lower().strip().replace(" ", "")
    return formatted_sentence[::-1] == formatted_sentence


def run():
    sentence = input("Write a sentence\n>>>")

    if is_palindrome(sentence):
        print("Is a palindrome")
    else:
        print("Is not a palindrome")


run()
def palindrome():
    word = input("Print a word to know if it is a palindrome: ")

    if word.lower().replace(' ', '') == word.lower().replace(' ', '')[::-1]:
        print(f'{word} is a palindrome')
    else:
        print(f'{word} is NOT a palindrome')

if __name__ == '__main__':
    palindrome()
<code> 
def palindromo (palabra):
    palabra1=palabra.replace(" ", "")
    palabra2 = palabra1[::-1]
    if palabra1 == palabra2:
        print(palabra+" es un palíndromo")
    else:
        print(palabra + " no es un palíndromo")



def run():
    palabra = input("ingresa una palabra: ")
    palindromo(palabra)    


if __name__ == "__main__":
    run()

Mi pequeño aporte del ejercicio. 😄

def esPalindromo(word):
    word = word.lower()  # Coloca en minúsculas la palabra.
    wordIns = word[::-1] # Invierte el orden de la palabra.
    if wordIns == word: # Analiza si son iguales o no.
        print("Es palindromo. " + wordIns.capitalize())
    else:
        print("No es palindromo. " + wordIns.capitalize())


def start():
    word = str(input("Ingresa la palabra a inspeccionar: \n"))
    esPalindromo(word) # Invoca la función, al no retornar ningún valor, solamente trabaja lo que tiene la función.


if __name__ == "__main__":
    start()