Python är ett programspråk som lanserades 1991 av Guido van Rossum. Det är vanligt som nybörjarspråk och inom undervisning, men också som generellt programspråk med tillämpning inom många olika domäner.

• Operatornerna + * går att använda på strings str * 3 >> HundHundHund

{vad:hur}

Exempel - {vaiabel:10.4f} :10 = Lägg 10st tomma "spaces" längst bak till nästa objekt - (Typ som "Insert") :04 = Int med 4st 0:or framför .4f = Lägg 4st decimaler efter commat - (F för float) :,} = Seperators tex 100,000,000

Slices i string

a = 'Hej där du'
b = a[4:7]
print(b)

> där

Slices med nästlade listor/dicts osv.

listor = [[1, 2], [3, 4], [5, 6]]
print(listor[0][0])

> 1

snake_case

• Små bokstäver
• Ej börja med siffror! ``
• Ord separeras med _ user_input = 'blabla'
• STORA BOKSTÄVER = Statisk variable, variabel som aldrig kommer byta innehåll.

Variabler som ALDRIG kommer att ändras, skirvs med STORA BOKSTÄVER. PI = 3,141.

Tal

tal = 100_000_000

• Stora tal kan göras lättare att läsa med _, påverkar inte koden.
• Använd f{x:,} för att skriva ut tal med seperators.

Unpacking

_, *c__

• Variabler som du inte vill skriva ut kan kallas "_"
• Detta kan vara bra när IDE:n klagar på att variabeln inte används.

a, b, c, *_ = (1, 2, 3, 4, 5)
print(a)
print(b)
print(c)

ZIP

• Används för att tex knyta ihop två eller fler listor.
• Om listorna är olika långa så stoppar ZIP när den minsta listan är slut (vill du ha största listan, använd itertools-modulen)

names = ['Peter Parker', 'Clark Kent', 'Wide Wilson', 'Bruce Wayne']
heros = ['Spiderman', 'Superman', 'Deadpool', 'Batman']

for name, hero in zip(names, heros):
    print(f'{name} is actually {hero}')

>>>
Peter Parker is actually Spiderman
Clark Kent is actually Superman
Wide Wilson is actually Deadpool
Bruce Wayne is actually Batman

Float = Tal med decimaler eller tex 1.2e34 vilket är desamma som 1.210^34

Int = Heltal utan decimaler

(För formatering av utskriften, se veriabler)

list = ['Bob', 'Eve', 'Pete', 'Jan', 'Kalle']

blalba

blalba

tuple = ('Bob', 'Eve', 'Pete', 'Jan', 'Kalle')

• Read-only

my_dictionary = {
	'namn': 'Kalle',
	'ålder': 23,
	'kompisar': ['Bob', 'Peter', 'Jakob']
}

En klass fungerar som ett skelett eller en ram för objekt. Klassen definierar hur objekten som stoppas in skall se ut. Tillexempel här ovan är en klass som definierar vad en person är. Så man lätt kan mata in värdena i klassen och definiera en person.

class Person:

    def __init__(self, name, age, is_male):
        self.name = name
        self.age = age
        is_male = is_male
        is_running = False

    def walk(self):
        self.is_running = False
        return ('Walking...')

    def run(self):
        self.is_running = True
        return ('Walking...')


user = Person('Bob', 25, True)
print(user.name)
user.walk()

@classmethod

Funktioner som påverkar information om själva klassen, exemplet nedan ändrar procentsatsen för löneförhöjning på klassen / till alla objekt. OBS! Om funktionen

Alternative constructors

Man kan använda en @classmethod thill att bygga upp instanser, dessa brukar man döpa till from..

@staticmethod

Funktioner inom en klass som inte påverkar information från varken klass eller objekten. Typ en funktion som tar ett datum och ser om det var en "working day". Tex.

class Employee:
    @staticmethod
    def is_workday(day):
        if day.weekday() == 5 or day.weekday() == 6:
            return False
        return True

@property

Man kan ange en instansvariabels property till att vara en set eller get metod.

Setters

Metod/funktion som ändrar instansvariabel eller klassvariabel i klassen. Tips, använd "assert" för att specificera vad du vill ha ut för information. Snyggt att använda properties, och skriva tex. @r.setter

Getters

Metod/funktion som hämtar data från instansvariabeln eller klassvariabeln. Man kan använda @property för att hämta informationen bättre.

Deleters

Tar bort attributer datan i ett instance. Alltså self.name = 'Bob' före och self.name = None efter. Snyggt att döpa @variabel.deleter

Inkapsling

Gömmer information inne i objekten, finns inte riktigt i Python. Det man kan göra är att byta init

Private variabler/methods

Instansvariabler eller instansmetoder som endast är kända inuti en klass, de skall inte åtkommas "utifrån". Dessa döps ett _ i början. Tex _stopp Man kan också använda två st __, då blir det extra "privat", detta skall användas med god kunskap. Kolla name mangling. Instansvariablerna till dessa brukar använda en set-metod för att få informationen från användaren. Eller med en @variabel.setter.

Public

Instansvariabler eller instansmetoder som kan "kommas åt" utanför klassen

Name mangling

__variabel, Man sätter 2st understreck framför variabeln för att göra den extra "private". Inom klassen cirkel så kommer __r att ha namnet _Crikel__r utanför klassen.Inne i klassen kan man fortfarande använda __r. c = Cirkel() print(c.__r) Kommer INTE att fungera. Vilket gör var eller metoden mer oåtkomligt utifrån. Detta följer dock inte Pythons konvention.

Inheritance

Klasser kan ärva sina förälderklassers attributer, för att slippa upprepad kod. Tex. Animal -> Mamals -> Human

class Barn(Förälder)

Syntax:

class WorkingStudent(Student):
    def __init__(self, name, school, salary):
        super().__init__(name, school)
        self.salary = salary

Subclass Är en "childklass", en klass som ärver attributes från en annan klass. Syntax: class Child_klass(Parent_class): def init(self, parametrar): super().init(parametrar till Parent_class, ny_parameter_för_denna_klass) self.ny_parameter_för_denna_klass = ny_parameter_för_denna_klass

Statisk bindning

blabla

Körs denna fil direkt eller blir den importerad från en annan fil?
True ifall python INTE har importerat koden.

if __name__ == __main__

Visar alla instance variabler som en lista

Greater. | Kolla eq

Greater than or equal | Kolla eq

Less than. | Kolla eq

Är en ”Constructor”, alltså en funktion som "bygger upp" objektet medhjälp av instansvariablerna som vi satt.

Less or equal | Kolla eq

class Club:
    def __init__(self, name):
        self.name = name
        self.players = []

    def __getitem__(self, i):
        return self.players[i]

Represents the object to other code.

isinstance(hund_1, människa) Kollar om vovve är en instance i hundklassen. Detta skulle retunera false, för att vovve är instance i hundklassen och alla föräldrar där innan i trädet, såsom mamal, djur osv.

issubclass(hund, mamal) Returnerar true för att hund är en subklass av mamal. Går upp i trädet av klasser, ej sidleds.

OBS! Kopior av objekt som i sin tur pekar bak på andra objekt, tillexempel en bil klass som pekar tillbaka på en person-klass. Ifall jag skulle vilja ändra på en kopia av bilobjekt så kan jag endast byta tillexempel färg på objektet, men om jag byter namn på ägaren påverkas alla kopior av det bilobjektet. Man kan gå runt detta med hjälp av en deepcopy, som finns i copymodulen.

JavaScript Object Notation

{
    "key": "value",
    "namn": "Bob",
    "age": 24,
    "isProgrammer": true,
    "hobbies": ["Weight Lifting", "Bowling"],
    "friends_array": [{
        "name": "Joey",
        "age": 36,
        "isProgramming": false,
    }]
}

• Strings
• Numbers
• Booleans
• Null
• Listor (JS arrays)
• Dicts (JS Objects)

• Kompakt textpaserat format
• Används för att utbyta data
• Lightweight(small file size), används därför ofta på nätet.
• Lätt att läsa, jämfört med typ XML
• Lättare att integrera/använda i tex JavaScript eller Python

• Snacka med API:er
• Config filer för appar

• Lätt, kompakt och riktigt snabb
• Kan spara både i RAM-minne och i databasen(fil)
• Dålig på att skriva då endast en person kan skriva samtidigt
• Passar små applikationer som typ i din smartphone, där endast en person skriver data samtidigt

SQL queries

CREATE TABLE

Skapar ett nytt table och specifierar vad den ska innehålla om tablet inte redan finns dvs.

CREATE TABLE IF NOT EXISTS books(name TEXT PRIMARY KEY, author TEXT, read INTEGER)

INSERT

INSERT INTO <table> VALUES (värde, värde, värde....)

SELECT

SELECT <columns> FROM <table> 

WHERE

UPDATE <table> SET <columns> WHERE <column>=<vad> 

UPDATE

UPDATE <table> SET <column>=<till-vad> WHERE <column>=<vad> 

DELETE

DELETE FROM <table> WHERE <column>=<vad> 

För att använda SQLite i Python

1. Importera sqlite3 modulen | import sqlite3
2. Connecta | connection = sqlite3.connect('data.db')
3. Skapa en cursor | cursor = connection.cursor()
4. Använd cursorn för att executa önskad SQL Query | cursor.execute('SQL QUERY HERE')
5. Commita ändringen |connection.commit()
6. Avbryt connection |connection.close()

• Operationer utförs med cursors
• Endast en cursor kan användas åt gången, för att write data.
• Flera cursors kan användas samtidigt för att read data

• "Saves the result of this query to the disk"
• Detta för att hålla datan i minnet tills vi är redo och commita allt samtidigt till disken.
• Det går även snabbare att skriva över mycket data samtidigt istället för lite data itaget.

• A new thread is spawned within the existing process.
• Starting a thread is faster than starting a process.
• Memory is shared between all threads.
• Mutexes often necessary to controll acces to shared data.
• One GIL (Global Interperter Lock) for all threads.

• A new process is started independent from the frist process.
• Starting a process is slower than starting a thread.
• Memory is not shared between processes.
• Mutexes is necessart (unless threading in the new process).
• One GIL (Global Interperter Lock) for all threads.

• Synchronous = actions that happen one after another. Programming as we've seen it until now is synchronous, because each line executes after the previous one.

• Asynchronous = actions that don't necessary happen after one another, or that can happen in arbitrary order ("without synchrony").

• Concurrency = The ability of our programs to run things in different order every time the program runs, without affecting the final outcome.

• Parallelism = Running two or more things at the same time.

• Thread = A line of code execution that can run in one of your computer's cores.

• Process: One of more threads and the resources they need (e.g. network connection, mouse pointer, hard drive access, or even the core(s) in which the thread(s) run).

• GIL = A key, critical, important resource in any Python program. Only one is created per Python process, so it's unique in each.

• Time slicing = När många trådar vill köras samtidigt och alla datorns kärnor är upptagna. Får varje tråd en bestämd tid i kärnan, för att sendan ställa sig på "kö" igen. Annars skulle trådarna som väntar kanske aldrig köras.

• Trådar kan förkorta "waiting time"
• Kan användas när python väntar på en "blocking operation" som tillexempel en user_input. Kan threading användas för att använda tiden för att kalkylera andra operationer istället för att vänta.
• Om alla dina trådar är upptagna, så kommer flera trådar inte hjälpa.
• Ditt OS kommer att ge prioritet till trådar som gör saker, så om din tråd "väntar" så kommer den att köras mer sällan.

• Never kill threads! Om du dödar en thread så kommer den troligtvis inte ge tillbaka "the GIL", vilket kommer resultera att ditt python program kommer att stoppas. Inte avslutas men stoppas, en såkallad deadlock.

blabla