Python-huijauslehti: Tärkeä nopea ja helppo opas

Kun ohjelmoit -sovelluksessa, luotettava huijauslehti rinnallasi voi muuttaa pelin. Python saattaa olla tunnettu yksinkertaisuudestaan ​​ja luettavuudestaan, mutta ei voi kiistää, että sen laaja valikoima ominaisuuksia ja toimintoja on liikaa muistiin!

Python-huijausarkit toimivat kätevänä referenssinä niin aloittelijoille kuin kokeneillekin kehittäjille. Ne tarjoavat perusoppaan erilaisille komentoille, syntakseille, tietorakenteille ja muille.

Tämä opas on Python-huijauslehti, jonka avulla voit selata kirjastoja, luokkia ja syntaksia, jotka voivat olla ylivoimaisia ​​etenkin aloittelijoille.

Oletko vanha koulu? Lataa ja tulosta mieluummin alla oleva pdf, joka auttaa sinua Python-oppimismatkallasi!

Sisällysluettelo

• Pikaopas Python-syntaksin perusteisiin
  • 1. Kommentit
  • 2. Muuttujat
  • 3. Tietotyypit
  • 4. Ehdolliset lausunnot
  • 5. Silmukat
  • 6. Toiminnot
• Pikaopas Python-tietorakenteille
  • 1. Luettelot
  • 2. Tuples
  • 3. Sarjat
  • 4. Sanakirjat
• Python-tiedoston I/O:n pikaopas
  • 1. Tiedostojen lukeminen
  • 2. Tiedostojen kirjoittaminen
  • 3. Liittäminen tiedostoihin
• Pikaopas Pythonin virheiden käsittelyyn
  • 1. Kokeile ja paitsi
  • 2. Lopuksi
  • 3. Poikkeusten lisääminen
• Pikaopas Python-moduuleille ja -paketeille
  • 1. Moduulien tuonti
  • 2. Pakettien luominen
• Pikaopas olio-ohjelmointiin Pythonissa
  • 1. Luokat
  • 2. Perintö
  • 3. Kapselointi
• 4 hyödyllistä Python-kirjastoa
  • 1. NumPy
  • 2. Pandat
  • 3. Pyynnöt
  • 4. Kaunis keitto
• Lopulliset ajatukset

Pikaopas Python-syntaksin perusteisiin

Python-huijausarkin käynnistämiseksi tutkimme joitain Python-syntaksin perusteita. Pythonin perusteiden vahva ymmärtäminen antaa sinulle vankan perustan monimutkaisemman koodin kirjoittamiselle.

Tätä viittausta varten olemme sisällyttäneet: kommentit , muuttujat , tietotyypit , ehdolliset lausekkeet , silmukat ja funktiot .

1. Kommentit

Kommentit ovat tärkeä osa koodiasi, koska niiden avulla voit selittää ajatteluprosessiasi ja tehdä koodistasi luettavamman. Pythonissa voit luoda yksirivisiä kommentteja hash-symbolilla (#).

# This is a single-line comment.

Monirivisissä kommenteissa voit käyttää kolminkertaisia ​​lainausmerkkejä (joko yksi- tai kaksinkertaisia).

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

2. Muuttujat

Pythonin muuttujia käytetään tietojen tallentamiseen. Voit määrittää muuttujille arvoja yhtäläisyysmerkillä (=).

x = 5
name = "John"

Muuttujien nimien tulee olla kuvaavia ja noudattaa nimeämiskäytäntöä, jossa käytetään pieniä kirjaimia ja alaviivoja välilyönneissä.

user_age = 25
favorite_color = "blue"

3. Tietotyypit

Python-kielessä on oletuksena sisäänrakennettu useita tietotyyppejä. Jotkut yleisimmistä ovat:

• Tekstityypit : str

• Boolen tyyppi : bool

• Numeeriset tyypit : int, float, kompleksi

• Sekvenssityypit : lista, monikko, alue

• Ei mitään Tyyppi: Ei tyyppiä

Voit selvittää minkä tahansa Python-objektin tietotyypin käyttämällä type()- funktiota. Esimerkiksi:

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

#Output: 'str'

4. Ehdolliset lausunnot

Pythonin ehdolliset lausekkeet sallivat koodin suorittamisen vain, kun tietyt ehdot täyttyvät. Yleiset ehdolliset lauseet ovat if , elif ja 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. Silmukat

Silmukkaa käytetään koodilohkon toistuvaan suorittamiseen. ' for ' silmukan ja ' while ' -silmukan.

Katsotaanpa niitä molempia:

Silmukoille:

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

Vaikka silmukat:

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

Näissä silmukoissa voit käyttää ehdollisia ja ohjauskäskyjä ohjelman kulun ohjaamiseen.

6. Toiminnot

Pythonin funktiot ovat koodilohkoja, jotka suorittavat tiettyjä tehtäviä. Voit määrittää funktion käyttämällä ' def' -avainsanaa, jota seuraa funktion nimi ja sulut, jotka sisältävät mahdolliset syöttöparametrit.

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

Kun haluat kutsua funktiota, käytä funktion nimeä ja sulkeita, jotka sisältävät tarvittavat argumentit.

function_name(arguments)

Nyt kun olemme käyneet läpi Pythonin perusteet, siirrytään seuraavassa osiossa joihinkin edistyneempiin aiheisiin.

Pikaopas Python-tietorakenteille

Seuraavaksi Python-huijaustaulukossamme keskustelemme joistakin Pythonin yleisimmin käytetyistä tietorakenteista. Nämä tietorakenteet ovat välttämättömiä ohjelmointiprojektien tietojen hallinnassa ja järjestämisessä.

Pythonissa on monia tietorakenteita, joita edistyneet kehittäjät voivat käyttää. Keskitymme kuitenkin luetteloihin , ketjuihin , joukkoihin ja sanakirjoihin .

1. Luettelot

A on muuttuva, järjestetty elementtisarja. Luo luettelo käyttämällä hakasulkeita ja erottele elementit pilkuilla.

Python-luettelot voivat sisältää erilaisia ​​tietotyyppejä, kuten merkkijonoja, kokonaislukuja, booleaneja jne. Tässä on joitain luetteloita:

• Luo lista:

  my_list = [1, 2, 3]

• Pääsyelementit:

  my_list[0]

• Lisää elementti:

  my_list.append(4)

2. Tuples

Tuple on samanlainen kuin luettelo, mutta se on muuttumaton, mikä tarkoittaa, että sen elementtejä ei voi muuttaa sen luomisen jälkeen. Voit luoda monikon käyttämällä sulkeita ja erottamalla elementit pilkuilla.

Tässä on joitain esimerkkejä tuple-operaatioista:

• Luo monikko:

  my_tuple = (1, 2, 3)

• Pääsyelementit:

  my_tuple[0] #Output: 1

3. Sarjat

Sarja on järjestämätön kokoelma ainutlaatuisia elementtejä. Voit luoda joukon käyttämällä set()-funktiota tai aaltosulkeet.

Se voi myös sisältää erilaisia ​​​​tietotyyppejä, kunhan ne ovat ainutlaatuisia. Tässä on joitain esimerkkejä asetusoperaatioista:

• Luo sarja:

   my_set = {1, 2, 3}

• Lisää elementti:

  my_set.add(4)

• Poista elementti:

  my_set.remove(1)

4. Sanakirjat

Sanakirja on avain-arvo-parien järjestämätön kokoelma, jossa avaimet ovat yksilöllisiä. Voit luoda sanakirjan aaltosulkeilla ja erottamalla avaimet ja arvot kaksoispisteillä. Tässä on esimerkkejä sanakirjan toiminnoista:

• Luo sanakirja:

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

• Pääsyelementit:

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

• Lisää avain-arvo-pari:

  my_dict['key3'] = 'value3'

• Poista avain-arvo-pari:

  del my_dict['key1']

Muista harjoitella ja tutkia näitä tietorakenteita Python-projekteissasi, jotta pääset paremmin käyttämään niitä! Seuraavaksi annamme sinulle viitteen tiedostojen I/O-tehtäviin.

Python-tiedoston I/O:n pikaopas

Tässä Python-huijausarkin osassa keskitymme joihinkin yleisiin Python-tiedostojen käsittelyyn liittyviin tehtäviin, kuten lukemiseen , kirjoittamiseen ja tietojen liittämiseen .

1. Tiedostojen lukeminen

Jos haluat lukea tiedoston, sinun on ensin avattava se sisäänrakennetulla open()- funktiolla siten, että tilaparametriksi on asetettu ' r ' lukemista varten:

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

Nyt kun tiedostosi on auki, voit lukea sen sisällön eri tavoilla:

• read(): Lukee tiedoston koko sisällön.

• readline() : Lukee a:n tiedostosta.

• readlines() : Palauttaa listan kaikista tiedoston riveistä.

On tärkeää muistaa sulkea tiedosto, kun olet lopettanut sen käsittelyn:

file_obj.close()

Vaihtoehtoisesti voit käyttää with - käskyä, joka sulkee tiedoston automaattisesti, kun koodilohko on valmis:

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

2. Tiedostojen kirjoittaminen

Jos haluat luoda uuden tiedoston tai korvata olemassa olevan, avaa tiedosto tilassa ' w ':

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

Kirjoita tiedot tiedostoon write()- menetelmällä:

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

Muista sulkea tiedosto:

file_obj.close()

Harkitse vielä kerran with-lauseen käyttöä tiiviimmän ja turvallisemman tavan käsitellä tiedostoja:

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

3. Liittäminen tiedostoihin

Jos haluat lisätä sisältöä olemassa olevaan tiedostoon korvaamatta sitä, avaa tiedosto tilassa ' 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 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. Lisää hakemistoon tyhjä tiedosto nimeltä init.py. Tämä tiedosto osoittaa Pythonille, että hakemistoa tulee käsitellä pakettina.

3. Lisää moduulitiedostosi (.py-tunnisteella) hakemistoon.

Nyt voit tuoda paketin tai sen moduulit Python-skripteihisi. Voit tuoda moduulin paketista käyttämällä syntaksia:

import 

Järjestä koodisi moduuleilla ja paketeilla, jotta se olisi organisoituvampi ja ylläpidettävämpi. Tämä helpottaa myös sinun ja muiden navigointia ja koodikannan ymmärtämistä.

Seuraavassa osiossa tarjoamme viittauksen Pythonin olio-ohjelmointikonsepteihin.

Pikaopas olio-ohjelmointiin Pythonissa

Object-Oriented Programming (OOP) on ohjelmointiparadigma, joka perustuu " objektien " käsitteeseen , joka voi sisältää dataa ja koodia.

Tiedot ovat kenttien muodossa, jotka tunnetaan usein attribuutteina tai ominaisuuksina , ja koodi on menettelyjen muodossa, joita usein kutsutaan menetelmiksi .

Tässä huijausarkin osassa perehdymme Pythonin OOP:n peruskäsitteisiin, mukaan lukien luokat , perinnöllisyys ja kapselointi .

1. Luokat

Luokka on suunnitelma objektien luomiseen. Se määrittelee objektien tiedot (attribuutit) ja toiminnallisuuden (menetelmät). Aloita oman luokan luominen käyttämällä “ luokka ” -avainsanaa ja luokan nimeä:

class ClassName:
    # Class attributes and methods

Jos haluat lisätä attribuutteja ja menetelmiä, määritä ne luokkalohkossa. Esimerkiksi:

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

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

Tässä esimerkissä uusi koira-objekti voidaan luoda nimellä ja rodulla, ja siinä on haukkumenetelmä, joka tulostaa " Hau! ” kun soitetaan.

2. Perintö

Periytymisen avulla yksi luokka voi periä attribuutteja ja menetelmiä toiselta luokalta, mikä mahdollistaa koodin uudelleenkäytettävyyden ja modulaarisuuden. Luokkaa, joka perii, kutsutaan alaluokiksi tai johdetuksi luokaksi, kun taas luokkaa, josta peritään, kutsutaan perusluokiksi tai yliluokiksi.

Suorittaaksesi periytymisen, lisää superluokan nimi sulkeisiin alaluokan nimen jälkeen:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

Voit esimerkiksi luoda alaluokan "villakoira" luokasta "Koira":

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

Villakoiraobjektilla olisi nyt kaikki Dog-luokan attribuutit ja menetelmät sekä oma show_trick -metodi.

3. Kapselointi

Kapselointi on käytäntöä kääriä tiedot ja menetelmät, jotka toimivat kyseisellä tiedolla yhdessä yksikössä, tässä tapauksessa objektissa. Tämä edistää selkeää eroa objektin sisäisen toteutuksen ja sen ulkoisen käyttöliittymän välillä.

Python käyttää nimenkäsittelyä luokan jäsenten kapseloimiseksi lisäämällä kaksoisalaviivan etuliite attribuutin nimeen, mikä tekee siitä näennäisen yksityisen.

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

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

Vaikka voit edelleen teknisesti käyttää näitä yksityisiä jäseniä Pythonissa, se ei ole suositeltavaa, koska se rikkoo kapselointiperiaatteita.

Ymmärtämällä ja toteuttamalla luokkia, periytymistä ja kapselointia Python-ohjelmissasi voit hyödyntää OOP:n tehoa ja joustavuutta puhtaan, modulaarisen ja uudelleenkäytettävän koodin luomiseen.

Huijaustaulukon viimeisessä osiossa tarjoamme sinulle pikaoppaan neljästä suositusta Python-kirjastosta.

4 hyödyllistä Python-kirjastoa

Useat Python-kirjastot voivat auttaa sinua saavuttamaan tai hankkimaan työkaluja erilaisiin aiheisiin, kuten matematiikkaan, datatieteeseen, verkkokaappaukseen jne.

Tässä osiossa käsittelemme lyhyesti seuraavia kirjastoja: NumPy , Pandas , Requests ja Beautiful Soup .

1. NumPy

NumPy on suosittu Python-kirjasto matemaattiseen ja tieteelliseen laskemiseen. Sen tehokkaan N-ulotteisen taulukkoobjektin avulla voit käsitellä monenlaisia ​​matemaattisia operaatioita, kuten:

• Matemaattiset perusfunktiot

• Lineaarialgebra

• Fourier-analyysi

• Satunnaislukujen sukupolvi

manipulaatiot tekevät siitä erityisen sopivan projekteihin, jotka vaativat numeerisia laskelmia.

2. Pandat

Pandas on tehokas tietojen analysointi- ja käsittelykirjasto, jonka avulla voit työskennellä strukturoidun tiedon kanssa. Se on myös erittäin suosittu datatiedeyhteisössä, koska se tarjoaa laajan valikoiman työkaluja datan käsittelyyn.

Joitakin sen ominaisuuksia ovat:

• Tietorakenteet, kuten Series (1D) ja DataFrame (2D)

• Tietojen puhdistus ja valmistelu

• Tilastollinen analyysi

• Aikasarjan toiminnallisuus

Pandasin avulla voit helposti tuoda, analysoida ja käsitellä tietoja useissa eri muodoissa, kuten CSV-, Excel- ja SQL-tietokantoissa.

Jos olet kiinnostunut Pandoista, voit katsoa videomme, jossa kerrotaan, kuinka voit ottaa aikasarjadatan uudelleen analyysin parantamiseksi Pandoilla:

3. Pyynnöt

Pyyntökirjasto yksinkertaistaa HTTP - pyyntöjen käsittelyä Pythonissa. Tämän kirjaston avulla voit helposti lähettää ja vastaanottaa HTTP-pyyntöjä, kuten GET, POST ja DELETE.

Joitakin tärkeimpiä ominaisuuksia ovat:

• Uudelleenohjausten käsittely ja linkkien seuraaminen verkkosivuilla

• Otsikoiden, lomaketietojen ja kyselyparametrien lisääminen yksinkertaisten Python-kirjastojen kautta

• Evästeiden ja istuntojen hallinta

Pyyntöjen avulla voit nopeasti ja tehokkaasti olla vuorovaikutuksessa eri verkkopalvelujen ja API:iden kanssa.

4. Kaunis keitto

Beautiful Soup on Python-kirjasto web-kaappausta varten, jonka avulla voit poimia tietoja HTML- ja XML-dokumenteista. Joitakin sen tärkeimpiä ominaisuuksia ovat:

• Tiettyjen tunnisteiden tai CSS-luokkien etsiminen

• Jäsennetyissä puissa navigointi ja muokkaaminen

• Oleellisen tiedon poimiminen tag-attribuuttien perusteella

Käyttämällä Beautiful Soupia yhdessä pyyntöjen kanssa voit luoda tehokkaita web-kaappaussovelluksia, jotka keräävät tietoa useilta verkkosivustoilta.

Lopulliset ajatukset

Ja se vie meidät nopean matkamme loppuun Python-kaistaa pitkin. Tämä on taskuoppaasi, luotettava apulainen, kun tarvitset nopean muistutuksen Pythonin tärkeimmistä toiminnoista ja komennoista.

Luettelomme ei ole tyhjentävä, mutta se on vankka alku, perusta, jolle voit rakentaa. Joten mene eteenpäin, merkitse se kirjanmerkkeihin, tulosta se, kiinnitä se seinällesi – varmista vain, että se on käden ulottuvilla, kun koodaat. Hyvää ohjelmointia!