How They Work Together

1. Node Exporter gathers metrics (CPU, memory, disk usage, etc.) from your systems.
2. Prometheus scrapes these metrics from Node Exporter at specified intervals and stores them.
3. Grafana connects to Prometheus, pulling in the stored metrics to create dashboards for easy visualization.

Step-by-Step Setup

1. Install Node Exporter

• Download Node Exporter:

wget https://github.com/prometheus/node_exporter/releases/download/v1.5.0/node_exporter-1.5.0.linux-amd64.tar.gz

• Extract and run Node Exporter:

tar xvfz node_exporter-1.5.0.linux-amd64.tar.gz
cd node_exporter-1.5.0.linux-amd64
./node_exporter

• Access Node Exporter metrics at http://<your_server_ip>:9100/metrics.

2. Install Prometheus

• Download Prometheus:

wget https://github.com/prometheus/prometheus/releases/download/v2.45.0/prometheus-2.45.0.linux-amd64.tar.gz

• Extract and configure Prometheus:

tar xvfz prometheus-2.45.0.linux-amd64.tar.gz
cd prometheus-2.45.0.linux-amd64

• Edit prometheus.yml to add your Node Exporter as a target:

scrape_configs:
  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']  # Replace with your Node Exporter address

• Start Prometheus:

./prometheus --config.file=prometheus.yml

• Access Prometheus at http://<your_server_ip>:9090.

3. Install Grafana

• Download and install Grafana using your package manager:

sudo apt-get install -y grafana  # for Debian/Ubuntu

• Start Grafana:

sudo systemctl start grafana-server
sudo systemctl enable grafana-server

• Access Grafana at http://<your_server_ip>:3000.

4. Connect Grafana to Prometheus

• Log in to Grafana (default user/password: admin/admin).
• Go to Configuration > Data Sources and select Prometheus.
• Enter your Prometheus URL (e.g., http://localhost:9090) and save.

5. Create a Dashboard in Grafana

• Go to Dashboards > New Dashboard.
• Choose Add Query and select Prometheus as the data source.
• Enter a metric (e.g., node_cpu_seconds_total), apply, and save the panel.

Conclusion
With this setup, Prometheus will regularly collect metrics from Node Exporter, and Grafana will visualize these metrics. This setup is efficient for monitoring the health and performance of your servers.

A system call is a way for a user program to interface with the operating system. The program requests several services, and the OS responds by invoking a series of system calls to satisfy the request. A system call can be written in assembly language or a high-level language like C or Pascal. System calls are predefined functions that the operating system may directly invoke if a high-level language is used.

In this article, you will learn about the system calls in the operating system and discuss their types and many other things.

What is a System Call?

A system call is a method for a computer program to request a service from the kernel of the operating system on which it is running. A system call is a method of interacting with the operating system via programs. A system call is a request from computer software to an operating system's kernel.

The Application Program Interface (API) connects the operating system's functions to user programs. It acts as a link between the operating system and a process, allowing user-level programs to request operating system services. The kernel system can only be accessed using system calls. System calls are required for any programs that use resources.

How are system calls made?

When a computer software needs to access the operating system's kernel, it makes a system call. The system call uses an API to expose the operating system's services to user programs. It is the only method to access the kernel system. All programs or processes that require resources for execution must use system calls, as they serve as an interface between the operating system and user programs.

Below are some examples of how a system call varies from a user function.

1. A system call function may create and use kernel processes to execute the asynchronous processing.
2. A system call has greater authority than a standard subroutine. A system call with kernel-mode privilege executes in the kernel protection domain.
3. System calls are not permitted to use shared libraries or any symbols that are not present in the kernel protection domain.
4. The code and data for system calls are stored in global kernel memory.

Follow the link below to visit actual post:

System Calls in Operating System (OS) - javatpoint

System Calls in Operating System (OS) with OS Tutorial, Types of OS, Process Management Introduction, Attributes of a Process, CPU Scheduling, FCFS with overhead, FCFS Scheduling etc.

www.javatpoint.com

Dekorator nimaligini yaxshi tushinish uchun avval funksiya nimaligin yaxshi tushunib olish kerak. Funksiya berilgan argumentlarga asoslanib qiymat qaytaradi. Bunga eng sodda misol:

>>> def add_one(number):
...	return number + 1
>>> add_one(4)
5

Pythonda funksiyalar birinchi klass obyektlari hisoblanadi. Yani funksiyalar xuddi boshqa Python obyektlari (int, list, tuple, str va h.kz) kabi boshqa funksiyalar uchun argument sifatida berilishi, o'zgaruvshiga biriktirilishi mumkin.

Funksiyalar ichma ich yozilishi ham mumkin, shu qatorda bir funksiya o'zining ichidagi boshqa bir funksiyani chaqirishi ham mumkin.

def parent():
    print("Printing from the parent() function")

    def first_child():
        print("Printing from the first_child() function")

    def second_child():
        print("Printing from the second_child() function")

    second_child()
    first_child()

Parent funksiyani chaqirganda nima bo'lishiga nazar soling:

>>> parent()
Printing from the parent() function
Printing from the second_child() function
Printing from the first_child() function

Ko'rib turganingizdek parent ichidagi funksiyalarning yozilish ketma ketligi ahamiyatga ega emas, ularni chaqirilish ketma ketligi muhimdir.

Bir funksiya boshqa funksiyani qaytarishiga misol ko'ramiz.

def parent(num):
    def first_child():
        return "Hi, I am Emma"

    def second_child():
        return "Call me Liam"

    if num == 1:
        return first_child
    else:
        return second_child

Etibor bergan bo'lsangiz bu yerda funksiyalar oxirida qavs qo'yilmasdan qaytarilmoqda, bu degani biz chunchaki funksiyaga havola qaytarayapmiz. Parent funksiya qabul qilayotgan num argumentga asoslanib bir ikki ichki funksiyadan biriga havola olishimiz mumkin:

>>> first = parent(1)
>>> second = parent(2)

>>> first
function parent..first_child at 0x7f599f1e2e18>

>>> second
function parent..second_child at 0x7f599dad5268>

Eng sodda dekorator

Misol:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

def say_whee():
    print("Whee!")

say_whee = my_decorator(say_whee)

Nima deb o'ylaysiz say_wee() funksiyasini chaqirganda nima sodir bo'ladi ? Sinab ko'ramiz:

>>> say_whee()
Something is happening before the function is called.
Whee!
Something is happening after the function is called.

Etibor bergan bo'lsangiz bu yerda hechqanaqa yangilik yo'q, yuqorida hozirgina o'rgangan bilimlarimiz orqali sodda dekorator yasadik.

Shunday funksiyani dekoratorga olish ushbu qatorda sodir bo'layapti:

say_whee = my_decorator(say_whee)

say_wee() funksiya bu yerda my_decorator() funksiyasiga argument sifatida berilayapti, my_decorator() bo'lsa wrapper funksiyasini qavslarsi chaqirib qo'yayapti, yani shu orqali biz my_decorator()  ichidagi wrapper() funksiyasiga murojaat qilayapmiz, wrapper() funksiyasi esa bizning decoratorga argument sifatida berilgan funksiyamizni qaytarayapti:

>>> say_whee
function my_decorator..wrapper at 0x7f3c5dfd42f0>

Sodda qilib aytganda: Decorator bu funksiyaning asosiy xususiyatini o'zgartirmasdan uni o'rab turadigan boshqa bir funksiya ekan.

Davom etishdan oldin, yana bir misolga nazar solamiz. wrapper() funksiya ham odatiy Python funksiya bo'lganligi uchun uni xususiyati ham dinamik o'zgarishi mumkin. Qo'shnilarni bezovta qilmaslik uchun say_wee() funksiyamizni faqat kunduz kun ishlaydigan qilamiz:

from datetime import datetime

def not_during_the_night(func):
    def wrapper():
        if 7 <= datetime.now().hour < 22: func() else: pass # hush, the neighbors are asleep return wrapper def say_whee(): print("whee!") say_whee="not_during_the_night(say_whee)" code>

Endi say_wee() funksiyasini kech soat 10 dan ertalab soat 7 gacha bo'lgan vaqtda chaqirsangiz u Wee! demaydi )):

>>> say_whee()
>>>

say_wee() funksiyasini dekoratorga olishda etirbor bergan bo'lsangiz birinchidan `say_wee` deb uch marta yozishga to'g'ri keldi, ikkinchidan bizga bir qaraganda yozgan kodimizda dekorator qatnashganligini anglab olish qiyin sababi odatiy ikkita Python funksiya yozdik. Ishimizni osonlashtirish va dekoratorni dekorator sifatida ajratib ko'rsatish uchun Pythonda @ ( odatda "pie sytax" deb nomlanadi) dan foydalanamiz. Ushbu misol yuqorida ko'rgan misolimiz bilan bir xil ishlaydi:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_whee():
    print("Whee!")

@my_decorator bu say_wee = my_decorator(say_wee) deb yozishning osonroq usuli.

Dekoratorlardan qayta foydalanish.

Dekoratorlar ham boshqa Python funksiyalari kabi oddiy funksiya, shunday ekan undan oson foydalanish uchun bizda barcha qurollar yetarli. Dekoratorlardan qayta foydalana olish uchun decorators.py fayl yarating va shu fayl ichida:

def do_twice(func):
    def wrapper_do_twice():
        func()
        func()
    return wrapper_do_twice

Endi boshqa bir faylda ushbu dekoratorni import qilib ishlatishimiz mumkin:

from decorators import do_twice

@do_twice
def say_whee():
    print("Whee!")

Ushbu misolni ishga tushirganda say_whee() ikki marta ishga tushganini guvohi bo'lishingiz mumkin:

>>> say_whee()
Whee!
Whee!

Funksiyalarga argument bergan holda dekoratorga olish.

Tasavvur qilaylik bizning funksiyamiz argumentlar qabul qiladi, biz uni dekoratorga ololamizmi ? Sinab ko'ramiz:

from decorators import do_twice

@do_twice
def greet(name):
    print(f"Hello {name}")

Afsuskiy bu kodni ishga tushirish xatolikka olib keldi:

>>> greet("World")
Traceback (most recent call last):
  File "", line 1, in 
TypeError: wrapper_do_twice() takes 0 positional arguments but 1 was given

Muammo shundaki dekoratorning wrapper_do_twice() funksiyasi argument olmaydi, demak ushbu funksiyaga bitta argument oladigan qilish yetarli. Ammo ushbu xolatda boshqa bir bir nechta argument oladigan, yoki umuman argument olaydigan funksiyalarni ushbu dekoratorga ololmay qolamiz. Shu sababli *args, **kwargs juftligidan foydalanamiz:

def do_twice(func):
    def wrapper_do_twice(*args, **kwargs):
        func(*args, **kwargs)
        func(*args, **kwargs)
    return wrapper_do_twice

Endi wrapper funksiya istalgancha argument ololadi, yoki umuman argument olmasligi ham mumkin, argument olgan taqdirda o'zi wrap qilayotgan funksiyaga argumentlarni yetkazib beradi. Shu orqali yuqorida dekoratorga olingan ikki funksiyamiz ham ishlaydi:

>>> say_whee()
Whee!
Whee!

>>> greet("World")
Hello World
Hello World

Dekoratorga olingan funksiyalardan qiymat olish.

Dekoratorga olingan funksiyalardan qaytayotgan qiymatlar qayerga ketadi ? Albatta buni dekorator hal qiladi. Ushbu sodda dekoratorga olinga funksiyani misol qilib ko'ramiz:

from decorators import do_twice

@do_twice
def return_greeting(name):
    print("Creating greeting")
    return f"Hi {name}"

Ishlatib ko'ramiz:

>>> hi_adam = return_greeting("Adam")
Creating greeting
Creating greeting
>>> print(hi_adam)
None

Afsuskiy None yani hechnarsa qaytmadi.

Sababi wrapper_do_twice hech narsa qaytarmayapti, u shunchaki o'zining berilgan funksiyani chaqirib qo'yayapti xolos. Buni to'g'rilash uchun biz wrapper_do_twice berilgan funksiyani qaytaradigan qilishimiz kerak:

def do_twice(func):
    def wrapper_do_twice(*args, **kwargs):
        func(*args, **kwargs)
        return func(*args, **kwargs)
    return wrapper_do_twice

Endi qaytariladigan qiymatda oxirgi return qilingan funksiyaning qiymati qaytadi:

>>> return_greeting("Adam")
Creating greeting
Creating greeting
'Hi Adam

Dekoratorga olingan funksiya aslida qaysi funksiya ?

Pythondagi eng katta qulayliklardan biri bu Python shellning mavjudligi va unda istalgan Python obyektni introspeksiya qila olishdir. Intorspeksiya bu obyektning o'zining barcha attributlari haqida va runtaymi haqida malumotlarini ko'rishdir. Misol uchun funksiya o'zining nomi va dokumentatsiyasini o'zida saqlaydi:

>>> print
<built-in function print>

>>> print.__name__
'print'

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    <full help message>

Introspeksiya esa siz yozgan funksiyalar uchun ham ishlaydi:

>>> say_whee
<function do_twice.<locals>.wrapper_do_twice at 0x7f43700e52f0>

>>> say_whee.__name__
'wrapper_do_twice'

>>> help(say_whee)
Help on function wrapper_do_twice in module decorators:

wrapper_do_twice()

Etibor bersangiz say_wee funksiya dekoratorga olingandan keyin o'zining kimligini unutib qo'ygan ko'rinadi. U o'zini do_twice dekoratori ichidagi wrapper_do_twice funksiyasi deb o'ylayapti, mantiqan to'g'ri lekin biz uchun foydali malumot emas.

Bu xolatni to'g'rilash uchun wrapper_do_twice funksiyamizni ham @funktools.wraps dekoratoriga olamiz, bu bizga wrapper_do_twice ichidagi funksiyaning o'z malumotlarini o'zgarmasdan saqlanib qolishini ta'minlaydi.

import functools

def do_twice(func):
    @functools.wraps(func)
    def wrapper_do_twice(*args, **kwargs):
        func(*args, **kwargs)
        return func(*args, **kwargs)
    return wrapper_do_twice

say_wee funksiyani o'zgartirishning xojati yo'q.

>>> say_whee
<function say_whee at 0x7ff79a60f2f0>

>>> say_whee.__name__
'say_whee'

>>> help(say_whee)
Help on function say_whee in module whee:

say_whee()

:), dekoratorga olingandan keyin ham funksiya o'z malumotlarini saqlab qoldi!

Kelajakdagi kodlaringiz uchun dekorator skeletoni, osh bo'lsin:

import functools

def decorator(func):
    @functools.wraps(func)
    def wrapper_decorator(*args, **kwargs):
        # Do something before
        value = func(*args, **kwargs)
        # Do something after
        return value
    return wrapper_decorator

Python Inheritance - Pythonda "meros olish"

Inheritance yani meros olish bu, biror asosiy klassdan boshqa bir maxsus klass yaratish, shu blan birga asosiy klassning barcha metod va attributlarini o'zida jam qilish.

UML da inheritance ushbu ko'rinishda namoyon bo'ladi:

Python-da hamma narsa obyektdir. Modullar obyekt, klasslar va funktsiyalar obyektlardir va albatta, klasslardan yaratilgan obyektlar ham obyektlardir.

Inheritance har qanday OO dasturlash tilining asosiy xususiyatidir. Python bir vaqtning o'zida bir nechta inheritance amalga oshira oladigan sanoqli dasturlash tillaridan biridir.

Pythonda yangi klass yaratganimizda ham beihtiyor inheritance ni ham ishlatamiz. Keling bu nimani anglatishini ko'rib chiqamiz:

Python shellni ochamiz va bitta bo'sh klass yaratamiz:

>>> class MyClass:
...     pass
...

Hech ish qilmaydigan klass yaratdik, boshqa bir klassdan inherit ham qilmadik, keling dir() funksiyasi orqali uning metodlarini sanab ko'ramiz:

>>> c = MyClass()
>>> dir(c)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__']

dir() barcha klassga tegishli metodlarni sanab chiqdi, lekin biz birorta metod yaratmagan edik, unda shuncha metod qayerdan keldi, shell orqali barcha metodlar python object() dan kelayotganini ko'rishimiz mumkin:

>>> o = object()
>>> dir(o)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__',
'__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__']

Etibor bersangiz dir() funksiyasi ko'rsatayotgan ikkita list deyarli bir xil, faqat __ dict __ va __ weakref __ metodlari myClass da qo'shimcha.

Shundan bilishimiz mumkinki pythonda istalgan klass Python object dan inherit qiladi, va qonuniy ushbu ko'rinishda yozish ham mumkin class myClass(object): lekin bu qo'pol hamda zarur emas.

Inheritancega misol:

Polygon bu uchda yoki undan ortiq tomonga ega yopiq ikki o'lchamli shakldir, shundan kelib chiqib polygon klassini yasaymiz:

class Polygon:
    def __init__(self, no_of_sides):
        self.n = no_of_sides
        self.sides = [0 for i in range(no_of_sides)]

    def inputSides(self):
        self.sides = [float(input("Enter side "+str(i+1)+" : ")) for i in range(self.n)]

    def dispSides(self):
        for i in range(self.n):
            print("Side",i+1,"is",self.sides[i])

Uchburchak bu uchta tomoni bor polygondir, demak u polygonning barcha qoidalariga bo'ysunadi, shunday ekan biz Polygon klassdan inherit qilgan holda Uchburchak klassni yaratsak bo'ladi, shunda polygonning barcha metod va atributlari Uchburchak klassda namoyon bo'ladi:

class Triangle(Polygon):
    def __init__(self):
        Polygon.__init__(self,3)

    def findArea(self):
        a, b, c = self.sides
        # calculate the semi-perimeter
        s = (a + b + c) / 2
        area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
        print('The area of the triangle is %0.2f' %area)
 

Uchburchak klassimizda endi qo'shimcha findArea() degan metod bor. Biz ushbu metodni ishlatib uchburchak yuzasini topishimiz mumkin:

>>> t = Triangle()

>>> t.inputSides()
Enter side 1 : 3
Enter side 2 : 5
Enter side 3 : 4

>>> t.dispSides()
Side 1 is 3.0
Side 2 is 5.0
Side 3 is 4.0

>>> t.findArea()
The area of the triangle is 6.00

Ko'rib turganingizde biz Uchburchak klassda inputSides() yoki dispSides() metodlarini yaratmagan bo'lsakda ularni ishlata oldik, aynan mana shu inheritance yani meros olish deyiladi.

Incapsulation - Enkapsulyatsiya

Enkapsulyatsiya Pythonda malumot va metodlarni bitta yaxlit konteyner ichiga solishdir. Misol uchun biz klass yaratdik, demak biz shu vaqtning o'zida enkapsulyatsiyani ishlatdik. Sababi klass o'zining metod va atributlarini bitta yaxlit konteyner ichiga oladi, yani o'zining ichiga. Klassdan tashqarida esa klassning metod va atributlari yashirindir.

Obyektga yo'naltirilgan dasturlash tillari funksiya va malumotlarning oson va samarali enkapsulyatsiyani taqdim qiladi. Natija sizfatida, bir biriga bog'liq malumot va funksiyalarning atrofida mantiqan tashqi dunyodan ajratib turuvchi chiziq tortiladi. Shu chiziqdan tashqarida faqat klassning interfeysi ochiq va uning pablik metodlari va atributlari ochiq, boshqa barcha malumot va funksiyalar himoyalangan hisoblanadi. Biz bu konsepsiyaga pablik funksiyalar va yashirin atributlarni misol qilishimiz mumkin.

Polymorphism - Polimorfizm

Polimorfizm so'zi bir nechta formasi yani bir nechta turi mavjud degani. Dasturlashda, polimorfizm bitta funksiya nomi bir nechta turdagi obyektlari uchun ishlatilishi tushuniladi.

Dasturlash tillar malumotlar ustida operatsiya bajarish uchun obyektlardan foydalanishadi. Obyektlar sonlar bo'lishi mumkin, matnlar bo'lishi mumkin, yoki mantiqiy malumotlar. Bazida obyektlar komplex malumot turlari ham bo'lishi mumkin, list, hash yoki class kabi.

Dasturlarda obyektlardan unumli foydalanish uchun ularni xotiraga saqlab qo'yadilar va kerak bo'lganda xotiradan olib ishlatadilar. Bazi dasturlash tillarida o'zgaruvchilar aslida xotirada saqlangan obyektga shunchaki havola bo'ladi.

Birinchi dasturlash tillarida xotira boshqaruvi uchun dasturchi to'liq javobgar bo'lgan, agar u biror obyekt yaratmoqchi bo'lsa uning uchun avval xotiradan joy ajratgan, obyektni ishlatib bo'lgandan so'ng esa xotirani bo'shatib qo'yishi kerak bo'lgan.

Bu yerda ikkita muammo bor:

1. Xotirani bo'shatib qo'yish esadan chiqib qolishi. Xotirani ishlatib bo'lgandan keyin uni bo'shatishni unutib qo'yaverish xotirani to'lib qolishiga olib keladi.
2. Xotirani erta bo'shatib qo'yish. Ikkinchi muammo esa xotira hali foydalanilayotgan vaqtda uni bo'shatib yuborish.

Avtomatik xotira boshqaruvi va axlat yig'uvchi (garbage collector)

Avtomatik xotira boshqaruvi uchun turli xil metodlardan foydalaniladi. Eng keng tarqalgan boshqaruv usullaridan biri bu reference counting. Dastur obyketlarning referencelarini doim kuzatib boradi, reference counti 0 ga teng bo'lga obyket ishlatilmayotgan hisoblanadi va u band qilib turgan xotira ozod qilinadi.

Ammo avtomatik xotira boshqaruvi biroz qimmatga tushadi, sababi buning uchun qo'shimcha xotira va qo'shimcha hisob kitob kerak bo'ladi. Ko'plab dasturlash tillarida "stop-the-world" metodikasi ishlaydi, bunda garbage collector ishlatilmayotgan obyektlarni collect qilayotgan vaqtda boshqa hama narsa to'xtatiladi.

Kompyuter olami Moor qonunida aytilgani kabi rivojlanib yangi kompyuterlarda katta miqdordagi RAM lar sabab,  avtomatik xotira boshqaruvining kamchiliklari ortib borayapti. Shunga qaramay zamonaviy dasturlash tillari Golang, Java va Python kabi dasturlash tillarida avtomatik xotira boshqaruvi mavjud.

Uzoq ishlovchi va tezlik o'ta muhim bo'lgan dasturlarda ishlatilgadigan dasturlash tillarida hali ham manula xotira boshqaruvi ishlatiladi. Klassik misol C++. Yana MacOS va IOS uchun ishlatiladigan objective-C, va yangi dasturlash tillaridan Rust ni misol qilishimiz mumkin.

Pythonda garbage collection qanday ishlaydi

Pythonda xotira boshqaruvida ikkita aspekt mavjud:

1. Recerence counting
2. Generational garbage collection

Reference counting

Pythonda garbage collectionning asosiy quroli bu reference countlar. Pythonda biz doim obyekt yaratganimizda, yaratilgan obyektning ikkita havolasi bo'ladi, birinchisi C type - list, dictionary, yoki int ga o'xshaga, ikkinchisi reference count.

Bazilar python garbage collectorni "poor man's garbage collector"i deb nomlashadi. Sababi u davriy reference larni aniqlay olmaydi. Ammo reference countingning bir joyib tomoni u xotiraga hechkim murojaat qilmasa u xotirani bo'shatib qo'yadi.

Generational garbage collection

Reference countga qo'shimcha tarzda Python garbage collector metodini ham xotira boshqaruvi uchun ishlatadi.

Avalgi bo'limda biz obyektni arrayga qo'shib uning reference counti ishganini ko'rdik. Ammo obyekti uning o'ziga qo'shsak nima bo'ladi.

>>> class MyClass(object):
...     pass
...
>>> a = MyClass()
>>> a.obj = a
>>> del a

Ushbu misolda biz class yasadik va shu classga instance yasadik, va shu instance ning proertysi sifatida o'zini ko'rsatdik. Xullas instanceni o'chirib tashladik.

Endi Python uchun ushbu instance mavhum, lekin uni Python xotiradan o'chirib tashlamadi. Instancening reference counti 0 emas, sababi uning o'ziga o'zi reference qilingan edi.

Ushbu muammo reference sikli deyiladi, biz bu muammoni reference count bilan hal qila olmaymiz. Ushbu muammoni hal qilish garbage collectorning ishi, standard bibliotekada u GC nomi ostida.

Generational garbage collection terminology

Garbage collectorni tushunish uchun ikkita muhim konsepsiya mavjud:

1. birinchi konsepsiya avlod (level, type).
2. ikkinchisi esa chegara.

Garbage collector xotiradagi barcha obyektarni kuzatib boradi. Yangi yaratilgan obyekt garbage collectorning birinchi avlodida yashashni boshlaydi. Agar Python garbage collectionni boshlasa va unda obyket saqlanib qolsa u ikkinchi avlodga o'tib yashashni boshlaydi. Pythonda garbage collectorning umumiy uchta avlodi bor, har bir ovlod bo'yicha garbage collect qilinganda saqlanib qolgan obyektlar o'zidan keyingi avoldga o'tib yashashni davom ettirishadi.

Har bir avlod uchun garbage collector modulining chegaralangan miqdorda obyektlar soni mavjud. Agar biror avlodda obyektlar soni belgilangandan oshib ketsa garbage collection jarayoni boshlanadi. Istalgan garbage collectiondan omon qolgan obyketlar o'zi turgan avolddan keyingi avlodga o'tib yashashda davom etadilar.

Reference countdan farqli o'laroq, siz garbage collectorni boshqarishingiz mumkin. Misol uchun obyektlar soni chegarasini o'zgartirish. Yoki garbage collection jarayonini o'zingiz boshlashingiz yoki garbage collect qilishni umuman to'xtatib qo'yishingiz ham mumkin.

GC moduldan foydalanish

gc modulini import qiling va python uchun hozirda belgilangan garbage collector chegarasini ko'ring:

>>> import gc
>>> gc.get_threshold()
(700, 10, 10)

Demak o'z o'rnida, birinchi avlod uchun 700 ta obyekt, va keyingi ikkita avlod uchun esa 10 tadan obyekt uchun ruxsat berilgan ekan.

get_count() orqali siz har bir avlodda nechtadan obyekt yashayotganini ham ko'rishingiz mumkin:

>>> import gc
>>> gc.get_count()
(596, 2, 1)

Ushbu holatda sizda eng yosh avlodingizda 596 ta ikkinchi avlodda esa 2 ta va uchinchi avlodda 1 ta obyket bor.

Ko'rib turganingizdek Python hali dasturni yozmasingizdan yoki ishga tushirmasingizdan o'zi bir olam obyket yaratib ulguradi. Biz garbage collection jarayonini o'zimiz ham gc.collect() funksiyasi orqali ishga tushira olamiz.

>>> gc.get_count()
(595, 2, 1)
>>> gc.collect()
577
>>> gc.get_count()
(18, 0, 0)

Ko'rib turganingizdek collect() funksiyasi katta miqdorda obyektlarni tozalab tashlaydi. Bu xolatda u naqd 577 ta obyektdan xotirani tozaladi.

Biz set_threshold() funksiyasi orqali avlodlarda saqlanadigan obyketlar soni o'zimiz o'rnatishimiz mumkin.

>>> import gc
>>> gc.get_threshold()
(700, 10, 10)
>>> gc.set_threshold(1000, 15, 15)
>>> gc.get_threshold()
(1000, 15, 15)

Yuqoridagi misolda biz garbage collection chegaraladini o'zimiz o'rnatdik. Ushbu chegaralarni uzaytirish garbage collection ishga tushish vaqtini uzaytiradi, va o'lik obyektlarni xotirada uzoqroq saqlab turishi evaziga dasturingizda yuz beradigan hisob kitoblarni kamaytiradi.

Python dasturchi sifatida siz uchun garbage collector nima mano anglatadi ?

Garbage collectoring asl konfiguratsiyasini o'zgartirmang. Asosiy jihatlardan biri Python dasturchining foydali ish koeffetsentini sezilarli oshiradi. Va albatta bu low level dasturlash tillarida dasturchi qilishi kerak bo'lga mayda ishlarni Python o'z bo'yniga olishidir.

Zich muhitlar uchun xotirani manual boshqarish muhim bo'lishi mumkin. Bu bilimlar bilan endi siz bazida sizning dasturingiz unumdorligi pastligini garbage collectionga to'nkashingiz ham odatiy xol, lekin ishonavering shunday xolatda ham garbage collector chegaralarini kengaytirgandan ko'ra dasturingiz ishlab turgan muhitni kuchaytirganingiz foydaliroq. Moore ning qoidasi aytganidek hozirda bizga kerakli kuchga ega mexanizmlarni arzonga topish hozirgi kunda oson.

Python o'zi ozod qilgan xotirani o'zi ishlab turgan OS ga qaytarmasligi aniq. Shu sababli istalgan manual garbage collection sizga o'zingiz kutgan natijani bermasligi mumkin.

Ushbu maqoladagi misollarni o'zingzda sinash uchun bu yerdan datasetni yuklab oling

Generatorlardan foydalanish

PEP 255 da tafsif berilgan, generatorlar lazy iterator qaytaradigan maxsus funksiyalardir. Ular iteratsiya qilsa bo'ladigan listga o'xshagan obyektlardir. Listlardan farqi, gerator o'zining kontentini xotirada saqlamaydi.

import sys
# Generatorlar bilan data pipeline yasash
# Biz yirik malumotlar ustida ishlaganimizda, generatordan foydalanishimiz mumkin
# Sababi generator kontentini list kabi xotirada saqlamaydi
try:
    file_name = sys.argv[1]
except:
    print("Iltimos fayl nomini kiriting: \> python file_name.py file_name.csv")
    sys.exit()

# Faylning har bir qatorini o'qiydigan generator
lines = (line for line in open(file_name))

# Har bir qatorning valuelarini vergul bilan bo'lib olib listga 
# qo'shib beradigan generator
list_line = (s.strip().split(",") for s in lines)

# bir marta next() ni chaqirib ustunlarning nomlarini o'zgaruvchiga 
# biriktirib olamiz
cols = next(list_line)
# data = next(list_line) # ikkinchi qatordagi datani olamiz

# print(dict(zip(cols, data))) # ustun nomlari va dataning qiymatlari # yordamida dictionary yasaydi.

# zip() ni chaqirib columt nomlari bilan datani birlashitirib 
# olamizda keyin undan dictionary yasaymiz:
#    1. keylar column nomlar bo'ladilar cols o'zgaruvchisiga biriktirilgan
#    2. valuelar esa list_line o'zgaruvchisiga generator orqali ketma ket biriktiriladigan malumotlar bo'ladi 
company_dicts = (dict(zip(cols, data)) for data in list_line)

# Seriasi aga teng bo'lgan har bir kompaniyani filterlaydi. 
# va shu kompaniyalarni raisedAmt sini generatorning yield 
# statementidagi elementi qilib belgilaydi.
funding = (
    int(company_dict['raisedAmt'])
    for company_dict in company_dicts
    if company_dict['round'] == "a"
)

# CSV fayldagi A seriaga ega kompaniyalarning raisedAmt fondining 
# yig'indisini olish uchun sum() ni chaqirib generatordagi 
# iteratsiyani ishga tushiramiz.
total_series = sum(funding)
print(f"A seriadagai umumiy fond miqdori: ${total_series}")

Dasturchi uchun bitta potok ishlayotgani sezilmaydi, lekin ayrim vaqtlardi u CPU da probka hosil qilib unumdorlikni kamaytiradi, yani sekinlashadi, yoki ko'p potokli kodlarda muammolar yuzaga kelishi mumkin.

Python GIL bir vaqtda bittadan ortiq potok ishlashiga ruxsat bermaganligi sababli bittadan ortiq yardoga ega bo'lgan Ko'p Potokli CPU lar Python code uchun ahamiyatsizdek bo'ladi, shuning uchun GIL Pythonning "infamos" xususiyati degan nomni ham olib ulgurgan.

Bu maqolada biz Python GIL ni unumdorlikga salbiy tasiri va bu tasirni qanaqa qilib chetklab o'tsa bo'lishini o'rganamiz.

Pythonga GIL nima uchun kerak ?, u qanaqa muammoni hal qiladi ?

Python xotira boshqaruvi uchun reference count ishlatadi. Yani Pythonda yaratilgan har bir obyektning reference count degan o'zgaruvchisi bo'ladi, shu o'zgaruvchi orqali Python obyekt necha marta ishlatilgani yoki umuman ishlatilmayotgani haqida xabar berib turadi, qachon ushbu count nolga yetsa, shu obyekt band qilib turgan xotira bo'shatiladi.

Qisqacha misol:

>>> import sys
>>> a = []
>>> b = a
>>> sys.getrefcount(a)
3

Bu yerda etibor bergan bo'lsangiz bo'sh a listning reference counti 3 ta, birinchisi o'zi yaratilgan holatda, ikkinchisi b o'zgaruvchiga havola berilganda, uchinchisi getrefcount() funksiyasiga argument qilib berilganda.

GIL ga qaytamiz:

Muammo shundaki reference count uchun uni ikkita yoki undan ortiq potok bir vaqtning o'zida ketma ket o'zgatirishini oldini olish uchun himoyachi kerak edi. Agar shu hoalt yuz beradigon bo'lsa, biror obyekt band qilib turgan xotira hech qachon ozod qilinmasligi mumkin, yoki undan ham yomoni, xotirada hali reference counti 0 ga teng bo'lmagan obyektni xotiradan o'chirib yuborishi, bunday xolatlar sizning Python dasturingizda kutilmagan noodatiy baglar paydo bo'ladi.

Reference countni himoya qilish uchun har bir potok bo'ylab tarqatilgan data stukturaga begona potok o'zgartirib yubormasligi uchun block qo'yiladi.

Lekin har bir obyektga yoki obyektlar guruhiga block qo'yish degani bu ko'plab blocklar bir vaqtning o'zida mavjud bo'ladi degani, bu DEADLOCK ga olib keladi (Deadlock bu bittadan ortiq locklar mavjud bo'lganda yuzaga keladi). Boshqa minus esa blocklarning ketma ket qo'yilishi va olinishi sababli yuzaga keladigan unumdorlikdagi muammolardir.

GIL bu interpretatorning o'zidagi block bo'lib,  qaysiki har bir Python kode interpretatsiya bo'lishi uchun interpretator lockdan ruxsat so'rash qoidasini o'rnatadi. Bu narsa deadlocklarning oldini oladi (Faqat block bir dona bo'lgan vaqtda) va unchalik unumdorlikga salbiy tasir qilmaydi. Ammo istalgan CPU talab qiladigan Python dasturni bir potokli qilib qo'yadi.

GIL Ruby va shunga o'xshagab bir nechta tillarda ham foydalanilgan bo'lsada u yagona yechim emas. Ayrim dasturlash potokdan himoyalangan xotira boshqaruvi uchun reference countdan boshqa usullardan foydalangan xolda GIL dan foydalanishning oldini olishadi, misol uchun garbage collection.

Bunday dasturlash tillari GIL ning bir potoklilik bilan keltiradigan unumdorligini JIT compaylerlar kabi xususiyatlar orqali kompensatsiya qiladi.

Nima uchun aynan GIL yechim sifatida olingan ?

Python hali kompyuterlarda ko'p potoklilik tushunchasi yo'q bo'lgan davrlardan buyon mavjud. Python developmetni tezlashtirish maqsadida foydalanish uchun oson qilib yaratilgan va shu sababli Pythonni kun sain ko'plab dasturchilar ishlata boshlashgan.

Python uchun kerak bo'lgan C kutubxonalari uchun juda ko'plab extentionlar yozilgan. Nojo'ya o'zgarishlarning oldini olish maqsadida, ushbu C extentionlari uchun GIL taminlab beradigan potokdan himoyalangan xotira boshqaruvi talab etilgan.

GIL ni implement qilish juda oson hamda osongina Pythonga qo'shilgan. GIL bir potokli dasturlarda bizga yuqori unumdorlik beradi, sababi dastur faqat bitta lock ustida ishlaydi.

Potokdan himoyalanmagan C extentionlari oson integratsiya qilingan. Va aynan shu extentionlar Pythonning ko'plab jamoalar tomonidan osongina qabul qilinishining asosidir.

Ko'rib turganingizdek GIL Pythonning boshlanish davrida ishlab chiqaruvchilar yuz tutgan katta muammoning pragmatik yechimi bo'lgan.

Ko'p potokli Python dasturlariga tasiri

Kompyuter dasturlariga qaraganimizda CPU bound dastrlar va I/O bound dasturlarning unumdorligida biroz farq bo'ladi.

CPU bound dasturlar CPU ni maksimum ishlatadi. Misol uchun matematik hisob kitoblar, matretsalarni ko'paytirish, qidiruv, rasmlar ustida operatsiyalar va h.kz.

I/O bound dasturlar esa ko'proq vaqtni Inputni qabul qilish va Outputni yetkazib berishga sarflaydilar. Bular foydalanuvchidan kelayotgan signal, yoki internetdan yuklanayotgan malumot, yoki malumotlar bazasida bajarilayotgan amallardir. Bazida I/O bound dasturlar qabul qilayotgan malumotri protsessdan o'tib tayor bo'lishini ham kutish evaziga umumiy olganda judayam uzoq kutib qolishlari mumkin, misol uchun siz foydalanuvchidan nimadur qabul qilmoqchi bo'lib input so'radingiz, u nima kiritishini uzoq o'ylashi mumkin, yoki siz malumotlar bazasidan so'ragan so'rovingizni tayorlash uchun malumotlar bazasining o'zida ushbu malumotni tayorlash uchun turli operatsiyalar talab etilishi mumkin.

Taymer implementatsiya qilingan dasturga misol:

# single_threaded.py
import time
from threading import Thread

COUNT = 50000000

def countdown(n):
    while n>0:
        n -= 1

start = time.time()
countdown(COUNT)
end = time.time()

print('Time taken in seconds -', end - start)

Mening 4 potokdan iborat bo'lgan protsessorimda bu code 1.902301549911499 sekund vaqt oldi

endi bizor kodga o'zgaritirish kiritib shu countdownni ikkita potokga ajratib beramiz:

# multi_threaded.py
import time
from threading import Thread

COUNT = 50000000

def countdown(n):
    while n>0:
        n -= 1

t1 = Thread(target=countdown, args=(COUNT//2,))
t2 = Thread(target=countdown, args=(COUNT//2,))

start = time.time()
t1.start()
t2.start()
t1.join()
t2.join()
end = time.time()

print('Time taken in seconds -', end - start)

Ko'rib turganingizdek ikkala misol ham deyarli bir xil vaqt oldi, sababi biz ikkinchi kodda ikkita potokga ajratgan bo'lsakda GIL ikkita potokni paraller bajarilishiga yo'l qo'ymadi.

I/O bound tizimlarda ko'p potokli dasturlarga GIL unchalik sezilarli tasir ko'rsatmaydi, potoklar I/O ni kutish vaqtida locklarni o'zaro almashadilar.

Lekin  potoklar to'liq CPU bound bo'lgan dasturlarda, misol uchun rasmlarni bo'laklarga bo'lib ishlov beradigan potoklar, lock evaziga nafaqat bir potokli bolib qoladi, balki unga ketadigan vaqtda ham o'sish ko'rishingiz mumkin, yuqoridagi misolga o'xshab, to'liq bitta potokdan foydalanilgan xolatga o'xshab.

Bu vaqtdagi o'sish potoklardagi locklarni ochish va lock qo'yish evaziga qo'shiladi.

Nega GIL hamon olib tashlanmagan ?

Ko'plab dasturchilar anchadan buyot norozilik bilan GIL ni olib tashlash kerakligi bilan murojaat qiladilar. Lekin Python kabi ko'p qo'llaniladigan dasturlash tiliga GIL ni olib tashlashchalik katta o'zgarishni backward compatible likka tasir qilmasdan amalga oshirishning imkoni yo'q.

Aslida Pythonning boshlanish fazalarida GIL bir necha marta Python contrubutorlari tomonidan o'chirib tashlangan, lekin bu urunishlar Pythonni ko'tarib turuvchi va GIL taqdim etayotgan xususiyatgan to'g'ridan to'g'ri bog'liq bo'lgan C extentionlarinign ishlay olmasligiga olib kelgan.

Va albatta GILning o'rniga ishlatishimiz mukin bo'lgan boshqa yechimlarning bazilari I/O bound tizimlarda sizning ko'p potokli hamda bir potokli Python dasturingiz ham bir varakayiga sezilarli darajada sekinlashishiga olib kelsa, bazilarini Pythonda implement qilish juda ham qiyin. Xullas Pythonning yangi versiyasini o'rnatishingiz dasturlaringizni sekin ishlashiga xizmat qilishini xoxlamasangiz kerak )).

Python BDFLi Guido Van Rossum Python comyunitiyga yuzlanib "GIL ni olib tashlash oson emas" degan edi.

Men Py3k (Pythonning 3... versialari) ga istalgan I/O bound tizimlarda Pythonning tezligiga tasir qilmaydigan o'zgarishlarni mamnunlik bilan qabul qilaman
[Guido Van Rossum]

GIL ni olib tashlashdagi harakatlarda ushbu shart hozirgacha qanoatlantirilgani yo'q.

Nima uchun GIL Python3 da ham o'chirilmadi ?

GIL ning Pythondan o'chirilishi Python3 ni Python2  dan ko'ra sekin qilib qo'yar edi. Hozirgi Python3 ning bir potokli lekin unumdorlik jhatdan kuchliligiga hechkim etiroz bildira olmaydi. Shunday ekan Pythonda hali hamon GIL mavjud.

Lekin Python3 da GIL ga ham bir qator o'zgartirishlar kiritilgan.

Biz yuqorida GIL ning CPU bound hamda I/O bound ko'p potokli dasturlarga tasirini o'rgandik. Lekin bir qismi CPU bound, bir qisim I/O bound dasturlarchi ?

Bunday dasturlarda GIL I/O bound potoklarni to'sib qoyadi, va shu tariqa ular CPU bound potoklarni olib qo'yishdan checklaydi.

Sababi Pythonda potokdan GIL malum vaqt intervalida ochib yuborilishi belgilangan, agar GIL ni boshqa potok talab qilmasagina avalgi potok yana o'z ishini davom ettirishi mumkin.

>>> import sys
>>> # The interval is set to 100 instructions:
>>> sys.getcheckinterval()
100

Bu usulning muammosi shundaki ko'pincha CPU bound potok boshqa potoklar GILni olmasdan oldin u qaytadan olib qo'yadi.

Bu muammo Python3.2 da 2009 yil Antoine Pitrou tomonidan hal qilingan.    

Qanday qilib Python GIL ni chetlab o'tish mumkin

Ko'p-protsesslik - ko'p potoklilik: Ko'p protsesslikni eng qulay ishlatiladigan vaqti bu ko'p potoklilikning o'rniga ko'p protsesslar hosil qilib ishlatishdir. Shunda Python dastur har bir protsess uchun alohida Python interpreter hosil qiladi va shunda GIL bu yerda muammo bo'la olmaydi. Ushbu xususiyatni implement qilish uchun Pythonda multiprocessing moduli mavjud:

from multiprocessing import Pool
import time

COUNT = 50000000
def countdown(n):
    while n>0:
        n -= 1

if __name__ == '__main__':
    pool = Pool(processes=2)
    start = time.time()
    r1 = pool.apply_async(countdown, [COUNT//2])
    r2 = pool.apply_async(countdown, [COUNT//2])
    pool.close()
    pool.join()
    end = time.time()
    print('Time taken in seconds -', end - start)

Mening tizimimda ushbu dastur quyidagi vaqtda bajarildi:

Ko'p potokga ajratib tekshirgan dasturimizga nisbatan o'sish bo'ldi.

Nega Ketadigan vaqt 2 barobar kamayib ketmadi, sababi ko'p protsesslilikni ham boshqarishni o'ziga yarasha qiyin vaqt oladigan jihatlari bor.

Alternativ Python interpretatorlari: Pythonda ko'plab interpretator turlari bor. Cpython, JPython, IronPython and PyPy, written in C, Java, C# and Python lar eng ko'p qo'llaniladiganlaridur. GIL faqatgina Pythonning asl implementatsiyasida bor qaysiki C da yozilgan.

....

CPU (Central Processing Unit) kompyuterning integral qismi hisoblanadi, u kompyuterning asosiy protsesslarini bajaradi. CPU asosiy operatsiyalarni bajaradigan bir vaqtda cache va xotira ham protsesslarni yakunlanishiga yordam beradi. CPU bound Kompyuter degani bu boshqa komponentlardan foydalanish o'rniga protsessni qatiy CPU zimmasiga yuklaydi. Bunday kompyuterlar CPU kuchli bo'lsa juda tezkor bo'ladi, ammo boshqa komponentlar ishlamaganligi sabab balans yo'qoladi.

Tizim CPU bound deyilganda barcha protsesslar faqat CPU orqali bajarilishi tushuniladi. Bunday xolatda CPU odatiy 10-20% emas balki 90-100% ishlaydi. CPU kuchli bo'lsa u kompyuterning umumiy tezligini ham tabiikiy oshiradi. Bunday xolat ko'proq sizning dasturlaringiz hisob kitob talab qiladigan dasturlar bo'lsa kuzatiladi. Agar dasturlar grafika yoki boshqa komponentlari ishlashini talab qiladigan dasturlar bo'lsa ular CPU bound tizimlarda yetarlicha ish ko'rsata olmaydilar.

I/O bound

Kompyuter tizimida I/O bound deb operatorlarning qabul qilinishi va qaytarib yuborilishini kutishga ketgan vaqt protsessni bajarishga ketgan vaqt sifatida qo'shib hisoblanishiga aytiladi, yani protsessning tugatilishi Input va Outputga bevosita bog'liq bo'lsa. Bu CPU bound terminining qarama qarshisi. Sodda qilib aytganda malumotni qabul qilish shu malumot ustida bajariladigan operatsiyadan ko'ra ko'p vaqt olishidir.

Linklangan listlar tartiblangan obyektlar jamlanmasidir. Linklangan listlarning odatiy listlardan farqi ular elementlarni xotirada odatiy listlarga qaraganda boshqacharoq saqlaydi. Odatiy listlar xotira blocklarida o'z elementlariga reference lar saqlaydi, Linklangan listlar esa referencelarni elementining bir qismi sifatida saqlaydi.

Asosiy tushuncha

Linklangan listlarning elementlari node deb ataladi, har bitta nodaning ikkita maydoni bo'ladi

• Data: nodada saqlanadigan malumot
• Next: keyingi nodaga havola

Odatiy nodaning ko'rinishi:

Linklangan listlar nodalar kolleksiyasidir. Birinchi noda head deb ataladi, u linklangan list ustida bajariladigan istalgan interatsiyaning boshlang'ich nuqtasi hisoblanadi. Oxirgi nodaning next maydonidagi havola None bo'lishi zarur, sababi uning oxirgi nodaligini faqat shunaqa qilib bildirish mumkin.

Amaliy dasturlar

Linked listlar amalda queue, stack yoki graph larni realizatsiya qilishda qo'l keladi.

Queue - Navbat yoki Stack - Taxmon

Queue bilan Stack faqat bir biridan elementlarni olish usuli bilan farq qiladi. Queue uchun biz First-In/First-Out (FIFO) usulini ishlatamiz. Bu degani birinchi qo'shilgan element birinchi chiqarib olinadi.

Yuqoridagi rasmda ko'rib turibsiz, queue ikkita tomoni bor, birinchisi front ikkinchisi rear. Elemement qo'shilganda rear tomondan qo'shiladi, chiqarilganda esa front tomondan chiqariladi, yani birinchi qo'shilgan element birinchi bo'lib chiqadi.

Stack uchun esa biz Last-In/First-Out nazariyasini ishlatamiz (LIFO). Bu degani oxirgi qo'shilgan element birinchi bo'lib chiqariladi.

Rasmda ko'rganingizdek, birinchi kiritilgan element yani indexi 0 bolgan element eng pastda, eng oxirgi qo'shilgan element esa eng tepada.

Graf (Graph)

Graflar obyektlar orasidagi bog'liqlikni ko'rsatish orqali qandaydur networkni namoyon qilish uchun ishlatiladi. Misol uchun Directed Acyclic graph (DAG) - (Yo'naltirilgan lekin siklga ega bo'lmagan graf)

Grafni turli xil ko'rinishda implement qilish mumkin, va ulardan biri adjecency list (Qo'shnilik ro'yhati. Grafning qirrasini uning qo'shni qirralariga bog'liqligini namoyon qiluvchi tartiblanmagan list). Adjecency list linklangan listlar ro'yhati bo'lib unda grafning har bir qirrasi va unga qo'shni bo'lgan qirralar birgalikda saqlanadi.

Xuddi shu ulangan listni Pythonda quyidagicha ko'rsatilishi ham mumkin.

>>> graph = {
...     1: [2, 3, None],
...     2: [4, None],
...     3: [None],
...     4: [5, 6, None],
...     5: [6, None],
...     6: [None]
... }

Ushbu dictionary dagi keylar source qirralardir, uning valuelari yani listlar bo'lsa shu qirraga qo'shni bo'lgan qirralarning.

Ishlash unumdorligini taqqoslash: Listlar va linklangan Listlar (Performance comparison: Lists vs Linked Lists)

Ko'p dasturlash tillarida linklangan listlar va odatiy listlarning xotirada saqlanishida aniq farqlar bor. Pythonda esa ikkalasi ham bir xil usulda xotirada saqlanadi. Shuning uchun unumdorlik haqida o'ylaganimizda Pythonda linklangan list va odatiy listlarning biror operatsiyani bajarishga ketadigan vaqti nuqtai nazardan taqqoslashimiz to'g'ri bo'ladi.

Element qo'shish va o'chirish

Pythonda listga element qo'shish uchun insert() yoki append() ishlatamiz. O'chirish uchun esa pop() yoki remove(). Ushbu metodlarning bir biridan farqi shundaki insert() va remove() odatiy holatda listning boshidagi elementlar ustida amal bajaradi, pop() va append() esa listning oxiridagi elementlar ustida amal bajaradi.

Bilishimiz joiz bo'lgan narsa, insert() va remove() ishlatilganda parda ortida elementlarni shift qilish talab etiladi va o'z o'rnida bu operatsiyalar ham qo'shimcha vaqt talab qiladi. Biz insert() yoki append() metodlarini listning oxiriga ishlatadigan bo'lsak unga konstant vaqt ketadi O(1), agar biz list metodlarini listning boshida yoki boshiga yaqin qo'llaydigan bo'lsak ushbu metodlar list hajmi ortgani sari operatsiyani bajarilishiga ketadigan vaqt ham proportsional tarzda oshadi O(n).

Linklangan listlar esa element o'chirish yoki qo'shishga kelganda unumdor hisoblanadi, yani u listning boshidami oxiridami farqi yo'q ketadigan vaqt O(1) bo'ladi.

Ushbu jihatda queue (FIFO) qilib ishlatganda linked listlar odatiy listlardan tezroq ishlaydi. Sababi Queueda element boshiga qo'shiladi va boshidan o'chiradi. Lekin linklangan listlarda Stackni implement qiladigan bo'lsak (LIFO) unda odatiy list bilan o'xshash ishlaydi. Sababi elementlar oxiridan qo'shiladi va o'chiriladi.

Elementlarni olish

Elementlarni olishga qolganda listlar linked listlarga qaraganda ancha tez ishlaydi. Agar biz qaysi element bizga kerakligini bilsa listdan uni O(1) vaqtda chiqarib olishimiz mumkin. Xuddi shu ishni linked listda bajaradigan bo'lsak O(n) vaqt ketadi, sababi berilgan elementni topish uchun butun listni aylanib chiqish kerak bo'ladi.

Malum elementli izlashga qolganda ikkala list ham bir xil ishlaydi. Ikkala holatda ham biz listni to'liq iteratsiya qilib chiqishimiz kerak bo'ladi.

collections.deque bilan tanishamiz

Pythonning collections modulida linklangan listlarni implement qilish uchun deque deb nomlangan maxsus obyekt bor, double-ended-queue.

collections.deque linklangan listlarda elementlarni olish, o'chirish, qo'shish, boshidan yoki oxiridan farqi yo'q, barchasini O(1) vaqtda bajaradi.

collections.deque dan foydalanish

Deque o'zi bilan bir nechta metodlarni olib keladi.

Birinchi linked list yasaymiz:

>>> from collections import deque
>>> deque()
deque([])

yuqoridagi kod bo'sh linklangan list yasaydi. Yaratgan zahotimiz uni elementlar bilan to'ldirishimiz mumkin, buning uchun argument sifatida istalgan iterable berib yuborsak bas:

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

deque ga stringni argument sifatida berib, unga element qo'shib va o'chirib ko'ramiz:

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Bu yerda append() ham pop() ham elementning oxirida amalga oshadi. Ammo biz deque bilan bemalol ushbu operatsiyalarni linked list boshida bajarishim ham mumkin:

>>> llist.appendleft("z")
>>> llist
deque(['z', 'a', 'b', 'c', 'd', 'e'])

>>> llist.popleft()
'z'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Queue va Stackni implement qilish

Queue - Navbat

Queueni implement qilishda siz listga yangi value qo'shib queue yaratasiz (enqueue), vaqti kelganda eng uzoq vaqt queueda qolgan elementni o'chirasiz (dequeue).

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

Hozir sizdagi navbatda Mary, John, va Susan bor, esingizda bo'lsin queue FIFO qonuniga bo'ysunadi, yani birinchi queuega kirgan element birinchi bo'lib chiqib ketadi.

Bir oz vaqt o'tgach navbatda turganlar uchun stollarda joylar bo'shaydi va siz navbatga eng birinchi kelgan element ni queuedan mana bu tarzda o'chirasiz:

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

har doim siz queuedan popleft() orqali element o'chirsangiz parda ortida linked listdan head element o'chadi, shu tariqa siz queueni implement qilgan bo'lasiz.

Stack - taxmon

Stack yaratmoqchi bo'lsangizchi, g'oya juda ham queuega o'xshash, yagona farq stacklar LIFO qonuniga bo'ysunadi, bu degani stackga oxirgi qo'shilgan elementni birinchi bo'lib olib tashlasa bo'ladi.

Tasavur qiling, siz web browser tarixi funksiyasini implement qilmoqchisiz, browser tarixida siz bemalol oxirgi kirgan websaytingizga birinchi bo'lib qaytolasiz.

Biz bu xusisiyatni stack yordamida quyidagicha amalga oshirishimiz mumkin:

>>> from collections import deque
>>> history = deque()

>>> history.appendleft("https://realpython.com/")
>>> history.appendleft("https://realpython.com/pandas-read-write-files/")
>>> history.appendleft("https://realpython.com/python-csv/")
>>> history
deque(['https://realpython.com/python-csv/',
       'https://realpython.com/pandas-read-write-files/',
       'https://realpython.com/'])

Bu misolda siz birinchi bo'sh browser tarixi yaratdingiz, va ketma ket unga uchta sayt urlini qo'shdingiz, appendleft() yordamida siz har bir urlni linked listni head qismiga qo'shdingiz.

Birozdan so'ng foydalanuvchi realpython websaytining bosh sahifasiga qaytishga qaror qildi, biz tarixni yaratishda stackdan foydalanganimizni bilgan xolda, oxirgi elementdan boshlab stackdan chiqarib tashlaymiz (LIFO):

>>> history.popleft()
'https://realpython.com/python-csv/'

>>> history.popleft()
'https://realpython.com/pandas-read-write-files/'

>>> history
deque(['https://realpython.com/'])

Va nixoyat, biz popleft() orqali elementlar qo'shilgan tomondan boshlab biz xoxlagan urlga yetib kelguncha elementlarni chiqarib tashladik, va ushbu namuna stackning real qo'llanishidir, bundan buyon stack yoki queuedagi challangelar bemalol pythonning collection modulidagi deque funksiyasi orqali amaliy stack yoki queue implement qilishimiz mumkin.

O'zingizni linklangan listingizni yarating

Linklangan listni qanaqa qilib yaratish mumkin.

Linklangan listimizni boshlash uchun class yaratib olamiz:

class LinkedList:
    def __init__(self):
        self.head = None

Linked listni saqlash uchun bizga kerak bo'ladigan yagona malumot bu listning qayerda boshlanishi yani head, biz uni yaratib oldik. Endi linked listning nodalarini implement qilish uchun boshqa class yaratamiz:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

Yuqoridagi class yaratilishida siz ikkita asosiy noda elementlarini ko'rishingiz mumkin, data va next, siz bunga yana __ repr __ method ham qo'shishingiz mumkin, instance haqida to'liqroq malumot bilan taminlash maqsadida:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

    def __repr__(self):
        return self.data

class LinkedList:
    def __init__(self):
        self.head = None

    def __repr__(self):
        node = self.head
        nodes = []
        while node is not None:
            nodes.append(node.data)
            node = node.next
        nodes.append("None")
        return " -> ".join(nodes)

Ushbu yaratilgan ikkita class orqali biz tezda uchta nodaga ega bo'lgan linked list yaratamiz.

>>> llist = LinkedList()
>>> llist
None

>>> first_node = Node("a")
>>> llist.head = first_node
>>> llist
a -> None

>>> second_node = Node("b")
>>> third_node = Node("c")
>>> first_node.next = second_node
>>> second_node.next = third_node
>>> llist
a -> b -> c -> None

Node ning data va next qiymatlarini berish orqali biz anchagina tez linked list yasashimiz mumkin. LinkedList va Node classlar bizning linked list implement qlishimizning boshlanishi, bundan buyogiga faqat funksionalni oshiramiz.

Linked list classning __ init __() metodiga linked listni malumot bilan to'ldirib olish uchun ozgina o'zgarish qilamiz:

def __init__(self, nodes=None):
    self.head = None
    if nodes is not None:
        node = Node(data=nodes.pop(0))
        self.head = node
        for elem in nodes:
            node.next = Node(data=elem)
            node = node.next

Ushbu o'zgarishdan so'ng linked list yasash yanada tezroq bo'ladi.

Qanday qilib linked listni loop (traverse) qilish mumkin

Traverse sodda qilib aytgandan iteratsiya qilish. Demak biz traverse qilish uchun __ iter __() funksiyasini yaratamiz, shunda bizning linked list ham odatiy listga o'xshab loop qilish imkoniyatini beradi:

def __iter__(self):
    node = self.head
    while node is not None:
        yield node
        node = node.next

Ushbu metod listning har bir nodini yield qiladi. Muhimi __ iter __() metodida yield qilishdan oldin node ni None emasligini tekshring, sababi agar node Nonde bo'lsa biz linked listning oxiriga yetib kelgan bo'lamiz.

>>> llist = LinkedList(["a", "b", "c", "d", "e"])
>>> llist
a -> b -> c -> d -> e -> None

>>> for node in llist:
...     print(node)
a
b
c
d
e

Yangi noda qo'shish

Yangi noda qo'shishning bir nechta usullari bor va har birining o'ziga yarasha qiyinchiligi bor, shuning uchun biz nodeni boshiga qo'shish, oxiriga qo'shish yoki qaysidur ikkita noda orasiga qo'shishni alohida funksiyalarga ajratib olamiz.

Boshidan qo'shish

Boshidan qo'shish bu eng osoni, sababi yangi elementni head deb belgilab qo'ysak bas, listni traverse qilishga xojat yo'q:

def add_first(self, node):
    node.next = self.head
    self.head = node

Ushbu metod quyidagicha ishlaydi:

>>> llist = LinkedList()
>>> llist
None

>>> llist.add_first(Node("b"))
>>> llist
b -> None

>>> llist.add_first(Node("a"))
>>> llist
a -> b -> None

Oxiriga qo'shish

Yangi nodeni oxiriga qo'shish uchun linked listni to'liq traverse qilishimiz kerak bo'ladi, next label None ga teng bo'lganda qo'shib qo'yamiz, oddiy listdagi kabi linked listda append qilib qo'yishning iloji yo'q, sababi biz oxirgi element qaysiligini bilmaymiz.

Ushbu metod bilan biz linked list oxiriga node qo'shamiz:

def add_last(self, node):
    if self.head is None:
        self.head = node
        return
    for current_node in self:
        pass
    current_node.next = node

Bu yerda for loop StopIteration Exception otgunicha linked listning o'zini loop qilaveramiz, loopdan chiqib ketganda bizning current_node o'zgaruvchimiz oxirgi nodaga teng bo'lgan bo'ladi, shunda biz oxirgi nodaning next referensini yangi nodaga qaratamiz, shunda oxirgi noda yangi qo'shilgan nodaga aylanadi.

misol:

>>> llist = LinkedList(["a", "b", "c", "d"])
>>> llist
a -> b -> c -> d -> None

>>> llist.add_last(Node("e"))
>>> llist
a -> b -> c -> d -> e -> None

>>> llist.add_last(Node("f"))
>>> llist
a -> b -> c -> d -> e -> f -> None

Ikkita noda orasiga noda qo'shish

Ikkita noda orasiga noda qo'shish, yani biz xoxlagan nodadan oldin yoki keyin noda qo'shish navbatdagi challange, uni amalga oshirish uchun ikkita metod yaratib olamiz:

1. Berilgan nodadan keyin qo'shish
2. Berilgan nodadan oldin qo'shish

Berilgan nodaning datasini qiymatiga qarab shu qiymatdan keyin noda qo'shish metodi:

def add_after(self, target_node_data, new_node):
    if self.head is None:
        raise Exception("List is empty")

    for node in self:
        if node.data == target_node_data:
            new_node.next = node.next
            node.next = new_node
            return

    raise Exception("Node with data '%s' not found" % target_node_data)

Bu yerda birinchi ishimiz biz izlayotgan dataga ega bo'lgan noda bor yo'qligi, biz izlayotgan datani topganimizda, list ketmaketligini buzmaslik uchun birinchi yangi nodaning next valuesini hozirgi nodaning next valuesiga tenglab olamiz, keyin hozirgi nodaning next valuesini yangi nodaga tenglaymiz.

Bu metodda ikkita exception qo'lladik, birinchisi list bo'sh bo'lsa xabar beradi, ikkinchisi esa biz izlagan dataga ega noda yo'q bo'lsa.

>>> llist = LinkedList()
>>> llist.add_after("a", Node("b"))
Exception: List is empty

>>> llist = LinkedList(["a", "b", "c", "d"])
>>> llist
a -> b -> c -> d -> None

>>> llist.add_after("c", Node("cc"))
>>> llist
a -> b -> c -> cc -> d -> None

>>> llist.add_after("f", Node("g"))
Exception: Node with data 'f' not found

add_before() metodi implement qilishga harakat qilamiz:

 1 def add_before(self, target_node_data, new_node):
 2    if self.head is None:
 3        raise Exception("List is empty")
 4
 5    if self.head.data == target_node_data:
 6        return self.add_first(new_node)
 7
 8    prev_node = self.head
 9    for node in self:
10        if node.data == target_node_data:
11            prev_node.next = new_node
12            new_node.next = node
13            return
14        prev_node = node
15
16    raise Exception("Node with data '%s' not found" % target_node_data)

Bu yerda ayrim narsalarni eslab qolish juda muhim. Birinchi add_after() da qilganimiz kabi list bo'sh yoki bo'sh emasligini tekshirishimiz lozim.

Ikkinchisi agar biz yangi nodani head element oldiga qo'shmoqchi bo'lsak add_first() metodigan qayta foydalanib qo'ysak bo'ladi, sababi biz head ni oldiga qo'shmoqchi bo'lsak demak biz shunchaki headni almashtirib qo'ymoqchimiz xolos.

Oxirgisi biz element oldidan element qo'shayotgandan undan oldinda turgan eski elementni (prev_node) bilishimiz shart, sababi yangi qo'shilgan elementni undan orqada qolayotgan elementga next qilib belgilashimiz kerak, ketma ketlik buzilmasligi uchun.

Qimmatbaho namuna ))

>>> llist = LinkedList()
>>> llist.add_before("a", Node("a"))
Exception: List is empty

>>> llist = LinkedList(["b", "c"])
>>> llist
b -> c -> None

>>> llist.add_before("b", Node("a"))
>>> llist
a -> b -> c -> None

>>> llist.add_before("b", Node("aa"))
>>> llist.add_before("c", Node("bb"))
>>> llist
a -> aa -> b -> bb -> c -> None

>>> llist.add_before("n", Node("m"))
Exception: Node with data 'n' not found

Linklangan listga element qo'shish borasida barcha metodlar tayyor.

Linklangan listdan nodani o'chirish

Linklangan listdan element o'chirishda o'chirilishi kerak bo'lgan elementni topish uchun biz avval listni to'liq aylanib chiqishimiz kerak bo'ladi. Kerakli elementni topganimizdan keyin undan bitta oldingi va bitta keyingi elementlarni ulab qo'yamiz.

Bu degani siz Listni traverse qilayotganda izlanayotgan elementdan oldingi nodani track qilishingiz kerak bo'ladi:

 1 def remove_node(self, target_node_data):
 2    if self.head is None:
 3        raise Exception("List is empty")
 4
 5    if self.head.data == target_node_data:
 6        self.head = self.head.next
 7        return
 8
 9    previous_node = self.head
10    for node in self:
11        if node.data == target_node_data:
12            previous_node.next = node.next
13            return
14        previous_node = node
15
16    raise Exception("Node with data '%s' not found" % target_node_data)

 Here is an example:

>>> llist = LinkedList()
>>> llist.remove_node("a")
Exception: List is empty

>>> llist = LinkedList(["a", "b", "c", "d", "e"])
>>> llist
a -> b -> c -> d -> e -> None

>>> llist.remove_node("a")
>>> llist
b -> c -> d -> e -> None

>>> llist.remove_node("e")
>>> llist
b -> c -> d -> None

>>> llist.remove_node("c")
>>> llist
b -> d -> None

>>> llist.remove_node("a")
Exception: Node with data 'a' not found

Shu xolos, endi biz linklangan listni implement qilishni bilamiz. Agar biz hozir o'rgangan bilimlarimizni o'zlashtirishga ulgurgan bo'lsak, maslahat berardim quyidagi topshiriqlarni mustaqil bajarishingizga:

1. Ma'lum o'rinda turgan elementni olish: llist.get(i) yoki llist[i].
2. Linked listni teskari sort qilish yani reverse qilish, llist.reverse()
3. LinkedList classdan inherit qiluvchi Queue classini yaratish va shu classda enqueue(), dequeue() metodlarini realizatsiya qiling.

Komplex Linked Listlardan foydalanish

Hozirgacha biz faqat bir tomonlama (singly linked lists) ulangan listnarning tuzilishi va ishlashini o'rgandik. Ammo linked listlarning boshqacha turlari ham mavjud va ular biroz boshqa maqsadlarda ishlatiladi.

Ikki tomonlama ulangan listlar (Doubly linked lists)

Ikki tomonlama ulangan listlarni nodasida ikkita reference bo'ladi:

1. Birinchisi Prev yani oldingi elementga
2. Ikkinchisi Next yani keyingi elementga reference

Yuqoridagi namunaga biroz o'zgarish kiritib ikki tomonlama ulangan list yasashimiz mumkin:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.previous = None

Shu yo'l bilan biz listni faqat oldinga emas orqaga qarab ham traverse qilishimiz mumkin, previous reference yordamida.

Sturktura jihatdan ushbu ko'rinishda bo'ladi:

collections.deque linked listlarni sturkturasi ichida ishlatishadi, lekin u ikki tomonlama ulangan listlarni ishlatmaydi. Ikki tomonlama ulangan listlar bilan esa deque istalgan elementni O(1) muddatda o'chirgan bo'lar edi.

Halqasimon ulangan listlar (Circular linked lists)

Halqasimon ulangan listlarda oxirgi elementning next referensi birnchi elementga yani headga qaratilgan bo'ladi, va ushbu ko'rinish tabiikiy halqasimon ko'rinish yasaydi.

Halqasimon ulangan listlarni ajoyib ishlatilish holatlari mavjud:

• Qayta qayta har bir o'yinchiga navbatni berish ko'p o'yinchilar qatnasha oladigan o'yinlarda
• Berilgan operatsion sistemada applicationning life cycle ini boshqarish uchun
• Fibonacci heap yasashda

Ko'rinish jihatdan quyidagicha:

Halqasimon ulangan listlarning bir ustunligi siz bu listni istalgan elementidan boshlab to'liq traverse qilishingiz mukin, faqat traversing boshlangan elementni eslab qolish va shu elementga qaytib kelganda loopni to'xtatish zarur, aks holda checksiz loop hosil bo'ladi.

Halqasimon ulangan listlarni implement qilish unchalik qiyinmas, bitta o'zgarish bu listlarda siz traversing boshlanish nuqtasini o'zingiz bera olasiz:

class CircularLinkedList:
    def __init__(self):
        self.head = None

    def traverse(self, starting_point=None):
        if starting_point is None:
            starting_point = self.head
        node = starting_point
        while node is not None and (node.next != starting_point):
            yield node
            node = node.next
        yield node

    def print_list(self, starting_point=None):
        nodes = []
        for node in self.traverse(starting_point):
            nodes.append(str(node))
        print(" -> ".join(nodes))

Endi listni traverse qilish bittagina argument oladi, starting_point, bu argument biz uchun ham traversingning boshi va oxiri bo'lib xizmat qiladi.

Oxirgi namuna halqasimon listlarni ishlatish namunasi bo'ladi:

>>> circular_llist = CircularLinkedList()
>>> circular_llist.print_list()
None

>>> a = Node("a")
>>> b = Node("b")
>>> c = Node("c")
>>> d = Node("d")
>>> a.next = b
>>> b.next = c
>>> c.next = d
>>> d.next = a
>>> circular_llist.head = a
>>> circular_llist.print_list()
a -> b -> c -> d

>>> circular_llist.print_list(b)
b -> c -> d -> a

>>> circular_llist.print_list(d)
d -> a -> b -> c

Sezgan bo'lsangiz None degan element yo'q, sababi listda oxirgi element degan narsani o'zi yo'q. Keyingi farq biz starting_point ni berganimizda go'yoki butunlay boshqa list hosil bo'layapti )).

O'qib chiqganlar uchun rahmat ! RealPython web sahifasidan tarjima qilindi. Tarjima hechqanaqa adabiy til yoki termin tarjimasiga suyanmagan. Izohlar bo'lsa izohingizni ubaydullo.uz sahifasida xabar sifatida qoldirishingiz mumkin.

Har bir avtor kitobga hikoya yozishdan oldin ehtiyot bo'lishlari kerak, yani birovning sahifasiga boshqa avtor hikoya yozib yuborishi mumkin emas, shuning uchun hikoya yozmoqchi bo'lgan yozuvchi kitob menejeri bilan bog'lanadi va u ruxsat bergan sahifaga hikoya yozadi.

Kitob ko'p yillardan beri foydalanilayotgani uchun unda keraksiz hikoyalar ko'payib ketishi tabiiy. Shunda ushbu hikoyalar boshqa yangi hikoyalar yozilishu uchun o'chirib tashlanadi.

Kitobni biz yaxlit xotira va uning varoqlarini malum bir chegaralangan miqdordagi xotira blocklarini saqlovchi soha sifatida qarayapmiz, sahifalarga hikoya yozadigan avtorlar esa kompyuterda ishga tushadigan turli dasturlardir. Avtorlar qaysi sahifaga hikoya yozishga ruxsat etilganligini belgilovchi kitob menejeri bu Xotira boshqaruvchisidir (Memory manager). Yangi xotira yaratish uchun eski hikoyalarni o'chiradigan kishi esa musorchi (Garbage collector)

Xotira boshqaruvi (Memory management)

Xotira boshqaruvi bu har bir dastur xotiradan o'qish va unga yozilishi tushuniladi. Dastur o'zi uchun malum xotira band qilishi mumkin, yoki malum xotira ishlatilmagan taqdirda uni bo'shatishi mumkin. Ushbu protsess umumiy qilib memory allocation deyiladi.

Python turlari

Asl Python C dasturlash tilida yozilgan. Python interpretastsiya jarayonida bytecode ga o'giriladi, va bu bytecode lar .pyc fayllarda yoki __ pycache __ papkasida saqlanadi. Pythonning Cpythondan boshqa ko'plab turlari borligini ham sanab o'tish joiz: Iron Python Microsoftning Common Language Runtime modulida ishlay olish uchun kompilyatsiya bo'ladi. JPython Java virtual mashenasida Python code ni Java bytecode ga kompile qilish uchun. PyPy, bu haqda alohida maqola o'qib chiqishni taklif qilar edim.

Python obyektlari

Pythonda hama narsa obyekt deb eshitgan bo'lsangiz kerak, misol uchun str malumot turi, int malumot turi, ularning barchasi obyekt. CPythonda barcha obyekt ishlatadigan PyObject degan struct bor.

Struct bu C dasturlash tilida turli malumot turlarini birlashtiruvchi strukturadir. OOP qiyosida qaraydigan bo'lsak u faqat atributlari bor lekin metodlari yo'q klassga o'xshaydi.

PyObject bu barcha Python obyektlarning eng katta bobosi hisoblanadi, va u faqat ikkita narsadan tashkil topadi.

1. ob_refcnt:  reference count
2. ob_type:   pointer to another object

ob_refcnt Pythonda garbage collection uchun ishlatiladi. ob_type esa boshqa bir malumot turiga havola (dict, int va h.kz)

Har bir obyektning o'zi uchun specific xotira beruvchi boshqaruvchisi bo'ladi (memory allocator), u obyektga qarab qanaqa qilib shu obyektga taaluqli malumotno xotiraga yozish uchun qanaqa qilib xotira olishni biladi, shu bilan  birga xotirani deallocation qiladigan ham manager bo'ladi, xotirga ishlatilmay qolganda uni boshqa maqsadlar uchun ozod qiladi.

Xotira ajratish va xotirani ozod qilish haqida gap ketganda bir muhim narsani esda tutish lozim. Xotira bu barcha uchun birdek bo'lishiladigan joy, shu sababli har xil xotira boshqaruvchisi bitta xotiraga yozishga harakat qilganda nojuya natijalarga olib kelishi mumkin.

GIL Global interpreter lock

Pythonda thread tarqatilgan xotira ustida amal bajarayotganda, boshqa thread uning dumini bosib olmasligi uchun GIL yechim hisoblanadi. Misol uchun ikkita shoir bitta listga sher yozsa oxirgi natija tushunarsiz text bo'lib qoladi, GIL bu muammoga bitta listga bir vaqtda faqat bitta shoir sher yozoladi degan qoida bilan buning oldini oladi.

Axlat yig'ish (Garbage collection)

Yuqorida misol keltirilgan shoirlar tushunchasida misol qiladigon bo'lsak, biror varoqdagi sher endi bizga kerak bo'lmaydigan bo'lsa biz undan qutilishimiz mumkin, yani o'chirib boshqa sher yozishimiz mumkin.

O'chirib yuborilgan eski sherni biz 0 (nol) ga tushirib qo'yilgan ob_refcnt yani object reference countga o'xshatishimiz mumkin.

Pythonda ref_count har xil sabablarga ko'ra o'sib borishi mumkin, misol uchun yangi o'zgaruvchiga biriktirilsa.

numbers = [1, 2, 3]
# Reference count = 1
more_numbers = numbers
# Reference count = 2

ref_count o'zgaruvchini funksiyaga argument qilib bergan taqdirda ham o'zgaradi

total = sum(numbers)

ref_count o'zgarishiga oxirgi misol bu, agar siz o'zgaruvchini list elementlari qilib bergan taqdiringizda ref_count oshib boradi.

matrix = [numbers, numbers, numbers]

Pythonda istalgan obyektni ref_countini bilib olishingiz mumkin, bu funksiya sys modulning getrefcount() funksiyasi orqali amalga oshiriladi, lekin yodingizda bo'lsin, obyektning refcountini ko'rish uning ref_countini yana bittaga oshiradi.

Xotira boshqaruvi (Memory management)

CPythondan hardware qadar orada abstraksiya qatlamlari mavjud. OS har doim applicationlar amal bajarishlari uchun fizik xotiradan joy ajratib virtual xotira yaratadi. Quyidagi to'q kulrang sohalar Python uchun mo'ljallangan xotiradir.

Cpythonning object allocatori object memory sohasidan xotira ajratish uchun javobgardir. Ushbu yashil object allocator soha asosiy mo'jiza yuz beradigon yerdir. U har doim pythonda yangi object yaratilayotganda yoki o'chirilayotganda ishga tushadi.

Pythonning source codiga berilgan izohlarda object allocatorga "umumiy malloc ustida ishlovchi va kichik hajmdagi blocklar uchun qulay" deyiladi. Bu yerda malloc C ning xotira boshqaruvi bibliotekasining funksiyasi hisoblanadi.

Hozir CPythonning xotira boshqaruvi strategiyasidagi 3 ta asosiy aspektga etibor beramiz.

Arena bu xotiradagi bir varoq deb hisoblangan Soha chegarasidir (page boundary). Soha chegarasi (page boundary) bu malum hajmdagi birlik deb hisoblangan va OS foydalanadigan xotiradagi bir bo'shliq. Python xotiradagi sohani 256 kb deb tasavvur qiladi.

Sohalar orasida havzalar (pool) lar mavjud, ular virtual xotirada 4 kb hisoblanadi. Kitob qiyosida oladigan bo'lsak bitta pool bir varoq degani. Har bir pool yanada kichikroq xotira blocklariga bo'linadi.

Pooldagi har bir blockning o'zining size class i bo'ladi. Bar bir size class mahsus block hajmini bildiradi, maxsus block hajmi so'ralayotgan bosh xotira hajmiga bog'liq, Pythonning source codida aynan ushbu izohlar qancha hajm egallaydigan object qanaqa blockga tushishi jadvali keltirilgan.

Misol uchun, 42 byte hajmdagi obyektni saqlamoqchi bo'lsa, python bizga 48 byteli blockga yo'naltiradi.

Poollar bir xil size class dan yaratilgan xotira blocklaridir. Har bir pool o'zida o'xshash size classga tegishli boshqa pool uchun double linked lists saqlaydilar (qo'shaloq ulanganlik havolasi).  Shu usulda Python so'ralayotgan xotirani osongina bir nechta pool bo'ylab izlab topishi mumkin.

usedpools har bir xotira blocki uchun ishlatilgan lekin bo'sh joylari bor xotira blocklari listini o'zida saqlaydi. Poollar 3 ta holatda bo'lishlari mumkin: used, full, yoki empty. used ishlatilgan lekin bo'sh orin bor, full bo'sh o'rin yoq, empty ishlatilmagan.

freepools ro'yhati ishlatilmagan poollarni ro'yhatini o'z ichida saqlaydi, lekin qachon poollari ishlatilmasdan qoladi, yoki bo'shatiladi ?

Tasavur qiling, siz 8 byte lik xotira so'radingiz, biror usedpoolda uncha xotira topilmadi, shunda biz freepoollardan birortasini olamiz va unga 8 byte lik xotira blockini yaratib malumotni saqlaymiz, shunda ushbu pool usedpoolss listiga qo'shiladi, keyingi xotira allocationida ishlatiladi.

Yoki biror fullpool ning biror blocki bo'shasa, ushbu block boshqa kerak bo'lmaganligi sababli, u pool o'z size classiga qarab usedpoolsga qo'shiladi.

Diagrammada ko'rib turganingizdek poolning bo'sh xotira blocklariga pointeri qaratilgan bo'ladi. Bu sturkturaning ishlash prinsipida biroz yetishmovchilik bor. Pointer uch qatlam bo'yicha ishlaydi (arena, pool, block) va u haqiqatdan kerak bo'lmasa xotira blockini ishlatmaydi.

Poolning blocklarida 3 ta holat bo'ladi:

• Untouched: Hali allocatsiya qilinmagan xotira blocki
• Free: Allocation qilingan lekin keyinchalik CPython uni bo'shatgan, va hozircha kerakli malumot o'zida saqlamayatkan block
• Allocated: O'zida kerakli malumot saqlab turgan xotira blocki

Freeblock pointeri doim ishlatilmayotgan yani biror malumot saqlasa bo'ladigan blocklarga qaratilgan bo'ladi. Agar so'ralayotgan xotira freeblocklarda yetarli bo'lmasa, allocator pooldagi untouched blocklardan kerakli miqdorda oladi.

Qachonki xotira menejeri biror xotira blockini bo'shatsa ushbu block freeblocks listga qo'shib qo'yiladi. Freeblocklar tepadagi diagrammaga o'xshab ketma ket yopishib turmasligi ham mumkin aksincha quyidagi diagrammada ko'rsatilgandek bo'lishi mumkin:

Arenas

Arenalar poollardan tashkil topadi. Poollar uch holatda yani used, full, empty bo'lishi mumkin. Arenaning o'zida esa pool kabi malum xolat mavjud emas.

Arenalar o'zaro bog'langan list ko'rinishida qurilgan va bu list usable_arenas deb nomlanadi. Bu list foydalanilgan poollar soniga qarab sort qilingan bo'ladi, yani qancha ko'p poool ishlatilgan bo'lsa shu arena listning boshiga yaqin bo'ladi.

Bundan chiqdi xotira zarur bo'lganda eng malumotga to'la arena tanlanadi, eng malumoti kam erana emas. Buning sababi nima ? nima uchun teskarisi emas ?

Bu narsa bizni xotirani to'laqonli bo'shatish tushunchasiga olib keladi, yani xotira blocki bo'shatilganganda u to'laqonli bo'shatilmaydi, yani OS ga qaytarilmaydi, uni Python allocation xolatida saqlaydi. Xotira to'laqonli bo'shatilsa u OS ga qaytarilishi kerak.

To'laqonli bo'shatilishi mumkin bo'lgan narsa bu faqat Arenadir. usable_arenas listni maqsadi shuki bo'sh xolatga yaqin bo'lgan arenalar bo'shatilishu zarur, shunda malum xotira to'laqonli bo'shatilishi mumkin, va Python programmasi ishlatayotgan umumiy xotira hajmi kamayadi.

Xulosa

Xotira boshqaruvi kompyuter olamining muhim integral qismi hisoblanadi. Yaxshimi yoki yomonmi Python buning barchasini parda ortida bajaradi.

Biz ushbu maqolada o'rgandik:

• Xotira boshqaruvi nima va u nima uchun muhim ?
• Pythonning o'z asl xolati, CPython, C dasturlash tilida yozilgan
• CPythonda xotira boshqaruvini taminlash uchun malumotlar strukturasi va lagoritmlar birgalikda qanday ishlaydi

Python compyuter bilan ishlashning mayda detallarini abstraktsiyalashtiradi. Bu bizga yuqori qatlamdagi funksionallarni har bitta bit hardwareda qanday saqlanishi haqida qayg'urmasdan yaratishimizga imkon beradi.

npm install -g @ vue / cli

Va ushubu buyruq yordamida frontend dasturingizni osongina yarating:

vue create <application_name>

Shu zahoti siz vue frontend dastur yaratish uchun sozlamalar tanlovini ko'rasiz:

1. Dastur opsiyalarini qo'lda sozlashni tanlang, "manual"
2. ushbu fundamental paketlarni tanlang: babel, vuex, css preprocessors, router
3. Vue ning oxirgi versiyasini tanlang, misol uchun 4.X
4. marshrutizator tarixini saqlash funksiyasi uchun "ha" ni tanlang
5. CSS -ni minifikatsiya qilish uchun o'zingiz maqul ko'rgan texnologiyani tanlang (dart sass)
6. Babel, Es Lint va boshqala paket konfiguratsiyalarini saqlash usulini tanlang.
7. Agar siz ushbu konfiguratsiyani kelajakdagi loyihalar uchun saqlamoqchi bo'lsangiz, "Ha" ni tanlang, aks holda "Yo'q".
8. Bajarildi!
   

Endi siz front end dasturingizni ushbu komanda bilan ishlatishingiz mumkin:
npm run serve

Va ushbu buyruq yordamida dasturingiz uchun kerak bo'lgan Js paketlarni o'rnatib olishingiz mumkin:

npm install <package_name>

Tamom!

Создаем приложение vue для django, перейдите в корневую папку Проекта,
и установите последнюю версию vue:

npm install -g @vue/cli

А затем с легкостью создаем приложение с помощью команды:

vue create <название_приложения>

После чего вы увидете варианты для создания внешнего интерфейса с vue:

1. выбрать ручной выбор
2. выберите: Babel, vuex, препроцессоры css, маршрутизатор
3. а затем выберите последнюю версию vue, например 4.x
4. выберите да для истории маршрутизатора
5. выберите, что вы предпочитаете для минификации CSS (dart sass)
6. выберите файлы конфигурации для сохранения конфигураций Babel, Es Lint и т. д.
7. выберите «Да», если вы хотите сохранить эту конфигурацию для будущих проектов, в противном случае - «Нет».
8. Выполнено!

Теперь вы можете запустить клиентское приложение с помощью команды:

npm run serve

Или вы можете установить любой пакет js, который вам нужен, с помощью команды:

npm install <название_пакета>

С этим все!

ERP (сокр. от Enterprise Resource Planning) означает "планирование ресурсов предприятия". Это программное обеспечение для управления бизнес-процессами, которое объединяет финансы, цепочки поставок, операции, торговлю, отчетность, производство, кадры и позволяет управлять ими. Большинство компаний располагают системами управления финансами и бизнес-процессами, но возможности этого ПО, как правило, ограничиваются повседневной рутиной или планами будущего развития.

В таком антиутопическом мире нужен надежный способ отличить злого бота от человека с благими намерениями. Как может веб-сайт банка быть уверенным, что ни в чем не повинная бабушка, которая входит в систему, чтобы проверить, что деньги на праздничный подарок были успешно переведены ее внукам, на самом деле является невинной бабушкой? Введите «Полностью автоматизированный общедоступный тест Тьюринга, чтобы отличить компьютеры от людей», или, проще говоря, CAPTCHA.

Bunday distopiya olamida sizga yomon botni yaxshi niyatli odamdan ajratib olishning ishonchli usuli kerak. Bayram sovg'asi pullari nevaralariga muvaffaqiyatli o'tkazilganligini tekshirish uchun tizimga kirgan begunoh buvisi aslida begunoh buvi ekanligiga bank veb-saytida qanday amin bo'lish mumkin? "Kompyuterlarni odamlardan farqlash uchun to'liq avtomatlashtirilgan ommaviy turing testi" yoki oddiygina CAPTCHA-ga kiring.

The search engine Alta Vista was one of the first popular websites that introduced a CAPTCHA-like protection when submitting new websites to its database.

There are many other forms of CAPTCHAs, including an audio version for the visually impaired. But it is the curiously simple variety — the “I’m not a robot” checkbox seen on many of today’s websites — that inspired the original question behind this article. This checkbox, endearingly called the “no CAPTCHA reCAPTCHA”, is a Google product that unsurprisingly uses a combination of advanced Google technology to produce a very simple result. Google will analyse your behaviour before, during and after clicking the checkbox to determine whether you appear human. This analysis might include everything from your browsing history (malicious bots don’t necessarily watch a few YouTube videos and check their Gmail before signing up for a bank account), to the way you organically move your mouse on the page. If Google is still unsure of your humanness after clicking the checkbox, you will be shown a visual reCAPTCHA (with words, street signs or images) as an additional security measure. This multi-faceted approach is necessary as computers become more skilled at complex image recognition and with the rise of CAPTCHA sweatshopping (think a large room of underpaid workers tasked with generating a heap of fake social media accounts).

Check out the video from google

Генетически модифицированный организм

ОписаниеГенети́чески модифици́рованный органи́зм — организм, генотип которого был искусственно изменён при помощи методов генной инженерии. Это определение может применяться для растений, животных и микроорганизмов.

Genetically modified organism

Description
Description A genetically modified organism is an organism whose genotype has been artificially altered using genetic engineering methods. This definition can be applied to plants, animals and microorganisms.

What is the difference between the two? If you look at just the definitions of vertical and horizontal you might see the following:

• Vertical: something that is standing directly upright at a right angle to the flat ground
• Horizontal: something that is parallel to the horizon (the area where the sky seems to meet the earth)

If you are a visual kind of person you may be able to see this. Let’s add some technology to this and see what we get.

Vertical scaling can essentially resize your server with no change to your code. It is the ability to increase the capacity of existing hardware or software by adding resources. Vertical scaling is limited by the fact that you can only get as big as the size of the server.

Horizontal scaling affords the ability to scale wider to deal with traffic. It is the ability to connect multiple hardware or software entities, such as servers, so that they work as a single logical unit. This kind of scale cannot be implemented at a moment’s notice.

So, having said all that, I always like to provide an example that you might be able to visually imagine.

Imagine, if you will, an apartment building that has many rooms and floors where people move in and out all the time. In this apartment building, 200 spaces are available but not all are taken at one time. So, in a sense, the apartment scales vertically as more people come and there are rooms to accommodate them. As long as the 200-space capacity is not exceeded, life is good.

This could even apply to a restaurant. You have seen the signs that tell you how many people could be held in the establishment. As more patrons come in more tables may be set up and more chairs added (scaling vertically). However when capacity is reached no more patrons would be able to fit. You can only be as big as the building and patio of the restaurant. This is much like in your cloud environment, where you could add more hardware to the existing machine (RAM and hard drive space) but you are limited to capacity of your actual machine.

On the horizontal scaling side, imagine a two lane expressway. The expressway is good to handle the 2,000 or so vehicles that travel the expressway. As commerce begins to expand, more buildings are constructed and more homes are built. As a result the expressway that once handled 2,000 or so vehicles is now having an increase to 8,000 vehicles. This makes a major traffic jam during rush hour. To alleviate this problem of traffic jams and an increase in accidents, the expressway can be scaled horizontally by constructing more lanes and quite possibly adding an overpass. In this example the construction will take some time. Much like scaling your cloud horizontally, you add additional machines to your environment (scaling wider). This requires planning and making sure you have resources available as well as making sure your architecture can handle the scalability.

I think this could be a simple way to explain scalability to a customer if they wanted to know the difference between vertical and horizontal scaling in the cloud. What are your thoughts? How have you described scalability? Leave a comment below and let me know.

Горизонтальное и вертикальное масштабирование в облаке

В этом облачном мире одной из важнейших функций является возможность масштабирования. Есть разные способы выполнить масштабирование, то есть преобразование, которое увеличивает или уменьшает. Один - это вертикальное масштабирование, а другой - горизонтальное масштабирование.

Какая разница между двумя? Если вы посмотрите только на определения вертикального и горизонтального, вы можете увидеть следующее:

• Вертикально: что-то, что стоит прямо вертикально под прямым углом к ​​плоской земле.
• По горизонтали: что-то параллельное горизонту (область, где кажется, что небо встречается с землей).

Если вы визуальный человек, вы можете это увидеть. Давайте добавим к этому технологию и посмотрим, что у нас получится.

Вертикальное масштабирование может существенно изменить размер вашего сервера без изменения вашего кода. Это возможность увеличить емкость существующего оборудования или программного обеспечения за счет добавления ресурсов. Вертикальное масштабирование ограничено тем фактом, что вы можете получить только размер сервера.

Горизонтальное масштабирование дает возможность масштабироваться шире для обработки трафика. Это возможность соединить несколько аппаратных или программных объектов, таких как серверы, так, чтобы они работали как единое логическое устройство. Такая шкала не может быть реализована в любой момент.

Итак, сказав все это, я всегда хотел бы привести пример, который вы могли бы визуально представить.

Представьте себе многоквартирный дом с множеством комнат и этажей, куда люди постоянно входят и выходят. В этом многоквартирном доме доступно 200 мест, но не все они заняты одновременно. Таким образом, в некотором смысле квартира масштабируется по вертикали по мере того, как приходит больше людей и появляются комнаты для их размещения. Пока емкость 200 мест не превышена, жизнь хороша.

Это может относиться даже к ресторану. Вы видели таблички, на которых указано, сколько человек может содержаться в заведении. По мере того, как приходит больше посетителей, может быть установлено больше столов и добавлено больше стульев (масштабирование по вертикали). Однако, когда емкость будет достигнута, посетители уже не смогут поместиться. Вы можете быть размером с здание и внутренний дворик ресторана. Это очень похоже на вашу облачную среду, где вы можете добавить дополнительное оборудование к существующей машине (ОЗУ и место на жестком диске), но вы ограничены емкостью вашей реальной машины.

Что касается горизонтального масштабирования, представьте себе двухполосную скоростную автомагистраль. Скоростная автомагистраль подходит для примерно 2000 транспортных средств, которые едут по ней. По мере того как торговля начинает расширяться, строится больше зданий и строится больше домов. В результате скоростная автомагистраль, которая когда-то обслуживала около 2 000 автомобилей, теперь увеличилась до 8 000 машин. Это создает большую пробку в час пик. Чтобы облегчить проблему пробок и увеличения количества аварий, скоростную автомагистраль можно масштабировать по горизонтали, построив больше полос и, вполне возможно, добавив эстакаду. В этом примере строительство займет некоторое время. Как и при горизонтальном масштабировании облака, вы добавляете в среду дополнительные машины (масштабирование шире). Это требует планирования и обеспечения наличия доступных ресурсов, а также уверенности в том, что ваша архитектура поддерживает масштабируемость.

Я думаю, что это может быть простой способ объяснить заказчику масштабируемость, если он хочет знать разницу между вертикальным и горизонтальным масштабированием в облаке. о чем ты думаешь? Как вы описали масштабируемость? Оставьте комментарий ниже и дайте мне знать.

How to explain vertical and horizontal scaling in the cloud - Cloud computing news

In this world of cloud, one of the biggest features is the ability to scale. There are different ways to accomplish scaling, which is a transformation that enlarges or diminishes. One is vertical scaling and the other is horizontal scaling. What is the difference between the two? If you look at just…

Cloud computing newsDavid Beaumont

This article get from ibm.com, Bu maqola ibm.com dan olindi, yuqorida maqolani asl nusxasiga havola keltirilgan.