Python Language Zelfstudie
Aan de slag met Python Language

Opmerkingen

versies

Ermee beginnen

Python is een veel gebruikte programmeertaal op hoog niveau voor algemene programmering, gemaakt door Guido van Rossum en voor het eerst uitgebracht in 1991. Python heeft een dynamisch type systeem en automatisch geheugenbeheer en ondersteunt meerdere programmeerparadigma's, waaronder objectgeoriënteerd, imperatief, functioneel programmeren en procedurele stijlen. Het heeft een grote en uitgebreide standaardbibliotheek.

Twee belangrijke versies van Python worden momenteel actief gebruikt:

• Python 3.x is de huidige versie en is in actieve ontwikkeling.
• Python 2.x is de oude versie en ontvangt tot 2020 alleen beveiligingsupdates. Er worden geen nieuwe functies geïmplementeerd. Merk op dat veel projecten nog steeds Python 2 gebruiken, hoewel migreren naar Python 3 gemakkelijker wordt.

U kunt beide versies van Python hier downloaden en installeren. Zie Python 3 versus Python 2 voor een vergelijking tussen hen. Daarnaast bieden sommige derde partijen opnieuw verpakte versies van Python die veelgebruikte bibliotheken en andere functies toevoegen om de installatie voor veelvoorkomende gebruikssituaties, zoals wiskunde, gegevensanalyse of wetenschappelijk gebruik, te vergemakkelijken. Zie de lijst op de officiële site .

Controleer of Python is geïnstalleerd

Om te bevestigen dat Python correct is geïnstalleerd, kunt u verifiëren dat u de volgende opdracht uitvoert in uw favoriete terminal (als u Windows OS gebruikt, moet u het pad van python toevoegen aan de omgevingsvariabele voordat u het in de opdrachtprompt gebruikt):

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

Als u Python 3 hebt geïnstalleerd, maar $ python --version een Python 2-versie $ python --version , hebt u ook Python 2 geïnstalleerd. Dit is vaak het geval op MacOS en veel Linux-distributies. Gebruik in plaats daarvan $ python3 om expliciet de Python 3-interpreter te gebruiken.

Hallo, World in Python met IDLE

IDLE is een eenvoudige editor voor Python, gebundeld met Python.

Hoe Hello, World-programma in IDLE te maken

• Open IDLE op het gewenste systeem.
  • In oudere versies van Windows is dit te vinden bij All Programs in het Windows-menu.
  • Zoek in Windows 8+ naar IDLE of vind het in de apps die op uw systeem aanwezig zijn.
  • Op Unix-gebaseerde (inclusief Mac) systemen kunt u het vanuit de shell openen door $ idle python_file.py typen.
• Het opent een shell met opties bovenaan.

In de schaal zit een prompt van drie rechte hoekbeugels:

>>>

Schrijf nu de volgende code in de prompt:

>>> print("Hello, World")

Druk op Enter .

>>> print("Hello, World")
Hello, World

Hallo World Python-bestand

Maak een nieuw bestand hello.py met de volgende regel:

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

Navigeer in uw terminal naar de map met het bestand hello.py .

Typ python hello.py en druk op Enter .

$ python hello.py
Hello, World

Je zou Hello, World op de console moeten zien afdrukken.

Je kunt hello.py ook vervangen door het pad naar je bestand. Als u het bestand bijvoorbeeld in uw thuismap hebt en uw gebruiker "gebruiker" is op Linux, kunt u python /home/user/hello.py typen.

Start een interactieve Python-shell

Door het uitvoeren van (uitvoeren) van het python commando in uw terminal, krijgt u een interactieve Python-shell te zien. Dit wordt ook wel de Python-interpreter of een REPL genoemd (voor 'Read Evaluate Print Loop').

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>

Als u Python 3 vanaf uw terminal wilt uitvoeren, voert u de opdracht python3 .

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>

U kunt ook de interactieve prompt starten en het bestand laden met python -i <file.py> .

Voer op de opdrachtregel uit:

$ python -i hello.py
"Hello World"
>>>

Er zijn meerdere manieren om de Python-shell te sluiten:

>>> exit()

of

>>> quit()

Als alternatief zal CTRL + D de shell sluiten en u terugplaatsen op de opdrachtregel van uw terminal.

Als je een opdracht wilt annuleren, ben je bezig met typen en ga je terug naar een schone opdrachtprompt, terwijl je in de Interpreter-shell blijft, gebruik CTRL + C.

Probeer online een interactieve Python-shell .

Andere online schelpen

Verschillende websites bieden online toegang tot Python-shells.

Online shells kunnen nuttig zijn voor de volgende doeleinden:

• Voer een klein codefragment uit vanaf een computer waarop de installatie van python ontbreekt (smartphones, tablets, enz.).
• Leer of onderricht basis Python.
• Los online rechterproblemen op.

Voorbeelden:

Disclaimer: documentatie-auteur (s) zijn niet verbonden met onderstaande bronnen.

• https://www.python.org/shell/ - De online Python-shell gehost door de officiële Python-website.
• https://ideone.com/ - Veel gebruikt op internet om gedrag van codefragmenten te illustreren.
• https://repl.it/langgrams/python3 - Krachtige en eenvoudige online compiler, IDE en tolk. Code, compileer en voer code uit in Python.
• https://www.tutorialspoint.com/execute_python_online.php - Volledige UNIX-shell en een gebruikersvriendelijke projectverkenner.
• http://rextester.com/l/python3_online_compiler - Eenvoudig en gemakkelijk te gebruiken IDE die de uitvoeringstijd toont

Voer opdrachten uit als een tekenreeks

Python kan willekeurige code worden doorgegeven als een string in de shell:

$ python -c 'print("Hello, World")'
Hello, World

Dit kan handig zijn wanneer u de resultaten van scripts samenvoegt in de shell.

Schelpen en verder

Pakketbeheer - Het door PyPA aanbevolen hulpmiddel voor het installeren van Python-pakketten is PIP . Voer op uw opdrachtregel pip install <the package name> om te pip install <the package name> . Bijvoorbeeld, pip install numpy . (Opmerking: op Windows moet u pip toevoegen aan uw PATH-omgevingsvariabelen. Om dit te voorkomen, gebruikt u python -m pip install <the package name> )

Shells - Tot nu toe hebben we verschillende manieren besproken om code uit te voeren met behulp van de native interactieve shell van Python. Shells gebruiken de interpretatiekracht van Python om in realtime met code te experimenteren. Alternatieve shells omvatten IDLE - een vooraf gebundelde GUI, IPython - bekend voor het uitbreiden van de interactieve ervaring, enz.

Programma's - Voor langdurige opslag kunt u inhoud opslaan in .py-bestanden en deze bewerken / uitvoeren als scripts of programma's met externe tools zoals shell, IDE's (zoals PyCharm ), Jupyter-notebooks , etc. Intermediaire gebruikers kunnen deze tools gebruiken; de hier besproken methoden zijn echter voldoende om aan de slag te gaan.

Met de Python-tutor kunt u door de Python-code bladeren, zodat u kunt visualiseren hoe het programma zal verlopen en kunt u begrijpen waar uw programma is misgegaan.

PEP8 definieert richtlijnen voor het opmaken van Python-code. Het is belangrijk om de code goed op te maken, zodat u snel kunt lezen wat de code doet.

Variabelen maken en waarden toewijzen

Om een variabele in Python te maken, hoeft u alleen de naam van de variabele op te geven en er vervolgens een waarde aan toe te wijzen.

<variable name> = <value>

Python gebruikt = om waarden aan variabelen toe te wijzen. Het is niet nodig om vooraf een variabele te declareren (of er een gegevenstype aan toe te wijzen), het toekennen van een waarde aan een variabele zelf declareert en initialiseert de variabele met die waarde. Er is geen manier om een variabele te declareren zonder er een beginwaarde aan toe te kennen.

# Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None

Variabele toewijzing werkt van links naar rechts. Dus het volgende geeft je een syntaxisfout.

0 = x
=> Output: SyntaxError: can't assign to literal

U kunt de trefwoorden van python niet als geldige variabelenaam gebruiken. U kunt de lijst met zoekwoorden weergeven op:

import keyword
print(keyword.kwlist)

Regels voor variabele naamgeving:

1. Variabelenamen moeten beginnen met een letter of een onderstrepingsteken.

 x  = True   # valid
 _y = True   # valid

 9x = False  # starts with numeral 
 => SyntaxError: invalid syntax   

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax

2. De rest van uw variabelenaam kan bestaan uit letters, cijfers en onderstrepingstekens.

has_0_in_it = "Still Valid" 

3. Namen zijn hoofdlettergevoelig.

x = 9  
y = X*5   
=>NameError: name 'X' is not defined

Hoewel het niet nodig is om een gegevenstype te specificeren bij het declareren van een variabele in Python, terwijl de benodigde ruimte in het geheugen voor de variabele wordt toegewezen, kiest de Python-interpreter automatisch het meest geschikte ingebouwde type ervoor:

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>

Nu je de basis van toewijzing kent, laten we deze subtiliteit over toewijzing in python uit de weg ruimen.

Wanneer u = gebruikt om een toewijzingsbewerking uit te voeren, staat links van = een naam voor het object rechts. Tenslotte, wat = doet toewijzen is de referentie van het object rechts om de naam aan de linkerkant.

Dat is:

a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"

Dus, uit vele toewijzingsvoorbeelden hierboven, als we pi = 3.14 , dan is pi een naam (niet de naam, omdat een object meerdere namen kan hebben) voor het object 3.14 . Als je hieronder iets niet begrijpt, kom dan terug naar dit punt en lees dit opnieuw! U kunt dit ook bekijken voor een beter begrip.

U kunt meerdere waarden toewijzen aan meerdere variabelen op één regel. Merk op dat er aan de rechter- en linkerkant van de operator = hetzelfde aantal argumenten moet zijn:

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack

De fout in het laatste voorbeeld kan worden verholpen door de resterende waarden toe te wijzen aan een gelijk aantal willekeurige variabelen. Deze dummy-variabele kan elke naam hebben, maar het is gebruikelijk om het onderstrepingsteken ( _ ) te gebruiken voor het toewijzen van ongewenste waarden:

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2

Merk op dat het aantal _ en het aantal resterende waarden gelijk moeten zijn. Anders wordt 'te veel waarden om de fout uit te pakken' weergegeven zoals hierboven:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)

U kunt ook tegelijkertijd een enkele waarde toewijzen aan meerdere variabelen.

a = b = c = 1
print(a, b, c)
# Output: 1 1 1

Bij het gebruik van dergelijke trapsgewijze toewijzing is het belangrijk op te merken dat alle drie variabelen a , b en c naar hetzelfde object in het geheugen verwijzen, een int object met de waarde 1. Met andere woorden, a , b en c zijn drie verschillende namen gegeven aan hetzelfde int-object. Het achteraf toewijzen van een ander object aan een van hen verandert de anderen niet, zoals verwacht:

a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.

Het bovenstaande geldt ook voor muteerbare typen (zoals list , dict , enz.), Net zoals het geldt voor onveranderlijke typen (zoals int , string , tuple , enz.):

x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]

Tot zover gaat het goed. Dingen zijn een beetje anders als het gaat om het wijzigen van het object (in tegenstelling tot het toewijzen van de naam aan een ander object, wat we hierboven deden) wanneer de trapsgewijze toewijzing wordt gebruikt voor veranderlijke typen. Kijk hieronder en je zult het uit de eerste hand zien:

x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected

Geneste lijsten zijn ook geldig in python. Dit betekent dat een lijst een andere lijst als element kan bevatten.

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4

Ten slotte hoeven variabelen in Python niet hetzelfde type te blijven als waarmee ze eerst werden gedefinieerd - u kunt eenvoudig = gebruiken om een nieuwe waarde aan een variabele toe te wijzen, zelfs als die waarde van een ander type is.

a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value

Als dit je dwars zit, denk dan aan het feit dat wat links van = slechts een naam voor een object is. Eerst noem je het int object met waarde 2 a , dan verander je van gedachten en besluit je de naam a te geven aan een string object, met de waarde 'Nieuwe waarde'. Simpel toch?

Gebruikers invoer

Interactieve invoer

Om invoer van de gebruiker te krijgen, gebruikt u de input ( opmerking : in Python 2.x wordt de functie in plaats daarvan raw_input genoemd, hoewel Python 2.x een eigen input die totaal anders is):

name = raw_input("What is your name? ")
# Out: What is your name? _

name = input("What is your name? ")
# Out: What is your name? _

In de rest van dit voorbeeld wordt de syntaxis van Python 3 gebruikt.

De functie gebruikt een stringargument, dat het weergeeft als een prompt en een string retourneert. De bovenstaande code geeft een prompt, wachtend op de gebruiker om in te voeren.

name = input("What is your name? ")
# Out: What is your name?

Als de gebruiker types "Bob" en hits te voeren, de variabele name wordt aan de string worden toegewezen "Bob" :

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob

Merk op dat de input altijd van het type str , wat belangrijk is als u wilt dat de gebruiker getallen invoert. Daarom moet u de str omzetten voordat u deze als een nummer probeert te gebruiken:

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0

NB: Het wordt aanbevolen om try / except blokken te gebruiken om uitzonderingen op te vangen bij het omgaan met gebruikersinvoer . Als uw code bijvoorbeeld een raw_input in een int wil casten, en wat de gebruiker schrijft is niet te casten, verhoogt dit een ValueError .

IDLE - Python GUI

IDLE is de geïntegreerde ontwikkel- en leeromgeving van Python en is een alternatief voor de opdrachtregel. Zoals de naam al aangeeft, is IDLE erg handig voor het ontwikkelen van nieuwe code of het leren van python. Op Windows wordt dit geleverd met de Python-interpreter, maar in andere besturingssystemen moet u deze mogelijk installeren via uw pakketbeheerder.

De hoofddoelen van IDLE zijn:

• Teksteditor met meerdere vensters met syntaxisaccentuering, automatisch aanvullen en slim inspringen
• Python-shell met syntaxisaccentuering
• Geïntegreerde debugger met stepping, blijvende breekpunten en zichtbaarheid van de call-stack
• Automatische inspringing (handig voor beginners die leren over de inspringing van Python)
• Het Python-programma opslaan als .py-bestanden en deze uitvoeren en later bewerken met IDLE.

Druk in IDLE op F5 of run Python Shell uit om een tolk te starten. Het gebruik van IDLE kan een betere leerervaring zijn voor nieuwe gebruikers omdat code wordt geïnterpreteerd terwijl de gebruiker schrijft.

Merk op dat er veel alternatieven zijn, zie bijvoorbeeld deze discussie of deze lijst .

Probleemoplossen

• ramen

  Als u Windows gebruikt, is de standaardopdracht python . Als u de foutmelding "'python' is not recognized" ontvangt, is de meest waarschijnlijke oorzaak dat de locatie van Python zich niet in de omgevingsvariabele PATH uw systeem bevindt. U kunt dit openen door met de rechtermuisknop op 'Deze computer' te klikken en 'Eigenschappen' te selecteren of door naar 'Systeem' te navigeren via 'Configuratiescherm'. Klik op 'Geavanceerde systeeminstellingen' en vervolgens op 'Omgevingsvariabelen ...'. Bewerk de variabele PATH zodat deze de map van uw Python-installatie en de map Script bevat (meestal C:\Python27;C:\Python27\Scripts ). Dit vereist beheerdersrechten en kan een herstart vereisen.

  Wanneer u meerdere versies van Python op dezelfde machine gebruikt, is een mogelijke oplossing het hernoemen van een van de python.exe bestanden. Als u bijvoorbeeld één versie python27.exe , wordt python27 de Python-opdracht voor die versie.

  U kunt ook de Python Launcher voor Windows gebruiken, die beschikbaar is via het installatieprogramma en standaard wordt geleverd. Hiermee kunt u de versie van Python selecteren die moet worden uitgevoerd met py -[xy] plaats van python[xy] . U kunt de nieuwste versie van Python 2 gebruiken door scripts met py -2 en de nieuwste versie van Python 3 door scripts met py -3 .

• Debian / Ubuntu / MacOS

  In deze sectie wordt ervan uitgegaan dat de locatie van het uitvoerbare python is toegevoegd aan de omgevingsvariabele PATH .

  Als u Debian / Ubuntu / MacOS gebruikt, opent u de terminal en typt u python voor Python 2.x of python3 voor Python 3.x.

  Typ which python om te zien welke Python-interpreter zal worden gebruikt.

• Arch Linux

  De standaard Python op Arch Linux (en nakomelingen) is Python 3, dus gebruik python of python3 voor Python 3.x en python2 voor Python 2.x.

• Andere systemen

  Python 3 is soms gebonden aan python plaats van python3 . Om Python 2 te gebruiken op deze systemen waar het is geïnstalleerd, kunt u python2 .

datatypes

Ingebouwde typen

Booleans

bool : een booleaanse waarde van True of False . Logische bewerkingen zoals and , or , kunnen not worden uitgevoerd op Booleans.

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

In Python 2.x en in Python 3.x is een Boolean ook een int . Het bool type is een subklasse van het int type en True en False zijn de enige voorbeelden:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

Als booleaanse waarden worden gebruikt in rekenkundige bewerkingen, worden hun gehele getallen ( 1 en 0 voor True en False ) gebruikt om een geheel getal te retourneren:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

Numbers

• int : geheel getal

  a = 2
  b = 100
  c = 123456789
  d = 38563846326424324
  

  Gehele getallen in Python zijn van willekeurige grootte.

  Opmerking: in oudere versies van Python was een long type beschikbaar en dit was anders dan int . De twee zijn verenigd.

• float : drijvend puntnummer; precisie hangt af van de implementatie en systeemarchitectuur, voor CPython komt het float gegevenstype overeen met een C-dubbel.

  a = 2.0
  b = 100.e0
  c = 123456789.e1
  

• complex : complexe getallen

  a = 2 + 1j
  b = 100 + 10j
  

De operatoren < , <= , > en >= roepen een uitzondering TypeError wanneer een operand een complex getal is.

strings

Reeksen en collecties

Python maakt onderscheid tussen geordende sequenties en ongeordende collecties (zoals set en dict ).

• strings ( str , bytes , unicode ) zijn sequenties

• reversed : een omgekeerde volgorde van str met reversed functie

  a = reversed('hello')
  

• tuple : een geordende verzameling van n waarden van elk type ( n >= 0 ).

  a = (1, 2, 3)
  b = ('a', 1, 'python', (1, 2))
  b[2] = 'something else' # returns a TypeError
  

  Ondersteunt indexering; onveranderlijk; hashable als alle leden hashable zijn

• list : een geordende verzameling van n waarden ( n >= 0 )

  a = [1, 2, 3]
  b = ['a', 1, 'python', (1, 2), [1, 2]]
  b[2] = 'something else' # allowed
  

  Niet hashable; veranderlijk.

• set : een ongeordende verzameling unieke waarden. Items moeten hashable zijn .

  a = {1, 2, 'a'}
  

• dict : Een ongeordende verzameling unieke sleutel / waarde-paren; sleutels moeten hashable zijn .

  a = {1: 'one',
       2: 'two'}
  
  b = {'a': [1, 2, 3],
       'b': 'a string'}
  

Een object is hashbaar als het een hash-waarde heeft die tijdens zijn levensduur nooit verandert (het heeft een __hash__() -methode nodig) en kan worden vergeleken met andere objecten (het heeft een __eq__() -methode nodig). Hashbare objecten die gelijkheid vergelijken, moeten dezelfde hashwaarde hebben.

Ingebouwde constanten

In combinatie met de ingebouwde gegevenstypen zijn er een klein aantal ingebouwde constanten in de ingebouwde naamruimte:

• True : de werkelijke waarde van de ingebouwde bool
• False : de valse waarde van de ingebouwde bool
• None : een singleton-object dat aangeeft dat een waarde afwezig is.
• Ellipsis of ... : overal gebruikt in kern Python3 + en beperkt gebruik in Python2.7 + als onderdeel van arraynotatie. numpy en gerelateerde pakketten gebruiken dit als een 'alles opnemen' referentie in arrays.
• NotImplemented : een singleton gebruikt om Python aan te geven dat een speciale methode de specifieke argumenten niet ondersteunt, en Python zal alternatieven proberen indien beschikbaar.

a = None # No value will be assigned. Any valid datatype can be assigned later

Het type variabelen testen

In python, kunnen we het datatype van een voorwerp te controleren met de ingebouwde functie type .

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

In voorwaardelijke verklaringen is het mogelijk om het datatype te testen met isinstance . Meestal wordt het echter niet aangemoedigd om te vertrouwen op het type variabele.

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

Lees voor informatie over de verschillen tussen type() en isinstance() : Verschillen tussen isinstance en type in Python

Om te testen of iets van NoneType :

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

Converteren tussen gegevenstypen

U kunt expliciete datatype-conversie uitvoeren.

'123' is bijvoorbeeld van het str type en kan met de functie int worden geconverteerd naar een geheel getal.

a = '123'
b = int(a)

Het omzetten van een float-string zoals '123.456' kan worden gedaan met behulp van de float functie.

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

U kunt ook reeks- of verzameltypen omzetten

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

Expliciet stringtype bij de definitie van letterlijke waarden

Met labels van één letter vlak voor de aanhalingstekens kunt u zien welk type tekenreeks u wilt definiëren.

• b'foo bar' : resultaten bytes in Python 3, str in Python 2
• u'foo bar' : resultaten str in Python 3, unicode in Python 2
• 'foo bar' : resultaten str
• r'foo bar' : resultaten zogenaamde ruwe string, waarbij het ontsnappen van speciale tekens niet nodig is, alles wordt letterlijk genomen terwijl u typt

normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

Muteerbare en onveranderlijke gegevenstypen

Een object wordt mutable genoemd als het kan worden gewijzigd. Wanneer u bijvoorbeeld een lijst doorgeeft aan een bepaalde functie, kan de lijst worden gewijzigd:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

Een object wordt onveranderlijk genoemd als het op geen enkele manier kan worden gewijzigd. Gehele getallen zijn bijvoorbeeld onveranderlijk, omdat ze niet kunnen worden gewijzigd:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

Merk op dat variabelen zelf veranderlijk zijn, dus we kunnen de variabele x opnieuw toewijzen, maar dit verandert niets aan het object waarnaar x eerder had gewezen. Het maakte x alleen maar wijzen naar een nieuw object.

Gegevenstypen waarvan de instanties muteerbaar zijn, worden muteerbare gegevenstypen genoemd en op vergelijkbare wijze voor onveranderlijke objecten en gegevenstypen.

Voorbeelden van onveranderlijke gegevenstypen:

• int , long , float , complex
• str
• bytes
• tuple
• frozenset

Voorbeelden van muteerbare gegevenstypen:

• bytearray
• list
• set
• dict

Ingebouwde modules en functies

Een module is een bestand met Python-definities en -instructies. Functie is een stuk code dat enige logica uitvoert.

>>> pow(2,3)    #8

Om de ingebouwde functie in python te controleren, kunnen we dir(). Retourneer de namen in het huidige bereik als u zonder argument roept. Anders retourneert u een alfabetische lijst met namen die (een deel van) het attribuut van het gegeven object bevatten, en van attributen die er vanaf bereikbaar zijn.

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]

Om de functionaliteit van elke functie te kennen, kunnen we ingebouwde functiehulp help .

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.

Ingebouwde modules bevatten extra functionaliteiten. Om bijvoorbeeld een vierkantswortel van een getal te krijgen, moeten we de math .

>>> import math
>>> math.sqrt(16) # 4.0

Om alle functies in een module te kennen, kunnen we de functielijst toewijzen aan een variabele en vervolgens de variabele afdrukken.

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']

het lijkt erop dat __doc__ nuttig is om wat documentatie te bieden over bijvoorbeeld functies

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'

Naast functies kan documentatie ook in modules worden verstrekt. Dus als u een bestand met de naam helloWorld.py als dit hebt:

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'

U kunt de docstrings als volgt openen:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'

• Voor elk door de gebruiker gedefinieerd type kunnen de attributen, de attributen van de klasse en recursief de attributen van de basisklassen van de klasse worden opgehaald met dir ()

>>> class MyClassObject(object):
...     pass
... 
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

Elk gegevenstype kan eenvoudig worden geconverteerd naar een tekenreeks met de ingebouwde functie str . Deze functie wordt standaard aangeroepen wanneer een gegevenstype wordt doorgegeven om print te print

>>> str(123)    # "123"

Inspringen blokkeren

Python gebruikt inspringen om besturings- en lusconstructies te definiëren. Dit draagt bij aan de leesbaarheid van Python, maar vereist van de programmeur dat hij goed let op het gebruik van witruimte. Aldus kan foutieve kalibratie van de editor resulteren in code die zich op onverwachte manieren gedraagt.

Python maakt gebruik van de dubbele punt ( : ) en inspringen voor het tonen waar de blokken code beginnen en eindigen (Als je uit een andere taal, dit niet te verwarren met een of andere manier is gerelateerd aan de ternaire operator ). Dat wil zeggen, blokken in Python, zoals functies, lussen, if clausules en andere constructies, hebben geen eind-id's. Alle blokken beginnen met een dubbele punt en bevatten vervolgens de ingesprongen lijnen eronder.

Bijvoorbeeld:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block

of

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block

Blokken die precies één instructie van één regel bevatten, kunnen op dezelfde regel worden geplaatst, hoewel dit formulier over het algemeen niet als een goede stijl wordt beschouwd:

if a > b: print(a)
else: print(b)  

Proberen dit te doen met meer dan één verklaring werkt niet :

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax

Een leeg blok veroorzaakt een IndentationError . Gebruik pass (een opdracht die niets doet) wanneer u een blok zonder inhoud hebt:

def will_be_implemented_later():
    pass

Spaties versus tabbladen

Kortom: gebruik altijd 4 spaties voor inspringen.

Alleen het gebruik van tabbladen is mogelijk, maar PEP 8 , de stijlgids voor Python-code, stelt dat spaties de voorkeur hebben.

Veel editors hebben een "tabs naar spaties" -configuratie. Bij het configureren van de editor, moet men onderscheid maken tussen de tab-teken ( '\ t') en de Tab-toets.

• Het tabblad teken moet worden geconfigureerd om 8 ruimtes laten zien, om de taal semantiek overeenkomen - althans in gevallen waarin (per ongeluk) gemengde inspringen is mogelijk. Bewerkers kunnen het tabteken ook automatisch omzetten in spaties.
• Het kan echter handig zijn om de editor zo te configureren dat het indrukken van de Tab- toets 4 spaties invoegt in plaats van een tab-teken.

Python-broncode geschreven met een combinatie van tabbladen en spaties, of met een niet-standaard aantal inspringruimten, kan pep8-conform worden gemaakt met behulp van autopep8 . (Een minder krachtig alternatief wordt geleverd met de meeste Python-installaties: reindent.py )

Collectietypen

Er zijn een aantal soorten collecties in Python. Terwijl typen zoals int en str een enkele waarde hebben, bevatten verzameltypen meerdere waarden.

lijsten

Het list is waarschijnlijk het meest gebruikte verzamelingstype in Python. Ondanks de naam lijkt een lijst meer op een array in andere talen, meestal JavaScript. In Python is een lijst slechts een geordende verzameling geldige Python-waarden. Een lijst kan worden gemaakt door waarden, gescheiden door komma's, tussen vierkante haken te plaatsen:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']

Een lijst kan leeg zijn:

empty_list = []

De elementen van een lijst zijn niet beperkt tot een enkel gegevenstype, wat logisch is gezien het feit dat Python een dynamische taal is:

mixed_list = [1, 'abc', True, 2.34, None]

Een lijst kan een andere lijst als element bevatten:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]

De elementen van een lijst zijn toegankelijk via een index of een numerieke weergave van hun positie. Lijsten in Python zijn nul-geïndexeerd, wat betekent dat het eerste element in de lijst op index 0 staat, het tweede element op index 1 enzovoort:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig

Indices kunnen ook negatief zijn, wat inhoudt dat vanaf het einde van de lijst wordt geteld ( -1 is de index van het laatste element). Dus, met behulp van de lijst uit het bovenstaande voorbeeld:

print(names[-1]) # Eric
print(names[-4]) # Bob

Lijsten kunnen worden gewijzigd, dus u kunt de waarden in een lijst wijzigen:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

Bovendien is het mogelijk om elementen toe te voegen en / of te verwijderen uit een lijst:

Voeg object toe aan einde van lijst met L.append(object) , retourneert None .

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Voeg een nieuw element toe aan de lijst bij een specifieke index. L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Verwijder het eerste exemplaar van een waarde met L.remove(value) , retourneert None

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

Haal de index op in de lijst van het eerste item waarvan de waarde x is. Er wordt een foutmelding weergegeven als een dergelijk item niet bestaat.

name.index("Alice")
0

Tel de lengte van de lijst

len(names)
6

tel het voorkomen van een item in de lijst

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3

Keer de lijst om

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]

Verwijder en retourneer item bij index (standaard ingesteld op het laatste item) met L.pop([index]) , retourneert het item

names.pop() # Outputs 'Sia'

U kunt de lijstelementen zoals hieronder herhalen:

for element in my_list:
    print (element)

tuples

Een tuple lijkt op een lijst, behalve dat het een vaste lengte heeft en onveranderlijk is. De waarden in de tuple kunnen dus niet worden gewijzigd, noch kunnen de waarden worden toegevoegd aan of verwijderd uit de tuple. Tuples worden vaak gebruikt voor kleine waardenverzamelingen die niet hoeven te worden gewijzigd, zoals een IP-adres en poort. Tuples worden weergegeven met haakjes in plaats van vierkante haken:

ip_address = ('10.20.30.40', 8080)

Dezelfde indexeringsregels voor lijsten zijn ook van toepassing op tupels. Tuples kunnen ook worden genest en de waarden kunnen elke geldige Python zijn.

Een tuple met slechts één lid moet op deze manier worden gedefinieerd (let op de komma):

one_member_tuple = ('Only member',)

of

one_member_tuple = 'Only member',   # No brackets

of gewoon met behulp van tuple syntaxis

one_member_tuple = tuple(['Only member'])

Woordenboeken

Een dictionary in Python is een verzameling sleutel / waarde-paren. Het woordenboek is omgeven door accolades. Elk paar wordt gescheiden door een komma en de sleutel en waarde worden gescheiden door een dubbele punt. Hier is een voorbeeld:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Om een waarde te krijgen, verwijs ernaar door de sleutel:

ca_capital = state_capitals['California']

U kunt ook alle sleutels in een woordenboek ophalen en deze vervolgens herhalen:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))

Woordenboeken lijken sterk op de JSON-syntaxis. De native json module in de standaardbibliotheek van Python kan worden gebruikt om te converteren tussen JSON en woordenboeken.

reeks

Een set is een verzameling elementen zonder herhalingen en zonder invoegvolgorde maar gesorteerde volgorde. Ze worden gebruikt in situaties waarin het alleen belangrijk is dat sommige dingen zijn gegroepeerd en niet in welke volgorde ze zijn opgenomen. Voor grote groepen gegevens is het veel sneller om te controleren of een element al dan niet deel uitmaakt van een set dan hetzelfde te doen voor een list .

Het definiëren van een set lijkt erg op het definiëren van een dictionary :

first_names = {'Adam', 'Beth', 'Charlie'}

Of u kunt een set met behulp van een bestaande list :

my_list = [1,2,3]
my_set = set(my_list)

Controleer het lidmaatschap van de set met in :

if name in first_names:
    print(name)

U kunt een set exact zoals een lijst herhalen, maar onthoud: de waarden staan in een willekeurige, door de implementatie gedefinieerde volgorde.

defaultdict

Een defaultdict is een woordenboek met een standaardwaarde voor sleutels, zodat sleutels zonder expliciete waarde zonder fouten kunnen worden geopend. defaultdict is vooral handig wanneer de waarden in het woordenboek verzamelingen (lijsten, dictaten, enz.) zijn in die zin dat het niet elke keer moet worden geïnitialiseerd wanneer een nieuwe sleutel wordt gebruikt.

Een defaultdict zal nooit een KeyError oproepen. Elke sleutel die niet bestaat, krijgt de standaardwaarde terug.

Overweeg bijvoorbeeld het volgende woordenboek

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Als we proberen toegang te krijgen tot een niet-bestaande sleutel, geeft python ons een foutmelding als volgt

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'

Laten we het proberen met een defaultdict . Het is te vinden in de collectiesmodule.

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')

Wat we hier hebben gedaan, is een standaardwaarde ( Boston ) instellen voor het geval dat de sleutel Give niet bestaat. Vul nu het dictaat in zoals eerder:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'

Als we proberen toegang te krijgen tot het dictaat met een niet-bestaande sleutel, geeft python ons de standaardwaarde weer, namelijk Boston

>>> state_capitals['Alabama']
'Boston'

en retourneert de gemaakte waarden voor bestaande sleutel net als een normaal dictionary

>>> state_capitals['Arkansas']
'Little Rock'

Help-hulpprogramma

Python heeft verschillende functies ingebouwd in de tolk. Als u informatie wilt over trefwoorden, ingebouwde functies, modules of onderwerpen, opent u een Python-console en voert u in:

>>> help()

U ontvangt informatie door zoekwoorden rechtstreeks in te voeren:

>>> help(help)

of binnen het hulpprogramma:

help> help

die een uitleg zal tonen:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

U kunt ook subklassen van modules aanvragen:

help(pymysql.connections)

U kunt hulp gebruiken om toegang te krijgen tot de docstrings van de verschillende modules die u hebt geïmporteerd, probeer bijvoorbeeld het volgende:

>>> help(math)

en je krijgt een foutmelding

>>> import math
>>> help(math)

En nu krijgt u een lijst met de beschikbare methoden in de module, maar pas NADAT u deze hebt geïmporteerd.

Sluit de helper met quit

Een module maken

Een module is een importeerbaar bestand met definities en instructies.

Een module kan worden gemaakt door een .py bestand te maken.

# hello.py
def say_hello():
    print("Hello!")

Functies in een module kunnen worden gebruikt door de module te importeren.

Voor modules die u hebt gemaakt, moeten deze zich in dezelfde map bevinden als het bestand waarin u ze importeert. (U kunt ze echter ook in de Python lib-directory plaatsen met de vooraf opgenomen modules, maar dit moet indien mogelijk worden vermeden.)

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"

Modules kunnen door andere modules worden geïmporteerd.

# greet.py
import hello
hello.say_hello()

Specifieke functies van een module kunnen worden geïmporteerd.

# greet.py
from hello import say_hello
say_hello()

Op modules kan een alias worden toegepast.

# greet.py
import hello as ai
ai.say_hello()

Een module kan een zelfstandig, uitvoerbaar script zijn.

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()

Voer het uit!

$ python run_hello.py
=> "Hello!"

Als de module zich in een map bevindt en door python moet worden gedetecteerd, moet de map een bestand met de naam __init__.py .

Stringfunctie - str () en repr ()

Er zijn twee functies die kunnen worden gebruikt om een leesbare weergave van een object te verkrijgen.

repr(x) roept x.__repr__() : een weergave van x . eval converteert het resultaat van deze functie meestal terug naar het oorspronkelijke object.

str(x) roept x.__str__() : een voor mensen leesbare string die het object beschrijft. Dit kan technische details verhelpen.

repr ()

Voor veel typen probeert deze functie een tekenreeks terug te geven die een object met dezelfde waarde zou opleveren als het wordt doorgegeven aan eval() . Anders is de weergave een tekenreeks tussen punthaken die de naam van het type object bevat, samen met aanvullende informatie. Dit omvat vaak de naam en het adres van het object.

str ()

Voor tekenreeksen retourneert dit de tekenreeks zelf. Het verschil tussen dit en repr(object) is dat str(object) niet altijd probeert een string terug te geven die acceptabel is voor eval() . Het doel is veeleer het retourneren van een afdrukbare of 'door mensen leesbare' string. Als er geen argument wordt gegeven, retourneert dit de lege tekenreeks '' .

Voorbeeld 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True

Voorbeeld 2:

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'

Wanneer u een klas schrijft, kunt u deze methoden overschrijven om te doen wat u maar wilt:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)

Met behulp van de bovenstaande klasse kunnen we de resultaten zien:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects

Externe modules installeren met behulp van pip

pip is je vriend wanneer je een pakket moet installeren uit de overvloed aan keuzes die beschikbaar zijn in de python-pakketindex (PyPI). pip is al geïnstalleerd als u Python 2> = 2.7.9 of Python 3> = 3.4 gebruikt, gedownload van python.org. Voor computers met Linux of een andere * nix met een native pakketbeheerder, moet pip vaak handmatig worden geïnstalleerd.

In gevallen waarin zowel Python 2 als Python 3 zijn geïnstalleerd, verwijst pip vaak naar Python 2 en pip3 naar Python 3. Als u pip worden alleen pakketten voor Python 2 pip3 en met pip3 worden alleen pakketten voor Python 3 geïnstalleerd.

Een pakket zoeken / installeren

Een pakket zoeken is net zo eenvoudig als typen

$ pip search <query>
# Searches for packages whose name or summary contains <query>

Een pakket installeren is net zo eenvoudig als typen (in een terminal / opdrachtprompt, niet in de Python-interpreter)

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package

waarbij xxx het versienummer is van het pakket dat u wilt installeren.

Wanneer uw server zich achter proxy bevindt, kunt u het pakket installeren met behulp van onderstaande opdracht:

$ pip --proxy http://<server address>:<port> install

Geïnstalleerde pakketten upgraden

Wanneer nieuwe versies van geïnstalleerde pakketten verschijnen, worden deze niet automatisch op uw systeem geïnstalleerd. Om een overzicht te krijgen van welke van uw geïnstalleerde pakketten verouderd zijn geraakt, voert u uit:

$ pip list --outdated

Gebruik een specifiek pakket om te upgraden

$ pip install [package_name] --upgrade

Het bijwerken van alle verouderde pakketten is geen standaardfunctionaliteit van pip .

Pip upgraden

Je kunt je bestaande pip-installatie upgraden met de volgende opdrachten

• Op Linux of macOS X:

  $ pip install -U pip
  

  Mogelijk moet u sudo met pip gebruiken op sommige Linux-systemen

• Op Windows:

  py -m pip install -U pip
  

  of

  python -m pip install -U pip
  

Lees hier voor meer informatie over pip.

Installatie van Python 2.7.x en 3.x

Opmerking : de volgende instructies zijn geschreven voor Python 2.7 (tenzij gespecificeerd): instructies voor Python 3.x zijn vergelijkbaar.

RAMEN

Download eerst de nieuwste versie van Python 2.7 van de officiële website ( https://www.python.org/downloads/) . Versie wordt geleverd als een MSI-pakket. Dubbelklik op het bestand om het handmatig te installeren.

Standaard wordt Python geïnstalleerd in een map:

 C:\Python27\

Waarschuwing: installatie wijzigt de omgevingsvariabele PATH niet automatisch.

Ervan uitgaande dat uw Python-installatie in C: \ Python27 is, voegt u dit toe aan uw PATH:

C:\Python27\;C:\Python27\Scripts\

Om te controleren of de Python-installatie geldig is, schrijft u in cmd:

python --version

Python 2.x en 3.x naast elkaar

Om Python 2.x en 3.x naast elkaar te installeren en te gebruiken op een Windows-machine:

1. Installeer Python 2.x met behulp van het MSI-installatieprogramma.

   • Zorg dat Python voor alle gebruikers is geïnstalleerd.
   • Optioneel: voeg Python toe aan PATH om Python 2.x via de opdrachtregel via python opvraagbaar te maken.

2. Installeer Python 3.x met behulp van het bijbehorende installatieprogramma.

   • Nogmaals, zorg ervoor dat Python voor alle gebruikers is geïnstalleerd.
   • Optioneel: voeg Python toe aan PATH om Python 3.x via de opdrachtregel via python opvraagbaar te maken. Dit kan de PATH instellingen van Python 2.x vervangen, dus controleer uw PATH en zorg ervoor dat deze is geconfigureerd volgens uw voorkeuren.
   • Zorg ervoor dat u het py launcher voor alle gebruikers installeert.

Python 3 installeert het Python-opstartprogramma dat kan worden gebruikt om Python 2.x en Python 3.x uitwisselbaar te starten vanaf de opdrachtregel:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Om de overeenkomstige versie van pip voor een specifieke Python-versie te gebruiken, gebruikt u:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)

LINUX

De nieuwste versies van CentOS, Fedora, Redhat Enterprise (RHEL) en Ubuntu worden geleverd met Python 2.7.

Om Python 2.7 handmatig op Linux te installeren, doe je het volgende in terminal:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install

Voeg ook het pad van nieuwe python toe in omgevingsvariabele PATH. Als nieuwe python in /root/python-2.7.X is, /root/python-2.7.X dan export PATH = $PATH:/root/python-2.7.X

Controleer nu of de Python-installatie geldig is, schrijf in terminal:

python --version

Ubuntu (uit bron)

Als je Python 3.6 nodig hebt, kun je het vanaf de bron installeren zoals hieronder getoond (Ubuntu 16.10 en 17.04 hebben een 3.6-versie in de universele repository). De onderstaande stappen moeten worden gevolgd voor Ubuntu 16.04 en lagere versies:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall

MacOS

Op dit moment wordt macOS geïnstalleerd met Python 2.7.10, maar deze versie is verouderd en enigszins aangepast ten opzichte van de reguliere Python.

De versie van Python die wordt geleverd met OS X is geweldig om te leren, maar het is niet goed voor ontwikkeling. De versie die wordt geleverd met OS X is mogelijk verouderd van de officiële huidige Python-release, die wordt beschouwd als de stabiele productieversie. ( bron )

Homebrew installeren:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Python 2.7 installeren:

brew install python

Voor Python 3.x gebruikt brew install python3 plaats hiervan de opdracht brew install python3 .