Çıxışların formatlaşdırılması

Çıxışların formatlaşdırılması, başqa sözlə, çıxış verilənlərinin istifadəçilərə formatlı şəkildə təqdim edilməsi proqramlaşdırmada ən vacib məsələlərdən biridir. Biz bu dərsimizdə Python dilində çıxışların formatlaşdırılmasının müxtəlif üsullarından bəhs edəcəyik. Bununla belə sizə məsləhət görəcəyimiz üsul string sinfinin format metodudur. Bu üsul həm olduqca çevikdir, həm də Python dilinin fəlsəfəsinə uyğun gəlir. Gəlin tələsməyək və bütün üsulları bir-bir nəzərdən keçirək.

Biz indiyə qədər çıxış verilənlərini ekrana primitiv üsullarla çıxarırdıq. Ekrana çıxarılan məlumatlar birdən çox olduqda onları bir-birindən ayırmaq lazımdır. Bunun da ən sadə yolu ya print() funksiyasının sep parametrindən (ayırıcı) istifadə, ya da sətirləri konkatenasiya (birləşdirilmə) etməkdən ibarətdir.

Adi qaydada print() funksiyasında sep parametri yazılmır və interpretator onun qiymətini default olaraq boşluq qəbul edir. Bu zaman funksiyanın bir-birindən vergüllə ayrılan arqumentləri ekrana çıxarılanda aralarında boşluq olur:

>>> a = 78
>>> b = 0.19
>>> print(a, b, a * b) 
78 0.19 14.82
>>>

Zərurət olduqda biz sep parametrindən yararlanaraq onu ixtiyari qiymətlərlə təyin edə bilərik:

>>> a = 78
>>> b = 0.19
>>> print(a, b, a * b, sep = ',') 
78,0.19,14.82
>>> print(a, b, a * b, sep = '---') 
78---0.19---14.82
>>>

Aşağıdakı proqramda isə çıxışları formatlaşdırmaq üçün sətirlərin konkatenasiyasından istifadə olunur:

>>> a = 78
>>> b = 0.19
>>> print(str(a)+ " " +str(b)+" " +str(a * b)) 
78 0.19 14.82
>>>

Yuxarıda sadalanan bu üsullar nə qədər sadə olsa da, peşəkarlıq baxımından qənaətbəxş deyil.

Ədəd tipləri

Python proqramlaşdırma dilində üç müxtəlif ədəd tipi var: tam (int), həqiqi (float) və kompleks (complex). int və float tipləri ilə siz artıq tanışsınız. Bunlarla bağlı bir neçə məqamı qeyd etdikdən sonra complex tipindən də danışacağıq.

int

int tam ədəd tipində ədədlər istənilən uzunluqda ola bilər. Daha doğrusu, int tipindəki ədədin uzunluğu kompüterin əməli yaddaşının verdiyi imkanla məhdudlaşır. Adi insanlar gündəlik həyatda onluq say sistemindəki ədədlərlə işləyir, amma proqramçılara həm də ikilik, səkkizlik və onaltılıq ədədlər lazım olur. Python dilində önlərinə müvafiq prefikslər qoymaqla bu ədədləri təsvir etmək mümkündür:

Say sistemiPrefiks
ikilik (binary)0b və ya 0B
səkkizlik (octal)0o və ya 0O
onaltılıq (hexadecimal)0x və ya 0X

İnterpretator prefikslərin köməyilə təsvir etdiyimiz ikilik, səkkizlik və onaltılıq ədədləri onluq say sistemində göstərəcək:

>>> 0b1101011 
107
>>> 0xFB + 0b10 
253
>>> 0o15 
13
>>>

Müxtəlif say sistemlərində olan ədədləri onluq sistemə çevirmək üçün iki parametrli int(x, b) funksiyasından istifadə olunur. Burada x digər say sistemində olan ədəddir və dırnaq arasında göstərilməlidir. İkinci parametr olan b isə verilmiş ədədin hansı say sistemində olduğunu bildirmək üçündür. Burada say sisteminin əsası kimi [2…36] aralığında qiymət göstərə bilərik:

>>> int("1001", 2) 
9
>>> int("15", 8) 
13
>>> int("0xFB", 16) 
251
>>>

Onluq say sistemindəki bir ədədi ikilik, səkkizlik və onaltılıq sistemə çevirmək üçün müvafiq olaraq bin(x), oct(x) və hex(x) funksiyalarından istifadə olunur. Burada x onluq say sistemindəki ədəddir:

>>> bin(9) 
'0b1001' 
>>> oct(13) 
'0o15'
>>> hex(251) 
'0xfb'
>>>

float

Python dilində həqiqi ədədlərlə işləmək üçün float tipi nəzərdə tutulmuşdur. Bu tipin qiymət aralığı aşağıdakı kimi təyin edilmişdir:

[2.2250738585072020𝑥10-308 . . . 1.7976931348623157𝑥10308]

Bu sərhədlər pozulduqda interpretator xəta mesajı verir:

>>> a = 3 ** 1000
>>> a + 0.1
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module> 
    a + 0.1
OverflowError: int too large to convert to float 
>>>

Onu da qeyd etmək lazımdır ki, float tipində verilən ədədlər vergüldən sonra 15 işarə dəqiqliyində ola bilir (16-cı mövqe qeyri-dəqiqdir):

>>> 1.1234567890123456789 
1.1234567890123457
>>>

Hesablamalarda daha yüksək dəqiqlik tələb olunursa, decimal moduluna müraciət etmək lazımdır.
Python proqramlaşdırma dilində həqiqi ədədlər adi qaydadan başqa, eksponensial formatda da təsvir oluna bilər. Bu zaman eksponent E və ya e simvolları ilə verilir. Eksponensial formatda təsvir edilən həqiqi ədədi interpretator adi qaydada göstərəcək:

>>> 123.45 
123.45
>>> 1.2345e2 
123.45
>>> 5.45E-2 
0.0545
>>>

Sonda onu da qeyd edək ki, rasional ədədlər ilə bağlı hesablamalar üçün Python dilində ayrıca fractions modulu nəzərdə tutulmuşdur.

complex

Python proqramlaşdırma dilində kompleks ədədlərlə işləmək üçün complex adlı xüsusi bir tip nəzərdə tutulmuşdur. Bildiyiniz kimi, kompleks ədədlər iki hissədən ibarətdir: həqiqi və xəyali. Kompleks ədədlər a+bj şəklində göstərilir. Burada a həqiqi hissə, b isə xəyali hissənin əmsalıdır və hər ikisi ədəd (int, float və həmçinin complex) tipində qiymət və ya dəyişən ola bilər.

Buradakı j (və ya J) isə √-1 xəyali ədədinin özünü bildirən xüsusi simvoldur:

>>> 3+4j 
(3+4j)
>>> 2.5+7.7J 
(2.5+7.7j) 
>>>

Kompleks ədədləri iki parametrli complex(a, b) funksiyasından istifadə etməklə də vermək olar.
Burada yenə a həqiqi, b isə xəyali hissənin əmsalıdır:

>>> complex(3, 4) 
(3+4j)
>>> x = complex(1, 2) 
>>> print(x)
(1+2j) 
>>>

Bir parametrli complex(s) funksiyası isə verilmiş sətir və ya ədədi kompleks ədədə çevirir. Burada çevirmək istədiyimiz ifadə (s) sətir tipində olub dırnaq arasında verilməlidir:

>>> complex("2+3j") 
(2+3j)
>>> complex("4") 
(4+0j)
>>> complex("2j") 
2j
>>> complex()
0j
>>> complex("info")
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module> 
    complex("info")
ValueError: complex() arg is a malformed string 
>>>

Sonuncu misaldan da gördüyünüz kimi, verilmiş ifadəni kompleks ədədə çevirmək mümkün olmadıqda interpretator xəta mesajı verir. Eyni xəta ifadə içərisində + və – operatorlarının ətrafında boşluqlar olanda (məsələn: complex(“2 + 3j”) yazıldıqda) da qeydə alınır.
Kompleks ədədlər üzərində toplama, çıxma, vurma və bölmə əməliyyatlarını yerinə yetirmək olar:

>>> x = 2+3j 
>>> y = 1+2j 
>>> x + y 
(3+5j)
>>> x - y 
(1+1j) 
>>> x * y 
(-4+7j) 
>>> x / y 
(1.6-0.2j) 
>>>

İki kompleks ədədi bir-birilə müqayisə (>, <, >=, <=) etmək olmaz, lakin onların bir-birinə bərabərliyini yoxlamaq olar:

>>> x = 2+3j
>>> y = 1+2j
>>> x > y
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module> 
    x > y
TypeError: unorderable types: complex() > complex() 
>>> x == y
False
>>>

Sonda kompleks ədədlər ilə bağlı bir neçə metodu da nəzərdən keçirək. Buradan “bəs metod nədir?” sualınızı eşidirəm 🙂 Əvvəlcədən qeyd edim ki, biz metodlar haqqında daha ətraflı obyekt yönlü proqramlaşdırmanı keçəndə bəhs edəcəyik. Hələlik isə onu bilməyiniz kifayətdir ki, metodlar da əslində funksiyalardır. Biz onları obyektlərə (indiki halda kompleks tipdə qiymət və ya dəyişənə) nöqtəli notasiya ilə tətbiq edirik. Yəni əvvəlcə qiymət və ya dəyişənin adını yazır, sonra nöqtə qoyur, ardınca da metodu qeyd edirik:

>>> x = 2+3j
>>> x.real # kompleks ədədin həqiqi hissəsi 
2.0
>>> x.imag # kompleks ədədin xəyali hissəsi 
3.0
>>> x.conjugate() # kompleks ədədin qoşması 
(2-3j)
>>>

Kompleks ədədlər ilə bağlı Python dilinin cmath modulunda bir sıra riyazi funksiyalar nəzərdə tutulmuşdur.

Massivlər

Bildiyiniz kimi, massiv bir adla adlandırılmış nizamlanmış kəmiyyətlər yığımıdır. Bir çox proqramlaşdırma dillərində massivlərlə işləmək üçün ayrıca array tipi nəzərdə tutulmuşdur. Python dilində standart tip kimi array tipi olmasa da, massivlərlə işləmək üçün bu dilin imkanları kifayət qədərdir. Konkret olaraq, siyahılar (lists), array modulu və NumPy massivlərindən istifadə etmək mümkündür. Biz bunlardan ikisi ilə yaxından tanış olacağıq.

Siyahıların massiv kimi istifadəsi

Massiv strukturlu verilənlərlə işləməyin ən sadə yolu siyahılardan (list tipi) istifadə etməkdir. Gəlin sadə misallar üzərində bunu nümayiş etdirək. Fərz edək ki, Əli üç fəndən qiymətlər alıb. Bu qiymətləri birölçülü massiv şəklində təsvir etmək olar. Aşağıdakı proqramı nəzərdən keçirin:

>>> marks = [3, 5, 4]
>>> for m in marks:
        print(m, end = ' ')

3 5 4 
>>>

Biz burada Əlinin qiymətlərini əvvəlcədən təyin etmiş oluruq. Amma bu qiymətlər, yəni massivin elementləri klaviaturadan da daxil edilə bilər:

marks = []

n = int(input("Qiymətlərin sayını daxil edin: ")) 
for i in range(n):
    marks.append(int(input("Qiymət: ")))

print("Şagirdlərin qiymətləri:")
for m in marks:
    print(m, end=' ')

Burada əvvəlcə boş massiv (siyahı) elan edilir və istifadəçidən qiymətlərin (massivin elementlərinin) sayı soruşulur. Sonra dövr qurularaq massivə klaviaturadan daxil edilən qiymətlər əlavə olunur. Ən sonda bu qiymətlər ekranda çapa verilir. Proqramı skriptdə yazıb icra edin.

İndi isə gəlin siyahılardan istifadə edərək ikiölçülü massivləri nəzərdən keçirək. Bu dəfə fərz edək ki, Əli, Vəli və Pirvəli üç fəndən qiymətlər alıb. Onların qiymətlərini ikiölçülü massiv şəklində təsvir etmək olar. Aşağıdakı proqramı nəzərdən keçirin:

>>> marks = [[3, 5, 4], [4, 3, 5], [5, 4, 3]] 
>>> for m in marks:
        for n in m: 
            print(n, end = ' ')
        print()

3 5 4 
4 3 5 
5 4 3 
>>>

Proqrama diqqətlə baxsanız, görəcəksiniz ki, biz burada elementləri siyahıdan ibarət siyahı təyin etmişik. Xatırlayırsınızsa, siyahılar mövzsunu işləyəndə qeyd etmişdik ki, iç-içə siyahılardan istifadə etmək mümkündür, yəni siyahının özü başqa siyahılardan ibarət ola bilər.
Eyni proqramı başqa cür də yazmaq olardı:

>>> marks = [[3, 5, 4], [4, 3, 5], [5, 4, 3]] 
>>> for i in range(len(marks)):
        for j in range(len(marks[i])): 
            print(marks[i][j], end = ' ')
        print()

3 5 4 
4 3 5 
5 4 3
>>>

Qiymətləri, yəni massivin elementlərini klaviaturadan da daxil edə bilərik:

marks = []
n = int(input("Şagirdlərin sayını daxil edin: ")) 
m = int(input("Qiymətlərin sayını daxil edin: "))

for i in range(n): 
    marks.append([])

for i in range(n): 
    r = marks[i]
    print("{}. şagirdin qiymətləri:".format(i + 1)) 
    for j in range(m):
        r.append(int(input("Qiymət: ")))

print("Şagirdlərin qiymətləri:") 
for i in range(n):
    for j in range(m): 
        print(marks[i][j], end = ' ')
    print()

Burada əvvəlcə boş massiv (siyahı) elan edilir. Bundan sonra istifadəçidən şagirdlərin (n) və qiymətlərin (m) sayı soruşulur. Daha sonra dövr qurularaq boş siyahıya şagirdlərin (n) sayı qədər elementlər (boş siyahılar) əlavə edilir (Biz burada siyahıya elementləri əlavə etmək üçün append() metodundan yararlanırıq). Həmin bu boş siyahılar da şagirdlərin müvafiq qiymətləri (klaviaturadan daxil edilənlər) ilə doldurulur. Nəhayət, bu qiymətlər ekranda çapa verilir. Bu proqramı da skriptdə yazıb icra edin.
İndi isə gəlin məsələni bir az mürəkkəbləşdirək, Əli, Vəli və Pirvəlinin orta qiymətlərini tapaq:

marks = []
n = int(input("Şagirdlərin sayını daxil edin: ")) 
m = int(input("Qiymətlərin sayını daxil edin: "))

for i in range(n): 
    marks.append([])

for i in range(n): 
    r = marks[i]
    print("{}. şagirdin qiymətləri:".format(i + 1)) 
    for j in range(m):
        r.append(int(input("Qiymət: ")))

print("Şagirdlərin orta qiymətləri:") 
for i in range(n):
    s = 0
    for j in range(m):
        s += marks[i][j]
    print("{0:d} - {1:3.1f}".format(i + 1, s / m))

Proqramı skriptdə yazıb icra edin.

array modulunun istifadəsi

Python proqramlaşdırma dilindəki array modulu massiv tipli verilənlərlə işləmək üçün nəzərdə tutulub. Buradakı massivlər yuxarıda bəhs etdiyimiz siyahılara çox bənzəyir. Lakin siyahılardan fərqli olaraq, array massivlərinin elementləri eynitiplidir və onların yaddaş ölçülərinə məhdudiyyətlər qoyulur.
Proqramda array massivlərindən istifadə edə bilmək üçün array modulunun özü daxil edilməlidir:

>>> from array import * 
>>>

Massivi təyin etmək üçün isə aşağıdakı konstruktordan istifadə edilir:

identifikator = array(tipkod[,inisiallaşdırıcı])

Burada identifikator massivin dəyişən adı, tipkod (tip kodu) elementlərinin tipini bildirən kod, inisiallaşdırıcı isə elementlərin siyahısıdır.
Massivin elementləri üçün təyin edilən tip kodları aşağıdakı cədvəldə verilmişdir:

TipkodTipMinimum ölçü (bayt)
bint 1
Bint 1
uUnicode character 2
hint 2
Hint 2
iint 2
Iint 2
lint 4
Lint 4
qint 8
Qint 8
ffloat4
dfloat8

Aşağıdakı nümunəni nəzərdən keçirin:

>>> from array import *
>>> mas = array('b', [1, 2, 3, 4, 5]) 
>>> for m in mas:
        print(m, end = ' ')

1 2 3 4 5
>>>

Elementləri klaviaturadan da daxil edə bilərsiniz. Bunun üçün massivin sonuna yeni element əlavə edən array.append(element) metodundan istifadə etməlisiniz:

from array import *

mas = array('b', [])
n = int(input("Qiymətlərin sayını daxil edin: "))

for i in range(n): 
    mas.append(int(input("Element: ")))

print("Massivin elementləri:") 
for m in mas:
    print(m, end = ' ')

Massivə yeni elementi müəyyən mövqedən daxil etmək üçün array.insert(mövqe, element) metodundan istifadə olunur:

>>> from array import *
>>> mas = array('b', [2, 3, 4, 5]) 
>>> mas.insert(0, 1)
>>> for m in mas:
        print(m, end = ' ')

1 2 3 4 5 
>>>

Massivin sonuna başqa iterasiyanın (məsələn: massivin) elementlərini artırmaq üçün array.extend(iterasiya) metodu tətbiq edilir. Burada diqqət etmək lazımdır ki, istifadə olunan iterasiyanın elementləri cari massivin elementləri ilə eyni tipdə olsun. Əks halda, TypeError xətası qeydə alınacaq. Aşağıdakı nümunəni nəzərdən keçirin:

>>> from array import *
>>> mas1 = array('b', [1, 2, 3, 4, 5]) 
>>> mas2 = array('b', [6, 7, 8]) 
>>> mas1.extend(mas2)
>>> for m in mas1:
        print(m, end = ' ')

1 2 3 4 5 6 7 8 
>>>

Massivin sonuna verilmiş siyahıdan elementləri əlavə etmək üçün array.fromlist(siyahı) metodundan istifadə olunur:

>>> from array import *
>>> mas = array('b', [1, 2, 3, 4, 5]) 
>>> a = [6, 7, 8]
>>> mas.fromlist(a)
>>> for m in mas:
        print(m, end = ' ')

1 2 3 4 5 6 7 8 
>>>

Massivdən onun elementini çıxarmaq üçün array.remove(element) və ya array.pop([mövqe]) metodlarından istifadə edilir. Birinci metod göstərilmiş elementi massivdə ilk tapdığı yerdən silir. İkinci metodda isə xaric edilməsi istənilən elementin mövqeyi göstərilir. Bu mövqe göstərilmədikdə massivin sonuncu elementi xaric edilir. Aşağıdakı nümunələri nəzərdən keçirin:

>>> from array import *
>>> mas = array('b', [1, 2, 3, 4, 5]) 
>>> mas.remove(3)
>>> mas
array('b', [1, 2, 4, 5])
>>> mas.pop(2)
4
>>> mas
array('b', [1, 2, 5])
>>> mas.pop()
5
>>> mas
array('b', [1, 2])
>>>

Massivdə verilmiş elementin neçənci mövqedə yerləşdiyini öyrənmək üçün array.index(element) metodundan istifadə edilir. Göstərilmiş elementdən massivdə bir neçəsi ola bilər, metod onlardan birincisinin mövqeyini qaytaracaq:

>>> from array import *
>>> mas = array('b', [1, 2, 3, 4, 5]) 
>>> mas.index(3)
2
>>>

Massivin elementlərini tərs düzmək üçün array.reverse() metodundan istifadə olunur:

>>> from array import *
>>> mas = array('b', [1, 2 , 3, 4, 5]) 
>>> mas.reverse()
>>> mas
array('b', [5, 4, 3, 2, 1])
>>>

Biz buraya qədər array modulunun bir neçə əsas metodlarını nəzərdən keçirdik. Digər metodlarla özünüz də tanış ola bilərsiniz. Sonda onu da qeyd edək ki, array modulu çoxölçülü massivlərlə işləməyə imkan vermir. Əslində daha öncə istifadə etdiyimiz siyahılarla da bu birbaşa mümkün deyildi. Biz dolayı yoldan, yəni iç-içə siyahılardan istifadə etməklə ikiölçülü massivləri emulyasiya etmiş olduq. Əgər çoxölçülü massivlərlə daha geniş imkanlarla işləmək istəyirsinizsə, NumPy massivlərindən istifadə etməlisiniz. NumPy Python dilində elmi hesablamalar və digər tətbiqi məsələlərin həlli üçün nəzərdə tutulan əlavə paketdir. Geniş məlumat əldə etmək üçün http://www.numpy.org saytına müraciət edin.