-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathproyecto.py
More file actions
1996 lines (1499 loc) · 61 KB
/
proyecto.py
File metadata and controls
1996 lines (1499 loc) · 61 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#...................................................................................primer modulo
"" """Empiezo otra vez ya que no se encontro practica.py"""
gracias = "gracias"
# hay palabras reservadas en python
"""and
as()
assert()
async()
await()
break()
class()
continue()
def()
del()
elif()
else()
except()
False()
finally()
for()
from()
global()
if()
import()
is()
lambda()
None
nonlocal()
not
or
pass
raise
return
True
try
while
with
yield """
'' """Palabras reservadas, tipo de datos, variables, constantes y
operadores"""
"Comentarios"
# se pueden hacer comentarios en python usando el simbolo #
# se puede sacar con atl 3
# se pueden hacer de una sola linea # o multilinea """ """ ''' '''
dsdf = print( "Mundo Hola")
''' Tipos de datos '''
# estan los datos Numericos, Diccionario, Booleanos, Sets(Conjuntos),
#str
california= "las cosas que nunca se tendrán"
print(california)
#int
d=34
e=45
s=67
m= s+e+d
print(m)
#boleeano
pedro=1
print(pedro==1)
'' 'Entrada de datos'
valor = 45
print(type(valor))
# Tipos de secuencia
'' '''' operadores de asignacion '''
# Permite asignar un valor a una varianle, usando para ello el operador "=" Estos operadores permiten realizar llamada asignacion aumentada, tecnica
# que implica un codigo mas corto de describir , la vez que mas ediciente en tiempo de ejecicionn esta asignacion aunkmentada se realiza generalmente
# entre operadores numericos.4
"="#asina el valor del operando de la parte derecha al de la izquieda
# x = "y"
"+="# suma el valor que hay en el operando de la parte izquierda al de la derecha y lo asigna al de la izquierda
# x += y
"-=" # resta el valor que hay en el operando dee la parte izquierda al de la derecha y lo asigna al de la izquierda
#x -= y
"**="# lleva el valor que hay en el operando de la parte izquierda al de la derecha y lo asigna al de la izquierda
#x *= y (x = x ** y)
"/="# divide el valor que hay en el operando de la parte izquierda al de la parte derecha y lo asigna al de la izquierda
# x /= y (x = x ** y)
"//=" # realiza la division entera del valor del operador de la parte izquierda entre el de la derecha y lo asigna al de la izquierda
# x//= y (x = x //y)
" %= "# realiza la division entera del valor del oprerando de la parte izqauierda entre el de la derecha y lo asigna al de la izquierda:
# x %= y (x = x % y)
"*="# Multiplica el valor que hay en el operando de la parte izquierda al de la derecha y lo asigna al de la izquierda:
# x *= y (x = x * y)
'' ''' Operadores aritmetricas '''
" % "# modulo [7%2=1] resto de la division entera de x ente y
"+"# suma [2+5=7] x mas y
"-"# resta [5-3=6] x menos y
"*"# Multiplicación [3*2=6] x multiplicado por y
"**" #exponente [2**4=16] x elevado a y
"/"# division [6/2=3] x division entre y
"//"#division entera [7/2=3] cociente de la division entera de x entre y
"-"# negacion [-5=-5] valor x en negativo
'' '''Operadores relacionales '''
"" ''' nos permiten comparara dos o mas valores y nos devuelven un resultado booleano'''
"=="# igualdad Evalua si el valor del operador de la izquierda es igual que el de la derecha , devolvioendo True en caso afirmativo
# 5==6 (False) 5==5 (True)
'!='# Distintos Evalua si el valor del operando de la izquiersa es distinto que el de la derecha
# 5!= 6 (True) 5==5 (False)
'>'# Mayor que Evalua si el valor del operador de la izquierda es mayor que el de la derecha
# 5 > 6 (False) 6 > 5 (True)
'<'# menor que Evalua si el valor del operando de la izquierda es menor que el de la derecha
# 5 < 6 (True) 6 < 5 (False)
'<='# Mayor o igual que Evalua si el valor del operando de la izquierda es mayor o igual que el de la derecha
# 5 >= 6 (False) 7 >= 6 (True)
'>='# Menor o igual que Evalua si el operando de la izquierda es menor o igual que el de la derecha
'' ''' operadores logicos '''
'' ''' nos permite uni valores comparados o negar (invertir) un valor. Nos
devuelven un resultado vooleano (verdadero o falso)'''
"and"# devuelve true si los dos operadores son true, en caso contrario devuelve false
# True and True (True)
# True and False (False)
"or"# Devuelve true si alguno de los operadores es verdadero en caso contrario devuelve false
# True or False (True)
# False or False (False)
"not"# Invierte el valor del operando sobre el que actua
# not True = (False)
'' ''' Precedencia de los operadores '''
'' ''' Hemos visto operadores relacionales,logicos,aritmetricos. pero cuando se unen
diferentes tipos de operadores, existen unas reglas de precedecia:'''
'' 'reglas de precedencia'
''# Primero Los parentesis () tiene la maxima prioridad
''# Segundo Las expresiones aritmetricas, respetando sus propias reglas
''# tercer Las expreciones relacionales o de comparacion
''# cuarto Las Expreciones logicas
'' ''' Cambiando tipos de variables'''
'''convertir variables de un tipo a otro se denomina casting, en python podemos
comprobar el tipo de una variable mediante la funcion type(), o bien mediante
la funcion isInstance(), como se muestra a conbtinuacion'''
asd = 2.0
ase = 1
print(type(asd))#<class 'float' >
print(type(ase))#<class 'int' >
'' ''' podemos cambiar el tipo de una varible mediante las funciones
int(), complex() y str() '''
print(int(18.6))
print(float(44))
print(complex(2))
'' ''' otras funciones que nos pueden ayudar bastante en la conversion y manejo de
numeros son:'''
'round()'# nos permite redondear un numero a su entero cercano
'max()'# nos devolvera el numero mayor de una secuencia de nuemrtos pasado como parametro
'min()'# nos devolvera el numero menor de uma secuencia de numeros pasada como parametro
'' ''' Trabajando con cadenoas de caracteres '''
''' Para invluir iuans comillas dentro de una cadena de caracteres devemos recurrir
a cualquiera de lsa dos opciones de se ven a conrinuacion, bien jugar con la
alternativa entre comillas dobles y simples, o bien ultilizar el caracter de
barra invertida o backslash (\) alt 92'''
"" 'Este texto invluy unas "" '
'' ''' una de ls operaciones mas comunes que se puede realizar con cadenas es
la concatenacion op sums de cadenas se suele realizar con el oprendor +,
aunque hay varias forms de realizarlas, como se ve a continuacion.
'''
c = 'esto es una cadena con\n dos lineas '
print(c+c)
'' ''' Tambien es posible realizar una multiplicacion de cadenas'''
diezespacios = ' '*10
print("aqui hay 10 espacios"+ diezespacios)
# los indice nos permiten posicionarnos en un caracter especifico de una cade
# y acceder a el. representan a un umero [indice], que empezando por el 0 indica
# el caracter de la primera posicion, y asi sucesivamente:
palabra = "python"
print(palabra[0], palabra[1])
# un inide negaticvo, hace referencia al caracter de la codena comenzando por la
# ultima posicion y en sentido inverso. Esto quiere decir que el indice -1 sera
# igual a la ultima posicion, -2 al penultimo, asi sucesivamente:
print(palabra[-1])
'' '''El slicing (rebanando) es una capacidad que tienen las cadenas de devolver un
subconjunto o subcadena utilizando dos índices [inicio:fin]. El primer
índice indica donde empieza la subcadena (se incluye el carácter) y el segundo
índice indica donde acaba la subcadena (se excluye el carácter).'''
print(palabra[0:2])
'' '''Si en el slicing no se indica un índice, se toma por defecto el principio y el final
(incluidos)
'''
print(palabra[2:])
print(palabra[:2])
print(palabra[:])
# Si un índice se encuentra fuera del rango
# de la cadena, el intérprete de Python dará error:
'''Pero con slicing esto no pasa y simplemente se considera el espacio como vacío:'''
print(palabra[:99])
print(palabra[99:])
'''Una propiedad de las cadenas es la inmutabilidad,
no se pueden modificar. Si intentamos reasignar un carácter, no nos dejará:'''
#palabra[0]= 'N' no nos dejara va a decir: 'str' object does not support item assignment
'''Sin embargo, utilizando slicing y concatenación, podemos generar nuevas cadenas fácilmente:
'''
palabra = "N" + palabra[1:]
print (palabra)
""" para poder contar palabras es muy util la funciom len()"""
print(len(palabra))
''' Como se aprecia anteriormente, la función print() incluye un salto de línea
cada vez que se ejecuta. Si queremos que Python no añada un salto de línea al
final de un print(), se definirá el argumento end con el carácter que
deseemos implementar como terminador de línea:
'''
print("Una cadena", end=" ")
print("Otra cadena")
print("Una cadena", end=", ")
print("Otra cadena")
####################################################################################################
#range () función devuelve una secuencia
# de números, comenzando desde 0 de forma predeterminada, se incrementa en 1
'ejemplo'
#Cree una secuencia de números del 3 al 19, pero incremente en 2 en lugar de 1:
x = range(3, 20, 2)
for n in x:
print(n)
'''Para permitir la introducción de múltiples valores recurriremos a la instrucción
for, que veremos más adelante:'''
valores = []
print("Introduce 3 valores")
for x in range(10):
valores.append( input("Introduzca un valor: ") )
print(valores)
''' Esta función acepta caracteres especiales como las
tabulaciones (/t) o los saltos de línea (/n):
'''
print("Un texto\tunatabulación")
print("Un texto\nuna nueva línea")
'''
Para evitar los caracteres especiales, debemos indicar que una cadena
es cruda (raw), anteponiendo una r a la cadena de caracteres a mostrar,
como se ve a continuación
'''
print(r"C:\nombre\directorio") # r = raw (cruda)
#Podemos utilizar """ (triples comillas) para cadenas multilínea:
print("""Una linea
otra linea
otra linea\tuna tabulación""")
''' Utilizando el parámetro sep, podemos separar cada uno de los caracteres de la
cadena con el carácter indicado y con el parámetro end podemos finalizar la
cadena con el carácter que le indiquemos: '''
print(1, 2, 3, 4)
print(1, 2, 3, 4, sep='*')
print(1, 2, 3, 4, sep='#', end='&')
'''
Existe una funcionalidad en las cadenas de texto que nos permite formatear
información cómodamente utilizando identificadores referenciados, para ello
usamos el método format():
'''
texto = "otro texto"
num = 10
c = "un texto '{}' y un número '{}'".format(texto,num)
print(c)
''' O podemos utilizar un identificador con una clave y luego pasarlas al método
format():
'''
print(( "Un texto '{t}' y un número '{n}'").format(t= texto, n= num))
print(("{t},{t},{t}").format(t=texto))
#También podemos realizar un formateo
#avanzado, alineando a la derecha en 30 caracteres de la siguiente manera:
print(("{:>30}").format("palabra"))
# O bien alineando a la izquierda en 30 caracteres
print(("{:30}").format("palabra"))
# O bien alineando al centro en 30 caracteres
print(("{:^30}").format("palabra"))
'''Para realizar un truncamiento de 5 caracteres procederemos de la siguiente
manera:
'''
print(("{:.5}").format("palabra"))
'''Combinando varios de estos formateos, hacemos un alineamiento a la derecha
en 30 caracteres con truncamiento de 3:'''
print(("{:>30.3}").format("palabra"))
'''Y, por último, para formatear números enteros, rellenados con ceros,
realizaremos lo siguiente:'''
print("{:04d}".format(10))
print("{:04d}".format(100))
print("{:04d}".format(1000))
''' Y eso mismo, si lo quisiéramos hacer con números decimales o flotantes,
lo haremos como a continuación:'''
# Se imprimiran 7 caracteres (inluido el punto), de los cuales 3 serán decimales
print("{:07.3f}".format(3.1415926))
print("{:07.3f}".format(153.21))
'' ''' Tipos de datos avanzados '''
'''Sumarios'''
''' ............................................................'''
"listas"
"tuplas"
"sets" 'o (conjuntos)'
"Diccionarios"
#...............................................................................................
'' '''Listas'''
# Una lista es una estructura en python de datos formada por una secuencia
# ordenadas de objetos, es una coleccion ordenada y mosificable que permite
# miembros duplicados.
# las listas en python son hererogeneas porque pueden estar formadas por
# elementos de distintos tipos. incluidos otras listas y mutables. porque sus
# elementos pueden modificarse.
numeros = [1,2,3,4]
print(numeros)
# atravez se los indices de una lista podemos cambiar el valor de sus elementos
# haciendo de esta forma la lista mutable
datos = [4,"Una cadena",-15,3.14,"Otra cadena"]
print(datos)
print(type(datos))
'''
Tanto el acceso a los elementos, que se realiza mediante índices, como el slicing,
se realizan de forma muy similar a las cadenas de caracteres, pudiendo también
acceder a los elementos desde el final con índices negativos, como hemos visto
con las cadenas:
'''
print(datos)
print(datos[0])
print(datos[-1])
print(datos[-2:])
print(datos[1:3])
'''
Las listas también aceptan el operador de suma, cuyo resultado es una nueva
lista que incluye todos los ítems:
'''
numeros = numeros + [5,6,7,8]
print(numeros)
'''
Las listas, como bien indicamos anteriormente, son modificables, y para ello
modificamos el valor a través de sus índices:
'''
pares = [0,2,4,5,8,10]
print(pares)
pares[3]= 6
print(pares)
'''
Asimismo, integran funcionalidades internas, como el método .append()
usado para añadir un ítem al final de la lista:
'''
pares.append(12)
print(pares)
pares.insert(0, 7)
pares.append(7*2)
print(pares)
'''Y
tienen una peculiaridad, que aceptan asignación con slicing para modificar
varios ítems en conjunto:
'''
letras = ['a','b','c','d','e','f']
print(letras[:3])
letras[:3] = ['A','B','C']
print(letras)
'''Si queremos borrar el contenido de una lista solo tenemos que asignar una lista
vacía a la misma:'''
letras[:3] = []
print(letras)
letras = []
print(letras)
'''
Al igual que sucede con las cadenas la función len() devuelve la cantidad de
elementos que contiene la lista o lo que es lo mismo, su longitud:
'''
print(len(letras))
print(len(pares))
'''
Para buscar un elemento dentro de una lista usaremos el operador in, que nos
devolverá verdadero o falso en función de si encuentra el elemento dentro de la
lista o no:
'''
print(pares)
print(2 in pares)
print(7 in pares)
'''
Podemos incluir listas dentro de listas, llamadas listas anidadas, y las
manipularemos fácilmente utilizando múltiples índices, como si nos
refiriéramos a las filas y columnas de una tabla:
'''
a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
r = [a,b,c]
print(r)
print(r[0]) # Primera sublista
print(r[-1]) # Ultima sublista
print(r[0][0]) # Primera sublista, primer item
print(r[1][1]) # Segunda sublista, segundo item
print(r[2][2]) # Tercera sublista, tercer item
print(r[-1][-1]) # Última sublista, último item
#............................................................................................................................................
'' '''Tuplas'''
'''Una tupla en Python es una estructura de datos formada por una secuencia
ordenada de objetos. Una colección ordenada e inmutable que permite
miembros duplicados.
Podemos decir que las tuplas son listas inmutables, que no pueden modificarse
después de su creación'''
'''Con las tuplas se trabaja exactamente igual que con las listas. La única
diferencia es que las tuplas son inmutables, no se puede modificar su contenido.
Los valores que componen una tupla van ordenados entre ( ) y separados por
comas. A continuación, se muestra cómo declarar una tupla, cómo mostrarla y
comprobar de qué tipo es el elemento creado'''
numeros = (1,2,3,4)
print(numeros)
datos = (44356,"Una cadena",-15,3.14,"Otra cadena")
print(datos)
print(type(datos))
'''Las tuplas, en cuanto a índices y slicing, funcionan de una forma muy similar
a las cadenas de caracteres y las listas:'''
print(datos[0])
print(datos[-1])
print(datos[-2:])
print(datos[1:3])
'''
También podemos realizar la suma de tuplas, que nos dará como resultado una
nueva tupla que incluye todos los ítems:
'''
numeros = numeros + (5,6,7,8)
print(numeros)
'''
Es muy importante tener en cuenta que los elementos de las tuplas no son
modificables, cualquier intento de modificación de los mismos nos dará error:
'''
#Al no ser modificables, no incluyen el método append()
pares = (0,2,4,5,8,10)
print(pares)
#Y tampoco aceptan la asignación con slicing para
# modificar varios ítems en conjunto:
letras = ('a', 'b', 'c', 'd', 'e', 'f')
print(letras[:3])
'''
La función len() también funciona con las tuplas del mismo modo que en las
listas y cadenas de caracteres:
'''
print(len(letras))
'al igual que en las listas, podemos buscar con el operado in:'
print(pares)
print(2 in pares) # hay 2 dentro del operador (pares) resultado True
print(7 in pares) # hay 7 dentro del operador (pares) resultado False
'''y tambien podemos maniupulas facilmente tuplas anidadas ultilizando multiples
indices, como si nos refirieramos a las filas y columnas de una tabla:'''
a = (1,2,3)
b = (4,5,6)
c = (7,8,9)
r = (a,b,c)
print(r)
print(r[-1]) # Ultima subtupla
print(r[1][1]) # Segunda subtupla, segundo item
print(r[2][2]) # Tercera subtupla, tercer item
print(r[-1][-1]) # Última subtupla, último item
#.............................................................................................................................................
'' '''sets'''
'''
Un conjunto o set, es una coleccion desordenada y no indexada en la no se
permite elementos repetidos. los usos basicos de estos conjutnos incluyen
verificacion de pertenecina y eliminacion de entradas duplicadas.
'''
A = {1,2,3,4}
B = {3,4,5,6}
'''Los valores que se componen un cojunto van indicados entre {} y se separados por
comas. A continuacion, se muetra como declarar u conjunto, como comtrarlo y comprobar
de que tipo es el elementos creado:
'''
numeros = {1,2,3,4}
print(1,2,3,4)
datos = {4,"Una cadena",-15,3.14,"Otra cadena"}
print(datos)
print(type(datos))
''' No podemos acceder a los elementos de un conjunto set haciendo referencia
a un indice, porque los conjuntos no estan ordenados y debido a esto, los
elementos no tienen indice. pero podemos recorrer los elementos del conjunto
utilizando un bucle for, que veremos mas adelante, o preguntar si un valor
especifico esta presente en un conunto utilizando la palabra clave in:'''
lenguajes = {
"PYTHON",
"C++",
"JAVA"
}
for z in lenguajes:
print(z)
print("python"in lenguajes)
'''Una vez se cerea un conjunto set, no podemos cambiar sus elementos, pero
podemos agregar nuevos elementos mediante el metodo add() para agregar un elemento a un conjunto
o mediante el metodo update() para agregar de un alementeo a un conjunto. podemos observar como el orden totalmente
aleatorio y dicidido por el lenguaje, como al no aceptar elementos repetidos,
'''
'''
si añadimos de un nuevo un elemento que ya existe,
no se añadira como un elemento nuevo:
'''
lenguajes = {"Python", "C++", "Java"}
print(lenguajes)
lenguajes.add("C#")
print(lenguajes)
# Como se puede ver, el orden es aleatorio y decidido por el lenguaje
lenguajes.update(["Go", "Javascript", "PHP"])
print(lenguajes)
'La función len() también funciona para los conjuntos:'
print(len(lenguajes))
'''
Para eliminar elementos del conjunto podemos utilizar dos métodos,
discard() o remove(), indicando entre paréntesis el elemento que
queremos eliminar:
'''
lenguajes = {"C#", "Python", "Go", "C++", "Javascript", "Java", "PHP"}
print(lenguajes)
lenguajes.remove("Go")
print(lenguajes)
lenguajes.discard("PHP")
print(lenguajes)
'Si queremos buscar dentro del conjunto lo haremos con el operador in:'
print(lenguajes)
print("C#" in lenguajes)
'''Y si lo que queremos es eliminar todo el contenido de un conjunto, debemos
utilizar el método clear():'''
lenguajes = {"C#", "Python", "Go", "C++", "Javascript", "Java", "PHP"}
print(lenguajes)
lenguajes.clear()
print(lenguajes)
'''Por último, debemos saber que los conjuntos no son anidables, de manera que
no puede haber conjuntos dentro de otros conjuntos:'''\
#...............................................................................................
'' ''' Diccionarios'''
'''
Un diccionario en Python es una colección desordenada, modificable e
indexada que no permite miembros duplicados. Un diccionario define una
relación uno a uno entre claves y valores.'''
vehiculos = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(vehiculos)
print(type(vehiculos))
'''Para acceder a los elementos de un diccionario tenemos dos formas, bien
haciendo referencia a su clave, o bien utilizando el método get(). Ambas
formas nos devolverán el valor correspondiente, como se ve a continuación:'''
valorQueMeInteresa = vehiculos["model"]
print(valorQueMeInteresa)
valorQueMeInteresa = vehiculos.get("model")
print(valorQueMeInteresa)
'''Para buscar una clave en un diccionario se utiliza el operador in (solo sirve
para buscar claves):'''
print("model" in vehiculos)
vehiculos = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(vehiculos)
vehiculos["year"] = 2020
print(vehiculos)
'''
Para saber la longitud de un diccionario usaremos la función len(), que
también funciona con los diccionarios: '''
print(len(vehiculos))
'''Para recorrer un diccionario utilizaremos el mismo método que con los
conjuntos:'''
for x in vehiculos:
print(x)
for x in vehiculos:
print(vehiculos[x])
for x in vehiculos:
print(x, ": ", vehiculos[x])
for x in vehiculos.values():
print(x)
'''
Existe un método de los diccionarios que nos facilita la lectura en clave y el
valor de los elementos, porque devuelve ambos valores en cada iteración
automáticamente:
'''
for x, y in vehiculos.items():
print(x, ": ", y)
'''
Para agregar elementos a un diccionario utilizaremos una nueva clave de índice
y le asignaremos un valor:
'''
vehiculos = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(vehiculos)
vehiculos["color"] = "red"
print(vehiculos)
'''
Para eliminar elementos del diccionario utilizaremos uno de estos tres métodos,
según nos sea más conveniente: clear() para borrar todo el diccionario,
pop() para eliminar el elemento con el nombre de clave especificado
y popitem() para eliminar el último elemento insertado. Hay que tener en
cuenta que popitem(), en versiones anteriores a la 3.7 del intérprete, elimina
un elemento aleatorio del diccionario en lugar de eliminar el último elemento
insertado:
'''
vehiculos = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(vehiculos)
# Elimina el último elemento insertado (en versiones anteriores a 3.7, se elimina un elemento aleatorio)
eliminado = vehiculos.popitem()
print(vehiculos)
print("Se ha eliminado la siguiente pareja de datos:", eliminado)
vehiculos = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(vehiculos)
eliminado = vehiculos.pop("model")
# Elimina el elemento con la clave especificada
print(vehiculos)
print("Se ha eliminado el valor", eliminado)
vehiculos = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(vehiculos)
vehiculos.clear( ) # Vacía el diccionario
print(vehiculos)
'''Un diccionario no se puede copiar realizando una asignación entre dos
diccionarios de la forma dict2 = dict1, porque el diccionario dict2 solo
será una referencia a dict1, y los cambios realizados en dict1 también se
realizarán automáticamente en dict2. Para hacer una copia hay que utilizar
el método copy():
'''
vehiculos = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(vehiculos)
vehiculos_copia = vehiculos.copy()
print(vehiculos_copia)
vehiculos.pop("model") # Elimina el elemento con la clave especificada
print(vehiculos)
print(vehiculos_copia)
'''
Se pueden anidar diccionarios, incluir diccionarios dentro de otros diccionarios.
En la siguiente imagen el diccionario familia contiene otros tres diccionarios'''
familia = {
"child1" : {
"name" : "Emil",
"year" : 2004
},
"child2" : {
"name" : "Tobias",
"year" : 2007
},
"child3" : {
"name" : "Linus",
"year" : 2011
},
}
print(familia)
'''Y para acceder a los diccionarios “internos” lo haremos de la siguiente manera:'''
valorQueMeInteresa = familia["child1"]
print(valorQueMeInteresa)
valorQueMeInteresa = familia["child3"]["name"]
print(valorQueMeInteresa)
'''Por último, en estos dos ejemplos vemos como incluir listas en nuestros diccionarios'''
diccionario = {
'nombre' : 'Carlos',
'edad' : 22,
'cursos' : ['Python', 'Django', 'Javascript']
}
print("Diccionario completo: ")
print(diccionario)
print("\nElementos del diccionario")
print(diccionario['nombre']) # Carlos
print(diccionario['edad']) # 22
print(diccionario['cursos']) # ['Python', 'Django', 'Javascript']
print("\nItems de la lista cursos: ")
print(diccionario['cursos'][0]) # Python
print(diccionario['cursos'][1]) # Django
print(diccionario['cursos'][2]) # Javascript
print("\nRecorriendo el diccionario con un bucle for")
for key in diccionario:
print(key, ":", diccionario[key])
clientes = {
'nombre' : ['Carlos','Cristian','David'] ,
'edad' : [22,30,32] ,
'lenguaje_favorito' : ['Python','Django','Javascript']
}
print("Diccionario completo: ")
print(diccionario)
print("\nMostrar todos los datos del primer cliente")
print(clientes['nombre'][0])
print(clientes['edad'][0])
print(clientes['lenguaje_favorito'][0])
print("\nMostrar todos los datos del segundo cliente")
print(clientes['nombre'][1])
print(clientes['edad'][1])
print(clientes['lenguaje_favorito'][1])
print("\nMostrar todos los datos del tercer cliente")
print(clientes['nombre'][2], end=", ")
print(clientes['edad'][2], end=", ")
print(clientes['lenguaje_favorito'][2])
#.......................................................................................................................................................................................
'' ''' Condicionales en Python'''
'''
Una sentencia condicional, como su nombre indica, es una
condición para discernir entre una opción u otra, y en el proceso mental
normalmente se manifiesta con un SI; por ejemplo: Si (va a
llover), coge el paraguas.'''
'''
Mediante una sentencia condicional seleccionamos un bloque de sentencias
que se ejecutarán cuando dicha condición se cumpla (sea verdadera). Para
entender un poco mejor las instrucciones condicionales, veamos un diagrama
de flujo de un programa con este tipo de instrucciones'''
'' '''IF'''
'''
Mediante la sentencia if evaluamos una condición y ejecutamos una serie de
instrucciones en caso que la condición evaluada sea verdadera. En caso
contrario, se continúa normalmente con la secuencia de instrucciones del
programa sin ejecutar ninguna de las que indicamos dentro de la sentencia if.
Su diagrama de flujo es el siguiente:'''
'''La instrucción if tiene la siguiente sintaxis'''
'''Una sentencia if permite dividir el flujo de un programa en diferentes
caminos. Las instrucciones que están incluidas dentro del if se ejecutan
siempre que la expresión que comprueba devuelva True:
'''
if True: # Equivale a if not false
print("Se cumple la condición")
print("También se muestra este print")
if True: # Equivale a if not false
print("Se cumple la condición")
print("También se muestra este print")
print("Este print no pertenece al if")
'''
Se pueden encadenar diferentes if:
'''
a = 2
if a == 2:
print("a vale 2")
if a == 5:
print("a vale 5")
'''
O anidar if dentro de otros if:
'''
a = 5
b = 10
if a == 5:
print("a vale",a)
b=b+1
if b == 10:
print("y b vale",b)
'''Y como condición, podemos evaluar múltiples expresiones,
siempre que devuelvan True o False:'''
if a==5 and b==10:
print("a vale 5 y b vale 10")
'' ''' If else'''
'''Cuando evaluamos una condición, discernimos el caso en que la condición
es verdadera (el if se cumple, da verdadero), pero también podemos evaluar si la
condición es falsa (else / si no). El diagrama de flujo, en este caso, es el
siguiente:
'''
'''La instrucción if ... else tiene la siguiente sintaxis'''
n = 6
if n >= 0:
print(n,"es un número mayor o igual que 0")
else:
print(n,"es un número menor que 0")
n = 11
if n % 2 == 0:
print(n,"es un número par")
else:
print(n,"es un número impar")
'' '''if - elif - else'''
'''
a sentencia elif dentro de una sentencia if es el resultado de anidar
varias sentencias if, unas dentro de otras
'''
'''La forma de funcionamiento es la siguiente: tras evaluar la condición de la
sentencia if, y si esta no se cumple, realizamos otra evaluación con la
sentencia elif y en caso que no se cumpla proseguiremos evaluando las
siguientes sentencias elif hasta que alguna se cumpla. Si ninguna de las
condiciones anteriores se cumple, se ejecutarán las instrucciones que van
tras la sentencia else. Si alguna de las condiciones se cumple se ejecutará
el código asociada a la misma.'''
orden = 3
if orden == 1: