Python Language Handledning
Komma igång med Python Language

Anmärkningar

versioner

Komma igång

Python är ett allmänt använt programmeringsspråk på hög nivå för programmering i allmänna syften, skapat av Guido van Rossum och släpptes först 1991. Python har ett system av dynamisk typ och automatisk minneshantering och stöder flera programmeringsparadigmer, inklusive objektorienterade, nödvändiga, funktionell programmering och procedurstilar. Det har ett stort och omfattande bibliotek.

Två huvudversioner av Python används för närvarande:

• Python 3.x är den aktuella versionen och är under aktiv utveckling.
• Python 2.x är den gamla versionen och kommer endast att få säkerhetsuppdateringar fram till 2020. Inga nya funktioner kommer att implementeras. Observera att många projekt fortfarande använder Python 2, även om det blir enklare att migrera till Python 3.

Du kan ladda ner och installera någon av versionerna av Python här . Se Python 3 vs. Python 2 för en jämförelse mellan dem. Dessutom erbjuder vissa tredjeparter ompaketerade versioner av Python som lägger till vanligt använda bibliotek och andra funktioner för att underlätta inställningen för fall av vanlig användning, såsom matematik, dataanalys eller vetenskaplig användning. Se listan på den officiella sajten .

Verifiera om Python är installerat

För att bekräfta att Python har installerats korrekt kan du verifiera att genom att köra följande kommando i din favoritterminal (Om du använder Windows OS måste du lägga till Pythons sökväg till miljövariabeln innan du använder den i kommandotolken):

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

Om du har installerat Python 3, men $ python --version matar ut en Python 2-version, har du också Python 2 installerad. Detta är ofta fallet på MacOS och många Linux-distributioner. Använd istället $ python3 att uttryckligen använda Python 3-tolk.

Hej, World in Python med IDLE

IDLE är en enkel redaktör för Python, som levereras med Python.

Hur man skapar Hello, World-programmet i IDLE

• Öppna IDLE på ditt valda system.
  • I äldre versioner av Windows kan det hittas på All Programs under Windows-menyn.
  • I Windows 8+ söker du efter IDLE eller hittar det i apparna som finns i ditt system.
  • På Unix-baserade (inklusive Mac) -system kan du öppna det från skalet genom att skriva $ idle python_file.py .
• Det öppnar ett skal med alternativ längst upp.

I skalet finns det en fråga om tre rätvinklar:

>>>

Skriv nu följande kod i prompten:

>>> print("Hello, World")

Hit Enter .

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

Hej World Python-fil

Skapa en ny fil hello.py som innehåller följande rad:

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

I din terminal navigerar du till katalogen som innehåller filen hello.py .

Skriv python hello.py sedan på Enter- tangenten.

$ python hello.py
Hello, World

Du borde se Hello, World tryckt på konsolen.

Du kan också ersätta hello.py med sökvägen till din fil. Om du till exempel har filen i din hemkatalog och din användare är "användare" på Linux kan du skriva python /home/user/hello.py .

Starta ett interaktivt Python-skal

Genom att köra (kör) python kommandot i din terminal presenteras du för ett interaktivt Python-skal. Detta är också känt som Python-tolkaren eller en REPL (för 'Läs utvärdera 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
>>>

Om du vill köra Python 3 från din terminal, kör kommandot 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
>>>

Starta alternativt den interaktiva prompten och ladda filen med python -i <file.py> .

Kör i kommandoraden:

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

Det finns flera sätt att stänga Python-skalet:

>>> exit()

eller

>>> quit()

Alternativt stänger CTRL + D skalet och sätter dig tillbaka på din terminals kommandorad.

Om du vill avbryta ett kommando är du mitt i att skriva och komma tillbaka till en ren kommandotolk, medan du stannar inne i tolkskalet, använd CTRL + C.

Prova ett interaktivt Python-skal online .

Andra online-skal

Olika webbplatser ger tillgång online till Python-skal.

Online-skal kan vara användbara för följande ändamål:

• Kör ett litet kodavsnitt från en maskin som saknar pythoninstallation (smartphones, surfplattor etc).
• Lär dig eller lära grundläggande Python.
• Lös problem med domare online.

Exempel:

Ansvarsfriskrivning: författare / dokumentation är inte anslutna till några resurser som anges nedan.

• https://www.python.org/shell/ - Pythons skal online som är värd av den officiella Python-webbplatsen.
• https://ideone.com/ - Mycket använt på nätet för att illustrera kodavsnittens beteende.
• https://repl.it/languages/python3 - Kraftfull och enkel online-kompilator, IDE och tolk. Koda, kompilera och köra kod i Python.
• https://www.tutorialspoint.com/execute_python_online.php - Fullständigt UNIX-skal och en användarvänlig projektutforskare.
• http://rextester.com/l/python3_online_compiler - Enkel och enkel att använda IDE som visar körningstid

Kör kommandon som en sträng

Python kan skickas godtycklig kod som en sträng i skalet:

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

Detta kan vara användbart när man sammanlänker resultaten från skript tillsammans i skalet.

Shells and Beyond

Pakethantering - Det rekommenderade PyPA-verktyget för installation av Python-paket är PIP . Installera, på din kommandorad köra pip install <the package name> . Till exempel, pip install numpy . (Obs! På fönster måste du lägga till pip till dina PATH-miljövariabler. För att undvika detta, använd python -m pip install <the package name> )

Skal - Hittills har vi diskuterat olika sätt att köra kod med Pythons inbyggda interaktiva skal. Skal använder Pythons tolkningskraft för att experimentera med kod i realtid. Alternativa skal inkluderar IDLE - ett förbuntat GUI, IPython - känt för att utöka den interaktiva upplevelsen, etc.

Program - För långvarig lagring kan du spara innehåll i .py-filer och redigera / köra dem som skript eller program med externa verktyg, t.ex. skal, IDE: er (som PyCharm ), Jupyter-anteckningsböcker , etc. Mellananvändare kan använda dessa verktyg; de metoder som diskuteras här är dock tillräckliga för att komma igång.

Python-läraren låter dig gå igenom Python-koden så att du kan visualisera hur programmet flyter och hjälper dig att förstå var ditt program gick fel.

PEP8 definierar riktlinjer för formatering av Python-kod. Det är viktigt att formatera koden så att du snabbt kan läsa vad koden gör.

Skapa variabler och tilldela värden

För att skapa en variabel i Python, behöver du bara ange variabelnamnet och sedan tilldela ett värde till det.

<variable name> = <value>

Python använder = att tilldela värden till variabler. Det finns inget behov av att deklarera en variabel i förväg (eller tilldela en datatyp till den), tilldela ett värde till en variabel själv förklarar och initierar variabeln med det värdet. Det finns inget sätt att deklarera en variabel utan att tilldela den ett initialvärde.

# 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

Variabel tilldelning fungerar från vänster till höger. Så följande ger dig ett syntaxfel.

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

Du kan inte använda pythons sökord som ett giltigt variabelnamn. Du kan se listan med nyckelord genom att:

import keyword
print(keyword.kwlist)

Regler för variabel namngivning:

1. Variablenamn måste börja med en bokstav eller en understruk.

 x  = True   # valid
 _y = True   # valid

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

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

2. Resten av ditt variabla namn kan bestå av bokstäver, siffror och understreck.

has_0_in_it = "Still Valid" 

3. Namnen är skiftlägeskänsliga.

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

Även om det inte finns något behov att ange en datatyp när man deklarerar en variabel i Python, samtidigt som det nödvändiga området i minnet tilldelas för variabeln, väljer Python-tolkaren automatiskt den lämpligaste inbyggda typen för den:

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 känner du grunderna i uppdraget, låt oss få denna subtilitet om uppdrag i python ur vägen.

När du använder = att utföra en tilldelningsoperation är vad som är till vänster om = ett namn på objektet till höger. Slutligen, vad = gör är att tilldela referensen för objektet till höger till namnet till vänster.

Det är:

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

Så från många uppdrags exemplen ovan, om vi plockar pi = 3.14 , då pi är ett namn (inte namnet, eftersom ett föremål kan ha flera namn) för objektet 3.14 . Om du inte förstår något nedan, kom tillbaka till denna punkt och läs igen! Du kan också titta på detta för att få en bättre förståelse.

Du kan tilldela flera värden till flera variabler på en rad. Observera att det måste finnas samma antal argument på höger och vänster sida av = operatören:

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

Felet i det sista exemplet kan undvikas genom att tilldela återstående värden till lika antal godtyckliga variabler. Denna dummyvariabel kan ha valfritt namn, men det är vanligt att använda understrecket ( _ ) för att tilldela oönskade värden:

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

Observera att antalet _ och antalet återstående värden måste vara lika. Annars kastas "för många värden för att packa upp fel" som ovan:

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)

Du kan också tilldela ett enda värde till flera variabler samtidigt.

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

När du använder en sådan kaskaduppgift är det viktigt att notera att alla tre variablerna a , b och c hänvisar till samma objekt i minnet, ett int objekt med värdet 1. Med andra ord är a , b och c tre olika namn ges till samma int-objekt. Att tilldela ett annat objekt efteråt ändrar inte de andra, precis som förväntat:

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.

Ovanstående gäller också för muterbara typer (som list , dict , etc.) precis som det gäller för immutable typer (som int , string , tuple , etc.):

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]

Än så länge är allt bra. Saker är lite annorlunda när det gäller att modifiera objektet (i motsats till att tilldela namnet till ett annat objekt, vilket vi gjorde ovan) när den kaskaderande tilldelningen används för muterbara typer. Ta en titt nedan så ser du det från första hand:

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

Kapslade listor är också giltiga i python. Detta innebär att en lista kan innehålla en annan lista som ett element.

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

Slutligen behöver variabler i Python inte hålla samma typ som de först definierades - du kan helt enkelt använda = att tilldela ett nytt värde till en variabel, även om det värdet är av en annan typ.

a = 2 
print(a)
# Output: 2

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

Om detta stör dig, tänk på det faktum att det som är till vänster om = bara är ett namn på ett objekt. Först kallar int objektet med värdet 2 a , då du ändrar dig och besluta att ge namnet a till en string objekt med värdet 'Nytt värde'. Enkelt, eller hur?

Användarinmatning

Interaktiv inmatning

För att få inmatning från användaren, använd input ( Obs : i Python 2.x kallas funktionen raw_input istället, även om Python 2.x har en egen version av input som är helt annorlunda):

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

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

Resten av detta exempel kommer att använda Python 3-syntax.

Funktionen tar ett strängargument som visar det som en prompt och returnerar en sträng. Ovanstående kod tillhandahåller en fråga som väntar på att användaren ska mata in.

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

Om användaren skriver "Bob" och träffar enter, kommer variabelns name att tilldelas strängen "Bob" :

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

Observera att input alltid är av typen str , vilket är viktigt om du vill att användaren ska ange siffror. Därför måste du konvertera str innan du försöker använda den som ett nummer:

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

OBS: Det rekommenderas att du använder try / except block för att fånga undantag när du hanterar användarinsatser . Till exempel, om din kod vill kasta en raw_input till ett int , och vad användaren skriver är ostängbar, höjer det en ValueError .

IDLE - Python GUI

IDLE är Pythons integrerade utvecklings- och inlärningsmiljö och är ett alternativ till kommandoraden. Som namnet antyder är IDLE mycket användbar för att utveckla ny kod eller lära sig python. På Windows kommer detta med Python-tolk, men i andra operativsystem kan du behöva installera den via din pakethanterare.

IDLE: s huvudsakliga syften är:

• Textredigerare med flera fönster med syntaxbelysning, autofyllnad och smart indrag
• Python-skal med syntaxmarkering
• Integrerad felsökare med steg, ihållande brytpunkter och synligheten för samtalstack
• Automatisk intryck (användbar för nybörjare som lär sig om Pythons intryck)
• Spara Python-programmet som .py-filer och kör dem och redigera dem senare när som helst med IDLE.

I IDLE, slå F5 eller run Python Shell att starta en tolk. Att använda IDLE kan vara en bättre inlärningsupplevelse för nya användare eftersom kod tolkas som användaren skriver.

Observera att det finns många alternativ, se till exempel denna diskussion eller denna lista .

Felsökning

• Windows

  Om du är på Windows är standardkommandot python . Om du får ett "'python' is not recognized" -fel är den mest troliga orsaken att Pythons plats inte finns i systemets PATH miljövariabel. Detta kan nås genom att högerklicka på 'Min dator' och välja 'Egenskaper' eller genom att navigera till 'System' genom 'Kontrollpanelen'. Klicka på 'Avancerade systeminställningar' och sedan 'Miljövariabler ...'. Redigera PATH variabeln för att inkludera katalogen för din Python-installation samt skriptmappen (vanligtvis C:\Python27;C:\Python27\Scripts ). Detta kräver administrativa behörigheter och kan kräva en omstart.

  När du använder flera versioner av Python på samma maskin är en möjlig lösning att byta namn på en av python.exe filerna. Att till exempel nämna en version python27.exe skulle göra att python27 blir Python-kommandot för den versionen.

  Du kan också använda Python Launcher för Windows, som är tillgängligt via installationsprogrammet och kommer som standard. Det låter dig välja vilken version av Python som ska köras med py -[xy] istället för python[xy] . Du kan använda den senaste versionen av Python 2 genom att köra skript med py -2 och den senaste versionen av Python 3 genom att köra skript med py -3 .

• Debian / Ubuntu / MacOS

  Detta avsnitt antar att platsen för den körbara python har lagts till i PATH miljövariabeln.

  Om du är på Debian / Ubuntu / MacOS, öppna terminalen och skriv python för Python 2.x eller python3 för Python 3.x.

  Skriv which python att se vilken Python-tolk som kommer att användas.

• Arch Linux

  Standard Python på Arch Linux (och efterkommande) är Python 3, så använd python eller python3 för Python 3.x och python2 för Python 2.x.

• Andra system

  Python 3 är ibland bunden till python istället för python3 . Om du python2 använda Python 2 på dessa system där den är installerad kan du använda python2 .

Datatyper

Inbyggda typer

Booleans

bool : Ett booleskt värde på antingen True eller False . Logiska operationer gillar and , or , not kan utföras på booleska.

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

I Python 2.x och i Python 3.x är en boolean också en int . bool är en underklass av int typen och True and False är dess enda fall:

issubclass(bool, int) # True

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

Om booleska värden används i aritmetiska operationer kommer deras heltal ( 1 och 0 för True och False ) att användas för att returnera ett heltalresultat:

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

Tal

• int : heltal

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

  Heltal i Python är av godtyckliga storlekar.

  Obs: i äldre versioner av Python var en long typ tillgänglig och detta skilde sig från int . De två har förenats.

• float : Flytande punktnummer; precisionen beror på arkitekturen genomförandet och system för CPython den float Datatyp motsvarar en C-dubbel.

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

• complex : Komplexa siffror

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

Operatörerna < , <= , > och >= höjer ett undantag för TypeError när någon operand är ett komplext nummer.

strängar

Sekvenser och samlingar

Python skiljer mellan ordnade sekvenser och oordnade samlingar (som set och dict ).

• strängar ( str , bytes , unicode ) är sekvenser

• reversed : En omvänd ordning på str med reversed funktion

  a = reversed('hello')
  

• tuple : En beställd samling av n värden av vilken typ som helst ( n >= 0 ).

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

  Stödjer indexering; oföränderlig; hashable om alla dess medlemmar är hashable

• list : En beställd samling av n värden ( n >= 0 )

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

  Inte hashable; föränderlig.

• set : En oordnad samling unika värden. Objekt måste vara hashable .

  a = {1, 2, 'a'}
  

• dict : En oordnad samling unika nyckelvärdespar; nycklar måste vara hashable .

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

Ett objekt är hashbart om det har ett hashvärde som aldrig förändras under dess livstid (det behöver en __hash__() -metod) och kan jämföras med andra objekt (det behöver en __eq__() -metod). Hårbara objekt som jämför jämlikhet måste ha samma hashvärde.

Inbyggda konstanter

I samband med de inbyggda datatyperna finns det ett litet antal inbyggda konstanter i det inbyggda namnområdet:

• True : Det verkliga värdet på den inbyggda bool
• False : Det falska värdet på den inbyggda bool
• None : Ett singletonobjekt som används för att signalera att ett värde saknas.
• Ellipsis eller ... : används i kärn Python3 + var som helst och begränsad användning i Python2.7 + som en del av arraynotation. numpy och relaterade paket använder detta som en "inkludera allt" -referens i matriser.
• NotImplemented : en singleton som används för att indikera för Python att en speciell metod inte stöder de specifika argumenten, och Python kommer att prova alternativ om det finns tillgängligt.

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

Testa typen av variabler

I Python, kan vi kontrollera datatyp av ett objekt med inbyggd funktion type .

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

I villkorade uttalanden är det möjligt att testa datatypen med isinstance . Men det uppmuntras vanligtvis inte att förlita sig på variabelns typ.

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

För information om skillnaderna mellan type() och isinstance() läs: Skillnader mellan isinstance och typ i Python

För att testa om något är av NoneType :

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

Konvertering mellan datatyper

Du kan utföra explicita datatypkonvertering.

Till exempel är '123' av str typ och det kan konverteras till heltal med int funktion.

a = '123'
b = int(a)

Konvertering från en floatsträng som '123.456' kan göras med hjälp av float funktionen.

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

Du kan också konvertera sekvens- eller samlingstyper

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

Explicit strängtyp vid definition av bokstavar

Med en bokstavsetikett precis framför citaten kan du berätta vilken typ av sträng du vill definiera.

• b'foo bar' : resultat bytes i Python 3, str i Python 2
• u'foo bar' : resultat str i Python 3, unicode i Python 2
• 'foo bar' : resultat str
• r'foo bar' : resultat så kallad rå sträng, där det inte är nödvändigt att slippa specialtecken, allt tas ordfört när du skrev

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

Muterbara och oföränderliga datatyper

Ett objekt kallas mutable om det kan ändras. När du till exempel skickar en lista till någon funktion kan listan ändras:

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

Ett objekt kallas oföränderligt om det inte kan ändras på något sätt. Heltal är till exempel oföränderliga eftersom det inte finns något sätt att ändra dem:

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

Observera att variablerna själva är muterbara, så vi kan tilldela variabeln x , men detta förändrar inte objektet som x tidigare hade pekat på. Det fick bara x peka på ett nytt objekt.

Datatyper vars instanser är muterbara kallas muterbara datatyper , och på liknande sätt för immutabla objekt och datatyper.

Exempel på oföränderliga datatyper:

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

Exempel på muterbara datatyper:

• bytearray
• list
• set
• dict

Inbyggda moduler och funktioner

En modul är en fil som innehåller Python-definitioner och uttalanden. Funktion är en kodkod som kör en del logik.

>>> pow(2,3)    #8

För att kontrollera den inbyggda funktionen i python kan vi använda dir(). Om du anropar utan argument, returnera namnen i det aktuella omfånget. Annars, returnera en alfabetiserad lista med namn som innehåller (en del av) attributet för det givna objektet och attribut som kan nås från det.

>>> 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'
]

Att veta funktionalitet någon funktion, kan vi använda inbyggd funktion 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.

Inbyggda moduler innehåller extra funktionaliteter. Till exempel för att få kvadratrot av ett nummer måste vi inkludera math .

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

För att känna till alla funktioner i en modul kan vi tilldela funktionslistan till en variabel och sedan skriva ut variabeln.

>>> 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']

det verkar som __doc__ är användbart för att tillhandahålla viss dokumentation i, säg, funktioner

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

Förutom funktioner kan dokumentation också tillhandahållas i moduler. Så om du har en fil med namnet helloWorld.py så här:

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

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

Du kan komma åt dokumentationen så här:

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

• För alla användardefinierade typer kan dess attribut, dess klassattribut och rekursivt attributen för dess klassklasser hämtas med 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__']

Alla datatyper kan enkelt konverteras till sträng med en inbyggd funktion som heter str . Denna funktion kallas som standard när en datatyp skickas för att print

>>> str(123)    # "123"

Blockering

Python använder intryck för att definiera kontroll- och slingkonstruktioner. Detta bidrar till Pythons läsbarhet, men det kräver att programmeraren är uppmärksam på användningen av vitrum. Således kan redaktörens felkalibrering resultera i kod som uppför sig på oväntade sätt.

Python använder kolon symbolen ( : ) och indrag för att visa var block av kod börjar och slutar (om du kommer från ett annat språk, inte ihop detta med något är relaterad till ternära operatör ). Det vill säga, block i Python, såsom funktioner, slingor, if klausuler och andra konstruktioner, har inga slutidentifierare. Alla block börjar med en kolon och innehåller sedan de intryckta linjerna under den.

Till exempel:

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

eller

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

Block som innehåller exakt en enda radsats kan placeras på samma linje, men denna form anses i allmänhet inte vara bra stil:

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

Försök att göra detta med mer än ett enda uttalande kommer inte att fungera:

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

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

Ett tomt block orsakar en IndentationError . Använd pass (ett kommando som inte gör någonting) när du har ett block utan innehåll:

def will_be_implemented_later():
    pass

Mellanslag kontra flikar

Kort sagt: använd alltid fyra utrymmen för intryck.

Det är bara möjligt att använda flikar men PEP 8 , stilguiden för Python-kod, anger att utrymmen föredras.

Många redaktörer har "flikar till mellanslag" -konfiguration. När du konfigurerar redaktör, bör man skilja mellan tabbtecknet (\ t) och Tab-tangenten.

• Tabbtecknet bör konfigureras för att visa 8 utrymmen, för att matcha de språk semantik - åtminstone i de fall när (oavsiktlig) blandad inbuktning är möjlig. Redaktörer kan också automatiskt konvertera flikens karaktär till mellanslag.
• Det kan dock vara till hjälp att konfigurera redigeraren så att du trycker på Tab- tangenten för att sätta in fyra mellanslag istället för att infoga ett flikstecken.

Python-källkod skriven med en blandning av flikar och mellanslag eller med ett icke-standardantal intryckningsutrymmen kan göras pep8-konform med hjälp av autopep8 . (Ett mindre kraftfullt alternativ kommer med de flesta Python-installationer: reindent.py )

Samlingstyper

Det finns ett antal samlingstyper i Python. Medan typer som int och str har ett enda värde, har samlingstyper flera värden.

listor

list är förmodligen den mest använda samlingstypen i Python. Trots namnet är en lista mer som en matris på andra språk, mestadels JavaScript. I Python är en lista bara en ordnad samling av giltiga Python-värden. En lista kan skapas genom att lägga till värden, separerade med komma, i fyrkantiga parenteser:

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

En lista kan vara tom:

empty_list = []

Elementen i en lista är inte begränsade till en enda datatyp, vilket är vettigt med tanke på att Python är ett dynamiskt språk:

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

En lista kan innehålla en annan lista som dess element:

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

Elementen i en lista kan nås via ett index eller numerisk representation av deras position. Listor i Python är nollindexade vilket innebär att det första elementet i listan är på index 0, det andra elementet är vid index 1 och så vidare:

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

Index kan också vara negativa vilket betyder att räkna från slutet av listan ( -1 är indexet för det sista elementet). Så med hjälp av listan från exemplet ovan:

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

Listor är muterbara, så du kan ändra värdena i en lista:

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

Dessutom är det möjligt att lägga till och / eller ta bort element från en lista:

Lägg till objekt i slutet av listan med L.append(object) , returnerar None .

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

Lägg till ett nytt element i listan vid ett specifikt index. L.insert(index, object)

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

Ta bort den första förekomsten av ett värde med L.remove(value) , returnerar None

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

Hämta indexet i listan över det första objektet vars värde är x. Det visar ett fel om det inte finns någon sådan artikel.

name.index("Alice")
0

Räkna längd på listan

len(names)
6

räkna förekomst av något objekt i listan

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

Omvänd listan

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

Ta bort och returnera objektet vid indexet (som standard till den sista artikeln) med L.pop([index]) , returnerar artikeln

names.pop() # Outputs 'Sia'

Du kan iterera över listelementen nedan:

for element in my_list:
    print (element)

tupler

En tuple liknar en lista förutom att den är fast längd och oföränderlig. Så värdena i tupeln kan inte ändras eller värdena läggs till eller tas bort från tupeln. Tuples används vanligtvis för små samlingar av värden som inte behöver ändras, till exempel en IP-adress och port. Tuples representeras med parenteser istället för fyrkantiga parenteser:

ip_address = ('10.20.30.40', 8080)

Samma indexeringsregler för listor gäller också tuple. Tuples kan också häckas och värdena kan vara valfritt giltiga Python.

En tupel med endast en medlem måste definieras (notera komma) på detta sätt:

one_member_tuple = ('Only member',)

eller

one_member_tuple = 'Only member',   # No brackets

eller bara med hjälp av tuple

one_member_tuple = tuple(['Only member'])

ordböcker

En dictionary i Python är en samling par med nyckelvärden. Ordboken är omgiven av lockiga hängslen. Varje par separeras med ett komma och nyckeln och värdet separeras av en kolon. Här är ett exempel:

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

För att få ett värde, hänvisa till det med dess nyckel:

ca_capital = state_capitals['California']

Du kan också få alla nycklarna i en ordlista och sedan iterera över dem:

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

Ordböcker liknar starkt JSON-syntax. Den ursprungliga json modulen i Python-standardbiblioteket kan användas för att konvertera mellan JSON och ordböcker.

uppsättning

En set är en samling element utan upprepningar och utan införingsordning men sorterad ordning. De används i situationer där det bara är viktigt att vissa saker grupperas ihop och inte i vilken ordning de ingick. För stora grupper av data är det mycket snabbare att kontrollera om ett element finns i en set eller inte än att göra samma sak för en list .

Att definiera en set liknar mycket att definiera en dictionary :

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

Eller så kan du bygga en set med en befintlig list :

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

Kontrollera medlemskapet i set med in :

if name in first_names:
    print(name)

Du kan iterera över en set precis som en lista, men kom ihåg: värdena kommer att vara i en godtycklig, implementeringsdefinerad ordning.

defaultdict

En defaultdict är en ordlista med ett standardvärde för nycklar, så att nycklar för vilka inget värde uttryckligen har definierats kan nås utan fel. defaultdict är särskilt användbart när värdena i ordboken är samlingar (listor, dikt osv.) i den meningen att det inte behöver initialiseras varje gång en ny nyckel används.

En defaultdict kommer aldrig att höja en KeyError. Varje nyckel som inte finns får standardvärdet tillbaka.

Tänk till exempel på följande ordlista

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

Om vi försöker få åtkomst till en icke-existerande nyckel returnerar python ett fel enligt följande

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

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

KeyError: 'Alabama'

Låt oss försöka med en defaultdict . Det finns i samlingmodulen.

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

Vad vi gjorde här är att ställa in ett standardvärde ( Boston ) i fall givnyckeln inte finns. Befolka nu dikt som tidigare:

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

Om vi försöker komma åt dikten med en icke-existerande nyckel kommer python att returnera standardvärdet, dvs Boston

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

och returnerar de skapade värdena för befintlig nyckel precis som en vanlig dictionary

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

Hjälpverktyg

Python har flera funktioner inbyggda i tolken. Om du vill få information om nyckelord, inbyggda funktioner, moduler eller ämnen öppnar du en Python-konsol och anger:

>>> help()

Du får information genom att ange nyckelord direkt:

>>> help(help)

eller inom verktyget:

help> help

som visar en förklaring:

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)

Du kan också begära underklasser av moduler:

help(pymysql.connections)

Du kan använda hjälp för att få tillgång till dokumentationen för de olika modulerna du har importerat, prova t.ex.

>>> help(math)

och du får ett fel

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

Och nu får du en lista över tillgängliga metoder i modulen, men bara EFTER du har importerat den.

Stäng hjälpen med att quit

Skapa en modul

En modul är en importerbar fil som innehåller definitioner och uttalanden.

En modul kan skapas genom att skapa en .py fil.

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

Funktioner i en modul kan användas genom att importera modulen.

För moduler som du har gjort måste de vara i samma katalog som filen du importerar dem till. (Du kan dock också lägga dem i Python lib-katalogen med de förmonterade modulerna, men bör undvikas om möjligt.)

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

Moduler kan importeras av andra moduler.

# greet.py
import hello
hello.say_hello()

Specifika funktioner för en modul kan importeras.

# greet.py
from hello import say_hello
say_hello()

Moduler kan vara alias.

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

En modul kan vara fristående körbart skript.

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

Kör det!

$ python run_hello.py
=> "Hello!"

Om modulen finns i en katalog och måste upptäckas med python, bör katalogen innehålla en fil med namnet __init__.py .

Strängfunktion - str () och repr ()

Det finns två funktioner som kan användas för att få en läsbar representation av ett objekt.

repr(x) samtal x.__repr__() : en representation av x . eval konverterar vanligtvis resultatet av denna funktion till det ursprungliga objektet.

str(x) kallar x.__str__() : en människa-läsbar sträng som beskriver objektet. Detta kan leda till viss teknisk detalj.

repr ()

För många typer gör denna funktion ett försök att returnera en sträng som skulle ge ett objekt med samma värde när det skickas till eval() . Annars är representationen en sträng innesluten i vinkelparenteser som innehåller namnet på objektets typ tillsammans med ytterligare information. Detta inkluderar ofta objektets namn och adress.

str ()

För strängar returnerar detta själva strängen. Skillnaden mellan detta och repr(object) är att str(object) inte alltid försöker returnera en sträng som är acceptabel för eval() . Snarare är målet att returnera en utskrivbar eller "mänsklig läsbar" sträng. Om inget argument ges returnerar det den tomma strängen, '' .

Exempel 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

Exempel 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)'

När du skriver en klass kan du åsidosätta dessa metoder för att göra vad du vill:

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)

Med hjälp av ovanstående klass kan vi se resultaten:

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

Installera externa moduler med pip

pip är din vän när du behöver installera ett paket från en mängd olika alternativ som finns tillgängliga på Python-paketets index (PyPI). pip är redan installerad om du använder Python 2> = 2.7.9 eller Python 3> = 3.4 laddas ned från python.org. För datorer som kör Linux eller en annan * nix med en ursprunglig pakethanterare måste pip ofta installeras manuellt.

I fall med både Python 2 och Python 3 installerad hänvisar pip ofta till Python 2 och pip3 till Python 3. Med pip installeras bara paket för Python 2 och pip3 kommer bara att installera paket för Python 3.

Hitta / installera ett paket

Att söka efter ett paket är lika enkelt som att skriva

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

Att installera ett paket är så enkelt som att skriva (i en terminal / kommandotolk, inte i Python-tolkaren)

$ 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

där xxx är versionnumret på paketet du vill installera.

När din server ligger bakom proxy kan du installera paket med kommandot nedan:

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

Uppgradering av installerade paket

När nya versioner av installerade paket visas visas de inte automatiskt på ditt system. För att få en översikt över vilka av dina installerade paket som har blivit föråldrade, kör:

$ pip list --outdated

För att uppgradera en specifik paketanvändning

$ pip install [package_name] --upgrade

Uppdatering av alla föråldrade paket är inte en standardfunktion för pip .

Uppgradera pip

Du kan uppgradera din befintliga pipinstallation med följande kommandon

• På Linux eller macOS X:

  $ pip install -U pip
  

  Du kan behöva använda sudo med pip på vissa Linux-system

• På Windows:

  py -m pip install -U pip
  

  eller

  python -m pip install -U pip
  

För mer information om pip, läs här .

Installation av Python 2.7.x och 3.x

Obs : Följande instruktioner skrivs för Python 2.7 (såvida inte de anges): instruktionerna för Python 3.x är likadana.

WINDOWS

Ladda ner först den senaste versionen av Python 2.7 från den officiella webbplatsen ( https://www.python.org/downloads/) . Version tillhandahålls som ett MSI-paket. För att installera den manuellt, dubbelklickar du bara på filen.

Som standard installerar Python i en katalog:

 C:\Python27\

Varning: installationen modifierar inte automatiskt PATH-miljövariabeln.

Antag att din Python-installation är i C: \ Python27, lägg till detta till din PATH:

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

För att kontrollera om Python-installationen är giltig, skriv i cmd:

python --version

Python 2.x och 3.x sida vid sida

Så här installerar och använder du både Python 2.x och 3.x sida vid sida på en Windows-maskin:

1. Installera Python 2.x med MSI-installationsprogrammet.

   • Se till att Python är installerat för alla användare.
   • Valfritt: lägg till Python till PATH att Python 2.x kan kallas ut från kommandoraden med python .

2. Installera Python 3.x med respektive installationsprogram.

   • Se igen till att Python är installerat för alla användare.
   • Valfritt: lägg till Python till PATH att Python 3.x kan kallas ut från kommandoraden med python . Detta kan åsidosätta Python 2.x PATH inställningar, så dubbelkontrollera din PATH och se till att den är konfigurerad efter dina preferenser.
   • Se till att installera py launcher för alla användare.

Python 3 kommer att installera Python-startprogrammet som kan användas för att starta Python 2.x och Python 3.x utbytbart från kommandoraden:

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.
>>>

För att använda motsvarande version av pip för en specifik Python-version använder du:

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 senaste versionerna av CentOS, Fedora, Redhat Enterprise (RHEL) och Ubuntu kommer med Python 2.7.

För att installera Python 2.7 på linux manuellt, gör bara följande på terminalen:

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

Lägg också till banan för ny python i PATH-miljövariabel. Om ny python är i /root/python-2.7.X kör sedan export PATH = $PATH:/root/python-2.7.X

För att kontrollera om Python-installationen är giltig, skriv i terminalen:

python --version

Ubuntu (från källa)

Om du behöver Python 3.6 kan du installera den från källan som visas nedan (Ubuntu 16.10 och 17.04 har 3.6-version i universalförvaret). Nedanstående steg måste följas för Ubuntu 16.04 och lägre versioner:

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

Mac OS

Som vi talar kommer macOS installerad med Python 2.7.10, men denna version är föråldrad och något modifierad från den vanliga Python.

Den version av Python som levereras med OS X är utmärkt att lära sig men den är inte bra för utveckling. Den version som levereras med OS X kan vara föråldrad från den officiella nuvarande Python-versionen, som anses vara den stabila produktionsversionen. ( källa )

Installera Homebrew :

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

Installera Python 2.7:

brew install python

För Python 3.x, använd kommandot brew install python3 istället.