Python-språket Lathund

Python är ett plattformsoberoende programmeringsspråk. Det är ett objektorienterat språk med dynamisk typning, ursprungligen designat för att skriva automatiseringsskript (shell). Med kontinuerliga uppdateringar av versioner och tillägg av nya språkfunktioner används det alltmer för utveckling av oberoende, storskaliga projekt.

Allmänt

• Python är skiftlägeskänsligt (distinguerar mellan stora och små bokstäver)
• Python-index börjar på 0
• Python använder blanksteg (tabbar eller mellanslag) för att dra in kod istället för att använda klammerparenteser.

Hjälp (Help)

Moduler (Bibliotek)

Import-satsen skapar en ny namnrymd och kör alla satser i den tillhörande .py-filen inom den namnrymden. Om du vill ladda modulinnehåll till den nuvarande namnrymden, använd “from module1 import *”

Skalära typer

Kontrollera datatyp: type(variable)

Heltal (Integers)

int/long - Stora heltal konverteras automatiskt till långa heltal (i Python 3 finns bara int, som hanterar alla storlekar).

Flyttal (Floats)

float - 64-bitars, det finns ingen "double"-typ.

Booleanska värden (Booleans)

bool - Sant (True) eller Falskt (False).

Strängar (Strings)

str - Python 2.x standard: ASCII; Python 3: Unicode.

• Strängar kan vara inom enkla/dubbla/trippla citattecken.
• En sträng är en sekvens av tecken och kan därför behandlas som vilken annan sekvens som helst.
• Specialtecken kan representeras genom att föregå dem med \ eller r (raw strings) som börjar med r.

  str1 = r'detta\f?ff'
• Strängformatering kan göras på flera sätt.

  template = '%.2f %s haha $%d'
  str1 = template % (4.88, 'hola', 2)

str(), bool(), int() och float() är också explicita typkonverteringsfunktioner.

Null-värde (Null)

NoneType(None) - Pythons ’null’-värde (det finns bara en instans av None-objektet).

• None är inte ett reserverat nyckelord, utan den unika instansen av “NoneType”.
• None är ett vanligt standardvärde för valfria funktionsparametrar:

  def func1(a, b, c = None)
• Vanlig användning av None:

  if variable is None :

Datum och tid

datetime - Inbyggd Python “datetime” modul tillhandahåller typerna “datetime”, “date”, “time” etc.

• “datetime” kombinerar information som lagras i “date” och “time”.

  Skapa datetime från sträng	dt1 = datetime.strptime(‘20091031’, ‘%Y%m%d’)
  Hämta “date”-objekt	dt1.date()
  Hämta “time”-objekt	dt1.time()
  Formatera datetime till sträng	dt1.strftime(’%m/%d/%Y %H:%M’)
  Ändra fältvärde	dt2 = dt1.replace(minute = 0, second=30)
  Hämta skillnad	diff = dt1 - dt2 # diff är ett ‘datetime.timedelta’ objekt

Datastrukturer

Tupler (Tuples)

En tupel är en sekvens med fast längd som inte kan modifieras.

Listor (Lists)

En lista är en sekvens med variabel längd där element kan modifieras.

Observera:

• “Start” index inkluderas, men “Stop” index inkluderas inte.
• start/stop kan utelämnas, standard är början/slutet.

Slicing (Utsnitt)

Sekvenstyper inkluderar ‘str’, ‘array’, ’tuple’, ’list’ etc.

list1[start:stop]
list1[start:stop:step]
list1[::2]
str1[::-1]

Dictionaries (Hash)

Mängder (Sets)

En mängd är en oordnad samling av unika element.

Funktioner

• Grundform

  def func1(posArg1, keywordArg1 = 1, ..):

• “Funktioner är objekt” vanlig användning:

  def func1(ops = [str.strip, user_define_func, ..], ..):
      for function in ops:
          value = function(value)

• Returvärden

  • Om funktionen slutar utan return-sats returneras inget värde (None).
  • Returnera flera värden via ett tupelobjekt.

  return (value1, value2)
  
  value1, value2 = func1(..)

• Anonyma funktioner (Lambda)

  lambda x : x * 2
  # motsvarar:
  # def func1(x) : return x * 2

Vanliga funktioner

1. Enumerate: returnerar en sekvens av (index, värde) tupler, där index är det nuvarande objektets index.

   for key, val in enumerate(collection):

2. Sorted: sorterar alla itererbara objekt.

   sorted([2, 1, 3]) => [1, 2, 3]

3. Zip: packar ihop motsvarande element från objekten i tupler och returnerar en lista bestående av dessa tupler.

   zip(seq1, seq2) => [('seq1_1', 'seq2_1'), (..), ..]

4. Reversed: returnerar en omvänd iterator.

   list(reversed(range(10)))

Kontroll och flöde (Control Flow)

1. Operatörer för “if else” villkor:

   Kontrollera om två variabler är samma objekt	var1 is var2
   Kontrollera om två variabler är olika objekt	var1 is not var2
   Kontrollera om två variabler har samma värde	var1 == var2

2. Vanlig användning av for-operatorn:

   for element in iterator :

3. ‘pass’ - Gör ingenting, används oftast som platshållare.

4. Ternärt uttryck

   value = true-expr if condition else false-expr

5. Det finns inga switch/case-satser, använd if/elif istället.

Objektorientering (OOP)

1. ‘object’ är basen för alla Python-typer.

2. Allt (nummer, strängar, funktioner, klasser, moduler etc.) är ett objekt, och varje objekt har en ’type’. Objektvariabler är pekare till deras plats i minnet.

3. Grundform för ett objekt

   class MyObject(object):
       # 'self' motsvarar 'this' i Java/C++
       def __init__(self, name):
           self.name = name
   
       def memberFunc1(self, arg1):
           ..
   
       @staticmethod
       def classFunc2(arg1):
           ..
   
   obj1 = MyObject('name1') 
   obj1.memberFunc1('a') 
   MyObject.classFunc2('b')

4. Interaktiva verktyg:

   dir(variable1) # Lista alla tillgängliga metoder på objektet

Strängoperationer

Foga samman lista/tupel med en avgränsare:

', '.join([ 'v1', 'v2', 'v3']) => 'v1, v2, v3'

Formatera sträng:

string1 = 'My name is {0} {name}'
newString1 = string1.format('Sean', name = 'Chen')

Dela upp sträng:

sep = '-'
stringList1 = string1.split(sep)

Hämta delsträng (slice):

start = 1
string1[start:8]

Fyll sträng med nollor (zero-pad):

month = '5'
month.zfill(2) => '05' 
month = '12'
month.zfill(2) => '12'

Undantagshantering (Exception Handling)

1. Grundform

try:
    ..
except ValueError as e:
    print(e)
except (TypeError, AnotherError):
    ..
except:
    ..
finally:
    ..

2. Manuellt utlösa undantag

raise AssertionError # Assertion misslyckades
raise SystemExit # Begär att programmet avslutas
raise RuntimeError('Error message :..')

List, Set och Dictionary Comprehension

Syntaktiskt socker för att göra kod lättare att läsa och skriva.

1. List Comprehension:

   Formar kortfattat en ny lista genom att filtrera element i en samling och transformera de element som klarar filtret i ett uttryck.

   Grundform:

   [expr for val in collection if condition]

   Genväg för:

   result = []
   for val in collection:
       if condition:
           result.append(expr)

2. Dictionary Comprehension:

   {key-expr : value-expr for value in collection if condition}

3. Set Comprehension: Samma som list comprehension, men med {} istället för [].

4. Nested List Comprehension (nästlad):

   Grundform:

   [expr for val in collection for innerVal in val if condition]