Python‐introduction‐to‐programming - itnett/FTD02H-N GitHub Wiki

Her er en grunnleggende forklaring på skriptet du har delt, formatert i GitHub Wiki markdown med emojis for å gjøre det mer visuelt:

# 🐍 Grunnleggende Python-skript: Boolske variabler og utskrift

Dette skriptet demonstrerer bruk av **boolske variabler** og funksjonen `print` i Python.

### 📚 Variabler:
- **`likes_cheese`** (bool): En boolsk variabel som indikerer om brukeren liker ost.
- **`has13Apples`** (bool): En boolsk variabel som indikerer om brukeren har 13 epler.

Skriptet skriver ut navnene og verdiene til disse variablene i konsollen.

### 📋 Kodeforklaring:

```python
"""
Dette skriptet demonstrerer bruk av boolske variabler og print-funksjonen i Python.
Variabler:
    likes_cheese (bool): En boolsk variabel som indikerer om brukeren liker ost.
    has13Apples (bool): En boolsk variabel som indikerer om brukeren har 13 epler.
Skriptet skriver ut navnene og verdiene til disse variablene i konsollen.
"""
# Dette er en boolsk verdi

likes_cheese = True  # snake_case variabel (vanlig Python-konvensjon)
has13Apples = False  # camelCase variabel (ofte brukt i andre språk, men ikke vanlig i Python)

print("Likes_Cheese")  # Skriver "Likes_Cheese" (tekst)
print(likes_cheese)    # Skriver verdien True
print("Has 13 Apples") # Skriver "Has 13 Apples" (tekst)
print(has13Apples)     # Skriver verdien False

🔍 Nøkkelpunkter:

  • Boolske verdier: Dette er variabler som kun kan ha to verdier, True (sant) eller False (usant).
  • Snake_case vs CamelCase:
    • likes_cheese: Dette er i snake_case, som er standard praksis i Python for variabelnavn.
    • has13Apples: Dette er i camelCase, som brukes mer i språk som JavaScript, men er ikke anbefalt i Python.
  • print()-funksjonen: Brukes til å skrive ut tekst eller variabelverdier til konsollen.

🖨️ Hva skriptet skriver ut:

Likes_Cheese
True
Has 13 Apples
False

💡 Læringspoeng:

  1. Boolske verdier: Brukes for å lagre True eller False.
  2. print(): Brukes til å vise data i konsollen.
  3. Kommentarer i Python: Startes med #, og er der for å forklare koden uten å påvirke kjøringen.

Dette er et flott grunnleggende eksempel på bruk av boolske variabler og funksjonen `print` i Python! 🐍💡

Her er en forklaring på variabelnavnene du har gitt:

```python
favorite_color = "blue"  # snake_case variabel
other_color = "Blue"     # camelCase variabel

🐍 Snake Case:

  • favorite_color = "blue" er et eksempel på en snake_case variabel.
    • I snake_case skriver man variabelnavn i små bokstaver og skiller ord med en underscore (_). Dette er vanlig praksis i Python, fordi det gjør variabelnavn lette å lese, spesielt når de består av flere ord.
    • Eksempel: favorite_color, user_name, total_amount.

🐫 Camel Case:

  • other_color = "Blue" er et eksempel på camelCase.
    • I camelCase skrives variabelnavn uten mellomrom eller underscore, men hvert ord etter det første starter med stor bokstav. CamelCase er vanligere i språk som JavaScript eller Java, men er ikke normen i Python.
    • Eksempel: otherColor, myFavoriteBook, totalAmount.

🔄 Forskjeller i Python:

  • I Python anbefales det å bruke snake_case for variabelnavn, fordi det følger PEP 8-retningslinjene (Python's Style Guide).
  • CamelCase brukes vanligvis ikke for variabelnavn i Python, men det er vanlig å bruke det for klassenavn.

🖼️ Hva betyr det for koden din?

  • Begge variablene vil lagre verdiene sine korrekt, men snake_case er mer idiomatisk for Python-programmering.

🖨️ Oppsummert:

favorite_color = "blue"  -> snake_case er anbefalt i Python
other_color = "Blue"     -> camelCase er mer vanlig i andre språk

Dette hjelper å forstå hvordan man bør navngi variabler på en mer Python-vennlig måte, og hvordan navngivningskonvensjoner påvirker lesbarheten av kode.

Forklaring av Python-skriptet:

Dette Python-skriptet demonstrerer bruken av booleanske, streng- og heltallsvariabler. Det inkluderer også eksempler på både snake_case og camelCase navnekonvensjoner, som vi tidligere har diskutert.

Variabler:

  • likes_cheese (bool): Indikerer om brukeren liker ost. Denne er definert som en snake_case variabel, som er normen i Python.
  • has13Apples (bool): Indikerer om brukeren har 13 epler. Her brukes camelCase, som er vanlig i noen andre programmeringsspråk, men ikke anbefalt i Python.
  • favorite_color (str): Brukerens favorittfarge, en streng i snake_case.
  • other_color (str): En annen farge, denne gangen i camelCase. Dette demonstrerer også at Python skiller mellom store og små bokstaver, så "blue" og "Blue" vil regnes som forskjellige verdier.
  • favorite_number (int): Et heltall som lagrer brukerens favorittnummer.

Hva gjør koden?

  1. Boolean-variabler:

    • likes_cheese er satt til True, som betyr at brukeren liker ost.
    • has13Apples er satt til False, som betyr at brukeren ikke har 13 epler.

  2. Utskrift:

    • Utskriften viser variabelnavnene og deres verdier.
    • Det demonstreres også at utskriften av variabler er avhengig av case-sensitivitet (store og små bokstaver behandles forskjellig i Python).

  3. Streng- og heltallsvariabler:

    • Skriptet definerer en favorittfarge og et favorittnummer, og skriver deretter verdiene ut.

Kodeblokk:

"""
Dette skriptet demonstrerer bruk av boolean, streng og heltall variabler i Python.
Det inkluderer eksempler på både snake_case og camelCase navnekonvensjoner.
Variabler:
    likes_cheese (bool): Indikerer om brukeren liker ost.
    has13Apples (bool): Indikerer om brukeren har 13 epler.
    favorite_color (str): Brukerens favorittfarge.
    other_color (str): En annen farge, som demonstrerer case-sensitivitet.
    favorite_number (int): Brukerens favorittnummer.
Funksjonalitet:
    - Skriver ut navn og verdier for de booleanske variablene.
    - Skriver ut navn og verdier for strengvariablene.
    - Skriver ut verdien av heltallsvariabelen.
"""

# Booleanske variabler
likes_cheese = True   # Snake_case variabel
has13Apples = False   # CamelCase variabel

# Skriv ut booleanske variabler
print("Likes Cheese:") 
print(likes_cheese)   # True
print("Has 13 Apples:")
print(has13Apples)    # False

# Strengvariabler
favorite_color = "blue"  # Snake_case variabel
other_color = "Blue"     # CamelCase variabel

# Skriv ut strengvariabler
print("Favorite Color:") 
print(favorite_color)   # blue
print("Other Color:")
print(other_color)      # Blue

# Heltallsvariabel
favorite_number = 13   # Snake_case variabel

# Skriv ut heltallsvariabel
print("Favorite Number:") 
print(favorite_number)  # 13

Viktige punkter forklart:

  • True og False: Disse er spesielle verdier i Python kalt booleaner. De brukes til å representere sannhet (True) og usannhet (False).
  • Strenger: En streng er en tekstverdi innkapslet i enten doble eller enkle anførselstegn.
  • Heltall (int): Dette er tall uten desimaler, og de brukes til å representere antall, telling, eller indeksering.

Dette skriptet viser en grunnleggende måte å bruke forskjellige datatyper på i Python, sammen med viktig syntaks som hjelper deg å forstå programmeringsflyten.

Forklaring av Python-skriptet:

Dette skriptet illustrerer bruk av booleanske, streng- og heltallsvariabler i Python. I tillegg blir det vist eksempler på snake_case og camelCase navngivningskonvensjoner.

Variabler i skriptet:

  • likes_cheese (bool): Indikerer om brukeren liker ost, satt til True. Denne bruker snake_case, som er standarden i Python for variabelnavn.
  • has13Apples (bool): Indikerer om brukeren har 13 epler, satt til False. Denne bruker camelCase, som er vanlig i noen andre programmeringsspråk, men ikke anbefalt i Python.
  • favorite_color (str): Brukerens favorittfarge, satt til "blue".
  • other_color (str): En annen farge, satt til "Blue", som illustrerer at Python skiller mellom små og store bokstaver (case-sensitive).
  • favorite_number (int): Brukerens favorittnummer, satt til 13.

Hva skjer i koden:

  1. Booleanske variabler:

    • likes_cheese er satt til True, som betyr at brukeren liker ost.
    • has13Apples er satt til False, som betyr at brukeren ikke har 13 epler.
    • Det skrives ut variabelnavnene og deres verdier.

  2. Strengvariabler:

    • favorite_color og other_color er begge strenger. "blue" og "Blue" behandles som ulike verdier på grunn av case-sensitivitet.
    • Begge variablene skrives ut for å vise forskjellen i verdi.

  3. Heltallsvariabel:

    • favorite_number er en heltallsvariabel satt til 13, og verdien skrives ut.

Kodeblokk:

"""
Dette skriptet demonstrerer bruken av boolean, streng og heltallsvariabler i Python.
Det inkluderer eksempler på både snake_case og camelCase navnekonvensjoner.
Variabler:
    likes_cheese (bool): Indikerer om brukeren liker ost.
    has13Apples (bool): Indikerer om brukeren har 13 epler.
    favorite_color (str): Brukerens favorittfarge.
    other_color (str): En annen farge, som demonstrerer case-sensitivitet.
    favorite_number (int): Brukerens favorittnummer.
Funksjonalitet:
    - Skriver ut navn og verdier for de booleanske variablene.
    - Skriver ut navn og verdier for strengvariablene.
    - Skriver ut verdien av heltallsvariabelen.
"""

# Booleanske variabler
likes_cheese = True   # snake_case variabel
has13Apples = False   # camelCase variabel

# Utskrift av booleanske variabler
print("Likes Cheese:") 
print(likes_cheese)    # True
print("Has 13 Apples:")
print(has13Apples)     # False

# Strengvariabler
favorite_color = "blue"   # snake_case variabel
other_color = "Blue"      # camelCase variabel

# Utskrift av strengvariabler
print("Favorite Color:") 
print(favorite_color)     # blue
print("Other Color:")
print(other_color)        # Blue

# Heltallsvariabel
favorite_number = 13   # snake_case variabel

# Utskrift av heltallsvariabel
print("Favorite Number:") 
print(favorite_number)  # 13

Viktige punkter forklart:

  • True og False: Disse er booleanske verdier i Python som representerer henholdsvis sann og usann.
  • Strenger: En streng er en tekstverdi innkapslet i anførselstegn, enten enkle (') eller doble (").
  • Heltall: Heltall er tall uten desimaler som brukes til å representere hele tall.

Skriptet gir et grunnleggende innblikk i hvordan man bruker og skriver ut forskjellige datatyper i Python.

Dette skriptet demonstrerer bruk av boolean, streng, heltall, og flyttallsvariabler i Python. Det viser også eksempler på Python-standard snake_case-navnekonvensjoner.

Variabler forklart:

  • Booleanske variabler:

    • likes_cheese: Indikerer om brukeren liker ost, satt til True (sann).
    • has_13_apples: Indikerer om brukeren har 13 epler, satt til False (usann).

  • Strengvariabler:

    • favorite_color: Brukerens favorittfarge, satt til "blue".
    • other_color: En annen farge, satt til "Blue", som demonstrerer case-sensitivitet i Python (Python skiller mellom store og små bokstaver).

  • Heltallsvariabel:

    • favorite_number: Brukerens favorittnummer, satt til 13.

  • Flyttallsvariabel:

    • tax_rate: Skattesats representert som et flyttall (desimaltall), satt til 1.07.

Hva skriptet gjør:

  1. Booleanske variabler:

    • Skriver ut navnene og verdiene til variablene likes_cheese og has_13_apples. Den første vil skrive ut True, den andre vil skrive ut False.

  2. Strengvariabler:

    • Skriver ut favorittfargene som er lagret i variablene favorite_color og other_color. Skriptet vil vise at "blue" og "Blue" behandles forskjellig på grunn av case-sensitivitet.

  3. Heltallsvariabel:

    • Skriver ut verdien av favorite_number, som er 13.

  4. Flyttallsvariabel:

    • Skriver ut verdien av skattesatsen tax_rate, som er 1.07.

Viktige konsepter:

  • Booleanske verdier: Representerer True (sant) eller False (usant), brukt i logiske operasjoner.
  • Strenger: Tekstverdier innkapslet i anførselstegn. Python skiller mellom store og små bokstaver (case-sensitiv).
  • Heltall: Representerer hele tall uten desimaler.
  • Flyttall: Representerer tall med desimaler.

Dette eksemplet gir en innføring i forskjellige datatyper og viser hvordan man kan skrive ut variabler ved hjelp av print()-funksjonen.

Her er noen optimaliserte kode-snutter som hjelper deg med å relatere og huske Python-konsepter vi har gjennomgått, som boolske variabler, strenger, heltall, og flyttall. Vi legger også vekt på gode programmeringsvaner.

1. Booleaner og Kontrollstrukturer

Dette er nyttig for å huske hvordan logiske betingelser fungerer i Python. Her bruker vi boolske variabler for å styre programflyten.

# Booleaner og if-else betingelser
likes_cheese = True
has_13_apples = False

if likes_cheese:
    print("Brukeren liker ost.")
else:
    print("Brukeren liker ikke ost.")

if has_13_apples:
    print("Brukeren har 13 epler.")
else:
    print("Brukeren har ikke 13 epler.")

2. Strenger og Case-sensitivitet

Denne kodesnutten viser hvordan strenger behandles forskjellig avhengig av store og små bokstaver.

# Strenger og case-sensitivitet
favorite_color = "blue"
other_color = "Blue"

# Sjekker case-sensitivitet
if favorite_color == other_color:
    print("Fargene er like.")
else:
    print("Fargene er ikke like.")

3. Matematiske Operasjoner med Heltall og Flyttall

Dette eksemplet minner deg på forskjellen mellom heltall (int) og flyttall (float) i Python, samt hvordan du kan utføre matematiske operasjoner.

# Heltall og flyttall
favorite_number = 13
tax_rate = 1.07

# Utfør matematiske operasjoner
total_price = favorite_number * tax_rate
print(f"Totalprisen med skattesats er: {total_price}")

4. Input og Typekonvertering

Her kombinerer vi brukerinput, typekonvertering, og forskjellige variabler. Dette hjelper deg med å forstå hvordan du samhandler med brukeren og konverterer mellom datatyper.

# Få input fra brukeren
user_input = input("Skriv inn et heltall: ")

# Konverterer strengen til et heltall
user_number = int(user_input)

# Skriv ut resultatet
print(f"Du skrev tallet {user_number}, som er av typen {type(user_number)}")

5. Forstå Flyttall og Avrunding

Når du arbeider med flyttall, kan det være nødvendig å runde av resultatene. Dette eksemplet minner deg om hvordan du kan bruke innebygde funksjoner for dette.

# Beregning og avrunding
resultat = 5 / 3
avrundet_resultat = round(resultat, 2)

print(f"Uten avrunding: {resultat}")
print(f"Avrundet til to desimaler: {avrundet_resultat}")

6. Relasjoner Mellom Ulike Datatyper

Dette eksemplet viser hvordan du kan kombinere ulike typer variabler og skrive dem ut i en sammenhengende setning.

# Kombinasjon av variabler
likes_cheese = True
favorite_color = "blue"
favorite_number = 13

print(f"Brukeren liker ost: {likes_cheese}. Favorittfargen er {favorite_color}, og favorittnummeret er {favorite_number}.")

7. List Komprehensjoner og Loops

For å forstå loops og list comprehensions, viser dette eksemplet hvordan du kan generere en liste med tall og manipulere den med en enkel for-løkke.

# Genererer en liste over tall fra 1 til 5
tall_liste = [i for i in range(1, 6)]

# Itererer gjennom listen og skriver ut hvert tall
for tall in tall_liste:
    print(f"Tallet er: {tall}")

Disse snuttene vil hjelpe deg med å forstå og huske Python-konseptene vi har gjennomgått.

Her er en tabell som forklarer ulike Python-konsepter, viser deres anvendelse, og gir eksempler på bruk. Denne tabellen inkluderer alt fra variabler, boolske verdier, snake/camelCase, print-funksjoner, til strenger, heltall, flyttall, loops, og mer.

Konsept Forklaring Eksempel på bruk i Python
Variabler Brukes til å lagre data, som kan være av ulike typer som tall, strenger, og boolske verdier. Python skiller mellom variabler basert på snake_case og camelCase. likes_cheese = True favorite_color = "blue"
Boolsk variabel Lagres som enten True eller False, og brukes ofte i betingelser og logiske operasjoner. likes_cheese = True has13Apples = False
Snake_case vs camelCase Snake_case bruker understreker for å separere ord i variabelnavn, mens camelCase bruker stor bokstav på det andre ordet i en sammensetning. has_13_apples = True (snake_case) has13Apples = True (camelCase)
print() Brukes til å skrive ut tekst, verdier eller resultat av operasjoner til konsollen. print("Favorittfarge:") print(favorite_color)
Strenger (strings) En samling av tegn omgitt av anførselstegn, som kan være enten enkel- eller dobbeltegn. Strenger er case-sensitiv. favorite_color = "blue" print(favorite_color)
Heltallsvariabel Representerer hele tall, brukt til aritmetiske operasjoner eller lagring av telleverdier. favorite_number = 13 print(favorite_number)
Flyttallsvariabel Flyttall representerer desimaltall og brukes når nøyaktighet er viktig, f.eks. for valuta, vekter eller mål. tax_rate = 1.07 print(tax_rate)
Strenger og case-sensitivitet Strenger er sensitive for store og små bokstaver, så blue og Blue er forskjellige verdier. if favorite_color == other_color: print("Ikke like farger")
Matematiske operasjoner Python støtter aritmetiske operasjoner som +, -, *, /, samt modulus (%) og eksponent (**) for både heltall og flyttall. total_price = favorite_number * tax_rate print(total_price)
Input og typekonvertering Input-funksjonen brukes til å få data fra brukeren, og typekonvertering brukes for å konvertere mellom datatyper som strenger til heltall eller flyttall. user_number = int(input("Skriv inn et tall: ")) print(user_number)
Flyttall og avrunding Python bruker funksjoner som round() for å runde av flyttall til ønsket antall desimaler. resultat = 5 / 3 avrundet = round(resultat, 2) print(avrundet)
Relasjoner mellom datatyper Python tillater kombinasjon av ulike typer variabler i samme setning, som f.eks. streng + heltall, for å skape meningsfulle utsagn. print(f"Brukeren liker ost: {likes_cheese}, favorittnummer: {favorite_number}")
List Comprehensions og loops Brukes til å skape lister på en kompakt måte, og loops som for-løkker brukes til å iterere over elementer i lister eller andre sekvenser. tall_liste = [i for i in range(1, 6)] for tall in tall_liste: print(tall)
Funksjoner Funksjoner hjelper med å gruppere kode for gjenbruk og forenkling av programlogikken. En funksjon kan ta inn parametere og returnere en verdi. def addisjon(a, b): return a + b print(addisjon(2, 3))

Disse eksemplene dekker de viktigste konseptene du bør kjenne til når du arbeider med Python. Å forstå og anvende disse vil hjelpe deg med å utvikle en sterk grunnleggende ferdighet i programmering.

No, snake_case and camelCase are not "just made up" terms; they are widely recognized naming conventions in Python and many other programming languages. Here's a breakdown:

  1. snake_case: This refers to writing variable and function names with words separated by underscores (_). All letters are typically lowercase. It is the recommended style for variable names, function names, and other identifiers in Python, following the PEP 8 style guide (Python's official style guide).

    • Example: likes_cheese, favorite_color, has_13_apples.

  2. camelCase: This is another naming convention where the first word is lowercase, and subsequent words start with capital letters without using underscores. While camelCase is common in languages like JavaScript or Java, it is not recommended for Python according to PEP 8. However, you'll still see camelCase used in some older Python code or non-standard libraries.

    • Example: has13Apples, otherColor.

In Python, snake_case is preferred, especially for function names and variables, while CamelCase (or PascalCase) is typically reserved for class names. For example:

  • snake_case: my_variable = 10
  • CamelCase: class MyClass:

Thus, both naming conventions exist and are important, but Python programmers primarily use snake_case for variables and functions.

For further reading, you can explore PEP 8 (Python Enhancement Proposal 8) which is the official style guide for Python code here.

Begrepene snake_case og camelCase er ekte og mye brukte navnekonvensjoner i programmeringsspråk, inkludert Python. Her er en enkel forklaring på disse to navnekonvensjonene:

1. snake_case:

  • Dette er en stil for å skrive variabelnavn, funksjonsnavn og andre identifikatorer der ord er skilt med understreker (_), og alle bokstaver vanligvis er små bokstaver.
  • Python anbefaler snake_case for variabel- og funksjonsnavn, som beskrevet i PEP 8 (Python's stilguide).
  • Eksempel på snake_case:
    • likes_cheese,
    • favorite_color,
    • has_13_apples.

2. camelCase:

  • I denne navnestilen skrives det første ordet med små bokstaver, og hvert påfølgende ord starter med stor bokstav uten understreker. Denne stilen er ikke anbefalt i Python ifølge PEP 8, men er ofte brukt i andre programmeringsspråk som Java og JavaScript.
  • Eksempel på camelCase:
    • has13Apples,
    • favoriteColor.

Forskjeller i Python:

  • snake_case er den foretrukne og anbefalte navnekonvensjonen i Python for variabler og funksjoner. Det gjør koden mer lesbar og er standarden i Pythons offisielle retningslinjer.
  • CamelCase (eller PascalCase) brukes mest til navn på klasser i Python. Dette betyr at hver orddel starter med stor bokstav, for eksempel MyClass eller AnimalKingdom.

Eksempel i Python:

# snake_case for variabler og funksjoner:
def calculate_area(radius):
    pi_value = 3.14
    return pi_value * radius ** 2

# CamelCase for klassenavn:
class CircleShape:
    def __init__(self, radius):
        self.radius = radius

Som du ser, brukes snake_case for funksjonen calculate_area og variabelen pi_value, mens CamelCase brukes for navnet på klassen CircleShape.

I Python skal du følge denne konvensjonen for å skrive kode som er i tråd med PEP 8, som sikrer lesbarhet og konsistens.

Den gitte Python-kodeeksemplet illustrerer bruk av navnekonvensjoner for variabler, funksjoner og klassenavn, som er viktige for å opprettholde lesbarhet og konsistens i koden.

Navnekonvensjoner

  • snake_case for variabler og funksjoner: I koden brukes snake_case for å navngi variabler og funksjoner. Denne konvensjonen innebærer å skrive navn med små bokstaver, og ord skilles med understreker. For eksempel følger både funksjonen calculate_area og variabelen pi_value denne konvensjonen. Dette stilen brukes mye i Python på grunn av dens lesbarhet og enkelhet.

  • CamelCase for klassenavn: I koden brukes CamelCase for å navngi klasser, hvor hvert ord begynner med en stor bokstav, uten understreker. For eksempel følger klassen CircleShape denne konvensjonen. Denne stilen hjelper med å skille klassenavn fra variabler og funksjoner, og gjør koden lettere å forstå.

Funksjonen calculate_area

Funksjonen calculate_area beregner arealet av en sirkel gitt dens radius. Den tar en parameter, radius, og bruker en lokal variabel pi_value satt til 3.14 (en tilnærming til π). Funksjonen returnerer arealet ved å bruke formelen ( \pi \times \text{radius}^2 ). Denne funksjonen kapsler inn logikken for arealberegning, noe som gjør den gjenbrukbar og enkel å kalle med forskjellige radiusverdier.

Klassen CircleShape

Klassen CircleShape representerer en sirkel med en spesifikk radius. Klassen bruker metoden __init__ til å initialisere sine instanser. Metoden tar en parameter, radius, og tildeler den til en instansvariabel self.radius. Klassen gir en enkel måte å opprette sirkelobjekter med en gitt radius på, og kapsler radiusattributtet inn i klassen.

Oppsummering

Kodeeksemplet demonstrerer effektivt bruk av snake_case for variabler og funksjoner, og CamelCase for klassenavn, i tråd med Pythons navnekonvensjoner. Funksjonen calculate_area tilbyr en gjenbrukbar måte å beregne sirkelens areal på, mens klassen CircleShape gir en enkel representasjon av en sirkel med et radiusattributt. Disse konvensjonene og strukturene bidrar til lesbarhet, vedlikeholdbarhet og klarhet i koden.

Ja, du har helt rett! I Python er det en sterk anbefaling om å bruke snake_case for variabler og funksjoner, og CamelCase for klassenavn. Dette følger PEP 8-standarden, som er Pythons offisielle stilguide for å opprettholde enhetlig og lesbar kode.

Grunner til at dette anbefales:

  • snake_case for variabler og funksjoner:

    • Det forbedrer lesbarheten. Ved å bruke små bokstaver og understrek mellom ord (for eksempel calculate_area), blir det enklere å skille navnene og forstå funksjonen deres med en gang.
    • Det er Pythons standard for variabler og funksjoner. Bruk av snake_case gjør koden din mer konsistent og forståelig for andre Python-utviklere.

  • CamelCase for klassenavn:

    • CamelCase (som i CircleShape) skiller klassenavn tydelig fra variabler og funksjoner, noe som gjør det enklere å forstå hvilke elementer som er klasser når man leser koden.
    • Det gir en visuell forskjell som gjør at utviklere umiddelbart kan identifisere klasser.

Hvorfor CamelCase ikke er anbefalt for variabler og funksjoner:

  • Selv om Python tillater CamelCase for variabler og funksjoner (som i has13Apples), er det ikke i tråd med PEP 8-retningslinjene.
  • Ved å bruke CamelCase på variabler og funksjoner kan det skape forvirring, da det bryter med Pythons stilkonvensjoner og kan gjøre koden vanskeligere å lese for andre Python-programmerere.

Konklusjon:

Mens Python er fleksibelt nok til å tillate begge stiler, er det sterkt anbefalt å følge PEP 8-standarden med snake_case for variabler og funksjoner, og CamelCase kun for klassenavn. Dette hjelper med å opprettholde konsistens og gjør koden mer lesbar og profesjonell.

Her er en tabell som rydder opp i begrepene rundt variabler, funksjoner og klasser i Python, med fokus på bruken av snake_case og CamelCase, og en forklaring på hva klassenavn faktisk er:

Begrep Navnekonvensjon Eksempel Beskrivelse
Variabler snake_case likes_cheese En variabel er et navn som peker på en verdi. For variabler bruker vi snake_case, altså små bokstaver med understrek mellom ordene.
Funksjoner snake_case calculate_area() En funksjon er en gjenbrukbar blokk med kode som utfører en spesifikk oppgave. Funksjonsnavn bruker også snake_case.
Klassenavn CamelCase CircleShape En klasse er en blåkopi eller mal for å lage objekter (instanser). Klassenavn bruker CamelCase, der hvert ord starter med stor bokstav.
Objekter snake_case my_circle = CircleShape() Et objekt er en spesifikk instans av en klasse. Variabelnavnet som peker til et objekt, bruker snake_case som vanlige variabler.
Metoder snake_case get_area() En metode er en funksjon som er definert inne i en klasse. Metodenavnet følger snake_case, akkurat som vanlige funksjoner.
Konstanter ALL_CAPS PI_VALUE = 3.14 Konstanter er variabler som ikke skal endres. Det er vanlig praksis å skrive disse med store bokstaver, separert med understrek.

Forklaring av klassebegrepet:

  • Klasse: En klasse er en mal eller et design for hvordan objekter skal være og oppføre seg. Tenk på en klasse som en "blåkopi" for objekter. For eksempel, hvis vi har en klasse som heter CircleShape, beskriver denne hvordan et sirkel-objekt skal være (f.eks. ha en radius) og hva det kan gjøre (f.eks. beregne areal).

    Eksempel på opprettelse av en klasse:

    class CircleShape:
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return 3.14 * self.radius ** 2

    Her ser vi at klassen CircleShape har en metode som heter calculate_area(), som beregner arealet av sirkelen basert på radiusen som er gitt når objektet opprettes.

Forskjellen mellom funksjoner og klasser:

  • Funksjoner som calculate_area() kan eksistere alene i koden og utføre en spesifikk handling.
  • Klasser er mer omfattende og kan inneholde flere funksjoner (metoder), samt variabler (attributter) som tilhører objektene som lages fra klassen.