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 )
Fundamentos de Programación y Python
Fundamentos de Programación con Python para Principiantes
Instalación y Uso Básico de Python en Windows y Mac
Semántica y Sintaxis en Programación Python
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manejo de Cadenas y Operaciones Básicas en Python
Tipos de Datos en Python: Enteros, Flotantes y Booleanos
Dominio de la función `print` en Python: usos y formatos avanzados
Operaciones matemáticas avanzadas en Python: módulo, potencia y más
Entrada de información y manejo de tipos de datos en Python
Colección y Procesamiento de Datos en Python
Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos
Copiar listas en Python sin compartir memoria con slicing
Manejo de Matrices y Tuplas en Python
Matrices en Juegos y Imágenes con Python
Diccionarios en Python: Uso y Manipulación de Datos
Control de Flujo en Python
Estructuras Condicionales en Programación: Uso de If, Else y Elif
Iteración y control de flujo con bucles en Python
Iteradores y Generadores en Python: Uso Eficiente de Memoria
Listas por comprensión en Python: creación y optimización de listas
Funciones y Manejo de Excepciones en Python
Funciones y Parámetros en Python: Crea una Calculadora Básica
Funciones Lambda en Python: Uso y Aplicaciones Prácticas
Recursividad en Python: Factoriales y Serie de Fibonacci
Manejo de Excepciones y Errores en Python
Programación Orientada a Objetos en Python
Programación Orientada a Objetos en Python: Clases y Métodos Básicos
Gestión de Biblioteca con Programación Orientada a Objetos
Herencia y Polimorfismo en Programación Orientada a Objetos
Programación Orientada a Objetos: Implementación de Clases y Herencia
Polimorfismo en Programación Orientada a Objetos
Herencia y Uso de la Función super() en Python
Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python
Lectura y escritura de archivos
Manipulación de Archivos TXT y CSV en Python
Manipulación de archivos CSV con Python: lectura y escritura
Manejo de Archivos JSON en Python para Aplicaciones Web y APIs
Biblioteca estándar de Python
Uso Eficiente de la Biblioteca Estándar de Python
Uso de las librerías OS, Math y Random en Python
Análisis de Datos de Ventas con Python y Statistics
Desarrollo del juego Batalla Naval en Python
Conceptos avanzados de Python
Programación Avanzada en Python: POO, Excepciones y Proyectos
Escritura de Código Pytónico y Buenas Prácticas en Python
Comentarios y Docstrings: Buenas Prácticas en Programación
Tiempo de vida y alcance de variables en Python
Anotaciones de Tipo en Python para Código Más Legible
Validación de Tipos y Manejo de Excepciones en Python
Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones
Decoradores
Decoradores en Python: Extiende Funcionalidades de Funciones
Uso de Decoradores Anidados y con Parámetros en Python
Decoradores en Programación Orientada a Objetos en Python
Métodos y estructura de clases en Python
Uso de Métodos Mágicos en Python
Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases
Ejecutar scripts Python con `if __name__ == '__main__'`
Metaprogramación en Python: Métodos `__new__` y `__init__`
Uso de *args y **kwargs en funciones de Python
Métodos y Atributos Privados y Protegidos en Python
Uso de Property en Python: Getter, Setter y Eliminación de Atributos
Métodos estáticos y de clase en Python
Programación concurrente y asíncrona
Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas
Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`
Asincronismo en Python con AsyncIO y Corrutinas
Sincronía y Concurrencia en Python: Teoría y Práctica
Creación de módulos y paquetes
Módulos y Paquetes en Python: Reutilización y Organización de Código
Uso de Paquetes y Subpaquetes en Python con Visual Studio Code
Publicación de Paquetes Python en PyPI
Proyecto final
Sistema de Gestión de Reservas en Python Avanzado
Sistema de Gestión de Reservas en Python Avanzado
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Copiar listas en Python sin compartir memoria con slicing
11/63Recursos
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.
¿Cómo evitar que dos listas apunten al mismo espacio de memoria?
Para evitar que dos variables apunten al mismo espacio de memoria, debemos crear una copia superficial de la lista original usando slicing. Por ejemplo:
- Crear una lista
Acon números del 1 al 5. - Asignar
B = Ay luego imprimir ambas listas muestra que ambas son idénticas. - Eliminar un elemento de
Atambién lo elimina deB.
¿Cómo usar slicing para crear una copia de una lista?
Podemos utilizar slicing para copiar una lista sin que ambas variables apunten al mismo espacio de memoria. Por ejemplo:
A = [1, 2, 3, 4, 5]
C = A[:]
Luego, verificamos los IDs de memoria:
print(id(A))
print(id(C))
Ambos IDs serán diferentes, lo que indica que C es una copia independiente de A.
¿Por qué es importante entender la asignación de memoria en listas?
En Python, a diferencia de otros lenguajes, podemos almacenar diferentes tipos de datos en una colección. Entender cómo funciona la memoria es crucial para evitar errores en el código, especialmente en aplicaciones del mundo laboral.
Aportes 43
Preguntas 2
Ordenar por:
```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.
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\[:]"
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"
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]`
El método slice en Python es como usar tijeras para cortar una lista. Imagina que tienes una fila de juguetes y solo quieres algunos de ellos. Con slice, puedes decirle a Python que te dé solo la parte de la lista que quieres, como si estuvieras cortando. Por ejemplo, si tienes 5 juguetes y solo quieres el segundo y el tercero, puedes usar slice para obtener solo esos. Así, no tocas el resto de la fila, solo obtienes lo que necesitas.
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 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
Con respecto al método Slice y la técnica slicing (mencionada en esta clase y en la clase de listas), hay una oportunidad de mejora.
Estamos nombrando método slice, para hacer referencia a la técnica Slicing. Sin embargo, ni en esta clase, ni en la clase anterior de listas, se mencionó el método Slice "slice()"
Cuando asignamos una variable con una lista a otra variable, por ejemplo a=b, no solo le asignamos los valores, si no tambien el espacio de memoria. Para evitar esto se usa el método slice
El espacio donde se guardan los objetos de python como listas, variables, etc, se llama heap, mientras que el stack en donde se guardan los objetos mas pequeños y las referencias.
La razon porque python usa heap para objetos grandes y las referencias en el stack, es para evitar redundar objetos grandes en memoria y ahorrar espacio
Para que `a` y `b` sean diferentes, debes usar el método de slicing. Cuando haces `b = a`, ambas variables apuntan al mismo espacio en memoria. Para crear una copia independiente, usa `b = a[:]`, que copia todos los elementos de `a` en `b`. Ahora, cualquier modificación en `a` no afectará a `b`. Por ejemplo:
```python
a = [1, 2, 3, 4, 5]
b = a[:] # Copia independiente
a.remove(1) # Modificar solo a
print(a) # [2, 3, 4, 5]
print(b) # [1, 2, 3, 4, 5] - sigue igual
```
Esto garantiza que `a` y `b` tendrán contenidos distintos.
Creo que la analogia mas parecida que logro encontrar es por ejemplo lo que pasa como cuando igualamos el valor de una celda en excel.
```js
a = [1,2,3]
b = a.copy()
print(a)
print(b)
a.append(4)
print(a)
print(b)
```
lo hice utilizando copy(), me resulto mas facil lista1 = \[1,2,3,4,5]lista2 = lista1.copy()lista2.append(6)print(lista1)print(lista2)print(id(lista1))print(id(lista2))```js
lista1 = [1,2,3,4,5]
lista2 = lista1.copy()
lista2.append(6)
print(lista1)
print(lista2)
print(id(lista1))
print(id(lista2))
```
Las diferencias entre tuplas y listas en Python son las siguientes:
1. **Mutabilidad**: Las listas son mutables, lo que significa que puedes modificar, agregar o eliminar elementos después de su creación. Las tuplas son inmutables; una vez creadas, no puedes cambiar su contenido.
2. **Sintaxis**: Las listas se definen con corchetes `[]`, mientras que las tuplas se definen con paréntesis `()`.
3. **Uso**: Las listas son ideales para colecciones de elementos que pueden cambiar, mientras que las tuplas son más adecuadas para datos que no deberían cambiar, como coordenadas o datos fijos.
4. **Rendimiento**: Las tuplas suelen ser más ligeras y rápidas que las listas debido a su inmutabilidad.
```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!
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
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?