Skip to content

3. مبانی

  

3.1. یک برنامه نمونه پایتون

در زیر برنامه‌ای که ویژگی‌های پایه‌ای پایتون را نشان می‌دهد، آورده شده است.

برنامه (bases_01)

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

# ----------------------------------
def affiche(chaine):
    #یک رشته را نمایش می‌دهد
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(variable):
    # نوع متغیر را نمایش می‌دهد
    print "type[%s]=%s" % (variable,type(variable))

# ----------------------------------
def f1(param):
    # ده به param اضافه می‌کند
    return param+10

# ----------------------------------
def f2():
    # ۳ مقدار بازمی‌گرداند
    return ("un",0,100);


# -------------------------------- برنامه اصلی ------------------------------------
# این یک نظر است
# متغیر بدون اعلام شدن استفاده شده
nom="dupont"

# یک نمایش صفحه
print "nom=%s" % (nom)

# یک لیست حاوی عناصری با انواع مختلف
liste=["un","deux",3,4]

# تعداد عناصر آن
n=len(liste)

#یک حلقه
for i in range(n):
  print "liste[%d]=%s" % (i,liste[i])

# ابتدایی‌سازی دو متغیر با یک تپل
(chaine1,chaine2)=("chaine1","chaine2")

#الحاق دو رشته
chaine3=chaine1+chaine2

# نمایش نتیجه
print "[%s,%s,%s]" % (chaine1,chaine2,chaine3)

# استفاده از یک تابع
affiche(chaine1)

# نوع یک متغیر ممکن است مشخص باشد
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# نوع یک متغیر می‌تواند در زمان اجرا تغییر کند
n="a change"
afficheType(n)

# یک تابع می‌تواند یک نتیجه بازگرداند
res1=f1(4)
print "res1=%s" % (res1)

#یک تابع می‌تواند یک لیست از مقادیر را بازگرداند
(res1,res2,res3)=f2()
print "(res1,res2,res3)=[%s,%s,%s]" % (res1,res2,res3)

#این مقادیر می‌توانستند در یک متغیر ذخیره شده باشند
liste=f2()
for i in range(len(liste)):
    print "liste[%s]=%s" % (i, liste[i])

# آزمایش‌ها
for i in range(len(liste)):
    # فقط رشته‌ها را نمایش می‌دهد
    if (type(liste[i])=="str"):
        print "liste[%s]=%s" % (i,liste[i])

# آزمایش‌های بیشتر
for i in range(len(liste)):
    # فقط اعداد صحیح بزرگ‌تر از ۱۰ را نمایش می‌دهد
    if (type(liste[i])=="int" and liste[i]>10):
        print "liste[%s]=%s" % (i,liste[i])

#یک حلقه while
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] #sum = sum + t[i]
    i+=1 #i = i + 1
print "somme=%s" % (somme)
# پایان برنامه

لطفاً توجه داشته باشید:

  • خط ۱: یک نظر ویژه برای اعلام نوع رمزگذاری اسکریپت، در این مورد UTF-8. این بستگی به ویرایشگر متنی مورد استفاده دارد. در اینجا با استفاده از Notepad++:
 
  • خط ۴: کلمه کلیدی **def** یک تابع را تعریف می‌کند؛
  • خطوط ۵–۶: بدنه تابع. این بخش با یک تَب به سمت راست جابجا شده است. این جابجایی، در ترکیب با کاراکتر «:» در دستور def، بدنه تابع را تعریف می‌کند. این موضوع برای تمام دستورات دارای بدنه صدق می‌کند: if، else، while، for، try، except؛
  • خط ۱۲: پایتون انواع متغیرها را به صورت داخلی مدیریت می‌کند. شما می‌توانید نوع یک متغیر را با استفاده از تابع type(variable) تعیین کنید، که یک متغیر از نوع 'type' را برمی‌گرداند. عبارت '%s' % (type(variable)) یک رشته است که نوع متغیر را نشان می‌دهد؛
  • خط ۲۵: برنامه اصلی. این بخش پس از تعریف تمام توابع اسکریپت قرار دارد. محتوای آن با فاصله شروع نمی‌شود؛
  • خط ۲۸: در پایتون نیازی به اعلام متغیرها نیست. پایتون به حروف بزرگ و کوچک حساس است. متغیر Nom با متغیر nom متفاوت است. یک رشته می‌تواند در گیومهٔ دوبل " یا گیومهٔ تکی ' قرار گیرد. بنابراین می‌توانید بنویسید 'dupont' یا "dupont";
  • خط ۳۱: عبارت "xxxx%syyyy%szzzz" % (100, 200) رشته "xxxx100yyy200szzzz" است، که در آن هر %s با یکی از عناصر تپل جایگزین شده است. %s قالب نمایش برای رشته‌ها است. قالب‌های دیگری نیز وجود دارند؛
  • خط ۳۴: بین یک تپل (1,2,3) (توجه کنید به پرانتزهای گرد) و یک لیست [1,2,3] (توجه کنید به کروشه‌های مربعی) تفاوت وجود دارد. یک تپل (tuple) غیرقابل تغییر است، در حالی که یک لیست (list) قابل تغییر است. در هر دو مورد، عدد i که نشان‌دهنده عنصر است با [i] نمایش داده می‌شود؛
  • خط ۴۰: range(n) تپل (0,1,2,...,n-1) است؛
  • خط ۷۴: len(var) تعداد عناصر در مجموعه var (تُپل، لیست، دیکشنری و غیره) است؛
  • خط ۸۶: سایر عملگرهای بولی or و not هستند.

خروجی صفحه به شرح زیر است:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
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. تبدیل انواع

در اینجا به تبدیل‌های نوع مربوط به داده‌های از نوع str (رشته کاراکتری)، int (پوره)، float (ممیز شناور) و bool (منطقی) می‌پردازیم.

برنامه (bases_01b)

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

#تبدیل انواع
# 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)

# مدیریت خطاهای تبدیل نوع
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# موارد مختلف مربوط به بولین‌ها
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)

تبدیل‌های نوع مختلف زیادی ممکن است. برخی ممکن است ناموفق باشند، مانند موارد در خطوط ۴۵–۴۹ که تلاش می‌کنند رشته 'abc' را به یک عدد صحیح تبدیل کنند. ما این خطا را با استفاده از ساختاری به نام try / except مدیریت کرده‌ایم. شکل کلی این ساختار به شرح زیر است:


try:
    actions
except Exception, Message:
    actions
finally:
    actions

اگر هر یک از عملیات‌های درون بلوک try استثناء‌ای پرتاب کنند (نشان‌دهنده خطا)، کنترل بلافاصله به بند **except می‌پرد. اگر عملیات‌های درون بلوک try استثناء‌ای پرتاب نکنند، بند except** نادیده گرفته می‌شود. ویژگی‌های Exception و Message در دستور except اختیاری هستند. وقتی وجود داشته باشد، Exception نوع استثنایی را که توسط دستور except مهار شده است مشخص می‌کند، و Message حاوی پیام خطای مرتبط با استثنا است. ممکن است چندین دستور except وجود داشته باشد اگر بخواهید انواع مختلف استثنا را در همان try مدیریت کنید.

دستور finally اختیاری است. اگر این دستور وجود داشته باشد، عملیات در finally همیشه اجرا می‌شوند، صرف‌نظر از اینکه آیا استثنایی رخ داده است یا خیر.

ما کمی بعد به موضوع استثناها باز خواهیم گشت.

خطوط ۵۲ تا ۶۱ تلاش‌های مختلفی را برای تبدیل داده‌های انواع str، int، float و NoneType به بولین نشان می‌دهند. این کار همیشه امکان‌پذیر است. قوانین به شرح زیر است:

  • bool(int i) برابر با False است اگر i برابر 0 باشد، و در غیر این صورت برابر با True است؛
  • bool(float f) برابر False است اگر f برابر 0.0 باشد، و در سایر موارد برابر True است؛
  • bool(str string) مقدار False را در صورتی که رشته دارای 0 کاراکتر باشد، و مقدار True را در سایر موارد برمی‌گرداند؛
  • bool(None) مقدار False را برمی‌گرداند. None یک مقدار ویژه است که به معنای وجود متغیر اما بدون مقدار بودن آن است.

خروجی صفحه به شرح زیر است:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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. دامنه متغیرها

برنامه (bases_02)

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

# دامنه متغیر
def f1():
    # متغیر سراسری i استفاده می‌شود
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # استفاده از متغیر سراسری i
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # استفاده از متغیر محلی i
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# آزمایش‌ها
i=0
j=0 # این دو متغیر برای تابع f ناشناخته‌اند
    # مگر اینکه صراحتاً آن‌ها را با دستور `global` اعلام کند
    # که می‌خواهد از آن‌ها استفاده کند
f1()
f2()
f3()
print "test[i,j]=[%s,%s]" % (i,j)

نتایج

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

یادداشت‌ها:

  • اسکریپت استفاده از متغیر i را که در توابع f1 و f2 به صورت سراسری (global) اعلام شده است، نشان می‌دهد. در این مورد، برنامه اصلی و توابع f1 و f2 از یک متغیر i مشترک استفاده می‌کنند.

3.4. فهرست‌ها، تپل‌ها و فرهنگ‌ها

3.4.1. آرایه‌های یک‌بعدی

برنامه (bases_03)

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

# فهرست‌های یک‌بعدی
# ابتدایی‌سازی
list1=[0,1,2,3,4,5]

# تکرار – ۱
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10;
# تکرار – ۲
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# افزودن دو عنصر
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# حذف دو عنصر آخر
list1[len(list1)-2:]=[]
print ("%s") % (list1)

#افزودن یک تپل به ابتدای لیست
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# افزودن دو عنصر در وسط لیست
list1[3:3]=[100,101]
print ("%s") % (list1)

# حذف دو عنصر از وسط لیست
list1[3:4]=[]
print ("%s") % (list1)

نکات:

  • نشانه‌گذاری array[i:j] به عناصر i تا j-1 آرایه اشاره دارد؛
  • نشانه‌گذاری [i:] نشان‌دهنده عناصر از i به بعد در آرایه است؛
  • علامت [:i] به عناصر 0 تا i-1 آرایه اشاره دارد؛
  • خط ۲۰: print (%s) % (list1) رشتهٔ کاراکتری را نمایش می‌دهد: "[ list1[0], list1[2], ..., list1[n-1]]".

نتایج

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
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]

کد بالا را می‌توان با استفاده از برخی متدهای لیست به صورت متفاوت نوشت (bases_03b):


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

# لیست‌های یک‌بعدی

# ابتدایی‌سازی
list1=[0,1,2,3,4,5]

# تکرار – ۱
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10
# تکرار – ۲
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# افزودن دو عنصر
list1.extend([10,11])
print ("%s") % (list1)

# حذف دو عنصر آخر
del list1[len(list1)-2:]
print ("%s") % (list1)

#افزودن یک تپل به ابتدای لیست
for i in (-12, -11, -10):
    list1.insert(0,i)
print ("%s") % (list1)

# افزودن در وسط لیست
for i in (101,100):
    list1.insert(3,i)
print ("%s") % (list1)

# حذف از وسط لیست
del list1[3:4]
print ("%s") % (list1)

نتایج به‌دست‌آمده با نسخه قبلی یکسان است.

3.4.2. واژه‌نامه

برنامه (bases_04)

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

def existe(conjoints,mari):
    #بررسی می‌کند که آیا کلید 'mari' در دیکشنری 'conjoints' وجود دارد یا خیر
    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)


# ----------------------------- اصلی
# واژه‌نامه‌ها
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

# تکرار - ۱
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
for (cle,valeur) in conjoints.items():
    print "conjoints[%s]=%s" % (cle,valeur)

# فهرست کلیدهای فرهنگ لغت
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

#فهرست مقادیر فرهنگ لغت
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (valeurs)

# جستجو برای یک کلید
existe(conjoints,"Jacques")
existe(conjoints,"Lucette")
existe(conjoints,"Jean")

#حذف یک جفت کلید-مقدار
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

یادداشت‌ها:

  • خط ۱۷: conjoints.items() لیست جفت‌های (کلید، مقدار) دیکشنری را به صورت تپل‌ها بازمی‌گرداند؛
  • خط ۲۲: conjoints.keys() کلیدهای فرهنگ لغت conjoints را برمی‌گرداند؛
  • خط ۲۷: conjoints.values() مقادیر فرهنگ لغت «conjoints» را برمی‌گرداند؛
  • خط ۷: conjoints.has_key(husband) مقدار True را در صورتی بازمی‌گرداند که کلید mari در فرهنگ لغت conjoints وجود داشته باشد، در غیر این صورت False را بازمی‌گرداند؛
  • خط ۳۸: یک فرهنگ لغت می‌تواند در یک خط نمایش داده شود.
نتایج
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
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. تُپل‌ها

برنامه (bases_05)

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

# تُپل‌ها
# ابتدایی‌سازی
tab1=(0,1,2,3,4,5)

# تکرار - ۱
print "tab1 a %s elements" % (len(tab1))
for i in range(len(tab1)):
    print "tab1[%s]=%s" % (i, tab1[i])

# تکرار - ۲
print "tab1 a %s elements" % (len(tab1))
for element in tab1:
    print element

# تغییر یک عنصر
tab1[0]=-1

نتایج
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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

یادداشت‌ها:

  • خطوط ۱۵–۱۸ نتایج: نشان می‌دهند که یک تپل قابل تغییر نیست.

3.4.4. فهرست‌های چندبعدی

برنامه (bases_06)

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

# فهرست‌های چندبعدی

# ابتدایی‌سازی
multi=[[0,1,2], [10,11,12,13], [20,21,22,23,24]]

# تکرار
for i1 in range(len(multi)):
    for i2 in range(len(multi[i1])):
        print "multi[%s][%s]=%s" % (i1,i2,multi[i1][i2])

# فرهنگ‌های چندبعدی
# ابتدایی‌سازی
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}

# تکرار
for (cle,valeur) in multi.items():
    for i2 in range(len(multi[cle])):
        print "multi[%s][%s]=%s" % (cle,i2,multi[cle][i2])
نتایج
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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. ارتباطات بین کانال‌ها و فهرست‌ها

برنامه (bases_07)

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

#تبدیل رشته به لیست
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)

# نمایش لیست
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# فهرست به رشته
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

#بیایید یک فیلد خالی اضافه کنیم
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# نمایش لیست
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

#بیایید یک فیلد خالی دیگر اضافه کنیم
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

#نمایش لیست
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

یادداشت‌ها:

  • خط ۵: متد chaine.split(separator) رشتهٔ کاراکتری chaine را به عناصری که توسط séparateur از هم جدا شده‌اند تقسیم می‌کند و آن‌ها را به صورت یک لیست بازمی‌گرداند. بنابراین، عبارت '1:2:3:4'.split(":") به لیست ('1','2','3','4'); ارزیابی می‌شود.
  • خط ۱۳: 'separateur'.join(liste) به رشته 'list[0]+separator+list[1]+separator+...' ارزیابی می‌شود.
نتایج
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<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. بیان‌های منظم

برنامه (bases_09)

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

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    #مقایسه رشته با الگو و الگو با الگو
    # نمایش نتایج
    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)


# بیان‌های منظم در پایتون
#استخراج فیلدهای مختلف از یک رشته
#الگو: دنباله‌ای از ارقام که توسط هر کاراکتری احاطه شده باشد
# ما فقط می‌خواهیم دنبالهٔ ارقام را استخراج کنیم
modele=r"^.*?(\d+).*?$"

# ما رشته را با الگو مطابقت می‌دهیم
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

#الگو: یک دنباله از ارقام که توسط هر کاراکتری احاطه شده است
# ما می‌خواهیم دنبالهٔ ارقام و همچنین فیلدهای بلافاصله قبل و بعد از آن را
modele=r"^(.*?)(\d+)(.*?)$"

# ما رشته را با الگو مطابقت می‌دهیم
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

#الگو – یک تاریخ در قالب dd/mm/yy
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")

#الگو – یک عدد اعشاری
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")
# پایان

یادداشت‌ها:

  • به ماژولی که در خط ۳ وارد شده توجه کنید. اینجاست که توابع مربوط به کار با عبارت‌های منظم قرار دارند؛
  • خط ۱۰: مقایسه یک رشته با یک عبارت منظم (pattern) مقدار بولی True را در صورتی که رشته با الگو مطابقت داشته باشد، و در غیر این صورت مقدار False را برمی‌گرداند؛
  • خط ۱۲: match.groups() یک تِپل است که عناصر آن بخش‌های رشته‌ای هستند که با عناصر عبارت منظم داخل پرانتز مطابقت دارند. در الگو:
  • ^.*?(\d+).*?، match.groups() یک تِپل با یک عنصر خواهد بود؛
  • ^(.*?)(\d+)(.*?)$، match.groups() یک تپل با ۳ عنصر خواهد بود.
نتایج
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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. حالت ارسال پارامتر تابع

برنامه (bases_10)

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

def f1(a):
    a=2

def f2(a,b):
    a=2
    b=3
    return (a,b)
  
# ------------------------ اصلی
x=1
f1(x)
print "x=%s" % (x)
(x,y)=(-1,-1)
(x,y)=f2(x,y)
print "x=%s, y=%s" % (x,y)
نتایج
1
2
x=1
x=2, y=3

یادداشت‌ها:

  • در پایتون، همه چیز یک شیء است. برخی از اشیاء به عنوان «غیرقابل تغییر» (immutable) شناخته می‌شوند: آنها قابل تغییر نیستند. این موضوع در مورد اعداد، رشته‌ها و تپل‌ها صدق می‌کند. هنگامی که اشیاء پایتون به عنوان آرگومان به توابع پاس داده می‌شوند، ارجاع آنها منتقل می‌شود، مگر اینکه این اشیاء «غیرقابل تغییر» باشند، که در این صورت خودِ مقدار شیء منتقل می‌شود؛
  • توابع f1 (خط ۳) و f2 (خط ۶) برای نشان دادن ارسال یک پارامتر خروجی در نظر گرفته شده‌اند. ما می‌خواهیم پارامتر واقعی یک تابع توسط خود تابع تغییر یابد؛
  • خطوط ۳–۴: تابع f1 پارامتر صوری خود a را تغییر می‌دهد. می‌خواهیم بدانیم آیا پارامتر حقیقی نیز تغییر خواهد کرد یا خیر.
  • خطوط ۱۲–۱۳: پارامتر حقیقی x=1 است. نتیجه خط ۱ نشان می‌دهد که پارامتر حقیقی تغییر نمی‌کند. بنابراین، پارامتر حقیقی x و پارامتر صوری a دو شیء متفاوت هستند؛
  • خطوط ۶–۹: تابع f2 پارامترهای صوری a و b را تغییر می‌دهد و آن‌ها را به عنوان نتیجه بازمی‌گرداند؛
  • خطوط ۱۵–۱۶: پارامترهای حقیقی (x, y) به f2 پاس داده می‌شوند و نتیجه f2 به (x, y) تخصیص داده می‌شود. خط ۲ نتایج نشان می‌دهد که پارامترهای حقیقی (x, y) تغییر یافته‌اند.

بنابراین می‌توان نتیجه گرفت که وقتی اشیاء «غیرقابل تغییر» پارامترهای خروجی هستند، باید در نتایج بازگردانده‌شده توسط تابع گنجانده شوند.

3.7. فایل‌های متنی

برنامه (bases_11)

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

import sys

# پردازش متوالی یک فایل متنی
# این شامل خطوطی در قالب login:pwd:uid:gid:infos:dir:shell است
# هر خط در یک فرهنگ لغت به شکل login => [uid,gid,infos,dir,shell] ذخیره می‌شود

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    #مقدار مرتبط با کلید در فرهنگ لغت «dico» را نمایش می‌دهد، اگر وجود داشته باشد
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        #کلید در دیکشنری 'dico' یافت نمی‌شود
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # در صورت وجود، کاراکتر پایان خط را از خط حذف می‌کند
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
#نام فایل تنظیم می‌شود
INFOS="infos.txt"

# آن را در حالت ایجاد باز می‌کند
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

#تولید محتوای دلخواه
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")

# فایل بسته می‌شود
fic.close()

# آن را در حالت خواندن باز می‌کند
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# واژه‌نامه خالی برای شروع
dico={}

# خواندن خط  
ligne=fic.readline()  
while(ligne!=''):
    # حرف پایان خط را حذف می‌کند
    ligne=cutNewLineChar(ligne)
  
    # قرار دادن خط در یک آرایه
    infos=ligne.split(":")
  
    #بازیابی ورود به سیستم
    login=infos[0]
  
    # حذف دو عنصر اول [login,pwd]
    infos[0:2]=[]
  
    # ایجاد یک مدخل در فرهنگ لغت
    dico[login]=infos
  
    # خواندن خط  
    ligne=fic.readline()  

# بستن فایل
fic.close()

# فرهنگ را پردازش کنید
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

یادداشت‌ها:

  • خط ۳۷: برای متوقف کردن اسکریپت در وسط کد.
نتایج

فایل infos.txt:

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

نتایج صفحه:

1
2
[login10,uid10:gid10:infos10:dir10:shell10]
la cle [X] n'existe pas
https://stahe.github.io
این آموزش دوره, نوشته شده توسط سرگئه تاه, تحت شرایط مجوز Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported در دسترس عموم قرار گرفته است.