Python Cheat Sheet: Essential snabb och enkel guide

När du programmerar i kan det vara en spelomvandlare att ha ett pålitligt fuskblad vid din sida. Python kan vara känt för sin enkelhet och läsbarhet, men det går inte att förneka att dess omfattande utbud av funktioner och funktioner är för mycket att memorera!

Python cheat sheets fungerar som en praktisk referens för både nybörjare och erfarna utvecklare. De ger en grundläggande referensguide för olika kommandon, syntax, datastrukturer och mer.

Den här guiden är ett Python-fuskblad som kan hjälpa dig att navigera genom , bibliotek, klasser och syntax som kan vara överväldigande, särskilt för nybörjare.

Är du old school? Föredrar att ladda ner och skriva ut, kolla in pdf-filen nedan för att hjälpa dig på din Python-inlärningsresa!

Innehållsförteckning

• Snabbreferens för Python Syntax Basics
  • 1. Kommentarer
  • 2. Variabler
  • 3. Datatyper
  • 4. Villkorliga uttalanden
  • 5. Slingor
  • 6. Funktioner
• Snabbreferens för Python-datastrukturer
  • 1. Listor
  • 2. Tupler
  • 3. Set
  • 4. Ordböcker
• Snabbreferens för Python File I/O
  • 1. Läsa filer
  • 2. Skriva filer
  • 3. Bifoga till filer
• Snabbreferens för felhantering i Python
  • 1. Prova och Undantag
  • 2. Slutligen
  • 3. Öka undantag
• Snabbreferens för Python-moduler och -paket
  • 1. Importera moduler
  • 2. Skapa paket
• Snabbreferens för objektorienterad programmering i Python
  • 1. Klasser
  • 2. Arv
  • 3. Inkapsling
• 4 användbara Python-bibliotek
  • 1. NumPy
  • 2. Pandas
  • 3. Förfrågningar
  • 4. Vacker soppa
• Slutgiltiga tankar

Snabbreferens för Python Syntax Basics

För att kicka igång vårt Python-fuskblad, kommer vi att utforska lite Python-syntaxgrunder. Att ha ett starkt grepp om Pythons grunder kommer att ge dig en solid grund för att skriva mer komplex kod.

För den här referensen har vi inkluderat: kommentarer , variabler , datatyper , villkorliga satser , loopar och funktioner .

1. Kommentarer

Kommentarer är en viktig del av din kod, eftersom de låter dig förklara din tankeprocess och göra din kod mer läsbar. I Python kan du skapa kommentarer på en rad med hjälp av hash-symbolen (#).

# This is a single-line comment.

För kommentarer med flera rader kan du använda tredubbla citattecken (antingen enkla eller dubbla).

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

2. Variabler

Variabler i Python används för att lagra data. Du kan tilldela värden till variabler med likhetstecknet (=).

x = 5
name = "John"

Variabelnamn ska vara beskrivande och följa namnkonventionen att använda små bokstäver och understreck för mellanslag.

user_age = 25
favorite_color = "blue"

3. Datatyper

Python-språket kommer med flera datatyper inbyggda som standard. Några av de vanligaste inkluderar:

• Texttyper : str

• Boolesk typ : bool

• Numeriska typer : int, float, komplex

• Sekvenstyper : lista, tupel, intervall

• Ingen typ: Ingen typ

För att ta reda på datatypen för ett Python-objekt kan du använda funktionen type() . Till exempel:

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

#Output: 'str'

4. Villkorliga uttalanden

Villkorssatser i Python låter dig exekvera kod endast när vissa villkor är uppfyllda. De vanliga villkorliga uttalandena är ' if ', 'elif ' och ' else '.

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. Slingor

En loop används för att upprepade gånger exekvera ett kodblock. en ' for ' loop och en ' while ' loop.

Låt oss ta en titt på dem båda:

För loopar:

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

While loopar:

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

Inuti dessa loopar kan du använda villkors- och kontrollsatser för att kontrollera ditt programs flöde.

6. Funktioner

Funktioner i Python är kodblock som utför specifika uppgifter. Du kan definiera en funktion med nyckelordet ' def ', följt av funktionsnamnet och parenteser som innehåller eventuella indataparametrar.

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

För att anropa en funktion, använd funktionsnamnet följt av parenteser som innehåller de nödvändiga argumenten.

function_name(arguments)

Nu när vi har gått igenom grunderna i Python, låt oss gå vidare till några mer avancerade ämnen i nästa avsnitt.

Snabbreferens för Python-datastrukturer

Nästa i vårt Python-cheatsheet kommer vi att diskutera några av de mest använda datastrukturerna i Python. Dessa datastrukturer är viktiga för att hantera och organisera data i dina programmeringsprojekt.

Det finns många datastrukturer i Python som avancerade utvecklare kan använda. Vi kommer dock att fokusera på Listor , Tuples , Sets och Dictionaries .

1. Listor

A är en föränderlig, ordnad sekvens av element. För att skapa en lista, använd hakparenteser och separera elementen med kommatecken.

Python-listor kan innehålla en mängd olika datatyper som strängar, heltal, booleaner, etc. Här är några listor:

• Skapa en lista:

  my_list = [1, 2, 3]

• Åtkomstelement:

  my_list[0]

• Lägg till ett element:

  my_list.append(4)

2. Tupler

En tuppel liknar en lista, men den är oföränderlig, vilket innebär att du inte kan ändra dess element när de väl har skapats. Du kan skapa en tupel genom att använda parenteser och separera elementen med kommatecken.

Här är några exempel på tuppeloperationer:

• Skapa en tupel:

  my_tuple = (1, 2, 3)

• Åtkomstelement:

  my_tuple[0] #Output: 1

3. Set

En uppsättning är en oordnad samling av unika element. Du kan skapa en uppsättning med funktionen set() eller hängslen.

Den kan också innehålla en mängd olika datatyper, så länge de är unika. Här är några exempel på inställningsoperationer:

• Skapa ett set:

   my_set = {1, 2, 3}

• Lägg till ett element:

  my_set.add(4)

• Ta bort ett element:

  my_set.remove(1)

4. Ordböcker

En ordbok är en oordnad samling nyckel-värdepar, där nycklarna är unika. Du kan skapa en ordbok med hjälp av hängslen och separera nycklar och värden med kolon. Här är några exempel på ordboksoperationer:

• Skapa en ordbok:

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

• Åtkomstelement:

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

• Lägg till ett nyckel-värdepar:

  my_dict['key3'] = 'value3'

• Ta bort ett nyckel-värdepar:

  del my_dict['key1']

Kom ihåg att öva och utforska dessa datastrukturer i dina Python-projekt för att bli mer skickliga i deras användning! Därefter kommer vi att ge dig en referens för fil I/O-uppgifter.

Snabbreferens för Python File I/O

I det här avsnittet av Python-fusket kommer vi att fokusera på några vanliga uppgifter relaterade till att arbeta med filer i Python, som att läsa , skriva och lägga till data.

1. Läsa filer

För att läsa en fil måste du först öppna den med den inbyggda open()- funktionen, med modeparametern inställd på ' r ' för läsning:

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

Nu när din fil är öppen kan du använda olika metoder för att läsa dess innehåll:

• read(): Läser hela innehållet i filen.

• readline() : Läser a från filen.

• readlines() : Returnerar en lista över alla rader i filen.

Det är viktigt att komma ihåg att stänga filen när du har arbetat klart med den:

file_obj.close()

Alternativt kan du använda with -satsen, som automatiskt stänger filen efter att kodblocket är klart:

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

2. Skriva filer

För att skapa en ny fil eller skriva över en befintlig, öppna filen med läge ' w ':

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

Skriv data till filen med metoden write() :

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

Glöm inte att stänga filen:

file_obj.close()

Återigen, överväg att använda with-satsen för ett mer kortfattat och säkrare sätt att hantera filer:

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

3. Bifoga till filer

För att lägga till innehåll till en befintlig fil utan att skriva över den, öppna filen med läge ' a ':

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

Använd metoden write() för att lägga till data till filen:

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

Och, som alltid, stäng filen när du är klar:

file_obj.close()

För ett mer effektivt och renare tillvägagångssätt, använd med uttalandet:

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

Genom att följa dessa steg och exempel kan du effektivt navigera i filoperationer i dina Python-applikationer. Kom ihåg att alltid stänga dina filer efter att ha arbetat med dem för att undvika potentiella problem och resursläckor!

I nästa avsnitt ger vi en referens för felhantering i Python.

Snabbreferens för felhantering i Python

I det här avsnittet kommer du att lära dig om felhantering i Python, som spelar en avgörande roll för att förhindra abrupt avslutande av dina program när det stöter på ett fel.

We’ll cover the following sub-sections: Try and Except, Finally, and Raising Exceptions.

1. Try and Except

To handle exceptions in your code, you can use the try and except blocks. The try block contains the code that might raise an error, whereas the except block helps you handle that exception, ensuring your program continues running smoothly.

Here’s an example:

try:
    quotient = 5 / 0

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

In this case, the code inside the try block will raise a ZeroDivisionError exception. Since we have an except block to handle this specific exception, it will catch the error and print the message to alert you about the issue.

2. Finally

The finally block is used when you want to ensure that a specific block of code is executed, no matter the outcome of the try and except blocks. This is especially useful for releasing resources or closing files or connections, even if an exception occurs, ensuring a clean exit.

Here’s an example:

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. Raising Exceptions

You can also raise custom exceptions in your code to trigger error handling when specific conditions are met. To do this, you can use the raise statement followed by the exception you want to raise (either built-in or custom exception).

For instance:

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)

In this example, we’ve defined a custom function to validate an age value. If the provided age is less than zero, we raise a ValueError with a custom message. When calling this function, you should wrap it in a try-except block to handle the exception properly.

Next, we’re going to provide a modules and packages. Let’s go!

Quick Reference for Python Modules and Packages

This section of our cheat sheet is for Python packages and modules, which are essential for structuring and organizing your code cleanly and efficiently.

You’ll learn about importing modules and creating packages.

1. Importing Modules

Modules in Python are files containing reusable code, such as functions, classes, or variables. Python offers several modules and packages for different tasks like data science, machine learning, robotics, etc.

To use a module’s contents in your code, you need to import it first. Here are a few different ways to import a module:

• import : This imports the entire module, and you can access its contents using the syntax ‘module_name.content_name.’
  For example:

  import random
  
  c = random.ranint()

• from import : This imports a specific content (function or variable) from the module, and you can use it directly without referencing the module name.

  from math import sin
  
  c = sin(1.57)

• från import * : Detta importerar allt innehåll i modulen. Var försiktig med denna metod eftersom det kan leda till konflikter om olika moduler har innehåll med samma namn.

Några vanligt använda inbyggda Python-moduler inkluderar:

1. matematik: Ger matematiska funktioner och konstanter

2. slumpmässigt: Genererar slumptal och tillhandahåller relaterade funktioner

3. datetime : Hanterar datum- och tidsoperationer

4. os: Interagerar med operativsystemet och hanterar filer och kataloger

2. Skapa paket

Paket i Python är samlingar av relaterade moduler. De hjälper dig att organisera din kod i logiska och funktionella enheter. Så här skapar du ett paket:

1. Skapa en ny katalog med önskat paketnamn.

2. Lägg till en tom fil med namnet init.py i katalogen. Den här filen indikerar för Python att katalogen ska behandlas som ett paket.

3. Lägg till dina modulfiler (med tillägget .py) till katalogen.

Nu kan du importera paketet eller dess moduler till dina Python-skript. För att importera en modul från ett paket, använd syntaxen:

import 

Strukturera din kod med moduler och paket för att göra den mer organiserad och underhållbar. Detta kommer också att göra det lättare för dig och andra att navigera och förstå din kodbas.

I nästa avsnitt ger vi en referens för objektorienterade programmeringskoncept i Python.

Snabbreferens för objektorienterad programmering i Python

Objektorienterad programmering (OOP) är ett programmeringsparadigm baserat på konceptet " objekt ", som kan innehålla data och kod.

Uppgifterna är i form av fält, ofta kända som attribut eller egenskaper , och koden är i form av procedurer, ofta kända som metoder .

I det här avsnittet av fuskbladet kommer vi att fördjupa oss i de grundläggande koncepten för OOP i Python, inklusive klasser , arv och inkapsling .

1. Klasser

En klass är en ritning för att skapa objekt. Den definierar data (attribut) och funktionalitet (metoder) för objekten. För att börja skapa din egen klass, använd nyckelordet " klass " följt av klassnamnet:

class ClassName:
    # Class attributes and methods

För att lägga till attribut och metoder, definiera dem helt enkelt i klassblocket. Till exempel:

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

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

I det här exemplet kan ett nytt hundobjekt skapas med ett namn och en ras, och det har en barkmetod som skriver ut " Woof! ” när man ringer.

2. Arv

Arv tillåter en klass att ärva attribut och metoder från en annan klass, vilket möjliggör återanvändning av kod och modularitet. Klassen som ärver kallas en underklass eller härledd klass, medan klassen som ärvs från kallas basklassen eller superklassen.

För att implementera arv, lägg till namnet på superklassen inom parentes efter underklassens namn:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

Till exempel kan du skapa en underklass "Poodle" från en "Hund"-klass:

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

Ett pudelobjekt skulle nu ha alla attribut och metoder för hundklassen, såväl som sin egen show_trick-metod.

3. Inkapsling

Inkapsling är praxis att linda in data och metoder som arbetar på dessa data inom en enda enhet, ett objekt i detta fall. Detta främjar en tydlig åtskillnad mellan ett objekts interna implementering och dess externa gränssnitt.

Python använder namnmangling för att uppnå inkapsling för klassmedlemmar genom att lägga till ett dubbelt understrecksprefix till attributnamnet, vilket gör det till synes privat.

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

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

Även om du fortfarande tekniskt sett kan komma åt dessa privata medlemmar i Python, avråds det starkt att göra det eftersom det bryter mot inkapslingsprinciperna.

Genom att förstå och implementera klasser, arv och inkapsling i dina Python-program kan du använda kraften och flexibiliteten hos OOP för att skapa ren, modulär och återanvändbar kod.

För vårt sista avsnitt av fuskbladet ger vi dig en snabbreferens för fyra populära Python-bibliotek.

4 användbara Python-bibliotek

Flera Python-bibliotek kan hjälpa dig att åstadkomma ett eller få verktyg för olika ämnen som matematik, datavetenskap, webbskrapning, etc.

I det här avsnittet kommer vi kort att diskutera följande bibliotek: NumPy , Pandas , Requests och Beautiful Soup .

1. NumPy

NumPy är ett populärt Python-bibliotek för matematisk och vetenskaplig beräkning. Med sitt kraftfulla N-dimensionella arrayobjekt kan du hantera ett brett utbud av matematiska operationer, som:

• Grundläggande matematiska funktioner

• Linjär algebra

• Fourieranalys

• Generering av slumptal

manipulationer gör den särskilt lämplig för projekt som kräver numeriska beräkningar.

2. Pandas

Pandas är ett kraftfullt dataanalys- och manipulationsbibliotek som du kan använda för att arbeta med strukturerad data. Det är också mycket populärt inom datavetenskapssamhället på grund av det breda utbudet av verktyg som det tillhandahåller för att hantera data.

Några av dess funktioner inkluderar:

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

• Datarensning och förberedelse

• Statistisk analys

• Tidsseriefunktionalitet

Genom att använda Pandas kan du enkelt importera, analysera och manipulera data i en mängd olika format, som CSV, Excel och SQL-databaser.

Om du är intresserad av Pandas kan du kolla in vår video om hur du samplar om tidsseriedata med Pandas för att förbättra analysen:

3. Förfrågningar

Requests - biblioteket förenklar processen att hantera HTTP-förfrågningar i Python. Med det här biblioteket kan du enkelt skicka och ta emot HTTP-förfrågningar, som GET, POST och DELETE.

Några nyckelfunktioner inkluderar:

• Hantera omdirigeringar och följa länkar på webbsidor

• Lägga till rubriker, formulärdata och frågeparametrar via enkla Python-bibliotek

• Hantera cookies och sessioner

Med hjälp av Requests kan du snabbt och effektivt interagera med olika webbtjänster och API:er.

4. Vacker soppa

Beautiful Soup är ett Python-bibliotek för webbskrapning, som låter dig extrahera data från HTML- och XML-dokument. Några av dess nyckelfunktioner inkluderar:

• Söker efter specifika taggar eller CSS-klasser

• Navigera och ändra analyserade träd

• Extrahera relevant information baserat på taggattribut

Genom att använda Beautiful Soup i kombination med Requests kan du skapa kraftfulla webbskrapningsapplikationer som samlar information från ett brett utbud av webbplatser.

Slutgiltiga tankar

Och det tar oss till slutet av vår snabba resa nerför Python-banan. Det här är din fickguide, din pålitliga sidekick när du behöver en snabb påminnelse om Pythons bästa funktioner och kommandon.

Vår lista är inte uttömmande, men det är en solid start, en grund du kan bygga vidare på. Så sätt igång, bokmärk det, skriv ut det, sätt fast det på väggen – se bara till att det finns nära till hands när du kodar. Trevlig programmering!