Python Cheat Sheet: Essential Rask og enkel guide

Når du programmerer i , kan det være en spillskifter å ha et pålitelig jukseark ved din side. Python kan være kjent for sin enkelhet og lesbarhet, men det er ingen tvil om at dets omfattende utvalg av funksjoner og funksjoner er for mye å huske!

Python-jukseark fungerer som en praktisk referanse for både nybegynnere og erfarne utviklere. De gir en grunnleggende referanseguide for ulike kommandoer, syntaks, datastrukturer og mer.

Denne guiden er et Python-jukseark som kan hjelpe deg med å navigere gjennom , biblioteker, klasser og syntaks som kan være overveldende, spesielt for nybegynnere.

Er du old school? Foretrekk å laste ned og skrive ut, vennligst sjekk ut pdf-en nedenfor for å hjelpe deg på Python-læringsreisen!

Innholdsfortegnelse

• Hurtigreferanse for grunnleggende Python-syntaks
  • 1. Kommentarer
  • 2. Variabler
  • 3. Datatyper
  • 4. Betingede erklæringer
  • 5. Løkker
  • 6. Funksjoner
• Hurtigreferanse for Python-datastrukturer
  • 1. Lister
  • 2. Tuples
  • 3. Sett
  • 4. Ordbøker
• Hurtigreferanse for Python File I/O
  • 1. Lese filer
  • 2. Skrive filer
  • 3. Legge til filer
• Hurtigreferanse for feilhåndtering i Python
  • 1. Prøv og Unntatt
  • 2. Til slutt
  • 3. Oppheve unntak
• Hurtigreferanse for Python-moduler og -pakker
  • 1. Importere moduler
  • 2. Opprette pakker
• Hurtigreferanse for objektorientert programmering i Python
  • 1. Klasser
  • 2. Arv
  • 3. Innkapsling
• 4 nyttige Python-biblioteker
  • 1. NumPy
  • 2. Pandaer
  • 3. Forespørsler
  • 4. Nydelig suppe
• Siste tanker

Hurtigreferanse for grunnleggende Python-syntaks

For å starte Python-juksearket vårt, skal vi utforske noen grunnleggende Python-syntaks. Å ha et godt grep om Python grunnleggende vil gi deg et solid grunnlag for å skrive mer kompleks kode.

For denne referansen har vi inkludert: kommentarer , variabler , datatyper , betingede setninger , looper og funksjoner .

1. Kommentarer

Kommentarer er en viktig del av koden din, siden de lar deg forklare tankeprosessen din og gjøre koden mer lesbar. I Python kan du lage enkeltlinjekommentarer ved å bruke hash-symbolet (#).

# This is a single-line comment.

For kommentarer med flere linjer kan du bruke tredoble anførselstegn (enten enkle eller doble).

""" This is a
multi-line
comment. """

2. Variabler

Variabler i Python brukes til å lagre data. Du kan tilordne verdier til variabler ved å bruke likhetstegnet (=).

x = 5
name = "John"

Variablenavn skal være beskrivende og følge navnekonvensjonen for bruk av små bokstaver og understreking for mellomrom.

user_age = 25
favorite_color = "blue"

3. Datatyper

Python-språket kommer med flere datatyper innebygd som standard. Noen av de mer vanlige inkluderer:

• Teksttyper : str

• Boolsk type : bool

• Numeriske typer : int, float, kompleks

• Sekvenstyper : liste, tuppel, rekkevidde

• Ingen type: Ingen type

For å finne ut datatypen til et hvilket som helst Python-objekt, kan du bruke type() -funksjonen. For eksempel:

name = 'jane'
print(type(name))

#Output: 'str'

4. Betingede erklæringer

Betingede setninger i Python lar deg kjøre kode bare når visse betingelser er oppfylt. De vanlige betingelsessetningene er ' hvis ', 'elif ' og ' annet '.

if condition:
    # Code to execute if the condition is true
elif another_condition:
    # Code to execute if the another_condition is true
else:
    # Code to execute if none of the conditions are true

5. Løkker

En løkke brukes til å utføre en kodeblokk gjentatte ganger. en ' for '-løkke og en ' while '-løkke.

La oss ta en titt på dem begge:

For løkker:

for variable in iterable:
    # Code to execute for each element in the iterable

Mens looper:

while condition:
    # Code to execute while the condition is true

Inne i disse løkkene kan du bruke betingede og kontrollsetninger for å kontrollere programmets flyt.

6. Funksjoner

Funksjoner i Python er kodeblokker som utfører spesifikke oppgaver. Du kan definere en funksjon ved å bruke nøkkelordet ' def ', etterfulgt av funksjonsnavnet og parenteser som inneholder alle inndataparametere.

def function_name(parameters):
    # Code to execute
    return result

For å kalle en funksjon, bruk funksjonsnavnet etterfulgt av parenteser som inneholder de nødvendige argumentene.

function_name(arguments)

Nå som vi har gått gjennom det grunnleggende om Python, la oss gå videre til noen mer avanserte emner i neste seksjon.

Hurtigreferanse for Python-datastrukturer

Neste i vårt Python-jukseark vil vi diskutere noen av de mest brukte datastrukturene i Python. Disse datastrukturene er avgjørende for å administrere og organisere dataene i programmeringsprosjektene dine.

Det er mange datastrukturer i Python som avanserte utviklere kan bruke. Vi vil imidlertid fokusere på Lister , Tuples , Sets og Dictionaries .

1. Lister

A er en foranderlig, ordnet sekvens av elementer. For å lage en liste bruker du firkantede parenteser og skiller elementene med komma.

Python-lister kan inneholde en rekke datatyper som strenger, heltall, booleaner osv. Her er noen lister:

• Lag en liste:

  my_list = [1, 2, 3]

• Tilgangselementer:

  my_list[0]

• Legg til et element:

  my_list.append(4)

2. Tuples

En tuppel ligner på en liste, men den er uforanderlig, noe som betyr at du ikke kan endre elementene når den er opprettet. Du kan lage en tuppel ved å bruke parenteser og skille elementene med komma.

Her er noen eksempler på tuppeloperasjoner:

• Lag en tuppel:

  my_tuple = (1, 2, 3)

• Tilgangselementer:

  my_tuple[0] #Output: 1

3. Sett

Et sett er en uordnet samling av unike elementer. Du kan lage et sett ved å bruke set()-funksjonen eller krøllete klammeparenteser.

Den kan også inneholde en rekke datatyper, så lenge de er unike. Her er noen eksempler på settoperasjoner:

• Lag et sett:

   my_set = {1, 2, 3}

• Legg til et element:

  my_set.add(4)

• Fjern et element:

  my_set.remove(1)

4. Ordbøker

En ordbok er en uordnet samling nøkkel-verdi-par, der nøklene er unike. Du kan lage en ordbok ved å bruke krøllete klammeparenteser og skille nøklene og verdiene med kolon. Her er noen eksempler på ordbokoperasjoner:

• Lag en ordbok:

  my_dict = {'key1': 'value1', 'key2': 'value2'}

• Tilgangselementer:

  my_dict['key1'] #Output:'value1'

• Legg til et nøkkelverdi-par:

  my_dict['key3'] = 'value3'

• Fjern et nøkkelverdi-par:

  del my_dict['key1']

Husk å øve og utforske disse datastrukturene i Python-prosjektene dine for å bli dyktigere i bruken deres! Deretter skal vi gi deg en referanse for fil I/O-oppgaver.

Hurtigreferanse for Python File I/O

I denne delen av Python-juksearket vil vi fokusere på noen vanlige oppgaver knyttet til arbeid med filer i Python, som å lese , skrive og legge til data.

1. Lese filer

For å lese en fil, må du først åpne den ved å bruke den innebygde open()- funksjonen, med modusparameteren satt til ' r ' for lesing:

file_obj = open('file_path', 'r')

Nå som filen din er åpen, kan du bruke forskjellige metoder for å lese innholdet:

• read(): Leser hele innholdet i filen.

• readline() : Leser a fra filen.

• readlines() : Returnerer en liste over alle linjene i filen.

Det er viktig å huske å lukke filen når du er ferdig med å jobbe med den:

file_obj.close()

Alternativt kan du bruke with- setningen, som automatisk lukker filen etter at kodeblokken er fullført:

with open('file_path', 'r') as file_obj:
    content = file_obj.read()

2. Skrive filer

For å opprette en ny fil eller overskrive en eksisterende, åpne filen med modus ' w ':

file_obj = open('file_path', 'w')

Skriv data til filen ved å bruke write() -metoden:

file_obj.write('This is a line of text.')

Ikke glem å lukke filen:

file_obj.close()

Igjen, vurder å bruke with-setningen for en mer kortfattet og sikrere måte å håndtere filer på:

with open('file_path', 'w') as file_obj:
    file_obj.write('This is a line of text.')

3. Legge til filer

For å legge til innhold til en eksisterende fil uten å overskrive den, åpne filen med modus ' a ':

file_obj = open('file_path', 'a')

Bruk write() -metoden for å legge til data til filen:

file_obj.write('This is an extra line of text.')

Og, som alltid, lukk filen når du er ferdig:

file_obj.close()

For en mer effektiv og renere tilnærming, bruk with- setningen:

with open('file_path', 'a') as file_obj:
    file_obj.write('This is an extra line of text.')

Ved å følge disse trinnene og eksemplene kan du effektivt navigere i filoperasjoner i Python-applikasjonene dine. Husk å alltid lukke filene dine etter å ha jobbet med dem for å unngå potensielle problemer og ressurslekkasjer!

I neste avsnitt gir vi en referanse for feilhåndtering i Python.

Hurtigreferanse for feilhåndtering i Python

I denne delen vil du lære om feilhåndtering i Python, som spiller en avgjørende rolle for å forhindre brå avslutning av programmene dine når det støter på en feil.

Vi vil dekke følgende underseksjoner: Prøv og unnta , Til slutt og Heve unntak .

1. Prøv og Unntatt

For å håndtere unntak i koden din, kan du bruke prøve- og unnta -blokkene. Prøv-blokken inneholder koden som kan føre til en feil, mens unntaksblokken hjelper deg med å håndtere det unntaket, og sikrer at programmet fortsetter å kjøre problemfritt.

Her er et eksempel:

try:
    quotient = 5 / 0

except ZeroDivisionError as e:
    print("Oops! You're trying to divide by zero.")

I dette tilfellet vil koden inne i try-blokken gi et ZeroDivisionError- unntak. Siden vi har en unntaksblokk for å håndtere dette spesifikke unntaket, vil den fange opp feilen og skrive ut meldingen for å varsle deg om problemet.

2. Til slutt

Den endelige blokken brukes når du vil sikre at en spesifikk kodeblokk blir utført, uansett utfallet av forsøket og unntatt blokker. Dette er spesielt nyttig for å frigjøre ressurser eller lukke filer eller tilkoblinger, selv om et unntak oppstår, for å sikre en ren utgang.

Her er et eksempel:

try:
    # Your code here
except MyException as e:
    # Exception handling
finally:
    print("This will run no matter the outcome of the try and except blocks.")

3. Oppheve unntak

Du kan også heve tilpassede unntak i koden din for å utløse feilhåndtering når spesifikke betingelser er oppfylt. For å gjøre dette kan du bruke raise- setningen etterfulgt av unntaket du ønsker å heve (enten innebygd eller tilpasset unntak).

For eksempel:

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be a negative value.")

try:
    validate_age(-3)
except ValueError as ve:
    print(ve)

I dette eksemplet har vi definert en egendefinert funksjon for å validere en aldersverdi. Hvis den angitte alderen er mindre enn null, viser vi en ValueError med en egendefinert melding. Når du kaller denne funksjonen, bør du pakke den inn i en prøve-unntatt-blokk for å håndtere unntaket riktig.

Deretter skal vi tilby moduler og pakker. La oss gå!

Hurtigreferanse for Python-moduler og -pakker

Denne delen av juksearket vårt er for Python-pakker og -moduler, som er avgjørende for å strukturere og organisere koden din rent og effektivt.

Du lærer om å importere moduler og lage pakker .

1. Importere moduler

Moduler i Python er filer som inneholder gjenbrukbar kode, for eksempel funksjoner, klasser eller variabler. Python tilbyr flere moduler og pakker for forskjellige oppgaver som datavitenskap, maskinlæring, robotikk, etc.

For å bruke en moduls innhold i koden din, må du først importere den. Her er noen forskjellige måter å importere en modul på:

• import : Dette importerer hele modulen, og du kan få tilgang til innholdet ved å bruke syntaksen ' modul_name.content_name '.
  For eksempel:

  import random
  
  c = random.ranint()

• fra import : Dette importerer et spesifikt innhold (funksjon eller variabel) fra modulen, og du kan bruke det direkte uten å referere til modulnavnet.

  from math import sin
  
  c = sin(1.57)

• fra import * : Dette importerer alt innholdet i modulen. Vær forsiktig med denne metoden da det kan føre til konflikter hvis ulike moduler har innhold med samme navn.

Noen ofte brukte innebygde Python-moduler inkluderer:

1. matematikk: Gir matematiske funksjoner og konstanter

2. tilfeldig: Genererer tilfeldige tall og gir relaterte funksjoner

3. datetime : Håndterer dato- og klokkeslettoperasjoner

4. os: Samhandler med operativsystemet og administrerer filer og kataloger

2. Opprette pakker

Pakker i Python er samlinger av relaterte moduler. De hjelper deg med å organisere koden din i logiske og funksjonelle enheter. Slik oppretter du en pakke:

1. Opprett en ny katalog med ønsket pakkenavn.

2. Legg til en tom fil kalt init.py i katalogen. Denne filen indikerer for Python at katalogen skal behandles som en pakke.

3. Legg til modulfilene (med filtypen .py) i katalogen.

Nå kan du importere pakken eller dens moduler til Python-skriptene dine. For å importere en modul fra en pakke, bruk syntaksen:

import 

Strukturer koden din med moduler og pakker for å gjøre den mer organisert og vedlikeholdbar. Dette vil også gjøre det lettere for deg og andre å navigere og forstå kodebasen din.

I neste avsnitt gir vi en referanse for objektorienterte programmeringskonsepter i Python.

Hurtigreferanse for objektorientert programmering i Python

Objektorientert programmering (OOP) er et programmeringsparadigme basert på konseptet " objekter ", som kan inneholde data og kode.

Dataene er i form av felt, ofte kjent som attributter eller egenskaper , og koden er i form av prosedyrer, ofte kjent som metoder .

I denne delen av juksearket skal vi fordype oss i de grunnleggende konseptene til OOP i Python, inkludert klasser , arv og innkapsling .

1. Klasser

En klasse er en blåkopi for å lage objekter. Den definerer dataene (attributtene) og funksjonaliteten (metodene) til objektene. For å begynne å lage din egen klasse, bruk nøkkelordet " klasse " etterfulgt av klassenavnet:

class ClassName:
    # Class attributes and methods

For å legge til attributter og metoder, bare definere dem i klasseblokken. For eksempel:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print("Woof!")

I dette eksemplet kan et nytt hundeobjekt opprettes med navn og rase, og det har en bjeffemetode som skriver ut " Wuff! " når du ringer.

2. Arv

Arv lar en klasse arve attributter og metoder fra en annen klasse, noe som muliggjør gjenbruk av kode og modularitet. Klassen som arver kalles en underklasse eller avledet klasse, mens klassen som arves fra kalles basisklassen eller superklassen.

For å implementere arv, legg til navnet på superklassen i parentes etter underklassens navn:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

Du kan for eksempel opprette en underklasse "Puddel" fra en "Hund"-klasse:

class Poodle(Dog):
    def show_trick(self):
        print("The poodle does a trick.")

Et puddelobjekt vil nå ha alle attributtene og metodene til hundeklassen, i tillegg til sin egen show_trick-metode.

3. Innkapsling

Innkapsling er praksisen med å pakke inn data og metoder som opererer på disse dataene i en enkelt enhet, et objekt i dette tilfellet. Dette fremmer et klart skille mellom et objekts interne implementering og dets eksterne grensesnitt.

Python bruker navnemangling for å oppnå innkapsling for klassemedlemmer ved å legge til et dobbelt understrekprefiks til attributtnavnet, noe som gjør det tilsynelatende privat.

class Example:
    def __init__(self):
        self.__private_attribute = "I'm private!"

    def __private_method(self):
        print("You can't see me!")

Selv om du fortsatt teknisk sett kan få tilgang til disse private medlemmene i Python, frarådes det på det sterkeste siden det bryter med innkapslingsprinsipper.

Ved å forstå og implementere klasser, arv og innkapsling i Python-programmene dine, kan du utnytte kraften og fleksibiliteten til OOP til å lage ren, modulær og gjenbrukbar kode.

For vår siste del av juksearket, vil vi gi deg en hurtigreferanse for fire populære Python-biblioteker.

4 nyttige Python-biblioteker

Flere Python-biblioteker kan hjelpe deg med å oppnå en eller få verktøy for ulike emner som matematikk, datavitenskap, nettskraping, etc.

I denne delen skal vi kort diskutere følgende biblioteker: NumPy , Pandas , Requests og Beautiful Suppe .

1. NumPy

NumPy er et populært Python-bibliotek for matematisk og vitenskapelig databehandling. Med det kraftige N-dimensjonale array-objektet kan du håndtere et bredt spekter av matematiske operasjoner, for eksempel:

• Grunnleggende matematiske funksjoner

• Lineær algebra

• Fourieranalyse

• Generering av tilfeldig tall

manipulasjoner gjør den spesielt egnet for prosjekter som krever numeriske beregninger.

2. Pandaer

Pandas er et kraftig dataanalyse- og manipulasjonsbibliotek som du kan bruke til å jobbe med strukturerte data. Det er også veldig populært i datavitenskapssamfunnet på grunn av det brede utvalget av verktøy det gir for å håndtere data.

Noen av funksjonene inkluderer:

• Datastrukturer som Series (1D) og DataFrame (2D)

• Datarensing og klargjøring

• Statistisk analyse

• Tidsseriefunksjonalitet

Ved å bruke Pandas kan du enkelt importere, analysere og manipulere data i en rekke formater, for eksempel CSV-, Excel- og SQL-databaser.

Hvis du er interessert i Pandas, kan du sjekke ut videoen vår om hvordan du kan prøve ut tidsseriedata ved å bruke Pandas for å forbedre analysen:

3. Forespørsler

Requests - biblioteket forenkler prosessen med å håndtere HTTP-forespørsler i Python. Med dette biblioteket kan du enkelt sende og motta HTTP-forespørsler, som GET, POST og DELETE.

Noen nøkkelfunksjoner inkluderer:

• Håndtere omdirigeringer og følge lenker på nettsider

• Legge til overskrifter, skjemadata og spørringsparametere via enkle Python-biblioteker

• Administrere informasjonskapsler og økter

Ved å bruke forespørsler kan du raskt og effektivt samhandle med ulike nettjenester og APIer.

4. Nydelig suppe

Beautiful Soup er et Python-bibliotek for nettskraping, som lar deg trekke ut data fra HTML- og XML-dokumenter. Noen av nøkkelfunksjonene inkluderer:

• Søker etter spesifikke tagger eller CSS-klasser

• Navigere og endre analyserte trær

• Trekke ut relevant informasjon basert på tag-attributter

Ved å bruke Beautiful Soup i forbindelse med forespørsler, kan du lage kraftige nettskrapingsapplikasjoner som samler informasjon fra et bredt spekter av nettsteder.

Siste tanker

Og det bringer oss til slutten av vår raske tur nedover Python-banen. Dette er din lommeguide, din trofaste sidemann når du trenger en rask påminnelse om Pythons toppfunksjoner og kommandoer.

Listen vår er ikke uttømmende, men den er en solid start, et grunnlag du kan bygge på. Så fortsett, bokmerk det, skriv det ut, fest det på veggen – bare sørg for at det er for hånden når du koder. God programmering!