<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Tato Airaldo on Medium]]></title>
        <description><![CDATA[Stories by Tato Airaldo on Medium]]></description>
        <link>https://medium.com/@estebanairaldo?source=rss-74b69ace6992------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*sgxaE7Ugrp8smZjmNO0pGQ.png</url>
            <title>Stories by Tato Airaldo on Medium</title>
            <link>https://medium.com/@estebanairaldo?source=rss-74b69ace6992------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 23:04:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@estebanairaldo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Programación orientada a Objetos II]]></title>
            <link>https://estebanairaldo.medium.com/programaci%C3%B3n-orientada-a-objetos-ii-48d3e96537e9?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/48d3e96537e9</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[programación]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[poo]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Thu, 29 Dec 2022 00:16:24 GMT</pubDate>
            <atom:updated>2022-12-29T00:16:24.770Z</atom:updated>
            <content:encoded><![CDATA[<p>Clases, Atributos, Métodos, Clases anidadas y Encapsulamiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/0*0LSgdNeV5c8zu2Cm" /></figure><p>Recapitulando…</p><h4>¿Qué es la programación orientada a objetos?</h4><p>Es un modo o <strong>paradigma de programación</strong>, que nos permite <strong>organizar el código pensando el problema como una relación entre “cosas”</strong>, denominadas objetos.</p><p>Los objetos <strong>se trabajan utilizando las clases. </strong>Estas nos permiten <strong>agrupar un conjunto de variables y funciones.</strong></p><h4><strong>Atributos</strong></h4><p>Cosas de lo más cotidianas como una computadora o un coche pueden ser representadas con <strong>clases. Estas clases tienen diferentes características</strong>, que en el caso de la computadora podrían ser la marca o modelo. Llamaremos a estas características, <strong>atributos</strong>.</p><h4><strong>Métodos</strong></h4><p>Por otro lado, las <strong>clases</strong> tienen un conjunto de funcionalidades. En el caso de la computadora podría ser imprimir o reproducir música. Llamaremos a estas funcionalidades<strong> métodos.</strong></p><h4><strong>Objetos</strong></h4><p>Por último, pueden existir diferentes tipos de computadoras. Llamaremos a estos diferentes tipos de computadoras objetos.</p><p>Es decir, <strong>el concepto abstracto de computadora es la clase, pero cualquier tipo de computadora particular será el objeto.</strong></p><p><strong>¿Para qué usar la POO?</strong></p><p>En el mundo de la programación hay gran cantidad de aplicaciones que realizan tareas muy similares y es importante identificar los patrones que nos permiten no reinventar la rueda. La programación orientada a objetos intentaba resolver esto.</p><blockquote>Python está diseñado para soportar el paradigma de la programación orientado a objetos (POO), donde todos los módulos se tratan como entidades que tienen atributos, y comportamiento. Lo cual, en muchos casos, ayuda a crear programas de una manera sencilla, además de que los componentes son reutilizables.</blockquote><h3><strong>Clases</strong></h3><p>Lo primero es crear una clase, a la cual llamaremos “perro”. Se trata de una clase vacía y sin mucha utilidad práctica, pero es la mínima clase que podemos crear. El uso del PASS realmente no tiene utilidad, pero daría un error si después de los : no tenemos contenido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/407/0*x504bciZsOerIgWg" /></figure><p><strong>Instanciar una clase</strong></p><p>Ahora que tenemos la clase, podemos crear uno o más objetos de la misma, como si de una variable normal se tratase.</p><p>Nombre de la variable igual a la clase con ( ). Dentro de los paréntesis irían los parámetros de entrada si los hubiera.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/273/0*DpjMCM_0byPkI3vq" /></figure><h3><strong>Atributos</strong></h3><p>A la hora de añadir atributos a la clase, es importante distinguir dos tipos:</p><ul><li><strong>Atributos de instancia:</strong> Pertenecen a la instancia de la clase o al objeto. Son atributos particulares de cada instancia, en nuestro caso de cada perro.</li><li><strong>Atributos de clase:</strong> Se trata de atributos que pertenecen a la clase, por lo tanto serán comunes para todos los objetos.</li></ul><p>Empecemos creando el nombre y la raza del perro. Esto se suele hacer por medio de un método <strong>__init__</strong> que será llamado automáticamente cuando se cree un objeto. No se le puede cambiar el nombre y tiene su definición propia, “<strong>Constructor</strong>”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/459/0*9SUEa0a-S8O8jEud" /></figure><p><strong>¿Qué es el self?</strong></p><p>Es una variable que representa la instancia de la clase, y deberá estar siempre ahí.</p><p>El uso de <strong>__init__ </strong>y el doble __ no es una coincidencia. Cuando veas un método con esa forma, significa que está reservado para un uso especial del lenguaje. En este caso sería lo que se conoce como <strong>constructor.</strong></p><p><strong>Asignando atributos de clase</strong></p><p>Hasta ahora hemos definido atributos de instancia, ya que pertenecen a cada perro concreto. Ahora vamos a definir un atributo de clase, que será común para todos los perros.</p><p>Por ejemplo, la especie de los perros es algo común para todos los objetos Perro.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/390/0*HTdQIhqP3kS4RG1t" /></figure><p><strong>Asignando atributos de clase</strong></p><p>Dado que es un atributo de clase, no es necesario crear un objeto para acceder al atributo.</p><p>Se puede acceder también al atributo de clase desde el objeto.</p><p>🤩<em>De esta manera, todos los objetos que se creen de la clase </em><strong><em>perro</em></strong><em> compartirán ese atributo de clase.</em></p><p><strong>Estructura final de una clase con atributos</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/476/0*2Acd5ZO_zzWkBbaa" /></figure><h3>Métodos</h3><p>En realidad cuando usamos <strong>__init__</strong> ya estábamos definiendo un método especial.</p><p>A continuación, vamos a ver cómo definir métodos que le den alguna funcionalidad interesante a nuestra clase, siguiendo con el ejemplo de perro. 👉</p><p>Vamos a codificar dos métodos: <strong>Ladrar</strong> y <strong>caminar</strong>.</p><p>El primero no recibirá ningún parámetro y el segundo recibirá el número de pasos que queremos andar. Como hemos indicado anteriormente, <strong>self</strong> hace referencia a la instancia de la clase.</p><p>Se puede definir un método con<strong> def y el nombre, y entre ( ) los parámetros de entrada que recibe</strong>, donde siempre tendrá que estar self el primero.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/569/0*qwGNEwuZmCAHFvPK" /></figure><p>Por lo tanto, si creamos un objeto <strong>mi_perro</strong>, podremos hacer uso de sus métodos llamándolos con <strong>.</strong> y el nombre del método. Como si de una función se tratase, pueden recibir y devolver argumentos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/657/0*tkIJO7g1tML22_TZ" /></figure><p>Nuestro código quedaría de la siguiente manera</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/629/0*YGg575sxMABSqLTQ" /></figure><h3><strong>Métodos especiales</strong></h3><p>Los <strong>métodos mágicos</strong> de las clases Python son aquellos que comienzan y terminan con dos caracteres subrayados. Son de suma importancia ya que muchas de las operaciones que se hacen con clases en Python utilizan estos métodos, como puede ser la creación del objeto<strong> (__init__)</strong> o generar una cadena que los represente <strong>(__str__)</strong>.</p><p>Todos estos métodos tienen un primer parámetro que hace referencia al propio objeto, que por convenio se suele llamar <strong>self.</strong> Siendo el resto de los parámetros del método variables.</p><p>Veamos a continuación algunos de estos métodos y cuál es su finalidad. 👉</p><h4><strong>Magic Method _init_</strong></h4><p>El método mágico más utilizado en las clases de python es el constructor. Empleado para crear cada una de las instancias de las clases. No tiene una cantidad fija de parámetros, ya que estos dependen de las propiedades que tenga el objeto. Por ejemplo, se puede crear un objeto Vector:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/284/1*byxAVAjH7mlaZvTqB5ivGg.png" /></figure><h4><strong>Magic method _str_</strong></h4><p>Posiblemente el segundo método más utilizado, con el que se crea una representación del objeto con significado para las personas.</p><p>En el ejemplo anterior, <strong>al imprimir el objeto, se ha visto una cadena que indica el tipo de objeto y una dirección</strong>. Lo que generalmente no tiene sentido para las personas.</p><p>Un problema que se puede solucionar con el método __str__.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/278/1*H3fEh09-xGEzYTUQGpA2cw.png" /></figure><h4>Magic method <strong>_len_</strong></h4><p>Podríamos usar la función len para obtener el número de elementos que tenga el objeto.</p><p>Pero si probamos con el objeto nos encontraremos con un error. 🤯</p><p>Esto es así porque la clase no ha implementado aún el método <strong>__len__</strong>. Un problema se puede solucionar de tomar fácil al incluir este método.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/283/1*cf446rzYmT2XgAmVeF00Ug.png" /></figure><p>El método __getitem__ solo nos sirve para leer, ya que para modificar, se tiene que crear también el método __setitem__, el cual veremos a continuación.</p><h4>Magic method <strong>_setitem_</strong></h4><p>Este es el complemento del método anterior. En este caso es necesario pasar dos parámetros adicionales, la posición y el valor a reemplazar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/379/1*w2D9bqgXXHb7gI5GqF5Qlw.png" /></figure><h3><strong>Clases anidadas</strong></h3><h4>Relación entre clases</h4><p>Cuando vimos el por qué trabajar por medio de este paradigma, dijimos que era fundamental para <strong>separar a nuestro problema en problemas más pequeños (Clases)</strong>, pero estos “problemas” no van a estar aislados, estarán <strong>relacionados entre sí.</strong> Por ejemplo, los<strong> Perros</strong>, suelen ser la mascota de una <strong>Persona.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pVloi0RuTJ0I5lRx" /></figure><p>Esta es otra forma de realizar clases internas a otras clases. No es lo más típico y usado, pero puede ser útil para cuando hay una relación muy estricta entre dos clases.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/0*ihhdWThZt8Cbkxzg" /></figure><h3><strong>Encapsulamiento</strong></h3><p>Es un concepto relacionado con la programación, orientada a objetos, y hace referencia al <strong>ocultamiento de los estados internos de una clase al exterior.</strong> Dicho de otra manera, encapsular consiste en <strong>hacer que los atributos o métodos internos a una clase no se puedan acceder ni modificar desde fuera,</strong> sino que tan solo el propio objeto pueda acceder a ellos.</p><p>Python por defecto no oculta los atributos y métodos de una clase al exterior ☹</p><p>Esto es genial para “aprender”, pero en la práctica no nos gustaría que desde la clase Perro le cambien el nombre a una instancia de la clase Sueldo, por dar un ejemplo. Es por eso que es fundamental “defender” a los datos y tornarlos privados.</p><p>Entonces…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/0*p7zBcaUQ7R5d0csV" /></figure><p>De esta forma, todo lo que esté privado <strong>( con doble __ )</strong> será imposible de acceder desde el exterior de la clase</p><h3><strong>¿Cómo encapsular en Python?</strong></h3><p>Hasta el momento sabemos que <strong>la encapsulación es el ocultamiento de datos del estado interno para proteger la integridad del objeto</strong>. En el siguiente ejemplo, CLIENTE es una clase, y hemos encapsulado (al anteponer __ ) la variable accountNumber.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/723/0*nw4QL3P_tZX50Ajt" /></figure><p>Del mismo modo, podemos ocultar el acceso a los métodos. Para eso, necesitamos anteponer el nombre del método con __ (subrayado doble).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/0*O3opFsjofgrW_Ntw" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48d3e96537e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programación orientada a Objetos]]></title>
            <link>https://estebanairaldo.medium.com/programaci%C3%B3n-orientada-a-objetos-a8f8e721c7e5?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8f8e721c7e5</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Sat, 24 Dec 2022 19:32:09 GMT</pubDate>
            <atom:updated>2022-12-24T19:32:09.315Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*e737yjYE4nWbjX34" /></figure><p>Es un modo o paradigma de programación, que nos permite organizar el código pensando el problema como una relación entre “cosas”, denominadas objetos. Los objetos se trabajan utilizando las “<strong>clases</strong>”.</p><p>Estas nos permiten agrupar un conjunto de variables y funciones que veremos a continuación.</p><p>Con la POO se busca resolver aplicaciones cada vez más complejas, sin que el código se vuelva un caos. Además, se pretende dar pautas para realizar las cosas de manera que otras personas puedan utilizarlas y adelantar su trabajo, de manera que consigamos que el código se pueda reutilizar.</p><p>Lo importante de la POO es poder separar los problemas generales en suma de pequeños problemas aislados, para poder modelar la solución y en un futuro que cualquiera pueda utilizar varios de estos módulos creados por este <strong>paradigma.</strong></p><p><strong>¿Qué es un paradigma de programación?</strong></p><p>Un paradigma de programación es un estilo de desarrollo de programas. Es decir, un <strong>modelo para resolver problemas computacionales</strong>.</p><p>Los lenguajes de programación se encuadran en uno o varios paradigmas a la vez a partir del tipo de órdenes que permiten implementar, algo que tiene una relación directa con su sintaxis.</p><p><strong>Paradigmas de programación:</strong></p><ul><li><strong>Imperativo</strong>: Los programas se componen de un conjunto de sentencias que cambian su estado. Son secuencias de comandos que ordenan acciones a la computadora.</li><li><strong>Declarativo:</strong> Opuesto al imperativo. Los programas describen los resultados esperados sin listar explícitamente los pasos a llevar a cabo para alcanzarlos.</li><li><strong>Lógico:</strong> El problema se modela con enunciados de lógica del primer orden.</li><li><strong>Funcional:</strong> Los programas se componen de funciones, es decir, implementaciones de comportamiento que reciben un conjunto de datos de entrada y devuelven un valor de salida.</li><li><strong>Orientado a Objetos:</strong> El comportamiento del programa es llevado a cabo por objetos, entidades que representan elementos del problema a resolver y tienen atributos y comportamiento.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*sHCrkIftlDn3kWYTiTiofw.png" /></figure><p><strong>Ventajas de la programación orientada a objetos</strong></p><p><strong>No se encapsulan los atributos</strong>, ni el acceso a los atributos desde las funciones, que también están encapsuladas dentro de la clase.</p><p><strong>Ofrece la posibilidad de heredar de unas clases a otras</strong> para que puedan acceder a los miembros de la clase padre, con lo cual podemos solucionar de una manera más eficiente, el ampliar el comportamiento de nuestros objetos o clases.</p><p><strong>Podemos hacernos visualmente una idea más clara de cómo se puede comportar la clase</strong>, además de tener en el mismo sitio tanto las funciones que hacen que podamos manejar la clase como los datos que vamos a manejar, etc.</p><h4><strong>¿Cómo se piensa con Programación Orientada a Objetos?</strong></h4><p>Es muy parecido a cómo lo haríamos en la vida real.</p><p>Por ejemplo: vamos a pensar en un coche para tratar de modelizar en un esquema de POO.</p><ul><li><strong>Elemento principal:</strong> coche.</li><li><strong>Características</strong>: marca, modelo, color, etc.</li><li><strong>Funcionalidades</strong>: reversa, aparcamiento, etc.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*JmUM-g8kTpEnWVWs" /></figure><p>Ahora si pensamos el ejemplo anterior desde el esquema de Programación Orientada a Objetos, sería de la siguiente manera:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/369/1*-TOvTkh2slj2BsQcP9Ypdw.png" /></figure><p>Para poder comentar el anterior esquema de POO fácilmente aparecen los denominados diagramas de clases.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/117/0*_uouz0AS27AekSaC" /><figcaption>Estructura estática que describe la estructura de un sistema mostrando las clases del sistema, sus atributos, operaciones, y las relaciones entre los objetos.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/801/1*oNhL8sgqrtS6_zwUZ9_dyg.png" /></figure><p><strong>Tipos de relaciones de clases</strong></p><p>La Orientación a Objetos (POO) intenta modelar aplicaciones del mundo real tan fielmente como sea posible y, por lo tanto, debe reflejar estas relaciones entre clases y objetos.</p><p>Existen tres tipos de relaciones:</p><h4>Agregación / Composición</h4><blockquote>Esta relación se presenta entre una clase TODO y una clase PARTE que es componente de TODO.</blockquote><blockquote>La implementación de este tipo de relación se consigue definiendo como atributo un objeto de la otra clase que es parte-de.</blockquote><blockquote>Los objetos de la clase TODO son objetos contenedores. <strong>Un objeto contenedor es aquel que contiene otros objetos.</strong></blockquote><h4>Asociación</h4><blockquote><strong>Especifica una relación semántica entre objetos no relacionados</strong>. Este tipo de relaciones permiten crear asociaciones que capturan los participantes en una relación semántica.</blockquote><blockquote>Son relaciones del tipo <strong>“pertenece_a”</strong> o <strong>“está_asociado_con”</strong>.</blockquote><blockquote>Se da cuando una clase usa a otra clase para realizar algo.</blockquote><h4>Generalización / Especialización. Herencia simple y herencia múltiple.</h4><blockquote>De todas las relaciones posibles entre las distintas clases y objetos, hay que destacar por su importancia en la POO el concepto de herencia. La relación de herencia es una relación entre clases que comparten su estructura y el comportamiento.</blockquote><blockquote>Resulta importante destacar que esta temática será abordada en próximos encuentros, por el momento únicamente definiremos los siguientes conceptos:</blockquote><blockquote><strong>Herencia simple: </strong>Una clase comparte la estructura y comportamiento de una sola clase.</blockquote><blockquote><strong>Herencia múltiple: </strong>Una clase comparte la estructura y comportamiento de varias clases.</blockquote><p><strong>Cardinalidad en las relaciones</strong></p><p>Sabemos que un coche tiene un motor, y que la persona está asociada a un vehículo.</p><p>Ahí nace el <strong>concepto de cardinalidad, es decir indicar el número de Objetos que están en la relación.</strong> Por ejemplo, una persona puede tener muchos coches, y que los coches solo tienen un motor.</p><p>Además, sabemos que cada motor pertenece a un solo coche, y los coches a veces tienen más de un titular que lo usan, es decir tienen a varias personas para usarlo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/375/0*IDaOkb5bLXxvgWND" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8f8e721c7e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Errores y excepciones en Python]]></title>
            <link>https://estebanairaldo.medium.com/errores-y-excepciones-en-python-1051e386b33c?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/1051e386b33c</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Mon, 21 Nov 2022 18:59:48 GMT</pubDate>
            <atom:updated>2022-11-21T18:59:48.258Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*z_m3CG-qX8-ozmKK" /><figcaption>¡Wellcome!</figcaption></figure><p><strong>Aprendiendo del error</strong></p><p>En la programación, se aprende a base de equivocarse, por lo tanto, debemos tolerar nuestros propios fallos para poder avanzar.</p><p>Programar no es fácil, podemos equivocarnos desde la concepción de la idea o también al escribir código, para lo primero poco podemos hacer, ya que es algo que mejorará con la práctica.</p><p><strong>¡A programar se aprende programando y cometer errores es la prueba de que estás avanzando!</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*k8156jQ7k4DDixEY" /><figcaption>¡cometan errores!</figcaption></figure><p>Existen al menos dos tipos diferentes de errores: errores de sintaxis y excepciones.</p><p><strong>Cuando el programa falla ocasiona su detención, por lo cual tenemos que ser capaces de detectar por qué y cómo prevenir estas fallas.</strong></p><p><strong>Errores</strong></p><p>Si algo tienen la mayoría de lenguajes de programación es que son exigentes con las instrucciones. Cuando en nuestro programa ocurre algún fallo Python nos lanzará un aviso indicando que ocurrió y detendrá la ejecución.</p><p>Los errores sintácticos están ligados a la sintaxis, que es la escritura de las instrucciones.</p><p>Algunos de los errores sintácticos más comunes:</p><ul><li>Cerrar paréntesis</li><li>Cerrar comillas o utilizar distintas comillas al abrir y cerrar</li><li>Tabular mal el código</li><li>No poner dos puntos al definir una función</li></ul><p>Ejemplo error sintáctico:</p><blockquote>print(“Hola”</blockquote><p>File “&lt;ipython-input-1–8bc9f5174855&gt;”, line 1</p><p>print(“Hola”</p><p>^</p><p><strong>SyntaxError:</strong> unexpected EOF while parsing</p><p><strong>EOF </strong>significa <strong>end of file</strong>, el error nos indica que esperaba que se cierre con un paréntesis.</p><h4>Errores de nombre</h4><p>Se producen cuando el sistema interpreta que debe ejecutar alguna función, pero no está definida. Devuelve NameError:</p><blockquote>&gt;&gt;&gt; <strong>pint</strong>(“Hola”)</blockquote><p>&lt;ipython-input-2–155163d628c2&gt; in &lt;module&gt;()</p><p>— → 1 <strong>pint</strong>(“Hola”)</p><p>NameError: name ‘pint’ is not defined</p><p>Pint no es la función print para imprimir por pantalla.</p><h4><strong>Errores semánticos</strong></h4><p>La mayoría de errores sintácticos y de nombre los identifican los editores de código antes de la ejecución, pero existen otros tipos que pasan más desapercibidos.</p><p>Estos errores son muy difíciles de identificar porque van ligados al sentido del funcionamiento y dependen de la situación. Algunas veces pueden ocurrir y otras no.</p><p>La mejor forma de prevenirlos es programando mucho y aprendiendo de tus propios fallos, la experiencia es la clave:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*MchsESwKWJC_YeSs" /><figcaption>codeen</figcaption></figure><p>Veamos a continuación algunos ejemplos:</p><p>Esta situación ocurre sólo durante la ejecución del programa, por lo que los editores no lo detectarán:</p><blockquote>lista = []</blockquote><blockquote>lista.pop()</blockquote><blockquote>&lt;ipython-input-6–9e6f3717293a&gt; in &lt;module&gt;()— → 1 l.pop()</blockquote><blockquote>IndexError: pop from empty list</blockquote><p>Si intentamos sacar un elemento de una lista vacía, algo que no tiene mucho sentido, el programa dará fallo de tipo IndexError.</p><p>Para prevenir el error deberíamos comprobar que una lista tenga como mínimo un elemento antes de intentar sacarlo, algo factible utilizando la función len():</p><blockquote>lista = []</blockquote><blockquote>if len(lista) &gt; 0:</blockquote><blockquote>&gt;&gt;&gt;lista.pop()</blockquote><p>Cuando leemos un valor con la función input(), éste siempre se obtendrá como una cadena de caracteres. Si intentamos operarlo directamente con otros números tendremos un fallo TypeError que tampoco detectan los editores de código:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/0*9T_kJupvl-MSPzYT" /><figcaption>Las cadenas F nos sirven para insertar valores dentro de una cadena. Dichos valores pueden ser una operación matemática, una variable, un número o el retorno ya sea una de una función o el de un método.</figcaption></figure><p>Como ya sabemos este error se puede prevenir transformando la cadena a entero o flotante:</p><h4><strong>Excepciones</strong></h4><p>Incluso si la sentencia o expresión es sintácticamente correcta, puede generar un error cuando se intenta ejecutarla. Los errores detectados durante la ejecución se llaman excepciones, y no son incondicionalmente fatales: pronto aprenderás cómo manejarlos en los programas en Python.</p><p>Sin embargo, la mayoría de las excepciones no son manejadas por los programas, y resultan en mensajes de error como los mostrados aquí:</p><blockquote>10 * (1/0)</blockquote><p>Traceback (most recent call last):</p><p>File “&lt;stdin&gt;”, line 1, in ?</p><p>ZeroDivisionError: integer division or modulo by zero</p><blockquote>&gt;&gt;&gt; 4 + spam*3</blockquote><p>Traceback (most recent call last):</p><p>File “&lt;stdin&gt;”, line 1, in ?</p><p>NameError: name ‘spam’ is not defined</p><p>Como podemos suponer, es difícil prevenir fallos que ni siquiera nos habíamos planteado que podían existir. Por suerte para esas situaciones existen las excepciones.</p><p>Las excepciones son bloques de código que nos permiten continuar con la ejecución de un programa pese a que ocurra un error.</p><p><strong>Try-Except</strong></p><p>Para prevenir el fallo debemos poner el código propenso a errores en un bloque <strong>try</strong> y luego encadenar un bloque <strong>except</strong> para tratar la situación excepcional mostrando que ha ocurrido un fallo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qFC1SU0HRVfhksp-" /></figure><p>La sentencia <strong>try </strong>funciona de la siguiente manera:</p><ul><li>Se ejecuta el bloque try (el código entre las sentencias try y except).</li><li>Si no ocurre ninguna excepción, el bloque except se saltea y termina la ejecución de la sentencia try.</li></ul><p>La sentencia try funciona de la siguiente manera 👇</p><ul><li>Si ocurre una excepción durante la ejecución del bloque try, el resto del bloque se saltea. Luego, si su tipo coincide con la excepción nombrada luego de la palabra reservada except, se ejecuta el bloque except, y la ejecución continúa luego de la sentencia try.</li><li>Si ocurre una excepción que no coincide con la excepción nombrada en el except, esta se pasa a declaraciones try de más afuera; si no se encuentra nada que la maneje, es una excepción no manejada, y la ejecución se frena con un mensaje como los mostrados arriba.</li></ul><p>Try — Except <strong>nos permite controlar situaciones excepcionales que generalmente darían error</strong> y en su lugar permite mostrar un mensaje o ejecutar una pieza de código alternativo.</p><h4>Else en try-except</h4><p>Las declaraciones try — except tienen un bloque else opcional, el cual, cuando está presente, debe seguir a los except. El bloque else es un buen momento para romper la iteración con break si todo funciona correctamente.</p><p>El uso de else es mejor que agregar código adicional en el try porque evita capturar accidentalmente una excepción que no fue generada por el código que está protegido por la sentencia try — except.</p><p>Ejemplo:</p><blockquote>while (True):</blockquote><blockquote>&gt;&gt;&gt;try:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;a = float(input(“Introduce un número: “))</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;b = float(input(“Introduce otro número: “))</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;print(a + b)</blockquote><blockquote>&gt;&gt;&gt;except:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;print(“Ha ocurrido un error. Tienes que introducir 2 números.”)</blockquote><blockquote>&gt;&gt;&gt;else:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;print(“La suma se ha realizado correctamente.”)</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;break # Importante romper la iteración si todo ha ido bien.</blockquote><h4><strong>Finally</strong></h4><p>La sentencia try tiene otra sentencia opcional que intenta definir acciones de limpieza que deben ser ejecutadas bajo ciertas circunstancias. Una sentencia finaly siempre es ejecutada antes de salir de la sentencia try, ya sea que una excepción haya ocurrido o no.</p><p>Cuando ocurre una excepción en la sentencia try y no fue manejada por una sentencia except (u ocurrió en una sentencia except o else), es relanzada luego de que se ejecuta la sentencia finally.</p><p>La sentencia finally es también ejecutada «a la salida» cuando cualquier otra sentencia de la sentencia try es dejada vía break, continue or return.</p><p>Ejemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*t9ZJfiIdVMEoIu7Im3i_1Q.png" /></figure><h4><strong>Excepciones múltiples</strong></h4><p>En una misma pieza de código pueden ocurrir muchos errores distintos y quizá nos interese actuar de forma diferente en cada caso.</p><p>Para esas situaciones algo que podemos hacer es asignar una excepción a una variable.De esta forma es posible analizar el tipo de error que sucede gracias a su identificador:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/511/1*U5DhjugSJrhqMcvEs4KVvg.png" /></figure><p>Cada error tiene un identificador único que curiosamente se corresponde con su tipo de dato. Aprovechando eso podemos mostrar la clase del error utilizando la sintaxis: <strong>&gt;&gt;&gt; print( type(e) )</strong></p><blockquote><strong>&gt;&gt;&gt; print( type(e).__name__)</strong></blockquote><blockquote><strong>&gt;&gt;&gt; print(type(1).__name__)</strong></blockquote><blockquote><strong>&gt;&gt;&gt; print(type(3.14).__name__)</strong></blockquote><blockquote><strong>&gt;&gt;&gt; print(type([]).__name__)</strong></blockquote><blockquote><strong>&gt;&gt;&gt; print(type(()).__name__)</strong></blockquote><p>Si lo ejecutamos, siempre nos indica “class” delante. Eso es porque en Python todo son clases, pero hablaremos de este concepto más adelante (POO). Lo importante ahora es que podemos mostrar solo el nombre del tipo de dato (la clase) consultando su propiedad especial name.</p><p>Gracias a los identificadores de errores podemos crear múltiples comprobaciones, siempre que dejemos en último lugar la excepción por defecto. Excepción que engloba cualquier tipo de error.</p><p>Veamos a continuación un ejemplo</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/558/1*WjKbDiUQ0jBpOVNjdtZ6_w.png" /></figure><p>¡A practicar!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*Fizu5R61QBsW96qT" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1051e386b33c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Parámetro y argumentos de funciones en Python]]></title>
            <link>https://estebanairaldo.medium.com/par%C3%A1metro-y-argumentos-de-funciones-en-python-a5e26ab7774e?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5e26ab7774e</guid>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python-programming]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Mon, 21 Nov 2022 15:20:36 GMT</pubDate>
            <atom:updated>2022-11-21T15:20:36.595Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/299/0*AROb9jugf2Zys8KV" /><figcaption>¡empecemos!</figcaption></figure><p>Como sabemos, durante la definición de la función, las variables o valores se denominan parámetros:</p><blockquote>def suma(numero1, numero2):</blockquote><blockquote>return numero1 + numero2</blockquote><p>Y durante la llamada se le denominan argumentos, como los argumentos de los scripts.</p><blockquote>resultado = suma(<strong>7</strong>, <strong>5</strong>)</blockquote><p>En este artículo estaremos viendo los distintos tipos de argumentos y parámetros.</p><h4><strong>Argumento por posición</strong></h4><p>Cuando se envían argumentos a una función, se reciben por orden en los parámetros definidos:</p><blockquote>def suma(<strong>numero1, numero2</strong>):</blockquote><blockquote>return numero1 + numero2</blockquote><blockquote>resultado = suma(7, 5)</blockquote><p>El argumento 7 es la posición 0, por consiguiente es el parámetro de la función numero1, seguidamente el argumento 5 es la posición 1 por consiguiente es el parámetro de la función numero2.</p><p>Si tomamos el siguiente ejemplo sabremos que la resta nos dará 3:</p><blockquote>def resta(a, b):</blockquote><blockquote>&gt;&gt;&gt;return a — b</blockquote><blockquote>resultado = resta(15, 12)</blockquote><blockquote>resultado</blockquote><p>Pero, si modificamos el orden de los argumentos nos dará otro resultado:</p><blockquote>resultado = resta(12, 15)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*36bFjKUosW3bpN5N" /></figure><h4><strong>Argumentos por nombre</strong></h4><p>Como vimos, si pasamos ordenado el argumento, se verá reflejado ordenadamente el parámetro.</p><p>Para cambiar esto se utiliza la asignación de argumentos por nombre, si indicamos durante la llamada que valor tiene cada parámetro a partir de su nombre:</p><blockquote>def resta(a, b):</blockquote><blockquote>&gt;&gt;&gt;return a — b</blockquote><blockquote>resultado = resta(b=15, a=12)</blockquote><blockquote>resultado</blockquote><p>Recordemos que al utilizar argumentos por nombre, no importa el orden:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*fWutvaTeSz_ejp7dYUHfow.png" /></figure><h4><strong>Llamada sin argumentos</strong></h4><p>Veamos qué pasa si llamamos una función con parámetros ya definidos:</p><blockquote>def resta(a, b):</blockquote><blockquote>return a — b</blockquote><blockquote>resultado = resta()</blockquote><p>Traceback (most recent call last):</p><p>File “&lt;stdin&gt;”, line 1, in &lt;module&gt;</p><p>TypeError: resta() takes exactly 2 arguments (0 given)</p><p><strong>Parámetros por defecto</strong></p><p>Python, nos deja asignar unos valores por defecto a los parámetros, es decir, indicarle que tendrán un valor por defecto si no viene ningún valor.</p><blockquote>def resta(a=10, b=5):</blockquote><blockquote>&gt;&gt;&gt;return a — b</blockquote><blockquote>resultado = resta()</blockquote><p>&gt;&gt;&gt;5</p><h4><strong>Argumentos</strong></h4><p>Si hablamos de argumentos tenemos que tener algo en cuenta:</p><p>Cuando enviamos información a una función generalmente estos datos se envían por valor.</p><p>Eso significa que se crea una copia dentro de la función de los valores que enviamos en sus propias variables. Pero, hay casos excepcionales, las colecciones, listas, diccionarios, conjuntos. Estos datos se envían por referencia.</p><p><strong>Referencia</strong></p><p>¿Que significa que los conjuntos como listas, tuplas, etc, se envíen por referencia?</p><p>Significa que, en lugar de una copia dentro de la función, estaremos manejando el dato original, y si lo modificamos también se verá reflejado en el exterior, es decir, en el conjunto original y no en una copia en la función. Esto debido a que hacen referencia a la variable externa, algo así como un acceso directo.</p><p><strong>Dependiendo del tipo de dato:</strong></p><ul><li>Paso por valor: se crea una copia local de la variable dentro de la función. <strong>Los tipos simples se pasan por valor</strong>: Enteros, flotantes, cadenas, lógicos…</li><li>Paso por referencia: Se maneja directamente la variable, los cambios realizados dentro de la función le afectarán también fuera. <strong>Los tipos compuestos se pasan por referencia</strong>: Listas, diccionarios, tuplas, conjuntos…</li></ul><p><strong>Paso por valor</strong></p><p>Los números se pasan por valor y crean una copia dentro de la función, no les afecta externamente lo que hagamos con ellos en la función:</p><blockquote>def doblar_valor(numero):</blockquote><blockquote>&gt;&gt;&gt;numero *= 2</blockquote><blockquote>numero = 10</blockquote><blockquote>doblar_valor(numero)</blockquote><blockquote>print(numero)</blockquote><blockquote>&gt;&gt;&gt; 10</blockquote><p><strong>Paso por referencia</strong></p><p>Las listas u otras colecciones son del tipo <strong>compuesto</strong>, por lo que se pasa por referencia, las modificaciones dentro de la función también se harán por fuera.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ISySQ-luHpghkWH3" /></figure><h4><strong>Argumentos valor-referencia</strong></h4><p>Como vimos, las listas en este caso, hacen referencia a su variable original mientras que los números o tipos de datos más simples “pasan” directamente por valor.</p><p>A continuación una pregunta clave…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*LkGY8M5enp9Vjs52o_ojeg.png" /></figure><p>La respuesta es NO. En Python no se pueden utilizar punteros como en otros lenguajes.</p><blockquote>def doblar_valor(<strong>numero</strong>):</blockquote><blockquote>&gt;&gt;&gt;return numero *= 2</blockquote><blockquote>numero = 10</blockquote><blockquote>numero = doblar_valor(numero)</blockquote><p>Aunque podemos utilizar trucos, como devolver el valor modificado dentro de la función y volverlo a asignar a la misma variable en caso de desear que sea “<strong>referencia</strong>”.</p><h4><strong>Argumentos indeterminados</strong></h4><h4><strong>Uso de *Args y **Kwargs en python</strong></h4><p>¿Para qué se usan?</p><p>Lo primero de todo es que en realidad no tienes por qué usar los nombres args o kwargs, ya que se trata de una mera convención entre programadores. (recomendamos utilizarla) Sin embargo, lo que sí debes usar es el asterisco simple * o doble **. Es decir, podrías escribir *variable y **variables.</p><p>Gracias a los *args en Python, podemos definir funciones cuyo número de argumentos es variable. Es decir, podemos definir funciones genéricas que no aceptan un número determinado de parámetros, sino que se “adaptan” al número de argumentos con los que son llamados. Ejemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/205/0*yek3UFPLg3Q6_L7L" /></figure><p>Veamos aquí como *args puede ser iterado, ya que en realidad es una tupla.</p><p>Por lo tanto iterando la tupla podemos acceder a todos los argumentos de entrada, y en nuestro caso sumarlos y devolverlos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/212/0*vptEqGpEyRCXjk0X" /></figure><p>Una forma más sencilla de escribir el código anterior. 👏</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/0*KG14j4v4xfsP-58L" /></figure><p>Al igual que en *args, en **kwargs el nombre es una mera convención entre los usuarios de Python. Puedes usar cualquier otro nombre siempre y cuando respetes el **.</p><p>A diferencia de *args, los **kwargs nos permiten dar un nombre a cada argumento de entrada, pudiendo acceder a ellos dentro de la función a través de un diccionario.</p><p><strong>Ejemplo uso de *Kwargs</strong></p><p>Podemos ver que es posible iterar los argumentos de entrada con items(), y podemos acceder a la clave key (o nombre) y el valor o value de cada argumento.</p><p>El uso de los **kwargs es muy útil si además de querer acceder al valor de las variables dentro de la función, quieres darles un nombre que de una información extra.</p><p><strong>Pensar como un diccionario.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/315/0*S15URAhgtT32zgvY" /></figure><h4><strong>Funciones recursivas</strong></h4><p><strong>Recursividad</strong></p><p>La recursión o recursividad es un proceso de repetición en el que algo se repite a sí mismo. Es el efecto que sucede cuando se ponen dos espejos frente al otro.</p><p>En informática, la recursividad es una técnica muy utilizada, la cual se basa en dividir un problema en partes más pequeñas para poder solucionarlo de forma más simple.</p><p>Donde más se suele utilizar es en las funciones.</p><p>Cuando una función se llama a sí misma, tenemos una función recursiva con un comportamiento muy similar al de una sentencia iterativa (if, while, etc.) pero debemos encargarnos de planificar el momento en que dejan de llamarse a sí mismas o tendremos una función recursiva infinita.</p><p>Podríamos dividir las funciones recursivas en dos: discursivas sin retorno y discursivas con retorno.</p><p><strong>Función recursiva sin retorno</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*0zm7J-TOzc5-ZkDR" /></figure><p>Un ejemplo de una función recursiva sin retorno es el de una cuenta regresiva hasta cero a partir de un número dado.</p><p><strong>Función recursiva con retorno</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*5Fz3XIke-Cdbmm8I" /></figure><p>Un ejemplo de una función recursiva con retorno, es el ejemplo del cálculo del factorial de un número corresponde al producto de todos los números desde 1 hasta el propio número.</p><p><strong>Funciones integradas</strong></p><p>Ahora que conocemos las funciones, no podemos acabar sin comentar varias de las integradas en Python. Muchas de ellas son para hacer conversiones entre tipos de datos, otras para manipular información, matemáticas, y de más.</p><p>👉Veremos un resumen de las más utilizadas incluyendo algunas ya conocidas.</p><p><strong>Int</strong></p><p>La función int() devuelve un número entero. Es un constructor, que crea un entero a partir de un entero float, entero complex o una cadena de caracteres que sean coherentes con un número entero.</p><p><strong>Float</strong></p><p>La función float() devuelve un número coma flotante float. Es un constructor, que crea un coma flotante a partir de un entero, entero long, entero float (cadenas de caracteres formadas por números y hasta un punto) o una cadena de caracteres que sean coherentes con un número entero.</p><p><strong>Str</strong></p><p>La función str() es el constructor del tipo de cadenas de caracteres, se usa para crear un carácter o cadenas de caracteres mediante la misma función str(). Puede convertir un número entero a una cadena de caracteres, de la siguiente forma:</p><p><strong>Round</strong></p><p>La función round() redondea un número flotante a una precisión dada en dígitos decimal (por defecto 0 dígitos). Esto siempre devuelve un <strong>número flotante</strong>. La precisión tal vez sea negativa.</p><p>👉En el siguiente ejemplo veremos el redondeo de un número flotante a entero, mayor o igual a .5 al alza:</p><blockquote>&gt;&gt;&gt; round(2.5)</blockquote><p>3</p><p>👉En este otro ejemplo veremos el redondeo de un número flotante a entero, menor de .5 a la baja:</p><blockquote>&gt;&gt;&gt; round(2.4)</blockquote><p>2</p><p><strong>Help</strong></p><p>Invoca el menú de ayuda del intérprete de Python</p><p>&gt;&gt;&gt; help()</p><p>Welcome to Python 3.8! This is the online help utility.</p><p>If this is your first time using Python, you should definitely check out the tutorial on the Internet at <a href="https://docs.python.org/3.8/tutorial/">https://docs.python.org/3.8/tutorial/.</a></p><p>Enter the name of any module, keyword, or topic to get help on writing Python programs and using Python modules. To quit this help utility and return to the interpreter, just type “quit”.</p><p>To get a list of available modules, keywords, or topics, type “modules”, “keywords”, or “topics”. Each module also comes with a one-line summary of what it does; to list the modules whose summaries contain a given word such as “spam”, type “modules spam”.</p><p>help&gt;</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5e26ab7774e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Funciones en Python]]></title>
            <link>https://estebanairaldo.medium.com/funciones-en-python-789eb3cdf9f4?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/789eb3cdf9f4</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Mon, 21 Nov 2022 14:37:00 GMT</pubDate>
            <atom:updated>2022-11-21T14:37:00.480Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*c1BsfcCiNQoBwISO" /></figure><p>Cuando creamos nuestros propios programas nos damos cuenta de que muchas de las tareas que implementamos se repiten o se presentan de forma similar pero con algunos cambios.</p><p>Entonces aparece la necesidad de agrupar este código repetido o similar, a las agrupaciones de código se les denomina <strong>funciones </strong>las cuales se pueden ejecutar múltiples veces gracias a un nombre único que las identifica.</p><p>Para comunicarse con nuestro proceso principal, las funciones pueden recibir y devolver datos manipulados. Un ejemplo de una función que conocemos es <strong>len</strong>() que nos permite saber la cantidad de elementos de una colección</p><p>Recordemos que a esta función hay que pasarle el elemento del cual queremos saber la longitud y devuelve un valor entero con la longitud, a este valor se le denomina valor de retorno.</p><blockquote><strong>&gt;&gt;&gt; len(“Hola”)</strong></blockquote><p><strong>4</strong></p><h4>Sentencia def</h4><p>La sentencia def sirve para crear funciones definidas por el usuario. Una definición de función es una sentencia ejecutable.</p><p><strong>Sintaxis para una definición de función en python</strong></p><ul><li><strong>Nombre:</strong> Es el nombre de la función</li><li><strong>Parámetro</strong>: Como vimos en la clase 8 hay scripts con argumentos, en las funciones, cuando recibe argumentos, se les denominan parámetros.</li><li><strong>Sentencias</strong>: Es el bloque del código.</li><li><strong>Return:</strong> Es una sentencia de Python, le indica a la función qué devolver cuando llamamos a la función</li><li><strong>Expresión:</strong> Es lo que devuelve la sentencia return.</li></ul><blockquote>&gt;&gt;&gt; def len(iterable):</blockquote><blockquote>contador = 0</blockquote><blockquote>for elemento in iterable:</blockquote><blockquote>contador += 1</blockquote><blockquote>RETURN contador</blockquote><p><strong>Definir funciones básicas en python</strong></p><blockquote><strong>def saludar():</strong></blockquote><blockquote><strong>print(‘Estoy saludando desde la función’)</strong></blockquote><p>La llamamos usando: <strong>saludar()</strong></p><p>Estoy saludando desde la función.</p><p><strong>Definir funciones más avanzadas</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1004/0*_qJD49PbZkhqwXJ8" /></figure><p><strong>Recomendaciones</strong></p><ul><li>Utilizar minúsculas</li><li>Las palabras se separan con guiones bajos _</li><li>Utilizar nombres autoexplicativos</li></ul><blockquote>No usar nombres que no definan lo que hace la función (ejemplo letras simples o palabras sin sentido con lo que haga la función)</blockquote><h4><strong>Variables y funciones</strong></h4><p>Ten en cuenta que las variables creadas en una función <strong>no existen </strong>fuera de la misma, de decir son variables locales.</p><blockquote><strong>def test():</strong></blockquote><blockquote><strong>&gt;&gt;&gt;variable_test = 10</strong></blockquote><blockquote><strong>&gt;&gt;&gt;print(variable_test)</strong></blockquote><blockquote><strong>print(variable_test)</strong></blockquote><p>NameError: name ‘variable_test’ is not defined</p><p>Sin embargo, hay que tener cuidado con las variables fuera de las funciones al usarlas en una función, ya que no puede llegar a funcionar como queremos:</p><blockquote><strong>variable_test = 10</strong></blockquote><blockquote><strong>def test():</strong></blockquote><blockquote><strong>variable_test = 155</strong></blockquote><blockquote><strong>print(variable_test)</strong></blockquote><blockquote><strong>test()</strong></blockquote><p><strong>&gt;&gt;&gt;155</strong></p><p>El print le da prioridad a la variable dentro de la función antes que a la de afuera.</p><h4>return de funciones en Python</h4><p>Las funciones pueden comunicarse con el exterior de las mismas, al proceso principal del programa usando la sentencia return. La comunicación con el exterior se hace devolviendo valores.</p><p>A continuación, un ejemplo de función usando return:</p><blockquote>def saludar_con_nombre(nombre):</blockquote><blockquote>&gt;&gt;&gt;saludando = print(‘Hola {}! ¿Cómo estás?’.format(nombre))</blockquote><blockquote>&gt;&gt;&gt;return saludando</blockquote><blockquote>saludar_con_nombre(“Juan”)</blockquote><p>&gt;&gt;&gt;Hola Juan ¿Cómo estás?</p><p>Sin embargo, hay que tener en cuenta que la función termina al devolver un valor, es decir, lo que escribamos después no se ejecutará:</p><blockquote>def saludar_con_nombre(nombre):</blockquote><blockquote>&gt;&gt;&gt;saludando = print(‘Hola {}! ¿Cómo estás?’.format(nombre))</blockquote><blockquote>&gt;&gt;&gt;return saludando</blockquote><blockquote>&gt;&gt;&gt;print(“Hola Mundo”) #esto no se printea</blockquote><p>Algo interesante que pasa si devolvemos una colección es que podemos utilizarla directamente desde la función y hacer uso de las funciones internas de las colecciones:</p><p>Sin embargo, cada vez que hagamos un print a una función la estaremos llamando, por lo que lo ideal es asignarlo a una variable y trabajarlo desde ahí:</p><blockquote>def lista():</blockquote><blockquote>&gt;&gt;&gt;return [1,2,3,4,5]</blockquote><blockquote>print(lista()[1:3])</blockquote><blockquote>variable = lista()</blockquote><blockquote>variable[1:4]</blockquote><p><strong>Ingresar valores a una función</strong></p><p>Vimos como devolver valores y así comunicar una función con el exterior, ahora enviaremos información desde el exterior a la función.</p><p>Para entender los conceptos más fácilmente vamos a trabajar alrededor de un caso de estudio típico: crear una función que sume dos números y retorne uno en su resultado.</p><p>Lo primero será definir una función la cual denominaremos como <strong>suma</strong> y recibirá 2 números con dos nombres como si fueran dos variables <strong>numero1 </strong>y <strong>numero2</strong>, luego retornamos la <strong>suma</strong> entre ambos números.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/434/0*HsxDXDvyqb7fY997" /></figure><blockquote>def suma(numero1, numero2):</blockquote><blockquote>&gt;&gt;&gt;return numero1 + numero2</blockquote><p>Lo que hacemos para indicar que se reciben valores es <strong>crear dos variables separadas por una coma</strong>. Cuando nosotros llamemos a la función, automáticamente, se le asignarán a estas variables los números que enviemos, siguiendo el mismo orden:</p><blockquote>&gt;&gt;&gt; r = suma(7, 5)</blockquote><p>En este caso 7 será la variable numero1 y 5 será la variable numero2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*AYDH18nknlOU4kJW" /></figure><h4>Momentos de una función</h4><ol><li>Tenemos la definición</li></ol><blockquote>def suma(numero1, numero2):</blockquote><blockquote>return numero1 + numero2</blockquote><p>2. Y la llamada</p><blockquote>r = suma(7, 5)</blockquote><p>Durante la definición de la función, las variables o valores se denominan parámetros</p><blockquote>def suma(numero1, numero2):</blockquote><blockquote>return numero1 + numero2</blockquote><p>Y durante la llamada se le denominan argumentos, como los argumentos de los scripts.</p><blockquote>r = suma(7, 5)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*l1qQDOE9cshKKtUZ" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=789eb3cdf9f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Manejo de archivos en Python]]></title>
            <link>https://estebanairaldo.medium.com/manejo-de-archivos-en-python-1f29c2af8547?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f29c2af8547</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[back-end-developer]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Mon, 21 Nov 2022 13:59:54 GMT</pubDate>
            <atom:updated>2022-11-21T13:59:54.949Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*2uwengWqJw8Se2DX" /></figure><h3>Persistencia de datos</h3><p>Hasta el momento todos los programas que realizamos ya tenían datos; por ejemplo: las edades de las personas, nombres, apellidos, lista de números, etc. Pero todos esos datos había que generarlos cada vez que usábamos nuestro programa y los datos se perdían de un día al otro.</p><p>La persistencia es lo que nos va a permitir guardar y recuperar los datos que se generaron en algún programa (ya sea nuestro o ajeno).</p><p>En programación, la persistencia es la acción de preservar la información de un objeto de forma permanente (guardado), pero a su vez también se refiere a poder recuperar la información del mismo (leerlo) para que pueda ser nuevamente utilizado.</p><p>De forma sencilla, puede entenderse que los datos tienen una duración efímera; desde el momento en que estos cambian de valor se considera que no hay persistencia de los mismos.</p><h4>Tipos de persistencia</h4><p>El guardado de datos se puede hacer en dos grandes estructuras.</p><ul><li>En base de datos (o almacenes de datos y sus variantes)</li></ul><blockquote>Las bases de datos son sin duda la mejor alternativa para almacenar y explorar los datos. Estas son complejas y por lo general necesitan de la instalación de algún motor o programa que nos permita utilizarlas.</blockquote><ul><li>En archivos</li></ul><blockquote>Los archivos son la forma más antigua, primitiva y simple de almacenar datos.</blockquote><blockquote>Pero créanlo o no, aún se sigue utilizando este mecanismo en más de un aplicativo; incluso en programas bastante sofisticados.</blockquote><p><strong>¿Qué son los archivos?</strong></p><p>Un archivo o fichero informático es una secuencia de bytes que son almacenados en un dispositivo. Un archivo es identificado por un nombre y la descripción de la carpeta o directorio que lo contiene. A los archivos informáticos se les llama así porque son los equivalentes digitales de los archivos escritos en expedientes, tarjetas, libretas, papel o microfichas del entorno de oficina tradicional.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/317/0*MNVy3_2QSKS1HwqS" /></figure><p><strong>Tipos de archivos</strong></p><p>Hay dos grandes tipos de archivos:</p><ul><li>Los binarios son aquellos archivos que mejoran su eficiencia pero los datos están guardados bajo agrupaciones de bytes; lo que hace que solo la pc pueda decodificarlos.</li><li>Los de texto son lo que uno imagina, texto que guarda el dato en particular de una forma bastante descriptiva e intuitiva.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/317/0*a2TIApyTRHvEjkog" /></figure><p>A su vez, los archivos de texto pueden ser de muchas extensiones, las más clásicas son: <strong>.txt, .doc, .docx, .xml, .csv, .json,</strong> etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/0*ufFsyvz-JqSGQoZL" /></figure><h4>Escritura de archivos con Google Colab</h4><ol><li>Damos acceso a nuestro drive.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/0*5fw5uQ7G6HwU4_2j" /></figure><p>2. Verificar nuestra identidad:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/0*SMVPQOidLBcBYb4c" /></figure><p>3. Seleccionar la carpeta donde queremos escribir nuestro archivo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/0*fFzj8x9jwvPeN1sN" /></figure><p>4. Seleccionar la carpeta donde queremos escribir nuestro archivo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/443/1*DtYvSQK9Iu3PXjLK8PW-4w.png" /></figure><p>5.Crear una variable con esa ruta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*s_Ar4HbvtyhJlKzC" /></figure><p>Y luego solo decidir cómo quieren que se llame el archivo y dar permisos para escribir en él “w”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/0*nLh4-pA_-3xqaGIy" /></figure><p>6. El archivo quedará así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/459/0*n4zKXJtXFg0VIq26" /></figure><p>Veamos un ejemplo similar, pero un poco más completo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/0*0_WpshOlZmp5qnwo" /></figure><p>¿Qué creen que se guardó?</p><p>Esta es una forma muy útil de guardar información utilizando lo que se llaman delimitadores</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/470/0*qjjcBB26xzcQcEx4" /></figure><h4>Lectura de archivos en Python</h4><p>Supongamos que queremos recuperar los datos de un archivo cualquiera: <a href="https://drive.google.com/file/d/1r3tsdHXRGNsZrWQXBFe7wBwi9HUFHmj4/view?usp=sharing">paraLeer.txt</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/0*ux-WDPL2vZmkO1WZ" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/434/0*nPFlKuuO6aKRtKLx" /></figure><p>Es muy sencillo y similar a lo que hicimos con la escritura; solo debemos dar permisos de lectura (read — r).</p><p>Además python nos da tres formas de realizarlo:</p><ul><li>Read</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/0*LuBsLmzFXkwiG4Cx" /></figure><ul><li>Readline (es lo mismo, sólo nos deja ver el primer renglón.)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/0*ERQc0jlkXSRoWubq" /></figure><ul><li>Readlines (es lo mismo…parece idéntico, pero esto nos permite acceder renglón por renglón al txt)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/589/0*z4I_n1eVzSxCZpeh" /></figure><ul><li>Seek (acceder a una ubicación en particular, es decir, empezar la lectura desde la posición indicada. ¿Qué ha pasado?, ¿Por qué la n?)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/0*wDdGsQPM-Xl2ta4A" /></figure><p>El Seek se puede combinar con cualquiera de las tres formas de lectura, pero podemos indicar desde qué carácter queremos iniciar la lectura, por ejemplo, acá le estamos indicando que queremos leer del carácter 20 en adelante.</p><h4><strong>ARCHIVOS JSON</strong></h4><p>SON es un formato de texto sencillo para el intercambio de datos. Se trata de un subconjunto de la notación literal de objetos de JavaScript, aunque, debido a su amplia adopción como alternativa a XML, se considera un formato independiente del lenguaje.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*1EGNRhb4t2zJ9sfQ" /></figure><p>Por ahora solo trabajamos con extensiones .txt, pero para el guardado de datos suele ser más útil otro tipo de formato, como el csv, xml o el json.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*Lwoq8qDT_Br7GLWQrJPqsg.png" /></figure><h4>ARCHIVOS CSV</h4><p>En este apartado vamos a leer datos de alguna fuente oficial para poderlos trabajar desde Python.</p><p>Ejemplo: datos oficiales de la Nación y de CABA (Argentina)</p><p><strong>Datos ciudad de Buenos Aires:</strong> <a href="https://data.buenosaires.gob.ar/dataset/">https://data.buenosaires.gob.ar/dataset/</a> <strong>Datos Nación:</strong> <a href="https://datos.gob.ar/">https://datos.gob.ar/</a></p><p>Hagamos un pequeño Análisis Exploratorio de Datos</p><p>¿QUÉ ES UN EDA?</p><p>El Análisis Exploratorio de Datos o también conocido como EDA de sus siglas en inglés: Exploratory Data Analysis, tiene como finalidad examinar nuestros datos para lograr un entendimiento holistico e integral de las relaciones existentes entre las variables analizadas.</p><p>El EDA, proporciona métodos sencillos para organizar y preparar los datos, detectar fallos en el diseño y recogida de datos, tratamiento y evaluación de datos ausentes, identificación de casos atípicos y mucho más.</p><p>Pasos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ruq-lOpNP8I1HUuW" /></figure><p>Admitimos que parece abrumador lo último, pero solo hicimos un read de un dato en otro formato csv. Pero veamos la magia; ya tenemos todos los datos guardados en una variable de Python como para trabajar sin problema:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/966/0*1iehRqLoVS6duzFF" /></figure><p>Todo lo que podemos hacer ahora ya depende de otra rama de la multifuncionalidad de Python, que es el análisis de datos.</p><p>Pero veamos lo básico:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YfHD9eGRRPN63xWt" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*u88zuD1gZeesoEbd" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*dVdnXLEdsTO0tkfQ" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f29c2af8547" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Métodos de colecciones]]></title>
            <link>https://estebanairaldo.medium.com/m%C3%A9todos-de-colecciones-3e6703258773?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e6703258773</guid>
            <category><![CDATA[backend-developer]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[back-end-development]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Sun, 20 Nov 2022 23:23:10 GMT</pubDate>
            <atom:updated>2022-11-20T23:23:10.381Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*J3ou3XtfuL8arnDn" /><figcaption>¡Arranquemos!</figcaption></figure><p>Revisaremos los métodos para cadenas, listas, conjuntos y diccionarios.</p><h4>Metodos para Cadenas en Python</h4><p><strong>Upper</strong></p><p>Esta función integrada sirve para hacer que se devuelva la misma cadena pero con sus caracteres en mayúscula, usando el método <strong>upper()</strong>.</p><p>Se escribe como: <strong>string.upper()</strong></p><blockquote>&gt;&gt;&gt; cadena = “Hola Mundo”</blockquote><blockquote>&gt;&gt;&gt; cadena.upper()</blockquote><p>“HOLA MUNDO”</p><blockquote>&gt;&gt;&gt; “hola amigo!”.upper()</blockquote><p>“HOLA AMIGO!”</p><p><strong>Lower</strong></p><blockquote>&gt;&gt;&gt; cadena = “Hola Mundo”</blockquote><blockquote>&gt;&gt;&gt; cadena.lower()</blockquote><p>“hola mundo”</p><blockquote>&gt;&gt;&gt; “HoLa AmIgO!”.lower()</blockquote><p>“hola amigo!”</p><p>Ya vimos cómo convertir a mayúsculas, pero también es útil convertir una cadena de caracteres a minúsculas, usando el método <strong>lower()</strong>.</p><p>Se escribe como: <strong>string.lower(</strong>)</p><p><strong>Capitalize</strong></p><p>Esta función integrada sirve para hacer que se devuelva la misma cadena pero con su primer carácter en mayúscula y el resto de caracteres hacerlos minúscula, usando el método <strong>capitalize()</strong>.</p><p>Se escribe como: <strong>string.capitalize()</strong></p><blockquote>&gt;&gt;&gt; cadena = “Hola Mundo”</blockquote><blockquote>&gt;&gt;&gt; cadena.capitalize()</blockquote><p>“Hola mundo”</p><blockquote>&gt;&gt;&gt; “HoLa AmIgO!”.capitalize()</blockquote><p>“Hola amigo!”</p><p><strong>Title</strong></p><p>Esta función integrada sirve para hacer que se devuelva la misma cadena pero con el primer carácter de cada palabra en mayúscula y el resto de caracteres hacerlos minúscula, usando el método <strong>title()</strong>.</p><p>Se escribe como: <strong>string.title()</strong></p><blockquote>&gt;&gt;&gt; cadena = “hOLA mUNDO”</blockquote><blockquote>&gt;&gt;&gt; cadena.title()</blockquote><p>“Hola Mundo”</p><blockquote>&gt;&gt;&gt; “HoLa AmIgO!”.title()</blockquote><p>“Hola Amigo!”</p><p><strong>Count</strong></p><p>Si necesitamos saber cuantas veces aparece una subcadena dentro de la misma cadena, usando el método <strong>count()</strong>.</p><p>Se escribe como:<strong> string.count()</strong></p><blockquote>&gt;&gt;&gt; cadena = “hOLa mUNDO esta cadena tiene muchas a”</blockquote><blockquote>&gt;&gt;&gt; cadena.count(“a”)</blockquote><p>6</p><blockquote>&gt;&gt;&gt; “HoLa amigo como estas amigo!”.count(“amigo”)</blockquote><p>2</p><p><strong>Find</strong></p><p>Si necesitamos averiguar el índice en el que aparece una subcadena dentro de la misma cadena, usamos el método <strong>find()</strong>.</p><p>Se escribe como: <strong>string.find()</strong>.</p><p>Si no encuentra la cadena devuelve un -1.</p><blockquote>&gt;&gt;&gt; cadena = “hOLa mUNDO esta cadena tiene muchas a”</blockquote><blockquote>&gt;&gt;&gt; cadena.find(“esta”)</blockquote><p>11</p><blockquote>&gt;&gt;&gt; “HoLa amigo como estas amigo!”.find(“chau”)</blockquote><p>-1</p><p><strong>Rfind</strong></p><p>Es exactamente igual al método find() los diferencia en que <strong>rfind() </strong>devuelve el índice, pero de la última ocurrencia de la subcadena, es decir, la última vez que aparece en la cadena.</p><p>Se escribe como:<strong> string.rfind()</strong>.</p><p>Si no encuentra la cadena devuelve un -1.</p><blockquote>&gt;&gt;&gt; “HoLa amigo como estas amigo!”.find(“amigo”)</blockquote><p>5</p><blockquote>&gt;&gt;&gt; “HoLa amigo como estas amigo!”.rfind(“amigo”)</blockquote><p>22</p><p><strong>Split</strong></p><p>Esta función integrada sirve para devolver una lista con la cadena de caracteres separada por cada índice de la lista.</p><p>Se escribe como: <strong>string.split(“cadena_a_separar”)</strong>.</p><p>Si no se indica alguna cadena para separar separa por “<strong>espacios</strong>”.</p><blockquote>&gt;&gt;&gt; cadena = “hOLA mUNDO”</blockquote><blockquote>&gt;&gt;&gt; cadena.split()</blockquote><p>[“hOLA”, “mUNDO”]</p><p><strong>Join</strong></p><p>Esta función integrada sirve para devolver una cadena separada a partir de una especie de separador.</p><p>Se escribe como: <strong>“separador”.join(“cadena”)</strong>.</p><p>Nota: Si no se especifica el separador nos devuelve un error.</p><blockquote>&gt;&gt;&gt; cadena = “Hola mundo”</blockquote><blockquote>&gt;&gt;&gt; “,”.join(cadena)</blockquote><p>“H,o,l,a, ,m,u,n,d,o”</p><blockquote>&gt;&gt;&gt; “ ”.join(cadena)</blockquote><p>“H o l a m u n d o”</p><p><strong>Replace</strong></p><p>Esta función integrada sirve para devolver una cadena reemplazando los sub caracteres indicados.</p><p>Se escribe como: <strong>cadena.replace(“caracter_a_remplazar”, “caracter_que_reemplaza”)</strong>.</p><p>También podemos indicar cuantas veces lo reemplazaremos utilizando un índice.</p><blockquote>&gt;&gt;&gt; cadena = “Hola mundo”</blockquote><blockquote>&gt;&gt;&gt; cadena.replace(“o”, “0”)</blockquote><p>“H0la mund0”</p><blockquote>&gt;&gt;&gt; “Hola mundo mundo mundo mundo mundo”.replace(‘ mundo’,’’,4)</blockquote><p>“Hola mundo”</p><p>Nota: En el último reemplazamos mundo 4 veces por un sólo carácter vacío</p><h4>Métodos para listas en Python</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*ZrxYUxuA8YIlR0NR" /></figure><p><strong>Insert</strong></p><p>Esta función integrada se usa para agregar un ítem a una lista, pero en un índice específico.</p><p>Se escribe como: <strong>lista.insert(posición, ítem)</strong>.</p><blockquote>&gt;&gt;&gt; lista = [1,2,3,4,5]</blockquote><blockquote>&gt;&gt;&gt; lista.insert(0, 0)</blockquote><p>[0,1,2,3,4,5]</p><blockquote>&gt;&gt;&gt; lista2 = [5,10,15,25]</blockquote><blockquote>&gt;&gt;&gt; lista2.insert(-1, 20) # Anteúltima posición</blockquote><p>[5,10,15,20,25]</p><blockquote>&gt;&gt;&gt; lista3 = [5,10,15,25]</blockquote><blockquote>&gt;&gt;&gt; n = len(lista3)</blockquote><blockquote>&gt;&gt;&gt; lista3.insert(n, 30) # Última posición</blockquote><p>[5,10,15,25,30]</p><p><strong>Reverse</strong></p><p>Esta función integrada sirve para dar vuelta una lista.</p><p>Se escribe como: <strong>lista.reverse()</strong></p><p><strong>Nota:</strong> Las cadenas no tienen la función reverse, pero se puede simular haciendo una conversión a lista y después usando el join</p><blockquote>&gt;&gt;&gt; lista = [1,2,3,4]</blockquote><blockquote>&gt;&gt;&gt; lista.reverse()</blockquote><p>[4,3,2,1]</p><p><strong>Sort</strong></p><p>Esta función integrada sirve para ordenar una lista automáticamente por valor, de menor a mayor.</p><p>Se escribe como: <strong>lista.sort()</strong>.</p><p>Si ponemos el argumento reverse=True la lista se ordenará de mayor a menor.</p><blockquote>&gt;&gt;&gt; lista = [5,-10,35,0,-65,100</blockquote><blockquote>&gt;&gt;&gt; lista.sort()</blockquote><p>[-65, -10, 0, 5, 35, 100]</p><blockquote>&gt;&gt;&gt; lista.sort(reverse=True)</blockquote><p>[100, 35, 5, 0, -10, -65]</p><h4>Métodos para Conjuntos en Python</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*HT-4IpgFUO9JvsJp" /></figure><p><strong>Copy</strong></p><p>Esta función integrada sirve para hacer que se devuelva una copia de un set.</p><p>Se escribe como: <strong>set.copy()</strong></p><blockquote>&gt;&gt;&gt; set1 = {1,2,3,4}</blockquote><blockquote>&gt;&gt;&gt; set2 = set1.copy()</blockquote><blockquote>&gt;&gt;&gt; print(set2)</blockquote><p>{1,2,3,4}</p><p><strong>Isdisjoint</strong></p><p>Esta función comprueba si el set es distinto a otro set, es decir, si no hay ningún ítem en común entre ellos.</p><p>Se escribe como: <strong>set1.isdisjoint(set2)</strong></p><p><strong>Nota: </strong>Devuelve False porque set1 y set2 comparten el 3</p><blockquote>&gt;&gt;&gt; set1 = {1,2,3}</blockquote><blockquote>&gt;&gt;&gt; set2 = {3,4,5}</blockquote><blockquote>&gt;&gt;&gt; set1.isdisjoint(set2)</blockquote><p>False</p><p><strong>Issubset</strong></p><p>Esta función comprueba si el set es subset de otro set, es decir, si todos sus ítems están en el otro conjunto.</p><p>Se escribe como: <strong>set1.issubset(set2)</strong></p><blockquote>&gt;&gt;&gt; set3 = {-1,99}</blockquote><blockquote>&gt;&gt;&gt; set4 = {1,2,3,4,5}</blockquote><blockquote>&gt;&gt;&gt; set3.issubset(set4)</blockquote><p>False</p><p><strong>Nota: </strong>Devuelve False porque set3 no está todo dentro de set4</p><p><strong>Issuperset</strong></p><p>Esta función es muy similar al issubset, la diferencia es que esta comprueba si el set es contenedor de otro set, es decir, si contiene todos los ítems de otro set.</p><p>Se escribe como: <strong>set1.issuperset(set2)</strong></p><blockquote>&gt;&gt;&gt; set5 = {1,2,3}</blockquote><blockquote>&gt;&gt;&gt; set6 = {1,2}</blockquote><blockquote>&gt;&gt;&gt; set5.issuperset(set6)</blockquote><p>True</p><p><strong>Unión</strong></p><blockquote>&gt;&gt;&gt; set1 = {1,2,3}</blockquote><blockquote>&gt;&gt;&gt; set2 = {3,4,5}</blockquote><blockquote>&gt;&gt;&gt; set1.union(set2)</blockquote><p>{1,2,3,4,5}</p><p>Esta función une un set con otro, y devuelve el resultado en un nuevo set.</p><p>Se escribe como: <strong>set1.union(set2)</strong></p><p><strong>Difference</strong></p><p>Esta función encuentra todos los elementos no comunes entre dos set, es decir, nos devuelve un set de ítems diferentes entre cada set.</p><p>Se escribe como: <strong>set1.difference(set2)</strong></p><blockquote>&gt;&gt;&gt; set1 = {1,2,3}</blockquote><blockquote>&gt;&gt;&gt; set2 = {3,4,5}</blockquote><blockquote>&gt;&gt;&gt; set1.difference(set2)</blockquote><p>{1,2}</p><p><strong>Nota: </strong>Acá devuelve 1 y 2 por qué le pregunta básicamente “que tengo de diferente al set2?”</p><p><strong>Difference_update</strong></p><p>Similar al difference, pero esta función nos guarda los ítems distintos en el set originales, es decir, le asigna como nuevo valor los ítems diferentes.</p><p>Se escribe como: <strong>set1.difference_update(set2)</strong></p><blockquote>&gt;&gt;&gt; set1 = {1,2,3}</blockquote><blockquote>&gt;&gt;&gt; set2 = {3,4,5}</blockquote><blockquote>&gt;&gt;&gt; set1.difference_update(set2)</blockquote><blockquote>&gt;&gt;&gt; print(set1)</blockquote><p>{1,2}</p><p><strong>Nota: </strong>Ahora set1 vale {1,2} porque es la diferencia que tenía con set2</p><p><strong>Intersection</strong></p><p>Esta función devuelve un set con todos los elementos comunes entre dos set, es decir, nos devuelve un set de ítems iguales entre cada set.</p><p>Se escribe como: <strong>set1.intersection(set2)</strong></p><blockquote>&gt;&gt;&gt; set1 = {1,2,3}</blockquote><blockquote>&gt;&gt;&gt; set2 = {3,4,5}</blockquote><blockquote>&gt;&gt;&gt; set1.intersection(set2)</blockquote><p>{3}</p><p><strong>Intersection_update</strong></p><p>Es exactamente igual al intersection, pero esta función actualiza el set original, es decir, le asigna como nuevo valor los ítems en común.</p><p>Se escribe como: <strong>set1.intersection_update(set2)</strong></p><p>&gt;&gt;&gt; set1 = {1,2,3}</p><p>&gt;&gt;&gt; set2 = {3,4,5}</p><p>&gt;&gt;&gt; <strong>set1.intersection_update</strong>(set2)</p><p>&gt;&gt;&gt; print(set1)</p><p>{3}</p><p><strong>Nota: </strong>Ahora set1 vale los ítems en común con set2</p><h4>Métodos para diccionaros en Python</h4><p><strong>Get</strong></p><p>La función get sirve para poder buscar un elemento a partir de su key, en el caso de no encontrar devuelve un valor por defecto que le indicamos nosotros. Se escribe como: dict.get(key, “valor por defecto”)</p><blockquote>&gt;&gt;&gt; colores = { “amarillo”:”yellow”, “azul”:”blue”, “verde”:”green” }</blockquote><blockquote>&gt;&gt;&gt; colores.get(“rojo”, “no hay clave rojo”)</blockquote><p>“no hay clave rojo”</p><blockquote>&gt;&gt;&gt; colores.get(“amarillo”, “no hay clave amarillo”)</blockquote><p>“yellow”</p><p><strong>Keys</strong></p><p>La función key sirve para poder traer todas las claves de un diccionario en el caso de desconocerlas.</p><p>Se escribe como: <strong>dict.keys()</strong></p><blockquote>&gt;&gt;&gt; colores = { “amarillo”:”yellow”, “azul”:”blue”, “verde”:”green” }</blockquote><blockquote>&gt;&gt;&gt; colores<strong>.keys()</strong></blockquote><p>dict_keys([‘amarillo’, ‘azul’, ‘verde’])</p><p><strong>Values</strong></p><p>La función values es similar a keys, pero esta sirve para poder traer todos los valores de un diccionario.</p><p>Se escribe como: <strong>dict.values()</strong></p><p>&gt;&gt;&gt; colores = { “amarillo”:”yellow”, “azul”:”blue”, “verde”:”green” }</p><p>&gt;&gt;&gt; colores.values()</p><p>dict_values([‘yellow’, ‘blue’, ‘green’])</p><p><strong>Items</strong></p><p>La función items es similar a keys y values, pero esta crea una lista con clave y valor de los ítems de un diccionario.</p><p>Se escribe como: <strong>dict.items()</strong></p><blockquote>&gt;&gt;&gt; colores = { “amarillo”:”yellow”, “azul”:”blue”, “verde”:”green” }</blockquote><blockquote>&gt;&gt;&gt; colores.items()</blockquote><p>dict_items([(‘amarillo’, ‘yellow’), (‘azul’, ‘blue’), (‘verde’, ‘green’)])</p><blockquote>&gt;&gt;&gt; for clave, valor in colores<strong>.items</strong>():</blockquote><p>print(clave, valor)</p><blockquote>&gt;&gt;&gt; amarillo yellow</blockquote><blockquote>&gt;&gt;&gt; azul blue</blockquote><blockquote>&gt;&gt;&gt; verde green</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*Anvg0sACU1ol0wgR" /><figcaption>¡gracias!</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e6703258773" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conjuntos y Diccionarios en Python]]></title>
            <link>https://estebanairaldo.medium.com/conjuntos-y-diccionarios-en-python-d96b15c3832f?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/d96b15c3832f</guid>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[back-end-developer]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Sun, 20 Nov 2022 22:36:26 GMT</pubDate>
            <atom:updated>2022-11-20T22:36:26.918Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*Er1lhqRREiSlMds7" /><figcaption>¡Comenzamos!</figcaption></figure><h4>Conjuntos en Python</h4><p>Un conjunto o <strong>set</strong> es una colección no ordenada de objetos únicos, es decir, no tiene elementos duplicados. Python provee este tipo de datos por defecto al igual que otras colecciones más convencionales como las <strong>listas, tuplas y diccionarios</strong>.</p><blockquote>Los conjuntos son ampliamente utilizados en lógica y matemática, y desde el lenguaje podemos sacar provecho de sus propiedades para crear código más eficiente y legible en menos tiempo.</blockquote><p>El conjunto se describe como una lista de ítems separados por coma y contenido entre dos llaves.</p><p><strong>Para crear un conjunto vacío debemos decirle set()</strong> de lo contrario si quisiéramos hacer como las listas y crearlo con <strong>{}</strong> Python crea un diccionario, el cual veremos más adelante</p><blockquote><strong>&gt;&gt;&gt; conjunto = {1, 2, 3, 4}</strong></blockquote><blockquote><strong>&gt;&gt;&gt; otro_conjunto = {“Hola”, “como”, “estas”, “?”}</strong></blockquote><blockquote><strong>&gt;&gt;&gt; conjunto_vacio = set()</strong></blockquote><p><strong>Heterogéneos</strong></p><p>En otros lenguajes, las colecciones tienen una restricción la cual solo permite tener un tipo de dato. Pero en Python, no tenemos esa restricción. Podemos tener un <strong>conjunto heterogéneo</strong> que contenga números, variables, strings, o tuplas.</p><p>Ejemplo:</p><blockquote>mi_var = ‘Una variable’</blockquote><blockquote>datos = {1, -5, 123.1,34.32, ‘Una cadena’, ‘Otra cadena’, mi_var}</blockquote><blockquote>print(type(datos))</blockquote><p>Sin embargo, un conjunto <strong>no puede incluir objetos mutables como listas,</strong> <strong>diccionarios, e incluso otros conjuntos o set.</strong></p><p>Ejemplo:</p><blockquote>&gt;&gt;&gt; s = {{1,2}, [1,2,3,4],2}</blockquote><p>Traceback (most recent call last):</p><p>File “&lt;stdin&gt;”, line 1, in &lt;module&gt;</p><p>TypeError: unhashable type: ‘set’</p><p>De la misma forma podemos obtener un conjunto a partir de cualquier objeto <strong>iterable</strong>:</p><blockquote>set1 = set([1, 2, 3, 4])</blockquote><blockquote>print(set1)</blockquote><blockquote>set2 = set(range(10))</blockquote><blockquote>&gt;&gt;&gt;print(set2)</blockquote><h4>set en python</h4><p>Un set puede ser <strong>convertido</strong> a una <strong>lista y viceversa</strong>. En este último caso, los elementos duplicados son unificados.</p><p>mi_lista=list({1, 2, 3, 4})</p><p>mi_set = set(mi_lista)</p><p>print(type(mi_set))</p><p>Como hablamos, <strong>las listas son mutables,</strong> sin embargo, el set también es mutable, pero no podemos hacer slicing, ni manejar un set por índice.</p><h4>Funciones de Conjuntos</h4><p>En los conjuntos, hay funciones que son muy interesantes e importantes, las funciones integradas.</p><p>Los conjuntos en Python tienen muchas funciones para utilizar, entre todas ellas vamos a nombrar las más importantes.</p><p><strong>ADD</strong></p><p>La primera función de los conjuntos de la que estaremos hablando es <strong>ADD</strong>. Esta función <strong>permite agregar un nuevo ítem al set</strong>. La misma se escribe mi_conjunto.add(ítem_a_agregar)</p><p><strong>mi_conjunto</strong> sería el set al que se le desee agregar el ítem, e <strong>ítem_a_agregar</strong> sería el ítem que deseemos agregar al set.</p><p>Ejemplo:</p><blockquote>&gt;&gt;&gt; numeros = {1,2,3,4}</blockquote><blockquote>&gt;&gt;&gt; numeros.add(5)</blockquote><p>{1,2,3,4,5}</p><p>No solo acaba ahí. <strong>En la función add también podemos realizar operaciones aritméticas en nuestro ítem</strong>.</p><p>Ejemplo:</p><blockquote>&gt;&gt;&gt; numeros = {1,2,3,4}</blockquote><blockquote>&gt;&gt;&gt; numeros.add(3*2)</blockquote><p>{1,2,3,4,6}</p><blockquote>&gt;&gt;&gt; numeros.add(3**2+1–12+5*3)</blockquote><blockquote>{1,2,3,4,6,13}</blockquote><p><strong>UPDATE</strong></p><p>Para añadir múltiples elementos a un set se usa la función <strong>update()</strong>, que puede tomar como argumento una lista, tupla, string, conjunto o cualquier objeto de tipo iterable.</p><p>La misma se escribe: mi_conjunto.update(ítem_a_agregar)</p><blockquote>numeros = {1,2,3,4}</blockquote><blockquote>numeros.update([5,6,7,8])</blockquote><blockquote>numeros.update(range(9,12))</blockquote><blockquote>print(numeros)</blockquote><p><strong>LEN</strong></p><p><strong>¿Se acuerdan cuando hablamos de len en listas?</strong> . En set, se puede usar exactamente la misma función para poder saber la longitud de un set, es decir, la cantidad de ítems dentro del mismo.</p><p><strong>DISCARD</strong></p><p>Si add te deja agregar un ítem al set, <strong>discard </strong>hace todo lo contrario, elimina el ítem del set, sin modificar el resto del set, si el elemento pasado como argumento a <strong>discard()</strong> no está dentro del conjunto es simplemente ignorado.</p><p>Se escribe como <strong>mi_conjunto.discard(item_a_descartar)</strong>.</p><blockquote>&gt;&gt;&gt; numeros = {1, 2, 3, 4}</blockquote><blockquote>&gt;&gt;&gt; numeros.discard(2)</blockquote><p>{1, 3, 4}</p><blockquote>&gt;&gt;&gt; datos = {1, -5, 123,34, ‘Una cadena’, ‘Otra cadena’}</blockquote><blockquote>&gt;&gt;&gt; datos.discard(‘Otra cadena’)</blockquote><p>{1, -5, 123,34, ‘Una cadena’}</p><p><strong>REMOVE</strong></p><p>La función <strong>remove </strong>funciona igual al discard, pero con una diferencia, en discard <strong>si el ítem a remover no existe</strong>, simplemente se ignora. En <strong>remove </strong>en este caso <strong>nos indica un error</strong>.</p><p>Se escribe como</p><p><strong>mi_conjunto.remove(item _a_ remove)</strong></p><blockquote>&gt;&gt;&gt; numeros = {1, 2, 3, 4}</blockquote><blockquote>&gt;&gt;&gt; numeros.remove(2)</blockquote><p>{1, 3, 4}</p><blockquote>&gt;&gt;&gt; numeros.remove(5)</blockquote><p>Traceback (most recent call last):</p><p>File “&lt;stdin&gt;”, line 1, in &lt;module&gt;</p><p>KeyError: 5</p><p><strong>IN</strong></p><p>Para determinar si un elemento pertenece a un set, utilizamos la palabra reservada in.</p><p>Se escribe como</p><p><strong>tem_a_validar in mi_conjunto</strong></p><blockquote>&gt;&gt;&gt; numeros = {1, 2, 3, 4}</blockquote><blockquote>&gt;&gt;&gt; 2 in numeros</blockquote><p>True</p><blockquote>&gt;&gt;&gt; 2 not in numeros</blockquote><p>False</p><blockquote>&gt;&gt;&gt; 4 in numeros</blockquote><p>True</p><p><strong>CLEAR</strong></p><p>Igual que en las listas, podremos borrar todos los valores de un set simplemente usando la función clear.</p><p>Se escribe como</p><p><strong>mi_conjunto.clear()</strong></p><p>¡No se puede asignar un set vacío por que lo toma como diccionario!</p><p><strong>POP</strong></p><p>La función pop retorna un elemento en forma aleatoria (no podría ser de otra manera, ya que los elementos no están ordenados). Así, el siguiente bucle imprime y remueve uno por uno los miembros de un conjunto.</p><blockquote>numeros = {1,2,3,4}</blockquote><blockquote>while numeros:</blockquote><blockquote>&gt;&gt;&gt;print(“Se está borrando: “, numeros.pop())</blockquote><p>Se está borrando: 1</p><p>Se está borrando: 2</p><p>Se está borrando: 3</p><p>Se está borrando: 4</p><h4>DICCIONARIO</h4><p>Un diccionario <strong>dict </strong>es una colección no ordenada de objetos. Es por eso que para identificar un valor cualquiera dentro de él, especificamos una <strong>clave </strong>(a diferencia de las listas y tuplas, cuyos elementos se identifican por su posición).</p><p>Las <strong>claves </strong>suelen ser <strong>int </strong>o <strong>string</strong>, aunque cualquier otro objeto inmutable puede actuar como una clave. Los valores, por el contrario, pueden ser de cualquier tipo, incluso otros diccionarios.</p><h4>Crear un diccionario en Python</h4><p>Para crear un diccionario se emplean llaves <strong>{}</strong>, y sus pares clave-valor se separan por comas. A su vez, intercalamos la clave del valor con dos puntos<strong> (:)</strong></p><p>Para crear un diccionario vacío se puede hacer diccionario = {}</p><p><strong>¿Cómo traer valor de Diccionarios?</strong></p><p>Para traer el valor de un diccionario se utiliza su clave</p><blockquote>&gt;&gt;&gt; colores = {“amarillo”: “yellow”, “azul”: “blue”, “rojo”: “red”}</blockquote><blockquote>&gt;&gt;&gt; colores[“amarillo”]</blockquote><p>“yellow”</p><blockquote>&gt;&gt;&gt; colores[“azul”]</blockquote><p>“blue”</p><blockquote>&gt;&gt;&gt; numeros = {10:”diez”, 20:”veinte”}</blockquote><blockquote>&gt;&gt;&gt; numeros[10]</blockquote><p>“diez”</p><p><strong>Mutabilidad</strong></p><p>Los diccionarios al igual que las listas son <strong>mutables</strong>, es decir, que podemos reasignar sus ítems haciendo referencia con el índice.</p><blockquote>&gt;&gt;&gt; colores = {“amarillo”: “yellow”, “azul”: “blue”, “rojo”: “red”}</blockquote><blockquote>&gt;&gt;&gt; colores[“ amarillo”] = “ white “</blockquote><blockquote>&gt;&gt;&gt; colores[“ amarillo”]</blockquote><p>“white”</p><p><strong>Asignación</strong></p><p>También permite operaciones en asignación</p><blockquote>&gt;&gt;&gt; edades = {“Juan”: 26, “Esteban”: 35, “Maria”: 29}</blockquote><blockquote>&gt;&gt;&gt; edades[“Juan”] += 5</blockquote><blockquote>&gt;&gt;&gt; edades[“Juan”]</blockquote><p>31</p><blockquote>&gt;&gt;&gt; edades[“Maria”] *= 2</blockquote><blockquote>&gt;&gt;&gt; edades[“Maria”]</blockquote><p>58</p><h4><strong>Funciones de diccionarios en Python</strong></h4><p>Al igual que en conjuntos, en los diccionarios encontramos funciones integradas.</p><p>Los diccionarios en Python tienen muchas funciones para utilizar. Si bien las desarrollaremos más adelante, a continuación vamos a nombrar las más importantes.</p><p><strong>Add</strong></p><p>No hay una función de add, pero para agregar una nueva clave-valor se puede realizar de la siguiente manera:</p><p>&gt;&gt;&gt; numeros = {‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4}</p><p>&gt;&gt;&gt; numeros[‘cinco’] = 5</p><p>{“uno”: 1, ”dos”: 2, “tres”: 3, “cuatro”: 4, “cinco”: 5}</p><p>En este caso, <strong>creamos una nueva clave que no existe “cinco” y asignamos el valor 5.</strong></p><p><strong>Update</strong></p><p>Este método actualiza un diccionario agregando los pares clave-valores.</p><blockquote>&gt;&gt;&gt; numeros = {‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4}</blockquote><blockquote>&gt;&gt;&gt; numeros.update({‘cinco’: 5, ‘seis’: 6})</blockquote><p>{‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4, ‘cinco’: 5, ‘seis’: 6}</p><blockquote>&gt;&gt;&gt; otro_dict = dict(siete=7)</blockquote><blockquote>&gt;&gt;&gt; numeros.update(otro_dict)</blockquote><p>{‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4, ‘cinco’: 5, ‘seis’: 6, ‘siete’: 7}</p><p><strong>Longitud del diccionario</strong></p><p>¿Se acuerdan cuando hablamos de len en listas? En dict, se puede usar exactamente la misma función para poder saber la longitud de un dict, es decir, <strong>la cantidad de ítems dentro del mismo</strong>.</p><blockquote>&gt;&gt;&gt; numeros = {‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4}</blockquote><blockquote>&gt;&gt;&gt; len(numeros)</blockquote><p>4</p><p><strong>Del</strong></p><p><strong>Del </strong>elimina el ítem del dict, sin modificar el resto del dict, si el elemento pasado como argumento a del() no está dentro del dict nos da error!</p><p>Se escribe como <strong>del mi_dict[“clave”]</strong>.</p><blockquote>&gt;&gt;&gt; numeros = {‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4}</blockquote><blockquote>&gt;&gt;&gt; del numeros[‘dos’]</blockquote><p>{‘uno’: 1, ‘tres’: 3, ‘cuatro’: 4}</p><p><strong>In</strong></p><p>Para determinar si un elemento <strong>pertenece </strong>a un dict, utilizamos la palabra reservada <strong>in</strong>.</p><p>Se escribe como <strong>clave_a_validar in mi_dict</strong></p><blockquote>&gt;&gt;&gt; numeros = {‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4}</blockquote><blockquote>&gt;&gt;&gt; ‘dos’in numeros</blockquote><p>True</p><blockquote>&gt;&gt;&gt; 2 not in numeros</blockquote><p>False</p><blockquote>&gt;&gt;&gt; 4 in numeros</blockquote><p>False</p><p><strong>Clear</strong></p><p>Igual que en las listas, podremos borrar todos los valores de un dict simplemente usando la función clear.</p><p>Se escribe como <strong>dict.clear()</strong>. Otra forma más cómoda es hacer <strong>mi_dict = {}</strong></p><blockquote>&gt;&gt;&gt; numeros = {‘uno’: 1, ‘dos’: 2, ‘tres’: 3, ‘cuatro’: 4}</blockquote><blockquote>&gt;&gt;&gt; numeros.clear()</blockquote><p>{}</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/0*zDJxNcAAJPoLUiv0" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d96b15c3832f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Controladores de Flujo II]]></title>
            <link>https://estebanairaldo.medium.com/controladores-de-flujo-ii-d440d4e084ed?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/d440d4e084ed</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[python-development]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Sun, 20 Nov 2022 15:57:04 GMT</pubDate>
            <atom:updated>2022-11-20T15:57:04.645Z</atom:updated>
            <content:encoded><![CDATA[<h4>Sentencias iterativas en Python</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/0*WqMkJhFZHsqoLb6P.gif" /></figure><p>Veremos cómo controlar el flujo con Python, pero antes de eso, ¿Qué es el flujo?. El flujo es una forma de entender la sucesión de las instrucciones de un programa, estas instrucciones se ejecutan una después de otras de forma ordenada y suelen tener el objetivo final de manipular información.</p><h4>Iterar</h4><p>En matemática, se refiere al proceso de iteración de una función, es decir, aplicando la función repetidamente, usando la salida de una iteración como la entrada a la siguiente.</p><p>En programación, Iteración es la <strong>repetición</strong> de un <strong>segmento de código</strong> dentro de un programa de computadora. Puede usarse tanto como un término genérico (como sinónimo de repetición) como para describir una forma específica de repetición.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/1*nv0-8-zfmmwtwwkKiKyLfA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/819/1*KiEHSafWEHuATdr183vkzw.png" /></figure><h4>Sentencia While en Python</h4><p>Vamos a comenzar con la sentencia iterativa más básica <strong>While</strong> (mientras).</p><p>Se basa en repetir un bloque de código a partir de evaluar una <strong>condición lógica</strong>, siempre que esta sea <strong>True</strong> (al igual que la sentencia <strong>if</strong>).</p><p><em>Como programadores debemos decidir el momento en que la condición cambie a </em><strong><em>False</em></strong><em> para hacer que el While finalice su ejecución y así salir de la iteración, de lo contrario estaríamos frente a un bucle </em><strong><em>infinito:</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*Cp3CRWNjjtndpLcS" /></figure><p>Flujo de ejecución de la sentencia while</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/379/1*TjrpVSyujDmw0DNKFTmWPQ.png" /></figure><p>Este tipo de flujo se llama bucle porque el tercer paso del bucle vuelve arriba.</p><p>👁‍🗨 Si la condición es falsa la primera vez que se pasa el bucle, las sentencias del interior del bucle no se ejecutan nunca.</p><p>Analicemos la siguiente sentencia:</p><blockquote><strong>num = 5</strong></blockquote><blockquote><strong>while num &gt; 0:</strong></blockquote><blockquote><strong>&gt;&gt;&gt;print(num)</strong></blockquote><blockquote><strong>&gt;&gt;num -= 1</strong></blockquote><blockquote><strong>&gt;&gt;&gt;print(‘Terminó el conteo!’)</strong></blockquote><p><strong>1. </strong>Declaramos una variable num y le asignamos el valor int 5.</p><p><strong>2. </strong>Usamos la sentencia while para indicar que mientras que num sea mayor a 0 entremos al bloque de código.</p><p><strong>3.</strong> Al evaluar num contra 0 nos indica que es True.</p><p><strong>4. </strong>Ingresamos al bloque de código, imprimimos num y le restamos 1 a num.</p><p><strong>5. </strong>Volvemos a repetir desde el paso 2 hasta que num deje de ser mayor a 0.</p><p><strong>6. </strong>Cuando la operación relacional de False saldremos del bucle.</p><p><strong>7. </strong>Imprimimos por pantalla Terminó el conteo!.</p><p><strong>8. </strong>Termina nuestro programa.</p><p>Otro Ejemplo:</p><blockquote>n = 0</blockquote><blockquote>while n &lt;= 5:</blockquote><blockquote>&gt;&gt;&gt;n += 1</blockquote><blockquote>&gt;&gt;&gt;print(‘n vale ‘, n)</blockquote><p><strong>¿Y un bucle infinito?</strong></p><blockquote><strong>while </strong>True:</blockquote><blockquote>&gt;&gt;&gt;print(“Esto es un bucle infinito!!!!!”)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*pBoMyREML54rg9rOORA_CA.png" /></figure><h4>Sentencia while-else en Python</h4><p>Este else sirve para ejecutar un bloque de código cuando el bucle while tenga una condición False o haya terminado y no haya sido forzado a salir mediante un break.</p><blockquote>chance = 1</blockquote><blockquote>while chance &lt;= 3:</blockquote><blockquote>&gt;&gt;&gt;txt = input(“Escribe SI: “)</blockquote><blockquote>&gt;&gt;&gt;if txt == “SI”:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;print(“Ok, lo conseguiste en el intento”, chance)</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;break</blockquote><blockquote>&gt;&gt;&gt;chance += 1</blockquote><blockquote>else:</blockquote><blockquote>&gt;&gt;&gt;print(“Has agotado tus tres intentos”)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*wvBE-z3sOeeNvv7SNFWGTA.png" /></figure><h4>Instrucciones a bucles en Python</h4><p>Usar bucles en Python nos permite automatizar y repetir tareas de manera eficiente. Sin embargo, a veces, es posible que un factor externo influya en la forma en que se ejecuta su programa.</p><p>Cuando esto sucede, es posible que prefiramos que nuestro programa cierre un bucle por completo, omita parte de un bucle antes de continuar o ignore ese factor externo.</p><p>Para hacer estas acciones Python nos brinda las instrucciones <strong>break</strong>, <strong>continue </strong>y <strong>pass</strong>.</p><h4>Instrucción break en Python</h4><p>En Python, la instrucción break le proporciona la oportunidad de cerrar un bucle cuando se activa una condición externa. Debe poner la instrucción break dentro del bloque de código bajo la instrucción de su bucle, generalmente después de una sentencia if condicional.</p><p>Ejemplo, salimos del bucle cuando <strong>i </strong>es igual a <strong>3</strong></p><blockquote>i = 1</blockquote><blockquote>while i &lt; 6:</blockquote><blockquote>&gt;&gt;&gt;print(i)</blockquote><blockquote>&gt;&gt;&gt;if i == 3:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;break</blockquote><blockquote>i += 1</blockquote><h4>Instrucción continue en Python</h4><p>La instrucción continue da la opción de omitir la parte de un bucle en la que se activa una condición externa, pero continuar para completar el resto del bucle. Es decir, la iteración actual del bucle se interrumpirá, pero el programa volverá a la parte superior del bucle.</p><p>Debe poner la instrucción continue dentro del bloque de código bajo la instrucción de su bucle, generalmente después de una sentencia if condicional.</p><p>Veamos un ejemplo:</p><blockquote>i = 0</blockquote><blockquote>while i &lt; 6:</blockquote><blockquote>&gt;&gt;&gt;i += 1</blockquote><blockquote>&gt;&gt;&gt;if i == 3:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;continue</blockquote><blockquote>print(i)</blockquote><h4>Instrucción pass en Python</h4><p>Cuando se activa una condición externa, la instrucción pass permite manejar la condición sin que el bucle se vea afectado de ninguna manera; todo el código continuará leyéndose a menos que se produzca la instrucción break u otra instrucción.</p><p>Debes poner la instrucción pass dentro del bloque de código bajo la instrucción de su bucle, generalmente después de una sentencia if condicional.</p><p>#Ejemplo 1</p><blockquote>n = 0</blockquote><blockquote>while n &lt; 10:</blockquote><blockquote>&gt;&gt;&gt;n += 1</blockquote><blockquote>&gt;&gt;&gt;if n == 2:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;pass</blockquote><blockquote>print(‘n vale’ , n)</blockquote><h4>Sentencia for en Python</h4><p>Ahora seguiremos con la sentencia iterativa que podríamos decir es la más usada For (para).</p><p>Se utiliza para recorrer los elementos de un objeto iterable (lista, tupla…) y ejecutar un bloque de código, o sea, tiene un número predeterminado de veces que itera.</p><p>En cada paso de la iteración se tiene en cuenta a un único elemento del objeto iterable, sobre el cual se pueden aplicar una serie de operaciones.</p><blockquote>lista = [1,2,3,4,5]</blockquote><blockquote>for valor in lista:</blockquote><blockquote>print(‘Soy un item de la lista y valgo’, valor)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/868/1*QrX4kkd4O6z-5NUvvov5pQ.png" /></figure><p>Ejemplo</p><p>lista = [0,1,2,3,4,5,6,7,8,9,10]</p><p>for num in lista:</p><p>print(‘Soy un valor de la lista y valgo’, num)</p><p>num *= 5</p><p>print(‘Soy un valor de la lista y ahora valgo’, num)</p><p>Si quisiéramos recorrer un string:</p><blockquote>texto = ‘Hola Mundo, estoy usando for en Python’</blockquote><blockquote>for letra in texto:</blockquote><blockquote>&gt;&gt;&gt;print(letra)</blockquote><blockquote>&gt;&gt;&gt;texto2 = ‘’</blockquote><blockquote>for letra in texto:</blockquote><blockquote>&gt;&gt;&gt;texto2 = letra * 2</blockquote><blockquote>print(texto2)</blockquote><h4>Sentencia range en Python</h4><p>Como vimos, el for en python necesita una colección de datos para poder utilizarlo, en otros lenguajes necesitamos solamente un número para indicar las iteraciones a cumplir.</p><p>Para simular estos casos Python nos provee de una función denominada range() (rango) el cual representa una colección de números inmutables.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*IyAC51PNU7qaKHeV5bVa-Q.png" /></figure><p>Ventajas de range en Python</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*x0egeJNMc2fwyP_HqAg63A.png" /></figure><h4>for-else en Python</h4><p>Igual que en la sentencia while podemos usar un else al final de la iteración.</p><blockquote><strong>for numero in range(10):</strong></blockquote><blockquote><strong>&gt;&gt;&gt;print(‘Numero vale’,numero)</strong></blockquote><blockquote><strong>else:</strong></blockquote><blockquote><strong>&gt;&gt;&gt;print(“Se terminó de iterar y numero vale: “, numero)</strong></blockquote><h4><strong>For-break-continue-pass</strong></h4><p>Igual que en la sentencia while podemos usar también las instrucciones break continue y pass.</p><blockquote>for numero in range(10):</blockquote><blockquote>&gt;&gt;&gt;if numero == 2:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;continue</blockquote><blockquote>&gt;&gt;&gt;elif numero == 8:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;break</blockquote><blockquote>&gt;&gt;&gt;else:</blockquote><blockquote>&gt;&gt;&gt;&gt;&gt;&gt;print(“Se terminó de iterar y numero vale: “, numero)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/280/0*9ltZYo7aFn4xRjZn" /><figcaption>gracias!</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d440d4e084ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Controladores de Flujo]]></title>
            <link>https://estebanairaldo.medium.com/controladores-de-flujo-448ca5eff92a?source=rss-74b69ace6992------2</link>
            <guid isPermaLink="false">https://medium.com/p/448ca5eff92a</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[Tato Airaldo]]></dc:creator>
            <pubDate>Sun, 20 Nov 2022 14:10:52 GMT</pubDate>
            <atom:updated>2022-11-20T14:10:52.701Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*narQxExkuS39Cpk3" /></figure><p><strong>¿Qué es el flujo? </strong>Veremos cómo controlar el flujo con Python, pero antes de eso, ¿Qué es el flujo? El flujo es una forma de entender la sucesión de las instrucciones de un programa, estas instrucciones se ejecutan una después de otras de forma ordenada y suelen tener el objetivo final de manipular información.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/0*YYF8eWvRBjn-Bpl4" /></figure><p>Sin embargo, para manipular datos no es suficiente con realizar cálculos o resolver expresiones, <strong>necesitamos que de alguna forma nuestro programa pueda elegir, que sepa cómo actuar en función de determinadas situaciones, o incluso repetir una tarea si es necesario</strong>.</p><p>Para estas situaciones, existen las sentencias de control de flujo.</p><h4>Sentencias de Control de flujos en Python</h4><p>Se dividen en dos tipos, las de control condicional y las de control iterativo. (A las siguientes imágenes se le denomina diagrama de flujo)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*S1mR3YkVzWGCKRBj" /></figure><p>Diagramas de flujo</p><p>Expresan nuestros algoritmos en forma de diagrama mediante una representación gráfica basada en figuras geométricas que varían según la estructura de código.</p><h4>Condicionales en Python</h4><p>En la vida diaria, actuamos de acuerdo a la evaluación de condiciones, de manera mucho más frecuente de lo que en realidad creemos: si el semáforo está en verde, cruzar la calle. Si no, esperar a que el semáforo se ponga en verde.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*wuQ2Eg0OoCDSKyaX" /></figure><p>A veces, también evaluamos más de una condición para ejecutar una determinada acción: si llega la factura de la luz y tengo dinero, pagar la factura.</p><p>Las sentencias de control condicionales, son aquellas que nos permiten evaluar si una o más condiciones se cumplen, para decir qué acción vamos a ejecutar. La evaluación de condiciones, solo puede arrojar 1 de 2 resultados: <strong>True</strong> o <strong>False</strong> (verdadero o falso).</p><p>Para describir la evaluación a realizar sobre una condición, se utilizan los operadores relacionales (==, !=, &gt;, &lt;, etc.). Y, para evaluar más de una condición simultáneamente se utilizan los operadores lógicos (not, and, or).</p><p>Las sentencias de control de flujo condicionales se definen mediante el uso de tres palabras claves reservadas:</p><ul><li>if (si)</li><li>elif (si no, si)</li><li>else (si no)</li></ul><h4>Sentencia if en Python</h4><p>Dentro de las sentencias condicionales el if (si) posiblemente sea la más famosa y utilizada en la programación, esto debido a que nos permite controlar el flujo del programa y dividir la ejecución en diferentes caminos.</p><p>Al utilizar esta palabra reservada<strong> if </strong>le estamos indicando a Python que queremos ejecutar una porción de código, o bloque de código, solo si se se cumple una determinada condición, es decir, si el resultado es<strong> True</strong>.</p><p>Primero definimos una variable <strong>edad</strong> y le asignamos un valor entero <strong>30</strong>. Después, a través del condicional, le decimos que queremos imprimir “<strong>Es un</strong> <strong>adulto</strong>” en pantalla, solo si se cumple la condición de que <strong>edad</strong> sea mayor o igual a 18.</p><p>Veamos el siguiente ejemplo:</p><blockquote><strong>edad = 30</strong></blockquote><blockquote><strong>if edad &gt;= 18:</strong></blockquote><blockquote><strong>print(‘Es un adulto’)</strong></blockquote><blockquote><strong>if True:</strong></blockquote><blockquote><strong>print</strong>(‘Se cumple la condición’)</blockquote><p><strong>Identación en Python</strong></p><p>Python se basa en la sangría (espacio en blanco al comienzo de una línea) para definir el alcance en el código. Otros lenguajes de programación a menudo usan corchetes para este propósito.</p><p>El siguiente código nos arrojará un error ya que el print no está identado:</p><blockquote><strong>a = 25</strong></blockquote><blockquote><strong>b = 50</strong></blockquote><blockquote><strong>if b &gt; a:</strong></blockquote><blockquote><strong>print</strong>(“b es más grande que a”)</blockquote><p>Puedes probarlo para verificarlo.</p><p>Ejemplo con OR:</p><blockquote><strong>a = 195</strong></blockquote><blockquote><strong>b = 50</strong></blockquote><blockquote><strong>c = 500</strong></blockquote><blockquote><strong>if a &gt; b or a &gt; c:</strong></blockquote><blockquote><strong>print</strong>(“Al menos una de las condiciones es verdadera”)</blockquote><p>Ejemplo con NOT:</p><blockquote><strong>x = 10</strong></blockquote><blockquote><strong>if not x &gt; 15:</strong></blockquote><blockquote><strong>print(“False”)</strong></blockquote><p><strong>If en una sola linea — Ejemplo 1:</strong></p><blockquote>a = 150</blockquote><blockquote>b = 35</blockquote><blockquote>if a &gt; b: print(“a es mayor que b”)</blockquote><p><strong>If en una sola linea — Ejemplo 2:</strong></p><blockquote>a = 5</blockquote><blockquote>b = 150</blockquote><blockquote>print(“A”) if a &gt; b else print(“B”)</blockquote><p><strong>If en una sola linea — Ejemplo 3:</strong></p><blockquote>a = 150</blockquote><blockquote>b = 330</blockquote><blockquote>print(“A”) if a &gt; b else print(“=”) if a == b else print(“B”)</blockquote><h4>Sentencia else en Python</h4><p>Veamos el siguiente ejemplo:</p><blockquote><strong>numero = 24</strong></blockquote><blockquote><strong>if numero &gt; 36:</strong></blockquote><blockquote><strong>&gt;&gt;&gt;print(“El número es más grande”)</strong></blockquote><blockquote><strong>else:</strong></blockquote><blockquote><strong>&gt;&gt;&gt;print(“El número es más chico”)</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*7i2OiVyeMaNV9Eiwag1BRw.png" /></figure><p>Veamos un ejemplo de cómo podemos trabajar con múltiples ifs anidados:</p><p><strong>Ejemplo 1</strong>:</p><blockquote>x = 25</blockquote><blockquote>if x &gt; 10:</blockquote><blockquote>&gt;&gt;&gt;print(“por encima de diez,”)</blockquote><blockquote>if x &gt; 20:</blockquote><blockquote>&gt;&gt;&gt;print(“y también por encima de 20!”)</blockquote><blockquote>else:</blockquote><blockquote>&gt;&gt;&gt;print(“pero no por encima de 20”)</blockquote><p><strong>Ejemplo 2:</strong></p><blockquote>x = 15</blockquote><blockquote>if x &gt; 10:</blockquote><blockquote>&gt;&gt;&gt;print(“por encima de diez,”)</blockquote><blockquote>if x &gt; 20:</blockquote><blockquote>&gt;&gt;&gt;print(“y también por encima de 20!”)</blockquote><blockquote>else:</blockquote><blockquote>&gt;&gt;&gt;print(“pero no por encima de 20”)</blockquote><h4>Sentencia elif en Python</h4><p>La última sentencia condicional que podemos encontrar es el <strong>elif </strong>(si no, si), también podríamos decir que es un hermano de <strong>if, </strong>ya que se utiliza en continuación al <strong>if</strong> para poder encadenar muchísimas más comprobaciones.</p><p>Al utilizar esta palabra reservada elif le estamos indicando a Python que queremos ejecutar una porción de código, o bloque de código, solo si la condición anterior no se cumple, es decir, si el resultado del <strong>if </strong>o algún <strong>elif</strong> fue <strong>False</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/491/1*b6r1wmGP9Ir3_Ua3UWNKxw.png" /></figure><p>Como podemos observar, la primera condición valida si A es igual a 4, como esto no es verdadero, se evalúa la siguiente condición, si A es igual a 5, si no A es igual a 6? .</p><p>Finalmente, se define un bloque else por default que se ejecutará cuando ninguna de las condiciones anteriores sea verdadera.</p><blockquote>comando = “SALIR”</blockquote><blockquote>if comando == “ENTRAR”:</blockquote><blockquote>&gt;&gt;&gt;print(“Bienvenido al sistema.”)</blockquote><blockquote>elif comando == “SALUDO”:</blockquote><blockquote>&gt;&gt;&gt;print(“Hola! ¿Cómo estás?”)</blockquote><blockquote>elif comando == “SALIR”:</blockquote><blockquote>&gt;&gt;&gt;print(“Saliendo del sistema.”)</blockquote><blockquote>else:</blockquote><blockquote>&gt;&gt;&gt;print(“No se reconoce el comando.”)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*ONLEdt_Hlt-jjer7WMxo9g.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=448ca5eff92a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>