3. Temel bilgiler

3.1. Bir Python programı örneği

Aşağıda, Python'un temel özelliklerini gösteren bir program yer almaktadır.

Program (bases_01)


# -*- coding=utf-8 -*-

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


# ----------------------------------
def afficheType(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ğer döndürür
    return ("un",0,100);


# -------------------------------- ana program ------------------------------------
# bu bir açıklamadır
# 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
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# bir değişkenin türü çalışma sırasında değişebilir
n="a change"
afficheType(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+t[i]
    i+=1 #i=i+1
print "somme=%s" % (somme)
# program sonu

Not:

1. satır: Komut dosyasının kodlama türünü belirtmeye yarayan özel bir yorum satırı; burada UTF-8. Bu, kullanılan metin düzenleyicisine bağlıdır. Burada Notepad++ ile:

1. satır: def anahtar sözcüğü bir işlevi tanımlar;
5-6. 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: 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, betikteki 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: "xxxx%syyyy%szzzz" % (100, 200) ifadesi, her bir %s'nin tuple'daki bir elemanla değiştirildiği "xxxx100yyy200szzzz" karakter dizisidir. %s, karakter dizilerinin görüntülenme biçimidir. Başka biçimler de mevcuttur;
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;
1. satır: range(n), (0,1,2,...,n-1) tuple'ıdır;
1. satır: len(var), var koleksiyonunun (tuple, liste, sözlük, ...) eleman sayısıdır;
satır 86: diğer Boole operatörleri or ve not'tir.

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

nom=dupont
liste[0]=un
liste[1]=deux
liste[2]=3
liste[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=<type 'int'>
type[chaine1]=<type 'str'>
type[['un', 'deux', 3, 4]]=<type 'list'>
type[a change]=<type '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

3.2. Tür Değişiklikleri

Burada str (karakter dizisi), int (tamsayı), float (kesirli sayı), bool (boole) türündeki verilerle yapılan tür dönüşümleri ele alınmaktadır.

Program (bases_01b)


# -*- coding=utf-8 -*-

# tip 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)

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

# boolean ile ilgili ç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)

Çok sayıda tür dönüşümü mümkündür. Bazıları başarısız olabilir; örneğin, 45-49. 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, Message:
    actions
finally:
    actions

Try bloğundaki işlemlerden herhangi biri bir istisna oluşturursa (hata bildirirse), hemen except bloğuna geçilir. Try bloğundaki işlemler istisna oluşturmazsa, except bloğu yok sayılır. except deyimindeki Exception ve Message öznitelikleri isteğe bağlıdır. Bu öznitelikler mevcut olduğunda, Exception, except komutu tarafından yakalanan istisna türünü belirtir ve Message, istisna ile ilgili hata mesajını 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 komutundaki eylemler her zaman yürütülür.

İstisnalara biraz ileride tekrar değineceğiz.

52-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 dizge) işlevi, dizge 0 karakterden oluşuyorsa False değerini, diğer tüm durumlarda ise True değerini verir;
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:

4 <type 'int'>
4 <type 'str'>
4.0 <type 'float'>
True <type 'bool'>
True <type 'bool'>
1 <type 'int'>
1.0 <type 'float'>
True <type 'str'>
4 <type 'str'>
4 <type 'int'>
4.0 <type 'float'>
True <type 'bool'>
4.32 <type 'float'>
4.32 <type 'str'>
4 <type 'int'>
True <type 'bool'>
invalid literal for int() with base 10: 'abc'
True <type 'bool'>
False <type 'bool'>
False <type 'bool'>
None <type 'NoneType'>
False <type 'bool'>
False <type 'bool'>

3.3. Değişkenlerin kapsamı

Program (bases_02)


# -*- coding=utf-8 -*-

# değişkenlerin kapsamı
def f1():
    # i küresel değişkeni kullanılır
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # i küresel değişkeni kullanıyoruz
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # yerel i değişkeni kullanılıyor
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# testler
i=0
j=0 # bu iki değişken, f işlevi tarafından bilinmez
    # f işlevi, global komutuyla bunları açıkça bildirmedikçe
    # bu değişkenleri kullanmak istediğini açıkça belirtirse
f1()
f2()
f3()
print "test[i,j]=[%s,%s]" % (i,j)

Sonuçlar

f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[1,30]
test[i,j]=[2,0]

Notlar:

Bu betik, f1 ve f2 fonksiyonlarında global olarak tanımlanan i değişkeninin kullanımını göstermektedir. Bu durumda, ana program ile f1 ve f2 fonksiyonları aynı i değişkenini paylaşmaktadır.

3.4. Listeler, tuple'lar ve sözlükler

3.4.1. Tek boyutlu listeler

Program (bases_03)


# -*- coding=utf-8 -*-

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

# dolaşım - 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10;
# tarama - 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# iki elemanın eklenmesi
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# son iki öğenin silinmesi
list1[len(list1)-2:]=[]
print ("%s") % (list1)

# listenin başına bir tuple ekleme
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# listenin ortasına iki öğe ekleme
list1[3:3]=[100,101]
print ("%s") % (list1)

# listenin ortasından iki öğenin silinmesi
list1[3:4]=[]
print ("%s") % (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, tablonun 0'dan i-1'e kadar olan elemanlarını belirtir;
1. satır: print (%s) % (list1) şu karakter dizisini görüntüler: "[ list1[0], list1[2], ..., list1[n-1]]".

Sonuçlar

list1 a 6 elements
list1[0]=0
list1[1]=1
list1[2]=2
list1[3]=3
list1[4]=4
list1[5]=5
list1 a 6 elements
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]

Yukarıdaki kod, listelerle ilgili bazı yöntemler kullanılarak farklı bir şekilde (bases_03b) yazılabilir:


# -*- coding=utf-8 -*-

# tek boyutlu listeler

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

# dolaşma - 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10
# dolaşma - 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# iki öğenin eklenmesi
list1.extend([10,11])
print ("%s") % (list1)

# son iki öğenin silinmesi
del list1[len(list1)-2:]
print ("%s") % (list1)

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

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

# listenin ortasından silme
del list1[3:4]
print ("%s") % (list1)

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

3.4.2. Sözlük

Program (bases_04)


# -*- coding=utf-8 -*-

def existe(conjoints,mari):
    # "mari" anahtarının "conjoints" sözlüğünde mevcut olup olmadığını kontrol eder
    if(conjoints.has_key(mari)):
        print "La cle [%s] existe associee a la valeur [%s]" % (mari, conjoints[mari])
    else:
        print "La cle [%s] n'existe pas" % (mari)


# ----------------------------- Ana
# sözlükler
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

# tarama - 1
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
for (cle,valeur) in conjoints.items():
    print "conjoints[%s]=%s" % (cle,valeur)

# sözlük anahtarları listesi
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

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

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

# anahtar-değer silme
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

Notlar:

1. satır: conjoints.items() işlevi, sözlüğün (anahtar, değer) çiftlerinin listesini birleştirir;
1. satır: conjoints.keys() işlevi, conjoints sözlüğünün anahtarlarını döndürür;
1. satır: conjoints.values(), eşler sözlüğündeki değerleri döndürür;
1. satır: conjoints.has_key(mari), mari anahtarı conjoints sözlüğünde mevcutsa True değerini döndürür, aksi takdirde False değerini döndürür;
1. satır: Bir sözlük tek bir satırda görüntülenebilir.

Sonuçlar

Nombre d'elements du dictionnaire : 4
conjoints[Paul]=Virginie
conjoints[Jean]=
conjoints[Pierre]=Gisele
conjoints[Jacques]=Lucette
liste des cles-------------
['Paul', 'Jean', 'Pierre', 'Jacques']
liste des valeurs------------
['Virginie', '', 'Gisele', 'Lucette']
La cle [Jacques] existe associee a la valeur [Lucette]
La cle [Lucette] n'existe pas
La cle [Jean] existe associee a la valeur []
Nombre d'elements du dictionnaire : 3
{'Paul': 'Virginie', 'Pierre': 'Gisele', 'Jacques': 'Lucette'}

3.4.3. Tuple'lar

Program (bases_05)


# -*- coding=utf-8 -*-

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

# dolaşım - 1
print "tab1 a %s elements" % (len(tab1))
for i in range(len(tab1)):
    print "tab1[%s]=%s" % (i, tab1[i])

# dolaşım - 2
print "tab1 a %s elements" % (len(tab1))
for element in tab1:
    print element

# bir öğenin değiştirilmesi
tab1[0]=-1

Sonuçlar

tab1 a 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 6 elements
0
1
2
3
4
5
Traceback (most recent call last):
  File "exemple_05.py", line 18, in <module>
    tab1[0]=-1
TypeError: 'tuple' object does not support item assignment

Notlar:

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

3.4.4. Çok boyutlu listeler

Program (bases_06)


# -*- coding=utf-8 -*-

# çok boyutlu listeler

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

# tarama
for i1 in range(len(multi)):
    for i2 in range(len(multi[i1])):
        print "multi[%s][%s]=%s" % (i1,i2,multi[i1][i2])

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

# tarama
for (cle,valeur) in multi.items():
    for i2 in range(len(multi[cle])):
        print "multi[%s][%s]=%s" % (cle,i2,multi[cle][i2])

Sonuçlar

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[zero][0]=0
multi[zero][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

3.4.5. Zincirler ve listeler arasındaki bağlantılar

Program (bases_07)


# -*- coding=Utf-8 -*-

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

# liste görüntüleme
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# listeden dizgiye
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

# boş bir alan ekleyelim
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# listeyi görüntüleme
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# tekrar boş bir alan ekleyelim
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# listeyi görüntüle
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

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: 'separateur'.join(liste)'in değeri, 'liste[0]+ayırıcı+liste[1]+ayırıcı+...' karakter dizisidir.

Sonuçlar

<type 'list'>
tab a 4 elements
['1', '2', '3', '4']
chaine2=1:2:3:4
chaine=1:2:3:4:
tab a 5 elements
['1', '2', '3', '4', '']
chaine=1:2:3:4::
tab a 6 elements
['1', '2', '3', '4', '', '']

3.5. Düzenli ifadeler

Program (bases_09)


# -*- coding=utf-8 -*-

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    # dizgiyi şablonla karşılaştır
    # sonuçları görüntüle
    print "\nResultats(%s,%s)" % (chaine,modele)
    match=re.match(modele,chaine)
    if match:
        print match.groups()
    else:
        print "La chaine [%s] ne correspond pas au modele [%s]" % (chaine,modele)


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

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

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

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

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

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

Notlar:

1. satırda içe aktarılan modüle dikkat edin. Düzenli ifadelerin yönetimine ilişkin işlevler 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:
^.*?(\d+).*? ise, match.groups() tek elemanlı bir tuple olacaktır;
^(.*?)(\d+)(.*?)$ örneğinde, match.groups() üç elemanlı bir tuple olacaktır.

Sonuçlar

Resultats(xyz1234abcd,^.*?(\d+).*?$)
('1234',)

Resultats(12 34,^.*?(\d+).*?$)
('12',)

Resultats(abcd,^.*?(\d+).*?$)
La chaine [abcd] ne correspond pas au modele [^.*?(\d+).*?$]

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

Resultats(12 34,^(.*?)(\d+)(.*?)$)
('', '12', ' 34')

Resultats(abcd,^(.*?)(\d+)(.*?)$)
La chaine [abcd] ne correspond pas au modele [^(.*?)(\d+)(.*?)$]

Resultats(10/05/97,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('10', '05', '97')

Resultats( 04/04/01 ,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('04', '04', '01')

Resultats(5/1/01,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
La chaine [5/1/01] ne correspond pas au modele [^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$]

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

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

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

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

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

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

3.6. Fonksiyon parametrelerinin aktarım şekli

Program (bases_10)


# -*- coding=utf-8 -*-

def f1(a):
    a=2

def f2(a,b):
    a=2
    b=3
    return (a,b)
  
# ------------------------ ana
x=1
f1(x)
print "x=%s" % (x)
(x,y)=(-1,-1)
(x,y)=f2(x,y)
print "x=%s, y=%s" % (x,y)

Sonuçlar

1 2	`x=1 x=2, y=3`

Notlar:

Python'da her şey bir nesnedir. Bazı nesneler "değiştirilemez" olarak adlandırılır: bunlar değiştirilemez. Sayılar, karakter dizileri ve tuple'lar bu kategoriye girer. Python nesneleri fonksiyonlara parametre olarak aktarıldığında, bu nesneler "değiştirilemez" olmadıkça referansları aktarılır; "değiştirilemez" nesneler söz konusu olduğunda ise nesnenin değeri aktarılır;
f1 (satır 3) ve f2 (satır 6) fonksiyonları, bir çıktı parametresinin aktarımını göstermeyi amaçlamaktadır. Bir fonksiyonun gerçek parametresinin fonksiyon tarafından değiştirilmesini istiyoruz;
3-4. satırlar: f1 işlevi, a adlı biçimsel parametresini değiştirir. Gerçek parametrenin de değiştirilip değiştirilmeyeceğini öğrenmek istiyoruz.
satır 12-13: gerçek parametre x=1'tir. Satır 1'deki sonuç, gerçek parametrenin değiştirilmediğini göstermektedir. Dolayısıyla, gerçek parametre x ile biçimsel parametre a birbirinden farklı iki nesnedir;
6-9. satırlar: f2 fonksiyonu, biçimsel parametreleri a ve b'yi değiştirir ve bunları sonuç olarak döndürür;
15-16. satırlar: f2 işlevine gerçek parametreler (x, y) aktarılır ve f2 işlevinin sonucu (x, y) nesnesine atanır. Sonuçların 2. satırı, gerçek parametrelerin (x, y) değiştirildiğini göstermektedir.

Buradan şu sonuç çıkar: "değiştirilemez" nesneler çıktı parametreleri olduğunda, bunların fonksiyon tarafından döndürülen sonuçların bir parçası olması gerekir.

3.7. Metin dosyaları

Program (bases_11)


# -*- coding=utf-8 -*-

import sys

# bir metin dosyasının sıralı işlenmesi
# bu, login:pwd:uid:gid:infos:dir:shell biçiminde bir dizi satırdır
# her satır, bir sözlükte login => [uid,gid,infos,dir,shell] biçiminde saklanır

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # sözlükte anahtara karşılık gelen değer varsa bunu görüntüler
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # anahtar, dico sözlüğünde bulunan bir anahtar değildir
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # varsa satır sonu işaretini siler
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# dosya adı belirlenir
INFOS="infos.txt"

# dosya yeni oluşturulurken açılır
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# rastgele bir içerik oluşturulur
for i in range(1,101):
    ligne="login%s:pwd%s:uid%s:gid%s:infos%s:dir%s:shell%s" % (i,i,i,i,i,i,i)
    fic.write(ligne+"\n")

# dosya kapatılır
fic.close()

# dosyayı okuma modunda açıyoruz
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# başlangıçta boş sözlük
dico={}

# satır okunur  
ligne=fic.readline()  
while(ligne!=''):
    # satır sonu karakteri kaldırılır
    ligne=cutNewLineChar(ligne)
  
    # satırı bir tabloya ekleniyor
    infos=ligne.split(":")
  
    # kullanıcı adı alınır
    login=infos[0]
  
    # ilk iki öğeyi kaldırıyoruz [login,pwd]
    infos[0:2]=[]
  
    # sözlüğe bir giriş oluşturulur
    dico[login]=infos
  
    # satırı okur  
    ligne=fic.readline()  

# dosyayı kapatıyoruz
fic.close()

# sözlüğü işleme
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Notlar:

1. satır: komut dosyasını kodun ortasında sonlandırmak için.

Sonuçlar

infos.txt dosyası:

login0:pwd0:uid0:gid0:infos0:dir0:shell0
login1:pwd1:uid1:gid1:infos1:dir1:shell1
login2:pwd2:uid2:gid2:infos2:dir2:shell2
...
login98:pwd98:uid98:gid98:infos98:dir98:shell98
login99:pwd99:uid99:gid99:infos99:dir99:shell99

Ekran sonuçları:

1 2	`[login10,uid10:gid10:infos10:dir10:shell10] la cle [X] n'existe pas`