Indexing y slicing

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 😄

Slice Notation

 
lista[inicio:fin:salto]

¿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

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```

AJSJJAJAJA mori de la risa cuando salio el “pto”

Para solucionar el problema del video anterior lo que hice pues esto:
user_option = (input(“piedra, papel o tijera =>”).lower())

Y al parecer funciona 😃

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 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’

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

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

Si escribes print(text [10:16: 3] y esa décima posición llega a ser un espacio en blanco empezará a contar 3 desde el siguiente caracter, mas no desde la posición en blanco?

print(text[-1])

Excelente

Buen día, comparto mi aporte

text = 'Ella sabe Python'
#Esta funcion permite ir a nivel de pocisiones, es decir vamos al caracter de la pocision deseada
print(text[0])
print(text[10])
#print(text[999])

#Esta nos permite ir al ultimo caracter
size = len(text)
print('size =>', size)
print(text[size -1])
#Esta tambien nos permite ir al ultimo caracter
print(text[-1])

#slicing, es decir extraemos caracteres del texto

print(text[0:5]) #extraemos subtexto de ese rango
print(text[10:16]) 
print(text[:10]) #extraemos el texto desde el inicio al 10
print(text[5:-1]) #Hace lo mismo que la de abajo
print(text[5:]) #extremos desde la pocision 5 hasta el final
print(text[:]) #Extraemos el mismo str desde el inicio hasta el final
print(text[10:16:1]) 
print(text[10:16:2]) #Damos inicio y fin para sacar texto, y definimos el num de saltos (num de caracteres que se saltan apartir del str)
print(text[::2]) #vamos del inicio a fin y saltamos de a 2

Juego del piedra, papel o tijera

Jugada_del_usuario = input("ingrese opción => ")
Jugada_de_la_computadora = "papel"
if Jugada_del_usuario.lower() == Jugada_de_la_computadora:
print(“empate, se repite la jugada!”)
elif Jugada_del_usuario.lower() == “piedra”:
if Jugada_de_la_computadora == “papel”:
print(“has perdido!”)
else:
print(“has ganado!”)
elif Jugada_del_usuario.lower() == “tijera”:
if Jugada_de_la_computadora == “piedra”:
print(“has perdido!”)
else:
print(“has ganado!”)

REGLAS DEL RECORRIDO POR CADENAS:

• el primer elemento desde la izquierda tiene índice 0

• al recorrer la cadena, con el ánimo de revisar sus letras componentes, se debe indicar el último índice posible que ya no está en la cadena.

• ejemplo: si una cadena tiene cuatro caracteres, “AMOR”, para recorrer la cadena letra por letra, en forma dinámica, se indica el índice máximo con la función len(cadena).

• la cadena “AMOR” tiene cuatro elementos o caracteres, de acuerdo a la función len(“AMOR”), pero el índice o posición de la letra “R” es 3.

• el recorrido quedaría como:
  for i in range(len(cadena)):
  print(cadena[i])

# Indexing : Significa que los textos tienen un indicador en el cual yo puedo ingresar a nivel de posiciones. 

text = "Ella sabe Python"
print(text[0])
print(text[1])
# En la mayoria de lenguajes,la primer posicion es 0. 

print(text[999]) #Este por ejemplo no la encuentra

# Como saber cual es el caracter final 
size = len(text)
print('size => ',size)
print(text[size - 1])

# 0 le damos el texto y le restamos 1
print(text[-1])

# slicing : Basado en las posiciones de los caracteres , podemos sacar ciertas partes del texto. 

# Obtener el texto de ese rango 
print(text[0:5])
print(text[10:16])
print(text[:10])
print(text[5:-1])

#Cuando no se pone nada , quiere decir que ira hasta el final del texto 
print(text[5:])
print(text[:])

# Saltos , el tercer valor es cuanto salto de letra en letra 
print(text[10:16:1])
print(text[10:16:2])
print(text[::2])

El ejercicio de la clase anterior tambien se puede solucionar ase

user_option = (input('Piedra, Papel o Tijera?: ').lower())

La cadena es un ARRAY.

text = "Ella sabe Python"
print(text[0])
print(text[1])
# print(text[999])
size = len(text)
print('size => ', size)
print(text[size-1])
print(text[-1])

# slicing

print(text[0:5])
print(text[10:16])
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])

Excelente ejercicio para ir practicando. Quise agregarle un poco más de complejidad al mío, agregando una lista con los tres valores y usando la librería random, para jugar con el sistema directamente.

""" Indexing """
text = "She can't help herself at all"
print("text =", text)
print("text[0] =>", text[0])
print("text[-1] =>", text[-1])
print("text[4] =>", text[4])

""" slicing """
print("-" * 35)
text = "El señor de la noche"
print("text =", text)
print("text[0:5] =>", text[0:5])
print("text[:8] =>", text[:8])
print("text[3:8] =>", text[3:8])
print("text[9:] =>", text[9:])
print("text[:] =>", text[:])

""" jumps """
print("-" * 35)
text = "I am the storm that is approaching"
print("text =", text)
print("text[0:8:1] =>", text[0:8:1])
print("text[0:8:2] =>", text[0:8:2])
print("text[::3] =>", text[::3])
print("text[::1] =>", text[::1])
print("text[::] =>", text[::])
print("text[::-1] =>", text[::-1])

Se albureo solo

import random

computer = (“Piedra”,“Papel”,“Tijera”)

def impresion(humano1,seleccion):
print(f"La computadora selecciono {seleccion}")
print(f"el Humano selecciono {humano1}")

def run():
marcadorh = 0
marcadorc = 0
empate = 0
for i in range(10):
opciones = “”“
1 = papel
2 = Piedra1
3 = Tijera
”""
print(opciones)

    humano1=""
    humano= int(input("ingresa el # del elemento para jugar "))
    if humano == 1:
        humano1 = "Papel"
    elif humano == 2:
        humano1 ="Piedra"
    elif humano == 3:
        humano1 ="Tijera"        

    seleccion = str(random.choice(computer))
    
    if humano1 == seleccion:
        print("Empate")
        impresion(humano1,seleccion)
        empate +=1
    else:
        if humano1 == "Papel" and seleccion != "Tijera":
            print ("Ganaste")
            impresion(humano1,seleccion)
            marcadorh += 1
        elif humano1 == "Piedra" and seleccion != "Papel":
            print("Ganaste")
            impresion(humano1,seleccion)
            marcadorh += 1
        elif humano1 == "Tijera" and seleccion != "Piedra":
            print("Ganaste")
            impresion(humano1,seleccion)
            marcadorh += 1
        else:
            print("Perdites")
            impresion(humano1,seleccion)
            marcadorc += 1
    print(f"el juego va de la siguientes manera humano lleva {marcadorh} y la computadora lleva {marcadorc} y fueron {empate} empates ")     

if name ==“main”:
run()

Hola, estoy intentando correr mi archivo en la terminal y me sale esto… (bash: 15_indexing.py: command not found) ¿Alguien sabe qué puedo hacer ahí?, el error comenzó a salir de un momento a otro y no me funciona así cree un nuevo documento de Python

text = 'Ella sabe Python'
print(text[0])
print(text[1])
#print(texto[8]) si le das una pocicion que no existe , sale error
size = len(text)
print('size =>', size)
print(text[size-1])
print(text[-1])

#slicing

print(text[0:5])
print(text[9:16])
print(text[:10])
print(text[10:])
print(text[:])
print(text)
print(text[10:16:1])
print(text[10:16:2])
print(text[::2])