Qué es un lenguaje de programación?

Es una forma de dar instrucciones a un computador. Los computadores comprenden un lenguaje

binario (0 y 1). Lo que se copia en uno de estos lenguajes de programación necesita ser
transformados en 0 y 1, lo hace un “traductor” llamado interprete (va renglón tras renglón a lo
largo del código y lo ejecuta en el computador) o un compilador (coge el código completo, lo lee
completo y luego lo traduce).

Primer código. Leer el nombre

Print(´Felipe´)

Input: para poder guardar información

Name = Input(´What is your name?´)

Print (name)

¿Qué aprender del lenguaje? Terminos propios: Data type (que tipo de datos puede sosterner un
programa), acciones, mejores practicas (para escribir códigos).
Tipos de datos fundamentales en Python: es un valor en Python,
- Int: numeros
- Float
- Bool
- Str: letras
- List
- Tuple
- Set
- dict
Classes: es decir, se pueden crear nuevos tipos de datos (custon type)
Tipos de datos especializados: paquetes y modulos (extensiones)
None: nada (idea del 0 en matemática).
Type (que tipo de datos se están usando) ej. Print(type(2+4))

Int (integer) y float (floating point number)

Integer es un numero entero
Floating es un numero decimal
** es Elevado al
// es division redondeada a un integer
Modulo print(5%4): lo restante del numero.
Math functions (actions)
Print (Round (numero)) -> redondear
Abs (numero) -> valor absoulto

Precedentes del operador.

Primero va a resolver las multiplicaciones y luego las +-.
Orden.
1. Lo que esté dentro de paréntesis
2. Elevado a (**).
3. Multiplicación y división
4. Suma y Resta
Data type: Complex
Para números complejos
Función bin(): representación de numeros en binario
VARIABLES: Guardan la información que puede ser usada en el programa. Son formas para
guardar la información.
EXPRESIONES Y DECLARACIONES: Expresión: es el pedazo del código que produce un valor
Iq=500 -> Declaración
User_age=Iq/5 -> Expresión
Auggmented assignment operator: Sólo para hacer los cálculos más rápido
Valor = 5
Valor += 2 -> Así se va a sumar 2 a Valor, es decir ya será 7
TIPO DE DATO STR: STRING
Es un pedazo de texto (está en rojo), esta entre “”.
Long_string = ´´´ -> ya puedo empezar a copiar. ´´´
String Concatenation (sólo funciona con textos, no int): dos textos en una sola linea “hello” + “
Felipe”.
Type convertion: Puedo convertir un int en un str si quiero, sólo debo: str(100) y ya no será int más
Escape Sequence. Weather = “It\´s \”kind of \” sunny”. Con el \, puedo decir que lo que siga es un
str. “\t” es ingresar un tab. “ \n” significa que será en otra línea.
Formatted strings.
Name= “Felipe”
Age = “22”
Print (“hi” + name + “. You are “ +str(age) + “Years old”) -> debemos convertir el int a str.
Pero si se pone una f antes de empezar a escribir (o un .format después del print)
Name = “Felipe”
Age = “22”
Print (f ”hi {Name}. You are {age} years old).
A los Str, se le puede asignar un numero y así extraer valores de este:
Selfish = “me me me”
# 01234567
Print (selfish[0]) -> me arrojará la primera m
Cuando se usan las [ ], se está diciendo que debe empezar a mirar un número, pero si se le pone
un : se dice dónde parar. [0:6]. Si se pone : adicional, se puede ir como entre los números (cada
cuanto se toma el valor) [0:8:2]. Los negativos indica empezar al revés, el -1 sería el 7.
Inmutabilidad: Las string son irreemplazables, es decir,
Selfish = 01234567
Selfish[0] =”8” -> es un error, no se puede cambiar
Función len() : Lenght -> Calcula cuan largo es una palabra (numero de dígitos).
FUNCIONES BUILT-IN (METHODS)
Resaltadas en azules, los métodos son acciones que sólo las strings pueden realizar.
Por ejemplo con .upper, todo se convierte en mayúsculas o con .capitalize() sólo pone en
mayúsculas sólo la primera letra de la oración. Con .replace (“old”,”new”) puedo reemplazar texto
Quote =”ser o no ser”
Print (Quote.upper())
TIPO DE DATOS BOOL: BOOLEANS
Pueden ser True (0) o False (1).
TIPO DE DATOS LIST
Es como un string, pero se hace con [ ].
Data structure: Es una forma de organizar la información.
Amazon_cart = [“libro”, “gafas”]
Print(Amazon_cart[2])
List Slicing: Las listas se pueden cambiar (a diferencia de los strings)
Amazon_cart = [“libro”, “gafas”]
Amazon_cart[0] = “Pc”
Print(Amazon_cart)
MATRICES:
Matrix=[
[1,2,3]
[4,5,6]
[7,8,9]
]
Print(matrix[0][1]) -> 2
METODOS EN LISTAS:
El método .append permite agregar nuevos valores a la lista, con .insert, hay que decir la posición
y luego el valor. Con .extend permite agregar más de un valor
Basket = [1,2,3,4,5]
New_list = basket.append(100)
Print(basket) -> [1,2,3,4,5,100]
Print(new_list) -> None, porque es una nueva lista vacía.
Con .pop, se retira el último dígito que haya al final de la lista, pero .pop(0), elimina la primera.
El .remove, se le da el valor que se quiera eliminar (no la posición, el valor). El .clear elimina todo
lo de la lista.
Con .index(), va a decir en qué posición está tal valor. El .count dirá cuantas veces está un valor en
la matriz. .sort organiza los caracteres.
Basket = [1,2,3,4,5]
Print (“4” in basket) -> True
RANGE me ayuda a generar listas, por ejemplp list(range(100)) generará una lista entre 0 y 99 (100
dígitos)
LIST UNPACKING:
A, *other = [1, 2, 3]
Print(A) -> 1
Print(other) -> [2, 3]
NONE: Ausencia de valor, se puede usar, por ejemplo
Weapons = None
DATA TYPE- DICT: DICTIONARY: Valor key desordenado (no mantiene un orden). Mantienen más
información que las listas
Dictionary = {
“a” : 1, -> “a” es una key
“b” : 2
}
Print(dictionary[2]) -> 2
Las key deben ser inmutables, es decir no pueden cambiar (NO listas).
METHODS: Por ejemplo con .get( )
User = {a:2]
Print (user.get(“age”)) -> no va a hacer error, sino None.
.keys ayuda a buscar valores dentro de las keys, por ejemplo; igual que .values( )
User={a:”f”}
Print (“f” in user.keys()) -> False, porque f no es una Key.
.clear vacía el diccionario
.pop (“value”) -> remueve el ultimo key, pero devuelve el valor
.update permite modificar keys o agregar nuevas

DATA TYPE-TUPLE: Son como listas, pero a diferencia de ellas, no se pueden modificar
(inmutables)
My_tuple = (1,2,3,4,5)
My_tuple[1] = “z” -> error, el tuple no se puede modificar
No se puede modificar, es decir no se puede organizar, revertir (un tuple puede ser un key en un
diccionario)
METHODS:
.count (), cuenta cuantas veces hay un valor
DATA TYPE-SET: Colección desordenada de objetos únicos
My_set = {1,2,3,4,5,5,5,5,5}
Print(My_set) -> {1,2,3,4,5} -> solo valores únicos. NO repite.
Los sets no dejan ingresar a la información que hay en ellos
Print(My_set[0]) -> error
METHODS:
My_set = {1,2,3,4,5}
Your_set = {4,5,6,7,8,9,10}
Algo como diagramas de Venn.
Print(my_set.difference(Your_set)) -> {1,2,3}
My_set.discard(5) -> None, pero luego (print(my_set) -> {1,2,3,4}
Print(My_set.difference_update(Your_set)) -> remueve todos los elementos de otro set en este.
Este cambia el set para más adelante, el primero (.difference) no.
My_set.intersection (Your_set) -> {4,5}
My_set.isdisjoint (Your_set) -> Estos sets no tienen nada en comun?
.issubset() -> pregunta si uno de los sets está completamente dentro del otro (F o V)
.isssuperset() -> lo contrario que la pregunta aneterior
My_set.union (Your_set) -> {1,2,3,4,5,6,7,8,9,10} pint(my_set | your_set) -> es lo mismo.

LOGICA CONDICIONAL.
BOOLEANS
If condition:
Is_old = True -> Si fuera False, el print de if no imprimiría nada, pero sí el de Else
Is_licensed = True
If is_old:
Print (“you are old enough to drive!”)
Elif is_licenced:
Print (“You can drive now!”) -> Otra condición
Else:
Print (“you are not of age!”) -> En caso de que todo sea false
En este caso queremos mirar ambos, ya que queremos mirar tanto si tiene la edad y si la licencia
es verdadera, en el código anterior solo estamos mirando una de ellas sin importar la otra. Se
pueden tener tantos Elif cuantos se quieran.
If is_old and is_licenced:
Print (“You can drive now!”)
TRUTHY AND FALSY:
Es possible crear Booleans con strings o int, con Bool()
Is_old = bool(“hello”) -> esto será Truthy
Is_licenced = bool(“0”) -> esto será falsy
TERNARY OPERATOR: Es una forma de hacer condicionales un poco más “limpia”.
Condition_if_true if condition else condition_if_false
Un ejemplo para saber si alguien te puede enviar mensajes a Fb.
Is_friend = True
Can_message = “message allowed” if is_friend else “not allowed to message”.
SHORT CIRCUITING: Cuando la maquina verifica algo y no necesita verificar el resto, no lo hace,
ahorra trabajo.
OPERADORES LÓGICOS (entre 2 cosas): and, or, >, >, ==, != (no igual), >=, <=, not (opuesto)
Print(not(1==1)) -> False
EJERCICIO:
Quiero saber si un personaje es un mago pero que no sea experto:
If is_magiciand and not is_expert:
PALABRA CLAVE IS:
== Chequea por la igualdad en valor, el is verifica si la ubicación en la memoria es la misma, es
decir no pueden ser valores equivalentes, tiene que ser el mismo valor. Con listas es diferente, ya
que 2 listas iguales no corresponden a la misma lista, igual que con diccionarios, sets, tupples.
LOOPS
Permite correr línea de códigos una y otra y otra vez, miles o millones de veces si se desea.
Permite iterar elementos que tengan varios valres..
FOR:
For ítem in [1,2,3,4,5] -> Iterable
Print (ítem) -> los muestra pero en orden vertical
For ítem in (1,2,3,4,5)
For x in [“a”, “b”, “c”]
Print (ítem, x)
Un iterable es una colección de objetos que pueden ser iterables, puede ser lista, diccionario,
tuple o set, incluso un string, es decir pueden ir uno por uno para revisar cada ítem en la colección.
User = {
“name”: “Golem”
“age”: 5006,
“can_swim”: False
}
For ítem in user:
Print (ítem) -> muestra las key del diccionario
METHODS PARA ITERAR EN DICCIONARIOS:
.items permite imprimir tanto las key como sus correspondientes
.values permite ver los valores correspondientes
.keys permite ver las keys
For key,values in user.items()
Print (key,values)
Los Int no se pueden iterar
Ejercicio:
My_list =[1,2,3,4,5,6,7,8,9,10]
Counter = 0
For ítem in my_list:
Counter = counter + item
Print (counter) -> 55
Con RANGE se puede crear loops
For number in range(100)
Print (number), o podría ser
Print (“hola”) -> pondría hola 100 veces
Con ENUMERATE () puedo enumerar los componentes de una colección de datos.
While condition:
I=0
While I < 50:
Print (i) -> va a poner 0 infinitas veces
BREAK
BREAK es otra palabra clave en Python (ayuda a parar el código)
I= 0
While i<50:
Print (i)
I = I + 1 -> imprimirá del 0 al 49 (llevarlo hasta el false)

También se puede usar ELSE.

My_list = [1,2,3]

For ítem in my_list:

Print (item)

I=0

While I < len(my_list)

Print(i)

I=I+1

CONTINUE permite que el loop regrese al renglón inicial

For ítem in my_list:

Continue
Print (item) -> No va a imprimir nada, porque continue regresa el códigov al renglón inicial.

Con end =”” puedo poner todo en una sola línea en una iteración

Print (“”, end = “”)

FUNCIONES

Usando def Podemos decirle a Python que vamos a crear una nueva función:

Def say_hello ()

Print (“hello”)

Say_hello() -> va a ser una nueva función

Sirve para definir cosas y acortar codigos, es decir si se quiere repetir algo, sólo basta con poner la
función, no toca repetir el código

PARAMETROS Y ARGUMENTOS POSICIONALES:

Un argumento es usado cuando le estoy dando valores a una función, mientras que los
parámetros son cuando se define la función. Necesitan estar en la posición que se les indica:

Def say_hello (name, emoji) -> name y emoji son parámetros

Print (f”hola {name} {emoji})

Say_hello (“Felipe”, “=)”) -> Felipe y =) son los argumentos

ARGUMENTOS KEYWORDS:

Nos permiten no preocuparnos sobre la posición en la que los parámetros están:

Say_hello (Emoji = “=)”, name= “Felipe”)

PARAMETROS PREDEFINIDOS:

Say_hello (name=”Felipe”, emoji = “=)”)

FUNCIÓN RETURN ():

Normalmente para definer funciones se necesita return:

Def sum(num1, num2):

Return num1+num2

Print (sum(4,5)) -> Si no pusiera Return, imprimiria None

Una función debe realizar una cosa bien y debe dar algo (return).

DOCSTRINGS:

Permiten comentar las funciones para mirar qué es lo que hace:

Def test(a)
 ´´´

Info: Esta función se encarga de imprimir el parámetro a.

´´´

Print (a)

*ARGUMENTO:

Def func(*args):

Return sum (arg)

Func (1,2,3,4) -> así me deja introducir muchos valores

**KEY ARGUMENTOS:

Def func (*args, **kwargs): $48.284.260.74 2039/11/18

Print (kwargs)

Print(func(1,2,3,4,5, num1=5, num2=10) -> me generará un diccionario {num1 : 5, num2 : 10}

SCOPE:

Me permite saber a cuáles variables tengo acceso.

Total = 0

Def count():

Global total

Total += 1 -> con global me permite usar la variable total que ya existía

Return total

Print(count())

NONLOCAL:

Me permite usar funciones dentro de funiones, ósea, no se quiere crear una nueva variable, sino
usar una que ya existe