Método slice

Otra forma de hacer una copia es mediante el método .copy() implementado en las listas:

lista1 = [1,2,3,4,5]
lista2 = lista1.copy()

lista2.append( 6 )

print( lista1 )
print( lista2 )

```js # Lista de ejemplo lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # Ejemplos de slicing sublista1 = lista[2:5] sublista2 = lista[:4] sublista3 = lista[5:] sublista4 = lista[::2] sublista5 = lista[1:7:2] # Slicing con índices negativos sublista6 = lista[-5:] sublista7 = lista[:-5] sublista8 = lista[-8:-2:2] # Salida de resultados print("Lista original:", lista) print("Sublista del índice 2 al 4:", sublista1) print("Sublista desde el inicio al índice 3:", sublista2) print("Sublista desde el índice 5 al final:", sublista3) print("Sublista con paso de 2:", sublista4) print("Sublista del índice 1 al 6 con paso de 2:", sublista5) print("Últimos 5 elementos:", sublista6) print("Todos menos los últimos 5:", sublista7) print("Sublista del índice -8 al -3 con paso de 2:", sublista8) ```xplicación del Código 1. **Lista de Ejemplo**: Se define una lista de ejemplo con 10 elementos. 2. **Slicing Básico**: Se crean sublistas utilizando diferentes combinaciones de índices de inicio, fin y paso. 3. **Slicing con Índices Negativos**: Se muestran ejemplos de cómo utilizar índices negativos para acceder a elementos desde el final de la lista. 4. **Salida de Resultados**: Se imprimen las sublistas resultantes para visualizar los efectos de cada operación de slicing. Este script te proporciona una comprensión completa de cómo utilizar el método `slice` para manipular listas en Python.

El slicing no crea copias de los elementos de la lista original. En su lugar, crea una vista (en el caso de listas de Python 3.x) o una nueva lista con referencias a los elementos de la lista original. Esto es eficiente en términos de memoria y tiempo, especialmente cuando se trabaja con listas grandes.


1. **Sintaxis básica:** * La sintaxis general para crear un slice en Python es la siguiente:secuencia\[inicio:fin:paso] * **inicio**: Índice donde comienza el slice (incluido). * **fin**: Índice donde termina el slice (excluido). * **paso**: Tamaño del incremento entre elementos del slice (opcional). 2. **Ejemplos de uso**:Supongamos que tenemos una lista de números:numeros = \[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * **Copia completa de la lista**:resultado = numeros\[:] \# Resultado: \[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * **Obtener los primeros tres elementos**:primeros\_tres = numeros\[:3] \# Resultado: \[0, 1, 2] * **Obtener todos los elementos desde el tercer elemento en adelante**:desde\_tercero = numeros\[2:] \# Resultado: \[2, 3, 4, 5, 6, 7, 8, 9] * **Obtener todos los elementos con un paso de 2**:con\_paso\_dos = numeros\[::2] \# Resultado: \[0, 2, 4, 6, 8] * **Índices negativos**: Podemos usar índices negativos para referirnos a elementos desde el final de la secuencia:ultimos\_tres = numeros\[-3:] \# Resultado: \[7, 8, 9] primeros\_salvo\_tres = numeros\[:-3] \# Resultado: \[0, 1, 2, 3, 4, 5, 6] * **Modificar valores con Slices**: También podemos usar Slices para modificar valores en una secuencia:frutas = \["manzana", "banana", "cereza", "dátil", "uva"] frutas\[1:3] = \["pera", "naranja"] \# Reemplaza "banana" y "cereza" por "pera" y "naranja"

Notas: -Si queremos tener dos listas con los mismos elementos, digamos que tenemos la lista a y queremos pasar sus datos a b, si se hace "b = a" se harán las dos listas idénticas pero tendrán en mismo id, entonces si se modifica algo en a repercutirá en b, para evitar esto hay que hacer "b = a\[:]"

El método `slice()` en programación, especialmente en lenguajes como Python o JavaScript, sirve para cortar o extraer una parte de una secuencia, como una lista o una cadena, sin modificar el original. En resumen, `slice()` te ayuda a obtener solo una parte de los datos, fácil y rápido.


Si hacemos un .append a la variable b, también cambia la a. `a = [1, 2, 3, 4, 5] ` `b = a ` `print(a) # [1, 2, 3, 4, 5]` `print(b) # [1, 2, 3, 4, 5]` `a.append(6)` `print(a) # [1, 2, 3, 4, 5, 6]` `print(b) # [1, 2, 3, 4, 5, 6]` `b.append(10)` `print(a) # [1, 2, 3, 4, 5, 6, 10] ` `print(b) # [1, 2, 3, 4, 5, 6, 10]`

"En algunos lenguajes de programación, existe el concepto de paso por valor y paso por referencia. El paso por referencia consiste en apuntar, a través de una variable, hacia un valor almacenado en memoria que es compartido con otra variable previamente asignada. Por lo tanto, los cambios que sufra el valor en una variable también se reflejarán en la otra, ya que ambas apuntan al mismo espacio en memoria. Sin embargo, en Python, el comportamiento es un poco diferente: aunque no implementa estrictamente el paso por valor o por referencia, los objetos mutables como listas o diccionarios pueden ser modificados a través de una referencia, lo que afecta a todas las referencias que apuntan a ese objeto, mientras que los objetos inmutables no se ven afectados de la misma manera."

Un excelente repaso gracias


```python print("--------------------------------------------------------------------------------------------------") print("Cambio de clase - Metodo SLICE") print("--------------------------------------------------------------------------------------------------") #Metodo SLICE listA = [34, 56, 78, 23, 12, 90, 44, 67, 89, 21, 11, 35, 50, 72, 60] listB = listA print(listA) print(listB) del listA[0] #Se mando a borrar en la "listA", pero se borro en las dos por que mabas ocupa y comparten el mismo lugar en memoria print(listA) print(listB) print(id(listA)) print(id(listB)) #Como vemos ambas estan compartiendo el mismo espacio en memoria, por eso su numero es el mismo #Para que esto no suceda es que se utiliza el METODO "SLICE" listC = listA[:] print(id(listA)) print(id(listB)) print(id(listC)) #Si nos damos cuenta el espacio en memoria ya cambio listA.append(89) print(listA) print(listB) print(listC) #podemos ver que aqui no se agrego la modificacion print(id(listA)) print(id(listB)) print(id(listC)) # aqui vemos wue mantiene el espacio de memoria tambien diferente ```print("--------------------------------------------------------------------------------------------------")print("Cambio de clase - Metodo SLICE")print("--------------------------------------------------------------------------------------------------")#Metodo SLICElistA = \[34, 56, 78, 23, 12, 90, 44, 67, 89, 21, 11, 35, 50, 72, 60]listB = listAprint(listA)print(listB)del listA\[0] #Se mando a borrar en la "listA", pero se borro en las dos por que mabas ocupa y comparten el mismo lugar en memoriaprint(listA)print(listB)print(id(listA))print(id(listB)) #Como vemos ambas estan compartiendo el mismo espacio en memoria, por eso su numero es el mismo#Para que esto no suceda es que se utiliza el METODO "SLICE"listC = listA\[:]print(id(listA))print(id(listB)) print(id(listC)) #Si nos damos cuenta el espacio en memoria ya cambio listA.append(89)print(listA)print(listB) print(listC) #podemos ver que aqui no se agrego la modificacion print(id(listA))print(id(listB)) print(id(listC)) # aqui vemos wue mantiene el espacio de memoria tambien diferente


Estoy obsesionado con este curso. Gracias Platzi!

Yo soy de ventas y quise checar esto para aprender algo nuevo, pero no especifican bien bien, por ejemplo no entiendo a que te refieres con id(a)... así que no entendí.

✅

En java esto pasa con todos los objetos (Instancia de una clase).

No se si esto es relevante aquí pero en resumen habla de copiar por referencia vs copiar por valor. Vengo de JS y en su momento me costo entenderlo pero aquí esta explicado perfectamente

Mas o menos así lo entendí# Lista originalnumbers = \[1, 2, 3, 111, 87, 4, 5] \# Crear una copia superficial de la listanumbers\_copy = numbers\[:] \# Modificar la lista originalnumbers\[0] = 99 \# Imprimir ambas listas para ver la diferenciaprint("Lista original:", numbers)print("Copia de la lista:", numbers\_copy) ```js # Lista original numbers = [1, 2, 3, 111, 87, 4, 5] # Crear una copia superficial de la lista numbers_copy = numbers[:] # Modificar la lista original numbers[0] = 99 # Imprimir ambas listas para ver la diferencia print("Lista original:", numbers) print("Copia de la lista:", numbers_copy) ```

La expresión slicing hace referencia a la **operación por medio de la cual se extraen elementos de una secuencia, tal como una lista o una cadena de caracteres**.

Así guardo mis apuntes para poder comprender mejor el proceso. Por si le sirve a alguien, lo dejo por acá :) ```python # Métido Slice # Cuando asignamos una lista a una nueva variable, por ejemplo, B = A, no estamos creando una copia independiente. Ambas variables apuntan al mismo espacio de memoria. Así, cualquier cambio en A se reflejará en B. a = [1,2,3,4,5] b = a print ('Lista A:', a) print ('Lista B:', b) del a [0] # Al eliminar se eliminará en ambas listas ya que tienen el mismo id en memoria print ('Lista A:', a) print ('Lista B:', b) # id me permite conocer cual es el codigo de cada varable dentro de la memoria print (id(a)) print (id(b)) c = a [:] # Slice!! Añadimos '[:]', '[:X]','[X:]' o '[X:X]' (dependiendo de los elementos que queramos traer de la lista inicial) y se genera una nueva lista con un id diferente print (id(a)) print (id(b)) print (id(c)) # Verás que tiene un id distinto # Si ahora eliminamos un elemento de la lista, no realizará cambios en C ya que está tiene un id diferente del a [-1] print ('Lista A:', a) print ('Lista B:', b) print ('Lista C:', c) # Sucede igual si añadimos un elemento a la lista a.append('Elemento Adicional') print ('Lista A:', a) print ('Lista B:', b) print ('Lista C:', c) ```

El método slice me permite trabajar en la misma variable y poderla gardar en otra con una "identificación" diferente.

```js #slice para copiar sin dirigirte al mismo espacio de memoria print (">>>>>>>>>>>>>>> slice") a = [1,2,3,4,5] b = a print (a) print (b) print (id(a)) print (id(b)) #aquí vemos que el slice id es el mismo] c = a[:] print (id(a)) print (id(b)) print (id(c)) # aquí se genera una clase diferente dentro de una colección a.append(6)# por que el append agrea un 6 a "a" y "b" perp a "c" ya no le tocó print ((a)) print ((b)) print ((c)) ```mi codigo comentado ```js ```

O método `slice()` em JavaScript é utilizado para copiar uma parte de um array ou string, retornando um novo array ou string sem modificar o original. Ele aceita dois parâmetros: o índice inicial (inclusivo) e o índice final (exclusivo). Se apenas o índice inicial for fornecido, o método copiará desde esse ponto até o final do array ou string. Aqui está um exemplo de uso com um array: ```javascript let array = \[1, 2, 3, 4, 5]; let novoArray = array.slice(1, 4); console.log(novoArray); // \[2, 3, 4] console.log(array); // \[1, 2, 3, 4, 5] (o array original não é modificado) ``` E com uma string: ```javascript let string = "Olá, mundo!"; let novaString = string.slice(4, 9); console.log(novaString); // " mundo" console.log(string); // "Olá, mundo!" (a string original não é modificada) ``` \### Parâmetros: 1\. \*\*Índice Inicial:\*\* Define o ponto de início da fatia. Se for negativo, indica a posição a partir do final do array/string. 2\. \*\*Índice Final:\*\* Define o ponto de término da fatia. Se omitido, a fatia vai até o final do array/string. Se negativo, indica a posição a partir do final, mas não inclui o valor no resultado. \### Observações: \- Se o `índice inicial` for maior ou igual ao comprimento do array/string, o método retorna um array/string vazio. \- Se o `índice final` for menor ou igual ao `índice inicial`, o método também retorna um array/string vazio. Este método é muito útil quando você deseja trabalhar com cópias de partes de arrays ou strings sem alterar o original.


<https://github.com/iecgerman/10002-python/blob/master/clase11.py>

pero pq el video se llama metodo slice , si nunca lo uso a.slice(start,end,step)

print("--------------------------------------------------------------------------------------------------")print("Cambio de clase - Metodo SLICE")print("--------------------------------------------------------------------------------------------------")#Metodo SLICElistA = \[34, 56, 78, 23, 12, 90, 44, 67, 89, 21, 11, 35, 50, 72, 60]listB = listAprint(listA)print(listB)del listA\[0] #Se mando a borrar en la "listA", pero se borro en las dos por que mabas ocupa y comparten el mismo lugar en memoriaprint(listA)print(listB)print(id(listA))print(id(listB)) #Como vemos ambas estan compartiendo el mismo espacio en memoria, por eso su numero es el mismo#Para que esto no suceda es que se utiliza el METODO "SLICE"listC = listA\[:]print(id(listA))print(id(listB)) print(id(listC)) #Si nos damos cuenta el espacio en memoria ya cambio listA.append(89)print(listA)print(listB) print(listC) #podemos ver que aqui no se agrego la modificacion print(id(listA))print(id(listB)) print(id(listC)) # aqui vemos wue mantiene el espacio de memoria tambien diferente```js print("--------------------------------------------------------------------------------------------------") print("Cambio de clase - Metodo SLICE") print("--------------------------------------------------------------------------------------------------") #Metodo SLICE listA = [34, 56, 78, 23, 12, 90, 44, 67, 89, 21, 11, 35, 50, 72, 60] listB = listA print(listA) print(listB) del listA[0] #Se mando a borrar en la "listA", pero se borro en las dos por que mabas ocupa y comparten el mismo lugar en memoria print(listA) print(listB) print(id(listA)) print(id(listB)) #Como vemos ambas estan compartiendo el mismo espacio en memoria, por eso su numero es el mismo #Para que esto no suceda es que se utiliza el METODO "SLICE" listC = listA[:] print(id(listA)) print(id(listB)) print(id(listC)) #Si nos damos cuenta el espacio en memoria ya cambio listA.append(89) print(listA) print(listB) print(listC) #podemos ver que aqui no se agrego la modificacion print(id(listA)) print(id(listB)) print(id(listC)) # aqui vemos wue mantiene el espacio de memoria tambien diferente ```

```python list_1 = [1,2,3,[4,5]] list_2 = list_1[:] # Se crea la copia list_2[2] = "Hello" # Esto solo cambia en list_2, todo bien list_2[3][0] = "World" # Pero esto cambia en ambas listas de nuevo print(list_1) print(list_2) ```La forma `[:]` y el método `copy()` de las listas en python crean un shallow copy osea un copia superficial. Podriamos cambiar todos los elementos superficiales de la copia sin alterar los elementos de la lista original pero si intentamos cambiar elementos de listas internas, estos cambian en ambos lados.

```python # Cuando creamos una variable que este apuntando a una ya creada, la informacion de esta segunda variable sera la misma de la primera, ejemplo: inf = [24,"Dia",33,"Noche",77,"Tarde"] inf2 = inf print(inf) print(inf2) # Si queremos que las modificaciones de la variable 1, no afecten a la variable 2, debemos agregar a la variable nueva un Metodo Slice "[:]" (Aqui le estamos ordenando a la variable que copie el mismo contenido de la variable 1, pero que la guarde en otro lugar independiente) ejemplo: inf = [24,"Dia",33,"Noche",77,"Tarde"] inf2 = inf inf3 = inf[:] inf.append("Mañana") print(inf) print(inf2) print(inf3) # En este ejemplo agregamos algo adicional en la lista 1 y en la 3, no cambio su contenido. # Para revisar en donde esta almacenada la iformacion de cada variable podemos imprimir en metodo "id". ejemplo inf = [24,"Dia",33,"Noche",77,"Tarde"] inf2 = inf inf3 = inf[:] print(id(inf)) print(id(inf2)) print(id(inf3)) ```

No se si es idea mía pero en este video sentí como si se hubieran obviado algunas explicaciones. Incluso en el programa que realiza aparece como el 8\_2.

Método slice **Sintaxis básica:** La sintaxis general para crear un slice en Python es la siguiente: ```js secuencia[inicio:fin:paso] ```**- inicio**: Índice donde comienza el slice (incluido). **- fin**: Índice donde termina el slice (excluido). **- paso**: Tamaño del incremento entre elementos del slice (opcional). **Ejemplos de uso**: Supongamos que tenemos una lista de números: ```js numeros = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ```**Copia completa de la lista**: ```js resultado = numeros[:] # Resultado: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ``` **Obtener los primeros tres elementos**: ```js primeros_tres = numeros[:3] # Resultado: [0, 1, 2] ```**Obtener todos los elementos desde el tercer elemento en adelante**: ```js desde_tercero = numeros[2:] # Resultado: [2, 3, 4, 5, 6, 7, 8, 9] ```

Pensaba que esto solo pasaba con los diccionarios