No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Indexing y slicing

24/38
Recursos

Aportes 117

Preguntas 13

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

Slice Notation

 
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 😃

Para entender la línea $ text[10:16:2] //Pto

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’

Por si alguien tenía la duda, para el slicing. En caso de que en el segundo valor pongan un valor negativo: print(text\[:-1]) Tomará como índice para tomar el slicing, el índice final menos el valor escrito, así: ```js ### EJEMPLO PARA LA CLASE text = 'Ella sabe Python' print(text[:-1]) # Ella sabe Pytho print(text[:-2]) # Ella sabe Pyth print(text[:-3]) # Ella sabe Pyt print(text[:-4]) # Ella sabe Py print(text[:-5]) # Ella sabe P ```
Gracias a la inteligencia artificial que fue integrada a Replit y a toda la gente que ha hecho los ejercicios de este curso en la plataforma, escribir el mismo texto del profe se vuelve trivial a tan solo esperar que la AI te sugiera la misma linea de código, la IA rápidamente predice la siguiente linea de código una vez ya has empezado, como resultado, no escribes mucho código y no gastas tiempo escribiendo algo que estas transcribiendo, y mejor pones esfuerzo en personalizar el código.
Para tener en cuenta: **Inmutabilidad de las cadenas:** Las cadenas en Python son inmutables, lo que significa que no puedes cambiar un carácter de una cadena utilizando la indexación. s = "PYTHON" s\[0] = "J"  # Esto dará un error **Valores predeterminados de slicing:** Si omites alguno de los tres parámetros en s\[start:stop:step], Python utilizará los valores predeterminados, que son start=0, stop=len(s) y step=1. s = "PYTHON" print(s\[::2])  # Salida: PTO

No saben lo brutalmente genial que es ese -1, defintiivamente en java todo es más complicado.

esto es un vector ahora como trabajar con matrices :S ya me duele la cabeza
Clase 22. Indexing y slicing \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*INDEXING\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* (Inicia en 0) Para hacer el indexado, Python siempre inicia en 0. Para hacer el conteo de carácteres, se inicia en 1. text = "Ella sabe Python" print(text\[0]) \# Imprime la letra E print(text\[1]) \# Imprime la letra l \#print(text\[999]) \# Imprime error. size = len(text) \# Cuenta el numero de carácteres en la variable 'text' (inicia en 1). print('size => ',size) \# Imprime el valor de la variable size. print(text\[size - 1]) \# Imprime el último caracter de la variable text (letra "n"). print(text\[-1]) \# Imprime el último caracter de la variable text (letra "n"). \*\*\*\*\*\*\*\*\*\*\*\*\*\*SLICING\*\*\*\*\*\*\*\*\*\*\*\*\*\* (Inicia en 0, \[pero no escribe el último carácter]). text = "Ella sabe Python" print(text\[0:5]) \# Imprime el texto desde el carácter 0 al carácter 4 ("Ella "). print(text\[10:16]) \# Imprime el texto desde el carácter 10 al carácter 15 ("Python"). print(text\[:10]) \# Imprime el texto desde el primer carácter, hasta el carácter 9 ("Ella sabe "). print(text\[5:-1]) \# Imprime el texto desde el carácter 5, restandole 1 carácter al final ("sabe Pytho"). print(text\[5:]) \# Imprime el texto desde el carácter 5, hasta el último carácter ("sabe Python"). print(text\[:]) \# Imprime desde el primer hasta el último carácter ("Ella sabe Python"). print(text\[10:16:1]) \# Imprime desde el carácter 10, hasta el carácter 15, dando saltos de a 1 ("Python"). print(text\[10:16:2]) \# Imprime desde el carácter 10, hasta el carácter 15, dando saltos de a 2 ("Pto"). print(text\[::2]) \# Imprime desde el principio, hasta el final, dando saltos de a dos ("El aePto").
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()

![](https://static.platzi.com/media/user_upload/image-51313fc4-905f-4009-b1e3-53309a2da6d2.jpg) Me surge una duda, ¿por qué antes de los dos puntos (\[ aquí: ]) me cuenta la posición inicial en cero pero, después de los dos puntos (\[ : aquí ]) la posición inicial la cuenta en uno. Mil gracias para quien pueda sacarme de la duda
Excelente material, y como podemos manipular los strings, es genial. muchas gracias por su exposición..
![](https://static.platzi.com/media/user_upload/image-bb6bb9c0-e055-4afe-81e0-fd511d871936.jpg)
En Python, el indexing y slicing son técnicas fundamentales para acceder y manipular elementos en secuencias como cadenas, listas y tuplas. El indexing permite seleccionar un elemento específico dentro de la secuencia mediante su posición, empezando por 0. Por ejemplo, `mi\_lista\[0]` accedería al primer elemento de la lista. Por otro lado, el slicing permite extraer porciones de la secuencia especificando un rango de índices. El formato básico es `mi\_secuencia\[inicio:fin]`, donde el rango va desde `inicio` hasta `fin-1`. Además, se pueden proporcionar pasos opcionales y omitir valores para seleccionar porciones más complejas. Estas técnicas son poderosas herramientas para trabajar eficientemente con datos en Python, facilitando la manipulación y extracción de información de secuencias de manera precisa.
codigo para verificar si es una palabra palindrome text=input('Ingrese una palabra, que pueda ser palindrome:\n') if text == text\[::-1]: print('Es palindrome') else: print('No es palindrome')
user\_option = input("piedra, papel o tijera => ").lower() TAMBIEN LO PUEDEN HACER HACI, solo le agregan el lower() al final de la linea
Excelente temas profer
Claro, aquí tienes un apunte de clase sobre las listas en Python, diseñado para ser muy didáctico y accesible incluso para quienes no tienen experiencia previa en programación. Las listas son una de las estructuras de datos más fundamentales y versátiles en Python. Permiten almacenar una colección de ítems en un solo lugar. Estos ítems pueden ser de cualquier tipo, incluyendo números, cadenas, o incluso otras listas. \### 1. Creación y Acceso a las Listas Para empezar, una lista se define con elementos entre corchetes `\[]`, separados por comas. Por ejemplo: ```python mi\_lista = \[1, 2, 3, 4, 5] ``` Acceder a los elementos de la lista se hace mediante índices, comenzando desde 0. Por lo tanto, para acceder al primer elemento de `mi\_lista`, usarías `mi\_lista\[0]`, que te dará `1`. \#### Ejemplo: ```python print(mi\_lista\[0]) # Accede al primer elemento print(mi\_lista\[4]) # Accede al último elemento ``` \### 2. Modificación de Listas Las listas son mutables, lo que significa que puedes cambiar sus elementos después de haberlas creado. \#### Ejemplo: ```python mi\_lista\[0] = 10 print(mi\_lista) # \[10, 2, 3, 4, 5] ``` \### 3. Métodos Comunes de las Listas Python ofrece una variedad de métodos útiles para trabajar con listas. Aquí algunos de los más usados: \- \*\*append(x)\*\*: Añade un ítem al final de la lista. \- \*\*insert(i, x)\*\*: Inserta un ítem en la posición `i`. \- \*\*remove(x)\*\*: Elimina el primer ítem desde la lista cuyo valor es `x`. \- \*\*pop(i)\*\*: Elimina el ítem en la posición `i` de la lista y lo devuelve. \- \*\*sort()\*\*: Ordena los ítems de la lista. \#### Ejemplo Complejo: Vamos a crear una lista de listas, modificarla y aplicar algunos métodos: ```python \# Crear una lista de listas matriz = \[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]] \# Añadir un nuevo elemento al final matriz.append(\[10, 11, 12]) print("Después de añadir:", matriz) \# Insertar un elemento en la posición 1 matriz.insert(1, \[13, 14, 15]) print("Después de insertar:", matriz) \# Eliminar un elemento específico matriz.remove(\[4, 5, 6]) print("Después de eliminar:", matriz) \# Acceder y modificar un elemento específico matriz\[0]\[1] = 20 print("Después de modificar:", matriz) ``` \### 4. Comprensión de Listas La comprensión de listas es una característica poderosa de Python que permite crear listas de manera concisa. Puedes construir una nueva lista aplicando una expresión a cada ítem de una secuencia existente. \#### Ejemplo: ```python \# Crear una lista con los cuadrados de los números del 1 al 5 cuadrados = \[x \*\* 2 for x in range(1, 6)] print(cuadrados) ``` \### 5. Operaciones con Listas Python también soporta operaciones como la concatenación (`+`) y la repetición (`\*`) con listas. \#### Ejemplo: ```python lista1 = \[1, 2, 3] lista2 = \[4, 5, 6] \# Concatenación lista3 = lista1 + lista2 print("Concatenación:", lista3) \# Repetición lista4 = lista1 \* 3 print("Repetición:", lista4) ``` \### Conclusión Las listas en Python son increíblemente flexibles y poderosas. Permiten almacenar colecciones de datos, modificarlos, y acceder a ellos de manera eficiente. Con la práctica, te familiarizarás con todas estas operaciones y podrás utilizar las listas para resolver una amplia gama de problemas en tus programas. Recuerda experimentar con los ejemplos proporcionados para reforzar tu comprensión.
```js text = "Ella sabe Python" #indexing: nos dice en que posicion esta una letra print(text[0]) #los corchetes indican la poscion dentro del string print(text[1]) # print(text[999]) si el nuero es mayor a la cantidad de caracteres dentro del string, nos da error #Como saber cual es el ultimo caracter de un string size = len(text) print('size => ',size) print(text[size - 1]) #otra forma de hacerlo mas directo print(text[-1]) #slicing permite sacar ciertas partes del texto print(text[0:5]) #obtiene la palabra ella print(text[10:16]) #obtiene la palabra Python print(text[:10]) #texto desde el inicio hasta el caracter 10 print(text[5:-1]) print(text[5:]) #desde la posicion 5 hasta el final print(text[:]) #desde el inicio hasta el final #saltos: el ultimo valor indica la cantidad de saltos que se hace print(text[10:16:1]) print(text[10:16:2]) print(text[::2]) ```text = "Ella sabe Python" \#indexing: nos dice en que posicion esta una letra print(text\[0]) #los corchetes indican la poscion dentro del string print(text\[1]) \# print(text\[999]) si el nuero es mayor a la cantidad de caracteres dentro del string, nos da error \#Como saber cual es el ultimo caracter de un string size = len(text) print('size => ',size) print(text\[size - 1]) \#otra forma de hacerlo mas directo print(text\[-1]) \#slicing permite sacar ciertas partes del texto print(text\[0:5]) #obtiene la palabra ella print(text\[10:16]) #obtiene la palabra Python print(text\[:10]) #texto desde el inicio hasta el caracter 10 print(text\[5:-1]) print(text\[5:]) #desde la posicion 5 hasta el final print(text\[:]) #desde el inicio hasta el final \#saltos: el ultimo valor indica la cantidad de saltos que se hace print(text\[10:16:1]) print(text\[10:16:2]) print(text\[::2])

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.

```js text = "Ella sabe Python" # INDEXING # Se trae el carácter que esta en la posición dada print(text[0]) # Rta: E print(text[-1]) # Rta: n (Al usar una posición negativa cuenta desde el último carácter al primero) # SLICING # Se trae los carácteres que estan entre las posiciones dadas print(text[0:5]) # Rta: Ella print(text[:5] # Rta: Ella print(text[5:] # Rta: sabe Python # Saltos print(text[10:16:2]) # Rta: Pto ```
#Desde el principio hasta la mitad
print(text[:len(text) // 2])

#Desde la mitad hasta el final
print(text[len(text) // 2:])
Con lo métodos con los string y esta clase se me despejan varias dudas que tenía!
print(text\[::-1]) #inicia del final hacia el principio print(text\[6::-1]) #inicia desde un punto hacia el inicio
Saludos tengo una duda. Si ejecuto este código: ![](https://static.platzi.com/media/user_upload/image-11df1f2d-24cb-450f-8861-84e8ee3af1bb.jpg) ¿No debería imprimir un espacio vacío mas al final? Pues si comienza en la posición 0 y avanza de uno en uno hasta la posición 11... ![](https://static.platzi.com/media/user_upload/image-5dc1f944-2df0-455c-9273-2c702f232e9b.jpg) P.D.: Ya vi que escribí mal la palabra posición en mi código XD
No entiendo porque si se puso un rango del 0 al 5, no se imprimió la "S" de la palabra sabe E=0 l=1 l=2 a=3 espacio=4 s=5
computadora="papel" jugador=input("Digite piedra, papel o tijera: ").lower() while computadora=="piedra": if computadora==jugador: print("Empate") quit() if jugador=="papel": print("Ganaste!!") quit() if jugador=="tijera": print("Perdiste") quit() else: print("Error") quit() while computadora=="papel": if computadora==jugador: print("Empate") quit() if jugador=="piedra": print("Perdiste!!") quit() if jugador=="tijera": print("Ganaste") quit() else: print("Error") quit() while computadora=="tijera": if computadora==jugador: print("Empate") quit() if jugador=="papel": print("Perdiste!!") quit() if jugador=="piedra": print("Ganaste") quit() else: print("Error") quit()

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

text = "Ella sabe Python" print(text\[0]) print(text\[1]) \#print(text\[999]) error String index out of range size = len(text) print('size => ', size) print(text\[size -1]) print(text\[-1]) print(text\[::-1]) \#slicing print(text\[0:5]) print(text\[10:16]) \################# print(text\[0:10]) \# Es lo mismo que => print(text\[:10]) \############################## print(text\[5:-1]) print(text\[5:]) print(text\[:]) print(text\[10:16:1]) print(text\[10:16:2]) print(text\[::2])
La nueva plataforma borro los recursos de los cursos, que por cierto son ya de mas de un año, y no sabemos que referencias o recursos validar para aprender mas... lastima ... menos mal ya en noviembre termono el plan
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:

  1. Los indexado al igual que los slicing el 0 es pisicion 1 y 1 es posicion 2.
  2. Los indexado son mas usados para devolver un valor individual los slicing para devolver una subsecuencia.
  3. La estructura del slicing es [Inicio:Fin:Pasos]
    Cuando iniciamos, debemos tener en cuenta la llave 1, pero cuando es fin, ya NO, por lo que contamos normalmente asi:
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])

slicing arroja desde que posicion quiero hasta la otra posicion

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])

print(text[999])

size = len(text)
print(‘size =>’,size )
print(text[size-1])
print(text[-1])

slicing

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()