FULL STACK PYTHON

Clase 27
PYTHON 3

Temas: Cadenas de caracteres. Métodos de cadenas. f-strings Índices y slicing (rebanadas). Tipo de datos compuestos. Listas.
Métodos. Tipos de datos mutables e inmutables. Tuplas, diccionarios, conjuntos
Cadenas y Listas
Les damos la bienvenida
Vamos a comenzar a grabar la clase
 Clase 26 Clase 27 Clase 28

Controladores de flujo Cadenas y Listas Funciones

● Estructuras control. ● Cadenas de caracteres. ● Funciones. Concepto.

● Condicionales: sentencia if. ● Métodos de cadenas. ● Llamada a función.
● Iterativas: sentencia while y for. ● f-strings ● Retorno y envío de valores.
● Operadores lógicos y ● Índices y slicing (rebanadas). ● Parámetros, argumentos, valor
relacionales. ● Tipo de datos compuestos. y referencia.
● Listas. Métodos. ● Parámetros mutables e
● Tipos de datos mutables e inmutables.
inmutables. ● Parámetros por defecto
● Tuplas, diccionarios, conjuntos ● Docstring.
● Funciones Lambda/Anónima.
Cadenas de caracteres
Python, al igual que la mayoría de los lenguajes de programación
actuales, provee un tipo de datos específico para tratar las cadenas de
caracteres (strings).
Se trata de un tipo de dato con longitud variable, ya que deben
adecuarse a la cantidad de caracteres que albergue la cadena.
Este tipo de datos posee una buena cantidad de métodos y
propiedades que facilita su uso.
Cadenas de caracteres
Una cadena de caracteres está compuesta por cero o más caracteres. Las
cadenas pueden delimitarse con comillas simples o dobles.
Inicialización de una cadena por asignación:
# Definición de cadenas usando comillas dobles
dia1 = "Lunes"
x = "" # x es un string de longitud cero

# Definición de cadenas usando comillas simples

dia2 = 'Martes'
z = "121" # z contiene dígitos, pero es un string
Cadenas de caracteres
Una ventaja del hecho de poder delimitar cadenas con comillas simples o
dobles es que si usamos comillas de una clase, las de otra clase puede
utilizarse como parte de la cadena:
Uso de comillas simples y dobles
print("Mi perro 'Toby'") # Mi perro 'Toby'
print('Mi perro "Toby"') # Mi perro "Toby"

Una cadena puede replicarse con el operador *:

Replicación
risa = 'ja'
carcajada = risa*5 # jajajajaja
asteriscos = "*"*10 # **********
Cadenas de caracteres
También pueden usarse triples comillas simples o dobles, que proveen un
método sencillo para crear cadenas usando más de una línea de código:
Cadenas delimitadas por comillas dobles o triples
# Definición de cadenas usando comillas dobles triples:
cadena1 = """En Python es posible definir
cadenas de caracteres utilizando más de una
línea de código"""

# Definición de cadenas usando comillas simples triples:

cadena2 = '''Por supuesto, se puede hacer
lo mismo utilizando comillas simples'''
Cadenas de caracteres | Concatenación
Para concatenar dos o más cadenas se utiliza el operador + (más):
Concatenación de cadenas Terminal
nombre= input("Ingrese su nombre: ") Ingrese su nombre: Pedro
saludo= "Hola "+ nombre Hola Pedro
print(saludo)

El mismo operador se usa para sumar números o concatenar cadenas. Pero no

podemos utilizarlo con datos mixtos, porque se obtiene un error. Este error se
puede evitar mediante las funciones de conversión de tipos.:
Concatenación de cadenas:
var1 = 3 + 5 # 8 (entero)
var2 = "3" + "5" # 35 (cadena)
var3 = 3 + "5" # TypeError
var4 = str(3) + "5" # 35 (cadena)
var5 = 3 + int("5") # 8 (entero)
Cadenas de caracteres | Comparación
Dos cadenas se pueden comparar mediante los operadores relacionales.
Comparación de cadenas Terminal
cadena1 = "Hola"
cadena2 = "Codo a Codo"
print(cadena1 > cadena2) True
print(cadena1 == cadena2) False
print(cadena1 < cadena2) False

La comparación es case sensitive, es decir, se distingue entre mayúsculas y

minúsculas.
Comparación de cadenas Terminal
cadena1 = "Hola"
cadena2 = "hola"
print(cadena1 == cadena2) False
Cadenas de caracteres
En Python disponemos de la función len(), que retorna la cantidad de
caracteres que contiene un string:
Función len()
nombre='Codo a Codo'
print(len(nombre)) #se imprime 11

Se accede a los elementos de la cadena utilizando subíndices:

Uso de subíndices Terminal
El primer caracter tiene
cadena = "Hola Codo a Codo" subíndice cero. Si usamos
print(cadena[0]) H subíndices negativos, se
print(cadena[5]) C cuentan desde el final de la
print(cadena[-1]) o cadena.
print(cadena[-2]) d
Cadenas de caracteres | Métodos
Las cadenas tienen una serie de métodos (funciones) que simplifican el
desarrollo de código. Tres de estos métodos son:
● .upper(): devuelve la cadena con todos sus caracteres en mayúsculas.
● .lower(): devuelve la cadena con todos sus caracteres en minúsculas.
● .capitalize(): devuelve la cadena con su primer caracter en mayúscula y todos los
demás en minúsculas.

Métodos propios de las cadenas: Existen los métodos .isupper() e

cadena = "Codo a Codo" .islower() que devuelven True si todos
print(cadena.upper()) # CODO A CODO los caracteres alfabéticos de una
print(cadena.lower()) # codo a codo cadena están en mayúsculas o
minúsculas respectivamente.
print(cadena.capitalize()) # Codo a codo
Cadenas de caracteres | Slicing
Una "rebanada" es un subconjunto de una cadena que se obtiene mediante
la definición de un índice inicio y/o fin. El subconjunto devuelto incluye el
valor del índice de inicio, pero no el valor final. Un tercer valor permite
determinar un paso, que incluso puede ser negativo:
Rebanadas
cadena = "¡Hola mundo!"
print(cadena[6:11]) # mundo
print(cadena[2:12:2]) # oamno
print(cadena[6:]) # mundo!
print(cadena[:5]) # ¡Hola
print(cadena[:]) # ¡Hola mundo!
print(cadena[::2]) # ¡oamno
print(cadena[::-1]) # !odnum aloH¡
Cadenas de caracteres | in / not in
Los operadores de pertenencia se utilizan para comprobar si un caracter o
cadena se encuentran dentro de otra.

OPERADOR DESCRIPCION

in Devuelve True si el valor se encuentra en una secuencia; False en caso contrario.

not in Devuelve True si el valor no se encuentra en una secuencia; False en caso contrario.

Ejemplos:
cadena = "Codo a Codo"
print("C" in cadena) # True
print("n" in cadena) # False
print("Codo" in cadena) # True
print("A" not in cadena) # True
print("o" not in cadena) # False
Cadenas de caracteres | for , min() y max()
Un bucle for puede iterar sobre una min() y max() devuelven el elemento
cadena, y la variable recibe en cada con el código ASCII más pequeño o
iteración uno de los caracteres de la más grande respectivamente:
misma:

For con cadenas Terminal min() y max() Terminal

cadena = "Python" P cadena = "Programador"
for letra in cadena: y print(max(cadena)) r
print(letra) t print(min(cadena)) P
for i in range(len(cadena)): h
print(cadena[i]) o
n
Cadenas de caracteres | .join(), .split() y .replace()
separador.join(cadena) devuelve una cadena con el separador entre cada
carácter. cadena.split(separador) convierte una cadena en una lista, y
cadena.replace(viejo, nuevo,max) reemplaza una cadena por otra hasta un
máximo. Si se omite max reemplaza todas las apariciones.

.join() split() .replace()

cadena = "12345" cadena = "Codo a Codo" cadena = "Codo a Codo"
cadena = '-'.join(cadena) lista = cadena.split(' ') cadena = cadena.replace('Codo','Mano')
print(cadena) print(lista) print(cadena) # Mano a Mano
#1-2-3-4-5 #['Codo', 'a', 'Codo'] cadena = "Codo a Codo"
cadena = cadena.replace('Codo','Mano' ,1)
print(cadena)
# Mano a Codo
Cadenas de caracteres | Detección de tipos
cadena.isalpha() devuelve True si todos los caracteres de una cadena son
alfabéticos. cadena.isdigit() devuelve True si todos los caracteres de una
cadena son dígitos. cadena.isalnum() devuelve True si todos los caracteres
de una cadena son alfabéticos o numéricos.

.isalpha() .isdigit() .isalnum()

cad1 = "Python" cad1 = "1234" cad1 = "12Ab"
. cad2 = "Python3" cad2 = "1234a" cad2 = "12Ab%"
print(cad1.isalpha()) print(cad1.isdigit()) print(cad1.isalnum())
# True # True # True
print(cad2.isalpha()) print(cad2.isdigit()) print(cad2.isalnum())
# False # False # False
Cadenas de caracteres | title() y center()
cadena.title() devuelve una cadena en minúsculas con el primer caracter de
cada palabra en mayúsculas. cadena.center(ancho, relleno) devuelve una
cadena en el ancho especificado. El resto de la cadena se rellena con
espacios o con el caracter opcional relleno.

.title() .center()
cad1 = "aprendiendo programación" cad1 = "Hola"
print(cad1.title()) cad2 = cad1.center(10,"*")
# Aprendiendo Programación print(cad2)
cad1 = "Este es un TEXTO" # ***Hola***
print(cad1.title())
# Este Es Un Texto
Cadenas de caracteres | Alineación
cadena.ljust(ancho, [relleno]) y cadena.rjust(ancho, [relleno]) devuelven
cadenas alineadas a izquierda o derecha, respectivamente. El resto de la
cadena se rellena con espacios o con el caracter opcional relleno.
cadena.zfill(ancho) devuelve una cadena alineada a la derecha en el ancho
especificado. El comienzo de la cadena se rellena con ceros.
.ljust() .rjust() .zfill()
cad1 = "Python" cad1 = "Python" cad1 = "120"
cad1 = cad1.ljust(10, '-') cad1 = cad1.rjust(10, '-') cad1 = cad1.zfill(8)
print(cad1) print(cad1) print(cad1)
# Python---- # ----Python # 00000120
Cadenas de caracteres | Recorte
cadena.lstrip(str) y cadena.rstrip(str) devuelven cadenas a las que se les
han quitado los caracteres indicados por str a la izquierda o a la derecha,
respectivamente. cadena.strip(str) devuelve una cadena sin los caracteres
indicados en str al inicio y al final de la cadena.

.lstrip() .rstrip() .strip()

cad1 = "---Hola-Mundo----" cad1 = "---Hola-Mundo----" cad1 = "---Hola-Mundo----"
cad1 = cad1.lstrip('-') cad1 = cad1.rstrip('-') cad1 = cad1.strip('-')
print(cad1) print(cad1) print(cad1)
# Hola-Mundo---- # ---Hola-Mundo # Hola-Mundo
Cadenas de caracteres | Búsquedas
cadena.find(<str>,[[inicio],[fin]]) devuelve la posición donde encuentra str
en la cadena. Si no lo encuentra devuelve -1. Se puede indicar los subíndices
desde (inicio) y hasta (fin) donde buscar.

<cadena>.rfind(<str>,[[inicio],[fin]]) es similar a find, pero busca la última

aparición.
.find() .rfind()
cad="Codo a Codo" cad="Codo a Codo"
pos= cad.find("Codo") pos= cad.rfind("Codo")
print(pos) # 0 print(pos) # 7
Cadenas de caracteres | f-Strings
f-Strings tiene una sintaxis simple y fluida que simplifica la tarea de dar
formato a cadenas de texto. Para mostrar variables se coloca el nombre de las
variables entre llaves {}, en una cadena que antepone f a su contenido. Al
ejecutar el código, todos los nombres de las variables se reemplazan por sus
respectivos valores:
f-Strings
legajo = 12212
nombre = "María"
nota = 10
print(f"Legajo: {legajo} Nombre: {nombre} Nota: {nota}")
# Legajo: 12212 Nombre: María Nota: 10
Listas
Una lista es una secuencia ordenada de elementos. Pueden tener
elementos del mismo tipo o combinar distintos tipos de datos, aunque
esto último es poco frecuente.
Las listas en Python son un tipo contenedor, compuesto, y se usan para
almacenar conjuntos de elementos relacionados.
Junto a las tuplas, diccionarios y conjuntos, constituyen uno de los
tipos de datos más versátiles del lenguaje, con la particularidad de ser
mutables. Esto último quiere decir que su contenido se puede
modificar después de haber sido creadas.
Listas
Las listas se crean asignando a una variable una secuencia de elementos
encerrados entre corchetes [ ] y separados por comas. Se puede crear una
lista vacía, y las listas pueden ser elementos de otras listas:
Creación de listas:
numeros = [1,2,3,4,5] #Lista de números
dias = ["Lunes", "Martes", "Miércoles"] #Lista de strings
elementos = [] #Lista vacía
sublistas = [ [1,2,3], [4,5,6] ] # lista de listas
print(sublistas[1]) #[4,5,6]
print(sublistas[1][1]) # 5

Las listas se suelen nombrar en plural. Para incluir una lista como parte de
otra, basta con incluirla separada por comas de los otros elementos.
Listas | Acceso por subíndice
Las listas se pueden imprimir directamente, y el acceso a sus elementos se
hace mediante subíndices. El primer elemento tiene subíndice cero. Un
subíndice negativo hace que la cuenta comience desde atrás. Un subíndice
fuera de rango genera un error: out of range

Acceso por subíndice: Terminal

dias = ["Lunes", "Martes", "Miércoles"]
print(dias) ['Lunes', 'Martes', 'Miércoles']
print(dias[0]) Lunes
print(dias[1]) Martes
print(dias[-1]) Miércoles
print(dias[3]) IndexError: list index out of range
Listas | Recorrer listas con for
Es posible recorrer una lista utilizando for y range para generar la
secuencia de índices:
For con listas For con listas
lista = [2,3,4,5,6] lista = [2,3,4,5,6]
suma = 0 suma = 0
for i in range(len(lista)): for elem in lista:
suma = suma + lista[i] suma = suma + elem
print(suma) # 20 print(suma) # 20

len(lista) retorna la cantidad de elementos que posee una lista y resulta muy
útil, entre otras cosas, para determinar la cantidad de ciclos de un bucle.
Listas | Recorrer listas con for.. in
También se puede iterar en forma directa los elementos de la lista, sin
necesidad de generar la secuencia de subíndices. En este caso la
variable i toma el elemento de la lista:

For .. in Terminal
vocales = ['a','e','i','o','u'] a
# El bucle recorre la lista e
for e in vocales: i
print(e) o
u
Listas | Desempaquetado y concatenado
El proceso de desempaquetado consiste en asignar cada elemento de
una lista a una variable. Además, las listas pueden concatenarse con el
operador suma:
Desempaquetado Terminal
dias = ["Lunes", "Martes", "Miércoles"]
d8, d2, d3 = dias
print(d8) Lunes
print(d2) Martes
print(d3) Miércoles

Concatenado Terminal
lista1 = [1,2,3]
lista2 = [4,5,6]
lista3 = lista1 + lista2 [1, 2, 3, 4, 5, 6]
print(lista3)
Listas | max(), min() y sum()
● La función max() devuelve el mayor elemento de una lista.
● La función min() devuelve el menor elemento de una lista.
● La función sum() devuelve la suma de los elementos de una lista:

max(), min() y sum() Terminal

lista = [3,4,5,6]
print(max(lista)) 6
print(min(lista)) 3
print(sum(lista)) 18
Listas | in / not in y list()
Los operadores de pertenencia in / not in permiten determinar si un elemento
está o no en una lista. La función list() convierte cualquier secuencia a una lista.
Se puede utilizar con rangos, cadenas y otros.

in / not in Terminal
lista = list(range(6))
print(lista) [0, 1, 2, 3, 4, 5]
cadena = "Hola"
print(list(cadena)) ['H', 'o', 'l', 'a']

lista2 = [3,4,5,6]
print(4 in lista2) True
print(8 in lista2) False
print("A" not in lista2) True
Listas | .append() e .insert()
El método append() agrega un elemento al final de la lista.
.append() Terminal
lista = [3,4,5]
lista.append(6)
print(lista) [3, 4, 5, 6]

insert(<pos>, <elemento>) inserta un elemento en una posición determinada:

.insert() Terminal
lista=[3,4,5]
lista.insert(0,2)
print(lista) [2, 3, 4, 5]
lista.insert(3,25)
print(lista) [2, 3, 4, 25, 5]
Listas | .pop() y .remove()
pop(<posición>) Elimina un elemento en una posición determinada de la
lista. Si no se pasa un argumento, pop() elimina el último elemento de la lista.
remove(<valor>) elimina un elemento en la lista, identificado por su valor.

.pop() .pop(posicion) .remove(valor)

lista = [6,9,8] lista = [3,4,5] lista = [3,4,5]
lista.pop() lista.pop(1) lista.remove(3)
#Resultado: [6,9] #Resultado: [3,5] #Resultado: [4,5]
Listas | .index(), count() y reverse()
index(<valor>) busca un valor y devuelve su posición. Admite como
argumento adicional un índice inicial a partir de donde comenzar la
búsqueda. count() devuelve la cantidad de repeticiones de un elemento, cero
si no lo encuentra. Y reverse() Invierte el orden de los elementos de una lista.

.index(valor) .count() .reverse()

lista = [3,4,5] lista = [3,4,5,3,5,8,5] lista = [3,4,5]
print(lista.index(5)) print(lista.count(5)) lista.reverse()
#Resultado: 2 # Resultado: 3 print(lista)
print(lista.count(2)) # Resulado: [5,4,3]
# Resultado: 0
Listas | .sort() y clear()
sort() ordena los elementos de la lista, de menor a mayor. sort(reverse=True)
ordena la lista de mayor a menor. En ambos casos, el orden depende del tipo
de dato contenido en la lista. Y clear() elimina todos los elementos de la lista.

.sort() sort(reverse=True) .clear()

lista = [5, 1, 7,10, 2] lista = [5, 1, 7, 2] lista = [3,4,5]
lista.sort() lista.sort(reverse=True) lista.clear()
print(lista) print(lista) print(lista)
#Resultado: [1,2,5,7,10] #Resultado: [7,5,2,1] #Resultado: []
Diccionarios
Los diccionarios en Python son un conjunto no ordenado de pares
clave: valor. Estas claves son únicas, y si se intenta guardar un valor a
una clave ya existente se pierde dicho valor.
Las claves pueden ser cualquier elemento de tipo inmutable (cadenas,
números o tuplas (si estás sólo contienen cadenas, números o tuplas).
Se representan como una lista de pares (las claves y valores) separados
por comas y encerrados entre llaves.
Diccionarios
Los diccionarios se pueden crear mediante la simple enumeración de los
elementos, o por comprensión:
Creación de un diccionario
# Creación: Por extensión
diccionario = {'Juan': 56, 'Ana': 15}
# Creación: Por compresión
diccionario = {x: x ** 2 for x in (2, 4, 6)}

Para acceder a las claves Python utiliza un método de hash. +info

Ejemplos de diccionarios:
{} # diccionario vacío
{'Juan': 56} # diccionario de un elemento
{'Juan': 56, 'Ana': 15} # diccionario de dos elementos
Diccionarios | Acceso
Puede accederse a un diccionario de diferentes maneras:
● A las claves, utilizando método keys()
● A los valores, utilizando la clave como índice
● A la clave-valor, utilizando método ítems()
● No es posible obtener porciones de un diccionario usando [:]
Ejemplos de diccionarios: Terminal
diccionario = {1: 'uno', 2:'dos', 3:'tres'}
print(diccionario.keys()) dict_keys([1, 2, 3])
for i in diccionario.keys(): uno
print(diccionario[i]) dos
for clave, valor in diccionario.items(): tres
print(clave, ':', valor, end= '; ') 1 : uno; 2 : dos; 3 : tres;
Diccionarios | Métodos, funciones y operadores
Los siguientes diagramas resumen los métodos, funciones y operadores
disponibles para los diccionarios:
Tuplas
Las tuplas en Python son conjunto de elementos separados por comas
y encerrados entre paréntesis. Los paréntesis no son obligatorios.
Las tuplas son inmutables y en general contienen una secuencia
heterogénea de elementos. Los elementos de una tupla si pueden ser
mutables.
Podemos pensar en una tupla como si fuese una lista, pero recordando
que su inmutabilidad hace que muchos de sus métodos y funciones no
puedan utilizarse.
Tuplas
Las tuplas se pueden crear por extensión, o mediante un empaquetado
(pack):
Creación de una tupla
# Creación: Por extensión
tupla1 = ('uno', 'dos', 'tres')
# Creación: Mediante empaquetado
tupla2 = 'Palotes, Juan de', (1930, 11, 13), 3000936

Y se pueden “desempaquetar” (unzip), volcando su contenido a variables. Se

requiere que la cantidad de variables a la izquierda del signo igual sea el
tamaño de la tupla.
Desempaquetado de una tuplas:
nombre, nacimiento, dni =( 'Palotes, Juan de', (1930, 11, 13), 3000936)
Tuplas | Acceso
Ejemplos de tuplas:
() # tupla vacía
'un valor', # tupla con un valor
('uno', 'dos', 'tres') # cadenas
('Palotes, Juan de', (1930, 11, 13), 3000936) # datos de persona

Se accede a los elementos desempaquetando, mediante un índice o usando

rebanadas (slices):
Acceso a elementos de una tuplas
tupla = ('Palotes, Juan de', (1930, 11, 13), 3000936)
nombre, fecha, dni = tupla # Desempaque
# Acceso por índices:
print('Nombre: ', tupla[0], '. Fecha nac.: ', tupla[1], '. DNI: ', tupla[2])
print(tupla[::]) # Acceso mediante rebanadas
Conjuntos
Los conjuntos en Python son una metáfora de los conjuntos del área de
la matemática. Al igual que aquellos, en Python son conjuntos de
elementos únicos, no ordenados y sus elementos no son mutables.
Se definen sus elementos encerrándolos entre llaves y separados por
comas.
No puede accederse a los elementos de un diccionario a través de un
subíndice pues sus elementos no están ordenados.
Conjuntos | Conjuntos
Ejemplos de conjuntos:
set() # conjunto vacío
{'un valor'} # conjunto con un valor
{'uno', 'dos', 'tres'} # conjunto de cadenas
{'Palotes, Juan de', (1930, 11, 13), 3000936} # datos de persona

Se accede a los elementos iterando o usando el método pop().

Acceso a elementos de un diccionario: Terminal

conjunto = {'Empleado', (1930, 11, 13), 36} {'Empleado', 36, (1930, 11, 13)}
a = set(conjunto) Empleado
print(a) 36
[print (elem) for elem in a] (1930, 11, 13)
print(a) {'Empleado', 36, (1930, 11, 13)}
Conjuntos | Métodos, funciones y operadores
Los siguientes diagramas resumen los métodos, funciones y operadores
disponibles para los conjuntos:
 String Lists Tuples Set Dictionaries
s = 'python' t = (8,'hola',False) s={8,'HI',False} d={1:'Juan',2:'Ana'}
l = [8,'hola',False]

r={9,'HI',False}
type(s) → str type(l) → list type(t) → tuple type(d) → dict
len(<list>) → int len(<tuple>) → int len(d) → int
len(s) → int max(t) → objeto type(s) → set
max(l) → objeto
max(s) → caracter min(l) → objeto min(t) → objeto
min(s) → caracter <list> + <list> → <list> len(<set>) → int
<list> * <int> → <list> <tuple> + <tuple> → max(s) → objeto
s.capitalize() → <tuple>
str l[i] → objeto <tuple> * <int> → <tuple> min(s) → objeto
s.upper() → str l.reverse() t[i] → objeto
s.lower → str l.sort() t.count(elemento)->int r|s={8,'HI,False,9)
s.index("a") → int l.append(x) t.index(elemento)->int for i in d.keys():
s.replace("C","c") → l.insert(pos,elemento) r&s={'hola',False}
str l.pop() print(diccionario[i])
s.split(" ") → l.remove(elemento) for x in <set>:
list for t in <tuple>: print(x)
<str>+<str> → <str> for x in <list>: print(t)
<str>*<int> → <str> print(x) <?> in <set> → <bool>
s[i] → caracter <?> in <tuple> → <bool>
for c in <str>: <?> in <list> → <bool>
Desordenado Par de valores
print(c) Inmutable
Ordenada Ordenado
Ordenada No permite duplicados
<str> in
Mutable Mutable
<str>→<bool> Inmutable No Indexado
No acepta duplicados
Permite duplicados Permite duplicados
Material extra
Artículos de interés
Material extra:

● Listas
● Diccionarios
● Tuplas
● Conjuntos

Videos:

● Listas, tuplas y diccionarios, en Píldoras Informáticas

● Conjuntos (primera parte) y conjuntos (segunda parte) en Programación ATS
No te olvides de dar el presente
Recordá:
● Revisar la Cartelera de Novedades.
● Hacer tus consultas en el Foro.
● Realizar los Ejercicios obligatorios.

Todo en el Aula Virtual.