Cheatsheet voor Python: essentiële snelle en eenvoudige handleiding

Bij het programmeren in Python kan het hebben van een betrouwbaar spiekbriefje aan je zijde een game-changer zijn. Python staat misschien bekend om zijn eenvoud en leesbaarheid, maar het valt niet te ontkennen dat het uitgebreide scala aan functies en functionaliteiten te veel is om te onthouden!

Python-spiekbriefjes dienen als handig naslagwerk voor zowel beginners als ervaren ontwikkelaars. Ze bieden een basisreferentiegids voor verschillende opdrachten, syntaxis, gegevensstructuren en meer.

Deze gids is een spiekbriefje voor Python dat u kan helpen bij het navigeren door verschillende functies , bibliotheken, klassen en syntaxis die overweldigend kunnen zijn, vooral voor beginners.

Ben je oldskool? Download en print liever, bekijk de onderstaande pdf om je te helpen op je Python-leerreis!

Python-Cheat-Sheet-1 downloaden

Inhoudsopgave

• Snelle referentie voor basisprincipes van Python-syntaxis
  • 1. Opmerkingen
  • 2. Variabelen
  • 3. Gegevenstypen
  • 4. Voorwaardelijke verklaringen
  • 5. Lussen
  • 6. Functies
• Snelle referentie voor Python-gegevensstructuren
  • 1. Lijsten
  • 2. Tupels
  • 3 sets
  • 4. Woordenboeken
• Snelle referentie voor Python File I/O
  • 1. Bestanden lezen
  • 2. Bestanden schrijven
  • 3. Toevoegen aan bestanden
• Snelle referentie voor foutafhandeling in Python
  • 1. Probeer en behalve
  • 2. Eindelijk
  • 3. Uitzonderingen maken
• Snelle referentie voor Python-modules en -pakketten
  • 1. Modules importeren
  • 2. Pakketten maken
• Snelle referentie voor objectgeoriënteerd programmeren in Python
  • 1. Klassen
  • 2. Overerving
  • 3. Inkapseling
• 4 handige Python-bibliotheken
  • 1. NumPy
  • 2. Panda's
  • 3. Verzoeken
  • 4. Mooie soep
• Laatste gedachten

Snelle referentie voor basisprincipes van Python-syntaxis

Om ons Python-spiekbriefje te starten, zullen we enkele basisprincipes van de Python-syntaxis verkennen. Als je de basis van Python goed onder de knie hebt, heb je een solide basis voor het schrijven van complexere code.

Voor deze referentie hebben we toegevoegd: commentaren , variabelen , gegevenstypen , voorwaardelijke instructies , loops en functies .

1. Opmerkingen

Opmerkingen zijn een belangrijk onderdeel van uw code, omdat ze u in staat stellen uw denkproces uit te leggen en uw code leesbaarder te maken. In Python kunt u opmerkingen van één regel maken met behulp van het hash-symbool (#).

# This is a single-line comment.

Voor opmerkingen met meerdere regels kunt u drievoudige aanhalingstekens gebruiken (enkel of dubbel).

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

2. Variabelen

Variabelen in Python worden gebruikt om gegevens op te slaan. U kunt waarden toewijzen aan variabelen met behulp van het gelijkteken (=).

x = 5
name = "John"

Variabelenamen moeten beschrijvend zijn en de naamgevingsconventie volgen van het gebruik van kleine letters en onderstrepingstekens voor spaties.

user_age = 25
favorite_color = "blue"

3. Gegevenstypen

De Python-taal wordt standaard geleverd met verschillende ingebouwde gegevenstypen. Enkele van de meest voorkomende zijn:

• Tekstsoorten : str

• Booleaans type : bool

• Numerieke typen : int, float, complex

• Reekstypen : lijst, tupel, bereik

• Geen Type: Geentype

Om het gegevenstype van een Python-object te achterhalen, kunt u de functie type() gebruiken . Bijvoorbeeld:

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

#Output: 'str'

4. Voorwaardelijke verklaringen

Met voorwaardelijke instructies in Python kunt u alleen code uitvoeren als aan bepaalde voorwaarden is voldaan. De gemeenschappelijke voorwaardelijke verklaringen zijn ' als ', 'elif ' en ' anders '.

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

Een lus wordt gebruikt om herhaaldelijk een codeblok uit te voeren. Python kent twee soorten loops: een ' for ' loop en een ' while ' loop.

Laten we ze allebei eens bekijken:

Voor lussen:

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

While-lussen:

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

Binnen deze loops kun je conditionele en control statements gebruiken om de flow van je programma te controleren.

6. Functies

Functies in Python zijn codeblokken die specifieke taken uitvoeren. U kunt een functie definiëren met behulp van het sleutelwoord ' def ', gevolgd door de functienaam en haakjes met eventuele invoerparameters.

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

Om een ​​functie aan te roepen, gebruikt u de functienaam gevolgd door haakjes met de benodigde argumenten.

function_name(arguments)

Nu we de basisprincipes van Python hebben besproken, gaan we verder met enkele meer geavanceerde onderwerpen in de volgende sectie.

Snelle referentie voor Python-gegevensstructuren

Vervolgens bespreken we in onze Python-cheatsheet enkele van de meest gebruikte datastructuren in Python. Deze gegevensstructuren zijn essentieel bij het beheren en organiseren van de gegevens in uw programmeerprojecten.

Er zijn veel datastructuren in Python die geavanceerde ontwikkelaars kunnen gebruiken. We zullen ons echter concentreren op Lijsten , Tuples , Sets en Woordenboeken .

1. Lijsten

Een lijst in Python is een veranderlijke, geordende reeks elementen. Om een ​​lijst te maken, gebruikt u vierkante haken en scheidt u de elementen met komma's.

Python-lijsten kunnen verschillende gegevenstypen bevatten, zoals strings, gehele getallen, booleans, enz. Hier zijn enkele voorbeelden van bewerkingen die u met Python- lijsten kunt uitvoeren:

• Maak een lijst:

  my_list = [1, 2, 3]

• Toegangselementen:

  my_list[0]

• Voeg een element toe:

  my_list.append(4)

2. Tupels

Een tuple lijkt op een lijst, maar is onveranderlijk, wat betekent dat u de elementen ervan niet meer kunt wijzigen als ze eenmaal zijn gemaakt. U kunt een tuple maken door haakjes te gebruiken en de elementen te scheiden met komma's.

Hier zijn enkele voorbeelden van tuple-bewerkingen:

• Maak een tuple:

  my_tuple = (1, 2, 3)

• Toegangselementen:

  my_tuple[0] #Output: 1

3 sets

Een set is een ongeordende verzameling unieke elementen. U kunt een set maken met de functie set() of accolades.

Het kan ook verschillende soorten gegevens bevatten, zolang ze maar uniek zijn. Hier volgen enkele voorbeelden van setbewerkingen:

• Maak een reeks:

   my_set = {1, 2, 3}

• Voeg een element toe:

  my_set.add(4)

• Een onderdeel verwijderen:

  my_set.remove(1)

4. Woordenboeken

Een woordenboek is een ongeordende verzameling sleutel-waardeparen, waarbij de sleutels uniek zijn. U kunt een woordenboek maken door accolades te gebruiken en de sleutels en waarden te scheiden met dubbele punten. Hier volgen enkele voorbeelden van woordenboekbewerkingen:

• Maak een woordenboek:

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

• Toegangselementen:

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

• Voeg een sleutel-waardepaar toe:

  my_dict['key3'] = 'value3'

• Een sleutel-waardepaar verwijderen:

  del my_dict['key1']

Vergeet niet om deze datastructuren in uw Python-projecten te oefenen en te verkennen om meer bedreven te worden in het gebruik ervan! Vervolgens geven we u een referentie voor bestands-I/O-taken.

Quick Reference for Python File I/O

In this section of the Python cheat sheet, we’ll focus on some common tasks related to working with files in Python, such as reading, writing, and appending data.

1. Reading Files

To read a file, you first need to open it using the built-in open() function, with the mode parameter set to ‘r‘ for reading:

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

Now that your file is open, you can use different methods to read its content:

• read(): Reads the entire content of the file.

• readline(): Reads a single line from the file.

• readlines(): Returns a list of all lines in the file.

It’s important to remember to close the file once you’ve finished working with it:

file_obj.close()

Alternatively, you can use the with statement, which automatically closes the file after the block of code completes:

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

2. Writing Files

To create a new file or overwrite an existing one, open the file with mode ‘w‘:

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

Write data to the file using the write() method:

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

Don’t forget to close the file:

file_obj.close()

Again, consider using the with statement for a more concise and safer way to handle files:

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

3. Appending to Files

To add content to an existing file without overwriting it, open the file with mode ‘a‘:

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

Use the write() method to append data to the file:

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

And, as always, close the file when you’re done:

file_obj.close()

For a more efficient and cleaner approach, use the with statement:

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

By following these steps and examples, you can efficiently navigate file operations in your Python applications. Remember to always close your files after working with them to avoid potential issues and resource leaks!

In the next section, we provide a reference for error handling in Python.

Quick Reference for Error Handling in Python

In this section, you’ll learn about error handling in Python, which plays a crucial role in preventing the abrupt termination of your programs when it encounters an error.

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 quick reference for popular Python 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)

• from import *: This imports all contents of the module. Be careful with this method as it can lead to conflicts if different modules have contents with the same name.

Some commonly used built-in Python modules include:

1. math: Provides mathematical functions and constants

2. random: Generates random numbers and provides related functions

3. datetime: Handles date and time operations

4. os: Interacts with the operating system and manages files and directories

2. Creating Packages

Packages in Python are collections of related modules. They help you organize your code into logical and functional units. To create a package:

1. Create a new directory with the desired package name.

2. Add an empty file named init.py to the directory. This file indicates to Python that the directory should be treated as a package.

3. Add your module files (with the .py extension) to the directory.

Now, you can import the package or its modules into your Python scripts. To import a module from a package, use the syntax:

import 

Structure your code with modules and packages to make it more organized and maintainable. This will also make it easier for you and others to navigate and comprehend your codebase.

In the next section, we provide a reference for object-oriented programming concepts in Python.

Quick Reference for Object-Oriented Programming in Python

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects“, which can contain data and code.

The data is in the form of fields, often known as attributes or properties, and the code is in the form of procedures, often known as methods.

In this section of the cheat sheet, we’ll delve into the fundamental concepts of OOP in Python, including classes, inheritance, and encapsulation.

1. Classes

A class is a blueprint for creating objects. It defines the data (attributes) and functionality (methods) of the objects. To begin creating your own class, use the “class” keyword followed by the class name:

class ClassName:
    # Class attributes and methods

To add attributes and methods, simply define them within the class block. For example:

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

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

In dit voorbeeld kan een nieuw Dog-object worden gemaakt met een naam en ras, en het heeft een blafmethode die " Woef! ' wanneer gebeld.

2. Overerving

Door overerving kan een klasse attributen en methoden van een andere klasse overnemen, waardoor code opnieuw kan worden gebruikt en modulair kan worden gemaakt. De klasse die erft wordt een subklasse of afgeleide klasse genoemd, terwijl de klasse waarvan wordt geërfd de basisklasse of superklasse wordt genoemd.

Om overerving te implementeren, voegt u de naam van de superklasse tussen haakjes toe na de naam van de subklasse:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

U kunt bijvoorbeeld een subklasse "Poedel" maken van een "Dog"-klasse:

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

Een Poodle-object zou nu alle attributen en methoden van de Dog-klasse hebben, evenals zijn eigen show_trick-methode.

3. Inkapseling

Inkapseling is de praktijk van het verpakken van gegevens en methoden die op die gegevens werken binnen een enkele eenheid, in dit geval een object. Dit bevordert een duidelijke scheiding tussen de interne implementatie van een object en de externe interface.

Python maakt gebruik van naammangeling om inkapseling voor klasleden te bereiken door een dubbel onderstrepingsteken voorvoegsel toe te voegen aan de attribuutnaam, waardoor het schijnbaar privé wordt.

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

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

Hoewel je technisch nog steeds toegang hebt tot deze privé-leden in Python, wordt dit sterk afgeraden omdat het inkapselingsprincipes schendt.

Door klassen, overerving en inkapseling in uw Python-programma's te begrijpen en te implementeren, kunt u de kracht en flexibiliteit van OOP gebruiken om schone, modulaire en herbruikbare code te creëren.

Voor ons laatste deel van het spiekbriefje geven we je een korte referentie voor vier populaire Python-bibliotheken.

4 handige Python-bibliotheken

Verschillende Python-bibliotheken kunnen u helpen een verscheidenheid aan taken uit te voeren of hulpmiddelen te verkrijgen voor verschillende onderwerpen, zoals wiskunde, datawetenschap, webschrapen, enz.

In deze sectie bespreken we kort de volgende bibliotheken: NumPy , Pandas , Requests en Beautiful Soup .

1. NumPy

NumPy is een populaire Python-bibliotheek voor wiskundig en wetenschappelijk computergebruik. Met zijn krachtige N-dimensionale array-object kunt u een breed scala aan wiskundige bewerkingen uitvoeren, zoals:

• Basis wiskundige functies

• Lineaire algebra

• Fourier-analyse

• Willekeurige nummergeneratie

De efficiënte array-manipulaties van NumPy maken het bijzonder geschikt voor projecten die numerieke berekeningen vereisen.

2. Panda's

Pandas is een krachtige bibliotheek voor gegevensanalyse en -manipulatie die u kunt gebruiken om met gestructureerde gegevens te werken. Het is ook erg populair in de data science-gemeenschap vanwege het brede scala aan tools die het biedt voor het verwerken van gegevens.

Enkele van de kenmerken zijn:

• Datastructuren zoals Series (1D) en DataFrame (2D)

• Gegevens opschonen en voorbereiden

• statistische analyse

• Tijdreeksfunctionaliteit

Door Panda's te gebruiken, kunt u eenvoudig gegevens importeren, analyseren en manipuleren in verschillende indelingen, zoals CSV-, Excel- en SQL-databases.

Als u geïnteresseerd bent in Panda's, kunt u onze video bekijken over het opnieuw bemonsteren van tijdreeksgegevens met behulp van Panda's om de analyse te verbeteren:

3. Verzoeken

De Requests- bibliotheek vereenvoudigt het proces van het afhandelen van HTTP-verzoeken in Python. Met deze bibliotheek kunt u eenvoudig HTTP-verzoeken verzenden en ontvangen, zoals GET, POST en DELETE.

Enkele belangrijke kenmerken zijn:

• Omleidingen en volgende links op webpagina's afhandelen

• Kopteksten, formuliergegevens en queryparameters toevoegen via eenvoudige Python-bibliotheken

• Cookies en sessies beheren

Met behulp van Requests kunt u snel en efficiënt communiceren met verschillende webservices en API's.

4. Mooie soep

Beautiful Soup is een Python-bibliotheek voor webscraping, waarmee u gegevens uit HTML- en XML-documenten kunt extraheren. Enkele van de belangrijkste kenmerken zijn:

• Zoeken naar specifieke tags of CSS-klassen

• Navigeren en wijzigen van geparseerde bomen

• Relevante informatie extraheren op basis van tagattributen

Door Beautiful Soup te gebruiken in combinatie met Requests, kunt u krachtige webscraping-applicaties maken die informatie verzamelen van een breed scala aan websites.

Laatste gedachten

En dat brengt ons aan het einde van onze snelle trip langs Python Lane. Dit spiekbriefje is je zakboekje, je trouwe hulpje voor als je een snelle herinnering aan de belangrijkste functies en commando's van Python nodig hebt.

Onze lijst is niet volledig, maar het is een solide start, een basis waarop u kunt bouwen. Dus ga je gang, maak er een bladwijzer van, druk het af, plak het op je muur - zorg er gewoon voor dat je het bij de hand hebt als je aan het coderen bent. Veel plezier met programmeren!