TIG054 Fortsättning i programmering Flashcards
Kompileringsfel (Compile Error)
Syntaxfel eller liknande
Saker som gör att Python inte förstår koden.
Måste åtgärdas innan programmet kan köras.
Vanligtvis ger kompilatorn felmeddelande.
Ex. print(“Hello, world!”
Ex. print(y), men y är inte definerad
Ex. z = x + y, men x är en int medan y är en string
Ex. Glömt kolon efter if sats
Ex. Felstavat funktion
Exekveringsfel
Runtime Error
Uppstår under programmets gång (inte under kompileringen).
Uppstår när ett program försöker utföra en åtgärd som inte kan slutföras korrekt av olika anledningar.
Ex. Division med noll, index utanför gränserna, nullreferens (referera till variabel som inte har något värde).
Programmet avbryts och ett felmeddelande visas.
Logiska Fel
Fel i själva logiska uppbyggnaden av programmet.
Orsaker inte krascher eller kompileringsfel, men resulterar ändå i ett oönskat beteende eller felaktig resultat när programmet körs.
Ex. Uppstår ofta i komplicerade villkorssatser.
Debugging
Åtgärda fel i programmet.
Identifiera, isolera och korrigera fel (buggar).
Breakpoints
Markeringar som sätts ut där man vill att stegandet ska börja.
Programmet körs som vanligt fram till första breakpointen. Sedan stannar den upp (innan koden på breakpointen körs) och låter den stega fram rad för rad.
Continue (VS Debugging)
Höger pil.
Kör vidare (till nästa breakpoint eller till programslut)
Step In (VS Debugging)
Om det finns ett funktionsanrop på raden, så följ med in i funktionen.
Annars, gå vidare till nästa rad.
Step Over (VS Debugging)
Gå vidare till nästa rad.
Om det finns ett funktionsanrop på raden, utför det bakom kulisserna (hoppa inte in och visa).
Abstraktion (Abstraction)
Process att generalisera konkreta detaljer.
Fokusera på detaljer med större betydelse.
Ex. Skapa klasser av vanligt förekommande objekt, skapa funktioner för vanliga händelser
Användaren av funktionen behöver bara veta dess indata och resultatet, inte nödvändigtvis dess interna arbete
Ex. För vårt Zoo skapar vi en klass Animal med information som namn, id och ålder samt metoder för att komma åt denna information.
Sedan skapar vi subklasser av sköldpadda, lejon och pingvin som inherite från Animal. Animal klassen är således en abstraction eftersom vi aldrig kommer skapa enbart en Animal utan vi skapar ett specifikt djur.
D: Don’t
R: Repeat
Y: Yourself
Stepwise Refinement / Stegvis Förfining
Man bryter ner en komplex uppgift eller system i mindre, mer hanterbara delar (delproblem).
Sedan fokuserar man på att förbättra varje del (problem) steg för steg tills man har en fullständig lösning.
Processen börjar med en övergripande idé eller mål. Sedan delas detta upp i mindre delar eller delproblem.
Passar bäst “i det lilla”, ex. när man ska designa en funktion med sina underfunktioner
Ex. Jackson Structured Programming (JSP), göra det grafiskt
Objektorienterad Programering (OOP)
Programmeringsparadigm/Metod
Programvaran struktureras kring objekt, vilka är grundläggande enheter som innehåller data och metoder för att manipulera den data.
Procedurell Programmering
Programmeringsparadigm/Metod
Programmen struktureras kring sekvenser av instruktioner, kända som procedurer eller funktioner.
Fokus är på att bryta ned problem i mindre delar och lösa dem steg för steg genom att använda sekvenser, selektion (villkor) och iteration (loopar).
Objekt
Ett objekt representerar en entitet i systemet och innehåller data, känd som attribut eller egenskaper, samt metoder, vilka är funktioner som kan användas för att manipulera data.
Ex. Objektet “bil” har attribut som modell, färg och hastighet
Klass
En klass är en mall eller en ritning för att skapa objekt.
Den beskriver strukturen och beteendet för objekt av en viss typ.
Från en klass kan flera objekt skapas, och de delar samma struktur och beteende som definierats av klassen.
Ex.
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
Vad för speciell metod behövs i Python för att skapa en instans av ett objekt?
__init__
Den kallas även för konstruktorn (i andra programmeringsspråk).
Det är en speciell metod i Python som kallas när en instans av en klass skapas
Vad för första argument måste finnas med i __init__ metoden av en klass?
self
Self behövs för att referera till den aktuella instansen av klassen.
När du definierar en metod i en klass i Python, måste den första parametern alltid vara self.
Ex.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
“self “ är en konventionell term, men du kan använda vilket namn du vill, men det är en allmänt accepterad praxis att använda self
När en metod på en klass kallas, skickas den aktuella instansen av klassen automatiskt till metoden som det första argumentet (vanligtvis self). Detta gör att metoden kan arbeta med de attribut och metoder som tillhör den specifika instansen av klassen
Attribut
Datafälten som tillhör ett objekt.
Representerar egenskaper eller tillstånd för objekten som skapas från klassen.
Lagrar data som är associerad med varje instans av klassen.
Attributen definieras inuti klassen och kan vara av olika datatyper, till exempel strängar, heltal, listor, eller till och med andra objekt.
När du skapar en instans av en klass, får varje instans sina egna kopior av klassens attribut. Detta innebär att varje instans kan ha olika värden för sina attribut, och att ändra attributens värden för en instans inte påverkar andra instanser av samma klass
Ex. Kan en klass som representerar en bil ha attributen tillverkare, modell och år
Bil1 är Tesla, Model X, 2023
Bil2 är Volvo, XC40, 2020
Metoder
Funktioner som är definierade i en klass och som används för att manipulera objektens tillstånd eller utföra andra åtgärder relaterade till klassen.
Fungerar som vanliga funktioner, fast knutna till objektet.
Ex. Introduce är en metod i klassen Person
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
print(f"My name is {self.name} and I am {self.age} years old.")
Instans (Objektinstans)
Refererar till en specifik förekomst av en klass.
När du skapar en instans av en klass, skapar du ett konkret objekt baserat på den mall eller blåsprint som klassen representerar.
Ex.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
Skapa instans av klassen ‘Person’
person1 = Person(“Alice”, 30)
Instansvariabler
Instansvariabler är variabler som är associerade med en specifik instans av en klass.
Varje instans av en klass har sina egna kopior av instansvariabler, och ändringar som görs på dessa variabler påverkar bara den specifika instansen.
I Python definieras instansvariabler inuti klassens konstruktor (__init__) med hjälp av self-referensen. När en instans skapas, används konstruktorn för att initialisera dess instansvariabler
Fungerar som vanliga variabler, fast knutna till objektet.
Ex.
class Person:
def __init__(self, name, age):
self.name = name # Instansvariabel
self.age = age # Instansvariabel
Skapa instanser av klassen ‘Person’
person1 = Person(“Alice”, 30)
person2 = Person(“Bob”, 25)
Användning av instansvariabler
print(person1.name) # Output: Alice
print(person2.age) # Output: 25
Hur definieras instansvariabler?
I Python definieras instansvariabler inuti klassens konstruktor (__init__) med hjälp av self-referensen. När en instans skapas, används konstruktorn för att initialisera dess instansvariabler.
Ex. species
class Animal:
def __init__(self, species):
self.species = species
animal1 = Animal(“dog”)
animal1 har en egen kopia av dessa instansvariabler med ett specifikt värde som tilldelats när instansen skapades.
Parameter
En variabel eller värde som används för att överföra data till en funktion eller metod när den kallas.
Parametrar används för att göra funktioner och metoder mer generella och återanvändbara, eftersom de tillåter funktioner att utföra operationer på olika värden utan att behöva hårdkoda dem direkt inuti funktionen.
Ex. a och b i funktionen
def add_numbers(a, b):
return a + b
result = add_numbers(3, 5)
print(result)
Vad behöver alla parameterlistor (samt instansvariabler) inledas med?
Self, som refererar till objektet själv.
När man anropar funktioner i objektet så måste själva objektet skickas med i processen. Detta för att klassen ska veta vilket objekt det är som ska använda sig av funktionen som finns i “ritningen”.
Detta gäller även för funktioner som inte har andra parametrar.
Instansvariablarna börjar med self för att visa att de hör till objektet.
Ex.
class Person:
def __init__(self, name, birth)
self.name = name
self.birth = birth
def updateName(self, name):
self.name = name
Information Hiding
Ett koncept inom objektorienterad programmering som handlar om att begränsa tillgången till viss information eller implementeringsdetaljer om en klass eller ett objekt.
Målet är att isolera och skydda interna detaljer från att bli oavsiktligt eller medvetet ändrade av andra delar av programmet som använder klassen eller objektet.
Genom att tillämpa information hiding kan du kontrollera hur data och metoder används och manipuleras utanför klassens gränssnitt. Detta ökar säkerheten och stabiliteten i koden samt underlättar underhåll och utveckling.
Det finns flera sätt att uppnå information hiding.
Ex. Använd av privata medlemmar, Använda getter/setter-metoder (för att styra åtkomsten och ändringen av attribut)
API
Application Programming Interface
Ett sätt för olika program eller delar av program att kommunicera med varandra och dela data och funktionalitet på ett standardiserat sätt.
API:er kan vara externa, där de tillhandahåller funktioner och data från en annan applikation eller tjänst, eller interna, där de definierar hur komponenter inom en applikation interagerar med varandra
Hur kan man göra information hiding för variabler?
Genom att ge variabler speciella namn.
Oftast finns det konventioner för variabelnamn för att indikera att de är avsedda att vara privata eller skyddade och inte ska manipuleras direkt utanför klassen.
I Python används vanligtvis en konvention med en eller flera understreck (_ eller __) i början av variabelnamnet för att indikera att det är en “protected” eller “private” variabel.
Skyddade: _ Ett enda understreck
Privata: __ Dubbla understreck
Privata använder sig av Name Mangling (inbyggd funktion hos Python)
Name Mangling
En funktion i Python som ändrar namnet på variabler som börjar med dubbla understreck (__) i början av deras namn (dvs. privata variabler).
Detta görs för att förhindra oavsiktlig åtkomst från utanför klassen.
När du definierar en variabel eller metod i en klass med dubbla understreck i början av dess namn, ändrar Python automatiskt namnet på den variabeln eller metoden till _klassnamn__variabel eller _klassnamn__metod där klassnamn är namnet på klassen. Detta gör att variabeln eller metoden inte kan nås utanför klassen med sitt ursprungliga namn.
Ex.
class MyClass:
def __init__(self):
self.__private_variable = “This is a private variable”
def get_private_variable(self):
return self.\_\_private_variable
my_object = MyClass()
print(my_object.get_private_variable()) #Detta funkar
print(my_object.__private_variable) #Detta ger fel
Vad innebär felet “AttributeError”?
Du försöker komma åt en privat variabel genom att kalla på dess variabelnamn istället för att använda dess get-metod.
Donut Model
Donut-modellen, även känd som Donut-programmet eller Donut-hålmönster, är en välkänd design som används i datorsäkerhet för att förklara sårbarheter i system.
Modellen illustrerar ett lagerbaserat skydd för att visa hur olika skyddslager, eller “skyddshål”, kan utnyttjas för att angripa ett system.
I inre “hålet” finns variablerna som är skyddade. Man kommer endast åt deras värden via metoderna som finns i det yttre lagret (getters and setters)
Hur är klassdiagram uppbyggda? Hur ser dem ut?
Ett klassdiagram är en typ av UML-diagram som används för att visualisera strukturen i ett system genom att modellera klasser och deras relationer till varandra.
Klassdiagram visar hur olika klasser är relaterade och hur de samverkar för att uppnå ett visst systemmål.
Klasser: Rektanglar med tre fält: överst visas klassens namn, i mitten visas dess attribut och längst ner visas dess metoder.
Attribut: Attribut är egenskaper eller data som tillhör en klass. De visas i mitten av klassrektangeln och anges vanligtvis med dess namn och datatyp.
Metoder: Funktioner eller operationer som en klass kan utföra. De visas längst ner i klassrektangeln och anges vanligtvis med dess namn, parametrar och returtyp.
Relationer: Relationer mellan klasser visas med linjer som förbinder klasserna.
Public: +
Private: -
Protected: #
Association (Klassdiagram)
Visar att två klasser har en relation till varandra.
En simple association som inte har någon dependency relation.
Representerar i klassdiagram som en enkel ifylld linje mellan två klasser.
Ex. Student - Course
Ex. Bibliotek - Bok
Bibliotek kan associeras med flera böcker, och en bok kan associeras med flera bibliotek. Associationen “innehåller” indikerar att ett bibliotek innehåller böcker, och en bok kan hittas i ett eller flera bibliotek. De är inte beroende av varandra
Aggregation (Klassdiagram)
Visar att en klass innehåller eller består av andra klasser.
Det visar en “har en” (“has a) relation
Det representeras vanligtvis med en ifylld linje med en öppen diamantformad pil.
Ex. Bil ◇- Personer (Passengers)
En person har en eller flera bilar, men bilar kan existera utanför en person.
(Cars may have passengers)
Komposition (Composition) (Klassdiagram)
Liknar aggregation, men med en starkare koppling där den inre klassen är en del av den yttre klassen och inte kan existera utan den.
“When a child object wouldn’t be able to exist without its parent object”
Det representeras vanligtvis med en ifylld linje med en fylld diamantformad pil.
Ex. House (contains) ◆- Room
Ett hus innehåller flera rum, men rummen existerar bara inom huset. (Om huset förstörs/rivs), så kommer även rummen i huset förstöras.
Ex.
class Room:
def __init__(self, size):
self.size = size
class House:
def __init__(self):
self.rooms = [Room(“Living room”), Room(“Bedroom”)]
Arv (Inheritence) (Klassdiagram)
Skapa en instans av underklassen
Arv (inheritance) är ett av huvudkoncepten inom objektorienterad programmering där en klass kan ärva egenskaper och beteenden från en annan klass, som kallas förälderklass eller överklass. Den klass som ärver egenskaper och beteenden kallas barnklass eller underklass.
Arv möjliggör återanvändning av kod och möjliggör en hierarkisk struktur där specialiserade klasser kan bygga på generella klasser
I Python uppnås arv genom att ange förälderklassen som en parameter vid definitionen av en barnklass. När en instans av barnklassen skapas, ärver den automatiskt attribut och metoder från förälderklassen.
Relationen visas med en öppen diamantformad ifylld pil med ett rakt/fullt sträck från barnklassen (subklassen) till föräldrar klassen.
Ex. Animal ◁- Dog
Ex.
class Animal:
def __init__(self, species):
self.species = species
def sound(self):
return "Make a sound"
class Dog(Animal):
#Om vi gör en egen konstruktor för subklassen måste vi importera in de variabler som skapas i föräldrarklassen
def __init__(self, species, breed):
super().__init__(species)
self.breed = breed
def sound(self):
return "Bark"
my_dog = Dog(“Canine”, “Labrador”)
Föräldrarklass/Överklass
En klass som andra klasser härstammar från genom arv i objektorienterad programmering.
En föräldrarklass definierar egenskaper och beteenden som är gemensamma för flera relaterade klasser och kan återanvändas av dess barnklasser.
Dessa attribut och metoder kan ärvas av barnklasserna, vilket innebär att barnklasserna automatiskt får tillgång till och kan använda dem.
Barnklasser/Underklasser
En klass som ärver egenskaper och beteenden från en föräldrarklass genom arv i objektorienterad programmering.
Barnklasser bygger på föräldrarklassens funktionalitet genom att lägga till eller modifiera dess egna metoder och attribut, vilket möjliggör specialisering och anpassning av klasserna för specifika syften.
Barnklasser ärver alla metoder och attribut från föräldrarklassen och kan utöka eller överrider dessa efter behov.
Detta ger möjlighet till återanvändning av kod och förenklar underhåll och förvaltning av koden.
Ex.
class Animal:
def __init__(self, species):
self.species = species
def make_sound(self):
print("Animal makes a sound")
class Dog(Animal): # Dog är en barnklass av Animal
def __init__(self, species, breed):
super().__init__(species)
self.breed = breed
def make_sound(self): # Överrider make_sound-metoden från föräldrarklassen
print("Dog barks")
Skapa en instans av barnklassen
my_dog = Dog(“Mammal”, “Labrador”)
super()
En inbyggd funktion i Python som används för att få åtkomst till metoder och attribut från förälderklassen i en barnklass.
Det möjliggör anrop av metoder och konstruktorer från förälderklassen inuti barnklassens metoder eller konstruktor.
Genom att använda super() i en barnklass kan du anropa metoder från förälderklassen utan att behöva hårdkoda namnet på förälderklassen.
Detta gör koden mer flexibel och minskar duplicering av kod
Syntax: super().metodNamn(argument)
Ex.
class Parent:
def method(self):
print(“Parent method”)
class Child(Parent):
def method(self):
super().method() # Anropa metoden från förälderklassen
print(“Child method”)
Skapa en instans av barnklassen och anropa dess metod
child = Child()
child.method()
#Skriver ut parent method och child method
super().__init__
super().__init__() används för att anropa konstruktorn från förälderklassen (eller överklassen) till en barnklass.
Det används vanligtvis i en barnklasskonstruktor för att initialisera attribut eller utföra andra åtgärder som förälderklassen ansvarar för.
När en barnklass definierar sin egen __init__()-metod och du vill att förälderklassens __init__()-metod ska köras för att göra något extra arbete vid instansiering av barnklassen, då används super().__init__().
Detta gör att du kan undvika att duplicera kod från förälderklassen i barnklassen och låter dig ha mer flexibilitet och bättre underhållbarhet.
Ex.
class Vehicle:
def __init__(self, color):
self.color = color
def display_color(self):
print("Vehicle color:", self.color)
class Car(Vehicle):
def __init__(self, color, brand):
super().__init__(color) # Anropa förälderklassens konstruktor för att initialisera färgen
self.brand = brand
def display_details(self):
super().display_color() # Anropa förälderklassens metod för att visa färgen
print("Car brand:", self.brand)
Skapa en instans av barnklassen
my_car = Car(“Blue”, “Toyota”)
Konvention vid importering av Pandas
import pandas as pd
Konvention vid importering av Numpy
import numpy as np
NumPy
Python-bibliotek som används för att utföra matematiska operationer på arrayer och matriser.
Fördelar med NumPy
- Effektivitet: Hantering av stora dataset och matriser. Beräkningar kan utföras snabbare.
- Sparar på minnet då vi kan välja datatyper i referens till bits - NumPy Arrayer: Mer kraftfulla och flexibel datastruktur än vanliga Python-listor.
- Enklare att utföra matematiska operationer på dataset med flera dimensioner.
- Avancerad indexering och slicing-funktionalitet. Enkelt att extrahera och manipulera data från arrayer på ett effektiv sätt. - Broadcast-Funktionalitet: Möjligt att utföra beräkningar även när dimensionerna på arrayerna inte matchar.
Hur kan vi installera NumPy?
pip install numpy
It is included in Anaconda
Vad för funktion genererar en NumPy Array av jämnt fördelade värden inom ett givet intervall?
np.arrange([start, ], stop, [step, ]
Start: Valfria startvärdet för sekvensen. Om inget anges antas det vara 0.
Stop: Stoppvärdet. Exlusivet, ingår inte i arrayen.
Step: Steget mellan varje efterföljande värde. Om inget anges antas det vara 1.
En bättre “version” av Pythons Range.
Ex. my_array = np.arange(1, 8, 0.5)
Ger
[1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5]
Array
En datatyp som används för att lagra en samling av element, där varje element kan nås via ett indexeringsnummer.
En array kan bestå av element av samma datatyp och kan vara dimensionell (en rad), tvådimensionell (en matris), tredimensionell eller flerdimensionell.
Elementen i en array lagras i minnet i en sekvensiell ordning, vilket gör det möjligt att nå dem genom att använda deras index eller position i arrayen
Vad för funktion skapar en NumPy Array från en befintlig sekvens eller lista?
np.array(objekt, dtype)
Objekt: Den befintliga sekvensen, ex. en lista.
Dtype: Den valfria datatypen för elementen i arrayen. Om inte angiven kommer datatypen att härldeas från de indata som tillhandahålls.
Ex. a = np.array([1, 2, 3])
Ger en array med elementen [1, 2, 3]
Hur kan vi ändra antalet bits som sparas för en datatyp i en NumPy Array?
dtype=np.(datatyp)+(bits)
Ex. dtype = np.int8
Vilket vid print(type(array)) får vi numpy.int8
Vanligtvis är int 64 bits, men vi ändrar detta genom dtype = np.int8
Vad för funktion använder vi för att få storleken på vår NumPy Array?
np.shape(array)
Detta returnerar en tupel med antalet (rader, kolumner)
Vi får formen (dimensionerna) av en array.
Ex. array_2d = np.array([[1,2,3], [4,5,6]])
np.shape(array_2d)
Ger (2, 3) vilket betyder att vi har 2 rader och 3 kolumner
Hur fungerar indexeringen för NumPy Arrayer?
array[row_index, column_index]
Ex. my_array[1, 2] = Element på rad 2 och kolumn 2
Slicing för Arrayer
array[start_row:end_row, start_column:end_column]
start_row: Startindex för raderna som ska extraheras.
end_row: Slutindex för raderna som ska extraheras. Notera att det sista indexet inte inkluderas.
start_column: Startindex för kolumnerna som ska extraheras.
end_column: Slutindex för kolumnerna som ska extraheras. Notera att det sista indexet inte inkluderas.
Några viktiga punkter att tänka på:
För att extrahera hela rader eller kolumner kan du använda : som en platsmarkör.
Ex. array[:, 1] extraherar hela kolumnen med index 1
Hur skapar vi en array fylld med nollor?
np.zeros(shape, dtype)
Shape: En tuple som beskriver dimensionerna på arrayen (rader, kolumner)
Dtype (Valfritt): Datatypen för elementen i arrayen. Standardvärde är “float”
Ex. np_zeros = np.zeros((2, 3)) skapar en tvådimensionell array med 2 rader och 2 kolumner
[[0. 0. 0.] [0.0.0]]
Ex. Np_zeros = np.zeros(5)
Hur beräknar vi medelvärdet av elementen i en array?
np.mean(array, axis)
Array: Arrayen
axis (valfritt): Axel längs vilken medelvärdet ska beräknas. Om inte angivet beräknas medelvärdet över hela arrayen, dvs axis=None
Ex. my_array_1 = np.array([[0, 1, 2, 3, 4],[10, 11, 12, 13, 10],
[30, 43, 11, 50, 30]])
medel = np.mean(my_array_1, axis=0)
Ger [13.33333333 18.33333333 8.33333333 22. 14.66666667]
Ex. medel = np.mean(my_array_1)
Ger 15.333333333333334
axis=None
Operationen utförs över hela arrayen.
axis=0
Operationen utförs längs raderna.
Lodrätt.
Ex. my_2d_array = np.array([[20, 30, 40], [10, 10, 20]])
np.mean(my_2d_array, axis=0)
Ger [15. 20. 30.]
axis=1
Operationen utförs över kolumnerna.
Vågrätt
Ex. my_2d_array = np.array([[20, 30, 40], [10, 10, 20]])
print(np.mean(my_2d_array, axis=1))
Ger [30. 13.33333333]
axis=-1
Motsvarar den sista axeln i en array, vilket är axeln som löper längs raderna.
Vågrätt
Ex. my_2d_array = np.array([[20, 30, 40], [10, 10, 20]])
print(np.mean(my_2d_array, axis=-1))
Ger [30. 13.33333333]
Vad finns det för begränsningar med Python listor (i jämförelse med NumPy Array)?
Omöjligt att plocka ut specifika element från Python Listor.
Ex. my_list[[1, 3, 4]] ger fel, medan detta fungerar för Array där vi får elementet på index 1, index 3 och index 4.
Ex. my_list{my_list>12] ger fel, medan detta fungerar för Array där vi får alla element i arrayen som har ett värde större än 12.
Vad betyder kommatecken (,) vid indexing för arrayer?
Kommatecken skiljer mellan varje dimension.
Ex. my_2d_array[1,3] ger elemented som ligger på rad 1 och kolumn 3.
Vad ger detta för utskrift?
my_2d_array = np.array([[0, 1, 2, 3, 4], [10, 11, 12, 13, 10], [30, 43, 11, 50, 30]])
print(my_2d_array[1:, [1, 3, 4]])
En array med [[11 13 10]
[43 50 30]].
Den plockar ut varje element på index 1, index 3 och index 4 från och med rad 1.
Tänk att varje rad är en lista där indexen börjar från 0 på första elementet.
Vad för värden för new_array?
new_array = old_array + 3
new_array tar alla värden i old_array och adderar dem med 3 och sparar i new_array.
Detta fungerar på samma sätt för alla andra matematiska funktioner.
Fungerar även med slicing av arrayer.
Ex. new_array = old_array[:, 2] + 3 innebär att new_array tar alla element som finns på index 2 (alla element i kolumn 2) och adderar dem med 3, sedan sparas dem i new_array.
Vad för element får new_array?
new_array = old_array + old_array
Innebär att elementen i old_array adderas med sig själv och läggs in i new_array.
Ger samma resultat som new_array = old_array * 2
my_array[my_array<3] = 0
Betyder att alla element i my_array som är mindre än 3 kommer tilldelas värdet 0 istället.
Fungerar på samma sätt med matematiska funktioner
Ex. my_array[my_array<3] += 5
Vad för datatyper kan en NumpyArray ha?
Flera olika.
Int, float, bool, string, etc.
Dessa kan vara i olika bits.
Kan man mixa datatyper i en NumPy Array?
Nej. De måste vara samma datatyper.
NumPy arrays är designade att vara “homogeneous”.
Om man ska göra matematiska funktioner mellan två olika arrayer, kan de ha olika shapes?
Nej.
De måste ha samma datatyp och samma dimensioner.
Ex. my_array_1 = np.array([[10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20]])
my_array_2 = np.array([[0, 1, 2, 3, 4], [10, 11, 12, 13, 10], [30, 43, 11, 50, 30]])
mix_array = my_array_1 + my_array_2
Ger fel
Vad för funktionen beräknar summan av elementen i en NumPy Array?
np.sum(Array, [axis])
Array: Arrayen
axis (valfritt): Axel längs vilken medelvärdet ska beräknas. Om inte angivet beräknas medelvärdet över hela arrayen, dvs axis=None
Ex. my_array_1 = np.array([[0, 1, 2, 3, 4],[10, 11, 12, 13, 10],])
summa = np.sum(my_array_1)
Ger 66
Ex. summa = np.sum(my_array_1, axis=0)
Ger [10 12 14 16 14]
Vad för funktionen returnerar det minsta värdet i en NumPy Array?
np.min(array, [axis])
axis (valfritt): Axel längs vilken medelvärdet ska beräknas. Om inte angivet beräknas medelvärdet över hela arrayen, dvs axis=None
Ex. my_array_1 = np.array([[0, 1, 2, 3, 4], [10, 11, 12, 13, 10]])
minsta = np.min(my_array_1, axis=1)
Ger [ 0 10]
Ex. minsta = np.min(my_array_1)
Ger 0
Vad för funktionen returnerar det största värdet i en NumPy Array?
np.max(array, [axis])
axis (valfritt): Axel längs vilken medelvärdet ska beräknas. Om inte angivet beräknas medelvärdet över hela arrayen, dvs axis=None
Ex. my_array_1 = np.array([[0, 1, 2, 3, 4], [10, 11, 12, 13, 10]])
största = np.max(my_array_1)
Ger 13
Ex. största = np.max(my_array_1, axis=-2)
Ger [10 11 12 13 10]
Vad för funktionen returnerar indexen på det största värdet i en NumPy Array?
np.argmax(array, [axis])
axis (valfritt): Axel längs vilken medelvärdet ska beräknas. Om inte angivet beräknas medelvärdet över hela arrayen, dvs axis=None
Ex. my_array_1 = np.array([[0, 1, 2, 3, 4], [10, 11, 12, 13, 10]])
största_index = np.argmax(my_array_1)
Returnerar 8
Ex. största_index = np.argmax(my_array_1, axis=1)
Ger [4 3]
Hur “räknas”/”tilldelas” elementen sina index i en NumPy Array med flera dimensioner?
rad 0: 0, 1, 2, 3, 4, …
rad 1: 0, 1, 2, 3, 4, …
osv.
Om man använder matematiska funktioner kan detta ändras beroende på axis.
Ex. axis=0
rad 0: 0, 0, 0, 0, …
rad 1: 1, 1, 1, 1, …
rad 2: 2, 2, 2, 2,
Vad för funktionen returnerar indexen på det minsta värdet i en NumPy Array?
np.argmin(array, [axis])
axis (valfritt): Axel längs vilken medelvärdet ska beräknas. Om inte angivet beräknas medelvärdet över hela arrayen, dvs axis=None
Ex. my_array_1 = np.array([[0, 1, 2, 3, 4], [10, 11, 12, 13, 10]])
minsta_index = np.argmin(my_array_1)
Ger 0
Ex. minsta_index = np.argmin(my_array_1, axis=0)
Ger [0 0 0 0 0]
Ex. minsta_index = np.argmin(my_array_1, axis=1)
Ger [0 0]
Vad är Pandas?
En populär Python-baserad programvarubibliotek som används för datahantering och dataanalys.
Det erbjuder datastrukturer och funktioner för att effektivt manipulera och analysera strukturerade data.
Pandas kan läsa och skriva data från och till olika datakällor, inklusive CSV-filer, Excel-filer, SQL-databaser, JSON-filer, HTML och mycket mer
Hur skapar vi en DataFrame i Pandas?
pd.DataFrame(data)
Ex. df = pd.DataFrame(data=(“äpple”, “banan”, “päron”))
Ger 0
0 äpple
1 banan
2 päron
Ex. data = (“äpple”, “banan”, “päron”)
df = pd.DataFrame(data)
Som ger samma.
Ex. data = {‘Name’: [‘Fanny’, ‘Patrik’, ‘Charlie’], ‘Age’: [21, 30, 25], ‘City’: [‘Göteborg’, ‘Stockholm’, ‘Nashville’]}
df = pd.DataFrame(data)
Ger
Name Age City
0 Fanny 21 Göteborg
1 Patrik 30 Stockholm
2 Charlie 25 Nashville
pd.DataFrame(data={‘col1’: [x, y, z], ‘col2’: [a, b, c]})
Hur kan vi “tilldela” våra kolumner namn i Pandas?
Genom användning av Dictionaries.
Ex. data = {‘Name’: [‘Fanny’, ‘Patrik’, ‘Charlie’], ‘Age’: [21, 30, 25], ‘City’: [‘Göteborg’, ‘Stockholm’, ‘Nashville’]}
Varje key blir kolumnnamnet.
Vad för funktion använder vi för att hämta kolumnens etiketter (namn) från en Pandas Dataframe?
df.columns
df: Namnet på den DataFrame man skapat
Ex.
data = {‘Name’: [‘Alice’, ‘Bob’, ‘Charlie’], ‘Age’: [25, 30, 35], ‘City’: [‘New York’, ‘Los Angeles’, ‘Chicago’]}
df = pd.DataFrame(data)
columns = df.columns
Ger Index([‘Name’, ‘Age’, ‘City’], dtype=’object’)
Det returnerar alltså en Index som innehåller namnen på kolumnerna i DataFrame
Vad för funktion använder vi för att hämta antalet radindex i en Pandas DataFrame?
df.index
df: Namnet på den DataFrame man skapat
Ex.
data = {‘Name’: [‘Alice’, ‘Bob’, ‘Charlie’], ‘Age’: [25, 30, 35], ‘City’: [‘New York’, ‘Los Angeles’, ‘Chicago’]}
df = pd.DataFrame(data)
index = df.index
Vilket ger RangeIndex(start=0, stop=3, step=1)
Den returnerar alltså ett RandeIndex-objekt som innehåller radindexen för DataFramen.
- I exemplet är det en numerisk sekvens från 0 till 2.
Vad för funktion använder vi för att extrahera de faktiska värdena från DataFrame (utan att inkludera rad- eller kolumnindex)?
Vad returnerar funktionen?
df.values
df: Namnet på den DataFrame man skapat
Funktionen returnerar en tvådimensionell NumPy-Array som innehåller datavärden från DataFrame
Ex.
data = {‘Name’: [‘Alice’, ‘Bob’, ‘Charlie’], ‘Age’: [25, 30, 35], ‘City’: [‘New York’, ‘Los Angeles’, ‘Chicago’]}
df = pd.DataFrame(data)
values = df.values
Ger [[‘Alice’ 25 ‘New York’]
[‘Bob’ 30 ‘Los Angeles’]
[‘Charlie’ 35 ‘Chicago’]]
Ex. np.shape(values)
Ger (3,3) vilket betyder att den har 3 rader och 3 kolumner.
Hur gör man för att få ut specifik kolumndata från en Pandas DataFrame?
df[‘kolumnnamn’]
kolumnnamn: Namnet på den kolumn du vill ha information om.
Ex.
data = {‘Name’: [‘Alice’, ‘Bob’, ‘Charlie’], ‘Age’: [25, 30, 35], ‘City’: [‘New York’, ‘Los Angeles’, ‘Chicago’]}
df = pd.DataFrame(data)
print(df[‘Name’])
Ger
0 Alice
1 Bob
2 Charlie
Name: Name, dtype: object
