Python
Python és un llenguage d'alt nivell de programació interpretat la filosofia de la qual fa recalcament en la legibilidad de la seua còdic. Es tracta d'un llenguage de programació multiparadigma, ya que soporta parcialment l'orientació a objectes, programació imperativa i, en menor mida, programació funcional. És un llenguage interpretat, dinàmic, multiplataforma.
Administrat per Python Software Foundation, posseïx una llicencia de còdic obert, denominada Python Software Foundation License.[1] Python es classifica constantment com un dels llenguages de programació més populars, sent ya en 2025 el més popular i ademés en una àmplia diferencia récort històric de més de 15 punts percentuals sobre el següent.[2]
Història
[editar | editar còdic]- Artícul principal → Història de Python.
Python va ser creat a finals dels anys huitanta per Guido van Rossum en Stichting Mathematisch Centrum (CWI),[3] en Països Baixos, com un successor del llenguage de programació ABC, capaç de manejar excepcions i interactuar en el sistema operatiu Amoeba.[4]
El nom del llenguage prové de l'afició del seu creador pels humoristes britànics Monty Python.[5]
Guido van Rossum és el principal autor de Python, i el seu continu rol central en decidir la direcció de Python és reconegut, referint-se a ell com Benevolente Dictador Vitalici (en anglés: Benevolent Dictator for Life, BDFL); no obstant el 12 de juliol de 2018 va declinar de dita situació d'honor sense deixar un successor o successora i en una declaració altisonante:[6]
El 20 de febrer de 1991, van Rossum va publicar el còdic per primera volta en alt.sources, en el número de versió 0.9.0.[8] En esta etapa del desenroll ya estaven presents classes en herència, maneig d'excepcions, funciones i els tipos modular, com str, list, dict, entre uns atres. Ademés en este llançament inicial apareixia un sistema de mòduls adoptat de Modula-3; van Rossum descriu el mòdul com «una de les majors unitats de programació de Python».[3] El model d'excepcions en Python és semblat al de Modula-3, en l'adició d'una clàusula else.[4] En l'any 1994 es va formar comp.lang.python, el fòrum de discussió principal de Python, marcant una fita en el creiximent del grup d'usuaris d'este llenguage.
Python va alcançar la versió 1.0 en giner de 1994. Una característica d'este llançament varen ser les ferramentes de la programació funcional: lambda, reduïx, filter i map.[9] Van Rossum va explicar que «fa 12 anys, Python va adquirir lambda, reduïx(), filter() i map(), cortesia de Amrit Perm, un hacker informàtic de Lisp que les va implementar perque les estranyava».[10]
L'última versió lliberada provinent de CWI va ser Python 1.2. En 1995, van Rossum va continuar el seu treball en Python en la Corporation for National Research Initiatives (CNRI) en Reston, #Virginia, a on va llançar vàries versions del software.
Durant la seua estància en CNRI, van Rossum va llançar l'iniciativa Computer Programming for Everybody (CP4I), en la finalitat de fer la programació més accessible a més gent, en un nivell de 'alfabetisació' bàsic en llenguages de programació, similar a l'alfabetisació bàsica en anglés i habilitats matemàtiques necessàries per molts treballadors. Python va tindre un paper crucial en este procés: per la seua orientació cap a una sintaxis neta, ya era idòneu, i les metes de CP4I presentaven similituts en el seu predecessor, ABC. El proyecte va ser patrocinat per DARPA.[11] Per a l'any 2007, el proyecte CP4I es trobava inactiu;[12] a pesar d'això, Python continua intentant ser fàcil de deprendre i no molt arcano en la seua sintaxis i semàntica, en l'objectiu de ser entendible inclús per a no-programadors.
En l'any 2000, l'equip principal de desenrolladors de Python es va canviar a BeOpen.com per a formar l'equip BeOpen PythonLabs. CNRI va demanar que la versió 1.6 fora pública, continuant el seu desenroll fins que l'equip de desenroll va abandonar CNRI; el seu programa de llançament i el de la versió 2.0 tenien una significativa cantitat de traslapo.[13] Python 2.0 va ser el primer i únic llançament de BeOpen.com. Despuix que Python 2.0 fora publicat per BeOpen.com, Guido van Rossum i els atres desenrolladors de PythonLabs es varen unir en Digital Creations.
Python 2.0 va prendre una característica major del llenguage de programació funcional Haskell: llistes per comprensió. La sintaxis de Python per a esta construcció és molt similar a la de Haskell, salve per la preferència dels caràcters de puntuació en Haskell, i la preferència de Python per paraules claus alfabètiques. Python 2.0 va introduir ademés un sistema de recolecció de fem capaç de recolectar referències cíclicas.[13]
Posterior a este doble llançament, i despuix que van Rossum deixara CNRI per a treballar en desenrolladors de software comercial, va quedar clar que l'opció d'usar Python en software disponible baix la GNU GPL era molt desijable. La llicència usada llavors, la Python License, incloïa una clàusula estipulant que la llicència estava governada per l'estat de #Virginia, per lo que, baix l'òptica dels advocats de Free Software Foundation (FSF), es feya incompatible en GPL. Per a les versions 1.61 i 2.1, CNRI i FSF varen fer compatibles la llicència de Python en GPL, renombrándola com Python Software Foundation License. En l'any 2001, van Rossum va ser premiat en el FSF Award for the Advancement of Free Software.
Python 2.1 va ser un treball derivat de les versions 1.6.1 i 2.0. És a partir d'este moment que Python Software Foundation (PSF) passa a dirigir el proyecte, organisada com una organisació sense ànim de lucre fundada en l'any 2001, prenent com a model a l'Apache Software Foundation.[1] Inclosa en este llançament va estar una implementació de l'alcanç de variables més pareguda a les regles del static scoping originat per Scheme.[14]
Una innovació major en Python 2.2 va ser l'unificació dels tipos en Python (tipos escrits en C), i classes (tipos escrits en Python) dins d'una jerarquia. Eixa unificació va conseguir un model d'objectes de Python pur i consistent.[15] També varen ser agregats els generadors, que varen ser inspirats pel llenguage Icon.[16]
Les #adició a la biblioteca estàndar de Python i les decisions sintàctiques varen ser influenciades fortament per Java en alguns casos: el paquet logging,[17] introduït en la versió 2.3, està basat en log4j; el parser SAX, introduït en 2.0; el paquet threading,[18] la classe del qual Thread expon un subconjunt de l'interfaç de la classe homònima en Java.
Python 2.7.x (última versió de la série Python 2.x) va ser oficialment descontinuado l'1 de giner de 2020 (pas inicialment planejat per a 2015), per lo que ya no es publicaran pegats de seguritat i atres millores per a ell.[19][20] En el final del cicle de vida de Python 2, solament tenen soport la branca Python 3.6.x[21] i posteriors.
En Python 3.5 aplegaria el soport inclós per a entrada/eixida asíncrona a través de la biblioteca asyncio, orientada a aplicacions que requerixen alt rendiment de còdic concurrent, com servidors web, biblioteques de conexió de bases de senyes i coes de tasques distribuïdes.[22]
Evolució de Python 3.x
A continuació, es detallen les característiques més destacades de les versions recents de Python 3.x:
Python 3.6[23] (23 de decembre de 2016):
- Lliterals de cadena formateados (f-strings): Introducció d'una nova forma de formatear cadenes utilisant una sintaxis més senzilla i llegible.
- Guions baixos en lliterals numèrics: Permet millorar la legibilidad dels números grans en permetre l'us de guions baixos com separadores.
- Anotacions de variables: Es va afegir una sintaxis estàndar per a les anotacions de tipo en variables.
- Generadors i #comprensió asíncronos: Faciliten l'escritura de còdic asíncrono més clar i eficient.
Python 3.7[24] (27 de juny de 2018):
- Mòdul dataclasses: Proporciona un decorador i funcions per a crear classes que solament contenen senyes, reduint el còdic repetitiu.
- Mòdul contextvars: Permet manejar variables de context, útils en programació asíncrona.
- Noves funcions en asyncio: Millores significatives en el mòdul asyncio, incloent noves funcions i optimisacions.
Python 3.8[25] (14 d'octubre de 2019):
- Operador d'assignació en expressions (:=): Conegut com el "operador morsa", permet assignar valors a variables com a part d'una expressió.
- Paràmetros posicionals-only: Permet especificar que certs paràmetros d'una funció deuen ser passats solament per posició, no per nom.
- Mòdul importlib.metadata: Proporciona una forma d'accedir a la metadata dels paquets instalats.
Python 3.9[26] (5 d'octubre de 2020):
- Operadors d'unió i actualisació en diccionaris: Es varen introduir els operadors | i |= per a unir i actualisar diccionaris de manera més intuïtiva.
- Soport per a anotacions de tipo genèriques en les coleccions estàndar: Simplifica l'especificació de tipos en estructures de senyes.
- Mòdul zoneinfo: Incorpora la base de senyes de zones horàries IANA directament en la biblioteca estàndar.
Python 3.10[27] (4 d'octubre de 2021):
- Estructures de control match i case: Implementació de la coincidència de patrons estructurals, similar a switch en atres llenguages.
- Millores en els mensages d'error: Mensages d'error més precisos i descriptivos per a facilitar la depuració.
- Soport per a anotacions de tipo més precises: Inclou l'unió de tipos en l'operador |.
Python 3.11[28] (24 d'octubre de 2022):
- Millores significatives en el rendiment: Python 3.11 és entre un 10% i un 60% més ràpit que Python 3.10.
- Grups d'excepcions i except*: Permet manejar múltiples excepcions simultàneament de manera més eficient.
- Mòdul tomllib: Afig soport per a analisar archius TOML en la biblioteca estàndar.
- Millores en els rastrejos d'errors: Senyala en major precisió l'ubicació exacta dels errors en el còdic.
En l'actualitat, Python s'aplica en els camps d'inteligència artificial i machine learning.[29]
Característiques i paradigmes
[editar | editar còdic]Python és un llenguage de programació multiparadigma. Açò significa que més que forçar als programadors a adoptar un estil particular de programació, permet varis estils: programació orientada a objectes, programació imperativa i programació funcional. Atres paradigmes estan soportats per mig de l'us d'extensions.
Python usa tipado dinàmic i conteo de referències per a la gestió de memòria.
Una característica important de Python és la resolució dinàmica de noms; és dir, lo que enllaça un método i un nom de variable durant l'eixecució del programa (també cridat enllaç dinàmic de métodos).
Un atre objectiu del disseny del llenguage és la facilitat d'extensió. Es poden escriure nous mòduls fàcilment en C o C++. Python pot incloure's en aplicacions que necessiten un interfaç programable.[30]
Encara que la programació en Python podria considerar-se en algunes situacions hostil a la programació funcional tradicional exposta per Lisp, existixen prou #analogia entre Python i els llenguages minimalistes de la família Lisp (com Scheme).
Filosofia
[editar | editar còdic]Els usuaris de Python es referixen a sovint a la filosofia de Python, que és prou similar a la filosofia d'Unix. El còdic que seguixca els principis de Python és reconegut com «pythónico». Estos principis varen ser descrits pel desenrollador de Python Tim Peters en El Zen de Python:
Des de la versió 2.1.2, Python inclou estos punts (en la seua versió original en anglés) com un ou de Pasqua que es mostra en eixecutar import this.[31]
Modo interactiu
[editar | editar còdic]L'intérpret de Python estàndar inclou un modo interactiu en el qual s'escriuen les instruccions en una espècie d'intérpret de comandos: les expressions poden ser introduïdes una a una, podent vore's el resultat de la seua evaluació immediatament, lo que dona la possibilitat de provar porcions de còdic en el modo interactiu abans d'integrar-ho com a part d'un programa. Açò resulta útil tant per a les persones que s'estan familiarizando en el llenguage com per als programadors més alvançats.
Existixen atres programes, com ANEU-LI, bpython i IPython,[32] que afigen funcionalitats extra al modo interactiu, com completamiento automàtic de còdic i coloreat de la sintaxis del llenguage.
Eixemple del modo interactiu:
>>> 1 + 1
2
>>> a = range(10)
>>> print(list(a))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]Elements del llenguage i sintaxis
[editar | editar còdic]Python està destinat a ser un llenguage de fàcil llectura. El seu format és visualment ordenat i, a sovint, usa paraules clau en anglés a on atres idiomes usen puntuació. A diferència de molts atres llenguages, no utilisa corchetes per a delimitar blocs i es permeten punts i menge despuix de les declaracions, pero rara volta, si és que alguna volta, s'utilisen. Té menys excepcions sintàctiques i casos especials que C o Pascal.
Dissenyat per a ser llegit en facilitat, una de les seues característiques és l'us de paraules a on atres llenguages utilisarien símbols. Per eixemple, els operadors llògics !, || i && en Python s'escriuen not, or i and, i els operadors aritmètics en python respectivament.
El contingut dels blocs de còdic (bucles, funcions, classes, etc.) és delimitat per mig d'espais o tabuladors, coneguts com sagnat o indentación, abans de cada llínea d'órdens pertanyents al bloc.[33] Python es diferencia aixina d'atres llenguages de programació que mantenen com a costum declarar els blocs per mig d'un conjunt de caràcters, normalment entre claus {}.[34][35] Es poden utilisar tant espais com a tabuladors per a sagnar el còdic, pero es recomana no mesclar-los.[36]
| Funció factorial en C (sagnia opcional) | Funció factorial en Python (sagnia obligatòria) |
|---|---|
int factorial(int x)
{
if (x < 0 || x % 1 != 0) {
printf("x deu ser un numere sancer major o igual a 0");
return -1; // Error
}
if (x == 0) {
return 1;
}
return x * factorial(x - 1);
} |
def factorial(x):
assert x >= 0 and x % 1 == 0, "x deu ser un sancer major o igual a 0."
if x == 0:
return 1
else:
return x * factorial(x - 1) |
Pel significat sintàctic de la sagnia, cada instrucció deu estar continguda en una sola llínea. No obstant, si per legibilidad es vol dividir l'instrucció en vàries llínees, afegint una barra invertida al final d'una llínea, s'indica que l'instrucció continua en la següent.
Estes instruccions són equivalents:
llista = ['valor 1', 'valor 2', 'valor 3']
cadena = 'Açò és una cadena prou llarga' |
llista = ['valor 1', 'valor 2' , 'valor 3']
cadena = 'Açò és una cadena ' 'prou llarga' |
Comentaris
[editar | editar còdic]Els comentaris es poden posar de dos formes. La primera i més apropiada per a comentaris llarcs és utilisant la notació ''' comentari ''', tres apòstrofs d'obertura i tres de tancament. La segona notació utilisa el símbol #, que s'estén fins al final de la llínea.
L'intérpret no té en conte els comentaris, lo que és útil si desigem posar informació adicional en el còdic. Per eixemple, una explicació sobre el comportament d'una secció del programa.
'''
Comentari més llarc en una llínea en Python
'''
print("Hola món") # També és possible afegir un comentari al final d'una llínea de còdicVariables
[editar | editar còdic]Les variables es definixen de forma dinàmica, lo que significa que no es té que especificar quin és el seu tipo de bestreta i pot prendre distints valors en un atre moment, inclús d'un tipo diferent al que tenia prèviament. S'usa el símbol = per a assignar valors.
x = 1
x = "text" # Açò és possible perque els tipos són assignats dinàmicamentEls noms de variables poden contindre números i lletres pero deuen començar en una lletra. Ademés, existixen 35 paraules reservades en python:[37][38]
|
|
|
|
A partir de Python 3.10 existixen també soft keywords, paraules que són reservades en certs contexts, pero que normalment poden ser usades com a noms de variables. Estos identificadors són Tipos de senyes[editar | editar còdic]Els tipos de senyes bàsiques es poden resumir en esta taula:
Condicionals[editar | editar còdic]Una sentència condicional eixecuta la seua bloc de còdic intern solament si es complix certa condició. Es definix usant la paraula clau >>> verdader = True
>>> if verdader: # No és necessari posar "verdader == True"
... print("Verdader")
... else:
... print("Fals")
...
Verdader
>>> llenguage = "Python"
>>> if llenguage == "C": # llenguage no és "C", per lo que este bloc s'obviarà i evaluarà la següent condició
... print("Llenguage de programació: C")
... elif llenguage == "Python": # Es poden afegir tants blocs "elif" com es vullga
... print("Llenguage de programació: Python")
... else: # En cas que cap de les anteriors condicions fòra certa, s'eixecutaria este bloc
... print("Llenguage de programació: indefinit")
...
Llenguage de programació: Python
>>> if verdader and llenguage == "Python": # Us de "and" per a comprovar que abdós condicions són verdaderes
... print("Verdader i Llenguage de programació: Python")
...
Verdader i Llenguage de programació: PythonBucle for[editar | editar còdic]El bucle for és similar a foreach en atres llenguages. Recorre un objecte iterable, com una llista, una tupla o un generador, i per cada element del iterable eixecuta el bloc de còdic intern. Es definix en la paraula clau >>> llista = ["a", "b", "c"]
>>> for i in llista: # Iteramos sobre una llista, que és iterable
... print(i)
...
a
b c
>>> cadena = "abcdef"
>>> for i in cadena: # Iteramos sobre una cadena, que també és iterable
... print(i, end=', ') # Afegint end=', ' al final fem que no introduïxca un bot de llínea, sino una menge i un espai
...
a, b, c, d, i, f,Bucle while[editar | editar còdic]El bucle while evalua una condició i, si és verdadera, eixecuta el bloc de còdic intern. Continua evaluant i eixecutant mentres la condició siga verdadera. Es definix en la paraula clau >>> numere = 0
>>> while numere < 10:
... print(numere, end=" ")
... numere += 1 # Un bon programador modificarà les variables de control en finalisar el cicle while
...
0 1 2 3 4 5 6 7 8 9Llistes i Tuplas[editar | editar còdic]
>>> llista = ["abc", 42, 3.1415]
>>> llista[0] # Accedir a un element pel seu índex
'abc'
>>> llista[-1] # Accedir a un element usant un índex negatiu
3.1415
>>> llista.append(True) # Afegir un element al final de la llista
>>> llista
['abc', 42, 3.1415, True]
>>> del llista[3] # Borra un element de la llista usant un índex (en este cas: True)
>>> llista[0] = "xyz" # Re-assignar el valor del primer element de la llista
>>> llista[0:2] # Mostrar els elements de la llista de l'índex "0" a el "2" (sense incloure este últim)
['xyz', 42]
>>> llista_anidada = [llista, [True, 42]] # És possible anidar llestes
>>> llista_anidada
[['xyz', 42, 3.1415], [True, 42]]
>>> llista_anidada[1][0] # Accedir a un element d'una llista dins d'una atra llista (del segon element,
mostrar el primer element)
True
>>> tupla = ("abc", 42, 3.1415)
>>> tupla[0] # Accedir a un element pel seu índex
'abc'
>>> del tupla[0] # No és possible borrar (ni afegir) un element en una tupla, lo que provocarà una excepció
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> tupla[0] = "xyz" # Tampoc és possible re-assignar el valor d'un element en una tupla, lo que també provocarà una excepció
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tupla[0:2] # Mostrar els elements de la tupla de l'índex "0" a el "2" (sense incloure este últim)
('abc', 42)
>>> tupla_anidada = (tupla, (True, 3.1415)) # També és possible anidar tuplas
>>> 1, 2, 3, "abc" # Açò també és una tupla, encara que és recomanable posar-la entre paréntesis (recorde que
requerix, a lo manco, una menge)
(1, 2, 3, 'abc')
>>> (1) # Encara que es troba entre paréntesis, açò no és una tupla, ya que no posseïx a lo manco una menge, per
lo que únicament apareixerà el valor
1
>>> (1,) # En canvi, en este atre cas, sí és una tupla
(1,)
>>> (1, 2) # En més d'un element no és necessària la menge final
(1, 2)
>>> (1, 2,) # Encara que agregar-la no modifica el resultat
(1, 2)Diccionaris[editar | editar còdic]
>>> diccionari = {"cadena": "abc", "numere": 42, "llista": [True, 42]} # Diccionari que té diferents
valors per cada clau, inclús una llista
>>> diccionari["cadena"] # Usant una clau, s'accedix al seu valor
'abc'
>>> diccionari["llista"][0] # Accedir a un element d'una llista dins d'un valor (del valor de la clau
"llista", mostrar el primer element)
True
>>> diccionari["cadena"] = "xyz" # Re-assignar el valor d'una clau
>>> diccionari["cadena"]
'xyz'
>>> diccionari["decimal"] = 3.1415927 # Insertar un nou element clau:valor
>>> diccionari["decimal"]
3.1415927
>>> diccionari_mixt = {"tupla": (True, 3.1415), "diccionari": diccionari} # També és possible
que un valor siga un diccionari
>>> diccionari_mixt["diccionari"]["llista"][1] # Accedir a un element dins d'una llista, que es
troba dins d'un diccionari
42
>>> diccionari = {("abc",): 42} # Sí és possible que una clau siga una tupla, puix és immutable
>>> diccionari = {["abc"]: 42} # No és possible que una clau siga una llista, puix és mutable, lo que provocarà una excepció
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'Sentència match-case[editar | editar còdic]Python conta en l'estructura match-case des de la versió 3.10. Esta té el nom de Structural Pattern Matching. match variable:
case condicion:
# codigo
case condicion:
# codigo
case condicion:
# codigo
case _:
# codigocal destacar que esta funcionalitat és considerablement més complexa que el conegut switch-case de la majoria de llenguages de programació, ya que no solament permet realisar una comparació del valor, sino que també pot comprovar el tipo de l'objecte, i els seus atributs. Ademés, pot realisar un desempaquetado directe de seqüències de senyes, i comprovar-los de forma específica.
En el següent eixemple, es comproven els atributs de la nostra instància de from dataclasses import dataclass
dataclass
class Punt:
x: int
i: int
coordenada = Punt(10, 34)
match coordenada:
case Punt(x=10, i=40): # els atributs "x" i "i" tenen el valor especificat
print("Coordenada 10, 40")
case Punt(): # si és una instància de Punt
print("és un punt")
case _: # si cap condició complida (per defecte)
print("No és un punt")En versions anteriors, existixen diferents formes de realisar esta operació llògica de forma similar: Usant if, elif, else[editar | editar còdic]Podem usar l'estructura de la següent manera: >>> if condicion1:
... fer1
>>> elif condicion2:
... fer2
>>> elif condicion3:
... fer3
>>> else:
... ferEn eixa estructura s'eixecutara controlant la condicion1, si no es complix passara a la següent i aixina successivament fins a entrar en el else. Un eixemple pràctic seria: >>> def calcule(op, a, b):
... if op == 'sum':
... return a + b
... elif op == 'rest':
... return a - b
... elif op == 'mult':
... return a * b
... elif op == 'div':
... return a / b
... else:
... return None
>>>
>>> print(calcule('sum',3,4))
7def fibo(n):
''' Calcula el n-simo termine de la successió de Fibonacci,
en una funció recursiva.
'''
if n == 0:
return(0)
elif n == 1:
return(1)
elif n > 1:
return(fibo(n-1) + fibo(n-2))
else:
return(None) # Valor no valgutPodríem dir que el costat negatiu de la sentència armada en if, elif i else és que si la llista de possibles operacions és molt llarga, les té que recórrer una per una fins a aplegar a la correcta. Usant diccionaris[editar | editar còdic]Podem usar un diccionari per al mateix eixemple: >>> def calcule(op, a, b):
... return {
... 'sum': lambda: a + b,
... 'rest': lambda: a - b,
... 'mult': lambda: a * b,
... 'div': lambda: a/b
... }.get(op, lambda: None)()
>>>
>>> print(calcule('sum',3,4))
7D'esta manera, si les opcions anaren moltes, no recorreria totes; solament aniria directament a l'operació buscada en l'última llínea ( Conjunts[editar | editar còdic]
>>> conjunt_immutable = frozenset(["a", "b", "a"]) # S'utilisa una llista com a objecte iterable
>>> conjunt_immutable
frozenset(['a', 'b'])
>>> conjunt1 = set(["a", "b", "a"]) # Primer conjunt mutable
>>> conjunt1
set(['a', 'b'])
>>> conjunt2 = set(["a", "b", "c", "d"]) # Segon conjunt mutable
>>> conjunt2
set(['a', 'c', 'b', 'd']) # Els conjunts no mantenen l'orde, com els diccionaris
>>> conjunt1 & conjunt2 # Intersecció
set(['a', 'b'])
>>> conjunt1 | conjunt2 # Unió
set(['a', 'c', 'b', 'd'])
>>> conjunt1 - conjunt2 # Diferència (1)
set([])
>>> conjunt2 - conjunt1 # Diferència (2)
set(['c', 'd'])
>>> conjunt1 ^ conjunt2 # Diferència simètrica
set(['c', 'd'])Llistes per comprensió[editar | editar còdic]Una llista per comprensió (en anglés list comprehension) és una expressió compacta per a definir llistes. De la mateixa manera que >>> range(5) # La funció range torna una llista, escomençant en 0 i terminant en el número indicat menys un
[0, 1, 2, 3, 4]
>>> [i * i for i in range(5)] # Per cada element del ranc, ho multiplica per sí mateix i ho agrega al resultat
[0, 1, 4, 9, 16]
>>> llista = [(i, i + 2) for i in range(5)]
>>> llista
[(0, 2), (1, 3), (2, 4), (3, 5), (4, 6)]Funcions[editar | editar còdic]
>>> def suma(x, i=2):
... return x + i # Retornar la suma del valor de la variable "x" i el valor de "i"
...
>>> suma(4) # La variable "i" no es modifica, sent el seu valor: 2
6
>>> suma(4, 10) # La variable "i" sí es modifica, sent el seu nou valor: 10
14*args:>>> def suma(*args):
... resultat = 0
... # Es itera la tupla d'arguments
... for num in args:
... resultat += num # Suma tots els arguments
... return resultat # Retorna el resultat de la suma
...
>>> suma(2, 4)
6
>>> suma(1, 3, 5, 7, 9) # No importa el número de variables posicionals que es passen a la funció
25**kwargs:def suma(**kwargs):
... resultat = 0
... # Es itera el diccionari d'arguments
... for key, value in kwargs.items():
... resultat += value # Suma tots els valors dels arguments
... return resultat
...
>>> suma(x=1, i=3)
4
>>> suma(x=2, i=4, z=6) # No importa el número de variables per clau que es passen a la funció
12lambda:
>>> suma = lambda x, i=2: x + i
>>> suma(4) # La variable "i" no es modifica, sent el seu valor: 2
6
>>> suma(4, 10) # La variable "i" sí es modifica, sent el seu nou valor: 10
14Classes[editar | editar còdic]
>>> class Persona():
... def __init__(self, nom, edat):
... self.nom = nomene # Un atribut qualsevol
... self.edat = edat # Un atre atribut qualsevol
... def mostrar_edat(self): # És necessari que, a lo manco, tinga un paràmetro, generalment self
... print(self.edat) # mostrant un atribut
... def modificar_edat(self, edat): # Modificant edat
... if 0 > edat < 150: # Es comprova que l'edat no siga menor que 0 (alguna cosa impossible) ni major que 150 (alguna cosa realment difícil)
... return False
... else: # Si està en el ranc 0-150, llavors es modifica la variable
... self.edat = edat # Es modifica l'edat
...
>>> p = Persona('Alicia', 20) # Instanciando la classe. Com es pot vore, no s'especifica el valor de self
>>> p.nom # La variable "nom" de l'objecte sí és accessible des de fòra
'Alicia'
>>> p.nom = 'Andrea' # I per tant, es pot canviar el seu contingut
>>> p.nom
'Andrea'
>>> p.mostrar_edat() # Es diu a un método de la classe
20
>>> p.modificar_edat(21) # És possible canviar l'edat usant el método específic que hem fet per a fer-ho de forma controlada
>>> p.mostrar_edat()
21Mòduls[editar | editar còdic]Existixen moltes propietats que es poden agregar al llenguage important mòduls, conjunts de funcions i classes per a realisar determinades tasques usualment escrits també en Python. Un eixemple és el mòdul tkinter,[41] que permet crear interfaços gràfics basats en la biblioteca Tk. Un atre eixemple és el mòdul Instalació de mòduls (pip)[editar | editar còdic]L'instalació de mòduls en Python es pot realisar per mig de la ferramenta de software Pip, que sol estar inclosa en les instalacions de Python. Esta ferramenta permet la gestió dels distints paquets o mòduls instalables per a Python, incloent aixina les següents característiques:
Interfaç al sistema operatiu[editar | editar còdic]El mòdul vos proveïx funcions per a interactuar en el sistema operatiu: >>> import vos
>>> vos.name # Torna el nom del sistema operatiu
'posix'
>>> vos.mkdir("/tmp/eixemple") # Crea un directori en la ruta especificadaPer a tasques d'administració d'archius, el mòdul shutil proveïx un interfaç de més alt nivell: >>> import shutil
>>> shutil.copyfile('senyes.db', 'informacion.db')
'informacion.db'
>>> shutil.move('/build/programes', 'dir_progs')
'dir_progs'Comodins d'archius[editar | editar còdic]El mòdul glob proveïx una funció per a crear llistes d'archius a partir de busques en comodins en carpetes: >>> import glob
>>> glob.glob('*.py')
['numeros.py', 'eixemple.py', 'eixemple2.py']Arguments de llínea d'órdens[editar | editar còdic]Els arguments de llínea d'órdens s'almagasenen en l'atribut argv del mòdul sys com una llista. >>> import sys
>>> print(sys.argv)
['demostracion.py', 'un', 'dos', 'tres']Matemàtica[editar | editar còdic]El mòdul math permet accedir a les funcions de matemàtica de punt flotant: >>> import math
>>> math.cos(math.pi / 3)
0.494888338963
>>> math.log(1024, 2)
10.0El mòdul random s'utilisa per a realisar seleccions a l'encert: >>> import random
>>> random.choice(['durazno', 'poma', 'frutilla'])
'durazno'
>>> random.sample(range(100), 10) # Elecció sense tongada
[30, 23, 17, 24, 8, 81, 41, 80, 28, 13]
>>> random.random() # Un float a l'encert en l'interval [0, 1)
0.23370387692726126
>>> random.randrange(6) # Un sancer a l'encert en l'interval [0, 6)
3El mòdul statistics s'utilisa per a estadística bàsica, per eixemple: mija, mijana, varianza, etc.: >>> import statistics
>>> senyes = [1.75, 2.75, 1.25, 0.5, 0.25, 1.25, 3.5]
>>> statistics.pixen(senyes)
1.6071428571428572
>>> statistics.medien(senyes)
1.25
>>> statistics.variance(senyes)
1.3720238095238095Dates i hores[editar | editar còdic]Els mòduls clave i datetime permeten treballar en dates i hores. >>> from datetime import datetime
>>> import clave
>>> datetime.now().isoformat() # Torna la data i hora actual
'2010-08-10T18:01:17.900401'
>>> datetime.now().strftime("%I-%m-%d %H:%M:%S") # Torna la data i/o hora actual en el format especificat
'2010-08-10 18:01:17'
>>> clave.strftime("%I-%m-%d %H:%M:%S") # Método equivalent
'2010-08-10 18:01:17'Mòdul Turtle[editar | editar còdic]El mòdul turtle permet l'implementació de gràfiques tortuga: >>> import turtle
>>> turtle.pensize(2)
>>> turtle.left(120)
>>> turtle.forward(100)Polígons en el mòdul Turtle:
Sistema d'objectes[editar | editar còdic]En Python tot és un objecte (inclús les classes). Les classes, en ser objectes, són instàncies d'una metaclase. Python, ademés, soporta herència múltiple i polimorfisme. >>> cadena = "abc" # Una cadena és un objecte de "str"
>>> cadena.upper() # En ser un objecte, posseïx els seus propis métodos
'ABC'
>>> llista = [True, 3.1415] # Una llista és un objecte de "list"
>>> llista.append(42) # Una llista (de la mateixa manera que tot) és un objecte, i també posseïx els seus propis métodos
>>> llista
[True, 3.1415, 42]Biblioteca estàndar[editar | editar còdic]Python té una gran biblioteca estàndar, usada per a una diversitat de tasques. Açò ve de la filosofia «piles incloses» (batteries included) en referència als mòduls de Python. Els mòduls de la biblioteca estàndar poden complementar-se en mòduls personalisats escrits en C o en Python. Per la gran varietat de ferramentes incloses en la biblioteca estàndar, combinada en la capacitat d'usar llenguages de baix nivell com a C i C++ (els quals són capaces d'interactuar en atres biblioteques), Python és un llenguage que combina la seua clara sintaxis en l'immens poder de llenguages de més baix nivell.[43] Implementacions[editar | editar còdic]Existixen diverses implementacions del llenguage:
Incidències[editar | editar còdic]A lo llarc de la seua història, Python ha presentat una série d'incidències, de les quals les més importants han segut les següents: El 13 de febrer de 2009 es va llançar una nova versió de Python baix el nom clau «Python 3000» o,[44] abreviat, «Py3K».[45] Esta nova versió inclou toda una serie de canvis que requerixen reescriure el còdic de versions anteriors. Per a facilitar este procés, junt en Python 3 s'ha publicat una ferramenta de traducció automàtica cridada 2to3.[46][47]
Vore també[editar | editar còdic]
Referències[editar | editar còdic]Bibliografia[editar | editar còdic]Enllaços externs[editar | editar còdic]
Referències[editar | editar còdic]
|
- Pàgines en erros de resaltat de sintaxis
- Pàgines en erros de referència
- Python
- Llenguages de programació orientada a objectes
- Llenguages de programació d'alt nivell
- Llenguages de programació dinàmicament tipados
- Llenguages de programació educatius
- Software de 1991
- Països Baixos en 1991
- Ciència i tecnologia dels Països Baixos
- Llenguatges de programació d'alt nivell
- Llenguatges de programació dinàmicament tipats