No tienes acceso a esta clase

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

Curso Básico de Python

Curso Básico de Python

Facundo García Martoni

Facundo García Martoni

Trabajando con texto: slices

19/32
Recursos

En Python, los slices, traducidos al español como “rebanadas”, nos permiten dividir los caracteres de un string de múltiples formas. A continuación, realizaremos un ejemplo cómo utilizarlos:

Cómo usar slices en Python

nombre = "Francisco"
nombre
"Francisco"
nombre[0 : 3)

Arranca desde el primer índice hasta llegar antes del 3° índice.
El resultado sería
"Fra"

nombre[:3]

Va desde el principio hasta antes de llegar del 3° índice. Como no hay ningún parámetro en el primer lugar, se interpreta que arranca desde el principio. Recordemos que empezamos a contar desde cero como primer dígito.
El resultado sería
"Fra"

nombre[1:7]

Arranca desde el índice 1 hasta llegar antes del 7.
El resultado sería
"rancis"

nombre[1:7:2]

Arranca desde el índice 1 hasta llegar antes del 7, pero pasos de 2 en 2, ya que eso es lo que nos indica el 3er parámetro, el cual es 2.
El resultado sería
"rni"

nombre[1::3]

Arranca desde el índice 1 hasta el final del string (al no haber ningún 2° parámetro, significa que va hasta el final), pero en pasos de 3 en 3.
El resultado sería
"rcc"

nombre[::-1]

Al no haber parámetro en las 2 primeras posiciones, se interpreta que se arranca desde el inicio hasta el final, pero en pasos de 1 en 1 con la palabra al revés, porque es -1.
El resultado sería
"ocsicnarF"

Aporte creado por: Ignacio Crespo, Diego Camacho

Aportes 303

Preguntas 21

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Excelente curso, se nota el amor por enseñar de Facundo. Gracias

el profesor tiene el don de enseñar

Explicación:
Los slices, traducidos al español como “rebanadas”, nos permiten dividir los caracteres de un string de múltiples formas. A continuación, un ejemplo de estos:

nombre = "Francisco"
nombre
"Francisco"
nombre[0 : 3) //Arranca desde el primer índice hasta llegar antes del 3° índice.
"Fra"
nombre[:3] //Va desde el principio hasta antes de llegar del 3° índice. Cómo no hay ningún parámetro en el primer lugar, se interpreta que arranca desde el principio.
"Fra"
nombre[1:7] //Arranca desde el índice 1 hasta llegar antes del 7.
"rancis"
nombre[1:7:2] //Arranca desde el índice 1 hasta llegar antes del 7, pero pasos de 2 en 2, ya que eso es lo que nos indica el 3! parámetro, el cual es 2.
nombre[1::3] //Arranca desde el índice 1 hasta el final del string (al no haber ningún 2° parámetro, significa que va hasta el final), pero en pasos de 3 en 3.
"rcc"
nombre[::-1]  //Al no haber parámetro en los 2 primeros lugares, se interpreta que se arranca desde el inicio hasta el final, pero en pasos de 1 en 1 con la palabra al revés, porque es -1.
"ocsicnarF"

Encontré esta imagen ,espero aporte adicionalmente a lo enseñado por el profesor.

10/10 Se dice que cuando Guido van Rossum creo python todas las indicaciones se las daba Facundo

Definitivamente en éste curso dieron con la persona mas idónea para dictarlo. Es muy fácil entenderle y explica muy bien. Excelente Facundo, felicitaciones, que gran pasión por enseñar.
P.D. Platzi tiene grandes profesores y sin duda Facundo es de los mejores.

El profesor tiene mucho carisma para enseñar y eso hace de su curso uno excelente, además que no da nada por obvio y explica detalladamente cada cosa.

Gracias, Facundo!

[desde,hasta,saltos]

SLICES(REBANADAS)
variable_string[caracter_inicial : caracter_final : pasos]

De los mejores cursos que he visto en Platzi!

Slices

  • Podemos dividir cadenas de texto utilizando slices de la siguiente forma

  • Se accede a los índices, en los corchetes colocamos el índice desde donde queremos dividir la cadena colocamos dos puntos y el índice hasta donde queremos dividir.

  • También le podemos agregar un tercer valor que es el numero de saltos que va a dar para dividir la cadena es decir si colocamos dos va a ir de dos en dos

nombre[1:3]
# Cuando no colocamos el primer indice
nombre[:3]
# Quiere decir que empieza a dividir desde el principio de la cadena
nombre[3:]
# y es igual para el caso contrario```

Un palindromo es un numero que se lee igual tanto de izquierda a derecha y viceversa…
ejemplo : 12521

Yeah! ¡Qué buena clase!

Que maravilla sería si el curso Fundamentos de Javascript fuera con la misma calidad de enseñanza que tiene el profesor Facundo.

Hey Platzi acerto con este profesor, explica muy bien!

Trabajando con texto: slices


Podemos hacer slices los textos, es como cortar una rebanada de pan.

nombre = 'Steven'

nombre[0:3]
#'Ste'

nombre[4:]
#'ven'

nombre[0:4:2]
# 'Se' <- el 2 representa que en pasos en 2 va ir extrayecdo los caracteres

nombre[::]
# 'Steven'

nombre[0::2]
# 'See'

nombre[::-1]
# 'nevetS'

yo cuando puso -1:

El mejor profe de Platzi :3

💡 Los slices son de gran utilidad para trabajar con textos de forma sencilla.

>>> name = "Brayan"
>>> name[:2:]

uuf que buen curso!

  • Slice, es cortar en rebanadas una cadena de texto.
  • variable[inicio:fin:paso], Crea una nueva cadena desde el inicio del indice hasta el fin del indice en pasos de paso.

Si no se especifica indice de inicio o fin, por defecto el inicio será 0 y el fin será la longitud de la cadena.

Si no se especifica el tamaño del paso, por defecto será 1. Si se especifica un tamaño negativo este ira de manera inversa.

Practicando lo aprendido me di cuenta de esto, podemos ejecutar muchos metodos en una sola linea eso es una locura!
Ahora bien, no se si sea una mala practica
![](

Excelente curso, en verdad eh aprendido mucho y apenas vamos comenzando con Lenguaje Python.

Resumen de la clase con el codigo

nombre = "Salvador"
print(nombre[0]) #Obtener el primer caracter
print(nombre[0:3]) #Obtener del primer al tercer caracter 
print(nombre[::2]) #Obtener caracteres saltando de 2 en 2 empezando del caracter 0
print(nombre[::-1]) #Obter de manera inversa
se me confunde a veces jeje, no se cuando es [::] y a veces cuando es [,] jeje creo que la coma va más con la función range
>>> nombre="Oscar"
>>> nombre
'Oscar'
>>> nombre[0]
'O'
>>> nombre[1]
's'
>>> nombre[0:3]
'Osc'
>>> nombre[:3]
'Osc'
>>> nombre[3:]
'ar'
>>> nombre[1:4]
'sca'
>>> nombre[1:4:2]
'sa'
>>> nombre[0:5:2]
'Ocr'
>>> nombre[::]
'Oscar'
>>> nombre[1::3]
'sr'
>>> nombre[::-1]
'racsO'
>>> 

como es que este hombre no tiene un 5.0 de estrellas si explica de maravilla, felicitaciones.
Vine para repasar python y termine sorprendido!!!

Lo mas interesante de todo esto es que esto mismo se aplica en las listas

interesante, voy a ver si puedo hacer que los slices sean variables que introduzca uno con un input. Por inventar jajaja

les comparto mis apuntes

""" 
upper sir ve para poner todas las letras en mayusculas
capitalize sirve para poner las primeras letras en mayusculas
strip elimina los espacios
lower pone todas las letras en minusculas
replace (x letra , por tal letra) reemplaza todas las letras que se pongan en la izquierda por todas las de la derecha
Indices [] sirven para indicar la posicion de un caracter, se inicia contando desde cero
len (nombre de la cadae, variable, etc.) sirve para contar cuantos caracteres hay
SLICES nombre_variable [Lugar donde se desee partir (0) : (3) lugar donde se desee terminar : (2) cada cuantas posiciones se desea avanzar ]
 """```

Que fácil es la estructura de poner los parámetros y recuperar segmentos de algún texto
También veo que tiene un buen programa para revisar la ortografía en este recuadro de texto, marca muy bien las faltas de ortografía.

Dato curioso:
También se puede recorrer la cadena con índices negativos.

Por ejemplo:

<code>

>>> nombre = "Francisco"
>>> nombre[-5:-1]
'cisc'
>>>

De esta manera nos regresa las ultimas 5 letras de la cadena, pero como el -1 es el ultimo elemento, este no se agrega en el ejemplo.

<h4>Slices de cadenas</h4>

En python se puede hacer slices de cadenas, para obtener una porción de la cadena original y poderla almacenar en variables o realizar diferentes funcionalidadaes.
La sintaxis es:

nombre = "Cristian"
nombre[0:3] #Esto retornará Cri
nombre[:3] #Esto retornará Cri también
nombre[3:] #Esto retornará stian
print(nombre[0:7:2]) #Retornará Cita, ya que hace saltos de 2

ya sabia varias cosas de python… pero el le pone mucho entusiasmo a enseñar así que me quede a verlos todos

¿Hay más cursos del profe Facundo?

Es un excelente profe, se me han hecho muy sencillas sus clases.

si mis profesores de universidad enseñarían con esa pasión con la que este hombre enseña , Amaría la universidad. Excelente curso.

  • variable[n:m]: obtengo las letras de la palabra desde el índice n hasta el índice m.

  • variable[:n]: obtengo las letras desde el inicio hasta el índice n.

  • variable[n:]: obtengo las letras desde el índice n hasta el final.

  • variable[n: m :x]: obtengo las letras desde n hasta m en salto de x.

  • variable[::]: obtengo las letras desde inicio a fin.

  • variable[n::x]: obtengo las letras desde el índice n hasta el final en saltos de x.

  • variable[::-1]: obtengo las letras desde el inicio hasta el fin en saltos de -1, revierte el orden de letras.

nombre ="Ella no te ama"
print (nombre[0:1])
print (nombre[0:2])
print (nombre[0:3])
print (nombre[0:4])
print (nombre[0:5])
print (nombre[0:6])
print (nombre[0:7])
print (nombre[0:8])
print (nombre[0:9])
print (nombre[0:10])
print (nombre[0:11])
print (nombre[0:12])
print (nombre[0:13])
print (nombre[0:14])

print(nombre[1:7:2])
print(nombre[8:])
print(nombre[0::11])
print(nombre[::-1])```

Buen curso, su forma de explicar hace que sea fácil entender.

Este curso me encanta es super digerible

Que manera de explicarlo profe! 🙌🏻
Super claro y muy bien ejemplificado.
Vamos con el reto 😄

Excelente Profesor y muy util lo que esta enseñando

que buena la clase

Slice nos permite interactuar con el texto y partirlo en fragmentos que le indiquemos y del tamaño que querramos, se usa asi: cadena[inicial:final:tamaño en saltos] por ejemplo, si tenemos como nombre="Octavio" nombre[0:4] da como resultado Octa nombre[:4], nombre[1:6:2]=cai

Una clase muy fluida y clara.

excelente clase

mucho amor por la profesión

Buen ejemplo para la explicacion !! 😀

Al igual que los previos comentarios, coincido.
El profesor Facundo tiene la capacidad innata de enseñar.
Su explicación es fácil de entender.

¡Muchas gracias!

Facundo es el mejor profesor que he visto en platzi, un total maestro, muchas gracias Facundo por la claridad con la que enseñas.

Sin duda la forma de enseñar de Facundo te inspira y engancha a querer seguir aprendiendo.

Comparto mis apuntes:

Información resumida de esta clase
#EstudiantesDePlatzi

  • Slices traducido es rebanadas
  • Puedo separar partes de caracteres en una cadena de caracteres usando Slice [ : ]
  • [ # de carácter donde queremos que inicie : # de carácter donde queremos que termine : # de pasos en lo que queremos que lo haga ]

Gracias por usar mi nombre de ejemplo… 😆
Ha sido excelente este curso, el profesor explica bastante bien cada tema!!

Te prendes si o si en este curso, lo explica tan bien y sencillo que es muy fácil entenderlo! Genio Facundo

Slice significa rebanadas, se emplea asi:
a[start:stop:step]

encontre estos metodos para cadenas 👇
30 metodos para cadenas

Esto súper útil, por ejemplo, yo le he usado para esto:

En México, hay un número de identificación que se llama RFC y un número de identidad poblacional que se llama CURP. En ambos números, los primeros 10 caracteres son los mismos.

Un posible uso es que se programe una regla de congruencia donde estos 10 primeros caracteres coincidan.

Algo muy sencillo en código:

rfc = 'PEPE070197R32'
curp = 'PEPE070197HGMG08'

if rfc[:10] == curp[:10]:
	print("Felicidades, ambos números son los mismos")
else:
	print("Por favor, revisa tus números")
# slices
matias = 'matias'
print(len(matias))

print(matias[0])
print(matias[0:3])
print(matias[0:6:2])

print(matias[:])
print(matias[::])
print(matias[::2])

slices: revanada de un string.

nombre[<indice>:<indice2>] : muestra del string desde <indice> hasta el valor anterior a <indice2>. El conteo de <indice> puede iniciar en 0, siendo el inicio del string.

nombre[:<indice>] : muestra del string desde el inicio del string hasta el valor anterior a <indice>.

nombre[<indice>:<indice2>:<# pasos>] : muestra desde <indice> hasta <indice2> con salteo de <# pasos>.

nombre[- <indice>] : El - indica mostrar  el carácter desde el final hasta inicio del string. El conteo inicia en -1, siendo el ultimo valor del string.

nombre[<indice>:- <indice2>] : muestra del string desde el <indice> hasta el valor anterior a - <indice2>.

nombre[<indice>:<indice2>:- <# pasos>] : muestra del string desde <indice> hasta <indice2> con salteo de <# pasos> desde el final hasta inicio del string.

Los slices funcionan de la siguiente manera

slice(start, stop, step)

**start (opcional): **número entero inicial donde comienza el corte del objeto. Predeterminado a Ninguno si no se proporciona.

stop: número entero hasta el que se realiza el corte. El corte se detiene en el índice de parada -1 (último elemento).

paso (opcional): valor entero que determina el incremento entre cada índice para el corte. El valor predeterminado es Ninguno si no se proporciona.

nombre = "Francisco"
nombre
"Francisco"
nombre[0 : 3) //Arranca desde el primer índice hasta llegar antes del 3° índice.
"Fra"
nombre[:3] //Va desde el principio hasta antes de llegar del 3° índice. Cómo no hay ningún parámetro en el primer lugar, se interpreta que arranca desde el principio.
"Fra"
nombre[1:7] //Arranca desde el índice 1 hasta llegar antes del 7.
"rancis"
nombre[1:7:2] //Arranca desde el índice 1 hasta llegar antes del 7, pero pasos de 2 en 2, ya que eso es lo que nos indica el 3! parámetro, el cual es 2.
nombre[1::3] //Arranca desde el índice 1 hasta el final del string (al no haber ningún 2° parámetro, significa que va hasta el final), pero en pasos de 3 en 3.
"rcc"
nombre[::-1] //Al no haber parámetro en los 2 primeros lugares, se interpreta que se arranca desde el inicio hasta el final, pero en pasos de 1 en 1 con la palabra al revés, porque es -1.
“ocsicnarF”

Resumen:

texto = "abcdefghijklmnopqrstuvwxyz"
print('' + texto)
print('Upper ' + texto.upper())
print('Capitalize' + texto.capitalize())
print('Lower ' + texto.lower())
print('Strip ' + texto.strip())
print('[0:3] ' + texto[0:3])  # Desde el indice 0 hasta antes del 3
print('[:3] ' + texto[:3])  # Desde el indice principio hasta antes del 3
print('[3:] ' + texto[3:])  # Desde el indice 3 hasta el indice final
print('[1:7] ' + texto[1:7])  # Desde el indice 1 hasta el indice 7
print('[::] ' + texto[::])  # Desde el indice principio al final
print('[1:20:2] ' + texto[1:20:1])  # Desde el indice 1 hasta el indice 20 en pasos de 2 en 2
print('[::-1] ' + texto[::-1])  # Desde el indice principio al final en pasos inversos
print('[1::3] ' + texto[1::3])  # Desde el indice 1 al final en pasos de 3

nombre = "mecz_code"

#Partición de cadenas de caracteres.
#Podemos
print(nombre[0:4])
#Obtenemos: mecz

#Podemos hacer particiones desde el inicio hasta un valor antes.
print(nombre[:4])
#Obtenemos: mecz

#Poder hacer particiones desde el final hasta una determianda posición.
print(nombre[0:])
#Obtenemos: mecz_code

#Podemos hacer particiones desde un número hasta otro, pero realizando
#un determinado números de salto.
print(nombre[1:9:2])
#Obtenemos: ezcd

#Podemos mostrar el nombre completo
print(nombre[::])
#Obtenemos: mecz_code

#Podemos mostrar el nombre al reves
print(nombre[::-1])
#Obtenemos: edoc_zcem

Asi como viste el ejemplo si aplicas el negativo a los otros dos indices tendrás esto
.
nombre = "Francisco"
nombre[::-1]
ocsucbarF
nombre[: - 1 :]
Francisc
nombre[-1::]
o
.
Obtendrás esos resultados

[email protected] si quieren saber en que indice esta la letra que estan buscando utilizen .find como ejemplo
letra = "daniel"
print(letra.find(“a”))

en pantalla sale el numero 1 que es la pocicion actual de la primera letra “a”

Conversor de monedas con conversión de cadena de caracteres a mayúsculas y restricción a tres caracteres.

# Espacio para definir fucniones

def conversor(moneda, monedas):
    cantidad = float(input('¿Cuantos ' + moneda +' tienes? : '))
    conversion = round(cantidad/monedas, 2)
    print('\n tienes $', conversion, ' dolares.\n')


# Código del programa

menu = """
Bienvenido al conversor de divisas 💰💵💴💶💷💲

1 para peso Colombiano COP
2 para peso Mexicanos MXN
3 para Eros EUR
4 para peso Argentínos ARS

"""
print(menu)

seleccion = int(input('Seleccione moneda de origen: '))

# USD/COP (29/10/21)
COP = 3758.5869

# USD/MXN (29/10/21)
MXN = 20.555271

# USD/EUR (29/10/21)
EUR = 0.86473736

# USD/ARS (31/10/21)
ARS = 99.684182

if not (seleccion <= 4 and seleccion > 0):
    nueva = input('Nueva moneda indique moneda (XYZ): ')
    nueva = nueva.upper()
    if len(nueva) == 3:
        valor = float(input('Valor de la moneda: '))
        conversor(nueva, valor)
    else:
        print('moneda no valida')
else:
    if seleccion == 1 :
        conversor('COP', COP)
    elif seleccion == 2 :
        conversor('MXN', MXN)
    elif seleccion == 3:
        conversor('EUR', EUR)
    elif seleccion == 4:
        conversor('ARS', ARS)

print('-- FIN --')
 

Slices [posicion_inicial_letra : posicion_final_letra : número_letras]

Slice -> Rebanadas -> Permiten dividir los caracteres de un string en n partes.

NOTA ACLARATORIA: Cuando se utiliza el segundo parámetro en un slice, por ejemplo mi_string[0:5], el 5 se refiere al índice de finalización, mas sin embargo, el elemento en este índice no será considerado.

Aprovecho para compartir un ejemplo con los conocimientos adquiridos hasta el momento en cuanto a la manupulación de strings:

#Working with strings
print('Working with strings (String methods) ***')
string = input('Input any string in any case convention: ')

uppercased_string = string.upper()
print(f'{string} ==uppercased=> {uppercased_string}')

lowercased_string = string.lower()
print(f'{string} ==lowercased=> {lowercased_string}')

capitalized_string = string.capitalize()
print(f'{string} ==capitalized=> {capitalized_string}')

stripped_string = string.strip()
print(f'{string} ==stripped=> {stripped_string}')

titled_string = string.title()
print(f'{string} ==titled=> {titled_string}')

string_first4 = string[0:4]
print(f'{string} ==First 4=> {string_first4}')

string_last4 = string[-4:]
print(f'{string} ==Last 4=> {string_last4}')

reversed_string = string[::-1]
print(f'{string} ==Reversed=> {reversed_string}')

print('END OF PROGRAM')

Michael de los Peaky Blinders enseña muy bien Python

Que buen profe!

Un 10 a tu devocion por enseñar como enseñas Facundo

Excelente clase y el curso genial de verdad Facundo muy bueno en lo que hace

de lejos, facundo es uno de los mejores profesores de platzi

Excelente Curso, muy entendible

Excelente tutor.
Explca excelentmente bien.

El profesor explica muy bien

excelente el curso

Hola amigos. ¿Alguien sabe por qué si escribo nombre[0:9:-1] no sale inverso el nombre?

muy buen curso!

Buenísimo, Master!

Cuando el tercer valor es negativo, el indice donde se inicia es el de mayor valor, y el siguiente será menor.

nombre='Harold'
nombre[4:1:-1]
'lor'

Super fácil de entender, gracias Facundo. Explicas super claro cada tema.
😃

Esta y la de funciones son mis clases favoritas hasta este momento

lo de la clase anterior demuestra que los strings trambien son listas tambien y que no son inmutables como dice el libro de joyanes 🤔👍

como dirian en argentina FACUNDO SOS GRANDE COMO PROFESOR!!!

Les dejo un link por si a alguno le sirve, donde podés probar los slices online 😉

https://www.w3schools.com/python/trypython.asp?filename=demo_string2

Rebanadas (slices) en los strings

En Python, los slices, traducidos al español como “rebanadas”, nos permiten dividir los caracteres de un string de múltiples formas. Otra operación que podemos realizar a una cadena es seleccionar solamente una parte de ella. Para ello se usa la notación [inicio:fin:paso] también en el nombre de la variable que almacena la cadena, donde:
• Inicio: es el índice del primer carácter de la porción de la cadena que queremos seleccionar.
• Fin: es el índice del último carácter no incluido de la porción de la cadena que queremos seleccionar.
• Paso: indica cada cuantos caracteres seleccionamos entre las posiciones de inicio y fin.
cadena = "Programa en Python"
cadena[0:8:1]

Codigo que calcule hasta la mitad del nombre!

nombre_a_partir = input('ingresa un nombre: ')

cantidad_de_letras = len(nombre_a_partir)

if cantidad_de_letras % 2 == 0:

    cantidad_de_letras_dividido_2 = int(cantidad_de_letras / 2)

elif cantidad_de_letras % 2 == 1:

    num1 = cantidad_de_letras / 3

    cantidad_de_letras_dividido_3 = int(cantidad_de_letras / num1)

nombre_a_partido = nombre_a_partir[0:cantidad_de_letras_dividido_2]

print(nombre_a_partido)

Slices - rebanadas
variable[desde este caracter : hasta este caracter : en esta cantidad de pasos]

Facundo debe hacer mas cursos de python!!!

#Esto me está gustando!

excelente el curso, al igual que el profesor muy bueno