Para poder tener las palabras al reves
text = "Ella sabe python"
print(text[::-1]
Introducción y primeros pasos con Python
¿Por qué aprender a programar en Python?
Accede a la versión más actualizada de este contenido
Herramientas del curso
Tu primer programa con Python
Herramientas para programar con Python
Playgrounds: Te doy la bienvenida a los ejercicios interactivos
Variables
Playgrounds: Modifica el valor de una variable
Quiz: Introducción y primeros pasos con Python
Tipos de datos en Python
Tipos de datos
Strings
Numbers
Booleans
Transformación de tipos
Playgrounds: Imprime el formato adecuado
Operadores y condicionales
Operadores aritméticos
Operadores de comparación
Comparación de números flotantes
Operadores lógicos: and y or
Operador lógico not
Condicionales
Proyecto: condicionales
Playgrounds: Identifica si un número es par o impar
Listas y diccionarios
String recargado
Indexing y slicing
Listas
Métodos de listas
Playgrounds: Agrega, modifica y elimina elementos de una lista
Tuplas
Proyecto: tuplas
Diccionarios: definición y lectura
Diccionarios: inserción y actualización
Playgrounds: Agrega, modifica y elimina elementos de un diccionario
Ciclos
Loops: While
Loops: For
Playgrounds: Agrega solo los números positivos de una lista
Ciclos anidados
¡Es tu turno: crea un tutorial!
Cierre
Proyecto: aplicando ciclos
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 117
Preguntas 13
Para poder tener las palabras al reves
text = "Ella sabe python"
print(text[::-1]
El concepto de Slicing me gusto y no fue tan complicado entenderlo, sin embargo al agregarle el salto me costo trabajo poder comprenderlo hasta que lo desglose de la siguiente forma:
Suponiendo que tenemos
text = "Hola Mundo"
Y queremos aplicar un salto de 2 desde el inicio hasta el final de la cadena
print(text[::2])
Python nos regresará Hl ud
, regresa como primer valor la posición inicial que le indiquemos (en este caso la posición 0), luego va contanto el número de saltos (en este caso 2), el que este en el 2 lo regresa.
Para comprenderlo mejor hice esta demostración.
Espero este aporte les sea de ayuda.
#NuncaParenDeAprender
Hay que tener en cuenta que, en la parte del slicing, el límite de la derecha es exclusivo, es decir:
print(text[0:5])-> Incluye desde el cero hasta el 4, es decir, el caracter en la posición 5 no la va a incluir, si se tiene en cuenta lo que se menciona del indexado (indexing)
Acaso eso fue un mensaje subliminal? jajaja
text = "Ella sabe Python"
print(text[0])
print(text[1])
print(text[999]) ## Si le das una posicion que no existe, da error
size = len(text)
print('size ', size)
print(text[size]) # Como empieza en 0, no llega a la última
print(text[size - 1])
print(text[-1])
# Slicing
print(text[0:5]) # Obtener del índice 0 al índice 4 excluyendo el índice 5
print(text[:10]) # Obtendrá siempre desde 0 si no se específica
print(text[5:]) # Obtendrá siempre hasta el final de la cadena desde donde específicaste el inicio
print(text[10:16:2]) # Sí se agrega un salto, regresa del inicio al final por los saltos
print(text[::2]) # Inicio al final en saltos de 2
Construcción de un programa para identificar palíndromos 😄
¿Qué es la indexación?
Indexar es crear una referencia a un elemento de un iterable (tuplas, cadenas) por su posición particular dentro del iterable.
Para comprobar cómo acceder a los elementos individuales de una lista, primero crearemos una lista. Veremos cómo funcionan las secuencias de objetos dentro de la lista en Python. La lista de objetos se escribe entre corchetes, como se muestra a continuación:
#posisción de cada carácter de un texto en python
text = 'Nosotros estamos aprendiendo Python '
print(text[0])#aca estamos accediendo al primer carácter
print(text[1])#segindo carácter del texto
#debemo saber cuántos caracteres hay en nuestro texto, y como saber cuál es el ultimo carácter, de la siguiente manera.
size = len(text)
print('size => ', size)
print(text[size - 1])
#pero hay una forma mucho más fácil de acceder al último carácter del texto
print(text[-1])#con esta función Python nos contara la última posición del texto
print(text[-2])#seria el penúltimo carácter
# SLINCING
#con slicing podemos sacar ciertas partes del texto
print(text[0:6])#aca estamos sacando desde el primer carácter hasta el carácter 4
print(text[10:16])# estamos sacando solo la palabra Python
print(text[:15])#podemo obviar el primer parametro y decirle hasta que carácter quiero avanzar
print(text[8:])#podemos indicar ir de cierto carácter hasta el final con esta función
print(text[:])#nos imprime toto el texto
print(text[12:14:18])#tambiem puedo darle un inicio u un fin a nuestro texto(saltos de línea)
print(text[12:14:2])#stos saltos de línea tambien son validos
print(text[::4])#al igual que este
lista[inicio:fin:salto]
AJSJJAJAJA mori de la risa cuando salio el “pto”
Jugando con el texto:
text = 'Ella sabe Python'
print(text[0]) #Res -> E
print(text[1]) #Res -> l
print(text[0:3]) #Res -> Ell
print(text[:3]) #Res -> Ell
print(text[3:]) #Res -> a sabe Python
print(text[1:7]) #Res -> lla sa
print(text[1:7:2]) #Res -> las
print(text[::]) #Res -> Ella sabe Python
print(text[1::3]) #Res -> l bPh
print(text[::-1]) #Res -> nohtyP ebas allE```
El indexing se refiere a acceder a un elemento específico de una estructura de datos utilizando su posición o índice. En Python, los índices comienzan desde 0 para el primer elemento y aumentan de forma secuencial. Puedes acceder a un elemento utilizando corchetes [] y especificando el índice correspondiente. Por ejemplo:
frutas = [“manzana”, “plátano”, “naranja”, “uva”]
print(frutas[0]) # Accede al primer elemento: "manzana"
print(frutas[2]) # Accede al tercer elemento: “naranja”
El slicing, por otro lado, te permite obtener una porción o subconjunto de una estructura de datos. Se realiza utilizando la sintaxis [inicio:fin], donde “inicio” es el índice del primer elemento a incluir y “fin” es el índice del elemento siguiente al último a incluir (no inclusivo). Por ejemplo:
frutas = [“manzana”, “plátano”, “naranja”, “uva”]
print(frutas[1:3]) # Obtiene los elementos desde el índice 1 hasta el índice 2: [“plátano”, “naranja”]
print(frutas[:2]) # Obtiene los primeros dos elementos: [“manzana”, “plátano”]
print(frutas[2:]) # Obtiene los elementos a partir del índice 2 hasta el final: [“naranja”, “uva”]
En resumen, el indexing se utiliza para acceder a elementos individuales en una estructura de datos, mientras que el slicing se utiliza para obtener una porción de una estructura de datos. Ambos son útiles para manipular y trabajar con datos de manera más precisa y eficiente en Python.
Para solucionar el problema del video anterior lo que hice pues esto:
user_option = (input(“piedra, papel o tijera =>”).lower())
Y al parecer funciona 😃
La frase dentro de la variable text = ‘Ella sabe Python’
De esa frase empezamos a contar desde 1 hasta llegar a 10
E → 1; l → 2 ; l → 3 ; a → 4 ; (espacio) → 5 ; s → 6 ; a → 7 ; b → 8 ; e → 9; (espacio) → 10 ; P → 11
Tomara desde después el carácter que esta en la posición 10 el cual queda en el espacio en blanco que hay entre ‘sabe Python’, toma ese espacio en blanco
Desde allí cuenta hasta llegar a la posición 16 incluyendo el 16
P → 11 ; y → 12 ; t → 13 ; h → 14 ; o → 15 ; n → 16
Y toma los caracteres dentro de ese rango entonces queda
‘Python’
Ahora al poner como tercer parámetro el :2, cuenta de dos en dos y salta la letra que queda en dos así
P → 1 ; y → 2 ; t → 1 ; h → 2 ; o → 1 ; n → 2
Toma solo los caracteres que quedan en 1 e ignora los que quedan en 2 y por tanto nos queda
‘Pto’
No saben lo brutalmente genial que es ese -1, defintiivamente en java todo es más complicado.
text = "Python"
print(text[0]) # P
print(text[-1]) # n
print(text[0:2]) # Py
print(text[:2]) # Py
print(text[:-2]) # Pyth
print(text[-2:]) # on
print(text[-4:-1]) # tho
print(text[-3:-1]) # ho
print(len(text)) # 6
print(text[0:0]) # 'vacio, nada'
print(text[0:-1]) # Pytho -> no incluye el ultimo caracter
print(text[0:-2]) # Pyth -> no incluye el -2 y el -1
print(text[0:-3]) # Pyt -> no incluye el -3, el -2 y el -1
print(text[0:-4]) # Py -> so on
print(text[0:-5]) # P
print(text[0:-6]) # 'vacio, nada'
print(text[1:6:2]) # yhn
print(text[::2]) # Pto
Buenas noches,
Yo coloque la funcion Lower después del input:
user_option = input('piedra, papel o tijera => ').lower()
Interesante. Me gustó el hecho de que Python acepte esto:
text = "Edinson aprende Python"
print(text[-1])
En vez de esto:
text = "Edinson aprende Python"
size = len(text)
print(text[size - 1])
iba a escribir que me gustó esta clase, pero a la vez descubrí que mejoraron un montón el “campo” para escribir comentarios. Excelente x2 platzi. Realmente hace valer su trabajo.
mi solución
usuario_digitado= input(print("Juguemos piedra, papel o tijera, escribe tu opción: "))
usuario = usuario_digitado.lower()
Letras mayusculas
A mi el orden me sale al revés: 0=n y 16=E.
Hola!
Les comparto el código de la clase.
# Indexing y slicing
text = "Ella sabe Python"
'''
indexing
Los textos tienen un indicador, al cual se puede acceder a nivel de posiciones.
El primer caracter siempre está en la posición 0.
'''
print(text[0])
print(text[1])
#print(text[999])
# Imprime el último caracter del texto
'''
size = len(text)
print("size =>", size)
print(text[size - 1])
'''
print(text[-1])
print(text[-2])
'''
slicing
Basados en las posiciones de los caracteres dentro de nuestro str
podemos sacar ciertas partes del texto.
'''
print(text[0:5])
print(text[10:16])
print(text[:10]) # Toma desde el inicio hasta la posicion 10
print(text[5:]) # Toma desde la posicion 5 hasta el final
print(text[:]) # Toma el str desde el inicio hasta el final
print(text[10:16:1]) # Saltos entre caracteres
print(text[10:16:2]) # Toma desde la posicion 10 hasta la 16 con saltos de 2 caracteres
print(text[::2]) # Toma el str desde el inicio hasta el final, con saltos de 2 caracteres
text='Ella sabe Python’
print(text[0])#Posición del caracter, empieza desde 0
#Para ultimo caracter
size=len(text)
print(text[size-1])
#otra opción de atras para delante
print(text[-1])
print(text[-6])
#slicing
print(text[0:5]) #Texto en esa posición
print(text[10:16])
print(text[:10])#Desde inicio asta posición 0
print(text[5:])
print(text[:])
print(text[10:16:1])#Con saltos
print(text[10:16:2])
print(text[::2])
tnt = "C7H5N3O3" #TNT
cloroeteno = "C2H3Cl" #Cloruro de Vinilo
print("El TNT posee 3 moléculas de nitrógeno: " + tnt[4:6]) #El último no es inclusivo
print("El cloruro de vinilo posee una molécula de cloro: " + cloroeteno[-2:])
Un input para elegir el caracter a mostrar
Mi pequeño aporte. Apenas estoy iniciando
num = int(input('Ingrese el numero de carecter =>'))
text = 'Ella sabe Python'
print(text[num])
UNA OPCION MAS CORTA:
user_option = input(‘piedra, papel o tijera’).lower()
algo que no se menciona en la clase es porque no nos imprime el texto completo en la línea 15 y tampoco se menciona lo que ocurre realmente en la línea 19 y 20, afortunadamente los compañeros dieron la razón del resultado de estas lineas del codigo.
lamentablemente platzi sigue pecando en el hecho de sacar varios cursos sin que estos estén realmente explicado bien los temas que se abordan, deberían revisar mejor los cursos antes de subirlos a la plataforma, y se que se podría decir que es un error pequeño pero por el dinero que uno paga este tipo de errores no deberían estar.
#Desde el principio hasta la mitad
print(text[:len(text) // 2])
#Desde la mitad hasta el final
print(text[len(text) // 2:])
Me encanto la clase de los index y los slicing. No sabia que se podia hacer eso. Si que estoy aprendiendo mucho con los conocimientos de python. Espero estar listo para las clases que vendran mas adelante.
good
✅
user_option = input('Rock, Paper, Scissors => ')
user_option = user_option.lower() # Convierte la entrada del usuario a minúsculas
bot_option = 'rock' # Cambiado a minúsculas para que coincida con user_option
if user_option == bot_option:
print('__Draw__')
elif user_option == 'rock':
if bot_option == 'scissors':
print('Rock wins Scissors!')
print('User wins!')
else:
print('Paper wins Rock!')
print('Bot wins!')
elif user_option == 'paper':
if bot_option == 'rock':
print("Paper wins Rock")
print('User wins!')
else:
print('Scissors win Paper!')
print('Bot wins!')
elif user_option == 'scissors':
if bot_option == 'paper':
print('Scissors win Paper')
print('User wins!')
else:
print('Rock wins Scissors')
print('Bot wins')
else:
print('Invalid option. Please choose Rock, Paper, or Scissors.')
El slicing con saltos nos regresa “PTO” kjakjakjakjakajkajkajakjakjakjakjakjakajkajakjakjakjakjakajkajkajakjakja
Mi código, saludos.
import random
computer_option = random.choice(["piedra","papel", "tijera"])
user_option = input("Elije piedra Papel o Tijera: ").lower()
if computer_option == user_option:
print(f"Empate la computadora tambien eligió {computer_option}")
elif computer_option == "piedra" and user_option == "papel":
print(f"Ganaste la computadora eligió {computer_option}")
elif computer_option == "papel" and user_option == "tijera":
print(f"Ganaste la computadora eligió {computer_option}")
elif computer_option == "tijera" and user_option == "piedra":
print(f"Ganaste la computadora eligió {computer_option}")
else:
print(f"Perdiste la computadora eligió {computer_option}")
```
user_option = input(‘piedra papel o tijera =>’).lower()
El slicing (rebanado) se utiliza para obtener una sub-secuencia de elementos, y es exclusivo, quiere decir que toma hasta el numero a su izquierda. ejemplo:
text = "Ella sabe Python"
print(text[0:3]) #Ell
print(text[0:4]) #Ella
print(text[0:5]) #Ella (espacio)
print(text[0:9]) #Ella (espacio) sabe
Woooow muchas gracias, excelente clase habia visto en algunos códigos ese tipo de sintaxys y aunque entendía en mayor parte, siempre quedan dudas de que es o para que sirve realmente, gracias por el detalle de realizar desde lo mas simple y paso a paso el curso
user_option = input(‘Piedra, Papel o Tijera =>’).lower()
player_choice = input("piedra, Papel o tijera =>").lower()
<#Juego PIEDRA - PAPEL O TIJERA
print('Bienvenido al juego PIEDRA - PAPEL - TIJERA\n')
user = input('Seleccione una opción:\n\nPIEDRA\nPAPEL\nTIJERA\nSelección: ')
computer = 'piedra'
user1 = user.lower()
print(f'Seleccionaste {user1} y computer {computer}')
if user1 == computer:
print('Es un empate')
elif user1 == 'papel' and computer == 'tijera':
print('Computer gana')
elif user1 == 'papel' and computer == 'piedra':
print('usuario gana')
elif user1 == 'piedra' and computer == 'tijera':
print('Usuario gana')
elif user1 == 'piedra' and computer == 'papel':
print('Computer gana')
elif user1 == 'tijera' and computer == 'papel':
print('Usuario gana')
else:
print('Computer gana')>
text = 'Ella baila sola'
text = text.title() # esto debido a que es el título de una canción
print(text)
print(text[0])
print(text[1])
#print(text[999]) este maracría un error porque no hay un caracter que llegue a 999
size = len(text)
print('size => ',size)
print(text[size - 1])
print(text[-1])
print(text[len(text)-1]) #esta forma se me ocurrió a mi para simplificar todo a una línea de código en lugar de crear una variable
# slicing
print(text[0:5])
print(text[10:16])
print(text[:10])
print(text[5:-1]) # este no incluye el último
print(text[5:])
print(text[:])
print(text[10:16:1])
print(text[10:16:2])
print(text[::2])
Hice este pequeño CÓDIGO que imprime una frase en VERTICAL…
text = input('Escribe una oración 👉 ')
text = text.upper()
print(text)
i = len(text) - 1 #esto para comenzar la variable en 0
print('nuesto contador sera "i" y tendra ', i, ' valores')
for i in range(0, i + 1): # Genera números del 1 al i (el último valor no se incluye por eso sumamos 1)
print(text[i])
Slicing:
'El slicing (rebanado) se utiliza para obtener una subsecuencia de elementos de una secuencia. Permite seleccionar una parte o segmento de la secuencia original.
Sintaxis del slicing: secuencia[inicio:fin:paso]
inicio: Índice del primer elemento de la subsecuencia.
fin: Índice del primer elemento que no se incluirá en la subsecuencia.
paso: Paso opcional que determina cuántos elementos se saltan entre cada elemento seleccionado.
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numeros, "\n")
print(numeros[2:6]) #[3, 4, 5, 6]
print(numeros[:6]) #[1, 2, 3, 4, 5, 6]
print(numeros[6:]) #[7, 8, 9, 10]
print(numeros[2::2]) #[3, 5, 7, 9]
print(numeros[:6:2]) #[1, 3, 5]
print(numeros[::2]) #[1, 3, 5, 7, 9]
print(numeros[::-1]) #[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Sintaxis del slicing: secuencia[inicio:fin:paso] inicio: Índice del primer elemento de la subsecuencia. fin: Índice del primer elemento que no se incluirá en la subsecuencia. paso: Paso opcional que determina cuántos elementos se saltan entre cada elemento seleccionado.
El slicing (rebanado) se utiliza para obtener una subsecuencia de elementos de una secuencia. Permite seleccionar una parte o segmento de la secuencia original.
Indexing: El indexing (indexación) se utiliza para acceder a elementos individuales de una secuencia utilizando su posición o índice. En Python, los índices comienzan desde 0 para el primer elemento, -1 para el último elemento, -2 para el penúltimo elemento y así sucesivamente.
Hola. aqui aprendiste basicamente la diferencia entre Indexado y slicing, cabe destacar que ambos usan las misma funcionalidad que es recorrer el objeto que tienes en el codigo.
la diferencia radica en que el indexado se dedica a devolver un valor unico del dato que te enfrentas.
el slicing por otro lado recorre los valores y los devuelve una subsecuencia de una secuencia mas grande(que esta en tus datos).
Llaves para jamas olvidar y abrir puertas en este lenguaje:
edad = "Estamos melos"
print(edad[0:2])
asi que, el valor que devuelve no es: ET,
va a devolver: ES
Si alguien quiere ir corriendo sus archivos desde el main, dando Ctrl + enter o simplemente presionando el botón “Run” les dejo cómo hacerlo.
Primero importamos el subprocess que es una librería python que nos sirve para ejecutar cosas que se encuentren fuera del archivo main.
Luego vamos a ejecutar subprocess.run() y dentro le pasamos una lista con el nombre del archivo que vamos a correr. Para el caso de este ejercicio quedaría así:
import subprocess
subprocess.run(['python', '15_indexing.py'])
Listo, ya podemos correr cualquiera de nuestros archivos desde el main simplemente cambiando el nombre, así no usaremos tanto el shell que a veces es molesto que se pierdan los comandos o cosas así.
Espero le sirva a alguien. Saludos.
comencé con java y pero me quedo con Python!
text = 'Ella sabe Python'
print(text[0])
print(text[1])
#print(text[999])
size = len(text)
print(size) #tira numero, pero si quiero que me pase el caractere hago lo siguiente
print(text[size -1])
print(text[-1]) #Va a la ultima posición
#slicing
print(text[0:5])
print(text[10:16]) #posición exacta
print(text[:10])
print(text[5:-]) #Es lo mismo que el sig print
print(text[5:])
print(text[:])
print(text[10:16:1]) #Un salto
print(text[10:16:2]) #dos saltos
print(text[::2]) #Salta de a 2 caracteres
Indexar: Es hacer índices e **_“indexing” _**es ordenar una serie de datos.
Slicing: operación por medio de la cual se extraen elementos de una secuencia, tal como una lista o una cadena de caracteres.
tamanio = len(texto)
print(tamanio)
tambien se puede eso
from os import system
system('clear')
text = "Ella sabe Python"
print ('EL texto ejemplo :')
print (text)
print(' ')
print('Mostrar el primer caracter y el segundo')
print(text[0])
print(text[1])
# print(text[999])un indice inexistente darìa como resultado un error
print (' ')
print('Mostrar el último caracter')
size = len(text)
print('size => ',size)
print()
print(text[size - 1])
print(text[-1])
# slicing
print(' Mostrar Subcadena de la posición 0 hasta la 5')
print(text[0:5] )
print(' ')
print (' Mostrar Subcadena de la posición 10 hasta la 16')
print(text[10:16])
print(' ')
print('Mostrar una subcadena de texto. Sí se obvia el primer parámetro se entenderá que, debera comenzar desde la posicion cero')
print(text[:10])
print('')
print('Mostra una subcadena, partiendo de un inicio y de un final, se se debe tomar que se toma el valor anterior')
print(text[5:-1])
print(text[5:])
print(text[:])
#Slaicing con saltos
print ('Slacing con saltos')
print(text[10:16:1])
print(text[10:16:2])
print(text[::2])
Me da curiosidad en aplicar esto, pero si existe es porque hubo una necesidad XD
text = 'Ella sabe Python'
print(text[::3]) # del inicio al final saltando de a 3 caracteres eso Eaa es tn. salta 2 caracteres y imprime el tercero.
print(’*** Piedra - papel - tijera ***’)
opciones_jugador = input(‘Elija una opcion : piedra - papel - tijera. ==>’)
print(opciones_jugador.lower())
opcion_computadora = ‘papel’
if opciones_jugador == opcion_computadora:
print(’ …Es un empate…!’)
elif opciones_jugador == ‘piedra’:
if opcion_computadora == “tijera”:
print(’…piedra gana a tijera’)
print(‘el usuario gano…!!!’)
else:
print(‘papel gana a tijera’)
print(’…papel gana a tijera…!!! ‘)
print(‘Computer gano…!!’)
if opciones_jugador == ‘piedra’:
print(’…piedra gana apapel…!!!’)
print(’ Jugador gana !!!’)
print(’…Eso es todo!!!’)
print (‘jaja!!’)
Excelnete la flexibilidad de Python
#Indexing Indicador de posiciones como arreglos
text = "Ella sabe Python"
print(text[0])
print(text[1])
print(text[2])
print(text[3])
print(text[4])
print(text[5])
#Saber el ultimo caracter del texto
size = len(text)
print(“Size=” ,size)
print(text[size-1])
print(text[-1])
print(text[0:5])
print(text[10:16])
print(text[0:10])
print(text[:10])
print(text[5:-1])
print(text[5:])
print(text[:])
#Saltos se come letras
print(text[10:16:1])
print(text[10:16:2])
print(text[::2])
#indexing
text = "Yo se programar en Python"
print(text[4]) # e
#print(text[99]) # Error
size = len(text)
print(text[size - 1]) #Una forma de imprimir el ultimo caracter, pero algo extensa. // n
print(text[-1]) # Esta directamente nos da el ultimo caracter. // n
#slicing
print(text[0:5]) # Nos imprime los caracteres dentro de este rango // Yo se
print(text[10:16]) # ramar
print(text[:10]) # si no enviamos nada en el primer valor, python entiende que es 0. // Yo se prog
print(text[5:]) # si no enviamos nada en el segundo valor, python entiende que es hasta el ultimo caracter.
#saltos
print(text[:10:2]) # si ponemos otros :, python entendera que estos son saltos, si pedimos dos saltos este hara Y y tomara dos saltos hasta terminar la cadena de texto// Y epo
my_var = "Ella sabe Python"
print(my_var[-6:])
Ese código imprime ‘Python’, por si a alguien le sirve…
text = 'Ella sabe Python'
print(text[0]) #Con los square brackets podemos traer el carácter según el índice que quiera
print(text[1])
#print(text[999])
print(text[-1])
# slicing
print(text[0:5]) #[#:#] para seleccionar cierto texto según los índices
print(text[10:16]) # [:10] inicia en 0
print(text[:10]) # [5:] va desde el punto que le indicamos al final
print(text[5:])
print(text[:]) # [:] selecciona del inicio al final completo
print(text[10:16:1])
print(text[10:16:2]) # [#:#:# saltos]
print(text[::2])
Me estoy enamorando de Python, ¡gracias!
listaNombres = ['Juan', 'Pepe', 'Jose', 'Jorge', ['Edwin', 'Luis']]
print(listaNombres[4][0])
Cree este programa de palindromos, tomando como referencia un comentario de otra compañera, añadiendo algunos elementos mas
print("Bienvenido a polindroPy")
print("")
while True:
palabra = input("Introduce una palabra para verificar si es palindromo (o escribe 'salir' para terminar): ")
if palabra.lower().replace(" ", "") == "salir":
break
palabra = palabra.replace(" ", "")
palindromo = palabra[::-1]
print(palabra.capitalize() + " es palindromo" if palindromo == palabra else palabra.capitalize() + " no es un palindromo")
print("")
Mi humilde version
game1 = str(input(‘Introduce tu opcion jugador 1:’).lower())
game2 = str(input(‘Introduce tu opcion jugador 2:’).lower())
if (game1 == ‘piedra’ and game2 == ‘tijera’) or (game1 == ‘papel’ and game2 == ‘piedra’) or (game1 == ‘tijera’ and game2 == ‘papel’):
print(‘Jugador 1 gana’)
elif (game2 == ‘piedra’ and game1 == ‘tijera’) or (game2 == ‘papel’ and game1 == ‘piedra’) or (game2 == ‘tijera’ and game1 == ‘papel’):
print(‘Jugador 2 gana’)
elif(game1 == game2):
print(‘Empate!!’)
Anteriormente, subí el código que realicé para el juego de piedra, papel o tijera, ahora lo mejore e hice que la computadora eligiera su respuesta de forma random, aquí se los dejo por si les interesa:
import random
def run():
options = ("piedra", "papel", "tijera")
computer_option = options[random.randint(0, 2)]
user_option = input("Elige piedra, papel o tijera: ")
user_option = user_option.lower().strip()
print(user_option)
print(computer_option)
if user_option == computer_option:
print("Empate!")
elif user_option == "piedra" and computer_option == "tijera":
print("Ganaste!")
elif user_option == "papel" and computer_option == "piedra":
print("Ganaste!")
elif user_option == "tijera" and computer_option == "papel":
print("Ganaste!")
else:
print("Perdiste")
if __name__ == "__main__":
run()
text = input(“Introduzca su opcion :”)
text = text.lower()
print(text)
Aquí mis apuntes en python
#Indexing
palabra = input('Ingresa una frase')
print("primer letra ",palabra[0])
print("Ultima letra ",palabra[(len(palabra) -1)])
print("Ultima letra ",palabra[-1])
# Slicing
print("rango ",palabra[2:5])
print("inicio a rango ",palabra[:2])
print("final a rango ",palabra[2:])
print("Toda la palabra ",palabra[:])
print("Toda la palabra con saltos",palabra[::2])
text = 'ella sabe algebra boleana’
print(text[0])
print(text[4])
print(text[5])
print(text[10])
size = len(text)
print(‘size =>’,size )
print(text[size-1])
print(text[-1])
print(text[0:4])
print(text[0:2])
print(text[12:19])
print(text[:12])
print(text[5:-1])
print(text[5:])
print(text[:])
print(text[10:16:1])
print(text[10:16:2])
print(text[::2])
text[1:99999999999999999999999999999999999999999999999999] …
Slice strings with position jumping.
Slice strings with position jumping.
yo hice de esta manera el piedra papel o tijera ![]()
text = "Ella sabe Python"
#va al a la letra E dado que esta esta en la posicion 0
print(text[0])
print(text[1])
# print(text[999]) da error por que la posicion no existe
size = len(text)
print('size => ', size)
#Para saber cual es el ultimo carecter de esa linea
print(text[size - 1])
#Con esta python hace la cuenta de la ultima letra a la primera
print(text[-1])
# slicing
#Muestra todo de la posicion 0 a la 5
print(text[0:5])
print(text[10:16])
#Muestra del inicio hasta el caracter 10, Abrevia
print(text[:10])
#hasta el final pero siempre quitara el ultimo caracter
print(text[5:-1])
#Va a mostrar desde el caracter 5 hasta el final 5: dejandolo abierto
print(text[5:])
#Muestra el str desde el inicio hasta el final
print(text[:])
#Con esta mostrara los caracteres que esten en ese orden pero tendra saltos de caracteres con este ultimo que se le agrega :2 dos saltos: PYTHON PTO
print(text[10:16:1])
print(text[10:16:2])
#Salta del inicio al final de dos en dos
print(text[::2])
Les comparto un ejercicio con algunas funciones de la clase pasada y de esta clase
def palindromo(palabra):
palabra = palabra.replace(' ', '').lower()
inversa = palabra[::-1]
if inversa == palabra:
return True
else:
return False
def run():
palabra = input('Ingresa una palabra o frase: ')
es_palindromo = palindromo(palabra)
if es_palindromo == True:
print('Es palindromo')
else:
print('No es palindromo')
if __name__ == '__main__':
run()
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?