Python

Da Wikipedia, a enciclopedia libre.
Ir á navegación Ir á busca
Nota de desambiguación.svg Desambiguación : se buscas outros significados, consulta Python (desambiguación) .
Python
linguaxe de programación
Logotipo de Python e wordmark.svg
Autor Guido van Rossum
Data de orixe 20 de febreiro de 1991
Última versión 3.9.6 (28 de xuño de 2021) e 3.10.0rc1 (3 de agosto de 2021)
Uso xenérico, script
Paradigmas Programación orientada a obxectos
Mecanografía dinámico
Extensións comúns .py, .pyw, .pyc, .pyo, .pyd
Influenciado por ABC , ALGOL 68 , C , C ++ , Dylan , Haskell , Icon , Java , Lisp , Modula-3 , Perl
Influíu Boo , Cobra , D , F # , Falcon , Go , Groovy , JavaScript , Julia , Ruby , Swift , Perl 6
Implementación de referencia
Sistema operativo Multiplataforma
Licenza Licenza Python Software Foundation
Páxina web www.python.org/

Python é unha linguaxe de programación máis "de alto nivel" que a maioría das outras linguaxes, orientado a obxectos , apto, entre outros usos, para o desenvolvemento de aplicacións distribuídas, scripts , computación numérica e probas de sistemas .

Ideado por Guido van Rossum a principios dos noventa , o nome foi escollido pola paixón do inventor por Monty Pythons e pola súa serie de televisión Monty Python's Flying Circus [1] e adoita compararse con Ruby , Tcl , Perl , JavaScript , Visual Basic ou Scheme [2] .

Tamén se adoita estudar entre as primeiras linguas pola súa semellanza cun pseudocódigo e úsase frecuentemente para simular a creación de software grazas á flexibilidade de experimentación permitida por Python, que permite ao programador organizar ideas durante o desenvolvemento, como por exemplo, crear un xogo a través de Pygame ou o back-end dun sitio web a través de Flask ou Django .

Python tamén ten unha sección de gráficos, o módulo Python Turtle Graphics.

Descrición

É unha linguaxe multi-paradigma que ten entre os seus obxectivos principais: dinamismo, sinxeleza e flexibilidade. Admite o paradigma orientado a obxectos, a programación estruturada e moitas funcións de programación funcional e de reflexión .

As características máis inmediatamente recoñecibles de Python son as variables sen escribir e o uso de sangría para a sintaxe de especificación, no lugar dos parénteses máis comúns.

Outras características distintivas son a sobrecarga de operadores e funcións a través de delegados , a presenza dun amplo surtido de tipos e funcións básicas e bibliotecas estándar, sintaxis avanzadas como o corte e a comprensión de listas .

A comprobación de tipos é forte ( escritura forte ) e realízase en tempo de execución ( dixitación dinámica ): unha variable é un contedor ao que se lle asocia unha etiqueta (o nome) que se pode asociar con diferentes contedores incluso de diferentes tipos durante a súa vida útil. Un sistema de recollida de lixo para liberar e recuperar automaticamente a memoria de traballo é parte de Python.

Python ten algo de parecido con Perl , pero os seus deseñadores escolleron unha sintaxe máis básica e uniforme co obxectivo de mellorar a lexibilidade do código. Do mesmo xeito que Perl, a miúdo clasifícase como linguaxe de script , pero aínda que é útil para escribir scripts do sistema, como alternativa, por exemplo, ao bash , a gran cantidade de bibliotecas dispoñibles e a facilidade coa que o idioma permite escribir software modular tamén favorece o desenvolvemento de aplicacións moi complexas.

Outras características

Código fonte dun programa escrito en Python
Exemplo de código fonte escrito en Python

Aínda que xeralmente considérase que Python é unha linguaxe interpretada , en realidade o código fonte non se converte directamente en linguaxe máquina . De feito, primeiro pasa por unha fase de precompilación en bytecode , que case sempre se reutiliza despois da primeira execución do programa, evitando así reinterpretar a fonte cada vez e mellorando o rendemento. Ademais, é posible distribuír programas Python directamente en bytecode, saltando completamente a fase de interpretación polo usuario final e obtendo programas Python de código pechado [3] .

Menú despregable desde o que pode executar o programa premendo en "Executar módulo" ou co atallo F5 desde Windows 10 en diante.

Do mesmo xeito que a linguaxe Lisp e a diferenza de Perl, o intérprete de Python tamén admite un modo de usuario interactivo ( REPL ) a través do cal pode introducir código directamente desde un terminal, mostrando o resultado inmediatamente.

Exemplo dalgúns códigos fonte escritos con Python IDLE 3.8.5

Ademais, o intérprete de Python está contido na biblioteca estándar, polo que como en moitas outras linguas interpretadas é posible que as cadeas arbitrarias sexan avaliadas no contexto actual. Tamén é posible pasar ao intérprete un contexto completamente diferente, en forma de listas que conteñen a lista de símbolos definidos.

Python tamén ten un marco de probas unitarias que admite o desenvolvemento de probas unitarias automatizadas.

Actuación

En comparación coas linguaxes compiladas de forma estática , como C , a velocidade de execución non é un dos puntos fortes de Python [4] , especialmente na computación matemática. Ademais, o programa está baseado unicamente nun núcleo e o multi-threading só está presente no nivel abstracto. Houbo unha extensión, Psyco [5] , cuxo desenvolvemento rematou en 2012, que era unha especie de compilador JIT , capaz de acelerar significativamente algúns tipos de código, especialmente a implementación de algoritmos, a costa de aumentar a memoria empregada. Un proxecto actual e desenvolvido activamente para mellorar o rendemento do código Python cun compilador JIT é PyPy [6] .

Python permítelle evitar facilmente o obstáculo do rendemento puro: de feito é relativamente sinxelo escribir unha extensión en C ou C ++ e usala despois en Python, explotando así a alta velocidade dunha linguaxe compilada só nas partes de que realmente serve e aproveitando a potencia e versatilidade de Python para todo o resto do software [7] .

Outras implementacións

Actualmente están dispoñibles as seguintes implementacións de Python:

Tipos de datos e estruturas

Como Python se escribe dinámicamente , todas as variables son realmente indicadores de obxectos . Por exemplo, se a unha variable se lle asigna un valor enteiro, pódese asignar unha cadea ou unha lista inmediatamente despois. Por outra banda, os obxectos teñen un tipo.

Python espera unha comprobación de tipo moderada no tempo de execución , é dicir, no tempo de execución . Os tipos numéricos teñen conversión implícita polo que é posible, por exemplo, multiplicar un número complexo por un enteiro. Non hai conversión implícita entre números e cadeas alfanuméricas; polo tanto, un número é un argumento non válido para as operacións de cadea, a diferenza do que ocorre por exemplo na linguaxe PHP.

Python ten varios modelos / bibliotecas para empregar para proporcionar funcionalidades sen ter que escribir código, como os gráficos de tartarugas [14] (para debuxar), copiar [15] (para crear copias de obxectos ), aleatorios [16] (para xerar aleatorios números), sys [17] (para interactuar desde a liña de comandos co intérprete) e hora (para operar con unidades de hora e data).

Python ofrece un gran número de tipos básicos , esencialmente numéricos e tipos de contedores. A característica distintiva é o soporte nativo, ademais de tipos clásicos como enteiros, punto flotante (números con punto flotante) e cadeas alfanuméricas, tipos aínda máis avanzados como enteiros de tamaño arbitrario, números complexos, listas , conxuntos e dicionarios . Non obstante, non hai ningún tipo específico para os personaxes.

Moitos outros tipos son importables desde bibliotecas estándar e pódense crear novos tipos a través das clases .

Gráficos de tartarugas

Exemplo da saída dun programa escrito coa biblioteca de tartarugas.

O módulo tartaruga, como as outras bibliotecas, pódese importar coa función de importación apropiada escribindo no código fonte:

 importar tartaruga
desde a importación de tartarugas Turtle , Screen

Os comandos escritos anteriormente poñen a disposición os obxectos Turtle e Screen, cuxas funcións poden asignarse a obxectos reais do seguinte xeito:

 desde a importación de tartarugas Turtle , Pantalla #. Importará unha tartaruga (pluma de pitón) e a súa pantalla.
Background = Screen () # polo que asigna todas as funcións e propiedades de Screen a Background.
Pen = Turtle () # este será o Pen.
# Por suposto, calquera nome de obxecto pode asignarse á tartaruga e á pantalla e cambiar ao longo do programa.

Todas as funcións do fondo e da pluma pódense usar chamándoas como no seguinte código:

 Bolígrafo . círculo ( 5 ) # por exemplo, a función círculo creará un círculo que teña o valor entre parénteses como raio
# A función setcolor (referida tanto á tartaruga como ao fondo) determina a súa cor
Antecedentes . setcolor ( "laranxa" ) # usando o nome de cor desexado
Antecedentes . setcolor ( "FFFFFF" ) # ou escribindo a cor en RGB hexadecimal

Tipos numéricos

Os tipos enteiros ( int ) e de coma flotante ( float ) teñen un tamaño dependente do hardware e da implementación do intérprete, normalmente de 32 e 64 bits . Espéranse nativamente enteiros arbitrariamente grandes ( long , que se converte na opción predeterminada para enteiros que comezan con Python 3.0) e números complex ( complex ).

Python ten todos os principais operadores lóxicos e aritméticos entre números, incluída a exponenciación. O tipo booleano ( bool ) tamén pertence á categoría de números.

Dende a versión 2.4 de Python están dispoñibles como biblioteca [18] tamén os números decimais ( decimal ), é dicir, os números en coma flotante cunha precisión ilimitada, como os dispoñibles en REXX ou Cobol , que non sofren problemas de redondeo e estabilidade típica dos números puntos flotantes clásicos.

Contedores

Python xeralmente considera como recipientes obxectos que ofrecen a posibilidade de iterar sobre un conxunto de elementos, polo tanto utilizables dentro de contextos como o loop for e funcións como suma, busca e ordenación. Os contedores xeralmente permítenlle manter datos heteroxéneos.

En canto aos contedores estándar adecuados, pódense clasificar como secuencias , conxuntos e dicionarios . Os contedores seguen unha filosofía común e comparten a maioría dos métodos .

As secuencias son contedores ordenados, compartindo métodos baseados na ordenación, indexación de números enteiros e a creación de subsecuencias mediante cortes .

As listas ( list ) poden ser secuencias estendidas, mentres que as tuplas ( tuple ) son secuencias inmutables. As cadeas alfanuméricas ( str e unicode ) tamén se consideran secuencias. Comezando con Python 3.0, os tipos str e unicode están unificados e aparece o tipo de byte , aproximadamente equivalente a unha cadea binaria.

Ofrécense todas as operacións de cadea clásicas como concatenación, formato, busca, substitución, etc. As cadeas en Python son secuencias inmutables, de xeito que calquera operación que de algunha maneira poida alterar unha cadea, como substituír un carácter, devolve realmente unha nova cadea, como en Java e C #.

Outros contedores son dicionarios ( dict ), coñecidos noutros contextos co nome de táboa de hash ou matrices asociativas . Existe unha sintaxe para a creación de dicionarios, cuxos elementos están especificados por un par de datos separados por dous puntos ":". O primeiro elemento do par representa o índice, chamado "clave", e o segundo é o seu valor correspondente. De feito, a cada elemento dun dicionario tamén se lle chama "par clave-valor".

Por exemplo, a seguinte instrución crea un dicionario identificado como diz composto por dous elementos cuxas claves son wikipedia e wikiquote , respectivamente e cos valores enteiros 40 e 60 asociados:

 diz = { 'wikipedia' : 40 , 'wikiquote' : 60 }

As claves dun dicionario son inmutables, mentres que o valor correspondente a cada clave pode modificarse mediante unha asignación. A seguinte instrución cambia o valor correspondente a "wikipedia", levándoo a 4500:

 diz [ 'wikipedia' ] = 4500

A partir da versión 2.7 de Python [19] , tamén se admiten conxuntos ( set e frozenset ), é dicir, conxuntos non ordenados de obxectos lavables .

Organización orientada a obxectos

O sistema tipo Python está ben integrado co sistema de clases . Aínda que os tipos de base non son formalmente clases, como en C # por exemplo, unha clase aínda pode herdar deles. Deste xeito é posible ampliar cadeas, dicionarios e incluso números enteiros. Tamén se admite a herdanza múltiple [20] .

Tamén se admiten funcións de introspección de tipo e clase. Os tipos e as clases son eles mesmos obxectos que se poden explorar e comparar. Os atributos xestionanse nun dicionario.

Sintaxe

Python foi deseñado para ser facilmente lexible e escribible. Visualmente preséntase dun xeito lineal e limpo, con poucas construcións sintácticas en comparación con outras linguaxes estruturadas como C , Perl ou Pascal .

Por exemplo, Python só ten dúas formas de loops: for que itera sobre elementos dunha lista ou un iterador (equivalente a Perl ou PHP foreach ) e while que loops sempre que a expresión booleana especificada sexa certa. Esencialmente carece de bucles ao estilo C for , do while e until , pero todos estes pódense expresar como simples equivalentes. Do mesmo xeito só ten a construción if elif else para opcións condicionais, pero non ten switch nin goto .

Sangría

Un aspecto inusual de Python é o método que emprega para delimitar bloques de programas, o que o fai único entre as linguas máis populares.

En idiomas derivados de ALGOL como Pascal, C e Perl, os bloques de código indícanse con parénteses ou con palabras clave; por exemplo, C e Perl usa {} while Pascal usos begin e end . Nestas linguas só é unha pura convención dos desenvolvedores recuar (é dicir, "recuar" desde a marxe esquerda da páxina) o código fonte dentro dun bloque para mellorar a súa lexibilidade e aclarar a estrutura do fluxo de execución.

Pola contra, Python deriva o seu sistema de sangría da linguaxe de programación Occam menos coñecida: en vez de empregar parénteses ou palabras clave, usa a propia sangría para indicar bloques aniñados xunto co carácter "dous puntos" (:). En Python pode usar tanto unha ficha como un número arbitrario de espazos, sempre que por suposto se usen dun xeito congruente coa sintaxe do idioma. O seguinte exemplo aclara isto mostrando a versión C e Python das funcións para calcular o factorial dun enteiro.

Factorial en Do:

 int factorial ( int x ) {
    if ( x == 0 ) 
        devolución 1 ;
    senón 
        devolver x * factorial ( x -1 );
}

Factorial en Python:

 factorial def ( x ):
    se x == 0 :
        devolución 1
    senón :
        retorno x * factorial ( x - 1 )

Nun primeiro momento este xeito de indicar bloques e expresar a sintaxe pode confundir as ideas dos procedentes doutras linguas, pero logo resulta moi vantaxoso, porque é conciso e obriga a escribir fontes sangradas correctamente, aumentando así a lexibilidade do código.

A desvantaxe é que a xestión de espazos e caracteres de tabulación pode ser diferente dun editor de texto a outro, o que obriga a prestar moita atención á sangría do código ou a confiar nas funcións de sangría automáticas que agora se presentan na maioría dos editores de programas. Tamén pode ocorrer que traballe con diferentes editores de código fonte, en varios ordenadores, e así acabar cun código fonte que usa pestanas e espazos de forma mixta, notando o erro só no tempo de execución.

Python tamén permite que algúns atallos escriban código "múltiple" na mesma liña. Se os dous puntos (:) inician un bloque de sangría de só unha liña: podemos movelo seguindo un espazo máis tarde.

 se b > a : print ( "b é maior que a" )

Aínda que non é moi bo para os puristas da linguaxe Python, aínda é posible usar o "punto e coma" (;) como na maioría das linguaxes de programación para indicar que unha instrución está rematada e iniciar outra na mesma liña.

 a = b + 10 ; print ( "Ola mundo" ); b = 243 - 23 ;

Programación funcional e sintaxe avanzada

Outro dos puntos fortes de Python é a dispoñibilidade de elementos que facilitan a programación funcional . As funcións considéranse obxectos e, polo tanto, pódense usar como calquera outro obxecto, por exemplo inseríndoas en coleccións ou empregándoas directamente como parámetros para outras funcións. Os elementos de programación funcional, xunto con construcións específicas para manipular contedores, fan que sexa aínda máis cómodo traballar con listas ou outros tipos de contedores.

As cortes son unha construción semellante á indexación capaz de obter subsecuencias especificando os índices de inicio, final e "paso".

 números = [ 1 , 2 , 3 , 4 , 5 ]
números_pares = números [ 1 :: 2 ] # exemplo de corte

A comprensión da lista é unha construción tomada da linguaxe funcional Haskell e permite o "recheo" dunha lista - usando unha sintaxe especial - como podemos ver no seguinte exemplo no que se calculan as cinco primeiras potencias de dúas:

 números = [ 1 , 2 , 3 , 4 , 5 ]
powers_of_two = [ 2 ** n para n en números ] # exemplo de comprensión da lista

Os xeradores , por outra banda, son obxectos particulares capaces de construír coleccións dun xeito dinámico, útiles para aumentar a eficiencia, en particular a presenza de iteracións nun gran número de elementos. As expresións do xerador , similares ás comprensións de listas, son unha ferramenta rápida e eficaz para crear xeradores. A palabra clave rendemento permítelle crear xeradores cunha sintaxe moi similar á dunha función.

Pasemos a algúns exemplos; expresión xeradora :

 números = [ 1 , 2 , 3 , 4 , 5 ]
powers_of_two = ( 2 ** n para n en números ) # xerador

Ou, para máis control, como unha función normal, podemos usar a palabra clave rendemento no canto de devolver , para converter a nosa función nun xerador. Deste xeito, a función "garda" o seu estado e despois retoma a execución do código cando se recorda o valor do seguinte rendemento .

 números = [ 1 , 2 , 3 , 4 , 5 ]
def power_of_two ( números ):
    para n en números :
        rendemento 2 ** n
gen = power_of_two ( números )

O uso é idéntico. Chámase á seguinte función que devolve un novo valor cada vez, retomando a execución de código a partir da palabra clave de rendemento . Cando os valores rematen, levantase unha excepción StopIterationError . Non obstante, non é o único xeito de interactuar cos xeradores e pode rastrexar os datos pasados ​​ao rendemento da función deste xeito:

 gen = ( 2 ** n para n no rango ( 1 , 6 ))
para x en gen :
    imprimir ( x )

Para crear unha lista a partir dun xerador, simplemente use a lista de chamadas (gen):

 gen = ( 2 ** n para n no rango ( 1 , 6 ))
print ( list ( gen ))

Os xeradores prefírense ás listas xa que non ocupan memoria, xa que os valores simplemente se calculan de cando en vez e non quedan na memoria. Para isto, é recomendable empregar, por exemplo, xrange (que é un xerador) no canto de rango (que devolve unha lista) con números moi grandes, para garantir unha maior velocidade

Tamén é posible escribir expresións if ... else nunha soa liña, que é útil en combinación con lambdas (ver máis abaixo).

 importar aleatoriamente
l = [ 1 , 2 ]
a = aleatorio . elección ( l )
imprimir ( 'Right' Un 'mal' == 1 persoa)

Dado que Python permítelle ter funcións como argumentos , tamén é posible ter construcións funcionais máis sutís, como a continuación . [21] .

En Python existe a palabra clave lambda , especialmente útil en contextos nos que é necesario realizar pequenas operacións que probablemente só se realicen nesa área do código:

 >>> l = [ 1 , 2 , 3 , 4 , 5 ] # ou rango (1,6)
>>> imprimir ( mapa ( lambda x : x + 10 , l ))
[ 11 , 12 , 13 , 14 , 15 ]

Non obstante, este uso do mapa está en disputa e prefírese empregar comprensións de lista:

 >>> l = [ 1 , 2 , 3 , 4 , 5 ] # ou rango (1,6)
>>> imprimir ([ x + 10 para x en l ])
[ 11 , 12 , 13 , 14 , 15 ]

Non obstante, os bloques lambda só poden conter expresións , non sentenzas . Polo tanto, non son o xeito máis xeral de devolver unha función. Pola contra, pode usar a seguinte técnica que devolve unha función cuxo nome está definido nun ámbito local, é dicir, un peche :

 def multiple_adder ( x , y ):
    sumador def ( z ):
        devolver z + x + y
    return ( x + y + sumador ( x + y )) # sería (x + y) * 3

Decoradores

Un decorador é calquera obxecto invocable de Python usado para engadir código ao comezo ou ao final dunha función, método ou definición de clase, sen modificar o seu código internamente. Un decorador pasou o obxecto e devolve o obxecto modificado.

Os decoradores están inspirados en parte pola notación Java, teñen sintaxe similar e considéranse azucre sintáctico . Usan @ como palabra clave:

 @viking_chorus
def menu_item ():
    imprimir ( "spam" )

Os decoradores pódense encadear colocando varios en liñas adxacentes:

 @Invencible
@favorite_color ( "Azul" )
def cabaleiro negro ():
    pasar

e equivale a:

 def cabaleiro negro ():
    pasar
black_knight = invencible (favorite_color ( "Blue") (black_knight))

A estrutura estándar do decorador é:

 def favorite_color ( cor ):
    decorador def ( func ):
        wrapper def ():
            imprimir (a cor )
            func ()
        envoltorio de retorno
    decorador de retorno

Comentarios

Como outras linguaxes de programación, en Python podes deixar comentarios en liñas de código para comprender mellor o que ocorre cando executas o programa. En Python, os comentarios (a partir das primeiras versións da linguaxe de programación) introdúcense co símbolo "#" para non alterar o código.

 print ( "algo aleatorio" ) #este programa imprime "algo aleatorio" ignorando calquera cousa despois do símbolo "#"
print ( "ir de cabeza a cabeza o efecto do hash desaparece e o código afecta ao programa" )

Manexo de excepcións

Python soporta e usa extensamente o manexo de excepcións como medio para informar e comprobar as condicións de erro, incluídas as excepcións provocadas por erros de sintaxe.

As excepcións permiten unha comprobación de erros máis concisa e fiable que moitas outras formas posibles empregadas normalmente para informar de erros ou situacións anormais. As excepcións son fiables ; non sobrecargan o código fonte como fan as comprobacións dos valores de erro devoltos e poden propagar facilmente a pila de chamadas de funcións cando hai que informar dun erro a un nivel superior do programa.

Coa xestión de excepcións, as comprobacións preventivas substitúense por un mecanismo máis sinxelo que lle permite realizar a acción desexada directamente e capturar por separado as excepcións que poidan producirse. Ademais do tratamento de erros, ás veces úsanse excepcións en Python tamén para o control de fluxo: por exemplo, a operación de iteración e, en consecuencia, o bucle for, baséase nunha sinalización de excepción.

Biblioteca estándar

Python ten unha extensa biblioteca estándar , o que o fai apto para moitos usos. Ademais dos módulos de biblioteca estándar, podes engadir outros escritos en C ou Python para satisfacer as túas necesidades particulares. Entre os módulos xa dispoñibles hai para escribir aplicacións web: admítense MIME , HTTP e todos os demais estándares de Internet. Tamén están dispoñibles módulos para crear aplicacións cunha interface gráfica, para conectarse a bases de datos relacionais , para usar expresións regulares .

A biblioteca estándar é un dos puntos fortes de Python. De feito, é compatible con todas as plataformas, a excepción dalgunhas funcións, claramente marcadas na documentación como específicas dunha plataforma concreta.

Exemplos de programas

Ola, mundo!

O seguinte exemplo de programa Python (versión 3.0) imprime o texto " Ola, mundo! ":

 print ( "Ola, mundo!" )

O seguinte é o mesmo programa que se executa coa versión 2.7 ou anterior:

 imprimir "Ola, mundo!"

RGB binario, RGB hexagonal

O seguinte exemplo de programa Python (versión 3.8.5 [22] ) converte unha entrada nunha cor codificada RGB cos pasos necesarios das porcentaxes vermello, verde e azul:

 def RGB_bin ():
importar cadea
porcentaxe1 = entrada ( "vermello ( % d ex):" )
porcentaxe2 = entrada ( "verde ( % d ex):" )
porcentaxe3 = entrada ( "azul ( % d ex):" )
print ( "Codificación en RGB dunha cor con" + str ( porcentaxe1 ) + " % o f vermello", + str ( porcentaxe2 ) + " % o f verde e" + str ( porcentaxe3 ) + " % o f azul ... " )
    
print ( str ( porcentaxe1 ) + ": 100 = X: 256, polo que X =" + str ( porcentaxe1 ) + "* 256 / 100." )
X = float (int (porcentaxe1) * 256/100)
    
print ( str ( porcentaxe2 ) + ": 100 = Y: 256, polo que Y =" + str ( porcentaxe2 ) + "* 256 / 100." )
Y = float (int (porcentaxe2) * 256/100)
    
print ( str ( porcentaxe3 ) + ": 100 = Z: 256, polo que Z =" + str ( porcentaxe3 ) + "* 256 / 100." )
Z = float (int (porcentaxe3) * 256/100)

X = bin ( int ( X ))
Y = bin ( int ( Y ))
Z = bin ( int ( Z ))
binario_color = ( str ( X ) + "" + str ( Y ) + "" + str ( Z ))
print ( "Color codificado por díxitos binarios:" + str ( binary_colour [ 2 :]))



def RGB_hex ():
porcentaxe1 = entrada ( "vermello ( % d ex):" )
porcentaxe2 = entrada ( "verde ( % d ex):" )
porcentaxe3 = entrada ( "azul ( % d ex):" )
print ( "Codificación en RGB dunha cor con" + str ( porcentaxe1 ) + " % o f vermello", + str ( porcentaxe2 ) + " % o f verde e" + str ( porcentaxe3 ) + " % o f azul ... " )
    
print ( str ( porcentaxe1 ) + ": 100 = X: 256, polo que X =" + str ( porcentaxe1 ) + "* 256 / 100." )
R = float (int (porcentaxe1) * 256/100)
    
print ( str ( porcentaxe2 ) + ": 100 = Y: 256, polo que Y =" + str ( porcentaxe2 ) + "* 256 / 100." )
G = float (int (porcentaxe2) * 256/100)
    
print ( str ( porcentaxe3 ) + ": 100 = Z: 256, polo que Z =" + str ( porcentaxe3 ) + "* 256 / 100." )
B = float (int (porcentaxe3) * 256/100)

R = hex ( int ( R ))
G = hex ( int ( G ))
B = hex ( int ( B ))
hexadecimal_colour = ( str ( R ) + " " + str ( G ) + " " + str ( B ))
print ( "Colour coded by hexadecimal digits: " + str ( hexadecimal_colour [ 2 : 5 ]) + str ( hexadecimal_colour [ 7 : 10 ]) + str ( hexadecimal_colour [ 12 : 14 ]))

L' output del codice sorgente sopra è il seguente:

 ======== RESTART : D : \ Python \ Python \ Python38 - 32 \ Python3 . 8.5 dal pc \ RGB . py =======
>>> RGB_bin ()
red ( % dex ): 30
green ( % dex ): 40
blue ( % dex ): 20
Coding in RGB a color with 30 % of red , 40 % of green and 20 % of blue ...
30 : 100 = X : 256 , so X = 30 * 256 / 100.
40 : 100 = Y : 256 , so Y = 40 * 256 / 100.
20 : 100 = Z : 256 , so Z = 20 * 256 / 100.
Colour coded by binary digits : 1001100 0b1100110 0b110011

Definizione di una classe

In Python è possibile creare classi attraverso un'istruzione specifica ( class ) che rappresenta l'alternativa più semplice, ma non esclusiva, per definire nuovi tipi di dato. Caratteristiche particolari in Python sono la possibilità di eredità multipla, la definizione di attributi tramite inizializzazione e non tramite dichiarazione, la dichiarazione esplicita del parametro riflessivo nei metodi d'istanza e l' overloading di funzioni e operatori.

Il parametro riflessivo è per convenzione chiamato 'self', ma il linguaggio non impone alcuna restrizione in merito alla scelta. Nessuna restrizione è posta anche alla definizione degli attributi: gli attributi esistono dal momento in cui vengono assegnati e l'assegnazione può avvenire al momento della costruzione (metodo __init__ , da preferire) oppure all'interno di altri metodi. Inoltre gli attributi possono essere aggiunti esternamente alla classe o direttamente a un oggetto.

Python fa distinzione tra metodi d'istanza, di classe o statici. Gli attributi possono essere invece d'istanza o di classe. Il supporto all'information hiding è parziale, ma integrato dallo strumento delle property che permettono di definire degli attributi virtuali con le caratteristiche di accesso volute.

Inoltre sono previsti dei metodi "speciali" associati a operatori e funzioni di built-in. Ad esempio, ridefinendo il metodo __add__ si ridefinisce l'operatore di addizione quando il primo operando sia del tipo definito, mentre __str__ ridefinisce la conversione a stringa. Non è invece permesso l'overloading dei metodi. Attraverso l'uso della riflessione e delle metaclassi è inoltre possibile personalizzare ulteriormente la definizione delle classi.

Ad esempio una classe Persona, avente solo un semplice costruttore e un metodo che restituisce il nome completo. È caldamente consigliato creare solo classi "new style", ovvero classi che ereditano (direttamente o indirettamente) da object [23] .

A partire da Python 3.6, è possibile utilizzare una nuova funzione chiamata "f-strings" [24] . Anteponendo la lettera f prima delle virgolette che aprono la dichiarazione di una stringa, questa funzione viene attivata. Grazie a essa è possibile includere variabili all'interno di una stringa inserendo il loro nome tra parentesi graffe. In questo modo rendiamo il codice molto più leggibile senza dover utilizzare una serie di + per concatenare variabili e stringhe vuote. Inoltre, nel caso in cui volessimo includere una variabile o un oggetto non di tipo stringa, la conversione avverrà in automatico, risparmiando l'eccezione TypeError.

 class Persona ( object ):
    # Costruttore della classe
    def __init__ ( self , nome , cognome ):
        self . nome = nome
        self . cognome = cognome

    def nome_completo ( self ):
        full = f 'Sig. { self . cognome } { self . nome } '
        return full

persona = Persona ( 'Mario' , 'Rossi' )
print ( persona . nome_completo ())

L'output presentato sarà il seguente: Sig. Rossi Mario

Note

  1. ^ Fonte: Copia archiviata , su python.org . URL consultato il 27 ottobre 2009 (archiviato dall' url originale il 17 dicembre 2009) .
  2. ^ Dal file README della distribuzione 2.6.4: " What is Python anyway? Python is an interpreted, interactive object-oriented programming language suitable (amongst other uses) for distributed application development, scripting, numeric computing and system testing. Python is often compared to Tcl, Perl, Java, JavaScript, Visual Basic or Scheme. "
  3. ^ How do I create a .pyc file? , su effbot.org . URL consultato il 28 maggio 2020 .
  4. ^ Python 3 vs C gcc - Which programs are fastest? | Computer Language Benchmarks Game , su benchmarksgame-team.pages.debian.net . URL consultato il 28 maggio 2020 .
  5. ^ Psyco - Home Page , su psyco.sourceforge.net . URL consultato il 28 maggio 2020 .
  6. ^ ( EN ) The PyPy Team, PyPy , su PyPy , 28 dicembre 2019. URL consultato il 28 maggio 2020 .
  7. ^ ( EN ) Real Python, Python Bindings: Calling C or C++ From Python – Real Python , su realpython.com . URL consultato il 28 maggio 2020 .
  8. ^ Jython: Python for the Java Platform
  9. ^ IronPython: the Python programming language for the .NET Framework
  10. ^ The Python programming language for S60 mobile phones
  11. ^ PyPy Archiviato il 13 gennaio 2007 in Internet Archive .
  12. ^ Pagina dove vengono archiviati i file caricati , su Repl.it .
  13. ^ SL4A su Google Code
  14. ^ 24.1. turtle — Turtle graphics — Python 3.3.7 documentation , su docs.python.org . URL consultato il 28 maggio 2020 .
  15. ^ 8.17. copy — Shallow and deep copy operations — Python 2.7.18 documentation , su docs.python.org . URL consultato il 28 maggio 2020 .
  16. ^ random — Generate pseudo-random numbers — Python 3.8.3 documentation , su docs.python.org . URL consultato il 28 maggio 2020 .
  17. ^ 28.1. sys — System-specific parameters and functions — Python 2.7.18 documentation , su docs.python.org . URL consultato il 28 maggio 2020 .
  18. ^ 9.4. decimal — Decimal fixed point and floating point arithmetic — Python 2.7.18 documentation , su docs.python.org . URL consultato il 28 maggio 2020 .
  19. ^ 5. Built-in Types — Python 2.7.18 documentation , su docs.python.org . URL consultato il 28 maggio 2020 .
  20. ^ ( EN ) Ereditarietà multipla , su Python ABC . URL consultato il 28 maggio 2020 .
  21. ^ Continuations Made Simple and Illustrated
  22. ^ rilascio versione 3.8.5 , su Python.org .
  23. ^ Un nuovo stile per le classi | Python-it.org # il punto di riferimento italiano per gli appassionati di Python , su python-it.org . URL consultato il 23 giugno 2010 (archiviato dall' url originale il 6 agosto 2010) .
  24. ^ ( EN ) PEP 498 -- Literal String Interpolation , su Python.org . URL consultato il 23 maggio 2019 .

Bibliografia

  • Micha Gorelick, Ian Ozsvald, Python alla massima potenza. Programmazione pratica ad alte prestazioni , Milano, Hoepli, 2015, p. 376, ISBN 9788820367015 .
  • Mark Lutz, Imparare Python , Milano, Tecniche Nuove, 2011, p. 1097, ISBN 9788848125956 .
  • ( EN ) Luciano Ramalho, Fluent Python: Clear, Concise, and Effective Programming , O'Reilly Media, 2015, p. 792, ISBN 9781491946008 .

Voci correlate

Altri progetti

Collegamenti esterni

Controllo di autorità LCCN ( EN ) sh96008834 · GND ( DE ) 4434275-5 · BNF ( FR ) cb13560465c (data)
Software libero Portale Software libero : accedi alle voci di Wikipedia che trattano di software libero