Vad är nytt i Python 3.0¶
- Författare:
Guido van Rossum
I den här artikeln förklaras de nya funktionerna i Python 3.0 jämfört med 2.6. Python 3.0, även känd som ”Python 3000” eller ”Py3K”, är den första någonsin avsiktligt bakåtkompatibla Python-versionen. Python 3.0 släpptes den 3 december 2008. Det finns fler ändringar än i en vanlig version, och fler som är viktiga för alla Python-användare. Ändå, efter att ha smält förändringarna, kommer du att upptäcka att Python verkligen inte har förändrats så mycket - i stort sett fixar vi mest välkända irritationer och vårtor och tar bort en hel del gammal cruft.
Den här artikeln försöker inte ge en fullständig specifikation av alla nya funktioner, utan försöker i stället ge en praktisk översikt. För fullständig information hänvisas till dokumentationen för Python 3.0 och/eller de många PEP:er som refereras till i texten. Om du vill förstå den fullständiga implementeringen och designrationaliteten för en viss funktion, har PEPs vanligtvis mer detaljer än den vanliga dokumentationen; men observera att PEPs vanligtvis inte hålls uppdaterade när en funktion har implementerats fullt ut.
På grund av tidsbrist är detta dokument inte så komplett som det borde ha varit. Som alltid när det gäller en ny version innehåller filen Misc/NEWS
i källdistributionen en mängd detaljerad information om varje liten sak som har ändrats.
Vanliga stötestenar¶
I det här avsnittet listas de få ändringar som troligen kommer att göra dig förvirrad om du är van vid Python 2.5.
Print är en funktion¶
Satsen print
har ersatts med funktionen print()
, med nyckelordsargument som ersätter de flesta av de speciella syntaxerna i den gamla satsen print
(PEP 3105). Exempel:
Gammal: print "Svaret är", 2*2
Ny: print("Svaret är", 2*2)
Gammal: print x, # Efterföljande kommatecken undertrycker ny rad
Nytt: print(x, end=" ") # Lägger till ett mellanslag istället för en ny rad
Gammal: print # Skriver ut en ny rad
Ny: print() # Du måste anropa funktionen!
Gammal: print >>sys.stderr, "fatalt fel"
Ny: print("fatalt fel", file=sys.stderr)
Gammal: print (x, y) # printar repr((x, y))
Nytt: print((x, y)) # Inte samma sak som print(x, y)!
Du kan också anpassa avgränsningen mellan objekten, t.ex.:
print("Det finns <", 2**32, "> möjligheter!", sep="")
som producerar:
Det finns <4294967296> möjligheter!
Anteckning:
Funktionen
print()
stöder inte ”softspace”-funktionen i det gamlaprint
-slutsatsen. Till exempel, i Python 2.x, skulleprint "A\n", "B"
skriva"A\nB\n"
; men i Python 3.0,print("A\n", "B")
skriver"A\n B\n"
.Till en början kommer du att skriva det gamla
print x
ofta i interaktivt läge. Dags att lära om fingrarna till att skrivaprint(x)
istället!När du använder konverteringsverktyget
2to3
från källa till källa konverteras allaprint
-satser automatiskt tillprint()
-funktionsanrop, så detta är oftast en icke-fråga för större projekt.
Vyer och iteratorer istället för listor¶
Vissa välkända API:er returnerar inte längre listor:
dict
-metodernadict.keys()
,dict.items()
ochdict.values()
returnerar ”views” istället för listor. Till exempel fungerar inte detta längre:k = d.keys(); k.sort()
. Användk = sorted(d)
istället (detta fungerar även i Python 2.5 och är lika effektivt).Dessutom stöds inte längre metoderna
dict.iterkeys()
,dict.iteritems()
ochdict.itervalues()
.map()
ochfilter()
returnerar iteratorer. Om du verkligen behöver en lista och indatasekvenserna alla är lika långa, är en snabb lösning att linda inmap()
ilist()
, t.ex.list(map(...))
, men en bättre lösning är ofta att använda en listförståelse (speciellt när den ursprungliga koden använderlambda
), eller att skriva om koden så att den inte behöver en lista alls. Särskilt knepigt ärmap()
som används för funktionens bieffekter; den korrekta transformationen är att använda en vanligfor
-loop (eftersom det bara skulle vara slöseri att skapa en lista).Om indatasekvenserna inte är lika långa kommer
map()
att stanna vid slutet av den kortaste av sekvenserna. För full kompatibilitet medmap()
från Python 2.x, linda även in sekvenserna iitertools.zip_longest()
, t.ex.map(func, *sequences)
blirlist(map(func, itertools.zip_longest(*sequences)))
.range()
beter sig nu somxrange()
brukade bete sig, förutom att den fungerar med värden av godtycklig storlek. Den senare finns inte längre.zip()
returnerar nu en iterator.
Beställning av jämförelser¶
Python 3.0 har förenklat reglerna för att beställa jämförelser:
Jämförelseoperatorerna för ordningsföljd (
<
,<=
,>=
,>
) ger upphov till ett TypeError-undantag när operanderna inte har en meningsfull naturlig ordningsföljd. Således är uttryck som1 < ''
,0 > None
ellerlen <= len
inte längre giltiga, och t.ex.None < None
ger upphov tillTypeError
istället för att returneraFalse
. En följd av detta är att det inte längre är meningsfullt att sortera en heterogen lista – alla element måste vara jämförbara med varandra. Observera att detta inte gäller för operatorerna==
och!=
: objekt av olika ojämförbara typer jämförs alltid ojämlikt med varandra.sorted()
ochlist.sort()
accepterar inte längre cmp-argumentet som ger en jämförelsefunktion. Använd key-argumentet istället. OBS: Argumenten key och reverse är nu ”endast nyckelord”.Funktionen
cmp()
bör betraktas som borta, och specialmetoden__cmp__()
stöds inte längre. Använd__lt__()
för sortering,__eq__()
med__hash__()
och andra jämförelser efter behov. (Om du verkligen behövercmp()
-funktionaliteten kan du använda uttrycket(a > b) - (a < b)
som motsvarighet tillcmp(a, b)
)
Heltal¶
PEP 237: I huvudsak har
long
bytt namn tillint
. Det vill säga, det finns bara en inbyggd integraltyp, som heterint
; men den beter sig mestadels som den gamlalong
-typen.PEP 238: Ett uttryck som
1/2
returnerar en float. Använd1//2
för att få det trunkerande beteendet. (Den senare syntaxen har funnits i flera år, åtminstone sedan Python 2.2.)Konstanten
sys.maxint
togs bort, eftersom det inte längre finns någon gräns för värdet på heltal. Däremot kansys.maxsize
användas som ett heltal som är större än alla praktiska index för listor eller strängar. Det överensstämmer med implementationens ”naturliga” heltalsstorlek och är vanligtvis detsamma somsys.maxint
i tidigare utgåvor på samma plattform (med samma byggalternativ).repr()
av ett långt heltal inkluderar inte längre det efterföljandeL
, så kod som ovillkorligen tar bort det tecknet kommer att hugga bort den sista siffran istället. (Användstr()
istället.)Octal-literaler är inte längre av formen
0720
; använd0o720
istället.
Text vs. Data istället för Unicode vs. 8-bitars¶
Allt du trodde att du visste om binärdata och Unicode har förändrats.
Python 3.0 använder begreppen text och (binär) data istället för Unicode-strängar och 8-bitarssträngar. All text är Unicode, men kodad Unicode representeras som binär data. Den typ som används för att hålla text är
str
, den typ som används för att hålla data ärbytes
. Den största skillnaden med 2.x-situationen är att alla försök att blanda text och data i Python 3.0 ger upphov tillTypeError
, medan om du skulle blanda Unicode och 8-bitars strängar i Python 2.x, skulle det fungera om 8-bitars strängen råkade innehålla endast 7-bitars (ASCII) byte, men du skulle fåUnicodeDecodeError
om den innehöll icke-ASCII-värden. Detta värdespecifika beteende har orsakat många ledsna miner genom åren.Som en konsekvens av denna filosofiska förändring måste i stort sett all kod som använder Unicode, kodningar eller binära data sannolikt ändras. Förändringen är till det bättre, eftersom det i 2.x-världen fanns många buggar som hade att göra med att blanda kodad och okodad text. För att vara förberedd i Python 2.x, börja med att använda
unicode
för all okodad text ochstr
endast för binär eller kodad data. Då kommer verktyget2to3
att göra det mesta av arbetet åt dig.Du kan inte längre använda
u"..."
-litteraler för Unicode-text. Du måste dock användab"..."
-litteraler för binära data.Eftersom typerna
str
ochbytes
inte kan blandas måste du alltid uttryckligen konvertera mellan dem. Användstr.encode()
för att gå frånstr
tillbytes
, ochbytes.decode()
för att gå frånbytes
tillstr
. Du kan också användabytes(s, encoding=...)
respektivestr(b, encoding=...)
.Precis som
str
är typenbytes
oföränderlig. Det finns en separat föränderlig typ för att hålla buffrade binära data,bytearray
. Nästan alla API:er som accepterarbytes
accepterar ocksåbytearray
. Det mutabla API:et är baserat påcollections.MutableSequence
.Alla backslashes i råa stränglitteraler tolkas bokstavligt. Detta innebär att
'\U'
och'\u'
escapes i råa strängar inte behandlas speciellt. Till exempel ärr'\u20ac'
en sträng med 6 tecken i Python 3.0, medan i 2.6 varur'\u20ac'
det enda ”euro”-tecknet. (Naturligtvis påverkar denna förändring endast råa stränglitteraler; eurotecknet är'\u20ac'
i Python 3.0.)Den inbyggda abstrakta typen
basestring
togs bort. Användstr
istället. Typernastr
ochbytes
har inte tillräckligt många gemensamma funktioner för att motivera en gemensam basklass. Verktyget2to3
(se nedan) ersätter varje förekomst avbasestring
medstr
.Filer som öppnas som textfiler (fortfarande standardläget för
open()
) använder alltid en kodning för att mappa mellan strängar (i minnet) och byte (på disken). Binära filer (öppnade med ettb
i lägesargumentet) använder alltid byte i minnet. Det innebär att om en fil öppnas med fel läge eller kodning kommer I/O sannolikt att misslyckas, istället för att i tysthet producera felaktiga data. Det innebär också att även Unix-användare måste ange rätt läge (text eller binärt) när de öppnar en fil. Det finns en plattformsberoende standardkodning som på Unix-plattformar kan ställas in med miljövariabelnLANG
(och ibland även med några andra plattformsspecifika lokalrelaterade miljövariabler). I många fall, men inte alla, är systemets standard UTF-8; du bör aldrig räkna med denna standard. Alla program som läser eller skriver mer än ren ASCII-text bör förmodligen ha ett sätt att åsidosätta kodningen. Det finns inte längre något behov av att använda de kodningsmedvetna strömmarna i modulencodecs
.De initiala värdena för
sys.stdin
,sys.stdout
ochsys.stderr
är nu textfiler med endast en kod (dvs. de är instanser avio.TextIOBase
). För att läsa och skriva bytesdata med dessa strömmar måste du använda derasio.TextIOBase.buffer
-attribut.Filnamn skickas till och returneras från API:er som (Unicode)-strängar. Detta kan medföra plattformsspecifika problem eftersom filnamn på vissa plattformar är godtyckliga byte-strängar. (Som en lösning accepterar de flesta API:er (t.ex.
open()
och många funktioner i modulenos
) som tar emot filnamnbytes
-objekt såväl som strängar, och några API:er har ett sätt att be om ettbytes
-returvärde. Således returneraros.listdir()
en lista överbytes
-instanser om argumentet är enbytes
-instans, ochos.getcwdb()
returnerar den aktuella arbetskatalogen som enbytes
-instans. Observera att näros.listdir()
returnerar en lista med strängar, utelämnas filnamn som inte kan avkodas korrekt i stället för att ge upphov tillUnicodeError
.Vissa system-API:er som
os.environ
ochsys.argv
kan också ge problem när de byte som görs tillgängliga av systemet inte kan tolkas med hjälp av standardkodningen. Att ställa in variabelnLANG
och köra programmet på nytt är förmodligen det bästa tillvägagångssättet.PEP 3138:
repr()
av en sträng escapar inte längre icke-ASCII-tecken. Den escapar dock fortfarande kontrolltecken och kodpunkter med icke-utskrivbar status i Unicode-standarden.PEP 3120: Standardkodningen för källan är nu UTF-8.
PEP 3131: Icke-ASCII-bokstäver är nu tillåtna i identifierare. (Standardbiblioteket är dock fortfarande ASCII-only, med undantag för namn på bidragsgivare i kommentarer)
Modulerna
StringIO
ochcStringIO
är borta. Istället importerar du modulenio
och använderio.StringIO
ellerio.BytesIO
för text respektive data.Se även Unicode HOWTO, som uppdaterades för Python 3.0.
Översikt över syntaxändringar¶
Detta avsnitt ger en kort översikt över varje syntaktisk förändring i Python 3.0.
Ny syntax¶
PEP 3107: Annoteringar för funktionens argument och returvärde. Detta ger ett standardiserat sätt att kommentera en funktions parametrar och returvärde. Det finns ingen semantik kopplad till sådana annoteringar förutom att de kan introspekteras vid körning med hjälp av attributet
__annotations__
. Avsikten är att uppmuntra experimenterande genom metaklasser, dekoratorer eller ramverk.PEP 3102: Endast nyckelordsargument. Namngivna parametrar som förekommer efter
*args
i parameterlistan måste anges med nyckelordssyntax i anropet. Du kan också använda en naken*
i parameterlistan för att ange att du inte accepterar en argumentlista med variabel längd, men att du har argument som endast innehåller nyckelord.Nyckelord som argument tillåts efter listan över basklasser i en klassdefinition. Detta används av den nya konventionen för att specificera en metaklass (se nästa avsnitt), men kan användas för andra ändamål också, så länge metaklassen stöder det.
PEP 3104:
nonlocal
uttalande. Mednonlocal x
kan du nu tilldela direkt till en variabel i ett yttre (men icke-globalt) scope.nonlocal
är ett nytt reserverat ord.PEP 3132: Utökad uppackning av Iterable. Du kan nu skriva saker som
a, b, *rest = some_sequence
. Och till och med*rest, a = stuff
. Objektetrest
är alltid en (eventuellt tom) lista; den högra sidan kan vara vilken iterabel som helst. Exempel:(a, *rest, b) = intervall(5)
Detta sätter a till
0
, b till4
och rest till[1, 2, 3]
.Ordboksförståelse:
{k: v for k, v in stuff}
betyder samma sak somdict(stuff)
men är mer flexibelt. (Detta är PEP 274 bekräftat. :-)Mängdlitteraler, t.ex.
{1, 2}
. Observera att{}
är en tom ordlista; användset()
för en tom uppsättning. Uppsättningsförståelse stöds också; t.ex. betyder{x for x in stuff}
samma sak somset(stuff)
men är mer flexibelt.Nya oktala literaler, t.ex.
0o720
(redan i 2.6). De gamla oktalliteralerna (0720
) är borta.Nya binära literaler, t.ex.
0b1010
(redan i 2.6), och det finns en ny motsvarande inbyggd funktion,bin()
.Byteslitteraler introduceras med en ledande
b
ellerB
, och det finns en ny motsvarande inbyggd funktion,bytes()
.
Ändrad syntax¶
PEP 3109 och PEP 3134: Ny
raise
-syntax för satser:raise [expr [från expr]]
. Se nedan.as
ochwith
är nu reserverade ord. (Sedan 2.6, faktiskt.)True
,False
ochNone
är reserverade ord. (2.6 tillämpade delvis restriktionerna förNone
redan)Ändra från
except
exc, var tillexcept
excas
var. Se PEP 3110.PEP 3115: Ny syntax för metaklasser. Istället för:
klass C: __metaklass__ = M ...
måste du nu använda:
klass C(metaklass=M): ...
Den modulglobala variabeln
__metaclass__
stöds inte längre. (Den var en krycka för att göra det lättare att använda nya klasser som standard utan att härleda alla klasser frånobject
)Listförståelser stöder inte längre den syntaktiska formen
[... för var i item1, item2, ...]
. Använd[... for var in (item1, item2, ...)]
i stället. Observera också att listcomprehensions har en annan semantik: de är närmare syntaktiskt socker för ett generatoruttryck inuti enlist()
-konstruktor, och i synnerhet läcker inte längre loopkontrollvariablerna ut i det omgivande omfånget.ellips (
...
) kan användas som ett atomiskt uttryck var som helst. (Tidigare var det bara tillåtet i slices.) Dessutom måste det nu stavas som...
. (Tidigare kunde det också stavas som. .
, av en ren olyckshändelse i grammatiken)
Borttagen syntax¶
PEP 3113: Uppackning av tuple-parametrar borttagen. Du kan inte längre skriva
def foo(a, (b, c)): ...
. Använddef foo(a, b_c): b, c = b_c
istället.Tog bort bakvända apostrofer (använd
repr()
istället).Borttagen
<>
(använd!=
istället).Borttaget nyckelord:
exec()
är inte längre ett nyckelord; det finns kvar som en funktion. (Lyckligtvis accepterades funktionssyntaxen även i 2.x.) Observera också attexec()
inte längre tar ett stream-argument; istället förexec(f)
kan du användaexec(f.read())
.Heltalslitteraler stöder inte längre en efterföljande
l
ellerL
.Stränglitteraler stöder inte längre en ledande
u
ellerU
.Syntaxen
from
moduleimport
*
är endast tillåten på modulnivå, inte längre inuti funktioner.Den enda acceptabla syntaxen för relativ import är
from .[module] import name
. Allaimport
-former som inte börjar med.
tolkas som absolut import. (PEP 328)Klassiska klasser är borta.
Ändringar som redan finns i Python 2.6¶
Eftersom många användare förmodligen hoppar direkt från Python 2.5 till Python 3.0, påminner det här avsnittet läsaren om nya funktioner som ursprungligen utformades för Python 3.0, men som portades tillbaka till Python 2.6. Motsvarande avsnitt i Vad är nytt i Python 2.6 bör konsulteras för längre beskrivningar.
PEP 343: Uttalandet ”med. Satsen
with
är nu en standardfunktion och behöver inte längre importeras från__future__
. Kolla även in Skriva för kontextansvariga och Modulen contextlib.PEP 366: Explicit relativistisk import från en huvudmodul. Detta ökar användbarheten av alternativet
-m
när den refererade modulen finns i ett paket.PEP 3101: Avancerad strängformatering. Observera: I beskrivningen för 2.6 nämns metoden
format()
för både 8-bitars och Unicode-strängar. I 3.0 är det bara typenstr
(textsträngar med Unicode-stöd) som stöder den här metoden; typenbytes
gör det inte. Planen är att så småningom göra detta till det enda API:et för strängformatering och att börja avskriva operatorn%
i Python 3.1.PEP 3105: print som funktion. Detta är nu en standardfunktion och behöver inte längre importeras från
__future__
. Mer detaljer gavs ovan.PEP 3110: Ändringar i undantagshantering. Syntaxen
except
excas
var är nu standard ochexcept
exc, var stöds inte längre. (Naturligtvis äras
var-delen fortfarande valfri)PEP 3112: Bytebokstäver. Strängnotationen
b"..."
(och dess varianter somb'...'
,b""..."""
ochbr"..."
) producerar nu en bokstav av typenbytes
.PEP 3116: Nytt I/O-bibliotek. Modulen
io
är nu standardmetoden för att göra fil-I/O. Den inbyggda funktionenopen()
är nu ett alias förio.open()
och har ytterligare nyckelordsargument encoding, errors, newline och closefd. Observera också att ett ogiltigt mode-argument nu ger upphov tillValueError
, inteIOError
. Det binära filobjektet som ligger till grund för ett textfilobjekt kan nås medf.buffer
(men tänk på att textobjektet upprätthåller en buffert av sig självt för att snabba upp kodnings- och avkodningsoperationerna).PEP 3118: Reviderat buffertprotokoll. Den gamla inbyggda
buffer()
är nu verkligen borta; den nya inbyggdamemoryview()
ger (mestadels) liknande funktionalitet.PEP 3119: Abstrakta basklasser. Modulen
abc
och de ABC som definieras i modulencollections
spelar en något mer framträdande roll i språket nu, och inbyggda samlingstyper somdict
ochlist
överensstämmer med ABC:ernacollections.MutableMapping
respektivecollections.MutableSequence
.PEP 3127: Stöd för heltalsbokstäver och syntax. Som nämnts ovan är den nya oktala bokstavsnoteringen den enda som stöds, och binära bokstäver har lagts till.
PEP 3141: En typhierarki för siffror. Modulen
numbers
är en annan ny användning av ABC, som definierar Pythons ”numeriska torn”. Notera också den nyafractions
-modulen som implementerarnumbers.Rational
.
Förändringar i biblioteket¶
På grund av tidsbegränsningar täcker detta dokument inte uttömmande de mycket omfattande ändringarna av standardbiblioteket. PEP 3108 är referensen för de större ändringarna av biblioteket. Här är en kortfattad genomgång:
Många gamla moduler togs bort. Vissa, som
gopherlib
(används inte längre) ochmd5
(ersatt avhashlib
), var redan utfasade av PEP 4. Andra togs bort som ett resultat av att stödet för olika plattformar som Irix, BeOS och Mac OS 9 togs bort (se PEP 11). Vissa moduler valdes också ut för borttagning i Python 3.0 på grund av brist på användning eller för att en bättre ersättning finns. Se PEP 3108 för en uttömmande lista.Paketet
bsddb3
togs bort eftersom dess närvaro i det centrala standardbiblioteket med tiden har visat sig vara en särskild börda för de centrala utvecklarna på grund av instabila tester och Berkeley DB:s utgivningsschema. Paketet lever dock vidare och underhålls externt på https://www.jcea.es/programacion/pybsddb.htm.Vissa moduler döptes om eftersom deras gamla namn inte lydde PEP 8, eller av olika andra skäl. Här är listan:
Gammalt namn
Nytt namn
_winreg
winreg
KonfigParser
configparser
kopiera_reg
copyreg
Köa
kö
SocketServer
socketserver
markupbas
_markupbase
repr
reprlib
test.test_support
test.support
Ett vanligt mönster i Python 2.x är att ha en version av en modul implementerad i ren Python, med en valfri accelererad version implementerad som ett C-tillägg; till exempel
pickle
ochcPickle
. Detta innebär att varje användare av dessa moduler måste importera den snabbare versionen och återgå till den rena Python-versionen. I Python 3.0 betraktas de accelererade versionerna som implementeringsdetaljer av de rena Python-versionerna. Användare bör alltid importera standardversionen, som försöker importera den accelererade versionen och faller tillbaka på den rena Python-versionen. Paretpickle
/cPickle
fick denna behandling. Modulenprofile
finns med på listan för 3.1. ModulenStringIO
har gjorts om till en klass i modulenio
.Vissa relaterade moduler har grupperats i paket, och vanligtvis har namnen på undermodulerna förenklats. De resulterande nya paketen är:
dbm
(anydbm
,dbhash
,dbm
,dumbdbm
,gdbm
,whichdb
).html
(HTMLParser
,htmlentitydefs
).http
(httplib
,BaseHTTPServer
,CGIHTTPServer
,SimpleHTTPServer
,Cookie
,cookielib
).tkinter
(allaTkinter
-relaterade moduler utomturtle
). Målgruppen förturtle
bryr sig egentligen inte omtkinter
. Observera också att från och med Python 2.6 har funktionaliteten iturtle
förbättrats avsevärt.urllib
(urllib
,urllib2
,urlparse
,robotparse
).xmlrpc
(xmlrpclib
,DocXMLRPCServer
,SimpleXMLRPCServer
).
Några andra ändringar i standardbiblioteksmoduler, som inte täcks av PEP 3108:
Dödade
sets
. Använd den inbyggdaset()
-klassen.Rensning av modulen
sys
: tog bortsys.exitfunc()
,sys.exc_clear()
,sys.exc_type
,sys.exc_value
,sys.exc_traceback
. (Observera attsys.last_type
etc. kvarstår)Uppstädning av typen
array.array
: metodernaread()
ochwrite()
är borta; användfromfile()
ochtofile()
istället. Dessutom är typkoden'c'
för array borta – använd antingen'b'
för bytes eller'u'
för Unicode-tecken.Uppstädning av modulen
operator
: tog bortsequenceIncludes()
ochisCallable()
.Uppstädning av modulen
thread
:acquire_lock()
ochrelease_lock()
är borta; användacquire()
ochrelease()
istället.Rensning av modulen
random
: tog bort API:etjumpahead()
.Modulen
new
är borta.Funktionerna
os.tmpnam()
,os.tempnam()
ochos.tmpfile()
har tagits bort till förmån för modulentempfile
.Modulen
tokenize
har ändrats för att fungera med bytes. Den huvudsakliga ingångspunkten är nutokenize.tokenize()
, istället för generate_tokens.string.letters
och dess vänner (string.lowercase
ochstring.uppercase
) är borta. Användstring.ascii_letters
etc. istället. (Anledningen till borttagandet är attstring.letters
och dess vänner hade ett lokalspecifikt beteende, vilket är en dålig idé för globala ”konstanter” med så attraktiva namn)Döpte om modulen
__builtin__
tillbuiltins
(tar bort understrecken och lägger till ett ’s’). Variabeln__builtins__
som finns i de flesta globala namnrymder är oförändrad. För att modifiera en builtin bör du användabuiltins
, inte__builtins__
!
PEP 3101: En ny metod för strängformatering¶
Ett nytt system för inbyggda strängformateringsoperationer ersätter strängformateringsoperatorn
%
. (Operatorn%
stöds dock fortfarande; den kommer att avskrivas i Python 3.1 och tas bort från språket vid en senare tidpunkt) Läs PEP 3101 för hela scoopet.
Ändringar av undantag¶
API:erna för att skapa och fånga upp undantag har rensats upp och nya kraftfulla funktioner har lagts till:
PEP 352: Alla undantag måste härledas (direkt eller indirekt) från
BaseException
. Detta är roten i undantagshierarkin. Detta är inte nytt som en rekommendation, men kravet att ärva frånBaseException
är nytt. (Python 2.6 tillät fortfarande att klassiska klasser togs upp, och lade ingen begränsning på vad du kan fånga) Som en följd av detta är strängundantag äntligen helt och hållet döda.Nästan alla undantag bör egentligen härledas från
Exception
;BaseException
bör endast användas som basklass för undantag som endast bör hanteras på högsta nivå, t.ex.SystemExit
ellerKeyboardInterrupt
. Det rekommenderade idiomet för att hantera alla undantag utom denna senare kategori är att användaexcept
Exception
.StandardError
togs bort.Undantag beter sig inte längre som sekvenser. Använd istället attributet
args
.PEP 3109: Upphävande av undantag. Du måste nu använda
raise Exception(args)
istället förraise Exception, args
. Dessutom kan du inte längre uttryckligen ange en traceback; om du måste göra detta kan du istället tilldela direkt till attributet__traceback__
(se nedan).PEP 3110: Fånga upp undantag. Du måste nu använda
except SomeException as variable
istället förexcept SomeException, variable
. Dessutom raderas variabeln explicit närexcept
-blocket lämnas.PEP 3134: Kedjning av undantag. Det finns två fall: implicit kedjning och explicit kedjning. Implicit kedjning sker när ett undantag tas upp i ett
except
ellerfinally
hanterarblock. Detta sker vanligtvis på grund av en bugg i hanterarblocket; vi kallar detta för ett sekundärt undantag. I det här fallet sparas det ursprungliga undantaget (som hanterades) som attributet__context__
för det sekundära undantaget. Explicit kedjning görs med denna syntax:raise SecondaryException() från primary_exception
(där primary_exception är vilket uttryck som helst som producerar ett undantagsobjekt, förmodligen ett undantag som tidigare fångats upp). I det här fallet lagras det primära undantaget i attributet
__cause__
för det sekundära undantaget. Den spårning som skrivs ut när ett ohanterat undantag inträffar går genom kedjan av attributen__cause__
och__context__
och skriver ut en separat spårning för varje komponent i kedjan, med det primära undantaget högst upp. (Java-användare kanske känner igen det här beteendet)PEP 3134: Exception-objekt lagrar nu sin traceback som attributet
__traceback__
. Detta innebär att ett undantagsobjekt nu innehåller all information om ett undantag och att det finns färre anledningar att användasys.exc_info()
(även om den senare inte har tagits bort).Några undantagsmeddelanden har förbättrats när Windows misslyckas med att ladda en tilläggsmodul. Till exempel är
felkod 193
nu%1 är inte en giltig Win32-applikation
. Strängar hanterar nu icke-engelska lokala språk.
Övrigt Övriga förändringar¶
Operatorer och specialmetoder¶
!=
returnerar nu motsatsen till==
, såvida inte==
returnerarNotImplemented
.Begreppet ”obundna metoder” har tagits bort från språket. När man refererar till en metod som ett klassattribut får man nu ett vanligt funktionsobjekt.
__getslice__()
,__setslice__()
och__delslice__()
dödades. Syntaxena[i:j]
översätts nu tilla.__getitem__(slice(i, j))
(eller__setitem__()
eller__delitem__()
, när den används som ett tilldelnings- respektive raderingsmål).PEP 3114: standardmetoden
next()
har bytt namn till__next__()
.Specialmetoderna
__oct__()
och__hex__()
har tagits bort –oct()
ochhex()
använder nu__index__()
för att konvertera argumentet till ett heltal.Borttaget stöd för
__members__
och__methods__
.Funktionsattributen med namnet
func_X
har bytt namn till__X__
, vilket frigör dessa namn i namnrymden för funktionsattribut för användardefinierade attribut. Således harfunc_closure
,func_code
,func_defaults
,func_dict
,func_doc
,func_globals
,func_name
bytt namn till__closure__
,__code__
,__defaults__
,__dict__
,__doc__
,__globals__
,__name__
, respektive.__nonzero__()
är nu__bool__()
.
Inbyggnader¶
PEP 3135: Ny
super()
. Du kan nu anropasuper()
utan argument och (förutsatt att detta är i en vanlig instansmetod definierad i enclass
-sats) rätt klass och instans kommer automatiskt att väljas. Med argument är beteendet hossuper()
oförändrat.PEP 3111:
raw_input()
har bytt namn tillinput()
. Det innebär att den nya funktioneninput()
läser en rad frånsys.stdin
och returnerar den med den efterföljande nya raden borttagen. Den ger upphov tillEOFError
om inmatningen avslutas i förtid. För att få det gamla beteendet hosinput()
, användeval(input())
.En ny inbyggd funktion
next()
lades till för att anropa metoden__next__()
på ett objekt.Avrundningsstrategin och returtypen för funktionen
round()
har ändrats. Exakta halvvägsfall avrundas nu till närmaste jämna resultat istället för bort från noll. (Till exempel returnerarround(2,5)
nu2
i stället för3
.)round(x[, n])
delegerar nu tillx.__round__([n])
istället för att alltid returnera en float. Den returnerar i allmänhet ett heltal när den anropas med ett enda argument och ett värde av samma typ somx
när den anropas med två argument.Flyttat
intern()
tillsys.intern()
.Borttaget:
apply()
. Istället förapply(f, args)
användf(*args)
.Tog bort
callable()
. Istället förcallable(f)
kan du användaisinstance(f, collections.Callable)
. Funktionenoperator.isCallable()
är också borta.Tog bort
coerce()
. Denna funktion fyller inte längre något syfte nu när klassiska klasser har försvunnit.Tog bort
execfile()
. Istället förexecfile(fn)
användexec(open(fn).read())
.Tog bort
file
-typen. Användopen()
. Det finns nu flera olika typer av strömmar som open kan returnera i modulenio
.Tog bort
reduce()
. Användfunctools.reduce()
om du verkligen behöver det, men 99 procent av tiden är en explicitfor
-loop mer läsbar.Tog bort
reload()
. Användimp.reload()
.Borttagen.
dict.has_key()
– använd operatornin
istället.
Ändringar i Build och C API¶
På grund av tidsbrist följer här en mycket ofullständig lista över ändringar i C API.
Stöd för flera plattformar togs bort, inklusive men inte begränsat till Mac OS 9, BeOS, RISCOS, Irix och Tru64.
PEP 3118: Nytt buffert-API.
PEP 3121: Initialisering och slutförande av tilläggsmodul.
PEP 3123: Anpassning av
PyObject_HEAD
till standard C.Inget mer C API-stöd för begränsad exekvering.
c API:erna
PyNumber_Coerce()
,PyNumber_CoerceEx()
,PyMember_Get()
ochPyMember_Set()
tas bort.Nytt C API
PyImport_ImportModuleNoBlock()
, fungerar somPyImport_ImportModule()
men blockerar inte importlåset (returnerar ett fel istället).Byt namn på C-nivå slot och metod för boolesk konvertering:
nb_nonzero
är nunb_bool
.Tog bort
METH_OLDARGS
ochWITH_CYCLE_GC
från C API.
Prestanda¶
Nettoresultatet av 3.0-generaliseringarna är att Python 3.0 kör pystone-riktmärket cirka 10% slägre än Python 2.5. Den största orsaken är troligen borttagandet av special-casing för små heltal. Det finns utrymme för förbättringar, men det kommer att ske efter att 3.0 har släppts!
Portning till Python 3.0¶
För portning av befintlig Python 2.5 eller 2.6 källkod till Python 3.0 är den bästa strategin följande:
(Förkunskapskrav:) Börja med utmärkt testtäckning.
Porta till Python 2.6. Detta bör inte vara mer arbete än den genomsnittliga porten från Python 2.x till Python 2.(x+1). Se till att alla dina tester godkänns.
(Använder fortfarande 2.6:) Slå på kommandoradsväxeln
-3
. Detta aktiverar varningar om funktioner som kommer att tas bort (eller ändras) i 3.0. Kör din testsvit igen och fixa kod som du får varningar om tills det inte finns några varningar kvar och alla dina tester fortfarande är godkända.Kör
2to3
käll-till-källa-översättaren över ditt källkodsträd. Kör resultatet av översättningen under Python 3.0. Fixa manuellt upp eventuella kvarvarande problem, fixa problem tills alla tester godkänns igen.
Det är inte rekommenderat att försöka skriva källkod som körs oförändrad under både Python 2.6 och 3.0; du skulle behöva använda en mycket förvrängd kodningsstil, t.ex. undvika print
-satser, metaklasser och mycket mer. Om du underhåller ett bibliotek som behöver stödja både Python 2.6 och Python 3.0, är det bästa tillvägagångssättet att ändra steg 3 ovan genom att redigera 2.6-versionen av källkoden och köra 2to3
-översättaren igen, snarare än att redigera 3.0-versionen av källkoden.
För portning av C-tillägg till Python 3.0, se Portning av tilläggsmoduler till Python 3.