{"id":353,"date":"2024-10-22T18:31:37","date_gmt":"2024-10-22T18:31:37","guid":{"rendered":"https:\/\/equipomedios.com\/blog\/?p=353"},"modified":"2024-10-18T18:33:32","modified_gmt":"2024-10-18T18:33:32","slug":"tipos-de-datos-tipo-listas-python","status":"publish","type":"post","link":"https:\/\/equipomedios.com\/blog\/tipos-de-datos-tipo-listas-python\/","title":{"rendered":"Tipos de Datos | Tipo Listas | Python"},"content":{"rendered":"

Tipo listas<\/h1>\n

En Python tiene varios tipos de datos\u00a0compuestos<\/em>\u00a0y dentro de las secuencias, est\u00e1n los tipos de\u00a0cadenas de caracteres<\/span>. Otro tipo muy importante de secuencia son las\u00a0listas<\/em>.<\/p>\n

Entre las\u00a0secuencias<\/em>, el m\u00e1s vers\u00e1til, es la\u00a0lista<\/em>, para definir una, usted debe escribir es entre corchetes, separando sus elementos con comas cada uno.<\/p>\n

La lista en Python son variables que almacenan\u00a0arrays<\/span><\/code>, internamente cada posici\u00f3n puede ser un tipo de datos distinto.<\/p>\n

\n
\n
>>> <\/span>factura<\/span> =<\/span> [<\/span>'pan'<\/span>,<\/span> 'huevos'<\/span>,<\/span> 100<\/span>,<\/span> 1234<\/span>]<\/span>\r\n>>> <\/span>factura<\/span>\r\n['pan', 'huevos', 100, 1234]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Las listas en Python son:<\/p>\n
    \n
  • heterog\u00e9neas<\/strong>: pueden estar conformadas por elementos de distintos tipo, incluidos otras listas.<\/li>\n
  • mutables<\/strong>: sus elementos pueden modificarse.<\/li>\n<\/ul>\n
    Una lista en Python es una estructura de datos formada por una secuencia ordenada de objetos.<\/p>\n
    Los elementos de una lista pueden accederse mediante su \u00edndice, siendo 0 el \u00edndice del primer elemento.<\/p>\n
    \n
    \n
    >>> <\/span>factura<\/span>[<\/span>0<\/span>]<\/span>\r\n'pan'<\/span>\r\n>>> <\/span>factura<\/span>[<\/span>3<\/span>]<\/span>\r\n1234<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    La funci\u00f3n\u00a0len()<\/span>\u00a0devuelve la longitud de la lista (su cantidad de elementos).<\/p>\n
    \n
    \n
    >>> <\/span>len<\/span>(<\/span>factura<\/span>)<\/span>\r\n4<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Los \u00edndices de una lista inicia entonces de\u00a00<\/strong>\u00a0hasta el tama\u00f1o de la lista menos uno (len(factura)<\/span>\u00a0-<\/span>\u00a01<\/span><\/code>):<\/p>\n
    \n
    \n
    >>> <\/span>len<\/span>(<\/span>factura<\/span>)<\/span> -<\/span> 1<\/span>\r\n3<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Pueden usarse tambi\u00e9n \u00edndices negativos, siendo\u00a0-1<\/strong>\u00a0el \u00edndice del \u00faltimo elemento.<\/p>\n
    \n
    \n
    >>> <\/span>factura<\/span>[<\/span>-<\/span>1<\/span>]<\/span>\r\n1234<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Los \u00edndices negativos van entonces de\u00a0-1<\/strong>\u00a0(\u00faltimo elemento) a\u00a0-len(factura)<\/span><\/code>\u00a0(primer elemento).<\/p>\n
    \n
    \n
    >>> <\/span>factura<\/span>[<\/span>-<\/span>len<\/span>(<\/span>factura<\/span>)]<\/span>\r\n'pan'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    A trav\u00e9s de los \u00edndices, pueden cambiarse los elementos de una lista en el lugar.<\/p>\n
    \n
    \n
    >>> <\/span>factura<\/span>[<\/span>1<\/span>]<\/span> =<\/span> \"carne\"<\/span>\r\n>>> <\/span>factura<\/span>\r\n['pan', 'carne', 100, 1234<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    De esta forma se cambia el valor inicial de un elemento de la lista lo cual hacen una la lista\u00a0mutable<\/em><\/p>\n
    <\/span><\/p>\n
    M\u00e9todos<\/h2>\n
    El el objeto de tipo\u00a0lista<\/em>\u00a0integra una serie de m\u00e9todos integrados a continuaci\u00f3n:<\/p>\n
    <\/span><\/p>\n
    append()<\/h3>\n
    Este m\u00e9todo agrega un elemento al final de una lista.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.5, 3.6, 4, 5]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>append<\/span>(<\/span>6<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.5, 3.6, 4, 5, 6]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    count()<\/h3>\n
    Este m\u00e9todo recibe un elemento como argumento, y cuenta la cantidad de veces que aparece en la lista.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> \"6 ->\"<\/span>,<\/span> versiones_plone<\/span>.<\/span>count<\/span>(<\/span>6<\/span>)<\/span>\r\n6 -> 1<\/span>\r\n>>> <\/span>print<\/span> \"5 ->\"<\/span>,<\/span> versiones_plone<\/span>.<\/span>count<\/span>(<\/span>5<\/span>)<\/span>\r\n5 -> 1<\/span>\r\n>>> <\/span>print<\/span> \"2.5 ->\"<\/span>,<\/span> versiones_plone<\/span>.<\/span>count<\/span>(<\/span>2.5<\/span>)<\/span>\r\n2.5 -> 1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    extend()<\/h3>\n
    Este m\u00e9todo extiende una lista agregando un iterable al final.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>extend<\/span>([<\/span>4<\/span>])<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>extend<\/span>(<\/span>range<\/span>(<\/span>5<\/span>,<\/span>7<\/span>))<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4, 5, 6]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    index()<\/h3>\n
    Este m\u00e9todo recibe un elemento como argumento, y devuelve el \u00edndice de su primera aparici\u00f3n en la lista.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>.<\/span>index<\/span>(<\/span>4<\/span>)<\/span>\r\n3<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    El m\u00e9todo admite como argumento adicional un \u00edndice inicial a partir de donde comenzar la b\u00fasqueda, opcionalmente tambi\u00e9n el \u00edndice final.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>]<\/span>\r\n>>> <\/span>versiones_plone<\/span>[<\/span>2<\/span>]<\/span>\r\n3.6<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>.<\/span>index<\/span>(<\/span>4<\/span>,<\/span> 2<\/span>)<\/span>\r\n3<\/span>\r\n>>> <\/span>versiones_plone<\/span>[<\/span>3<\/span>]<\/span>\r\n4<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>.<\/span>index<\/span>(<\/span>4<\/span>,<\/span> 5<\/span>)<\/span>\r\n6<\/span>\r\n>>> <\/span>versiones_plone<\/span>[<\/span>6<\/span>]<\/span>\r\n4<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    El m\u00e9todo devuelve un excepci\u00f3n\u00a0ValueError<\/span>\u00a0si el elemento no se encuentra en la lista, o en el entorno definido.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>.<\/span>index<\/span>(<\/span>9<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: 9 is not in list<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    insert()<\/h3>\n
    Este m\u00e9todo inserta el elemento x en la lista, en el \u00edndice i.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4, 5, 6]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>insert<\/span>(<\/span>2<\/span>,<\/span> 3.7<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.7, 3.6, 4, 5, 6]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    pop()<\/h3>\n
    Este m\u00e9todo devuelve el \u00faltimo elemento de la lista, y lo borra de la misma.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>.<\/span>pop<\/span>()<\/span>\r\n6<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4, 5]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Opcionalmente puede recibir un argumento num\u00e9rico, que funciona como \u00edndice del elemento (por defecto, -1)<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>.<\/span>pop<\/span>(<\/span>2<\/span>)<\/span>\r\n3.6<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 4, 5, 6]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    remove()<\/h3>\n
    Este m\u00e9todo recibe como argumento un elemento, y borra su primera aparici\u00f3n en la lista.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4, 5, 6]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>remove<\/span>(<\/span>2.5<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 3.6, 4, 5, 6]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    El m\u00e9todo devuelve un excepci\u00f3n\u00a0ValueError<\/span>\u00a0si el elemento no se encuentra en la lista.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4, 5, 6]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>remove<\/span>(<\/span>7<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nValueError<\/span>: list.remove(x): x not in list<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    reverse()<\/h3>\n
    Este m\u00e9todo invierte el orden de los elementos de una lista.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>2.1<\/span>,<\/span> 2.5<\/span>,<\/span> 3.6<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4, 5, 6]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>reverse<\/span>()<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[6, 5, 4, 3.6, 2.5, 2.1]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
    <\/span><\/p>\n
    sort()<\/h3>\n
    Este m\u00e9todo ordena los elementos de una lista.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span> =<\/span> [<\/span>4<\/span>,<\/span> 2.5<\/span>,<\/span> 5<\/span>,<\/span> 3.6<\/span>,<\/span> 2.1<\/span>,<\/span> 6<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[4, 2.5, 5, 3.6, 2.1, 6]<\/span>\r\n>>> <\/span>versiones_plone<\/span>.<\/span>sort<\/span>()<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[2.1, 2.5, 3.6, 4, 5, 6]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    El m\u00e9todo\u00a0sort()<\/span><\/code>\u00a0admite la opci\u00f3n\u00a0reverse<\/span><\/code>, por defecto, con valor\u00a0False<\/span><\/code>. De tener valor\u00a0True<\/span><\/code>, el ordenamiento se hace en sentido inverso.<\/p>\n
    \n
    \n
    >>> <\/span>versiones_plone<\/span>.<\/span>sort<\/span>(<\/span>reverse<\/span>=<\/span>True<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones_plone<\/span>\r\n[6, 5, 4, 3.6, 2.5, 2.1]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    Convertir a listas<\/h2>\n
    Para convertir a\u00a0tipos listas<\/em>\u00a0debe usar la funci\u00f3n\u00a0list()<\/span>\u00a0la cual\u00a0esta integrada<\/span>\u00a0en el interprete Python.<\/p>\n
    \n
    Truco<\/p>\n
    Para m\u00e1s informaci\u00f3n consulte las funciones integradas para\u00a0operaciones de secuencias<\/span>.<\/p>\n<\/div>\n
    \n<\/div>\n
    <\/span><\/p>\n
    Ejemplos<\/h2>\n
    A continuaci\u00f3n, se presentan algunos ejemplos de su uso:<\/p>\n
    Ejemplo de definir una colecci\u00f3n ordenada\/arreglos o vectores<\/strong><\/p>\n
    \n
    \n
    # Definir una colecci\u00f3n ordenada \/ arreglos o vectores<\/span>\r\nlista<\/span> =<\/span> [<\/span>2<\/span>,<\/span> \"CMS\"<\/span>,<\/span> True<\/span>,<\/span> [<\/span>\"Plone\"<\/span>,<\/span> 10<\/span>]]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplo de acceder a un elemento especifico de una lista<\/strong><\/p>\n
    \n
    \n
    # Acceder a un elemento especifico<\/span>\r\nl2<\/span> =<\/span> lista<\/span>[<\/span>1<\/span>]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplo de acceder a un elemento en una lista anidada<\/strong><\/p>\n
    \n
    \n
    # Acceder a un elemento en una lista anidada<\/span>\r\nl3<\/span> =<\/span> lista<\/span>[<\/span>3<\/span>][<\/span>0<\/span>]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplo de definir nuevo valor de un elemento de lista<\/strong><\/p>\n
    \n
    \n
    # Definir nuevo valor de un elemento de lista<\/span>\r\nlista<\/span>[<\/span>1<\/span>]<\/span> =<\/span> 4<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplo de obtener un rango de elemento especifico<\/strong><\/p>\n
    \n
    \n
    # Obtener un rango de elemento especifico<\/span>\r\nl3<\/span> =<\/span> lista<\/span>[<\/span>0<\/span>:<\/span>3<\/span>]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplos de obtener un rango con saltos de elementos espec\u00edficos<\/strong><\/p>\n
    \n
    \n
    # Obtener un rango con saltos de elementos espec\u00edficos<\/span>\r\nl4<\/span> =<\/span> lista<\/span>[<\/span>0<\/span>:<\/span>3<\/span>:<\/span>2<\/span>]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplo de iterar sobre cualquier secuencia<\/strong><\/p>\n
    Usted puede iterar sobre cualquier secuencia (cadenas de caracteres, lista, claves en un diccionario, lineas en un archivo, \u2026):<\/p>\n
    Ejemplo de iterar sobre una cadenas de caracteres<\/em><\/p>\n
    \n
    \n
    >>> <\/span>vocales<\/span> =<\/span> 'aeiou'<\/span>\r\n>>> <\/span>for<\/span> letra<\/span> in<\/span> 'hermosa'<\/span>:<\/span>\r\n... <\/span>    if<\/span> letra<\/span> in<\/span> vocales<\/span>:<\/span>\r\n... <\/span>        print<\/span> letra<\/span>,<\/span>\r\ne o a<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplo de iterar sobre una lista<\/em><\/p>\n
    Para separar una cadena en frases, los valores pueden separarse con la funci\u00f3n integrada\u00a0split()<\/span><\/code>.<\/p>\n
    \n
    \n
    >>> <\/span>mensaje<\/span> =<\/span> \"Hola, como estas tu?\"<\/span>\r\n>>> <\/span>mensaje<\/span>.<\/span>split<\/span>()<\/span> # retorna una lista<\/span>\r\n['Hola,', 'como', 'estas', 'tu?']<\/span>\r\n>>> <\/span>for<\/span> palabra<\/span> in<\/span> mensaje<\/span>.<\/span>split<\/span>():<\/span>\r\n... <\/span>    print<\/span> palabra<\/span>\r\n...<\/span>\r\nHola,<\/span>\r\ncomo<\/span>\r\nestas<\/span>\r\ntu?<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
    Ejemplo de iterar sobre dos o m\u00e1s secuencias<\/em><\/p>\n
    Para iterar sobre dos o m\u00e1s secuencias al mismo tiempo, los valores pueden emparejarse con la funci\u00f3n integrada\u00a0zip()<\/span>.<\/p>\n
    \n
    \n
    >>> <\/span>preguntas<\/span> =<\/span> [<\/span>'nombre'<\/span>,<\/span> 'objetivo'<\/span>,<\/span> 'sistema operativo'<\/span>]<\/span>\r\n>>> <\/span>respuestas<\/span> =<\/span> [<\/span>'Leonardo'<\/span>,<\/span> 'aprender Python y Plone'<\/span>,<\/span> 'Linux'<\/span>]<\/span>\r\n>>> <\/span>for<\/span> pregunta<\/span>,<\/span> respuesta<\/span> in<\/span> zip<\/span>(<\/span>preguntas<\/span>,<\/span> respuestas<\/span>):<\/span>\r\n... <\/span>    print<\/span> '\u00bfCual es tu <\/span>{0}<\/span>?, la respuesta es: <\/span>{1}<\/span>.'<\/span>.<\/span>format<\/span>(<\/span>\r\n... <\/span>        pregunta<\/span>,<\/span> respuesta<\/span>)<\/span>\r\n...<\/span>\r\n\u00bfCual es tu nombre?, la respuesta es: Leonardo.<\/span>\r\n\u00bfCual es tu objetivo?, la respuesta es: aprender Python y Plone.<\/span>\r\n\u00bfCual es tu sistema operativo?, la respuesta es: Linux.<\/span><\/pre>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
    Tipo listas En Python tiene varios tipos de datos\u00a0compuestos\u00a0y dentro de las secuencias, est\u00e1n los tipos de\u00a0cadenas de caracteres. Otro tipo muy importante de secuencia son las\u00a0listas. Entre las\u00a0secuencias, el m\u00e1s vers\u00e1til, es la\u00a0lista, para definir una, usted debe escribir es entre corchetes, separando sus elementos con comas cada uno. La lista en Python son […]<\/p>\n","protected":false},"author":1,"featured_media":331,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[39,40],"tags":[],"class_list":["post-353","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programacion","category-python"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/equipomedios.com\/blog\/wp-content\/uploads\/2024\/08\/python-logo-master-v3-TM.png?fit=601%2C203&ssl=1","jetpack_sharing_enabled":true,"jetpack-related-posts":[],"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/353","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/comments?post=353"}],"version-history":[{"count":1,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/353\/revisions"}],"predecessor-version":[{"id":354,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/353\/revisions\/354"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media\/331"}],"wp:attachment":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media?parent=353"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/categories?post=353"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/tags?post=353"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}