-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.html
1081 lines (1072 loc) · 44.1 KB
/
index.html
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
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="IE=7" />
<meta name="description" content="Python Tutorial" />
<link rel="stylesheet" href="./assets/css/style.css" />
<link
rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"
/>
<link
rel="shortcut icon"
href="./assets/img/python-logo.png"
type="image/x-icon"
/>
<title>Python Tutorial</title>
</head>
<body>
<nav id="navbar">
<header>
<h1>Python Tutorial</h1>
</header>
<div class="navbar-toggle" onclick="toggleNavbar()">
<i class="fa fa-bars"></i>
</div>
<ul class="show_nav_def">
<li title="Ir a sección Introducción">
<a href="#Introducción" class="nav-link">Introducción</a>
</li>
<li title="Ir a sección Variables y Operadores">
<a href="#Variables_y_Operadores" class="nav-link"
>Variables y Operadores</a
>
</li>
<li title="Ir a sección Estructuras de Datos">
<a href="#Estructuras_de_Datos" class="nav-link"
>Estructuras de Datos</a
>
</li>
<li title="Ir a sección Control de Flujo">
<a href="#Control_de_Flujo" class="nav-link">Control de Flujo</a>
</li>
<li title="Ir a sección Funciones">
<a href="#Funciones" class="nav-link">Funciones</a>
</li>
<li title="Ir a sección Programación Orientada a Objetos">
<a href="#Programación_Orientada_a_Objetos_(POO)" class="nav-link"
>Programación Orientada a Objetos (POO)</a
>
</li>
<li title="Ir a sección Decoradores">
<a href="#Decoradores" class="nav-link">Decoradores</a>
</li>
<li title="Ir a sección Iteradores y Generadores">
<a href="#Iteradores_y_Generadores" class="nav-link"
>Iteradores y Generadores</a
>
</li>
<li title="Ir a sección Módules y Paquetes">
<a href="#Módulos_y_Paquetes" class="nav-link">Módulos y Paquetes</a>
</li>
<li title="Ir a sección Manejo de Excepciones">
<a href="#Manejo_de_Excepciones" class="nav-link"
>Manejo de Excepciones</a
>
</li>
<li title="Ir a sección Expresiones Regulares">
<a href="#Expresiones_Regulares" class="nav-link"
>Expresiones Regulares</a
>
</li>
<li title="Ir a sección Manipulación de Archivos">
<a href="#Manipulación_de_Archivos" class="nav-link"
>Manipulación de Archivos</a
>
</li>
<li title="Ir a sección Trabajo Con API Rest">
<a href="#Trabajo_con_API_REST" class="nav-link"
>Trabajo con API REST</a
>
</li>
</ul>
</nav>
<div id="layout">
<main id="main-doc">
<section class="main-section" id="Introducción">
<header>
<h2>
Introducción
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Python es un lenguaje de alto nivel cercano al lenguaje natural,
interpretado, multiplataforma, scripting y de propósito general.
Precisamente, es su cercania con el lenguaje natural lo que
facilita su aprendizaje. En este tutorial se realiza un recorrido
por los principales tópicos de dicho lenguaje.
</p>
</article>
</section>
<section class="main-section" id="Variables_y_Operadores">
<header>
<h2>
Variables y Operadores
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Las variables y los operadores son dos conceptos fundamentales en
la programación en Python. Las variables se utilizan para
almacenar datos, y los operadores se utilizan para realizar
operaciones con datos.
</p>
<h3>Variables</h3>
<p>
En Python, una variable es un espacio de almacenamiento que tiene
un nombre identificador y contiene un valor o referencia a un
objeto. Al asignar un valor a una variable, le das un nombre
descriptivo que luego puedes utilizar para referenciar y manipular
ese valor. La asignación de variables en Python se realiza
mediante el operador de asignación =.
<br /><br />
A continuación muestro un ejemplo:
</p>
<p class="code_section">
<code
># Asignación de variables<br />
nombre = "John"<br />
edad = 25 <br />
altura = 1.75 <br />
es_estudiante = True</code
>
</p>
<h3>Operadores</h3>
<p>
Python incluye varios tipos de operadores que permiten realizar
operaciones en variables y valores. Aquí hay algunos de los
operadores más comunes:
</p>
<ol>
<li>
<h4>Operadores Aritméticos</h4>
<p>Los operadores aritméticos más comunes son</p>
<ul>
<li>Suma: +</li>
<br />
<li>Resta: -</li>
<br />
<li>Multiplicación: *</li>
<br />
<li>División: /</li>
<br />
<li>Potenciación: **</li>
</ul>
</li>
<li>
<h4>Operadores Lógicos</h4>
<p>Los operadores lógicos más comunes son:</p>
<ul>
<li>AND: <code>and</code></li>
<br />
<li>OR: <code>or</code></li>
<br />
<li>NOT: <code>not</code></li>
</ul>
</li>
<li>
<h4>Operadores de Comparación</h4>
<p>Los operadores de comparación más comunes son:</p>
<ul>
<li>Igual: <code>==</code></li>
<br />
<li>Distinto: <code>!=</code></li>
<br />
<li>Mayor que: <code>></code></li>
<br />
<li>Menor que: <code><</code></li>
<br />
<li>Mayor o igual que: <code>>=</code></li>
<br />
<li>Menor o igual que: <code><=</code></li>
</ul>
</li>
<li>
<h4>Operadores de Asignación</h4>
<p>Los operadores de asignación más comunes son:</p>
<ul>
<li>Suma: <code>+=</code></li>
<br />
<li>Resta: <code>-=</code></li>
<br />
<li>Multiplicación: <code>*=</code></li>
<br />
<li>División: <code>/=</code></li>
<br />
<li>Módulo: <code>%=</code></li>
<br />
<li>Potenciación: <code>**=</code></li>
</ul>
</li>
</ol>
</article>
</section>
<section class="main-section" id="Estructuras_de_Datos">
<header>
<h2>
Estructuras de Datos
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Las estructuras de datos son contenedores que almacenan datos.
Python proporciona una variedad de estructuras de datos, como
listas, tuplas, conjuntos y diccionarios.
</p>
<h3>Listas</h3>
<p>
Una lista es una estructura de datos que puede almacenar una
secuencia de elementos. Los elementos de una lista pueden ser de
cualquier tipo de dato, incluidos números, cadenas, objetos y
otras listas. Para crear una lista, se usa la corchetes []. Por
ejemplo, para crear una lista que almacenará los números 1, 2 y 3,
se usaría el siguiente código:
</p>
<p><code>numeros = [1, 2, 3]</code></p>
<h3>Tuplas</h3>
<p>
Una tupla es una estructura de datos similar a una lista, pero los
elementos de una tupla son inmutables. Esto significa que los
elementos de una tupla no se pueden modificar una vez que se han
asignado. Para crear una tupla, se usa la sintaxis ( y ). Por
ejemplo, para crear una tupla que almacenará los números 1, 2 y 3,
se usaría el siguiente código:
</p>
<p><code>numeros = (1, 2, 3)</code></p>
<h3>Conjuntos</h3>
<p>
Un conjunto es una estructura de datos que almacena una colección
de elementos únicos. Los elementos de un conjunto no están
ordenados y no tienen índices. Para crear un conjunto, se usa la
sintaxis {}. Por ejemplo, para crear un conjunto que almacenará
los números 1, 2 y 3, se usaría el siguiente código:
</p>
<p><code>numeros = {1, 2, 3}</code></p>
<h3>Diccionarios</h3>
<p>
Un diccionario es una estructura de datos que permite almacenar y
organizar datos de manera eficiente. Se trata de una colección no
ordenada de pares clave-valor, donde cada clave debe ser única.
Los diccionarios son conocidos también como "mapas" o "tablas
hash" en otros lenguajes de programación. Un diccionario en Python
se define utilizando llaves {} y tiene la siguiente estructura
básica:
</p>
<p><code>personas = { "Juan": 20, "María": 25 }</code></p>
</article>
</section>
<section class="main-section" id="Control_de_Flujo">
<header>
<h2>
Control de Flujo
<div class="separador"></div>
</h2>
</header>
<article>
<p>
El control de flujo en Python es el proceso de controlar el orden
en que se ejecutan las instrucciones de un programa. Se utiliza
para determinar qué instrucciones se ejecutan, cuándo se ejecutan
y cuántas veces se ejecutan.
</p>
<h3>Sentencias condicionales</h3>
<p>
Las sentencias condicionales se utilizan para controlar el flujo
del programa en función de una condición. Las sentencias
condicionales más comunes en Python son <code>if</code>,
<code>elif</code> y <code>else</code>.
</p>
<h3>Bucles</h3>
<p>
Los bucles se utilizan para ejecutar un bloque de instrucciones
repetidamente. Los bucles más comunes en Python son
<code>while</code>, <code>for</code> y se utiliza la palabra
<code>break</code> para interrumpir la ejecución del loop y la
palabra clave <code>continue</code> para saltar de la actual
iteración a la siguiente.
</p>
</article>
</section>
<section class="main-section" id="Funciones">
<header>
<h2>
Funciones
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Una función es un bloque de código reutilizable que se puede
llamar desde cualquier parte del programa. Las funciones se
utilizan para dividir un programa en tareas más pequeñas y
manejables, y para hacer que el código sea más fácil de leer y
mantener.
</p>
<p>
Para definir una función en Python, se utiliza la palabra clave
<code>def</code> seguida del nombre de la función, los parámetros
de entrada y el cuerpo de la función. El cuerpo de la función es
un bloque de código que se ejecutará cuando se llame a la función.
</p>
<p>
El siguiente código define una función llamada sum() que suma dos
números:
</p>
<p class="code_section">
<code
>def sum(a, b):<br />
return a + b</code
>
</p>
<p>
La misma función anterior se puede crear utilizando una
<b>función anónima lambda</b> y asignarla a una variable:
</p>
<p><code> sum=lambda a, b: a + b </code></p>
</article>
</section>
<section
class="main-section"
id="Programación_Orientada_a_Objetos_(POO)"
>
<header>
<h2>
Programación Orientada a Objetos (POO)
<div class="separador"></div>
</h2>
</header>
<article>
<p>
La Programación Orientada a Objetos (POO) es un paradigma de
programación que organiza el código en torno a objetos. Los
objetos son entidades que contienen datos (llamados atributos) y
métodos (funciones que se aplican a una instancia de la clase).
Los datos son información que el objeto almacena, y los métodos
son acciones que el objeto puede realizar.
<br />
<br />
En Python, la POO se implementa mediante clases. Las clases son
plantillas que se utilizan para crear objetos. Las clases definen
los datos y los métodos que tendrá un objeto.
</p>
<p>
El siguiente código define una clase llamada <code>Mascota</code>:
</p>
<p class="code_section">
<code>
class Mascota:<br />
  def __init__(self, nombre, especie):<br />
    self.nombre = nombre<br />
    self.especie = especie<br />
<br />
  def presentarse(self):<br />
    return f"Soy {self.nombre}, una
{self.especie}."<br />
<br />
mi_mascota = Mascota("Firulais", "perro")<br />
print(mi_mascota.presentarse())
</code>
</p>
</article>
</section>
<section class="main-section" id="Decoradores">
<header>
<h2>
Decoradores
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Los decoradores son funciones que se utilizan para modificar el
comportamiento de otras funciones. Los decoradores se pueden
utilizar para agregar funcionalidad, realizar comprobaciones de
seguridad o registrar información sobre la ejecución de una
función.
</p>
<p>Los decoradores se definen usando la sintaxis siguiente:</p>
<p class="code_section">
<code>
@decorador_funcion <br />
def funcion_a_decorar(): <br />
  pass
</code>
</p>
<br />
<p>
En esta sintaxis, <code>decorador_funcion</code> es la función
decoradora, y <code>funcion_a_decorar </code> es la función que se
va a decorar. La función decoradora se ejecuta antes de que se
ejecute la función a decorar. La función decoradora puede devolver
la función a decorar, o puede devolver una función completamente
nueva.
</p>
<p class="code_section">
<code>
def imprimir_nombre_funcion(funcion):<br />
  def wrapper(*args, **kwargs):<br />
    print(funcion.__name__)<br />
    return funcion(*args, **kwargs)<br />
  return wrapper
</code>
</p>
<br />
<p>Este decorador se puede utilizar de la siguiente manera:</p>
<p class="code_section">
<code>
@imprimir_nombre_funcion<br />
def saludar(nombre):<br />
  print("Hola, {}!".format(nombre))
</code>
</p>
</article>
</section>
<section class="main-section" id="Iteradores_y_Generadores">
<header>
<h2>
Iteradores y Generadores
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Los iteradores y generadores son conceptos relacionados que
permiten trabajar eficientemente con secuencias de datos,
especialmente cuando se trata de conjuntos de datos grandes o
cuando queremos generar valores sobre la marcha sin almacenarlos
todos en la memoria.
</p>
<h3>Iteradores:</h3>
<p>
Un iterador es un objeto que implementa los métodos
<code>__iter__()</code> y <code>__next__()</code>. El método
<code>__iter__()</code> devuelve el propio objeto iterador, y el
método <code>__next__()</code> proporciona el siguiente elemento
de la secuencia.
<br />
El siguiente es un ejemplo de uso:
</p>
<p class="code_section">
<code>
class Contador:<br />
  def __init__(self, limite):<br />
    self.limite = limite<br />
    self.valor_actual = 0<br />
<br />
  def __iter__(self):<br />
    return self<br />
<br />
  def __next__(self):<br />
    if self.valor_actual <
self.limite:<br />
      resultado =
self.valor_actual<br />
      self.valor_actual += 1<br />
      return resultado<br />
    else:<br />
      raise StopIteration<br />
<br />
# Uso del iterador
<br />
contador_iterador = Contador(5) <br />
for numero in contador_iterador:<br />
  print(numero)
</code>
</p>
<h3>Generadores:</h3>
<p>
Los generadores son una forma más sencilla y cómoda de crear
iteradores. Se definen mediante funciones que contienen la palabra
clave <strong>yield</strong>. Cuando se llama al generador, la
ejecución se pausa en la instrucción <strong>yield</strong>, y el
valor se devuelve al llamante. La próxima vez que se llama al
generador, la ejecución se reanuda justo después del
<strong>yield</strong>, manteniendo el estado interno.
<br />
<br />
El siguiente es un ejemplo de uso:
</p>
<p class="code_section">
<code>
def generador_pares(n): <br />
  for i in range(0, n, 2):<br />
    yield i <br />
# Uso del generador
<br />
for num in generador_pares(6):<br />
  print(num)
</code>
</p>
<br />
<p>
En este ejemplo, el generador
<strong>generador_pares</strong> produce números pares hasta el
límite n. Cada vez que se itera sobre el generador, la ejecución
se pausa en el <code>yield</code> y se reanuda cuando se solicita
el siguiente valor.
</p>
</article>
</section>
<section class="main-section" id="Módulos_y_Paquetes">
<header>
<h2>
Módulos y Paquetes
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Los módulos y paquetes son mecanismos que permiten organizar y
estructurar el código de manera más eficiente, facilitando la
reutilización y el mantenimiento del código.
</p>
<h3>Módulos:</h3>
<p>
Un módulo en Python es simplemente un archivo que contiene código
Python, ya sea funciones, clases o variables. Un módulo puede ser
importado en otro script o programa, permitiendo así la
reutilización de código.
<br /><br />
Ejemplo de Módulo:
<br /><br />
Supongamos que tenemos un archivo llamado
<strong>operaciones.py</strong> con el siguiente contenido:
</p>
<p class="code_section">
<code>
# operaciones.py<br />
def suma(a, b):<br />
     return a + b<br />
def resta(a, b):<br />
     return a - b<br />
</code>
</p>
<p>
Este archivo se puede considerar un módulo. Para usar las
funciones definidas en este módulo en otro archivo, simplemente lo
importamos:
</p>
<p class="code_section">
<code>
# otro_script.py
<br />
import operaciones
<br />
resultado_suma = operaciones.suma(5, 3)<br />
resultado_resta = operaciones.resta(10, 4)<br />
<br />
print("Suma:", resultado_suma)<br />
print("Resta:", resultado_resta)
</code>
</p>
<h3>Paquetes</h3>
<p>
Un paquete en Python es una forma de organizar múltiples módulos
relacionados en un directorio. Un paquete debe contener un archivo
especial llamado <strong>__init__.py</strong> para que Python lo
reconozca como un paquete. <br /><br />
Ejemplo de Paquete:<br /><br />
Supongamos que tenemos una estructura de directorios como esta:
</p>
<p class="code_section">
<code>
mi_paquete/<br />
|-- __init__.py<br />
|-- operaciones/<br />
|-|-- __init__.py<br />
|-|-- suma.py<br />
|-|-- resta.py<br />
|-- otro_script.py
</code>
</p>
<p>
Los archivos <strong>suma.py</strong> y
<strong>resta.py</strong> contienen las funciones de mi_suma y
mi_resta, respectivamente. El contenido de
<strong>__init__.py</strong> (tanto en mi_paquete como en
operaciones) puede ser un archivo vacío o contener código que se
ejecuta cuando el paquete o módulo se importa.
</p>
<p class="code_section">
<code>
# otro_script.py
<br />
from mi_paquete.operaciones import suma, resta
<br /><br />
resultado_suma = suma.mi_suma(5, 3)<br />
resultado_resta = resta.mi_resta(10, 4)<br />
<br />
print("Suma:", resultado_suma)<br />
print("Resta:", resultado_resta)
</code>
</p>
<p>También puede ser realizado de la siguiente manera:</p>
<p class="code_section">
<code>
# otro_script.py
<br />
from mi_paquete.operaciones.suma import mi_suma <br />
from mi_paquete.operaciones.resta import mi_resta
<br /><br />
resultado_suma = mi_suma(5, 3)<br />
resultado_resta = mi_resta(10, 4)<br />
<br />
print("Suma:", resultado_suma)<br />
print("Resta:", resultado_resta)
</code>
</p>
<p>
Los módulos y paquetes son esenciales para estructurar proyectos
más grandes y facilitar la reutilización del código en Python.
</p>
</article>
</section>
<section class="main-section" id="Manejo_de_Excepciones">
<header>
<h2>
Manejo de Excepciones
<div class="separador"></div>
</h2>
</header>
<article>
<p>
El manejo de excepciones en Python se refiere a la práctica de
gestionar y responder a situaciones excepcionales o errores
durante la ejecución de un programa. Las excepciones son eventos
que pueden ocurrir durante la ejecución y que pueden interrumpir
el flujo normal del programa si no se manejan adecuadamente. El
manejo de excepciones permite a los programadores anticipar y
gestionar estas situaciones excepcionales, evitando que el
programa se bloquee o produzca resultados incorrectos.
<br /><br />
En Python, el manejo de excepciones se realiza mediante bloques
<strong>try</strong>, <strong>except</strong>,
<strong>else</strong> y <strong>finally</strong>. La estructura
básica es la siguiente:
</p>
<p class="code_section">
<code>
try:<br />
    # Código que puede generar una excepción
<br />
    resultado = dividir(10, 0)<br />
except ZeroDivisionError:<br />
    # Manejo específico para la excepción
ZeroDivisionError<br />
    print("Error: No se puede dividir por
cero.")<br />
except Exception as e:<br />
     # Manejo genérico para otras
excepciones<br />
     print(f"Error inesperado: {e}")<br />
else:<br />
     # Se ejecuta si no hay excepciones<br />
     print("La división se realizó con
éxito.")<br />
finally:<br />
     # Se ejecuta siempre,
independientemente de si se produjo una excepción o no<br />
     print("Este bloque se ejecuta
siempre.")
</code>
</p>
<p>En este ejemplo se tiene lo siguiente: <br /></p>
<ul>
<li>
El código dentro del bloque <strong>try</strong> es susceptible
a lanzar una excepción.
</li>
<br />
<li>
Los bloques except especifican cómo manejar excepciones
particulares. En este caso, se maneja la excepción
<strong>ZeroDivisionError</strong> y, de manera más genérica,
<strong>Exception</strong>.
</li>
<br />
<li>
El bloque <strong>else</strong> se ejecuta si no se produce
ninguna excepción en el bloque <strong>try</strong>.
</li>
<br />
<li>
El bloque <strong>finally</strong> se ejecuta siempre,
independientemente de si se produjo una excepción o no. Es útil
para realizar acciones de limpieza o liberación de recursos.
</li>
</ul>
</article>
</section>
<section class="main-section" id="Expresiones_Regulares">
<header>
<h2>
Expresiones Regulares
<div class="separador"></div>
</h2>
</header>
<article>
<p>
Las expresiones regulares (también conocidas como regex o regexp)
son patrones de búsqueda de texto que se utilizan para realizar
operaciones de búsqueda y manipulación en cadenas de texto. En
Python, las expresiones regulares se implementan a través del
módulo <code>re</code>, que proporciona funciones para trabajar
con estas expresiones.
<br />
<br />
Las expresiones regulares son extremadamente poderosas y
flexibles, permitiendo buscar patrones específicos, realizar
sustituciones, validar formatos y más.
</p>
<h3>Sintaxis Básica de Expresiones Regulares en Python:</h3>
<ol>
<li>
<p>
<strong>Raw Strings (cadenas sin procesar): </strong> En
Python, se recomienda utilizar cadenas sin procesar
(precedidas por r) al trabajar con expresiones regulares, ya
que evitan la necesidad de duplicar barras invertidas (\) para
escapar caracteres especiales.
</p>
<p class="code_section">
<code> patron = r"\d{3}-\d{2}-\d{4}" </code>
</p>
</li>
<br />
<li>
<p><strong>Metacaracteres Comunes:</strong></p>
<ul>
<li>
<strong>.</strong>: Coincide con cualquier carácter excepto
una nueva línea.
</li>
<br />
<li>
<strong>^</strong>: Coincide con el inicio de una cadena.
</li>
<br />
<li>
<strong>$</strong>: Coincide con el final de una cadena.
</li>
</ul>
<br />
<p>Este es un ejemplo de uso de <strong>^</strong>:</p>
<p class="code_section">
<code>
import re<br />
texto = "Hola, mundo!"<br /><br />
# Buscar la palabra "Hola" al principio de la cadena<br />
resultado = re.search(r"^Hola", texto)
</code>
</p>
</li>
<br />
<li>
<p><strong>Cuantificadores: </strong></p>
<ul>
<li>
<strong>*</strong> : Coincide con 0 o más repeticiones del
carácter anterior.
</li>
<br />
<li>
<strong>+</strong> : Coincide con 1 o más repeticiones del
carácter anterior.
</li>
<br />
<li>
<strong>?</strong> : Coincide con 0 o 1 repetición del
carácter anterior.
</li>
<br />
<li>
<strong>{m,n}</strong> : Coincide con entre m y n
repeticiones del carácter anterior.
</li>
</ul>
</li>
<br />
<li>
<p><strong>Clases de Caracteres:</strong></p>
<ul>
<li>
<strong>[...]</strong> : Coincide con cualquier carácter
dentro de los corchetes.
</li>
<br />
<li>
<strong>[^...]</strong> : Coincide con cualquier carácter
que no esté dentro de los corchetes.
</li>
</ul>
</li>
</ol>
<br />
<p>
Estos son solo algunos ejemplos básicos. Las expresiones regulares
pueden volverse bastante complejas y son una herramienta poderosa
para la manipulación de cadenas de texto. La biblioteca
<code>re</code> en Python proporciona varias funciones, como
<code>search</code>, <code>match</code>, <code>findall</code>,
<code>sub</code>, entre otras, para trabajar con expresiones
regulares.
</p>
</article>
</section>
<section class="main-section" id="Manipulación_de_Archivos">
<header>
<h2>
Manipulación de Archivos
<div class="separador"></div>
</h2>
</header>
<article>
<p>
La manipulación de archivos en Python se refiere a la capacidad
del lenguaje para realizar operaciones de lectura, escritura y
manipulación de archivos en el sistema de archivos del sistema
operativo. Python posee la función <code>open</code> para
interactuar con archivos de texto y binarios.
</p>
<h3>Ejemplos de Manipulación de Archivos:</h3>
<ol>
<li>
<h4>Lectura de un Archivo de Texto:</h4>
<p class="code_section">
<code>
# Abrir un archivo en modo de lectura<br />
with open("archivo.txt", "r") as archivo:<br />
  # Leer todo el contenido del archivo<br />
  contenido = archivo.read()<br />
  print(contenido)<br />
<br />
# O leer línea por línea<br />
archivo.seek(0) # Reiniciar el puntero del archivo al
principio<br />
lineas = archivo.readlines()<br />
for linea in lineas:<br />
  print(linea.strip()) # Eliminar caracteres de
nueva línea al final<br />
</code>
</p>
</li>
<li>
<h4>Escritura en un Archivo de Texto:</h4>
<p class="code_section">
<code
># Abrir un archivo en modo de escritura <br />
with open("nuevo_archivo.txt", "w") as archivo:<br />
  # Escribir contenido en el archivo<br />
  archivo.write("Hola, este es un nuevo
archivo.\n")<br />
  archivo.write("Línea 2: Contenido
adicional.")<br
/></code>
</p>
</li>
<li>
<h4>Manipulación de Archivos Binarios:</h4>
<p class="code_section">
<code>
# Leer y escribir archivos binarios<br />
with open("imagen.jpg", "rb") as archivo_entrada:<br />
  datos_binarios = archivo_entrada.read()<br />
  with open("copia_imagen.jpg", "wb") as
archivo_salida:<br />
      archivo_salida.write(datos_binarios)<br />
</code>
</p>
</li>
<li>
<h4>
Uso de la Instrucción <code>with </code> para Garantizar el
Cierre del Archivo:
</h4>
<p>
La instrucción <code>with </code> asegura que el archivo se
cierre adecuadamente después de que se complete el bloque de
código. Esto es útil para prevenir posibles problemas de
manejo de archivos y para liberar recursos.
</p>
<p class="code_section">
<code
>with open("archivo.txt", "r") as archivo:<br />
  # Realizar operaciones de lectura<br />
  contenido = archivo.read()<br />
  print(contenido)<br />
# El archivo se cerrará automáticamente al salir del bloque
'with'
</code>
</p>
</li>
</ol>
<br />
<p>
Estos son solo ejemplos básicos. Además de los modos de lectura y
escritura (<strong>"r"</strong> ,<strong>"w"</strong> ), existen
otros modos como <strong>"a"</strong> (para añadir al final del
archivo) y <strong> "b"</strong> (para modo binario). También
puedes utilizar la biblioteca <code>os</code> para operaciones más
avanzadas en archivos y directorios. <br /><br />
Recordar manejar excepciones, como FileNotFoundError al abrir
archivos, para garantizar la robustez del código.
</p>
</article>
</section>
<section class="main-section" id="Trabajo_con_API_REST">
<header>
<h2>
Trabajo con API REST
<div class="separador"></div>
</h2>
</header>
<article>
<p>
El trabajo con API REST en Python implica interactuar con
servicios web que siguen los principios de arquitectura REST
(Transferencia de Estado Representacional). Las API REST utilizan
operaciones HTTP estándar (GET, POST, PUT, DELETE) para realizar
acciones sobre recursos, y los datos se suelen enviar y recibir en
formato JSON.
<br /><br />
A continuación, se muestra un ejemplo básico de cómo realizar
solicitudes a una API REST utilizando el módulo
<strong>requests</strong> en Python.
</p>
<h3>Ejemplo de Trabajo con API REST:</h3>
<p class="code_section">
<code>
import requests <br />
<br />
# Ejemplo de una API pública (JSONPlaceholder: Fake Online REST
API for Testing and Prototyping)<br />
<br />
url = "https://jsonplaceholder.typicode.com/posts/1"<br />
<br />
# Realizar una solicitud GET para obtener un recurso<br />
response = requests.get(url)<br />
<br />
# Verificar si la solicitud fue exitosa (código de estado
200)<br />
if response.status_code == 200:<br />
  # Convertir la respuesta a formato JSON<br />
  datos = response.json()<br />
  print("Título del post:", datos["title"])<br />
else:<br />
  print("Error en la
solicitud:",response.status_code)<br />
</code>
</p>
<p>En el ejemplo anterior se realiza lo siguiente:</p>
<ol>
<li>
Se utiliza la biblioteca <strong>requests </strong> para
realizar una solicitud HTTP GET a la API pública
JSONPlaceholder.
</li>
<br />
<li>
Se verifica el código de estado de la respuesta. Un código de
estado 200 indica que la solicitud fue exitosa.
</li>
<br />
<li>
Si la solicitud fue exitosa, se convierten los datos de la
respuesta a formato JSON y se imprime el título del post.
</li>
</ol>
<h3>Ejemplo de Envío de Datos con una Solicitud POST:</h3>
<p class="code_section">
<code>
import requests
<br />
# Ejemplo de una API pública para crear un nuevo recurso
<br />
url = "https://jsonplaceholder.typicode.com/posts" <br />