A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Tuplas

21/31
Recursos

Aportes 167

Preguntas 19

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Las tuplas al igual que las listas en Python son secuencias pero las tuplas son secuencias inmutables (eso significa que no se pueden modificar) de objetos.

驴C贸mo identificar una tupla en Python?
Las tuplas en Pyhton poseen siguiente sintaxis:

tuple_name = ('first_value', 2, 'u_can_add_ints')

Mientras que las listas en Python tienen esta sintaxis:

list_name = [1,'2', 3]

Como pueden apreciar, para la asignaci贸n de las tuplas, el contenido debe ir 鈥渆mpaquetado鈥 mediante par茅ntesis 鈥()鈥, mientras que para las listas, se empaquetan en corchetes 鈥淸]鈥.

Para declarar una tupla en Python se realiza lo siguiente:

tuple_name = ()

El contenido de la tupla pueden ser de tipo int, float y string.

Nota: en caso de que tu tupla s贸lo contenga un valor, debes agregar una comar 鈥,鈥, por ejemplo:

En caso de contener un int:

tuple_name = (1,) 

En caso de contener un float:

tuple_name = (2.0,) 

En caso de contener un string:

tuple_name = ('string',) 

Tuplas

  1. Una tupla consiste en objetos inmutables. (Objetos que no pueden cambiar despu茅s de la creaci贸n)

  2. Una tupla tiene poca memoria.

  3. Una tupla se almacena en un solo bloque de memoria.

  4. Crear una tupla es m谩s r谩pido que crear una lista.

  5. Un elemento en una tupla no se puede quitar ni reemplazar.

Listas

  1. Una lista consta de objetos mutables. (Objetos que se pueden cambiar despu茅s de la creaci贸n)

  2. La lista tiene una gran memoria.

  3. La lista se almacena en dos bloques de memoria (uno es de tama帽o fijo y el otro es de tama帽o variable para almacenar datos)

  4. Crear una lista es m谩s lento porque se necesita acceder a dos bloques de memoria.

  5. Un elemento en una lista se puede eliminar o reemplazar.

fuente

Quiero a帽adir que las tuplas tambi茅n se pueden representar sin par茅ntesis

my_tuple = 1, 2, 3
print(my_tuple)

o

my_tuple = (1, 2, 3)
print(my_tuple)

Tuplas:

  • Secuencias inmutables de objetos, osea son listas de valores que no podemos modificar.

  • Pueden ser de tipo

    • Entero int (1,)
    • Flotante float (2.0,)
    • String (鈥楽tring鈥)
    • Booleano (true)
  • Las tuplas al igual que los strings podemos acceder por indice

my_tuple(1,2,3)
my_tuple[0] = 1
my_tuple[1] = 2
my_tuple[2] = 3

  • Podemos desempaquetar tuplas, para ello hay que definir ciertas variales para reasignarlas.
    x, y, z = my_tuple
    x = 1 y=2 z=3

Les comparto una imagen donde se explica un poco m谩s la diferencia entre tuplas, listas, conjunto y diccionario por si alguno tiene dudas al respecto 馃槃

En el siguiente enlace m谩s ejemplos sobre las tuplas : https://www.w3schools.com/python/python_tuples.asp

La principal diferencia entre una tupla y una lista, es que los valores de la lista se pueden modificar a lo largo del c贸digo, en un tupla no. La ventaja que tiene usar tuplas es que ocupa menos espacio en memoria a diferencia de la lista, ya que en la lista ocupamos dos bloques de memoria para que pueda ser mutable.

<"""
Tuplas 

son secuencias inmutables de objetos

A diferencia de las cadenas pueden contener cualquier tipo de objetos

Pueden utilizarse para devolver varios valores en una funcion
"""

#creacion de una tupla vacia
my_tuple = ()
print(type(my_tuple))

my_tuple = (1, 'dos' , True)

#se puede acceder a las duplas por el index
print(my_tuple[0])
print(my_tuple[1])
print(my_tuple[2])

#no se pueden modificar las tuplas, provoca error
# my_tuple[0] = 2

#no se pueden modificar pero si pueden apuntar a otro lugar de memoria
my_tuple = (1)

#tipo de objeto int debido a que no se uso sintaxis adecuada
print(type(my_tuple))

#los items deberan estar separados por comas
my_tuple = (1,)
print(type(my_tuple))

#tuplas pueden sumarse
#la variable no se modifica, apunta a otro lugar de memoria
my_other_tuple = (2,3,4)
my_tuple += my_other_tuple
print(my_tuple)

#se pueden asignar los items de las tuplas a otras variables
x, y, z = my_other_tuple
print (x,y,z)

#se pueden asignar el retorno de las funciones a una tupla
def coordenadas():
    return(5,4)

coordenada = coordenadas()
print(coordenada)

#asignar los items de la tupla a variables x y
x , y = coordenada

print(x, y)>

Las tupas son inmodificables pero si reasignables

Las Tuplas no se pueden modificar, pero si se pueden reasignar.

Tuplas = Lista de objetos inmutables. No se puede modificar los elementos de la tupla.

Si se puede modificar TODA la tupla por otra tupla.

Son muy utiles para almacenar listas de objetos de distinto tipo de dato.

Una caracteristica muy util es desempaquetar una tupla, sin necesidad de un ciclo.

Pienso que las tuplas sirven para crear como un array de constantes, o como dice David devolver valores de funciones en diferentes variables, que buena utilidad la de las tuplas.

print("Me estoy enamorando de Python.")

Syntactically, a tuple is a comma-separated list of values:

>>> t = 'a', 'b', 'c', 'd', 'e'

Although it is not necessary, it is common to enclose tuples in parentheses to help us quickly identify tuples when we look at Python code:

>>> t = ('a', 'b', 'c', 'd', 'e')

To create a tuple with a single element, you have to include the final comma:

>>> t1 = ('a',) 
>>> type(t1) 
<type 'tuple'>

Tomado del libro 鈥淧ython for everybody鈥, p谩gina 117.

As铆 que esto tambi茅n es v谩lido.

>>> t = 3,
>>> type(t)
<class 'tuple'>

Particularmente esto me causo mucho conflicto, no lo hab铆a visto en otros lenguajes, pero la raz贸n es porque el constructor de una tupla es la coma. 隆Woooooo!

Listas

  • Colecci贸n de datos ordenados
  • Pueden contener objetos de diferentes tipos
  • Mutables
  • Accesibles mediante un indice
list = ["mango", "fresa", "manzana]

Arreglo

  • Colecci贸n de datos ordenados
  • Sus objetos deben ser del mismo tipo
  • Mutable
  • Accesible mediante un indice
  • En python requiere importar la libreria para usarlas
import array as arr
a = arr.array ('i', [1, 2, 3])

Tupla

  • Colecci贸n de datos no ordenados
  • Puede contener objetos de diferentes tipos
  • No mutables
  • Accesible mediante un indice
tuple = ("mango", "fresa", "manzana")

https://www.geeksforgeeks.org/python-list-vs-array-vs-tuple/

Diganme si tengo al mal 馃槖

Para 鈥渕odificar鈥 una Tupla

mi_tupla = (1, 'dos', True)
mi_lista = list(mi_tupla)
print("Antes: ",mi_tupla)
mi_lista[2] = 'III' 
mi_tupla = tuple(mi_lista)
print("Despues: ",mi_tupla)

En realidad se crea una lista a partir de una tupla y luego se crea una tupla a partir de una lista (modificada).

Tuplas:

  • Inmutables
  • Aceptan cualquier tipo de datos
  • Acepta mas tuplas anidadas dentro de otra.
  • Es indexable.
>>> my_tuple = 1, [1,2], {1:"one", 2: "two"}, (1,2,"three")
>>> type(my_tuple)
<class 'tuple'>
>>> my_tuple
(1, [1, 2], {1: 'one', 2: 'two'}, (1, 2, 'three'))
>>>

Qu茅 son las tuplas 馃悕
En Python, una tupla es un conjunto ordenado e inmutable de elementos del mismo o diferente tipo.
Pueden utilizarse para devolver varios valores en una funci贸n.
Las tuplas se representan escribiendo los elementos entre par茅ntesis y separados por comas.

>>> (1, "a", 3.14)
(1, 'a', 3.14)

En realidad no es necesario escribir los par茅ntesis para indicar que se trata de una tupla, basta con escribir las comas, pero Python escribe siempre los par茅ntesis:

>>> 1, "a", 3.14
(1, 'a', 3.14)

La funci贸n len() devuelve el n煤mero de elementos de una tupla:

>>> len((1, "a", 3.14))
3

Una tupla puede no contener ning煤n elemento, es decir, ser una tupla vac铆a.

>>> ()
()
>>> len(())
0

Una tupla puede incluir un 煤nico elemento, pero para que Python entienda que nos estamos refiriendo a una tupla es necesario escribir al menos una coma.
El ejemplo siguiente muestra la diferencia entre escribir o no una coma. En el primer caso Python interpreta la expresi贸n como un n煤mero y en el segundo como una tupla de un 煤nico elemento.

>>> (3)
3
>>> (3,)
(3,)

Python escribe una coma al final en las tuplas de un 煤nico elemento para indicar que se trata de un tupla, pero esa coma no indica que hay un elemento despu茅s:

>>> (3,)
(3,)
>>> len((3,))
1

Con las tuplas tambi茅n las podemos agregar, reasignandolas de la siguiente manera

>>>my_tuple = (1, )
>>> my_other_tuple = (2, 3, 4)
>>> my_tuple += my_other_tuple
>>> print(my_tuple)
(1, 2, 3, 4)

Tambi茅n podemos desempaquetar una tupla de la siguiente manera:

>>> x, y, z = my_other_tuple
>>> x
2
>>> y
3
>>> z
4

Regresar los valores de una funci贸n

>>> def coordenadas():
...     return(5,4)
>>> coordenada = coordenadas()
>>> coordenada
(5, 4)
>>> x, y = coordenadas()
>>> x
5
>>> y
4

Unpacking
El desempaquetado (unpacking) es una caracter铆stica muy especial de Python que nos permite asignar un conjunto de valores a un conjunto de variables con la condici贸n de que la cantidad de variables tiene que ser siempre igual a la cantidad de valores. Por ejemplo, una tupla como (10, 20, 30) la podr铆amos asignar a las variables x, y, z respectivamente utilizando unpacking de la siguiente forma:

Entiendo que el tema de las listas, tuplas, conjuntos y diccionario es un tema amplio para estudiar que merece el revisarse constantemente. Son objetos poderosos para trabajar el registro de los datos. Consult茅 una info b谩sica y para comenzar, en esta p谩gina: https://j2logo.com/python/tutorial/tipos-de-datos-basicos-de-python/#tipos-datos-otros

TUPLAS
Son inmutables, es decir no pueden ser mutados los objetos dentro de una tuppla, solo se puede realizar una re-asignaci贸n

Tambien se pueden devolver mas de un valor en las funciones !

def cordenadas():
    return 4,5
    
x = cordenadas()

print (x)

x,y = cordenadas()

print (x,y)

y,_ = cordenadas()

print (y)```

Un dato curioso de las tuplas es que se calculan mas r谩pido que las listas

Cada clase que tomo me encanta m谩s que la anterior. 馃槉
Gracias profesor Aroesti!

馃槏 ahora todo tiene sentido!

Hice algo que me pareci贸 un buen ensayo.
Saludos.

def saludo ():
    print (f'\n\nListo {dataPlayer[0]}!!!')

def codGen ():
    codUser = (f'{dataPlayer[0][:3]}'+f'{dataPlayer[1][:1]}'+f'{dataPlayer[2][1::2]}'+f'{dataPlayer[3][:1]}'+f'{dataPlayer[4][1:]}')
    print (f'\n\nTU CODIGO DE USUARIO ES: {codUser}')

print ('Hola.\nVamos a registrar tus datos')
user = input ('Nombre de usuario: ')
age = input ('Edad actual: ')
country = input ('Residencia actual: ')
wins = input ('Victorias de Equipo: ')
defeats = input ('Derrotas de Equipo: ')


dataPlayer = (user, age, country, wins, defeats)

codGen ()
saludo()

print (f'\nDatos Registrados:\nUsuario: {dataPlayer[0]}\nEdad: {dataPlayer[1]}\nPais: {dataPlayer[2]}\nVictorias: {dataPlayer[3]}\nDerrotas: {dataPlayer[4]}\nGracias.')

# Tuplas
# Son datos que jamas se pueden cambiar
# Pueden contener cualquier tipo de dato que quieras
# Pueden utilizarse para devolver valores obtenidos mediante una funcion
# Se puede reasignar la tupla creada para la variable para insertar otros valores pero no podemos de por si modficar los datos que tengan en una posicion dada de la tupla

# Ejemplo de tutpla
tupla_inicial = ()

tupla_reasignable = ()
# Lo curioso que nosotros podemos recorrer la tupla como una cajita(array) por el cual obtener los datos desde la posicion inicial de este a partir desde el 0 a n elementos que tengamos dentro de la tupla
tupla_reasignable = ('hola', 'como estas', 'adios')

print(tupla_reasignable[2])

primerNumeroTupla = (1,)
sumaDeTupla = (2,3,4)

primerNumeroTupla += sumaDeTupla

print(primerNumeroTupla)

# Desestructurar objetos
# variables por las posicion de los objetos recordar que es una cajita(array)
# ej: 
# cajita = (1,2,3,4,5)
# destructuracion
# primerNumero,segundoNumero,tercerNumero,cuartoNumero = cajita
# print(primerNumero) = 1 Ta Da!!

# Tener en mente que estas variables van desde la ultima posicion en adelante 
x, y, z = sumaDeTupla

print(x)
print(y)
print(z)```

Muy buenos los comentarios de los compa帽eros. Siempre se hallan cosas interesantes en los comentarios.
Saludos a todos.

No se modifican, se crean nuevas. Excelente.

Esto es poderoso, ya que puedo tomar un registro (una tupla) de una base de datos, colocarlo en una tupla y procesarlo, con una m铆nima cantidad de transformaciones.

Super interesante estas tuplas, muy util para crear arreglos que tengan distintos valores de distintos tipos de datos, fue lo que mas me llamo la atenci贸n.

Para complementar el concepto me pareci贸 bastante interesante este post sobre las diferencias y las ventajas que tienen usar una tupla y una lista: https://www.afternerd.com/blog/difference-between-list-tuple/

Tengo una duda.
En este primer ejemplo se escribi贸:
my_tuple=(1,鈥榙os鈥,True)
my_tuple=(3,)
S茅 que se guard贸 en distinta parte de la memoria.
Pero, 驴C贸mo podr铆a acceder a la primera?

Gracias

Se pueden re-asignar mas no modificar: clave esta parte

A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The main difference between the tuples and the lists is that the tuples cannot be changed unlike lists. Tuples use parentheses, whereas lists use square brackets.
https://www.tutorialspoint.com/python3/python_tuples.htm

RESUMEN:

Tupla -> _son cadenas de objetos inmutables, es decir que no pueden ser modificados. _
Pueden ser cadenas con cualquier tipo de objetos.
Se pueden utilizar en funciones para devolver varios valores, a diferencia del return que solo devuelve un solo valor.

CLASE: TUPLE
驴Como se define python? my_tuple = () #Como vemos solo se requiere ()
Que contiene: puede devolver varios objetos de diferentes clases.

Ejemplo(Consola de python)

my_tuple=()
type(my_tuple)
<class 鈥榯uple鈥>

my_tuple=(1, 鈥榙os鈥, True) #valores de tipo int, string, bool
my_tuple[0] #Estamos llamdo a los indices de las tuplas
1

my_tuple[1]
鈥榙os鈥

print(my_tuple[1])
dos

my_tuple[2]
True

Si tratas de reasignar un valor a un indice de la tupla nos votar谩 error:

my_tuple[2]=3
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
TypeError: 鈥榯uple鈥 object does not support item assignment

Para definir a TUPLAS DE 1 SOLO VALOR
se define d la siguiente manera: -> my_tuple=(1,) <鈥 Con un 1 seguido de una coma

Ejemplos:
>>> my_tuple=(1)
>>> type(my_tuple)     #Como no introducimos la coma, la tupla se dedfinio con un valor int =1
class 'int'>
>>> my_tuple=(1,)      #Manera correcta de asignai贸n
type(my_tuple)
<class 'tuple'>

**
OPERACIONES CON TUPLAS:**
tratamos de asignar variables a los valores de las tuplas:
Ejemplo:
>>> my_other_tuple=(2,3,4)
>>> x,y,z=my_other_tuple
>>> my_tuple+=my_other_tuple
>>> my_tuple
(1, 2, 3, 4)

LAS FUNCIONES PUEDEN DEVOLVER TUPLAS
>>> def cordenadas():
鈥 return(5,4)

>>> cordenada=cordenadas()
>>> print(cordenada)
(5, 4)
>>> type(cordenada)
<class 鈥榯uple鈥>

Las tuplas se pueden modificar__
??

Lo que aprend铆 y entend铆.

Practicando un poco 馃槂

def run():
    # Las tuplas son inmutables
    tupla = (1,"2",3.0)
    # Agregar una coma cuando es una tupla de un valor
    tupla_one_value = (5,)
    # Sumar tuplas
    tuple_join = tupla + tupla_one_value
    # desempaquetar tupla
    a, b, c = tupla
    # devolver una tupla con una funcion
    def coordenada():
        return (1,3)
    
    x, y = coordenada()


    print(f"""
            tupla \t\t-> {tupla}
            tupla_one_value \t-> {tupla_one_value}
            tuple_join \t\t-> {tuple_join}
            a, b, c \t\t-> {a} {b} {c}
            x, y \t\t-> {x} {y}
    """)


if __name__ == '__main__':
    run()

Les dejo mis apuntes de la clase donde explico algunos m茅todos para als tuplas y algunas de sus caracter铆sticas
Apuntes

Que clase m谩s tesa!!!, o sea el contenido es claro, pero siento que despu茅s de 2 o 3 d铆as, sin practica no hay mucho que pueda recordar, as铆 que siento que volver茅 a ver esta clase de nuevo en un tiempo para refrescar conceptos y tratar adaptar mejor estos conceptos tan poderosos.

Las tuplas son cadenas de datos que nos permiten almacenar todo tipo de datos dentro de Python tal y como se puede hacer con las listas. Pero en gran diferencia no podemos modificarlas despu茅s de haberlas creados(Son datos inmutables).

Las tuplas se definen con () y las listas con []

my_tuple = (1,"Mexico", True)

x,y,z = my_tuple

print(f'Esta es mi tupla {my_tuple} y estos son sus valores X {x} Y {y} Z {z}')

my_tuple = (1,)

驴C贸mo identificar una tupla en Python?
馃馃馃
Las tuplas en Pyhton poseen siguiente sintaxis:
tuple_name = (鈥榝irst_value鈥, 2, 鈥榰_can_add_ints鈥)
馃
Mientras que las listas en Python tienen esta sintaxis:
list_name = [1,鈥2鈥, 3]

Buena clase!

En Python, una tupla es un conjunto ordenado e inmutable de elementos del mismo o diferente tipo. Las tuplas se representan escribiendo los elementos entre par茅ntesis y separados por comas. Una tupla puede no contener ning煤n elemento, es decir, ser una tupla vac铆a.

En verdad excelente. Gracias

Peque帽o recordatorio de las caracter铆sticas de los array y listas en Python
Lista:
-Colecci贸n de datos ordenados
-Se pueden modificar los datos que contiene
-Puede incluir datos de distintos tipos
-Accesible mediante 铆ndice
Se declaran as铆: list = [鈥渕ango鈥, 1, True]

Array:
-Colecci贸n de datos del mismo tipo primitivo ordenados
-Se puede modificar
-Accesible mediante 铆ndice
-Los datos se guardan de forma contigua as铆 es m谩s f谩cil encontrar los datos
-Se utiliza cuando necesitamos almacenar datos del mismo tipo

Cuando se define un array lo primero que haremos es establecer cu谩l es el tipo de dato que va a contener, se asignar谩 con una letra identificativa. Esto que parece una restricci贸n garantiza tambi茅n, cuando se trabaja con miles o millones de datos, que todos sean del mismo tipo.

El array se declara as铆:
// Primero hay que importar el m贸dulo array
import array as arr
// Creamos un array de tipo int
a = arr.array(鈥榠鈥, [1, 2, 3])
La i hace referencia al c贸digo que hemos mencionado antes.

Tuplas
Caracter铆sticas de las tuplas:
-Son secuencias inmutables de objetos, es decir, no podemos borrar ni modificar los que tiene, pero si se pueden reasignar.
-A diferencia de las cadenas pueden contener cualquier tipo de objeto
-Puede utilizarse para devolver varios valores en una funci贸n
-Ocupan menos espacio en memoria.
-Se almacenan en un bloque de memoria
-Se utilizan porque son m谩s r谩pido de crear que una lista.

Se declaran de la siguiente forma:
my_tuple = (1, 2, 鈥榯res鈥, True)

En caso de que tu tupla s贸lo contenga un valor, debes agregar una coma 鈥,鈥 para que python lo reconozca como tupla, por ejemplo:
my_tuple = (1,)

Tambi茅n podemos juntar tuplas de la siguiente forma:
my_tuple += my_other_tuple

Las tuplas pueden ser desempaquetadas para duplicar esos valores a otras variables, al desempaquetar debemos duplicar todas las variables que haya dentro de la tupla.
Se realiza de la siguiente forma:
my_tuple = (1, 2, 3, 鈥楶epe鈥, True)
a, b, c, d, e = my_tuple
Se van duplicando en el mismo orden.

Tipos de datos estructurados: Muchos datos(bytes) dentro de una sola variable.
Mutabilidad
Tuplas: Secuencias inmutables de datos. Contienen caualquier tipo de dato(puede haber tuplasd mixtas). Devuelven varios valores en una funci贸n. Es una lista de data que no se puede modificar.
Se puede accesar global o por indiece.
Se desempaquetan asignandole una variable a cada indice.
Variable = (tupla,)

Podemos poner como el valor retornable una tupla: return (2,3,4,5)

A la hora de definir una tupla con solo objeto, es necesario que pongamos una coma para se帽alizar que tenemos una tupla y no un entero o cadena ( o cualquier tipo de dato que pongamos singularmente)

Creo que la forma m谩s f谩cil de definir una tupla (si vienes de otros lenguajes de programaci贸n) es como un array est谩tico (o en C++ un array com煤n), me parece genial que con las tuplas se puede hacer lo que en JavaScript se llamar铆a (destructuring) jaja

Bien explicado! no me qued贸 claro si una tupla puede guardar una funci贸n y luego acceder a ella por medio de la tupla.

#las tuplas son secuencias inmutables de objetos
#las tuplas se pueden usar para devolver m谩s de un valor

my_tuple = () #una tupla vac铆a se puede definir solamente con par茅ntesis
type(my_tuple) #Esto es para saber qu茅 es de tipo tupla

#asign谩ndoles valores de mi tupla
my_tuple = (1, 'dos', True) #reaccionando la tupla con valores de diferente tipo

#imprimiendo estos valores
print(my_tuple[0]) #esto deber铆a imprimir el primer valor de mi tupla porque en programaci贸n al 铆ndice empieza en 0. En este caso ser铆a el entero 1
print(my_tuple[1]) #en este caso se imprimiria el segundo valor de mi dupla Qu茅 es la cadena 'dos'.

#conociendo el error al intentar cambiar un valor asignado a mi tupla
#my_tuple[0] = 2 #A qu茅 intentamos cambiar el primer valor, que ser铆a el n煤mero 1, por el n煤mero 2.
#my_tuple = (1) #si podemos reasignar una tupla pero para que sea de tipo tupla necesita coma despu茅s del primer valor.
#type(my_tuple) #aqu铆 dir铆a que es un entero y no una tupla

my_other_tuple = (2, 3, 4) #Creamos otra tupla
my_tuple += my_other_tuple #Creamos un nuevo espacio de memoria con los valores de my_tuple y my_other_tuple. Y ponemos a la variable my_tuple a apuntar a ese espacio de memoria

my_tuple = (1, 2, 3)
variable_1, variable_2, variable_3 = my_tuple #si tengo una tupla de tres n煤meros yo puedo asignar esos numeros a tres variables diferente.

def coordenadas():
    return (5, 4)

x, y = coordenadas()
print(x, y)

#aqu铆 yo aprend铆 qu茅 las tuplas las puedo usar para asignar una cierta cantidad de n煤meros a una cierta cantidad de variables y tambi茅n puedo con las funciones devolver m谩s de un n煤mero mediante tuplas

esta muy interesante, tuve que retornar el video poquito para entenderle mejor

Importante diferenciar.

Listas: permiten cambiar los elementos por otro

my_list = [1,2,3]

Tuplas: no se cambian los valores, para hacerlo se deberia cambiar toda la tupla, suelen gastar menos memoria,

my_tuple = (1,2,3)

Diccionarios: Tiene una llave y un valor

my_dic = {uno : 1, dos : 2, tres : 3}

buen aporte

Tuplas: son secuencias inmutables de Objetos(es como una lista la cual no podemos modificar con posterioridad pero si las podemos asignar)

A diferencia de los Strings las Tuplas pueden tener cualquier tipo de objeto.

Las tuplas pueden devolver varios valores en una funcion

Las tuplas no se pueden modificar pero si se pueden reasignar

puedes reasignar el valor dentro de la tupla poniendola entre parentesis y tambien puedes sumarizarlas

podemos reasignar las tuplas de las maneras que nosotros queramos

Como regresar varios valores de una funcion

podemos regresar el valor de una tupla con la funcion de coordenadas

def coordenadas ():

鈥 return (5, 4)

  • Las tuplas son secuencias de objetos inmutables, es decir que no se pueden modificar.
  • A diferencia de las cadenas de textos, que tambi茅n son inmutables, las tuplas pueden contener cualquier tipo de objeto.
  • Las tuplas se pueden usar para devolver varios valores en una funci贸n.
  • Las tupas se pueden sumar con otras tuplas, en este caso no estamos modificando, si no reasignando.
  • Se puede desempaquetar los valores de una tupla en varias variables.
my_tuple=(1,2,3)
x,y,z=my_tuple # x=1, y=2, z=3

Entendido el manejo de tuplas

Las tuplas son listas de objetos que no se pueden modificar

Me gusto mucho el hecho de que se puedan sumar las tuplas, es curioso la forma en que se hace.

隆Maravilloso!

Tupla: Son secuencias inmutables de objetos.

No pueden modicarse!!

Acceptable

En verdad am茅 la clase de tuplas. Hace alg煤n tiempo trabaj茅 en un programa que tenia ese tipo de datos y yo todo terco trataba de modificar sus valores. Vaya error en el que estaba.

Nada mas util que las tuplas

Aqui es donde se ponen interesantes las cosas.

Se pone la cosa seria.

cual es la diferencia entre una tupla y un vector?

Es muy buena la utilizacion de las tuplas, ya que no se pueden modificar y eso puede ayudar a que tu programa no sea modificado.

Estos conceptos ya me vuelan la cabeza! .
En el buen sentido por que esta genial el curso!

Est谩 muy bien explicado!

Corriganme si me equivoco:
Arreglos: Puede almacenar una colecci贸n del mismo tipo de dato, los datos pueden modificarse o reasignar datos al arreglo.
Tuplas: Puede almacenar una colecci贸n de objetos de distintos tipos de datos, los datos no pueden modificarse, pero se puede reasignar datos a las tuplas.

En Mexico los conocemos como Arrays

my_tupla = ()
type(my_tupla)
<class 鈥榯uple鈥>

my_tupla = (1, 鈥榙os鈥, True)
my_tupla[0]
1

my_tupla[1]
鈥榙os鈥

my_tupla[2]
True

my_tupla = (1)
type(my_tupla)
<class 鈥榠nt鈥>

my_tupla = (1,)
type(my_tupla)
<class 鈥榯uple鈥>

my_otra_tupla = (2, 3, 4)
my_tupla += my_otra_tupla
print(my_tupla)
(1, 2, 3, 4)

x, y, z = my_otra_tupla
x
2

y
3

z
4

def coordenadas():
鈥 return(5, 4)

coordenadas = coordenadas()
coordenada
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
NameError: name 鈥榗oordenada鈥 is not defined

coordenadas
(5, 4)

x, y = coordenadas()
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
TypeError: 鈥榯uple鈥 object is not callable

print(x, y)
2 3

def coordenadas():
鈥 return(5, 4)

coordenadas = coordenadas()
coordenada = coordenadas()
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
TypeError: 鈥榯uple鈥 object is not callable

def coordenadas():
鈥 return(5, 4)

coordenada = coordenadas()
coordenada
(5, 4)

x, y = coordenadas()
print(x, y)
5 4

x
5

y
4

Este tema es fascinante鈥ara repasar y profundizar mucho

Muy bien explicado

genial

my_tuple = (1,) #Creacion de tuplas print(my_tuple) >>>1 my_other_tuple = (2, 3, 4) my_tuple += my_other_tuple #reasignaci贸n de tuplas print(my_tuple) >>>(1, 2, 3, 4) x, y, z = my_other_tuple print (x) >>>2

Tambi茅n sirve para darse una idea de como realizar operaciones con matrices, que veo se usara mas adelante en los cursos de Data Scients

Concepto cr铆tico: mutabilidad, inmutabilidad y referencia en Python: A efectos pr谩cticos, es como si se tratara de un puntero (empleando conceptos de otros lenguajes) a ese objeto, Es decir, no contiene su valor, sino una referencia a 茅l. ``` >>> my_tuple = (1, ) >>> my_other_tup

Excelente clase!

excelente clase

Hice un resumen de las estructuras de datos con algunos ejemplos https://drive.google.com/file/d/1p_ljmmtBdSTHh_5rnXXUeD2Qs2XhUpYK/view?usp=sharing, espero les sirva.

MUY PRACTICO ESA ULTIMA PARTE

Clarisimo 馃榾

No sab铆a que se pod铆a asignar una tupla entera a otra cosa, pero tiene sentido, no est谩s modificando la tupla, simplemente est谩s reasignando la variable entera.

buena clase

<my_tuple=()
tipo=type(my_tuple)
print(tipo)
my_tuple2=(1, 'dos', True)
primer_elemento=my_tuple2[0]#Recuerda que Python siempre empieza a contar desde 0
print(primer_elemento)
my_tuple3=(1)#Lo se帽ala como tipo 'int' porque no hemos agregado una coma
tipo3=type(my_tuple3)
print(tipo3)
my_tuple4=(1,)#Ahora si lo se帽ala como tupla
tipo4=type(my_tuple4)
print(tipo4)
my_other_tuple1=(1,)
my_other_tuple=(2,3,4)
my_other_tuple1 +=my_other_tuple #Estamos combinando las tuplas
print(my_other_tuple1)
x,y,z=my_other_tuple#Desempaquetar elementos de la tupla
print(x)
print(y)
print(z)

def coordenadas():#Esta funcion guarda una tupla
    return (5,4)

coordenada=coordenadas()#La variable coordenada ahora guarda la funcion que guerda a su vez una tupla
print(coordenada)
x,y=coordenadas()
print(x,y)
>

[2:27] Para definir una tupla usamos los par茅ntesis. Por ejemplo my_tuple = ().

[2:59] A diferencia de java y otros lenguajes, los tipos de valores dentro de una tupla pueden ser mixtos. Podemos acceder a los valores de la tupla mediante 铆ndices.

Tuplas, un elemento muy vers谩til, no existente en otros lenguajes de programaci贸n.

Tuplas

Las tuplas son secuencias inmutables (no se pueden modificar) de objetos, que a diferencia de las cadenas pueden contener cualquier tipo de objetos. Estas pueden utilizarse para devolver varios valores en una funci贸n.

def coordenadas():

    # En nuestra funci贸n devolveremos la tupla (5, 4).
    return (5,4)

# Si ejecutamos la funci贸n vamos a recibir la tupla.
>>> coordenadas()
(5,4)

# Tambien podemos "desempaquetar" la tupla que recibimos,
# esto significa que podemos asignar cada valor que nos llega de la
# tupla a variables que definamos.
>>> x, y = coordenadas()

# Si imprimimos la primera variable desempaquetada veremos
# el primer valor de la tupla.
>>> x
5

# Y muy parecido al ejemplo anterior, con nuestra
# variable "y" tendremos el segundo valor.
>>> y
4

Genial, organizamos y podemos reasignar valores 馃槈

[3:37] Se dice que una tupla es inmutable, debido a que despues de creada sus elementos no se pueden modificar. (Aunque en esos casos si lo requerimos lo que podemos hacer es crear una nueva)