3. Python’un Temelleri

3.1. [bases_01] betiği: temel işlemler

[bases_01] betiği, Python’un temel özelliklerini gösterir.


# ----------------------------------
def affiche(chaine):
    # dizeyi görüntüler
    print("chaine=%s" % chaine)


# ----------------------------------
def affiche_type(variable):
    # değişken türünü gösterir
    print("type[%s]=%s" % (variable, type(variable)))


# ----------------------------------
def f1(param):
    # parametreye 10 ekler
    return param + 10


# ----------------------------------
def f2():
    # 3 değerden oluşan bir tuple döndürür
    return "un", 0, 100


# -------------------------------- ana program ------------------------------------
# bu bir yorumdur
# bildirilmeden kullanılan değişken
nom = "dupont"

# ekran çıktısı
print("nom=%s" % nom)

# farklı türde öğeler içeren bir liste
liste = ["un", "deux", 3, 4]

# eleman sayısı
n = len(liste)

# bir döngü
for i in range(n):
    print("liste[%d]=%s" % (i, liste[i]))

# 2 değişkenin bir tuple ile başlatılması
(chaine1, chaine2) = ("chaine1", "chaine2")

# 2 dizgenin birleştirilmesi
chaine3 = chaine1 + chaine2

# sonucun görüntülenmesi
print("[%s,%s,%s]" % (chaine1, chaine2, chaine3))

# fonksiyon kullanımı
affiche(chaine1)

# bir değişkenin türü bilinebilir
affiche_type(n)
affiche_type(chaine1)
affiche_type(liste)

# bir değişkenin türü çalışma sırasında değişebilir
n = "a changé"
affiche_type(n)

# bir işlev bir sonuç döndürebilir
res1 = f1(4)
print("res1=%s" % res1)

# bir işlev bir değerler listesi döndürebilir
(res1, res2, res3) = f2()
print("(res1,res2,res3)=[%s,%s,%s]" % (res1, res2, res3))

# bu değerler bir değişkende toplanabilirdi
liste = f2()
for i in range(len(liste)):
    print("liste[%s]=%s" % (i, liste[i]))

# testler
for i in range(len(liste)):
    # sadece dizeleri görüntüler
    if type(liste[i]) == "str":
        print("liste[%s]=%s" % (i, liste[i]))

# diğer testler
for i in range(len(liste)):
    # sadece 10'dan büyük tamsayıları görüntüler
    if type(liste[i]) == "int" and liste[i] > 10:
        print("liste[%s]=%s" % (i, liste[i]))

# bir while döngüsü
liste = (8, 5, 0, -2, 3, 4)
i = 0
somme = 0
while i < len(liste) and liste[i] > 0:
    print("liste[%s]=%s" % (i, liste[i]))
    somme += liste[i]  # toplam=toplam+liste[i]
    i += 1  # i=i+1
print("somme=%s" % somme)
# program sonu

Açıklamalar

1. satır: def anahtar sözcüğü bir işlevi tanımlar;
1. satır: işlev, [chaine] parametresini alır. Parametrenin türü belirtilmez. Python, yalnızca değer aktarımını kullanır. Bu, veriye göre farklılık gösterir:
2. basit türler (sayı, boole...) için bu değer, verinin içerdiği değerdir (4, True...);
3. karmaşık türler (liste, sınıf…) için bu değer, verinin adresidir;
3-4. satırlar: fonksiyonun içeriği. İçerik, bir sekme kadar sağa kaydırılmıştır. def komutundaki : karakteriyle ilişkili bu girinti, fonksiyonun içeriğini tanımlar. Bu durum, içeriği olan tüm komutlar için geçerlidir: if, else, while, for, try, except;
1. satır: Burada kullanılan sözdizimi [print('text1%F1text2%F2…' % data1, data2)]'tir:
2. [%Fi] (burada %s) gösterim biçimleridir:
3. %s (string): bir karakter dizisi için;
4. %d (decimal): işaretli ondalık tamsayılar için;
5. %f (float): gerçek sayılar için ondalık biçim;
6. %e (üstel): bir gerçek sayı için üstel biçim;
7. …
[data1, data2…], değerini görüntülemek istediğimiz ifadeler:
- [data1], F1 biçiminde görüntülenecektir;
- [data2], F2 biçiminde görüntülenecektir;
- …
1. satır: Python, değişkenlerin türünü dahili olarak yönetir. Bir değişkenin türünü, 'type' türünde bir değişken döndüren type(variable) işleviyle öğrenebiliriz. '%s' % (type(değişken)) ifadesi, değişkenin türünü temsil eden bir karakter dizisidir;
1. satır: ana program. Bu program genellikle (ancak zorunlu olarak değil) komut dosyasındaki tüm fonksiyonların tanımlanmasından sonra gelir. İçeriği girintisizdir;
1. satır: Python'da değişkenler bildirilmez. Python, büyük/küçük harf ayrımına duyarlıdır. Nom değişkeni, nom değişkeninden farklıdır. Bir karakter dizisi tırnak işaretleri " veya kesme işaretleri ' ile çevrelenebilir. Dolayısıyla 'dupont' veya "dupont" şeklinde yazılabilir;
1. satır: (1,2,3) tuple'ı (parantezlere dikkat edin) ile [1,2,3] listesi (köşeli parantezlere dikkat edin) arasında bir fark vardır. Tuple değiştirilemezken, liste değiştirilebilir. Her iki durumda da i numaralı eleman [i] olarak gösterilir;
satır 40: range(n), (0,1,2,…,n-1) tuple'ıdır;
1. satır: %d biçimi, işaretli tamsayılar için kullanılır;
1. satır: len(var), var koleksiyonunun (tuple, liste, sözlük…) eleman sayısıdır;
satır 84: [for in …] yapısı, yinelenebilir bir yapıyı yinelemek için kullanılır. Listeler ve tuple'lar yinelenebilir öğelerdir;
satır 86: diğer boole operatörleri or ve not'tur;
1. satır: listedeki >0 sayıların toplamını alır;

Ekran çıktısı şu şekildedir:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_01.py
nom=dupont
liste[0]=un
liste[1]=deux
liste[2]=3
liste[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=<class 'int'>
type[chaine1]=<class 'str'>
type[['un', 'deux', 3, 4]]=<class 'list'>
type[a changé]=<class 'str'>
res1=14
(res1,res2,res3)=[un,0,100]
liste[0]=un
liste[1]=0
liste[2]=100
liste[0]=8
liste[1]=5
somme=13

Process finished with exit code 0

3.2. [bases_02] betiği: biçimlendirme dizeleri

Python 3, karakter dizelerini biçimlendirmenin yeni bir yolunu getirmiştir:


# biçimlendirme dizeleri
# biçimler C dilindekilerle aynıdır
# tamsayı
int1 = 10
print(f"[int1={int1}]")
print(f"[int1={int1:4d}]")
print(f"[int1={int1:04d}]")
# kayan nokta
float1=8.2
print(f"[float1={float1}]")
print(f"[float1={float1:8.2f}]")
print(f"[float1={float1:.3e}]")
# dize
str1="abcd"
print(f"[str1={str1}]")
print(f"[str1={str1:8s}]")
str2="jean de florette"
print(f"[{str2:20.10s}]")
# biçimlendirilmiş dizeler değişkenlere atanabilir
str3=f"[{str2:20.10s}]"
print(str3)

Biçimlendirilmiş dizgenin sözdizimi şöyledir:

1	`f'…{expr1:format1} …. {expr2:format2} ….'`

burada:

[expri]: bir ifade;
[formati]: [expri] ifadesinin biçimi. Bu biçimler C diline aittir:
- %d: tamsayılar için;
- %f: gerçek sayılar için ondalık gösterim;
- %e: gerçek sayılar için üs gösterimi;
- %s: karakter dizeleri için. [expri] için herhangi bir biçim kullanılmadığında bu biçim kullanılır;
- %nd, %nf, %ns: [expri]'i n karakterlik olarak görüntüler: dize ya kesilir ya da boşluklarla tamamlanır;
1. satır: [04d], 4 karakterlik tamsayı, sol tarafı sıfırlarla doldurulur;
1. satır: [8.2f], 8 karakterlik ondalık sayı, virgülden sonra 2 karakter;
1. satır: [.3e], mantis kısmı 3 ondalık basamaklı üstel biçiminde;
satır 18: [20.10s], 20 karakter olacak şekilde boşluklarla tamamlanmış bir dizgenin ilk 10 karakteri;

Çalıştırma sonuçları şöyledir:

C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_02.py
[int1=10]
[int1=  10]
[int1=0010]
[float1=8.2]
[float1=    8.20]
[float1=8.200e+00]
[str1=abcd]
[str1=abcd    ]
[jean de fl          ]
[jean de fl          ]

Process finished with exit code 0

3.3. [bases_03] betiği: tür dönüşümleri

Burada str (dize), int (tamsayı), float (kesirli sayı) ve bool (boole) türündeki verilerle yapılan tür dönüşümlerine odaklanacağız.


# tür dönüşümleri
# int --> str, float, bool
x = 4
print(x, type(x))
x = str(4)
print(x, type(x))
x = float(4)
print(x, type(x))
x = bool(4)
print(x, type(x))

# bool --> int, float, str
x = True
print(x, type(x))
x = int(True)
print(x, type(x))
x = float(True)
print(x, type(x))
x = str(True)
print(x, type(x))

# str --> int, float, bool
x = "4"
print(x, type(x))
x = int("4")
print(x, type(x))
x = float("4")
print(x, type(x))
x = bool("4")
print(x, type(x))

# float --> str, int, bool
x = 4.32
print(x, type(x))
x = str(4.32)
print(x, type(x))
x = int(4.32)
print(x, type(x))
x = bool(4.32)
print(x, type(x))

# tür dönüşümü hatalarının yönetimi
try:
    x = int("abc")
    print(x, type(x))
except ValueError as erreur:
    print(erreur)

# çeşitli durumlar
x = bool("abc")
print(x, type(x))
x = bool("")
print(x, type(x))
x = bool(0)
print(x, type(x))
x = None
print(x, type(x))
x = bool(None)
print(x, type(x))
x = bool(0.0)
print(x, type(x))

# tüm veriler sınıf örnekleridir ve bu nedenle yöntemlere sahiptir
# karakter dizesi
str1 = "abc"
print(str1.capitalize())
# tamsayı
int1 = 4
print(int1.bit_length())
# boole
bool1=True
print(bool1.conjugate())
# gerçek sayı
float1=8.2
print (float1.is_integer())

Çok sayıda tür dönüşümü mümkündür. Bazıları başarısız olabilir; örneğin, 46-47. satırlarda 'abc' dizesini tamsayıya dönüştürmeye çalışırken olduğu gibi. Bu hatayı try / except yapısı ile ele aldık. Bu yapının genel biçimi

şöyledir:


try:
    actions
except Exception as ex:
    actions
finally:
    actions

try bloğundaki işlemlerden biri bir istisna oluşturursa (bir hata bildirirse), hemen except bloğuna geçilir. try bloğundaki işlemler bir istisna oluşturmazsa, except bloğu yok sayılır. except komutunun Exception ve ex öznitelikleri isteğe bağlıdır. Bu öznitelikler mevcut olduğunda, Exception, except komutu tarafından yakalanan istisna türünü belirtir ve ex, meydana gelen istisnayı içerir. Aynı try içinde farklı istisna türlerini yönetmek istenirse, birden fazla except komutu bulunabilir.

finally komutu isteğe bağlıdır. Bu komut varsa, istisna olsun ya da olmasın, finally'teki eylemler her zaman yürütülür.

İstisnalara biraz ileride tekrar değineceğiz.

49-61. satırlar, str, int, float, NoneType türündeki verileri boole değerine dönüştürmeye yönelik çeşitli denemeleri göstermektedir. Bu her zaman mümkündür. Kurallar şunlardır:

bool(int i), i 0 ise False, diğer tüm durumlarda True değerine eşittir;
bool(float f), f 0,0 ise False, diğer tüm durumlarda True değerine eşittir;
bool(str chaine), chaine 0 karakter içeriyorsa False, diğer tüm durumlarda True değerini alır;
bool(None) değeri False'dur. None, değişkenin var olduğunu ancak bir değeri olmadığını belirten özel bir değerdir.

Ekran çıktıları şu şekildedir:

C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_03.py
4 <class 'int'>
4 <class 'str'>
4.0 <class 'float'>
True <class 'bool'>
True <class 'bool'>
1 <class 'int'>
1.0 <class 'float'>
True <class 'str'>
4 <class 'str'>
4 <class 'int'>
4.0 <class 'float'>
True <class 'bool'>
4.32 <class 'float'>
4.32 <class 'str'>
4 <class 'int'>
True <class 'bool'>
invalid literal for int() with base 10: 'abc'
True <class 'bool'>
False <class 'bool'>
False <class 'bool'>
None <class 'NoneType'>
False <class 'bool'>
False <class 'bool'>
Abc
3
1
False

Process finished with exit code 0

Tüm verilerin nesneler, yani sınıf örnekleri olduğu dikkatinizi çekecektir. Bu, verilerin yöntemlere sahip olabileceği anlamına gelir. Kodun 63-75. satırları bunu göstermektedir. Burada kullanılan yöntemlerin ne işe yaradığını açıklamaya çalışmıyoruz, sadece bunların var olduğunu göstermek istiyoruz.

3.4. [bases_04] betiği: değişkenlerin kapsamı

[bases_04] betiği, Python'da blok kapsamlı değişken kavramının olmadığını gösterir:


# değişkenlerin kapsamı
i = 4
if True:
    i += 1
    j = 7
print(f"i={i}, j={j}")

Sonuçlar

C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_04.py
i=5, j=7

Process finished with exit code 0

Yorumlar

Sonuçlar iki şeyi göstermektedir:

1. satır: [if] bloğundaki [i] değişkeni, 2. satırda kullanılan i değişkeniyle aynıdır;
1. satır: [j] değişkeni, [if] bloğunda başlatılan değişkendir;

Değişkenlerin tanımlandığı bazı dillerde, bir blokta (3-5. satırlardaki gibi) tanımlanan bir değişken, o bloğun dışında bilinmez. Python'da ise böyle bir durum söz konusu değildir.

3.5. [bases_05] betiği: listeler - 1

[bases_05] betiği şöyledir:


# tek boyutlu listeler
# başlatma
list1 = [0, 1, 2, 3, 4, 5]

# döngü - 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
    print(f"list1[{i}]={list1[i]}")

list1[1] = 10
# döngü - 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
    print(element)

# iki öğenin eklenmesi
list1[len(list1):] = [10, 11]
# %s biçimi, listeyi tek satırda görüntülemeye olanak tanır
print("%s" % list1)

# son iki öğenin silinmesi
list1[len(list1) - 2:] = []
# varsayılan biçim, listeyi tek satırda görüntülemeyi sağlar
print(f"{list1}")

# Listenin başına bir liste eklenmesi
list1[:0] = [-10, -11, -12]
print(f"{list1}")

# Listenin ortasına iki öğe eklenir
list1[3:3] = [100, 101]
print(f"{list1}")

# Listenin ortasındaki iki öğenin silinmesi
list1[3:4] = []
print(f"{list1}")

Notlar:

[i:j] notasyonu, tablonun i'den j-1'e kadar olan elemanlarını belirtir;
[i:] notasyonu, tablonun i ve sonraki elemanlarını ifade eder;
[:i] notasyonu, dizinin 0'dan i-1'e kadar olan elemanlarını belirtir;
1. satır: print (%s) % (list1) komutu şu karakter dizisini görüntüler: "[ list1[0], list1[2]…, list1[n-1]]";
1. satır: print ('f{list1}') ifadesi de aynı işlevi görür;

Sonuçlar


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_05.py
list1 a 6 éléments
list1[0]=0
list1[1]=1
list1[2]=2
list1[3]=3
list1[4]=4
list1[5]=5
list1 a 6 éléments
0
10
2
3
4
5
[0, 10, 2, 3, 4, 5, 10, 11]
[0, 10, 2, 3, 4, 5]
[-10, -11, -12, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 100, 101, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 101, 0, 10, 2, 3, 4, 5]

Process finished with exit code 0

3.6. [bases_06] betiği: listeler - 2

Yukarıdaki kod, listelerin bazı yöntemleri kullanılarak farklı bir şekilde (bases_06) yazılabilir:


# tek boyutlu listeler

# başlatma
list1 = [0, 1, 2, 3, 4, 5]

# dolaşma - 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
    print(f"list1[{i}]={list1[i]}")

# bir öğenin değiştirilmesi
list1[1] = 10

# dolaşma - 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
    print(element)

# iki öğenin eklenmesi
list1.extend([10, 11])
print(f"{list1}")

# son iki öğenin silinmesi
del list1[len(list1) - 2:]
print(f"{list1}")

# listenin başına bir tuple ekleme
for i in (-12, -11, -10):
    list1.insert(0, i)
print(f"{list1}")

# listenin ortasına ekleme
for i in (101, 100):
    list1.insert(3, i)
print(f"{list1}")

# listenin ortasından silme
del list1[3:4]
print(f"{list1}")

Elde edilen sonuçlar, önceki sürümdekiyle aynıdır.

3.7. [bases_07] komut dosyası: sözlük

[bases_07] komut dosyası, bazen ilişkisel dizi olarak da adlandırılan bir sözlüğün nasıl tanımlanıp kullanılacağını gösterir.


# "mari" anahtarının "conjoints" sözlüğünde mevcut olup olmadığını kontrol eden bir işlev
def existe(conjoints, mari):
    if mari in conjoints:
        print(f"La clé [{mari}] existe associée à la valeur [{conjoints[mari]}]")
    else:
        print(f"La clé [{mari}] n'existe pas")


# ----------------------------- Ana
# bir sözlük
conjoints = {"Pierre": "Gisèle", "Paul": "Virginie", "Jacques": "Lucette", "Jean": ""}

# tarama - 1
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
for (clé, valeur) in conjoints.items():
    print(f"conjoints[{clé}]={valeur}")

# sözlüğün anahtar listesi
print("liste des clés-------------")
clés = conjoints.keys()
print(f"{clés}")

# sözlüğün değer listesi
print("liste des valeurs------------")
valeurs = conjoints.values()
print(f"{valeurs}")

# anahtar arama
existe(conjoints, "Jacques")
existe(conjoints, "Lucette")
existe(conjoints, "Jean")

# bir anahtar-değer çiftinin silinmesi
del (conjoints["Jean"])
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
print(f"{conjoints}")

# sözlüğün anahtarları ve değerleri liste değildir
print(f"type des clés : {type(clés)}")
print(f"type des valeurs : {type(valeurs)}")

# bunlar listelere dönüştürülebilir
lclés = list(clés)
print(f"clés : {type(lclés)}, {lclés}")
lvaleurs = list(valeurs)
print(f"valeurs : {type(lvaleurs)}, {lvaleurs}")

Notlar:

1. satır: Bir sözlüğün sabit olarak tanımlanması;
1. satır: conjoints.items() işlevi, sözlüğün (anahtar, değer) çiftlerinden oluşan listeyi birleştirir;
1. satır: conjoints.keys() işlevi, sözlüğün anahtarlarını birleşik olarak döndürür;
1. satır: conjoints.values(), eşler sözlüğündeki değerleri döndürür;
1. satır: conjoints içindeki "mari" ifadesi, mari anahtarı conjoints sözlüğünde varsa True değerini, yoksa False değerini döndürür;
1. satır: Bir sözlük tek bir satırda görüntülenebilir.

Sonuçlar


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_07.py
Nombre d'éléments du dictionnaire : 4
conjoints[Pierre]=Gisèle
conjoints[Paul]=Virginie
conjoints[Jacques]=Lucette
conjoints[Jean]=
liste des clés-------------
dict_keys(['Pierre', 'Paul', 'Jacques', 'Jean'])
liste des valeurs------------
dict_values(['Gisèle', 'Virginie', 'Lucette', ''])
La clé [Jacques] existe associée à la valeur [Lucette]
La clé [Lucette] n'existe pas
La clé [Jean] existe associée à la valeur []
Nombre d'éléments du dictionnaire : 3
{'Pierre': 'Gisèle', 'Paul': 'Virginie', 'Jacques': 'Lucette'}
type des clés : <class 'dict_keys'>
type des valeurs : <class 'dict_values'>
clés : <class 'list'>, ['Pierre', 'Paul', 'Jacques']
valeurs : <class 'list'>, ['Gisèle', 'Virginie', 'Lucette']

Process finished with exit code 0

Notlar:

sonuçların 16-17. satırlarında, bir sözlüğün anahtarlarının ve değerlerinin bir liste değil, 'dict_keys' türü oluşturduğu görülmektedir;
18-19. satırlar: Basit bir tür değişikliği ile bunları '[list]' türüne dönüştürebiliriz;

3.8. [bases_08] komut dosyası: tuple'lar

Tuple, listeyle benzerlikler gösterir ancak değiştirilemez:


# tüpler
# başlatma
tuple1 = (0, 1, 2, 3, 4, 5)

# dolaşım - 1
print(f"tuple1 a {len(tuple1)} elements")
for i in range(len(tuple1)):
    print(f"tuple1[{i}]={tuple1[i]}")

# dolaşım - 2
print(f"tuple1 a {len(tuple1)} elements")
for element in tuple1:
    print(element)

# bir tuple tek satırda görüntülenebilir
print(f"tuple1={tuple1}")

# bir tuple değiştirilemez
tuple1[0] = 10

Sonuçlar


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_08.py
tuple1 a 6 elements
tuple1[0]=0
tuple1[1]=1
tuple1[2]=2
tuple1[3]=3
tuple1[4]=4
tuple1[5]=5
tuple1 a 6 elements
0
1
2
3
4
5
tuple1=(0, 1, 2, 3, 4, 5)
Traceback (most recent call last):
  File "C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_08.py", line 19, in <module>
    tuple1[0] = 10
TypeError: 'tuple' object does not support item assignment

Process finished with exit code 1

Notlar:

Sonuçların 17-20. satırları: bir tuple'ın değiştirilemeyeceğini gösterir.

3.9. [bases_09] komut dosyası: çok boyutlu listeler ve sözlükler

[bases_09] komut dosyası, çok boyutlu bir liste veya sözlüğün nasıl tanımlanıp kullanılacağını gösterir:


# çok boyutlu listeler
# başlatma
multi = [[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]]

# dolaşma
for i1 in range(len(multi)):
    for i2 in range(len(multi[i1])):
        print(f"multi[{i1}][{i2}]={multi[i1][i2]}")

# tek satırda görüntüleme
print(f"multi={multi}")

# çok boyutlu sözlükler
# başlatma
multi = {"zéro": [0, 1], "un": [10, 11, 12, 13], "deux": [20, 21, 22, 23, 24]}

# tarama
for (clé, valeur) in multi.items():
    for i2 in range(len(valeur)):
        print(f"multi[{clé}][{i2}]={multi[clé][i2]}")

# tek satırda görüntüleme
print(f"multi={multi}")

Açıklamalar

1. satır: multi[i1] bir listedir;
1. satır: valeur bir listedir;

Sonuçlar


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_09.py
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi=[[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]]
multi[zéro][0]=0
multi[zéro][1]=1
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24
multi={'zéro': [0, 1], 'un': [10, 11, 12, 13], 'deux': [20, 21, 22, 23, 24]}

Process finished with exit code 0

3.10. [bases_10] komut dosyası: dizeler ve listeler arasındaki bağlantılar

[bases_10] betiği, bir dizede aynı ayırıcıyla ayrılmış öğeleri bir listeye nasıl aktarılacağını gösterir.


# dizgiyi listeye dönüştürme
chaine = '1:2:3:4'
liste = chaine.split(':')
print(type(liste))

# liste görüntüleme
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")

# listeden dizgiye
chaine2 = ":".join(liste)
print(f"chaine2={chaine2}")

# boş bir alan ekleyelim
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")

# liste görüntüleme
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")

# tekrar boş bir alan ekleyelim
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")

# liste görüntüleme
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")

Notlar:

1. satır: chaine.split(ayırıcı) yöntemi, chaine karakter dizisini séparateur ile ayrılmış öğelere böler ve bunları liste biçiminde döndürür. Böylece '1:2:3:4'.split(":") ifadesinin değeri ('1','2','3','4') listesidir;
1. satır: 'ayırıcı'.join(liste) ifadesinin değeri, 'liste[0]+ayırıcı+liste[1]+ayırıcı+…' karakter dizisidir.

Sonuçlar


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_10.py
<class 'list'>
liste a 4 éléments
liste=['1', '2', '3', '4']
chaine2=1:2:3:4
chaine=1:2:3:4:
liste a 5 éléments
liste=['1', '2', '3', '4', '']
chaine=1:2:3:4::
liste a 6 éléments
liste=['1', '2', '3', '4', '', '']

Process finished with exit code 0

3.11. [bases_11] betiği: düzenli ifadeler

[bases_11] betiği, düzenli ifadelerin nasıl kullanıldığını gösterir:


# düzenli ifadeler modülünü içe aktarıyoruz
import re


# --------------------------------------------------------------------------
def compare(modèle, chaine):
    #, [chaîne] dizesini [modèle] şablonuyla karşılaştırır
    # sonuçları göster
    print(f"\nRésultats({chaine},{modèle})")
    match = re.match(modèle, chaine)
    if match:
        print(match.groups())
    else:
        print(f"La chaîne [{chaine}] ne correspond pas au modèle [{modèle}]")


# Python'da düzenli ifadeler
# bir dizeden farklı alanları alma
# şablon: herhangi bir karakterle çevrili bir sayı dizisi
# sadece sayı dizisini almak istiyoruz
modèle = r"^.*?(\d+).*?$"

# dizgiyi modelle karşılaştırıyoruz
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")

# şablon: herhangi bir karakterle çevrili bir sayı dizisi
# sayı dizisinin yanı sıra öncesindeki ve sonrasındaki alanları da almak istiyoruz
modèle = r"^(.*?)(\d+)(.*?)$"

# dizgiyi şablonla karşılaştırıyoruz
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")

# şablon - gg/aa/yy formatında bir tarih
modèle = r"^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$"
compare(modèle, "10/05/97")
compare(modèle, " 04/04/01 ")
compare(modèle, "5/1/01")

# şablon - ondalık sayı
modèle = r"^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$"
compare(modèle, "187.8")
compare(modèle, "-0.6")
compare(modèle, "4")
compare(modèle, ".6")
compare(modèle, "4.")
compare(modèle, " + 4")
# son

Notlar:

1. satırda içe aktarılan [re] modülüne dikkat edin. Düzenli ifadeleri yönetme işlevleri bu modülde bulunur;
1. satır: Bir dizenin bir düzenli ifadeyle (şablon) karşılaştırılması, dize şablona uyuyorsa True boole değerini, uymuyorsa False değerini döndürür;
1. satır: match.groups(), parantezlerle çevrili düzenli ifadenin öğelerine karşılık gelen dize parçalarından oluşan bir tuple'dır. Şablonda:
2. ^.*?(\d+).*?, match.groups() tek elemanlı bir tuple olacaktır çünkü bir parantez vardır;
3. ^(.*?)(\d+)(.*?)$ örneğinde, match.groups() üç parantez olduğu için 3 elemanlı bir tuple olacaktır;
1. satır: bir literal düzenli ifade r"xxx" şeklinde yazılır. Dizgiyi düzenli ifade haline getiren r sembolüdür;

Düzenli ifadeler, bir karakter dizesinin biçimini test etmemizi sağlar. Böylece, bir tarihi temsil eden dizgenin gg/aa/yy biçiminde olup olmadığını kontrol edebiliriz. Bunun için bir şablon kullanılır ve dize bu şablonla karşılaştırılır. Dolayısıyla bu örnekte, j, m ve a rakamlar olmalıdır. Geçerli bir tarih biçiminin şablonu "\d\d/\d\d/\d\d" şeklindedir; burada \d sembolü bir rakamı ifade eder. Şablonda kullanılabilecek semboller şunlardır:

Karakter	Açıklama
\	Bir sonraki karakteri özel karakter veya literal olarak işaretler. Örneğin, "n" "n" karakterine karşılık gelirken, "\n" yeni satır karakterine karşılık gelir. "\\" dizisi "\" karakterine, "\(" ise "(" karakterine karşılık gelir.
^	Dizenin başına karşılık gelir.
$	Dizenin sonuna karşılık gelir.
*	Önceki karakterle eşleşir; sıfır kez veya birden çok kez. Dolayısıyla, "zo*" hem "z" hem de "zoo" ile eşleşir.
+	Önceki karakterle, bir kez veya birden fazla kez eşleşir. Dolayısıyla, "zo+" "zoo" ile eşleşir, ancak "z" ile eşleşmez.
?	Önceki karakterle eşleşir; sıfır veya bir kez. Örneğin, "a?ve?" "lever" kelimesindeki "ve" ile eşleşir.
.	Satır başı karakteri hariç, herhangi bir tek karakterle eşleşir.
(şablon)	modèle'i arar ve eşleşmeyi saklar. Eşleşen alt dize, match.groups() koleksiyonundan çıkarılabilir. Parantez ( ) içindeki karakterlerle eşleşmeleri bulmak için "$" veya "$" kullanın.
x\|y	x veya y ile eşleşir. Örneğin, "z\|foot" correspond à "z" ou à "foot". "(z\|f)oo" "zoo" veya "foo" ile eşleşir.
{n}	n, negatif olmayan bir tamsayıdır. Tam olarak n çarpı karakter değerine karşılık gelir. Örneğin, "o{2}", "Bob," içindeki "o" harfine değil, "fooooot" içindeki ilk iki "o" harfine karşılık gelir.
{n,}	n, negatif olmayan bir tamsayıdır. Karakterin en az n katına karşılık gelir. Örneğin, "o{2,}" "Bob" kelimesindeki "o" harfine değil, "fooooot" kelimesindeki tüm "o" harflerine karşılık gelir. "o{1,}" "o+" ile eşdeğerdir ve "o{0,}" "o*" ile eşdeğerdir.
{n,m}	m ve n, negatif olmayan tamsayılardır. Karakterin en az n ve en fazla m kez tekrarlandığı durumlara karşılık gelir. Örneğin, "o{1,3}", "foooooot" kelimesindeki ilk üç "o" karakterine karşılık gelir ve "o{0,1}", "o?" ile eşdeğerdir.
[xyz]	Karakter kümesi. Belirtilen karakterlerden birine karşılık gelir. Örneğin, "[abc]", "plat" kelimesindeki "a" harfine karşılık gelir.
[^xyz]	Negatif karakter kümesi. Belirtilmeyen tüm karakterlere karşılık gelir. Örneğin, "[^abc]", "plat" kelimesindeki "p" harfine karşılık gelir.
[a-z]	Karakter aralığı. Belirtilen dizideki tüm karakterlere karşılık gelir. Örneğin, "[a-z]", "a" ile "z" arasındaki tüm küçük harf karakterlerine karşılık gelir.
[^m-z]	Negatif karakter aralığı. Belirtilen dizide bulunmayan tüm karakterlere karşılık gelir. Örneğin, "[^m-z]", "m" ile "z" arasında bulunmayan tüm karakterlere karşılık gelir.
\b	Bir kelimeyi temsil eden sınırla, başka bir deyişle bir kelime ile boşluk arasındaki konuma karşılık gelir. Örneğin, "er\b", "lever" kelimesindeki "er"e karşılık gelir, ancak "verbe" kelimesindeki "er"e karşılık gelmez.
\B	Bir kelimeyi temsil etmeyen bir sınırla eşleşir. "en*t\B", "bien entendu" kelimesindeki "ent" ile eşleşir.
\d	Bir rakamı temsil eden bir karaktere karşılık gelir. [0-9] ile eşdeğerdir.
\D	Rakam olmayan bir karaktere karşılık gelir. [^0-9] ile eşdeğerdir.
\f	Sayfa sonu karakterine karşılık gelir.
\n	Satır sonu karakterine karşılık gelir.
\r	Satır başı karakterine karşılık gelir.
\s	Boşluk, sekme, sayfa sonu vb. dahil olmak üzere tüm boşluk karakterlerine karşılık gelir. "[ \f\n\r\t\v]" ile eşdeğerdir.
\S	Beyaz olmayan tüm boşluk karakterlerine karşılık gelir. "[^ \f\n\r\t\v]" ile eşdeğerdir.
\t	Bir sekme karakterine karşılık gelir.
\v	Dikey sekme karakterine karşılık gelir.
\w	Bir kelimeyi temsil eden ve alt çizgi içeren herhangi bir karaktere karşılık gelir. "[A-Za-z0-9_]" ile eşdeğerdir.
\W	Bir kelimeyi temsil etmeyen herhangi bir karaktere karşılık gelir. "[^A-Za-z0-9_]" ile eşdeğerdir.
\num	num'e karşılık gelir; burada num pozitif bir tamsayıdır. Kaydedilmiş eşleşmelere atıfta bulunur. Örneğin, "(.)\1" iki ardışık aynı karaktere karşılık gelir.
\n	n'e karşılık gelir; burada n sekizlik bir kaçış değeridir. Sekizlik kaçış değerleri 1, 2 veya 3 basamaklı olmalıdır. Örneğin, "\11" ve "\011" her ikisi de bir sekme karakterine karşılık gelir. "\0011", "\001" ve "1"e eşittir. Sekizlik kaçış değerleri 256'yı aşmamalıdır. Aşılması durumunda, ifadede yalnızca ilk iki rakam dikkate alınır. ASCII kodlarının düzenli ifadelerde kullanılmasına olanak tanır.
\xn	n'e karşılık gelir; burada n onaltılık bir kaçış değeridir. Onaltılık kaçış değerleri mutlaka iki basamaklı olmalıdır. Örneğin, "\x41" "A" harfine karşılık gelir. "\x041" ise "\x04" ve "1" değerlerinin birleşimine eşittir. ASCII kodlarının düzenli ifadelerde kullanılmasına izin verir.

Bir şablondaki öğe, 1 veya daha fazla kopya halinde bulunabilir. 1 rakamı temsil eden \d sembolüyle ilgili birkaç örneği inceleyelim:

şablon	anlam
\d	bir rakam
\d?	0 veya 1 rakam
\d*	0 veya daha fazla rakam
\d+	1 veya daha fazla rakam
\d{2}	2 rakam
\d{3,}	en az 3 rakam
\d{5,7}	5 ile 7 arasında rakam

Şimdi, bir karakter dizisi için beklenen biçimi tanımlayabilen bir model düşünelim:

aranan dize	model
gg/mm/yy biçiminde bir tarih	\d{2}/\d{2}/\d{2}
hh:mm:ss biçiminde bir saat	\d{2}:\d{2}:\d{2}
işaretsiz bir tamsayı	\d+
boş olabilir bir boşluk dizisi	\s*
önünde veya arkasında boşluk bulunabilen işaretsiz bir tamsayı	\s\d+\s
işareti olan veya olmayan bir tamsayı; başında veya sonunda boşluk olabilir	\*s[+\|-]*?\s\d+\s*
önünde veya arkasında boşluk bulunabilen işaretsiz bir gerçek sayı	\s\d+(.\d)?\s*
işareti olan veya olmayan bir gerçek sayı; başında veya sonunda boşluk olabilir	\*s[+-]*?\s\d+(.\d)?\s
"juste" kelimesini içeren bir dize	\bjuste\b

Dizgide kalıbın nerede aranacağını belirtebiliriz:

desen	anlam
^örnek	model, dizginin başında yer alır
model$	şablon dizgiyi sonlandırır
^desen$	şablon dizgiyi başlatır ve bitirir
desen	desen, dizgenin başından başlayarak her yerinde aranır.

aranan dize	desen
ünlem işaretiyle biten bir dize	!$
nokta ile biten bir dize	\.$
// dizisiyle başlayan bir dize	^//
yalnızca bir kelimeden oluşan ve isteğe bağlı olarak öncesinde veya sonrasında boşluklar bulunan bir dize	^\s\w+\s$
önünde veya arkasında boşluk olabilecek iki kelimeden oluşan bir dize	^\s\w+\s\w+\s*$
"secret" kelimesini içeren bir dize	\bsecret\b

Bir şablonun alt kümeleri "çıkarılabilir". Böylece, bir dizgenin belirli bir şablona uyup uymadığını kontrol etmekle kalmaz, aynı zamanda bu dizgede parantezlerle çevrelenmiş şablonun alt kümelerine karşılık gelen öğeleri de çıkarabiliriz. Örneğin, gg/aa/yyyy tarihini içeren bir dizgiyi analiz ediyorsak ve bu tarihin gg, aa, yyyy öğelerini de ayıklamak istiyorsak, (\d\d)/(\d\d)/(\d\d) şablonunu kullanırız.

Komut dosyasının sonuçları


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_11.py

Résultats(xyz1234abcd,^.*?(\d+).*?$)
('1234',)

Résultats(12 34,^.*?(\d+).*?$)
('12',)

Résultats(abcd,^.*?(\d+).*?$)
La chaîne [abcd] ne correspond pas au modèle [^.*?(\d+).*?$]

Résultats(xyz1234abcd,^(.*?)(\d+)(.*?)$)
('xyz', '1234', 'abcd')

Résultats(12 34,^(.*?)(\d+)(.*?)$)
('', '12', ' 34')

Résultats(abcd,^(.*?)(\d+)(.*?)$)
La chaîne [abcd] ne correspond pas au modèle [^(.*?)(\d+)(.*?)$]

Résultats(10/05/97,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('10', '05', '97')

Résultats( 04/04/01 ,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('04', '04', '01')

Résultats(5/1/01,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
La chaîne [5/1/01] ne correspond pas au modèle [^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$]

Résultats(187.8,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '187.8')

Résultats(-0.6,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('-', '0.6')

Résultats(4,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4')

Résultats(.6,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '.6')

Résultats(4.,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4.')

Résultats( + 4,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('+', '4')

Process finished with exit code 0