Python: Mokymasis Python

Išsamus Python vadovas

👋 Sveiki atvykę į Stackhero dokumentaciją!

Stackhero siūlo paruoštą naudoti Python cloud sprendimą, kuris suteikia daugybę privalumų, įskaitant:

  • Įdiekite savo programą per kelias sekundes su paprastu git push.
  • Naudokite savo domeno vardą ir pasinaudokite automatinės HTTPS sertifikatų konfigūracijos privalumais, kad padidintumėte saugumą.
  • Mėgaukitės ramybe su automatinėmis atsarginėmis kopijomis, vieno paspaudimo atnaujinimais ir paprasta, skaidria bei prognozuojama kainodara.
  • Gaukite optimalią veikimo ir tvirtą saugumo lygį dėka privačios ir dedikuotos VM.

Taupykite laiką ir supaprastinkite savo gyvenimą: išbandyti Stackhero Python cloud hosting sprendimą užtrunka tik 5 minutes!

Šis vadovas siūlo esminių Python sąvokų ir sintaksės apžvalgą. Jis tarnauja kaip greitas priminimas patyrusiems kūrėjams ir draugiška įžanga pradedantiesiems. Apimantis viską nuo pagrindinių duomenų tipų iki pažangių funkcijų, šis špargalkė apima temas, tokias kaip valdymo srautas, funkcijos, klasės, objektai ir bendri moduliai. Laikykite jį po ranka kaip greitą nuorodą dirbant su Python projektais. Atminkite, kad Python turi didžiulę bibliotekų ir sistemų ekosistemą, todėl papildomų išteklių ir dokumentacijos tyrinėjimas padės giliau įsigilinti į specializuotas temas.

Sėkmingo programavimo!

Įvadas į Python

Python yra universalus, aukšto lygio programavimo kalba, sukurta Guido van Rossum ir pirmą kartą išleista 1991 m. Ji yra populiari dėl savo skaitomumo ir paprastumo, todėl puikiai tinka tiek pradedantiesiems, tiek patyrusiems kūrėjams. Python plačiai naudojama interneto kūrime, duomenų analizėje, dirbtiniame intelekte, mašininio mokymosi ir automatizavimo srityse, tarp daugelio kitų sričių.

Kai kurie dažni Python naudojimo atvejai apima interneto programų kūrimą naudojant sistemas, tokias kaip Django ar Flask, duomenų analizę ir vizualizaciją su bibliotekomis, tokiomis kaip pandas ir matplotlib, ir mašininio mokymosi modelių kūrimą su įrankiais, tokiais kaip TensorFlow ir scikit-learn.

Python plati standartinė biblioteka ir klestinti trečiųjų šalių paketų ekosistema daro ją galinga ir lankstia kalba, skirta spręsti įvairias programavimo užduotis.

Pagrindiniai duomenų tipai

Python pagrindiniai duomenų tipai apima sveikuosius skaičius (visus skaičius), slankiojo kablelio skaičius (skaičius su dešimtainėmis dalimis), boolean (tiesa/netiesa reikšmes) ir eilutes (simbolių sekas):

  • int: Sveikasis skaičius, pvz., 42
  • float: Slankiojo kablelio skaičius, pvz., 3.14
  • bool: Boolean, pvz., True arba False
  • str: Eilutė, pvz., "hello"

Pavyzdys:

integer = 42
floating_point = 3.14
boolean = True
string = "Hello, World!"

Dažnos duomenų struktūros

Python suteikia keletą duomenų struktūrų, padedančių efektyviai organizuoti, saugoti ir manipuliuoti duomenimis. Dažniausiai naudojamos yra sąrašai, tuple, žodynai ir rinkiniai. Sąrašai ir tuple palaiko tvarkingą elementų seką, žodynai saugo raktų ir reikšmių poras, o rinkiniai saugo unikalius elementus. Kiekviena struktūra turi įvairių metodų, pritaikytų specifiniams naudojimo atvejams.

  • Sąrašas: my_list = [1, 2, 3, 4]
  • Tuple: my_tuple = (1, 2, 3, 4)
  • Žodynas: my_dictionary = {'key1': 'value1', 'key2': 'value2'}
  • Rinkinys: my_set = {1, 2, 3, 4}

Sąrašai

Sąrašai yra kintamos, tvarkingos elementų kolekcijos. Jie leidžia dublikatus ir gali turėti įvairių duomenų tipų elementus, įskaitant kitus sąrašus, tuple, žodynus ar rinkinius. Galite lengvai pridėti, atnaujinti ir pašalinti elementus. Sąrašai apibrėžiami kvadratiniais skliaustais [] su elementais, atskirtais kableliais.

Pagrindiniai punktai apie sąrašus:

  1. Kintami ir tvarkingi
  2. Leidžia dublikatus
  3. Išlaiko elementų pridėjimo tvarką
  4. Palaiko kelis duomenų tipus
  5. Teikia operacijas elementų pridėjimui, atnaujinimui ir šalinimui

Sąrašai dažnai naudojami, kai reikia dinaminės ir keičiamo dydžio elementų kolekcijos.

Pavyzdžiai:

# Sukurti sąrašą
my_list = [1, 2, 3, 4, 5]

# Pasiekti elementus
print(my_list[0])  # Rezultatas: 1
print(my_list[-1])  # Rezultatas: 5

# Pridėti elementus
my_list.append(6)
print(my_list)  # Rezultatas: [1, 2, 3, 4, 5, 6]

# Atnaujinti elementus
my_list[0] = 0
print(my_list)  # Rezultatas: [0, 2, 3, 4, 5, 6]

# Pašalinti elementus
del my_list[0]
print(my_list)  # Rezultatas: [2, 3, 4, 5, 6]

Žodynai

Žodynai yra kintamos, netvarkingos raktų ir reikšmių porų kolekcijos. Kiekvienas raktas turi būti unikalus, ir galite naudoti šiuos raktus, norėdami pasiekti jų susijusias reikšmes. Kaip ir sąrašai, žodynai gali saugoti įvairių duomenų tipų elementus, įskaitant įdėtas kolekcijas. Jie apibrėžiami garbanotais skliaustais {} su raktų ir reikšmių poromis, atskirtomis kableliais, ir raktais bei reikšmėmis, atskirtomis dvitaškiu.

Pagrindiniai punktai apie žodynus:

  1. Kintama ir netvarkinga kolekcija
  2. Sudaryta iš raktų ir reikšmių porų su unikaliomis raktais
  3. Pasiekite reikšmes naudodami raktus
  4. Saugo įvairius duomenų tipus

Žodynai yra idealūs užduotims, kur reikia atlikti paieškas, pvz., konfigūracijos nustatymams ar dažnio skaičiavimams.

Pavyzdžiai:

# Sukurti žodyną
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Pasiekti elementus
print(my_dictionary['a'])  # Rezultatas: 1

# Pridėti elementus
my_dictionary['d'] = 4
print(my_dictionary)  # Rezultatas: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Atnaujinti elementus
my_dictionary['a'] = 0
print(my_dictionary)  # Rezultatas: {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Pašalinti elementus
del my_dictionary['a']
print(my_dictionary)  # Rezultatas: {'b': 2, 'c': 3, 'd': 4}

Tuple

Tuple yra nekintamos, tvarkingos elementų kolekcijos. Jie veikia kaip sąrašai, išskyrus tai, kad sukūrus tuple, jo elementai negali būti keičiami, pridedami ar pašalinami. Tuple apibrėžiami naudojant skliaustus () su elementais, atskirtais kableliais.

Pagrindiniai punktai apie tuple:

  1. Nekintama ir tvarkinga kolekcija
  2. Palaiko kelis duomenų tipus
  3. Fiksuoto dydžio struktūra

Tuple yra naudingi, kai reikia nekintamos kolekcijos arba kai norite naudoti kolekciją kaip žodyno raktą.

Pavyzdys:

# Sukurti tuple
my_tuple = (1, 2, 3, 4, 5)

# Pasiekti elementus
print(my_tuple[0])  # Rezultatas: 1
print(my_tuple[-1])  # Rezultatas: 5

# Pastaba: Tuple yra nekintami

Rinkiniai

Rinkiniai yra kintamos, netvarkingos kolekcijos, kurios saugo unikalius elementus. Jie automatiškai pašalina dublikatus ir neprižiūri tvarkos. Rinkiniai gali turėti įvairių duomenų tipų elementus, išskyrus kintamus tipus, tokius kaip sąrašai ir žodynai. Jie gali būti apibrėžiami naudojant garbanotus skliaustus {} arba set() konstruktorių.

Pagrindiniai punktai apie rinkinius:

  1. Kintami ir netvarkingi
  2. Saugo tik unikalius elementus, automatiškai pašalindami dublikatus
  3. Išskiria kintamus tipus (pvz., sąrašus ir žodynus)

Rinkiniai yra idealūs narystės testavimui, deduplikavimui ir rinkinių operacijoms, tokioms kaip sąjunga, sankirta ir skirtumas.

# Sukurti rinkinį
my_set = {1, 2, 3, 4, 5}

# Patikrinti narystę
print(1 in my_set)  # Rezultatas: True

# Pridėti elementą
my_set.add(6)
print(my_set)  # Rezultatas: {1, 2, 3, 4, 5, 6}

# Atnaujinti pašalinant vieną elementą ir pridedant kitą
my_set.remove(1)
my_set.add(0)
print(my_set)  # Rezultatas: {0, 2, 3, 4, 5, 6}

# Pašalinti elementą
my_set.remove(0)
print(my_set)  # Rezultatas: {2, 3, 4, 5, 6}

Sąlyginiai sakiniai: if, elif, else

Sąlyginiai sakiniai leidžia vykdyti kodą, atsižvelgiant į tai, ar sąlyga yra teisinga, ar klaidinga.

if condition1:
  # daryti kažką
elif condition2:
  # daryti kažką kita
else:
  # daryti dar ką nors

Pavyzdys:

x = 42

if x > 50:
  print("x yra didesnis nei 50")
elif x < 50:
  print("x yra mažesnis nei 50")
else:
  print("x yra lygus 50")

for ciklas

for ciklai iteruoja per seką, pvz., sąrašą ar diapazoną, vykdydami kodo bloką kiekvienam elementui.

Pavyzdys:

for i in range(5):
  print(i)

while ciklas

while ciklai vykdo kodo bloką tol, kol nurodyta sąlyga yra teisinga.

Pavyzdys:

i = 0
while i < 5:
  print(i)
  i += 1

Funkcijos

Funkcijos apima kodą į pakartotinai naudojamus blokus, kurie gali priimti įvestis (argumentus) ir grąžinti išvestis. Jos apibrėžiamos naudojant def raktinį žodį ir gali būti iškviečiamos pagal jų pavadinimą.

def function_name(argument1, argument2=default_value):
  # daryti kažką
  return result

Pavyzdys:

def add(a, b):
  return a + b

result = add(3, 4)
print(result)  # Rezultatas: 7

Lambda funkcijos

Lambda funkcijos, dar vadinamos anoniminėmis funkcijomis, yra glaustos vienos išraiškos funkcijos, sukurtos naudojant lambda raktinį žodį. Jos dažnai naudojamos trumpoms operacijoms, dažnai kaip argumentai funkcijoms, tokioms kaip map(), filter(), ar sorted().

lambda arguments: expression

Pavyzdys:

add = lambda a, b: a + b
result = add(3, 4)
print(result)  # Rezultatas: 7

Sąrašų supratimas

Sąrašų supratimas leidžia sukurti sąrašus vienoje, skaitomoje eilutėje, derinant išraišką su ciklu ir pasirinktinai sąlyga. Jie puikiai tinka duomenų transformavimui ar filtravimui.

new_list = [expression for item in iterable if condition]

Pavyzdys:

squares = [x * x for x in range(1, 6)]
print(squares)  # Rezultatas: [1, 4, 9, 16, 25]

Išimčių tvarkymas

Išimčių tvarkymas leidžia jūsų programai tvarkyti vykdymo klaidas elegantiškai. Python teikia try, except ir finally blokus, kad būtų galima sugauti ir tvarkyti išimtis, užtikrinant, kad jūsų programa tęstųsi arba baigtųsi sklandžiai.

try:
    # kodas, kuris gali sukelti išimtį
except ExceptionType as error_variable:
    # tvarkyti išimtį
finally:
    # kodas, kuris bus vykdomas, nesvarbu, ar įvyko išimtis

Pavyzdys:

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Negalima dalinti iš nulio!")

Klasės ir objektai

Klasės apibrėžia planus objektų kūrimui objektinėje programavimo paradigmoje (OOP). Objektai yra klasės egzemplioriai su atributais (duomenimis) ir metodais (funkcijomis), kurie atlieka specifines užduotis. OOP skatina struktūruotą, pakartotinai naudojamą ir prižiūrimą kodą.

class ClassName:
  def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2

  def method_name(self, argument1):
    # daryti kažką
    return result

Pavyzdys:

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

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

# Sukurti Dog egzempliorių
dog1 = Dog("Buddy", 3)
dog1.bark()  # Rezultatas: Woof!

Modulių importavimas

Moduliai yra atskiri failai, kuriuose yra Python kodas, pvz., funkcijos, klasės ar kintamieji. Modulių importavimas leidžia išplėsti jūsų programos funkcionalumą naudojant išorines bibliotekas ir sistemas.

import module_name
from module_name import specific_function_or_class

Pavyzdys:

import math
print(math.sqrt(16))  # Rezultatas: 4.0

Failų įvestis/išvestis

Failų įvestis/išvestis (I/O) apima skaitymą iš failų ir rašymą į failus Python. Tai būtina dirbant su duomenų saugojimu ir atkūrimu.

Failo skaitymas

with open('filename.txt', 'r') as file:
  content = file.read()

Rašymas į failą

with open('filename.txt', 'w') as file:
  file.write('turinys, kurį reikia parašyti į failą')

Konteksto valdytojai

Konteksto valdytojai padeda valdyti išteklius, tokius kaip failai ar tinklo ryšiai, užtikrinant, kad jie būtų tinkamai įgyti ir išleisti. Naudojant konteksto valdytoją, jūsų kodas tampa švaresnis ir atsparesnis klaidoms.

with resource as alias:
  # naudoti resource kaip alias

Pavyzdys:

with open('file.txt', 'r') as file:
  content = file.read()
  print(content)  # Rezultatas: Hello, World!

Dekoratoriai

Dekoratoriai leidžia išplėsti arba modifikuoti funkcijų ar klasių elgesį, nekeisdami jų šaltinio kodo. Jie apgaubia kitą funkciją ir prideda tam tikrą funkcionalumą prieš arba po apgaubtos funkcijos vykdymo.

def decorator_function(func):
  def wrapper(*args, **kwargs):
    # daryti kažką prieš iškviečiant funkciją
    result = func(*args, **kwargs)
    # daryti kažką po funkcijos iškvietimo
    return result
  return wrapper

@decorator_function
def my_function():
  # daryti kažką

Pavyzdžiai:

def greet_decorator(func):
  def wrapper(name):
    return "Hello, " + func(name) + "!"
  return wrapper

@greet_decorator
def get_name(name):
  return name

print(get_name("John"))  # Rezultatas: Hello, John!

Itertools modulis

Itertools modulis teikia funkcijas iteratorių kūrimui ir darbui su jais. Jis apima begalinius iteratorius (pvz., count, cycle ir repeat), baigtinius iteratorius (pvz., accumulate, chain, compress) ir kombinatorinius iteratorius (pvz., product, permutations ir combinations).

Pavyzdys:

import itertools

for i in itertools.count(5, 5):
  if i > 20:
    break
  print(i)  # Rezultatas: 5, 10, 15, 20

Collections modulis

Collections modulis siūlo specializuotus konteinerių duomenų tipus, kurie gali pagerinti jūsų programas.

from collections import namedtuple, defaultdict, Counter, deque

Pavyzdžiai:

from collections import namedtuple, deque, Counter, OrderedDict, defaultdict

# namedtuple
Person = namedtuple('Person', 'name age')
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Rezultatas: Alice 30

# deque
dq = deque([1, 2, 3, 4, 5])
dq.append(6)
dq.appendleft(0)
print(dq)  # Rezultatas: deque([0, 1, 2, 3, 4, 5, 6])

# Counter
count = Counter("hello world")
print(count)  # Rezultatas: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)  # Rezultatas: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Rezultatas: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Reguliarios išraiškos

Reguliarios išraiškos leidžia galingą teksto apdorojimą ir manipuliavimą. re modulis teikia funkcijas, tokias kaip match, search, findall, finditer, split ir sub.

Pavyzdys:

import re

pattern = r'\d+'
result = re.findall(pattern, "There are 10 cats and 5 dogs.")
print(result)  # Rezultatas: ['10', '5']

Datos ir laikai

Darbas su datomis ir laikais yra dažnas reikalavimas, ypač duomenų analizėje ar planavimo užduotyse. datetime modulis teikia klases ir funkcijas darbui su datomis, laikais ir intervalais.

import datetime

# datetime, date, time, timedelta, timezone

Pavyzdžiai:

from datetime import datetime, timedelta

# Dabartinė data ir laikas
current_time = datetime.now()
print("Dabartinė data ir laikas:", current_time)

# Pasirinktinė data ir laikas
custom_date = datetime(2022, 12, 31, 23, 59, 59)
print("Pasirinktinė data ir laikas:", custom_date)

# Konvertuoti eilutę į datetime
date_str = "2023-01-01 00:00:00"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("Eilutė į datetime:", date_obj)

# Konvertuoti datetime į eilutę
date_str2 = date_obj.strftime("%Y-%m-%d %H:%M:%S")
print("Datetime į eilutę:", date_str2)

# Datos ir laiko aritmetika
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Vakar:", yesterday)
print("Rytoj:", tomorrow)

Sąrašų pjovimas

Sąrašų pjovimas leidžia išgauti dalį sąrašo ar kitos sekos tipo, nurodant pradžios, pabaigos ir pasirinktinai žingsnio reikšmes. Ši funkcija yra labai naudinga išgaunant posėkius.

my_list[start:end:step]

Pavyzdys:

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]
print(sub_list)  # Rezultatas: [1, 2, 3]

Eilučių formatavimas

Eilučių formatavimas yra statinio teksto derinimo su dinaminėmis reikšmėmis procesas. Python siūlo kelis formatavimo metodus, įskaitant %-formatavimą, str.format() metodą ir f-strings (Python 3.6+), kurie leidžia lengvai generuoti suformatuotas eilutes.

%-formatavimas

print("Hello, %s" % name)

str.format

print("Hello, {}".format(name))

f-strings (Python 3.6+)

print(f"Hello, {name}")

Pavyzdys:

name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)  # Rezultatas: My name is John and I am 30 years old.

Komandinės eilutės argumentai

Komandinės eilutės argumentai leidžia perduoti įvesties reikšmes Python skriptui, kai jis vykdomas iš komandinės eilutės. sys.argv sąrašas suteikia prieigą prie šių argumentų, todėl juos lengva analizuoti ir naudoti jūsų skripte.

import sys

arguments = sys.argv

Pavyzdys:

# Išsaugokite šį kodą faile pavadinimu "cmd_args.py"
# Vykdykite su: python cmd_args.py Alice
# Tikėtinas rezultatas: Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("Argumentų nepateikta.")

Other articles for Python