Fundamentos de Python
Autor:
Romulo Salvador
Semillero de Investigación en Business Analytics (SYBA UNALM)
GitHub: [Link]
LinkedIn: [Link]
ORCID: [Link]
Índice
1. Introducción a Python
Usos y aplicaciones de Python. Áreas de desarrollo destacadas. Entornos de trabajo
(PyCharm, Jupyter, Azure, Colab)
2. Google Colab
Atajos básicos. Tipos de celdas: Código y Markdown
3. Tipos de datos y variables
3.1. Numéricos (int, float)
3.2. Booleanos
3.3. Cadenas de texto (strings Y entrada de usuario)
4. Operadores
4.1. Aritméticos
4.2. Comparación (orden lexicográfico) 4.3. Lógicos
4.4. Asignación
4.5. Identidad
4.6. Pertenencia
5. Estructuras de control
5.1. Condicionales: if, elif, else
5.2. Bucles: for, while
6. Estructuras de datos
6.1. Listas
6.2. Matrices
6.3. Cadenas de caracteres
6.4. Tuplas
6.5. Conjuntos
6.6. Diccionarios
7. Funciones y control de flujo
7.1. break
7.2. continue
7.3. range
7.4. pass
7.5. Definición de funciones (def, return, parámetros por defecto)
7.6. Funciones lambda y composición
8. Clases y objetos
8.1. Definición de clases
8.2. Creación de objetos
8.3. Métodos de objetos
1. Introducción a Python
Python se destaca por su versatilidad y amplia comunidad, lo que permite crear aplicaciones
robustas para backend, automatización y análisis avanzado. Además, es muy usado en
ciencia de datos, inteligencia artificial, ciberseguridad y desarrollo de herramientas
multiplataforma.
Desarrollos interesantes en el mundo de Python:
PyPI: El sistema de paquetes de Python, PyPI, ha superado los 200 millones de
descargas al mes, lo que lo convierte en uno de los repositorios de paquetes más
populares en el mundo.
Aplicaciones en la nube: Python está ganando terreno como lenguaje de elección para
la implementación de aplicaciones en la nube, gracias a su amplia gama de bibliotecas y
herramientas de desarrollo.
Científico de datos: Python sigue siendo un lenguaje popular para la ciencia de datos,
con una creciente comunidad de usuarios que utilizan bibliotecas como NumPy, Pandas
y Matplotlib para analizar y visualizar grandes conjuntos de datos.
Automatización: Python también es ampliamente utilizado en la automatización de
tareas, especialmente en áreas como la automatización de pruebas, la gestión de redes
y la automatización de trabajos en segundo plano.
Entornos de trabajo para Python:
PyCharm
Jupyter Notebooks
Azure Notebooks
Google Collaboratory
2. Introducción a Colab
Atajos:
Ctrl + m + a Crear una celda sobre la actual
Ctrl + m + b Crear una celda debajo de la actual
Ctrl + m + d Borrar celda
2.1. Tipos de celdas
Para la ejecución de código en celdas se puede usar el botón play o la combinación de
teclas Shift + Enter
In [ ]: print("Esto es una celda de código")
Esto es una celda de código
In [ ]: #Esto es un comentario en una celda de código
5 + 4
9
Out[ ]:
Las siguiente son inputs y outputs en celdas Markdown
Las siguiente son inputs y outputs en celdas Markdown
# Esto es un título 1
Esto es un título 1
## Esto es un título 2
Esto es un título 2
### Esto es un título 3
Esto es un título 3
*Esto es un texto en cursiva*
Esto es un texto en cursiva
**Esto es un texto en negrita**
Esto es un texto en negrita
Esto es una lista:
1. Elemento de la lista
2. Elemento de la lista
Esto es una lista:
1. Elemento de la lista
2. Elemento de la lista
3. Tipos de datos y variables
A diferencia de otros lenguajes de programación, Python no requiere que se declaren los
tipos de datos
3.1. Numéricas
In [ ]: 32
32
Out[ ]:
In [ ]: # La ejecución solo muestra el último comando
x=32
print(x) #Si usamos comandos print se muestran varias filas de resultados
x
32
32
Out[ ]:
In [ ]: #tipo de variable
type(x)
int
Out[ ]:
In [ ]: y = 45.0
type(y)
float
Out[ ]:
In [ ]: z = int(y)
print(z)
type(z)
45
int
Out[ ]:
In [ ]: y = 45.9
int(y) # solo toma en cuenta la parte entera, función SUELO
45
Out[ ]:
In [ ]: #Impresion de varios valores en una sola linea de codigo
x, y, z
(32, 45.9, 45)
Out[ ]:
3.2. Booleanos
In [ ]: a = True
b = False
print(a)
b
True
False
Out[ ]:
In [ ]: int(a)
1
Out[ ]:
In [ ]: float(b)
0.0
Out[ ]:
3.3. Cadenas
In [ ]: cadena = "Hola, mundo!"
cadena
'Hola, mundo!'
Out[ ]:
In [ ]: type(cadena)
str
Out[ ]:
In [ ]: 'Hola, "Alejandro" es mi nombre'
'Hola, "Alejandro" es mi nombre'
Out[ ]:
In [ ]: "Hola, 'Manuel' es mi nombre"
"Hola, 'Manuel' es mi nombre"
Out[ ]:
Entrada de valores por usuario
In [ ]: nombre = input()
Romulo
In [ ]: nombre*5
'RomuloRomuloRomuloRomuloRomulo'
Out[ ]:
In [ ]: saludo = "Hola, " + nombre
saludo
'Hola, Romulo'
Out[ ]:
In [ ]: "python" + str(3)
'python3'
Out[ ]:
In [ ]: [Link]()
'hola, romulo'
Out[ ]:
In [ ]: [Link]()
'HOLA, ROMULO'
Out[ ]:
In [ ]: saludo = [Link]()
saludo
'HOLA, ROMULO'
Out[ ]:
In [ ]: "Natalia Malaga" == "natalia malaga"
False
Out[ ]:
4. Operadores
4.1. Operadores Aritméticos
Adición
In [ ]: # ¿Cuánto dura un partido de fútbol con tiempo extra?
45 + 45 + 15 + 15
120
Out[ ]:
Multiplicación
In [ ]: # ¿Cuántos segundos tiene un día?
segundos = 24 * 60 * 60
segundos
86400
Out[ ]:
División
In [ ]: 47 / 9
5.222222222222222
Out[ ]:
División entera
In [ ]: int(47/9)
5
Out[ ]:
In [ ]: 47 // 9
5
Out[ ]:
Residuo de una división
In [ ]: 47 % 9
2
Out[ ]:
Potencia
In [ ]: 3 ** 2
9
Out[ ]:
Raíz cuadrada
In [ ]: 16 ** (1/2)
4.0
Out[ ]:
Paréntesis para orden de operaciones
In [ ]: 4 + 5 * 6
34
Out[ ]:
In [ ]: (4 + 5) * 6
54
Out[ ]:
In [ ]: 4 < 5
True
Out[ ]:
4.2. Operadores de Comparación
Igualdad
In [ ]: 8==(2*4)
True
Out[ ]:
Desigualdad
In [ ]: 8!=5
True
Out[ ]:
Menor
In [ ]: 3<4
True
Out[ ]:
Menor o igual que
In [ ]: 4<=4
True
Out[ ]:
In [ ]: 3<=5
True
Out[ ]:
Mayor
In [ ]: 8>4
True
Out[ ]:
Mayor o igual que
In [ ]: 4>=4
True
Out[ ]:
In [ ]: 6>=3
True
Out[ ]:
El orden lexicográfico
Es el orden en el que se colocan las palabras en un diccionario. En Python, el orden
lexicográfico se aplica a los objetos de tipo string, que se comparan carácter por carácter. Si
un carácter en una cadena es menor que otro en otra cadena, la primera cadena es
considerada menor que la segunda.
In [ ]: print("apple" < "banana")
print("cat" < "dog")
print("egg" < "eggs")
print("Zebra" < "apple")
print("apple" < "Apple")
True
True
True
True
False
El orden lexicográfico en Python es sensible a mayúsculas y minúsculas, por lo que las
cadenas que contienen letras mayúsculas se colocan antes que las que contienen solo letras
minúsculas. Es importante tener en cuenta que en Python, el orden lexicográfico se aplica a
todos los tipos de secuencias, incluyendo listas, tuplas y conjuntos, y no solo a las cadenas.
4.3. Operadores Lógicos
In [ ]: a=True
b=False
And
In [ ]: a and a
True
Out[ ]:
In [ ]: a and b
False
Out[ ]:
Or
In [ ]: a or b
True
Out[ ]:
In [ ]: # xor
a ^ b
True
Out[ ]:
Not
In [ ]: not a
False
Out[ ]:
Lógica proposicional
In [ ]: not((True and False) or (False and True))
True
Out[ ]:
4.4. Operadores de Asignación
Asignación simple
In [ ]: x = 10
x
10
Out[ ]:
Asignación múltiple
In [ ]: x = y = z = 10
x, y, z
(10, 10, 10)
Out[ ]:
Adición de asignación
In [ ]: x += 10
x
20
Out[ ]:
Sustracción de asignación
In [ ]: x -= 10
x
10
Out[ ]:
Multiplicación de asignación
In [ ]: x *= 10
x
100
Out[ ]:
División de asignación
In [ ]: x /= 10
x
10.0
Out[ ]:
Módulo de asignación
In [ ]: x %= 10
x
0.0
Out[ ]:
Potencia de asignación
In [ ]: x **= 10
x
0.0
Out[ ]:
División entera de asignación
In [ ]: x //= 10
x
0.0
Out[ ]:
Además, en Python también es posible utilizar la asignación condicional con el operador
ternario: if-else
In [ ]: x = 5 if y > 5 else 20
x
5
Out[ ]:
4.5. Operaciones de Identidad
Is
In [ ]: x = [1, 2, 3]
y = x
x is y
True
Out[ ]:
In [ ]: x = [1, 2, 3]
y = [1, 2, 3]
x is not y
True
Out[ ]:
Es importante tener en cuenta que los operadores de identidad se utilizan para comparar
objetos en memoria y no valores. Por lo tanto, dos objetos que contienen los mismos
valores pueden ser objetos diferentes en memoria.
In [ ]: x = [1, 2, 3]
y = [1, 2, 3]
x == y, x is y
(True, False)
Out[ ]:
4.6. Operadores de Pertenencia
In
In [ ]: x = [1, 2, 3]
2 in x
True
Out[ ]:
In [ ]: 4 not in x
True
Out[ ]:
Estos operadores se pueden utilizar con diferentes tipos de objetos, como listas, tuplas,
conjuntos, diccionarios, etc.
In [ ]: x = {'a': 1, 'b': 2}
'a' in x
True
Out[ ]:
5. Estructuras de Control
5.1. Condicionales
5.1.1. If
In [ ]: a = 33
b = 200
if b > a:
print("b es mayor que a")
b es mayor que a
5.1.2. Elif
In [ ]: a = 33
b = 33
if b > a:
print("b es mayor que a")
elif a == b:
print("a y b son iguales")
a y b son iguales
5.1.3. Else
In [ ]: a = 200
b = 33
if b > a:
print("b es mayor que a")
elif a == b:
print("a y b son iguales")
else:
print("a es mayor que b")
a es mayor que b
5.2. Iterativas
5.2.1. For
In [ ]: fruits = ["apple", "banana", "cherry"]
for x in fruits:
print(x)
apple
banana
cherry
5.2.2. While
In [ ]: i = 1
while i < 6:
print(i) # mientras i es menor que 6, se imprime
i += 1
1
2
3
4
5
6. Estructuras de Datos
6.1. Listas
In [ ]: lista=[3,2,1,3]
lista
[3, 2, 1, 3]
Out[ ]:
In [ ]: type(lista) # tipo de estructura
list
Out[ ]:
In [ ]: len(lista) # longitud o numero de elementos
4
Out[ ]:
In [ ]: lista[0] # llamar un elemento
3
Out[ ]:
In [ ]: lista[1:] # llamar un intervalo[cerrado:abierto]
[2, 1, 3]
Out[ ]:
In [ ]: [Link]() # ordenar la lista
lista
[1, 2, 3, 3]
Out[ ]:
In [ ]: [Link](reverse=True) # ordenar la lista de forma descendente
lista
[3, 3, 2, 1]
Out[ ]:
In [ ]: [Link](3) # imprime la posicion de 3, solo el mas cercano
0
Out[ ]:
In [ ]: [Link](3) # imprime las veces que esta repetido n
2
Out[ ]:
In [ ]: 2 in lista # imprime un booleano indicando si esta en la lista
True
Out[ ]:
In [ ]: [Link]() #inviertes el orden de la lista
lista
[1, 2, 3, 3]
Out[ ]:
Modificar elementos de listas
In [ ]: c2 = [i**2 for i in lista] # numeros al cuadrado
c2
[1, 4, 9, 9]
Out[ ]:
In [ ]: lista[2] = "Scala"
lista
[1, 2, 'Scala', 3]
Out[ ]:
Aumentar elementos
In [ ]: lista*3 # triplica len(lista)
[1, 2, 'Scala', 3, 1, 2, 'Scala', 3, 1, 2, 'Scala', 3]
Out[ ]:
In [ ]: [Link](3) # agregar al final, ID constante
lista
[1, 2, 'Scala', 3, 3]
Out[ ]:
In [ ]: lista = lista + [3] # ID diferente
lista
[1, 2, 'Scala', 3, 3, 3]
Out[ ]:
In [ ]: [Link]([7,8,9]) # agregar varios
lista
[1, 2, 'Scala', 3, 3, 3, 7, 8, 9]
Out[ ]:
In [ ]: [Link](0,20) # insertar "(posicion, valor)"
lista
[20, 1, 2, 'Scala', 3, 3, 3, 7, 8, 9]
Out[ ]:
Eliminar elementos
In [ ]: del lista [-1]
lista
[20, 1, 2, 'Scala', 3, 3, 3, 7, 8]
Out[ ]:
In [ ]: [Link](0) # borrar la posocion 0, default -1
20
Out[ ]:
In [ ]: [Link](3) # elimina el valor indicado, solo una vez, la primera coincidencia
lista
[1, 2, 'Scala', 3, 3, 7, 8]
Out[ ]:
In [ ]: [Link]() # elimina todos los valores de la lista
lista
[]
Out[ ]:
In [ ]: lista1 = [Link]() # diferente ID
print(id(lista))
id(lista1)
138915332708928
138915332546112
Out[ ]:
In [ ]: lista2 = lista # igual ID
print(id(lista))
id(lista2)
138915332708928
138915332708928
Out[ ]:
6.2. Matrices
In [ ]: matriz= [[1,2],[3,4]]
matriz[0][1]
2
Out[ ]:
In [ ]: matriz[1:][0:] # (matriz[1:])[:1]
[[3, 4]]
Out[ ]:
In [ ]: [lista]*3 # crea una matriz,igual ID
[[], [], []]
Out[ ]:
Otra forma de crear matrices:
In [ ]: notas=[]
x=3
for i in range(x): # x filas
[Link]([0]*x) # x columnas, ID diferente
notas
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
Out[ ]:
Entrada de valores de una matriz
In [ ]: f=int(input("ingrese el número de filas: "))
c=int(input("ingrese el número de columnas: "))
notas=[]
for i in range(0,f):
[Link]([0]*c)
print(notas)
for i in range(f):
for j in range(c):
print("ingrese la nota del ",i+1,"-ésimo estudiantes y del ",j+1,"-ésimo cu
#nota =float(input())
notas[i][j] = float(input())
print(notas)
ingrese el número de filas: 3
ingrese el número de columnas: 2
[[0, 0], [0, 0], [0, 0]]
ingrese la nota del 1 -ésimo estudiantes y del 1 -ésimo curso:
15
ingrese la nota del 1 -ésimo estudiantes y del 2 -ésimo curso:
13
ingrese la nota del 2 -ésimo estudiantes y del 1 -ésimo curso:
11
ingrese la nota del 2 -ésimo estudiantes y del 2 -ésimo curso:
17
ingrese la nota del 3 -ésimo estudiantes y del 1 -ésimo curso:
18
ingrese la nota del 3 -ésimo estudiantes y del 2 -ésimo curso:
12
[[15.0, 13.0], [11.0, 17.0], [18.0, 12.0]]
6.3. Cadena de Caracteres (inmutable)
In [ ]: # la cadena se comporta como una lista
cad= "hola mundo" # creando cadena
cad[0] # imprime la posicion 0 de la cadena
'h'
Out[ ]:
In [ ]: cad[-1]
'o'
Out[ ]:
In [ ]: cad[2:9]
'la mund'
Out[ ]:
In [ ]: list(cad)
['h', 'o', 'l', 'a', ' ', 'm', 'u', 'n', 'd', 'o']
Out[ ]:
In [ ]: cad + 's' # concatenando
'hola mundos'
Out[ ]:
In [ ]: [Link]('h','o') # reemplazamos 'h' por 'o'
'oola mundo'
Out[ ]:
In [ ]: [Link]() # la convierte a mayusculas
'HOLA MUNDO'
Out[ ]:
In [ ]: for elem in cad: # cad se comporta como un range
print(elem)
h
o
l
a
m
u
n
d
o
In [ ]: # k toma los valores [longitud,-1>, sumando -1(default:+1)
for k in range(len(cad)-1,-1,-1):
print(cad[k])
o
d
n
u
m
a
l
o
h
6.4. Tuplas
In [ ]: #La tupla es como una lista pero que no puede ser editada
tupla=(4,5,8,"contenido","elemento", [1,2,3],6.9) #creacion de tuplas
#los mismos codigos de lista funcionan con la tupla(*claro, cumplan la condicion de
lista = list(tupla) # conviertes la tupla en una lista
tupla = tuple(lista) #conviertes la lista en una tupla
6.5. Conjuntos
In [ ]: conjunto =set() #si no ponemos esto python lo toma como un diccionario
conjunto = {1,2,"letter", 4.21} # al hacer esos dos pasos tenemos un conjunto
#en un cunjunto puede ir cualquier valor menos otras colecciones
[Link](5) #agrega el valor indicado en cualquier lugar del conjunto
conjunto
{1, 2, 4.21, 5, 'letter'}
Out[ ]:
In [ ]: [Link](1) #elimina el valor indicado del conjunto
conjunto
{2, 4.21, 5, 'letter'}
Out[ ]:
In [ ]: [Link]() #borra todos los elementos del conjunto
conjunto
set()
Out[ ]:
In [ ]: 3 in conjunto # verifica si el valor indicado esta en el cojunto
False
Out[ ]:
In [ ]: 3 not in conjunto #verifica si el valor indicado no esta en el cojunto
True
Out[ ]:
Operaciones con conjuntos (dados los conjuntos a y b)
In [ ]: a =set()
a = {1,2,3,4,5}
b =set()
b = {4,5,6,7,8}
In [ ]: c = a | b # al hacer eso unes dos conjuntos
c
{1, 2, 3, 4, 5, 6, 7, 8}
Out[ ]:
In [ ]: c = a & b # intereseccion de conjuntos
c
{4, 5}
Out[ ]:
In [ ]: c = a - b # todo a menos b
c
{1, 2, 3}
Out[ ]:
In [ ]: c = a ^ b # diferencia simetrica
c
{1, 2, 3, 6, 7, 8}
Out[ ]:
In [ ]: [Link](c) # verifica si a es un subconjunto de c
False
Out[ ]:
In [ ]: [Link](a) #verifica si c es un superconjunto de a
False
Out[ ]:
In [ ]: [Link](b) #verifica si a y b son disconjuntos
False
Out[ ]:
In [ ]: a = frozenset({1,2,3}) #convierte inmutable a un conjunto
6.6. Diccionarios
{index ó keys: values} = {indices ó llaves: valores}
In [ ]: # los valores de los significantes(values) pueden ser listas o tuplas, e incluso di
diction ={'a':'armadillo','b':'burro','c':'cabra'}
diction['a'] # imprime el value del index 'a'
'armadillo'
Out[ ]:
In [ ]: [Link]() # imprime(armadillo,burro,...)
dict_values(['armadillo', 'burro', 'cabra'])
Out[ ]:
In [ ]: [Link]() # imprime(a,b,c)
dict_keys(['a', 'b', 'c'])
Out[ ]:
In [ ]: list([Link]()).index('cabra') # busca el indice de la cadena "cabra"
2
Out[ ]:
In [ ]: list([Link]())[list([Link]()).index('cabra')] # busca la llave de la
'c'
Out[ ]:
In [ ]: diction['d'] = 'delfin' # crea o edita un elemento
diction
{'a': 'armadillo', 'b': 'burro', 'c': 'cabra', 'd': 'delfin'}
Out[ ]:
In [ ]: # busca en index's y si no lo encuentra imprime: "no existe ese valor"
[Link]("b","no existe ese valor")
'burro'
Out[ ]:
Creación de tuplas dentro de una lista
In [ ]: [Link]()
dict_items([('a', 'armadillo'), ('b', 'burro'), ('c', 'cabra'), ('d', 'delfin')])
Out[ ]:
In [ ]: len(diction) # cuenta cuantos index hay en el diccionario
4
Out[ ]:
In [ ]: 'a' in diction # verifica si un index esta presente
True
Out[ ]:
In [ ]: 'armadillo' in [Link]() # si un value esta presente
True
Out[ ]:
In [ ]: 'burro' == diction['b'] # true, mismo ID
True
Out[ ]:
In [ ]: 'burro'in diction['b'] # true , mismo ID
True
Out[ ]:
In [ ]: for animal in diction:
# print(animal) # a,b,c
# print(diction[animal]) # armadillo,burro,..
if diction[animal] == 'burro':
print(animal)
In [ ]: [Link]() #borra todos lo elementos
diction
{}
Out[ ]:
7. Funciones
7.1. Break (ruptura)
In [ ]: # Salga del bucle cuando sea "banana":x
fruits = ["apple", "banana", "cherry", "pear"]
for x in fruits:
print(x)
if x == "banana":
break
apple
banana
In [ ]: # Salir del bucle cuando es "plátano", Pero esta vez el descanso llega antes de la
fruits = ["apple", "banana", "cherry", "pear"]
for x in fruits:
if x == "banana":
break
print(x)
apple
7.2. Continue
In [ ]: # Con la declaración continue podemos detener el iteración actual del bucle y conti
fruits = ["apple", "banana", "cherry", "pear"]
for x in fruits:
if x == "banana": # No imprime plátano
continue
print(x)
apple
cherry
pear
7.3. Range
In [ ]: # Devuelve una secuencia de números, comenzando desde 0 por defecto, e incrementos
for x in range(6):
print(x)
0
1
2
3
4
5
In [ ]: # Incremente la secuencia con 3 (el valor predeterminado es 1):
for x in range(2, 20, 3):
print(x)
2
5
8
11
14
17
7.4. Pass
In [ ]: # Los bucles no pueden estar vacíos, pero si para Alguna razón tiene un bucle sin c
for x in [0, 1, 2]:
pass
7.5. Def (funciones)
In [ ]: def sumar1(x,y): # x & y son los argumentos de entrada
return(x+y)
resultado=sumar1(3,4)
print(resultado)
type(resultado)
7
int
Out[ ]:
Sin Return
In [ ]: def sumar1(x,y): # x & y son los argumentos de entrada
print(x+y)
resultado=sumar1(3,4)
print(resultado)
type(resultado) # NoneType es un tipo de datos que representa la ausencia de valor
7
None
NoneType
Out[ ]:
Argumentos por default
In [ ]: def sumar(x,y=1): # y toma un valor por default
suma=x+y
return (suma,x,y)
sumar(3)
(4, 3, 1)
Out[ ]:
Una función que lee una lista de elementos numéricos.
In [ ]: def crearLista(n): # n es argumento de entrada para el número de elementos en la li
L =[]
#n = int(input("ingrese el número de elementos: "))
for e in range(n):
print("ingrese el ",e+1," elemento:")
elem = float(input())
[Link](elem)
return (L)
A = crearLista(3) # A toma el valor de la lista creada
A
ingrese el 1 elemento:
1
ingrese el 2 elemento:
2
ingrese el 3 elemento:
4
[1.0, 2.0, 4.0]
Out[ ]:
In [ ]: crearLista(3)[0]
ingrese el 1 elemento:
5
ingrese el 2 elemento:
7
ingrese el 3 elemento:
9
5.0
Out[ ]:
De una lista retorna el valor de la media
In [ ]: def media(lista):
n = len(lista)
media = sum(lista)/n
return media
media([0,1,2,3,4])
2.0
Out[ ]:
Composicion de funciones
In [ ]: media(crearLista(4)) # f(g(x))
ingrese el 1 elemento:
2
ingrese el 2 elemento:
4
ingrese el 3 elemento:
6
ingrese el 4 elemento:
8
5.0
Out[ ]:
In [ ]: def aprobado(nota):
return nota>=10.5
aprobado(media(crearLista(4))) # h(f(g(x)))
ingrese el 1 elemento:
13
ingrese el 2 elemento:
17
ingrese el 3 elemento:
4
ingrese el 4 elemento:
5
False
Out[ ]:
7.6. Lambda
In [ ]: x = lambda a : a + 10
x(5)
15
Out[ ]:
In [ ]: # Pueden tomar cualquier número de argumentos
x = lambda a, b, c : a + b + c
x(5, 6, 2)
13
Out[ ]:
Función anónima durante un corto período de tiempo
In [ ]: def myfunc(n):
return lambda a : a * n
In [ ]: mydoubler = myfunc(2) # Duplica el número
mydoubler(11)
22
Out[ ]:
In [ ]: mytripler = myfunc(3) # Triplica el número
mytripler(11)
33
Out[ ]:
8. Clases y objetos
8.1. Clases
In [ ]: class MyClass: # clase denominada MyClass
x = 5 # con una propiedad denominada x
8.2. Objetos
In [ ]: p1 = MyClass() # objeto denominado p1
p1.x
5
Out[ ]:
La función init ()
In [ ]: class persona:
def __init__(self, name, age):
[Link] = name
[Link] = age
p1 = persona("John", 36)
print([Link])
print([Link])
John
36
In [ ]: print(p1)
<__main__.persona object at 0x7e57be7538f0>
La función str ()
In [ ]: class persona:
def __init__(self, name, age):
[Link] = name
[Link] = age
def __str__(self):
return f"{[Link]}({[Link]})"
p2 = persona("John", 36)
print(p2)
p2
John(36)
<__main__.persona at 0x7e57be753980>
Out[ ]:
8.3. Métodos de Objetos
In [ ]: class persona:
def __init__(self, name, age):
[Link] = name
[Link] = age
def myfunc(self):
print("Hello my name is " + [Link])
p1 = persona("John", 36)
[Link]()
Hello my name is John
El parámetro self
Es una referencia a la instancia actual de la clase, y se utiliza para acceder a las variables que
pertenecen a la [Link]
In [ ]: class persona:
def __init__(mysillyobject, name, age): # mysillyobject en lugar de self
[Link] = name
[Link] = age
def myfunc(abc): # abc en lugar de self
print("Hello my name is " + [Link])
p1 = persona("John", 36)
[Link]()
Hello my name is John
Modificar propiedades de objeto
In [ ]: [Link] = 40
Eliminar propiedades de objeto
In [ ]: del [Link]
Eliminar objetos
In [ ]: del p1
La declaración de aprobación
In [ ]: class Person:
pass # para evitar obtener un error, en caso la clase este vacía