Skip to content

Commit d7fb08a

Browse files
authored
Merge pull request mouredev#5233 from estelacode/eml
#1 - Python
2 parents 9a1385b + 1daed6a commit d7fb08a

File tree

1 file changed

+267
-0
lines changed
  • Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/python

1 file changed

+267
-0
lines changed
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,267 @@
1+
# 01 - OPERADORES Y ESTRUCTURAS DE CONTROL
2+
3+
## 1. Crea ejemplos utilizando todos los tipos de operadores de tu lenguaje:
4+
# Aritméticos, lógicos, de comparación, asignación, identidad, pertenencia, bits...(Ten en cuenta que cada lenguaje puede poseer unos diferentes)
5+
6+
7+
### Operadores Aritméticos : permiten realizar operaciones aritméticas y devolver su resultado.
8+
#-----------------------------------------------------------------------------
9+
x = 2; y = 3
10+
print("Operadores aritméticos")
11+
print("x+y =", x+y) # operador + (suma)
12+
print("x-y =", x-y) # operador - (resta)
13+
print("x*y =", x*y) # operador * (multiplicación)
14+
print("x/y =", x/y) # operador / (dividion)
15+
print("x%y =", x%y) # opoerador % (modulo)
16+
print("x**y =", x**y) # operador ** (potencia)
17+
print("x//y =", x//y) # operador // (división entera)
18+
19+
# Nota: el orden de prioridad de losoperadores aritméticos es el siguiente:
20+
# () Parentesis,
21+
# ** Potencia,
22+
# -x Negacion,
23+
# * / // % Multiplicación, División, Cociente, Módulo
24+
# + - Suma, Resta
25+
26+
27+
28+
### Operadores de Asignación : permiten realizar una operacion y asignar el resultado a una variable.
29+
#-----------------------------------------------------------------------------
30+
# Operador = asigna un valor a una variable
31+
# Operador += equivalente a sumar y asignar el resultado a la variable inicial.
32+
# Operador -= equivalente a restar y asignar el resultado a la variable inicial.
33+
# Operador *= equivale a multiplicar una variable por otra y almacenar el resultado en la primera.
34+
# Operador /= equivale a dividir una variable por otra y almacenar el resultado en la primera.
35+
# Operador %= equivale a hacer el módulo de la división de dos variables y almacenar su resultado en la primera.
36+
# Operador //= la operación cociente entre dos variables y almacena el resultado en la primera.
37+
# Operador **= equivale a realiza la operación exponente del primer número elevado al segundo, y almacena el resultado en la primera variable.
38+
# Operador &= equivale a realiza la operación AND entre dos variables y almacena el resultado en la primera variable.
39+
40+
a=2; b=3
41+
print("Operadores de asignación")
42+
x=a; x+=b; print("x+=", x) #5
43+
x=a; x-=b; print("x-=", x) #-1
44+
x=a; x*=b; print("x*=", x) #6
45+
x=a; x/=b; print("x/=", x) #0.6666666666666666
46+
x=a; x%=b; print("x%=", x) #2
47+
x=a; x//=b; print("x//=", x) #0
48+
x=a; x**=b; print("x**=", x) #8
49+
x=a; x&=b; print("x&=", x) #2
50+
x=a; x|=b; print("x|=", x) #3
51+
52+
53+
### Operadores Relacionales : permiten realizar operaciones de comparación y devolver True o False.
54+
#-----------------------------------------------------------------------------
55+
x=2; y=3
56+
print("Operadores Relacionales")
57+
print("x==y =", x==y) # False Operador de comparación (igualdad)
58+
print("x!=y =", x!=y) # True Operador de comparación (desigualdad)
59+
print("x>y =", x>y) # False Operador de comparación (mayor que)
60+
print("x<y =", x<y) # True Operador de comparación (menor que)
61+
print("x>=y =", x>=y) # False Operador de comparación (mayor o igual que)
62+
print("x<=y =", x<=y) # True Operador de comparación (menor o igual que)
63+
64+
65+
### Operadores Lógicos : permiten realizar operaciones logicas y devolver True o False.
66+
#-----------------------------------------------------------------------------
67+
# and Devuelve True si ambos elementos son True True and True = True
68+
# or Devuelve True si al menos un elemento es True True or False = True
69+
# not Devuelve el contrario, True si es Falso y viceversa not True = False
70+
71+
72+
# AND:
73+
#El operador and evalúa si el valor a la izquierda y el de la derecha son True, y en el caso de ser cierto, devuelve True. Si uno de los dos valores es False, el resultado
74+
# será False.
75+
print(True and True) # True
76+
print(True and False) # False
77+
print(False and True) # False
78+
print(False and False) # False
79+
80+
81+
# OR:
82+
# El operador or devuelve True cuando al menos uno de los elementos es igual a True. Es decir, evalúa si el valor a la izquierda o el de la derecha son True.
83+
84+
print(True or True) # True
85+
print(True or False) # True
86+
print(False or True) # True
87+
print(False or False) # False
88+
89+
90+
# NOT:
91+
# El operador not devuelve el opuesto de un valor. Es decir, True se convierte en False y False se convierte en True.
92+
print(not True) # False
93+
print(not False) # True
94+
print(not not not not True) # True
95+
96+
# Se puede usar 0 y 1 para representar False y True respectivamente.
97+
print(not 0) # True
98+
print(not 1) # False
99+
100+
101+
# Nota: el orden de aplicación de los operadores puede influir en el resultado. De mayor a menor prioridad: not, and y or.
102+
print(False and False or True) # True
103+
print(True or False and False) # True
104+
print(0 and not 1 or 1 and not 0 or 1 and 0) #(False and False or True and True or True and False) --> # True
105+
106+
107+
# Operadores de Identidad: permiten comprobar si dos variables hacen referencia al mismo objeto, devolviendo True en el cado de ser cierto.
108+
#-----------------------------------------------------------------------------
109+
# is Devuelve True si hacen referencia a el mismo objeto
110+
# is not Devuelve False si no hacen referencia a el mismo objeto
111+
112+
a = 10 ; b = 10 ; print(a is b) # True
113+
# La funcion id() Devuelve el identificador único de un objeto. Ambos apuntan a la misma ubicación en memoria al ser el mismo valor.
114+
print(id(a)) # 9756512 Este valor es la dirección de memoria del objeto
115+
print(id(b)) # 9756512 Este valor es la dirección de memoria del objeto
116+
117+
a = 10 ; b = 10 ; print(a is not b) # False --> ambas variables apuntan a el mismo objeto.
118+
a = 10 ; b = 20 ; print(a is not b) # True --> las variables no apuntan a el mismo objeto.
119+
120+
121+
# Operadores de pertenecia: permiten comprobar si un objeto pertenece a una secuencia ( lista, tupla , conjunto o cadena), devolviendo True en el caso de ser cierto.
122+
#-----------------------------------------------------------------------------
123+
# in Devuelve True si el objeto pertenece a la secuencia
124+
# not in Devuelve False si el objeto no pertenece a la secuencia
125+
126+
a = 10 ; print(a in [10,20,30]) # True
127+
a = 50 ; print(a in [10,20,30]) # False
128+
print([1, 2] in [4, [1, 2], 7]) # True
129+
print(3 not in [1, 2, 4, 5]) # True
130+
x = ["apple", "banana"] ; print("banana" in x) # True
131+
print('s' in 'perro') # False
132+
133+
134+
# Operadores de bitwise
135+
#-----------------------------------------------------------------------------
136+
# AND (&) Realiza una operación AND bit a bit --> Compara cada bit de dos operandos y devuelve 1 si ambos bits son 1, de lo contrario devuelve 0.
137+
a = 4 ; bin_a = bin(a)
138+
b = 5; bin_b = bin(b)
139+
140+
print(f"AND: {bin_a} & {bin_b} = {bin(a & b)}")
141+
142+
# OR (|) Realiza una operación OR bit a bit --> compara cada bit de dos operandos y devuelve 1 si al menos uno de los bits es 1.
143+
print(f"OR: {bin_a} | {bin_b} = {bin(a | b)}")
144+
145+
# NOT (~) Realiza una operación NOT bit a bit --> ealiza la operación not sobre cada bit del número que le introducimos, es decir, invierte el valor de cada bit,
146+
# poniendo los 0 a 1 y los 1 a 0. El comportamiento en Python puede ser algo distinto del esperado. En realidad ~a sería -a-1
147+
148+
print(f"NOT: ~{bin_a} = {bin(~a)}")
149+
150+
# XOR (^) Realiza una operación XOR bit a bit --> compara cada bit de dos operandos y devuelve 1 si exactamente uno de los bits es 1, pero no ambos.
151+
print(f"XOR: {bin_a} ^ {bin_b} = {bin(a ^ b)}")
152+
153+
# Operadores de Desplazamiento:Los operadores de desplazamiento mueven los bits de un número hacia la izquierda (<<) o hacia la derecha (>>) en la cantidad especificada.
154+
#-----------------------------------------------------------------------------
155+
156+
# Desplazamiento Derecha (>>) Desplaza los bits a la derecha
157+
158+
print(f'{bin_a} >> 2 = {bin(a>>2)}')
159+
print(f'{bin_b} >> 2 = {bin(b>>2)}')
160+
161+
# Desplazamiento Izquierda (<<) Desplaza los bits a la izquierda
162+
163+
print(f'{bin_a} << 2 = {bin(a<<2)}')
164+
print(f'{bin_b} << 2 = {bin(b<<2)}')
165+
166+
167+
## 2. Utilizando las operaciones con operadores que tú quieras, crea ejemplos:
168+
# que representen todos los tipos de estructuras de control que existan en tu lenguaje:
169+
# Condicionales, iterativas, excepciones...
170+
171+
## Estrcuturas de control
172+
# Condicionales
173+
174+
# If-elif-else
175+
def grupo_edad(edad):
176+
if edad <=0:
177+
print('la edad no puede ser negativa, ni igual a 0')
178+
elif 0 > edad <=3:
179+
print('bebe')
180+
elif 4 >= edad <=12:
181+
print('niño')
182+
elif 13 >= edad <=17:
183+
print('adolescente')
184+
elif 18>= edad <=60:
185+
print('adulto')
186+
else:
187+
print('mayor de 60')
188+
189+
grupo_edad(-5)
190+
grupo_edad(0)
191+
grupo_edad(4)
192+
grupo_edad(17)
193+
grupo_edad(25)
194+
grupo_edad(80)
195+
196+
197+
# Iterativas
198+
for i in range(5):
199+
print(i)
200+
201+
202+
# Ciclos anidados
203+
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
204+
205+
for row in matrix:
206+
for item in row:
207+
print(item)
208+
209+
210+
x = 3
211+
while x > 0:
212+
x -=1
213+
print(x)
214+
215+
# Excepciones
216+
# Una excepción es un evento inesperado que ocurre durante la ejecución del programa.
217+
# Control de excepciones: try, except, else, finally.
218+
219+
"""
220+
Principales tipos de excepciones:
221+
* TypeError : Ocurre cuando se aplica una operación o función a un dato del tipo inapropiado.
222+
* ZeroDivisionError : Ocurre cuando se itenta dividir por cero.
223+
* OverflowError : Ocurre cuando un cálculo excede el límite para un tipo de dato numérico.
224+
* IndexError : Ocurre cuando se intenta acceder a una secuencia con un índice que no existe.
225+
* KeyError : Ocurre cuando se intenta acceder a un diccionario con una clave que no existe.
226+
* FileNotFoundError : Ocurre cuando se intenta acceder a un fichero que no existe en la ruta indicada.
227+
* ImportError : Ocurre cuando falla la importación de un módulo.
228+
229+
"""
230+
231+
def division(a, b):
232+
try:
233+
result = a / b
234+
except ZeroDivisionError as e:
235+
print('catch ZeroDivisionError:', e)
236+
except TypeError as e:
237+
print('catch TypeError:', e)
238+
else:
239+
print("result is", result)
240+
finally:
241+
print("'This is always executed'")
242+
243+
division(10, 0)
244+
division('a', 'b')
245+
division(12, 3)
246+
247+
248+
## 3. Debes hacer print por consola del resultado de todos los ejemplos.
249+
250+
##DIFICULTAD EXTRA (opcional):
251+
# Crea un programa que imprima por consola todos los números comprendidos entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3.
252+
# Resultado : 10, 14, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52
253+
254+
255+
# solucion 1
256+
print("Solucion 1")
257+
for i in range(10, 56,2):
258+
if i != 16 and i % 3 != 0:
259+
print(i)
260+
261+
262+
# solucion 2
263+
print("Solucion 2")
264+
for i in range(10, 56):
265+
if i%2 == 0 and i != 16 and i % 3 != 0:
266+
print(i)
267+

0 commit comments

Comments
 (0)