رفتن به مطلب

پست های پیشنهاد شده

دسته بندی

در این بخش به دسته‌بندی انواع شی بر اساس برخی از تعریف‌های پایتون پرداخته شده است.

  • انواع عددی (Numeric Types):
- int
- long (2.x)
- float
- complex
- Decimal
- Fraction
- bool
  • انواع دنباله (Sequence Types):
- str
- unicode (2.x)
- bytes (3.x)
- bytearray (3.x/2.6+)
- tuple
- list
  • انواع تغییر ناپذیر (Immutable Types):
- int
- long (2.x)
- float
- complex
- Decimal
- Fraction
- bool
- str
- unicode (2.x)
- bytes (3.x)
- tuple
- frozenset
  • انواع تغییر پذیر (Mutable Types):
- bytearray (3.x/2.6+)
- list
- dict
- set
  • انواع نگاشت (Mapping Types):
- dict
  • انواع مجموعه (Set Types):
- set
- frozenset
  • برخی دیگر:
- zip
- dict_views
- NoneType

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

دستورهای کنترلی

در حالت عادی جریان اجرای یک برنامه روند ثابتی دارد به این شکل که کدها سطر به سطر، از بالا به پایین خوانده و اجرا می‌شوند؛ دستورهای کنترلی امکانی برای کنترل یا تغییر این جریان ثابت است. با استفاده از این دستورها می‌توان برای اجرای یک بلاک شرط تعیین کرد که اگر در زمان اجرا این شرط برقرار نباشد از اجرای بلاک صرف نظر خواهد شد یا می‌توان شرایطی را به وجود آورد که اجرای یک بلاک را از میان چندین بلاک مشخص انتخاب گردد و همچنین می‌توان اجرای یک بلاک را چندین بار تکرار کرد.

انتخاب

با استفاده از دستور انتخاب می‌توان بر حسب شرایط برنامه در زمان اجرا تعیین کرد که آیا یک بلاک دستور اجرا شود یا خیر و همچنین از بین دو یا چند بلاک دستور کدام یک انتخاب و اجرا گردد. پایتون تنها یک ساختار انتخاب را ارایه می‌دهد که می‌تواند به سه شکل «تک انتخابی»، «دو انتخابی» و «چند انتخابی» پیاده‌سازی گردد؛ این ساختار به نام دستور if خوانده می‌شود و در ادامه بررسی خواهد شد.

دستور if

۱. ساختار ساده (تک انتخابی)

این ساختار یک دستور مرکب است که در سرآیند آن یک «شرط» (Condition) بررسی می‌گردد و تنها در صورتی که این شرط برقرار باشد بدنه اجرا خواهد گشت؛ در غیر این صورت مفسر از اجرای دستور(های) بدنه صرف نظر کرده و به سراغ نخستین دستور بعد از این ساختار می‌رود. این ساختار با استفاده از کلمه کلیدی if و الگویی مشابه پایین پیاده‌سازی می‌گردد:

if condition :
    StatementBlock

منظور از شرط عبارتی است که می‌توان آن را به یکی از مقدار‌های بولی (True یا False) ارزیابی نمود؛ در اینجا اگر شرط برابر True ارزیابی گردد بخش بدنه دستور if اجرا می‌گردد. به نمونه کدهای پایین توجه نمایید:

>>> a = 5
>>> b = 3
>>> if a > b:
...     print("a is greater than b")
...
a is greater than b
>>>
>>> if a == b:
...     print("a is equal to b")
...
>>>

در نمونه کد بالا شرط برابر False ارزیابی شده و از اجرای بدنه خودداری شده است؛ بنابراین هیچ متنی در خروجی چاپ نشده است.

>>> if a > b and a >= 0:
...     print("a is positive and greater than b")
...
a is positive and greater than b
>>>

همانطور که در نمونه کد بالا نیز مشاهده می‌شود می‌توان از عملگرهای منطقی (not ،or ،and) برای بررسی برقرار بودن (یا نبودن) همزمان چندین شرط بهره گرفت.

می‌دانیم که: عدد یک و تمام اعداد مخالف صفر در پایتون برابر مقدار بولی True و عدد صفر، اشیا خالی به مانند "" یا [] برابر مقدار False ارزیابی می‌شوند:

>>> if 1:
...     print("Condition is True")
...
Condition is True
>>>
>>> if []:
...     print("Condition is True")
...
>>>
>>> a = False

>>> if not a:
...     print("Condition is True")
...
Condition is True
>>>

می‌توان از ساختار if به شکل تودرتو (Nested) نیز بهره برد. در این حالت بدنه دستور if حاوی یک یا چند دستور if دیگر می‌شود که البته آن‌ها نیز می‌توانند حاوی دستور‌های if دیگری در بدنه خود باشند:

>>> d = {'name': 'Jhon', 'job': 'programmer', 'age': 40}

>>> if d['age'] >= 40:
...     if d['job'] == 'programmer':
...         print(d['name'])
...
Jhon
>>>

۲. ساختار همراه با else (دو انتخابی)

با استفاده از کلمه‌ کلیدی else می‌توان بلاکی را برای اجرا در حالتی که شرط برقرار نیست - زمانی که شرط if برابر مقدار بولی False ارزیابی می‌گردد - تعیین کرد. else یک بخش جدا است که سرآیند و بدنه مخصوص به خود را دارد؛ این سرآیند می‌بایست فاقد هر گونه شرطی باشد:

>>> a = False

>>> if a:
...     print("Condition is True")
... else:
...     print("Condition is False")
...
Condition is False
>>>
>>> a = 7

>>> if a in [1, 2, 3]:
...     print("a is in list")
... else:
...     print("a is not in list")
...
a is not in list
>>>
>>> d = {'name': 'Bob', 'job': 'designer', 'age': 45}

>>> if d['age'] >= 40:
...     if d['job'] == 'programmer':
...         print(d['name'])
...     else:
...         print(d['name'], d['job'])  # Will be executed
... else:
...     if d['age'] >= 35:
...         print(d['name'], 'Between 35 and 40 years old')
...     else:
...         print(d['name'], 'Less than 35 years old')
...
Bob designer
>>>

۳. ساختار همراه با elif (چند انتخابی)

دستور if را می‌توان گسترش داد و بخش‌های بیشتری را با شرط‌های گوناگون ایجاد نمود؛ به این صورت که ابتدا شرط بخش if بررسی می‌گردد و چنانچه برابر True ارزیابی نگردد، شرط مربوط به نختسین بخش elif بررسی می‌گردد که اگر باز هم برابر True نشود شرط بخش elif بعدی بررسی خواهد شد و به همین صورت ادامه می‌یابد؛ در انتها نیز اگر هیچ کدام از شرط‌ها (if و elif) برابر True نشوند آنگاه بدنه مربوط به بخش else (در صورت وجود) اجرا می‌گردد. الگوی این ساختار مانند پایین است:

if condition_1:
    statements
elif condition_2:
    statements
elif condition_3:
    statements
else:
    statements
  • هر elif یک بخش جدا است که سرآیند و بدنه مخصوص به خود را دارد.
  • تعداد بخش‌های elif اختیاری است و محدودیتی در آن وجود ندارد.
  • بخش elif نمی‌تواند قبل از if یا بعد از else قرار بگیرد.
  • در این ساختار نیز وجود بخش else اختیاری است.

در این ساختار بخش‌ها به ترتیب از بالا به پایین بررسی می‌شوند و با True ارزیابی شدن شرط هر بخش، بدنه مربوط به آن اجرا و از بررسی دیگر بخش‌ها صرف نظر می‌گردد. به نمونه کد پایین توجه نمایید:

>>> percent = 60

>>> if percent == 100:
...    print('100 %')
... elif percent >= 75:
...    print('75-100 %')
... elif percent >= 50:
...    print('50-75 %')
... elif percent >= 25:
...    print('25-50 %')
... else:
...    print('less than 25 %')
...
50-75 %
>>>

اگر بخواهیم نمونه کد بالا را با استفاده از if های تودرتو پیاده‌سازی نماییم به شکل پایین خواهد شد:

>>> percent = 60

>>> if percent == 100:
...     print('100 %')
... else:
...     if percent >= 75:
...         print('75-100 %')
...     else:
...         if percent >= 50:
...             print('50-75 %')
...         else:
...             if percent >= 25:
...                 print('25-50 %')
...             else:
...                 print('less than 25 %')
...
50-75 %
>>>

چنانچه قصد دارید تمام شرط‌های مورد نظر بررسی شوند می‌توانید از چند دستور if به شکل متوالی استفاده نمایید:

# File: Documents/script.py
# Python 3.x

import sys

# Get script argument and convert it to an integer
percent = int(sys.argv[1])

if percent == 100:
    print('100 %')
if percent >= 75:
    print('75-100 %')
if percent >= 50:
    print('50-75 %')
if percent >= 25:
    print('25-50 %')
if percent < 25:
    print('less than 25 %')
user> cd Documents/

user> python script.py 60
50-75 %
25-50 %

دستور switch/case

در صورتی که سابقه برنامه‌نویسی با زبان‌های دیگری همچون C و Java را داشته باشید حتما با دستور switch نیز آشنا هستید؛ این دستور در زبان پایتون پیاده‌سازی نشده است.

دستور switch مقداری را دریافت می‌کند و سپس آن را با مقدارهای هر case درون ساختار خود به ترتیب مقایسه می‌کند؛ در صورتی که این مقدار با یکی از case ها برابر باشد، دستورهای مرتبط با آن case را اجرا کرده و از بررسی دیگر case ها صرف نظر می‌کند. همچنین اگر مقدار دریافتی با هیچ یک از case ها مطابقت نداشته باشد دستورهای مربوط به بخش default (در صورت وجود) را اجرا می‌کند. در پایین نمونه‌ایی از این دستور در زبان Java آورده شده است:

int success;
char grade = 'B';
switch (grade) {
            case 'A':
                    System.out.println("Excellent grade");
                    success = 1;
                    break;
            case 'B':
                    System.out.println("Very good grade");
                    success = 1;
                    break;
            case 'C':
                    System.out.println("Good grade");
                    success = 1;
                    break;
            case 'D':
            case 'E':
            case 'F':
                    System.out.println("Low grade");
                    success = 0;
                    break;
            default:
                    System.out.println("Invalid grade");
                    success = -1;
                    break;
}

برای پیاده‌سازی چنین ساختاری در پایتون می‌توان از if/elif/else استفاده کرد:

grade = 'B'
if grade == 'A':
    print('Excellent grade')
    success = 1
elif grade == 'B':
    print('Very good grade')
    success = 1
elif grade in ('D', 'E', 'F'):
    print('Low grade')
    success = 0
else:
    print('Invalid grade')
    success = -1

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

تکرار

گاهی نیاز پیدا می‌کنیم که بلاکی را چندین بار پشت سرهم اجرا نماییم. به ساختار تکرار «حلقه» (Loop) گفته می‌شود؛ در ادامه به بررسی ساختار دو حلقه ارایه شده در زبان پایتون خواهیم پرداخت.

دستور while

این دستور مرکب یک حلقه تکرار است که یک شرط را در سرآیند خود بررسی می‌کند و چنانچه شرط برابر مقدار True ارزیابی شود، دستورهای بدنه را اجرا می‌کند؛ مفسر پس از اتمام اجرای بدنه دوباره به سرآیند برگشته و شرط را بررسی می‌کند که اگر شرط هنوز هم برقرار باشد از نو دستورهای بدنه اجرا می‌گردند. در حالت عادی روند تکرار اجرای بدنه تا زمانی که شرط سرآیند برابر True ارزیابی گردد ادامه خواهد یافت. الگوی این دستور به مانند پایین است:

while condition :
    statements

شرط همواره می‌بایست از درون بدنه کنترل شود به گونه‌ای که در مرحله‌ خاصی برابر مقدار False ارزیابی گردد؛ در غیر این صورت یک حلقه بی‌نهایت ایجاد می‌شود که مفسر هیچگاه نمی‌تواند از اجرای آن خارج شود. برای نمونه اجرای دستور پایین هیچگاه توسط مفسر پایتون پایان نمی‌پذیرد و برای اتمام آن می‌بایست از سیستم عامل کمک گرفت:

>>> while 1:
...     print('Press Ctrl+C to stop!')
...
Press Ctrl+C to stop!
Press Ctrl+C to stop!
Press Ctrl+C to stop!
[..]

ولی در نمونه کد پایین مقدار متغیر a از درون بدنه کنترل و در هر بار اجرا یک واحد کاهش می‌یابد؛ بنابراین اجرای حلقه تنها تا زمانی که شرط نقض نشده باشد ادامه می‌یابد:

>>> a = 5

>>> while a > 0:
...     print(a)
...     a -= 1   # a = a - 1
...
5
4
3
2
1
>>>

در نمونه کد بالا بهتر می‌بود به جای عبارت a > 0 تنها از خود متغیر a به عنوان شرط حلقه استفاده نماییم؛ چرا که در هر مرتبه اجرا یک واحد از آن کم می‌شود و با رسیدن به مقدار صفر به صورت خودکار توسط مفسر پایتون به مقدار False ارزیابی و تکرار اجرای بدنه حلقه متوقف می‌گردد.

به عنوان نمونه‌ای دیگر،‌ فاکتوریل (

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
) عدد ۱۰ را می‌توان به صورت پایین محاسبه کرد:

>>> a = 10

>>> n = 1
>>> while a >= 1:
...     n = n * a
...     a -= 1
...
>>> print(n)
3628800

دستور continue

این دستور در هر نقطه از بخش بدنه که آورده شود، دستورهای بعد از آن نادیده گرفته می‌شوند و جریان اجرا به ابتدای حلقه یعنی بخش سرآیند پرش می‌کند. برای نمونه می‌خواهیم اعداد صحیح زوجی که کوچکتر از ۱۰ هستند را بر روی خروجی نمایش دهیم. در نمونه کد پایین برای اعداد فرد دستور continue از ادامه اجرا و نمایش آن‌ها جلوگیری می‌کند و جریان اجرا را به ابتدای حلقه پرش می‌دهد:

>>> n = 10

>>> while n:
...     n -= 1
...     if n % 2 != 0:
...         continue
...     print(n)
...
8
6
4
2
0
>>>

البته مثال بالا را بدون continue نیز می‌توان به انجام رساند:

>>> n = 10
>>> while n:
...     n -= 1
...     if n % 2 == 0:
...         print(n)

دستور break

این دستور در هر نقطه از بخش بدنه که آورده شود، دستورهای بعد از آن نادیده گرفته می‌شوند و جریان اجرا از حلقه خارج می‌شود. در نمونه کد پایین با هر اجرای بدنه یک واحد به counter افزوده می‌شود و هرگاه مقدار آن برابر ۴ گردد، بدون توجه به شرط، اجرای حلقه متوقف می‌شود:

>>> counter = 0

>>> while counter < 100:
...     if counter == 4:
...         break
...     print(counter)
...     counter += 1
...
0
1
2
3
>>>

در while نیز می‌شود از بخش else استفاده نماییم؛ به این صورت که اگر حلقه به صورت طبیعی پایان پذیرد - و نه توسط دستور break - آنگاه بدنه else اجرا می‌گردد.

نمونه کد پایین بررسی می‌کند که آیا عدد n یک «عدد اول» (

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
) هست یا خیر؛ این اعداد بزرگتر از یک بوده و به جز خود و عدد یک بر هیچ عدد دیگری بخش پذیر نیستند. بنابراین اگر عددی کوچکتر از n (به جز یک) پیدا شود که بر آن بخشپذیر باشد (یعنی باقی مانده تقسیم بر آن صفر باشد) اول نبودن عدد n ثابت می‌شود و حلقه به کمک دستور break متوقف می‌گردد:

>>> n = 23
>>> i = 2
>>> while i < n:
...     if n % i == 0:
...         print(n, "is not a prime number")
...         break
...     i += 1
... else:
...     print(n, "is a prime number")
...
23 is a prime number
>>>

دستور for

این دستور مرکب یک حلقه تکرار است که بر اساس تعداد عضوهای یک شی دنباله یا در حالت کلی‌تر یک شی تکرارکننده (iterator) - که در انتها بررسی خواهد شد - اجرای دستورهای بدنه را تکرار می‌کند. الگوی این دستور به شکل پایین است:

for target in object:
    statements

هر حلقه for دقیقا به تعداد عضوهای شی object تکرار می‌گردد؛ هر بار یک عضو از دنباله (یا تکرارکننده) object با حفظ ترتیب اعضا به متغیر target انتساب داده می‌شود و یک مرتبه بدنه اجرا می‌گردد؛ این روند تا پایان پیمایش عضوهای object ادامه می‌یابد. از متغیر target می‌توان در داخل بدنه استفاده کرد که در مرتبه نخست اجرای حلقه به عضو یکم و با اجراهای بعدی به عضوهای بعدی از object اشاره خواهد داشت. به نمونه کدهای پایین توجه نمایید:

>>> for item in [1, 2, 3]:
...     print(item)
...
1
2
3
>>>
>>> for char in 'python':
...     print(char)
...
p
y
t
h
o
n
>>>
>>> L = [(1, 2), (3,4), (5, 6)]

>>> for a, b in L:
...     print(a, b)
...
1 2
3 4
5 6
>>>

در نمونه کد بالا، از آنجا که هر عضو دنباله خود یک دنباله دو عضوی است، بنابراین از دو متغیر برای اشاره به شی پیمایش استفاده شده است.

>>> L = [(1, 2), (3,4), (5, 6)]

>>> for both in L:
...     a, b = both
...     print(a, b)
...
1 2
3 4
5 6
>>>

در نمونه کد بالا، متغیر both در هر مرتبه تکرار به یک شی تاپل اشاره دارد.

>>> a, *b, c = (1, 2, 3, 4)
>>> a, b, c
(1, [2, 3], 4)

>>> for a, *b, c in [(1, 2, 3, 4), (5, 6, 7, 8)]:
...     print(a, b, c)
...
1 [2, 3] 4
5 [6, 7] 8
>>>
>>> d = {'name': 'Jhon', 'job': 'designer', 'age': 40}

>>> for key in d:
...     print(key)
...
name
job
age
>>>

در حالت عادی برای یک شی دیکشنری،‌ کلیدهای آن پیمایش می‌شوند.

>>> d = {'name': 'Jhon', 'job': 'designer', 'age': 40}

>>> d.items()
dict_items([('name', 'Jhon'), ('job', 'designer'), ('age', 40)])

>>> for key, value in d.items():
...     print(key, value)
...
name Jhon
job designer
age 40
>>>

توجه: معمولا از حلقه for در مواقعی که تعداد تکرار مشخص باشد و از حلقه while زمانی که تعداد تکرار نامشخص است استفاده می‌شود.

مانند حلقه while در اینجا نیز می‌توان از دستورهای continue و break استفاده کرد. همچنین حلقه for می‌تواند شامل بخش else باشد.

مثال تشخیص عدد اول در حلقه while را با استفاده از حلقه for بازنویسی می‌کنیم:

>>> n = 23

>>> for i in range(2, n):
...     if n % i == 0:
...         print(n, "is not a prime number")
...         break
... else:
...     print(n, "is a prime number")
...
23 is a prime number
>>>

تابع (range(stop:

این تابع [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] یک شی از نوع range را برمی‌گرداند؛ این شی یک دنباله تغییر ناپذیر است که معمولا از آن برای پیمایش در حلقه for استفاده می‌شود. با تبدیل شی range به نوع لیست خواهیم دید که این شی یک دنباله مرتب از اعداد صفر تا آرگومان stop (و نه خود آن) است؛ آرگومان stop می‌بایست یک عدد صحیح مثبت باشد:

>>> r = range(10)    # Python 3.x

>>> type(r)
<class 'range'>

>>> r
range(10)

>>> print(r)
range(10)

>>> list(r)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> tuple(r)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

>>> import sys
>>> sys.getsizeof(r)
48

این تابع را می‌توان به صورت دو آرگومانی ((range(start, stop) نیز فراخوانی نمود که آرگومان یکم عدد آغازین دنباله را تعیین می‌کند و می‌تواند یک عدد منفی نیز باشد:

>>> list(range(2, 10))
[2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(-2, 10))
[-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

در این حالت می‌توان از آرگومان سومی نیز برای تعیین گام یا فاصله بین اعداد بهره گرفت:

>>> list(range(2, 10, 2))
[2, 4, 6, 8]

>>> list(range(2, 10, 3))
[2, 5, 8]

>>> list(range(2, 10, 4))
[2, 6]
  • هر سه آرگومان می‌بایست از نوع صحیح باشند.
  • برای تعیین آرگومان stop منفی، می‌بایست آرگومان گام را نیز به شکل منفی تعیین نمود:
>>> list(range(2, -10, -1))
[2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

>>> list(range(2, -10, -2))
[2, 0, -2, -4, -6, -8]
>>> list(range(-2, -10, -1))
[-2, -3, -4, -5, -6, -7, -8, -9]

>>> list(range(-2, -10, -2))
[-2, -4, -6, -8]

در نسخه‌های 2x پایتون دو نسخه از این تابع وجود دارد: تابع range [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] و تابع xrange [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
].

خروجی تابع range یک شی از نوع لیست است:

>>> r = range(10)    # Python 2.x

>>> type(r)
<type 'list'>

>>> r
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> import sys
>>> sys.getsizeof(r)
152

ولی خروجی تابع xrange یک شی از نوع xrange می‌باشد:

>>> r = xrange(10)    # Python 2.x

>>> type(r)
<type 'xrange'>

>>> r
xrange(10)

>>> list(r)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> import sys
>>> sys.getsizeof(r)
40

خروجی تابع xrange ساده‌تر و بهینه تر از خروجی تابع range است بنابراین معمولا پیشنهاد می‌شود که در حلقه for از تابع xrange استفاده شود؛ به همین دلیل می‌باشد که تابع range در نسخه‌های 3x پایتون حذف شده است و تنها تابع xrange باقی‌مانده که با نام و نوع range پیاده‌سازی شده است.

  • چگونگی استفاده و تعداد آرگومان‌های هر دو تابع همانند نسخه 3x است که پیش از این بررسی شد.

چند مثال‌ ساده دیگر:

>>> L = ['a', 'b', 'c', 'd']

>>> for i in range(len(L)):
...     print(L[i])
...
a
b
c
d
>>>
>>> s = 'pythonprogramminglanguage'

>>> for c in s[9:13]:
...     print(c)
...
g
r
a
m
>>>
>>> reven = range(0, 10, 2)
>>> list(reven)
[0, 2, 4, 6, 8]

>>> rodd = range(1, 10, 2)
>>> list(rodd)
[1, 3, 5, 7, 9]

>>> list(zip(reven, rodd))
[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]

>>> L = []
>>> for a, b in zip(reven, rodd):
...    L.append(a*b)
...
>>> L
[0, 6, 20, 42, 72]

می‌توان نتایج حلقه for را مستقیم در یک شی لیست قرار داد؛ برای نمونه دستور پایین را در نظر بگیرید:

>>> L = []
>>> for x in range(5):
...     L.append(x**2)
...
>>> L
[0, 1, 4, 9, 16]

که می‌توان خیلی ساده آن را به صورت پایین بازنویسی کرد:

>>> [x ** 2 for x in range(5)]
[0, 1, 4, 9, 16]

و به عنوان مثال‌هایی دیگر به نمونه کدهای پایین توجه نمایید:

>>> y = 7

>>> [y * x for x in range(10)]
[0, 7, 14, 21, 28, 35, 42, 49, 56, 63]
>>> L = [(1, 2), (3, 4), (5, 6)]

>>> [a + b for a, b in L]
[3, 7, 11]
>>> [a * b for a, b in zip(range(0, 10, 2), range(1, 10, 2))]
[0, 6, 20, 42, 72]
>>> [(a, b) for a, b in zip(range(0, 10, 2), range(1, 10, 2))]
[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]

از دستورهای مرکب پایتون می‌توان در داخل بدنه یکدیگر بهره برد که البته این موضوع برای دستورهای for و while نیز صادق است. از هر دو این دستورها می‌توان بر حسب نیاز در داخل بدنه یکدیگر یا به شکل تودرتو استفاده کرد:

>>> for i in range(1, 5):
...     for j in range(0, i):
...         print(i)
...
1
2
2
3
3
3
4
4
4
4
>>>

به نمونه کد بالا توجه نمایید؛ با هر بار تکرار حلقه یکم تمام دستورهای بدنه آن که شامل یک حلقه دیگر است اجرا می‌گردد. از متغیر i درون حلقه داخلی نیز استفاده شده است. در بار نخستِ اجرای حلقه بیرونی مقدار i برابر عدد 1 قرار داده می‌شود که در این صورت اجرای حلقه داخلی تنها یک بار تکرار می‌گردد (1 == ((len(range(0, 1) و یک مقدار 1 در خروجی نمایش داده می‌شود،‌ بار دوم i برابر عدد 2 می‌شود و در نتیجه حلقه داخلی دو بار تکرار می‌گردد که بر اثر آن دو مقدار 2 در خروجی چاپ می‌گردد. این روند تا پایان تکرار حلقه بیرونی ادامه می‌یابد.

تابع (یا دستور) print به صورت پیش‌فرض پس از اجرا و چاپ مقدار به سطر بعدی می‌رود.

اگر از پیش با زبان‌هایی نظیر C یا Java آشنایی دارید؛ برای درک بهتر ساختار حلقه for پایتون نمونه کد پایین که به زبان Java است را در نظر بگیرید:

int[][] array = { { 1, 2 }, { 3 }, { 4, 5, 6 } };

for ( int row = 0; row < array.length; row++ )
{
    for ( int column = 0; column < array[ row ].length; column++ )
        System.out.printf( "%d ", array[ row ][ column ] );

    System.out.println();
}

// Paul Deitel, Harvey Deitel "Java: How to Program" (9th Edition) page 270
1 2
3
4 5 6

که می‌توانیم آن را توسط زبان پایتون به شکل پایین پیاده‌سازی نماییم:

>>> array = ((1, 2), (3,), (4, 5, 6))
>>> for row in range(0, len(array)):
...     for column in range(0, len(array[row])):
...         print("%d " % array[row][column])
...     print()

تابع (enumerate(iterable:

علاوه‌ بر تابع ()range در حلقه‌های for می‌توانیم از تابع ()enumerate [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] نیز استفاده کنیم. این تابع یک شی دنباله یا تکرارکننده را به عنوان آرگومان دریافت می‌کند و یک شی از نوع enumerate برمی‌گرداند:

>>> L = ['a', 'b', 'c']

>>> e = enumerate(L)

>>> type(e)
<class 'enumerate'>

>>> e
<enumerate object at 0x7fc76a6b92d0>
>>> print(e)
<enumerate object at 0x7fc76a6b92d0>

>>> import sys
>>> sys.getsizeof(e)
72

با تبدیل این شی به یک شی لیست مشاهده می‌شود که این شی عضوهای آرگومان ورودی خود را به شکل جفت‌هایی به همراه اندیس موقعیت آن‌ها ذخیره کرده است (index, value):

>>> list(e)
[(0, 'a'), (1, 'b'), (2, 'c')]

استفاده از این تابع در مواقعی که پیمایش یک دنباله غیر عددی یا بررسی اندیس دنباله حلقه را در نظر داشته باشید بسیار مفید است:

>>> s = 'python'

>>> for i, v in enumerate(s):
...     print('%s) %s' % (i, v * 7))
...
0) ppppppp
1) yyyyyyy
2) ttttttt
3) hhhhhhh
4) ooooooo
5) nnnnnnn
>>>
>>> s = 'python'

>>> [v * i for i, v in enumerate(s)]
['', 'y', 'tt', 'hhh', 'oooo', 'nnnnn']

این تابع همچنین یک آرگومان اختیاری با نام start دارد که با مقدار دادن به آن می‌توان عدد ابتدایی شمارش اندیس‌ها را تعیین نمود؛ مقدار پیش‌فرض این آرگومان عدد صفر است:

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']

>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

شی تکرارکننده

در این بخش قصد داریم با مفهوم iterator (تکرارکننده) در پایتون آشنا شویم. برای این منظور بهتر است ابتدا مفهوم iterable (تکرارپذیر) را بدانیم.

تمام انواع دنباله یک iterable هستند؛ در واقع به اشیایی با این قابلیت که بتوان در هر لحظه یک عضو درون آن را دستیابی نمود iterable گفته می‌شود. اکثر انواع آماده شی که در پایتون می‌شناسیم یک iterable است؛ انواع شی رشته، لیست، تاپل، دیکشنری، range ،zip (یا xrange) یا یک شی فایل (file) و هر شی از کلاسی که خودتان به همراه متد‌های ویژه ()__iter__ یا ()__getitem__ تعریف نمایید یک iterable هستند.

شی iterator با استفاده از تابع آماده ()iter [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] ایجاد می‌شود؛ این تابع یک شی iterable را به عنوان آرگومان دریافت می‌کند و آن را در قالب یک شی iterator بر می‌گرداند:

>>> L = [1, 2, 3, 4, 5]
>>> type(L)
<class 'list'>

>>> itr = iter(L)

>>> type(itr)
<class 'list_iterator'>
>>> t = (1, 2, 3, 4, 5)
>>> type(t)
<class 'tuple'>

>>> itr = iter(t)

>>> type(itr)
<class 'tuple_iterator'>
>>> s = 'python'
>>> type(s)
<class 'str'>

>>> itr = iter(s)

>>> type(itr)
<class 'str_iterator'>
>>> d = {'name': 'Bob', 'age': 40}
>>> type(d)
<class 'dict'>

>>> itr = iter(d)

>>> type(itr)
<class 'dict_keyiterator'>

یک شی iterator این قابلیت را دارد که می‌توان عضوهای درون آن را یکی یکی با استفاده از متد ()__next__ (یا ()next در پایتون 2x) پیمایش کرد؛ این متد در بار نخستِ فراخوانی عضو یکم شی و در دفعات بعدی فراخوانی به ترتیب عضوهای بعدی را برمی‌گرداند:

>>> L = [1, 2, 3, 4, 5]
>>> itr = iter(L)
>>> # Python 3.x

>>> itr.__next__()
1
>>> itr.__next__()
2
>>> itr.__next__()
3
>>> # Python 2.x

>>> itr.next()
1
>>> itr.next()
2
>>> itr.next()
3

با فراخوانی پی در پی این متد و رسیدن به انتهای پیمایش؛ زمانی که دیگر عضوی برای برگرداندن وجود ندارد یک خطا - البته درست این است که بگوییم یک استثنا (Exception) - با نام StopIteration گزارش می‌گردد:

>>> itr.__next__()
4
>>> itr.__next__()
5
>>> itr.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

این دقیقا همان کاری است که در دستور for به انجام می‌رسد. زمانی که از یک دنباله برای پیمایش در این دستور استفاده می‌کنید؛ for در پشت صحنه آن را به یک iterator تبدیل و سپس پیمایش یک به یک عضوها را آغاز می‌کند. در هر لحظه‌ که StopIteration رخ دهد، متوجه پایان دنباله شده و تکرار حلقه را پایان می‌بخشد.

در آینده توسط درس استثنا‌ها در پایتون خواهید دید که می‌توان با ایجاد iterator و استفاده از دستور try/except [که در همان درس خواهید آموخت] یک حلقه while را به مانند حلقه for پیاده‌سازی کرد.

با استفاده از ماژول itertools می‌توانید iterator های بی‌نهایت (Infinite) یا بدون توقف ایجاد نمایید. برای نمونه تابع cycle درون این ماژول، شی iterator ای می‌سازد که در انتهای پیمایش متوقف نمی‌شود و از نو به ابتدای شی برگشته و عضو یکم را برمی‌گرداند:

>>> import itertools

>>> L = [1, 2, 3, 4, 5]

>>> itr = itertools.cycle(L)

>>> type(itr)
<class 'itertools.cycle'>

>>> itr.__next__()
1
>>> itr.__next__()
2
>>> itr.__next__()
3
>>> itr.__next__()
4
>>> itr.__next__()
5
>>> itr.__next__()
1
>>> itr.__next__()
2

این ماژول شامل تابع‌های کاربردی بسیاری است که برای مطالعه بیشتر می‌توانید به صفحه آن در

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
مراجعه نمایید.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

ورودی و خروجی

موضوع این درس به چگونگی دریافت یا خواندن داده‌ها از کاربر حالت تعاملی یا فایل‌ها و همچنین نمایش یا نوشتن در آن‌ها اختصاص یافته است؛ بر همین اساس در متن درس به بررسی شی فایل و تابع‌های آماده ()print و ()input در پایتون پرداخته خواهد شد. به برخی از تفاوت‌ها در پیاده‌سازی نسخه جدید پایتون (شاخه 3x) که به موضوع این درس مربوط می‌باشند نیز اشاره شده است.

فایل ها

فایل‌ها (Files) جزو منابع منطقی کامپیوتر به شمار می‌روند، توسط سیستم عامل مدیریت می‌شوند و امکانی برای نگهداری طولانی مدت از اطلاعات می‌باشند. فایل‌ها در واقع بیت‌هایی متوالی از صفر و یک هستند که بر روی دیسک ذخیره گشته‌اند و معمولا در دو قالب جداگانه:

  • «فایل‌‌ باینری» (binary file) - مانند: فایل‌های ویدئو، فایل‌های تصویر، فایل zip، فایل بایت‌کد پایتون و...
  • «فایل‌ متنی» (text file) - مانند: فایل HTML، فایل ماژول پایتون و...

شناخته می‌شوند.

همانطور که گفته شد فایل‌ها چیزی جز مجموعه‌ای از مقدارهای باینری (یا دودویی) نیستند و فایل‌های متنی نیز در واقع یک زیر مجموعه از فایل‌های باینری است با این تفاوت که بیت‌های یک فایل متنی در کنار هم، بسته به نوع کدگذاری آن متناظر با دنباله‌ای از کاراکترهایی مشخص و قابل چاپ هستند. محتوای این نوع فایل در سطرهایی جداگانه قرار داده می‌شود و با استفاده از برنامه‌های ویرایشگر متن برای انسان خوانا می‌باشد. در یک فایل متنی با کدگذاری ASCII (اَسکی) هر هشت بیت (یک بایت) برابر یک کاراکتر می‌باشد - کدهای اسکی هفت بیتی هستند ولی در اکثر کامپیوترها برای هر کدام یک بایت در نظر گرفته می‌شود - برای نمونه کلمه Python به شکل شش بایت که هر کدام به ترتیب برابر مقدار باینری کد اسکی هر یک از این کاراکترها می‌باشد، ذخیره می‌شود. اسکی تنها از ۱۲۸ کاراکتر - از کد ۰ تا ۱۲۷ (در پایه ده) - پشتیبانی می‌کند و به همین دلیل امروزه بیشتر از کدگذاری‌های استاندارد Unicode (یونیکد) استفاده می‌گردد. در یونیکد مجموعه بسیار بزرگتری از کاراکتر نسبت به کدگذاری اسکی پشتیبانی می‌شود به گونه‌ای که اسکی را نیز در برمی‌گیرد؛ برای نمونه در کدگذاری UTF-8 از این استاندارد، ۱۲۸ کد نخست (از کد ۰ تا ۱۲۷) برابر کد همان ۱۲۸ کاراکتر اسکی می‌باشد. کدگذاری UTF-8 کاراکترهای یونیکد را در یک دنباله بایت با طول متغیر (۱ تا ۶ بایت) ارايه می‌دهد؛ در این کدگذاری برای کاراکترهای اسکی تنها یک بایت در نظر گرفته می‌شود.

در یک فایل باینری وجود سطر مفهومی ندارد و بایت‌های آن ممکن است داده‌هایی را نمایش دهند که نمی‌توان آن‌ها را توسط هیچ یک از کدگذاری‌های کاراکتر (UTF-8 ،ASCII و...) چاپ کرد یا حتی ممکن است در صورت چاپ آن‌ها نیز حاصل برای انسان غیر قابل فهم باشد.

پایتون یک نوع شی آماده برای دستیابی فایل‌ها در برنامه ارایه می‌دهد که این شی با استفاده از تابع آماده  (open(file, mode [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] ایجاد می‌گردد؛ آرگومان نخست یک شی رشته حاوی نام کامل فایل (نشانی + نام + پسوند) مورد نظر بر روی دیسک کامپیوتر است و آرگومان دوم نیز یک رشته با مقداری خاص است و حالتی که این فایل می‌بایست در آن باز شود را مشخص می‌سازد؛ این آرگومان اختیاری است و مقدار پیش‌فرض آن 'r' می‌باشد. برای نمونه به کدهای پایین که با یکدیگر معادل هستند توجه نمایید:

>>> f = open('/home/saeid/Documents/sample.txt')
>>> f = open('/home/saeid/Documents/sample.txt', 'r')
>>> f = open('/home/saeid/Documents/sample.txt', mode='r')

مسیر نمونه فایل بالا بر اساس سیستم فایل لینوکس درج شده است که در ویندوز برای مثال می‌تواند به یکی از دو شکل پایین درج گردد:

r'C:\Users\Saeid\Documents\sample.txt'
'C:\\Users\\Saeid\\Documents\\sample.txt'

آرگومان file را می‌توان تنها با نام خالی فایل و بدون ذکر مسیر آن مقداردهی کرد؛ در این صورت مفسر پایتون مسیر دایرکتوری جاری را برای آن در نظر می‌گیرد. با استفاده از تابع ()getcwd از ماژول os [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] می‌توانیم مسیر دایرکتوری جاری برنامه را به دست آوریم.

>>> import os

>>> os.getcwd()
'/home/saeid'

آرگومان mode نیز بر حسب نیاز می‌تواند یکی از مقدارهای پایین را داشته باشد:

  • 'r': فایل در قالب متنی تنها به منظور خواندن از آن باز می‌شود و اشاره‌گر در ابتدای آن قرار می‌گیرد. چنانچه فایلی با این نام موجود نباشد یک خطا (یا استثنا) FileNotFoundError گزارش می‌گردد. معادل 'rt'
  • 'w': فایل در قالب متنی تنها به منظور نوشتن در آن باز می‌شود؛ متن درون آن (در صورت وجود) پاک می‌شود و اشاره‌گر در ابتدای آن قرار می‌گیرد. چنانچه فایلی با این نام موجود نباشد، ابتدا ایجاد و سپس باز می‌شود. معادل 'wt'
  • 'a': فایل در قالب متنی تنها به منظور افزودن متنی در انتهای متن موجود در آن باز می‌شود؛ اشاره‌گر در انتهای فایل قرار دارد. چنانچه فایلی با این نام موجود نباشد، ابتدا ایجاد و سپس باز می‌شود. معادل 'at'
  • 'x': فقط در پایتون exclusive creation) - 3x) فایل در قالب متنی ایجاد و به منظور نوشتن در آن باز می‌شود؛ چنانچه این فایل از پیش موجود باشد یک خطا (یا استثنا) FileExistsError گزارش می‌گردد. معادل 'xt'
  • 'rb' و 'wb' و 'ab' و 'xb': همان توضیح گزینه‌های مشابه بالا را دارند ولی با این تفاوت که برای کار با فایل‌هایی در قالب باینری استفاده می‌شوند.
  • '+r': فایل در قالب متنی به منظور خواندن و نوشتن باز می‌شود و اشاره‌گر در ابتدای آن قرار می‌گیرد. چنانچه فایلی با این نام موجود نباشد یک خطا (یا استثنا) FileNotFoundError گزارش می‌گردد. توجه داشته باشید که در این حالت عمل نوشتن از همان ابتدای فایل، باعث جایگزین شدن متن جدید با متن حاضر می‌شود. معادل '+rt' یا 'r+t'
  • '+w': فایل در قالب متنی به منظور نوشتن و خواندن باز می‌شود؛ متن درون آن (در صورت وجود) پاک می‌شود و اشاره‌گر در ابتدای آن قرار می‌گیرد. چنانچه فایلی با این نام موجود نباشد، ابتدا ایجاد و سپس باز می‌شود. معادل '+wt' یا 'w+t'
  • '+a': فایل در قالب متنی به منظور افزودن متنی در انتهای متن موجود در آن و همچنین خواندن باز می‌شود؛ اشاره‌گر در انتهای فایل قرار دارد. چنانچه فایلی با این نام موجود نباشد، ابتدا ایجاد و سپس باز می‌شود. معادل '+at' یا 'a+t'
  • '+x': فقط در پایتون 3x - فایل در قالب متنی ایجاد و به منظور نوشتن و خواندن باز می‌شود؛ چنانچه این فایل از پیش موجود باشد یک خطا (یا استثنا) FileExistsError گزارش می‌گردد. معادل '+xt' یا 'x+t'
  • '+rb' یا 'r+b' و '+wb' یا 'w+b' و '+ab' یا 'a+b' و '+xb' یا 'x+b': همان توضیح گزینه‌های مشابه بالا را دارند ولی با این تفاوت که برای کار با فایل‌هایی در قالب باینری استفاده می‌شوند.
  • 'rU': خواندن یک فایل متنی با پشتیبانی از Universal Newline. معادل 'rtU'
  • 'rbU': خواندن یک فایل باینری با پشتیبانی از Universal Newline.

که در آن‌ها:

  • r: خواندن (read)
  • w: نوشتن (write)
  • a: درج در انتها (appending)
  • t: تعیین قالب متنی (text) برای فایل مورد نظر؛ قالب پیش‌فرض است و نیازی به درج آن نیست
  • b: تعیین قالب باینری (binary) برای فایل مورد نظر
  • +: فایل به منظور بروز رسانی (updating) باز می‌شود
  • U: حالت Universal Newline

در قرارداد سیستم‌های عامل گوناگون از رشته‌های مختلفی - که می‌تواند از یک یا چند کاراکتر تشکیل شده باشد - برای نشانه‌گذاری انتهای سطرهای یک فایل متنی استفاده شده است؛ برای نمونه در ویندوز از CRLF (یا 'r\n\') و در گنولینوکس از LF (یا 'n\') استفاده می‌شود. شی فایل پایتون به صورت پیش‌فرض از همان قرارداد سیستم عامل میزبان برای تعیین رشته Newline خود استفاده می‌کند؛ ولی چنانچه قصد دارید در پایتون فایلی با قرارداد سیستم عامل دیگری را به منظور خواندن باز نمایید می‌بایست این کار را در حالت Universal Newline انجام دهید. در این حالت به هنگام خواندن از یک فایل، پایتون تمام رشته‌های Newline موجود در فایل را به کاراکتر 'n\' نگاشت می‌کند [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]؛ دستور os.linesep [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] رشته Newline سیستم عامل میزبان را برمی‌گرداند:

>>> import os

>>> os.linesep  # GNU/Linux
'\n'

باز کردن یک فایل به منظور خواندن از آن حکم یک منبع ورودی (input) و باز کردن یک فایل به منظور نوشتن در آن حکم یک منبع خروجی (output) را در برنامه دارد.

تابع ()open آرگومان‌های اختیاری دیگری نیز دارد که برای بررسی آن‌ها می‌توانید به اسناد پایتون مراجعه نمایید.

متدهای شی فایل

(write(string: یک شی از نوع str یا bytes را دریافت می‌کند و آن را درون شی فایل مورد نظر می‌نویسد:

>>> text = '1) Python\n2) Programming\n3) Language\n'

>>> print(text)
1) Python
2) Programming
3) Language

>>>

>>> type(text)
<class 'str'>
>>> # Python 3x

>>> output = open('textfile.txt', 'w')
>>> output.write(text)
37
>>> output.close()

در پایتون 3x، متد write تعداد کاراکترهایی که می‌نویسد را برمی‌گرداند.

>>> # Python 3x

>>> output = open('binaryfile.bin', 'wb')
>>> output.write(text)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: a bytes-like object is required, not 'str'

در پایتون 3x به این دلیل که نوع رشته‌های باینری (bytes) از رشته‌های معمولی (str) جدا گشته است، نمی‌توان از شی str برای نوشتن در فایلی که در حالت باینری باز شده است استفاده کرد.

>>> # Python 3x

>>> data = '1) Python\n2) Programming\n3) Language\n'

>>> # Convert str to bytes
>>> bdata = bytes(data, 'utf-8')

>>> bdata
b'1) Python\n2) Programming\n3) Language\n'

>>> type(bdata)
<class 'bytes'>


>>> output = open('binaryfile.bin', 'wb')
>>> output.write(bdata)
37
>>> output.close()

در رفتار گنولینوکس تفاوتی بین حالت متنی و باینری وجود ندارد؛‌ اکنون اگر هر دو فایل textfile.txt و binaryfile.bin را (در گنولینوکس) توسط برنامه ویرایشگر متن باز نمایید، خواهید دید که محتوای این دو فایل مشابه یکدیگر نمایش داده می‌شوند.

در گنولینوکس، باز کردن فایل textfile.txt توسط یک برنامه ویرایشگر متن:

1) Python
2) Programming
3) Language

در گنولینوکس، باز کردن فایل binaryfile.bin توسط یک برنامه ویرایشگر متن:

1) Python
2) Programming
3) Language

ولی در ویندوز به هنگام حالت متنی، اگر یک فایل را به منظور خواندن باز نمایید کاراکترهای 'n\' موجود در آن به شکل 'r\n\' برگردانده می‌شوند و اگر که یک فایل را به منظور نوشتن باز کنید، هر بار رشته 'r\n\' به جای 'n\' نوشته می‌شود. در حالت باینری این کارها انجام نمی‌شود.

اگر دستورهای یاد شده را در ویندوز اجرا نماییم؛ دو فایل مورد نظر با محتوای پایین توسط برنامه ویرایشگر متن نمایش داده خواهند شد.

در ویندوز، باز کردن فایل textfile.txt:

1) Python
2) Programming
3) Language

در ویندوز، باز کردن فایل binaryfile.bin:

1) Python2) Programming3) Language

به نمونه‌ کدهای بالا در پایتون 2x نیز توجه نمایید:

>>> # Python 2x

>>> output = open('textfile.txt', 'w')
>>> output.write('1) Python\n2) Programming\n3) Language\n')
>>> output.close()
>>> # Python 2x

>>> data = '1) Python\n2) Programming\n3) Language\n'

>>> type(data)
<type 'str'>

>>> output = open('binaryfile.bin', 'wb')
>>> output.write(data)
>>> output.close()
>>> # Python 2x

>>> bdata = b'1) Python\n2) Programming\n3) Language\n'

>>> type(bdata)
<type 'str'>

>>> output = open('binaryfile.bin', 'wb')
>>> output.write(bdata)
>>> output.close()
  • ()close: پس از پایان کار با هر فایل می‌بایست که آن را ببندید؛ این متد فایل باز شده را می‌بندد. شی فایل مورد نظر پس از فراخوانی این متد، هیچ متد دیگری را نمی‌تواند فراخوانی کند.

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

همچنین برای بررسی اینکه یک فایل باز است یا اینکه بسته شده است می‌توانید از صفت closed استفاده نمایید؛ این صفت در صورتی که فایل بسته شده باشد حاوی مقدار True می‌باشد:

>>> f.closed
False

>>> f.close()

>>> f.closed
True
  • ()read: تمام محتوای فایل را می‌خواند و در قالب یک شی از نوع str - برای فایل‌های متنی در هر دو شاخه پایتون و باینری در پایتون 2x - یا bytes - برای فایل‌های باینری در پایتون 3x - برمی‌گرداند:
>>> input = open('textfile.txt')

>>> content = input.read()

>>> input.close()

>>> type(content)
<class 'str'>

>>> content
'1) Python\n2) Programming\n3) Language\n'

>>> print(content)
1) Python
2) Programming
3) Language

>>>
>>> # Python 3x, Reading a binary file

>>> input = open('binaryfile.bin', 'rb')

>>> content = input.read()

>>> input.close()

>>> type(content)
<class 'bytes'>

>>> content
b'1) Python\n2) Programming\n3) Language\n'

>>> print(content)
b'1) Python\n2) Programming\n3) Language\n'
>>>
>>> # Python 2x, Reading a binary file

>>> input = open('binaryfile.bin', 'rb')

>>> content = input.read()

>>> input.close()

>>> type(content)
<type 'str'>

>>> content
'1) Python\n2) Programming\n3) Language\n'

>>> print content
1) Python
2) Programming
3) Language

>>>

این متد یک آرگومان اختیاری نیز دارد؛ این آرگومان یک عدد صحیح است که تعداد کاراکتر (یا بایت) که می‌بایست از فایل خوانده و برگردانده شوند را تعیین می‌کند:

>>> f = open('textfile.txt')

>>> f.read(5)
'1) Py'

>>> f.read(5)
'thon\n'

>>> f.read(10)
'2) Program'

>>> f.read(4)
'ming'

>>> f.read(1)
'\n'

>>> f.close()

به نمونه کد بالا توجه نمایید؛ هنگامی که فایل در این حالت (rt) باز شده است اشاره‌گر در ابتدای فایل قرار گرفته و با هر میزان خواندن از فایل، موقعیت اشاره‌گر نیز به جلو حرکت داشته است.

  • ()readline: در هر فراخوانی یک سطر از فایل - تا رشته Newline - را برمی‌گرداند:
>>> f = open('textfile.txt')

>>> f.readline()
'1) Python\n'

>>> f.readline()
'2) Programming\n'

>>> f.readline()
'3) Language\n'

>>> f.readline()
''

>>> f.close()
  • ()readlines: تمام سطرهای یک فایل را در قالب یک شی لیست بر می‌گرداند:
>>> f = open('textfile.txt')

>>> cl = f.readlines()

>>> cl
['1) Python\n', '2) Programming\n', '3) Language\n']

>>> cl[1]
'2) Programming\n'

>>> f.close()
  • (writelines(list: یک شی لیست که تمام اعضای آن از نوع str هستند را به عنوان آرگومان گرفته و اعضای آن را به ترتیب در فایل مورد نظر می‌نویسد:
>>> L = ['a', 'b', 'c', 'd\n', 'e']

>>> f = open('tf.txt', 'w')
>>> f.writelines(L)
>>> f.close()

حاصل کد بالا؛ باز کردن فایل tf.txt توسط یک برنامه ویرایشگر متن:

abcd
e
  • (seek(offset: آرگومان offset یک عدد صحیح است و این متد موقعیت اشاره‌گر فایل را به آن offset نسبت به ابتدای فایل تغییر می‌دهد:
>>> f = open('textfile.txt')

>>> f.seek(3)
3

>>> f.read(6)
'Python'

>>> f.close()
  • ()flush: باعث ذخیره محتوای بافر در فایل می‌شود.

هنگامی که فایلی را به منظور نوشتن باز می‌کنید، تا پیش از زمان بستن فایل هر آنچه در آن می‌نویسید در بافر قرار داده می‌شود. فراخوانی این متد کمک می‌کند تا بدون بستن فایل، اطلاعات از بافر به فایل منتقل گردند.

دستور for

از تابع ()open نیز می‌توان در حلقه for استفاده کرد؛ در این صورت در هر بار تکرار سطرهای فایل پیمایش می‌شوند:

>>> for line in open('textfile.txt'):
...     print(line, end='')
...
1) Python
2) Programming
3) Language
>>>

از آنجا که متن درون فایل خود حاوی Newline (در اینجا: 'n\') است، آرگومان end تابع ()print را برای جلوگیری از درج 'n\' در انتهای هر سطر تغییر دادیم.

دستور with/as

یک دستور مرکب است که از اشیایی که با نوع ”Context Manager“ [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] در پایتون شناخته می‌شوند، پشتیبانی می‌کند [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]. برخی از اشیا در پایتون - به مانند شی فایل - قابلیتی با نام ”Context Manager“ دارند؛ برای پیاده سازی این قابلیت، کلاس شی مورد نظر می‌بایست حاوی دو متد ویژه ()__enter__ و ()__exit__ باشد که به ترتیب در زمان‌های «ورود به» و «خروج از» بدنه دستور with/as فراخوانی می‌شوند.

دستور with/as ساختاری مشابه پایین دارد:

with expression as variable:
    statement(s)

در این ساختار، expression نماد بخشی از دستور است که یک شی از نوع Context Manager را برمی‌گرداند؛ این شی با استفاده از کلمه کلیدی as به یک متغیر ارجاع داده می‌شود. برای نمونه ساختار with/as مربوط به یک شی فایل در پایین نوشته شده است:

with open('textfile.txt', 'w') as output:
    output.write('text')

پس از ایجاد شی فایل، این شی می‌بایست وارد اجرای دستور with/as شود؛ with/as این کار را با فراخوانی متد ()__enter__ انجام می‌دهد. در واقع این متد همان شی فایل ایجاد شده را برمی‌گرداند که در ادامه توسط as به متغیر output ارجاع داده می‌شود. همچنین با استفاده از این ساختار دیگر نیازی به فراخوانی متد ()close برای شی فایل نمی‌باشد؛ چرا که این کار پس از پایان دستورهای بدنه با فراخوانی شدن متد ()__exit__ توسط with/as به انجام می‌رسد؛ در واقع with/as بستن فایل را در پایان اجرای دستورهای بدنه خود تضمین می‌کند. همچنین در این ساختار چنانچه هنگام کار با فایل خطایی (یا استثنایی) رخ دهد، پیش از گزارش آن، ابتدا فایل بسته خواهد شد.

توجه داشته باشید که یک شی فایل همیشه باید بسته شود؛ در مواقعی که قصد استفاده از حلقه for برای یک شی فایل را دارید بهتر است از آن درون ساختار with/as بهره بگیرید:

with open('textfile.txt') as f:
    for line in f:
        print(line)

از دستور with/as می‌توان به شکل تودرتو نیز بهره گرفت:

with A() as a:
    with B() as b:
        statements

همچنین به نسخه‌های 2.7 و از 3.1 به بعد پایتون سینتکس جدیدی افزوده شده است که توسط آن می‌توان همزمان از چند Context Manager بهره گرفت:

with A() as a, B() as b:
    statements

به مانند نمونه کد پایین که دو فایل را باز می‌کند؛ از یکی می‌خواند و برخی از سطرهای آن را در فایل دیگر می‌نویسد:

with open('data') as fin, open('res', 'w') as fout:
    for line in fin:
        if 'key' in line:
            fout.write(line)

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

شی فایل استاندارد

سه نوع شی فایل توسط مفسر پایتون ایجاد می‌گردد که هر سه آن‌ها توسط ماژول sys در دسترس هستند:

  • sys.stdin: ورودی استاندارد [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]؛ برای دستیابی تمامی ورودی‌ها در حالت تعاملی پایتون - مانند فراخوانی تابع ()input - از این شی استفاده می‌گردد.
  • sys.stdout: خروجی استاندارد [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]؛ توسط print مورد استفاده قرار می‌گیرد.
  • sys.stderr: خطا استاندارد [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]؛ شی‌ای است که خطاها را دریافت می‌کند.

نه همیشه ولی می‌توان منبع sys.stdin را صفحه‌کلید کامپیوتر و منبع sys.stdout و sys.stderr را نیز صفحه‌نمایش در نظر گرفت.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

تابع ()input

از این تابع در پایتون برای گرفتن ورودی از کاربر - در حالت تعاملی - استفاده می‌گردد که در نسخه جدید تغییراتی با نسخه قدیمی ایجاد شده است.

پایتون 2x:

  • ()raw_input
  • ()input

در این شاخه از پایتون دو تابع ()raw_input [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] و ()input [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] برای همین منظور در دسترس است. تابع ()raw_input یک سطر از کاربر را می‌خواند و در قالب یک شی از نوع str برمی‌گرداند:

>>> s = raw_input()
Hello Python

با اجرا دستور سطر یکم، مفسر پایتون منتظر ورود متن می‌ماند - در این نمونه متن Hello Python نوشته می‌شود - سپس با دریافت کلید Enter تمام کاراکترهای دریافتی را در قالب یک شی رشته - نوع str - به متغیر s ارجاع می‌دهد:

>>> s
'Hello Python'
>>> type(s)
<type 'str'>

همچنین می‌توان متنی را برای مشاهده کاربر به صورت آرگومان در فراخوانی تابع قرار داد:

>>> s = raw_input("What's your name? ")
What's your name? Alan

>>> s
'Alan'
>>> s = raw_input("How old are you? ")
How old are you? 41

>>> s
'41'
>>> type(s)
<type 'str'>

تابع ()input در پایتون 2x نیز عملکردی برابر با دستور (()eval(raw_input دارد. ()eval [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] تابع آماده دیگری در پایتون است که یک شی رشته را دریافت و متن آن را به شکل کد پایتون تفسیر می‌کند:

>>> x = 1
>>> y = eval('x + 1')
>>> y
2
>>> type(y)
<type 'int'>

به نمونه کدهای پایین نیز توجه نمایید:

>>> eval("9 // 2")
4

>>> eval("9 /// 2")
  File "<string>", line 1
    9 /// 2
        ^
SyntaxError: invalid syntax
>>>
>>> a = '32'
>>> type(a)
<type 'str'>

>>> b = eval(a)

>>> b
32
>>> type(b)
<type 'int'>
>>> print eval("__import__('os').getcwd()")
/home/saeid

تابع ()__import__ [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] عملکردی برابر با دستور import دارد ولی با این تفاوت که می‌توان از آن به شکلی پویا در طی اجرای برنامه برای وارد کردن ماژول‌های گوناگون استفاده نمود؛ در این حالت نام یک ماژول حتی می‌تواند به شکل یک متغیر در آرگومان تابع قرار بگیرد.

اکنون که با عملکرد تابع ()eval آشنا شده‌اید به بیان مثال‌هایی از تابع ()input - در نسخه‌های 2x - می‌پردازیم:

>>> s = input("What's your name? ")
What's your name? Alan

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'Alen' is not defined
>>>

در نمونه کد بالا؛ ورودی کاربر - متن Alen - با هیچ سینتکس تعریف شده‌ای در پایتون مطابقت نداشته و باعث بروز خطا گشته است:

>>> s = input("What's your name? ")
What's your name? "Alan"

>>> s
'Alan'
>>> s = input("How old are you? ")
How old are you? 41

>>> s
41
>>> type(s)
<type 'int'>

و مثالی دیگر:

>>> a = raw_input()
3 * 4 ** 5

>>> a
'3 * 4 ** 5'


>>> b = input()
3 * 4 ** 5

>>> b
3072

پایتون 3x:

  • ()input

در این شاخه از پایتون تابع ()input از شاخه 2x وجود ندارد (حذف شده) و تنها تابع ()raw_input باقی مانده است که آن هم به ()input [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] تغییر نام پیدا کرده است.

تابع ()input در پایتون 3x همانند تابع ()raw_input در پایتون 2x است:

>>> s = input("What's your name? ")
What's your name? Alan

>>> s
'Alan'
>>> type(s)
<class 'str'>

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

تابع print()

پایتون 2x:

در این شاخه از پایتون print به شکل یک دستور ساده در پایتون پیاده‌سازی شده است [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]. این دستور یک یا چند شی را ابتدا به نوع str تبدیل کرده و سپس به خروجی می‌فرستد:

>>> s = 'Python'

>>> print s
Python

>>> print s, "2.x"
Python 2.x

>>> print 4 * 5 / 2, 3 * 3
10 9
>>> print

>>>
  • اشیا می‌بایست توسط یک کاما , از یکدیگر جدا شوند.
  • این دستور به صورت پیش‌فرض یک حرف فاصله (یک کلید Space) در بین اشیا قرار می‌دهد.
  • در صورتی که یک عبارت محاسباتی یا منطقی به این دستور داده شود، ابتدا حاصل آن محاسبه یا ارزیابی شده و سپس به نوع str تبدیل می‌گردد.
  • دستور print به شکل تنها، یکی سطر خالی را ایجاد می‌کند.

دستور print همچنین به صورت پیش‌فرض یک 'n\' در انتهای هر سطر قرار می‌دهد؛ برای لغو این رفتار می‌توان در انتهای دستور یک کاما , قرار داد:

>>> for a in range(5):
...     print a
...
0
1
2
3
4
>>>


>>> for a in range(5):
...     print a,
...
0 1 2 3 4
>>>

این دستور توانایی نوشتن در شی فایلی غیر از شی استاندارد را نیز دارد؛ برای این منظور می‌بایست از الگوی پایین پیروی گردد:

>>> text = 'Hi :)'
>>> output = open('textfile.txt', 'w')

>>> print >> output, text

>>> output.close()

پایتون 3x:

دستور print به شکل تابع ()print در نسخه‌های 3x پایتون پیاده‌سازی شده است [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]؛ الگوی این تابع به شکل پایین می‌باشد:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
>>> s = 'Python'

>>> print(s)
Python

>>> print(s, '3x')
Python 3x

>>> print(4 * 5 / 2, 3 * 3)
10.0 9
  • sep: رشته‌ای که می‌بایست بین اشیا قرار گیرد را تعیین می‌کند. مقدار این آرگومان در حالت پیش‌فرض یک حرف فاصله (یک کلید Space) است. مقدار ارسالی به این آرگومان می‌بایست یک شی رشته یا None باشد:
>>> print(s, '3x', sep='-')
Python-3x

>>> print(s, '3x', sep=None)
Python 3x
  • end: رشته‌ای که می‌بایست در انتهای هر سطر قرار گیرد را تعیین می‌کند. مقدار این آرگومان در حالت پیش‌فرض 'n\' است. مقدار ارسالی به این آرگومان می‌بایست یک شی رشته یا None باشد:
>>> for a in range(5):
...     print(a)
...
0
1
2
3
4
>>>


>>> for a in range(5):
...     print(a, end=' ')
...
0 1 2 3 4 >>>

file: خروجی را تعیین می‌کند که می‌بایست یک شی به همراه متد (write(string درون کلاس خود، باشد. این آرگومان به صورت پیش‌فرض بر روی خروجی استاندارد مقداردهی شده است. این تابع قابلیت استفاده در حالت باینری فایل‌ها را ندارد:

>>> output = open('textfile.txt', 'w')

>>> print('Hi :)', file=output)

>>> output.close()
  • flush: این آرگومان از نسخه 3.3 به تابع ()print پایتون افزوده شده است. هنگامی که خروجی بر روی یک فایل قرار گرفته باشد؛ با تنظیم این گزینه بر روی مقدار True، عمل انتقال متن به فایل بدون اتلاف وقت انجام می‌پذیرد.

این تابع با استفاده از دستور import پایین در نسخه‌های 2.6 و 2.7 پایتون نیز در دسترس است [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]:

from __future__ import print_function

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

کتابخانه استاندارد

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

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
و

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
مشاهده نمایید. لازم به یادآوری است که بخشی بزرگی از قدرت پایتون به دلیل وجود کتابخانه‌های فراوان و قدرتمند آن است که تعداد زیادی از آن‌ها خارج کتابخانه استاندارد پایتون و درون جامعه کاربری در حال توسعه هستند که فهرست تقریبا کاملی از آن‌ها نیز توسط

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
قابل جستجو و دریافت هستند.

math

این ماژول حاوی ثابت‌ها (Constants) و تابع‌های ریاضی است [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] که برخی از آن‌ها به شرح پایین است:

  • math.pi: ثابتی حاوی عدد π (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ) است [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.pi
3.141592653589793
>>>
  • math.e: ثابتی حاوی عدد e (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ) است [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.e
2.718281828459045
>>>
  • math.inf: (از نسخه 3.5 به بعد) - ثابتی حاوی مقدار مثبت بی‌نهایت (Positive infinity) است که این مقدار برابر با خروجی تابع ('float('inf می‌باشد. math.inf - نیز برابر منفی بی‌نهایت است [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ].

برای بررسی inf بودن (مثبت یا منفی) از تابع (math.isinf(x [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] استفاده می‌شود:

>>> import math

>>> a = math.inf
>>> b = 10
>>> a > b
True

>>> math.inf + math.inf
inf
>>> 1 / math.inf
0.0
>>> math.inf / 2
inf
>>> 3 * math.inf
inf
>>> -3 * math.inf
-inf

>>> math.isinf(a)
True
>>> math.isinf(b)
False
>>>
  • math.nan: از نسخه 3.5 به بعد - ثابتی حاوی مقدار «تعریف نشده» یا NaN - اختصار Not a Number (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ) - می‌باشد که این مقدار برابر با خروجی تابع ('float('nan است [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ].

برای بررسی nan بودن از تابع (math.isnan(x [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] استفاده می‌شود:

>>> import math

>>> a = math.nan
>>> a
nan

>>> 0 * math.inf
nan
>>> math.inf - math.inf
nan

>>> math.isnan(a)
True
>>>
  • (math.ceil(x: کوچکترین عدد صحیحی که بزرگتر یا مساوی با عدد x باشد را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.ceil(4)
4
>>> math.ceil(-4.17)
-4
>>> math.ceil(4.17)
5
>>>
  • (math.floor(x: بزرگترین عدد صحیحی که کوچکتر یا مساوی با عدد x باشد را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.floor(4)
4
>>> math.floor(-4.17)
-5
>>> math.floor(4.17)
4
>>>
  • (math.fabs(x: همانند تابع آماده ()abs [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ] مقدار قدر مطلق (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ) عدد x را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.fabs(-4.17)
4.17
>>> math.fabs(-4)
4.0
>>> math.fabs(4)
4.0
>>>
  • (math.factorial(x: مقدار فاکتوریل (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ) عدد x را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.factorial(5)
120
>>>
  • (math.exp(x: حاصل e**x (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ) را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.exp(3)
20.085536923187668
>>>
  • (math.log(x[, base]: حاصل لگاریتم (Logarithm) عدد x در پایه base را برمی‌گرداند؛ آرگومان base اختیاری است و چنانچه ذکر نگردد به صورت پیش‌فرض حاصل لگاریتم عدد x در پایه عدد e یا همان لگاریتم طبیعی (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ) برگردانده می‌شود [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.log(math.e)     # ln e == 1
1.0
>>> math.log(1)          # ln 1 == 0
0.0
>>>
>>> math.log(8, 2)       # 2**3 == 8
3.0
>>> math.log(100, 10)    # 10**2 == 100
2.0
>>> math.log(81, 3)      # 3**4 == 81
4.0
>>> math.log(2, 10)
0.30102999566398114
>>>

برای سادگی استفاده در محاسبه‌های ریاضی دو تابع (log10(x [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] - محاسبه لگاریتم عدد x در پایه عدد 10 - و (log2(x [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] - محاسبه لگاریتم عدد x در پایه عدد 2؛ که از نسخه 3.3 به بعد اضافه شده است - نیز در دسترس هستند:

>>> math.log10(100)
2.0
>>> math.log2(8)
3.0
>>>
  • (math.sqrt(x: ریشه دوم (Square root) یا همان جذر (

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    )‌ عدد x را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.sqrt(4)
2.0
>>>
  • (math.pow(x, y: عدد x را به توان عدد y می‌رساند و حاصل را برمی‌گرداند [اسناد پایتون]:

این تابع هر دو آرگومان خود را به نوع float تبدیل می‌کند؛ چنانچه می‌خواهید با اعداد صحیح کار کنید، از عملگر ** یا تابع آماده ()pow [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] استفاده نمایید:

>>> 3**2
9
>>> pow(3, 2)
9
  • توابع مثلثاتی (Trigonometric functions) [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:  (cos(x و (sin(x و (tan(x و (acos(x و (asin(x و (atan(x که در تمام آن‌ها زاویه x بر حسب رادیان (Radian) است:
>>> import math

>>> math.cos(0)
1.0
>>> math.sin(0)
0.0
>>> math.tan(0)
0.0
>>>
  • (math.degrees(x: زاویه x را از رادیان به درجه تبدیل می‌کند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.degrees(0)
0.0
  • (math.radians(x: زاویه x را از درجه به رادیان تبدیل می‌کند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import math

>>> math.degrees(0)
0.0
>>> math.radians(30)
0.5235987755982988
>>> math.sin(math.radians(90))
1.0
  • توابع هذلولی (Hyperbolic functions) [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:  (cosh(x و (sinh(x و (tanh(x و (acosh(x و (asinh(x و (atanh(x.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

OS

این ماژول امکان استفاده از برخی قابلیت‌های وابسته به سیستم عامل را فراهم می‌آورد؛ مانند گرفتن مسیر دایرکتوری برنامه [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]. برخی از تابع‌های موجود در این ماژول به شرح پایین است:

  • os.environ: یک شی از نوع نگاشت - مانند نوع دیکشنری - است که حاوی متغیرهای محیطی سیستم عامل می‌باشد [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]

باید توجه داشت که مقدار این دستور متناسب با لحظه‌ای از سیستم عامل است که ماژول os به اسکریپت import شده است و شامل متغیرهایی که پس از این لحظه ایجاد شده باشند نمی‌شود.

>>> # Python 3.x, GNU/Linux

>>> import os
>>> os.environ
environ({'LOGNAME': 'saeid', 'PWD': '/home/saeid', '_': '/usr/bin/python3', 'LANG': 'en_US.UTF-8', 'PATH': '/usr/local/sbin:/usr/local/bin:/usr/bin', 'ZSH': '/home/saeid/.oh-my-zsh'})
>>>
>>> os.environ['PATH']
'/usr/local/sbin:/usr/local/bin:/usr/bin'

>>> os.environ['LANG']
'en_US.UTF-8'
  • ()os.getcwd: مسیر دایرکتوری جاری (Current Working Directory)‌ را برمی‌گرداند. خروجی این تابع برابر با دستور pwd در خط فرمان گنولینوکس یا %echo %CD در خط فرمان ویندوز می‌باشد. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
# Python 3.x, GNU/Linux

~ pwd
/home/saeid
~ python3 -q
>>> import os
>>> os.getcwd()
'/home/saeid'
>>>
  • (os.chdir(path: مسیر دایرکتوری جاری را به مسیر آرگومان دریافتی path تغییر می‌دهد. عملکرد این تابع برابر با دستور cd در خط فرمان‌های گنولینوکس و ویندوز است. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os

>>> os.getcwd()
'/home/saeid'

>>> os.chdir('/etc')

>>> os.getcwd()
'/etc'
  • (os.listdir(path: یک شی لیست که شامل محتویات درون دایرکتوری path است را برمی‌گرداند. چنانچه آرگومان path ارسال نشود به صورت پیش‌فرض مسیر دایرکتوری جاری در نظر گرفته می‌شود. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]
>>> import os
>>> os.listdir('/home/saeid/Pictures')
['scan0001.jpg', 'smplayer_screenshots', 'GNU.png', 'Wallpapers']
  • (os.mkdir(path: یک دایرکتوری که نام کامل آن توسط آرگومان path تعیین شده است را ایجاد می‌کند. در صورتی که این دایرکتوری از قبل موجود باشد یک استثنا FileExistsError رخ می‌دهد. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os
>>> os.mkdir('dir1')

در نمونه کد بالا از آنجا که مسیر دایرکتوری ذکر نشده است؛ دایرکتوری dir1 به صورت پبش فرض در مسیر دایرکتوری جاری (که در اینجا: /home/saeid/ است) ایجاد می‌گردد؛ همین امر باعث بروز استثنا با اجرای دستور پایین می‌شود:

>>> os.mkdir('/home/saeid/dir1')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: '/home/saeid/dir1'
>>> os.mkdir('/home/saeid/Documents/dir2')

نمونه کد بالا موجب ایجاد دایرکتوری dir2 درون مسیر دایرکتوری Documents می‌شود.

مسیر دایرکتوری می‌بایست به صورت صحیح وارد شود؛ در نمونه کد پایین نیز به همین دلیل که دایرکتوری dir3 وجود ندارد، استثنایی رخ داده است.

>>> os.mkdir('/home/saeid/Documents/dir3/dir4')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: '/home/saeid/Documents/dir3/dir4'
  • (os.makedirs(path: همانند (os.mkdir(path است ولی با این تفاوت که تمامی دایرکتوری‌های میانی مورد نیاز را هم ایجاد می‌کند. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]

در نمونه کد پایین برای ایجاد دایرکتوری dir5 دایرکتوری‌های dir3 و dir4 - که البته وجود ندارند - نیز ایجاد می‌گردند.

>>> import os
>>> os.makedirs('/home/saeid/Documents/dir3/dir4/dir5')
  • (os.rmdir(path: دایرکتوری مشخص شده توسط آرگومان path را حذف می‌کند. این دایرکتوری می‌بایست خالی باشد در غیر این صورت یک استثنا OSError رخ می‌دهد. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]

البته برای حذف کامل یک دایرکتوری به همراه تمام محتویات آن می‌توانید از تابع (rmtree(path درون ماژول shutil [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
] استفاده نمایید:

>>> import shutil
>>> shutil.rmtree("/home/saeid/Documents/dir1")
  • (os.removedirs(path: همانند (os.rmdir(path است ولی با این تفاوت که عملکردی بازگشتی دارد و تا زمانی که خطایی رخ نداده دایرکتوری‌های مشخص شده در آرگومان path را یکی یکی حذف می‌کند. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]
>>> import os
>>> os.removedirs('/home/dir1/dir2/dir3')

در نمونه کد بالا ابتدا دایرکتوری dir3 (با مسیر 'home/dir1/dir2/dir3/') حذف می‌شود - البته اگر خالی باشد - و بعد از آن برای حذف دایرکتوری dir2 (با مسیر 'home/dir1/dir2/') تلاش می‌شود که اگر آن‌هم خالی باشد و حذف گردد، روند حذف به همین شکل برای باقی مسیر ادامه می‌یابد.

  • (os.rename(src, dst: این تابع برای تغییر نام یک فایل یا دایرکتوری کاربرد دارد. آرگومان src نام اصلی و آرگومان dst نیز نام جدید برای فایل یا دایرکتوری مورد نظر می‌باشند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os
>>> os.getcwd()
'/home/saeid/Documents/dir'
>>> os.listdir(os.getcwd())
['fontsdir', 'index.html', 'style.css']

>>> os.rename("fontsdir", "_fonts")

>>> os.listdir(os.getcwd())
['index.html', 'style.css', '_fonts']

توجه داشته باشید چنانچه فایل یا دایرکتوری موردنظر در مسیری دیگری از مسیر دایرکتوری جاری باشد؛ لازم است نام به شکل کامل (همراه با مسیر) ذکر گردد. همچنین بدیهی است که تغییر مسیر در آرگومان dst موجب عمل انتقال (Move) می‌شود:

>>> import os
>>> os.getcwd()
'/home/saeid/Documents/dir/dir1'
>>> os.listdir(os.getcwd())
['index.html', 'style.css', '_fonts']

>>> os.rename("_fonts", "/home/saeid/Documents/dir/dir2/_fonts")

>>> os.listdir(os.getcwd())
['index.html', 'style.css']

>>> os.chdir('/home/saeid/Documents/dir/dir2')
>>> os.listdir(os.getcwd())
['_fonts']

در گنولینوکس چنانچه بخواهیم نام فایلی به یک نام از پیش موجود تغییر داده شود؛‌ [در صورتی که کاربر نیز اجازه دسترسی (Permission) لازم را داشته باشد] یک عمل جایگزینی (Replace) صورت می‌گیرد، ولی برای چنین مواقعی در سیستم عامل ویندوز یک خطای OSError رخ خواهد داد. رویداد این ماجرا در هنگام تغییر نام یک دایرکتوری، باعث بروز خطای OSError در هر دو سیستم عامل می‌شود.

  • (os.renames(old, new: عملکردی مشابه با تابع ()rename دارد با این تفاوت که اگر دایرکتورهای میانی از مسیر آرگومان new، وجود نداشته باشند، آن‌ها را نیز ایجاد می‌کند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os
>>> os.getcwd()
'/home/saeid/Documents/dir'
>>> os.listdir(os.getcwd())
['index.html', 'style.css', '_fonts', 'js']

>>> os.renames("style.css", "css/style.css")

>>> os.listdir(os.getcwd())
['index.html', 'css', '_fonts', 'js']
  • (os.walk(rootdirpath: مسیر یک دایرکتوری را به عنوان دایرکتوری ریشه پیمایش می‌کند و مسیر هر دایرکتوری را که می‌بیند به همراه نام دایرکتوری‌ها و فایل‌های درون آن برمی‌گرداند. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
dir1
├── dir2
   └── file21
├── file11
└── file12
>>> import os

>>> tuple(os.walk('/home/saeid/Documents/dir1'))
(('/home/saeid/Documents/dir1', ['dir2'], ['file12', 'file11']), ('/home/saeid/Documents/dir1/dir2', [], ['file21']))
>>> import os

>>> for root, dirs, files in os.walk('/home/saeid/Documents/dir1'):
...     print('Found directory: {}'.format(root))
...     for filename in files:
...         print('\t{}'.format(filename))
...
Found directory: /home/saeid/Documents/dir1
  file12
  file11
Found directory: /home/saeid/Documents/dir1/dir2
  file21
>>>

جهت پیمایش دایرکتوری‌ها به صورت پیش‌فرض از بالا (دایرکتوری ریشه) به پایین است که می‌توان با False قرار دادن آرگومان اختیاری topdown آن را معکوس نمود:

>>> for root, dirs, files in os.walk('/home/saeid/Documents/dir1', topdown=False):
...     print('Found directory: {}'.format(root))
...     for filename in files:
...         print('\t{}'.format(filename))
...
Found directory: /home/saeid/Documents/dir1/dir2
    file21
Found directory: /home/saeid/Documents/dir1
    file12
    file11
>>>
  • os.sep: این متغیر حاوی کاراکتری می‌باشد که سیستم‌عامل از آن برای جدا سازی اجزای یک مسیر استفاده می‌کند. مانند: / در گنولینوکس یا \\ در ویندوز [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]
  • os.extsep: این متغیر حاوی کاراکتری می‌باشد که در سیستم‌عامل جاری از آن برای جدا سازی نام فایل از پسوند آن استفاده می‌گردد. مانند: . (نام فایل: script.py) [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]
  • os.pardir: حاوی مقداری است که در سیستم‌عامل جاری از آن برای اشاره به یک دایرکتوری بالاتر از دایرکتوری جاری استفاده می‌گردد (Parent Directory). مانند: .. در گنولینوکس و ویندوز [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
# GNU/Linux

~ pwd
/home/saeid/Documents

~ cd ..

~ pwd
/home/saeid
  • os.curdir: حاوی مقداری است که در سیستم‌عامل جاری از آن برای اشاره به دایرکتوری جاری استفاده می‌گردد (Current Directory). مانند: . در گنولینوکس و ویندوز [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
# GNU/Linux

~ pwd
/home/saeid

~ cd .

~ pwd
/home/saeid

~ cd ./..

~ pwd
/home

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

os.path

این ماژول توابعی مفیدی برای کار با مسیر فایل‌ها و دایرکتوری‌ها پیاده‌سازی کرده است [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
].

ملاحظه: برای خواندن و نوشتن فایل‌ها از ()open و برای دسترسی به سیستم‌فایل از ماژول os استفاده نمایید.

  • (os.path.split(path: مسیر path دریافتی را به یک تاپل (dirname, basename) تجزیه می‌کند که در آن basename آخرین بخش از مسیر path و dirname نیز هر آنچه قبل از basename باشد، خواهند بود [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os.path

>>> for path in [ '/one/two/three',
...               '/one/two/three/',
...               '/',
...               '.',
...               '']:
...     print ('"%s" : "%s"' % (path, os.path.split(path)))
...
"/one/two/three" : "('/one/two', 'three')"
"/one/two/three/" : "('/one/two/three', '')"
"/" : "('/', '')"
"." : "('', '.')"
"" : "('', '')"
>>>
  • (os.path.basename(path: مقداری برابر با بخش دوم از تاپل خروجی تابع (os.path.split(path را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os.path
>>>
>>> for path in [ '/one/two/three',
...               '/one/two/three/',
...               '/',
...               '.',
...               '']:
...     print ('"%s" : "%s"' % (path, os.path.basename(path)))
...
"/one/two/three" : "three"
"/one/two/three/" : ""
"/" : ""
"." : "."
"" : ""
>>>
  • (os.path.dirname(path: مقداری برابر با بخش یکم از تاپل خروجی تابع (os.path.split(path را برمی‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os.path
>>>
>>> for path in [ '/one/two/three',
...               '/one/two/three/',
...               '/',
...               '.',
...               '']:
...     print ('"%s" : "%s"' % (path, os.path.dirname(path)))
...
"/one/two/three" : "/one/two"
"/one/two/three/" : "/one/two/three"
"/" : "/"
"." : ""
"" : ""
>>>
  • (os.path.splitext(path: مشابه تابع (os.path.split(path است با این تفاوت که پسوند را از path جدا کرده و نتیجه را به شکل تاپل بر می‌گرداند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os.path
>>>
>>> for path in [ 'filename.txt',
...               'filename',
...               '/path/to/filename.txt',
...               '/',
...               '.',
...               '']:
...     print ('"%s" : "%s"' % (path, os.path.splitext(path)))
...
"filename.txt" : "('filename', '.txt')"
"filename" : "('filename', '')"
"/path/to/filename.txt" : "('/path/to/filename', '.txt')"
"/" : "('/', '')"
"." : "('.', '')"
"" : "('', '')"
>>>
  • (os.path.join(*paths: اجزای یک مسیر را به یکدیگر متصل می‌کند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
# GNU/Linux

import os

>>> os.path.join('one', 'two', 'three')
'one/two/three'

>>> os.path.join(os.sep, 'one', 'two', 'three')
'/one/two/three'
# Windows

import os

>>> os.path.join('one', 'two', 'three')
'one\\two\\three'

>>> os.path.join(os.sep, 'one', 'two', 'three')
'\\one\\two\\three'

همچنین برای ایجاد چندین مسیر به صورت همزمان، می‌توان اجزای هر مسیر را به صورت یک تاپل (یا لیست) درون یک لیست قرار داد و سپس با استفاده از حلقه for، اجزای هر مسیر را جداگانه به تابع join ارسال نمود. البته باید توجه داشت که می‌بایست پارامتر مشخص شده در تعریف تابع join با یک ستاره مشخص شده باشد؛ در این حالت اجزای درون یک تاپل (یا لیست) به صورت پارامترهای جدا تابع در نظر گرفته می‌شوند، چیزی مانند نمونه کد بالا - در درس تابع دوباره به این شیوه ارسال پارامتر اشاره خواهد شد - به نمونه کد پایین توجه نمایید:

>>> import os

>>> for parts in [ ('one', 'two', 'three'),
...                ('/', 'one', 'two', 'three'),
...                ('/one', 'two', '/three', 'four'),
...                ]:
...     print (parts, ':', os.path.join(*parts))
...
('one', 'two', 'three') : one/two/three
('/', 'one', 'two', 'three') : /one/two/three
('/one', 'two', '/three', 'four') : '/three/four'
>>>

توجه: هر مسیر می‌بایست دقیقا شامل یک کاراکتر جدا کننده دایرکتوری (os.sep) باشد در غیر این صورت اجزا فقط از آخرین نمونه به بعد در نظر گرفته می‌شوند. این اتفاق در تاپل سوم ('one', 'two', '/three', 'four/') از نمونه کد بالا رخ داده است.

  • (os.path.expanduser(path: این تابع تنها یک پارامتر با ترکیب user~ می‌پذیرد و کاراکتر ~ را به مسیر دایرکتوری کاربر user در سیستم عامل تبدیل می‌کند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
# GNU/Linux

>>> os.path.expanduser('~saeid')
'/home/saeid'
# Windows

>>> os.path.expanduser('~saeid')
'C:\\Documents and Settings\\saeid'
# GNU/Linux

>>> for user in [ '', 'saeid', 'www-data', 'postgres' ]:
...     lookup = '~' +  user
...     print (lookup, ':', os.path.expanduser(lookup))
...
~ : /home/saeid
~saeid : /home/saeid
~www-data : /var/www
~postgres : /var/lib/postgresql
>>>
  • (os.path.expandvars(path: این تابع مقدار متغیرهای محیطی موجود در پارامتر دریافتی را جایگزین کرده و حاصل را برمی‌گرداند. نام متغیرها می‌بایست با الگوی name$ داخل پارامتر ذکر گردند. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os

>>> os.environ['MYVAR'] = 'VALUE'
>>> os.path.expandvars('/path/to/$MYVAR')
'/path/to/VALUE'
  • (os.path.normpath(path: مسیر را نرمال‌سازی می‌کند. در این راه تمام مسیرهایی که به یکی از اشکال A//B A/B/ A/./B A/foo/../B هستند، به صورت A/B ارزیابی می‌شوند. همچنین در سیستم عامل ویندوز کاراکتر جداکننده دایرکتوری گنولینوکس (/) را به \ تبدیل می‌کند [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> for path in [ 'one//two//three',
...               'one/./two/./three',
...               'one/../one/two/three',
...               ]:
...     print (path, ':', os.path.normpath(path))
...
one//two//three : one/two/three
one/./two/./three : one/two/three
one/../one/two/three : one/two/three
>>>
# Windows

>>> for path in [ 'one/two/three',
...
...               'one\\two\\three',
...               'one\\.\\two\\.\\three',
...               'one\\..\\one\\two\\three',
...               ]:
...     print (path, ':', os.path.normpath(path))
...
one/two/three : one\two\three
one\two\three : one\two\three
one\.\two\.\three : one\two\three
one\..\one\two\three : one\two\three
  • (os.path.abspath(path: مسیر نسبی را نرمال‌سازی کرده و به مسیر مطلق (Absolute - مسیری از ابتدا یا همان روت سیستم فایل - در گنولینوکس: مسیری که با / شروع شده باشد - در ویندوز: مسیری که با نام یک درایو شروع شده باشد) تبدیل می‌کند. حاصل این تابع برابر با حاصل (os.path.normpath(os.path.join(os.getcwd(), path) می‌باشد. [

    محتوای مخفی

      برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
    ]:
>>> import os

>>> os.getcwd()
'/mnt/Data/WorkSpace/PythonPersianTutorial'

>>> for path in [ '.',
...               '..',
...               './one/two/three',
...               '../one/two/three']:
...     print ('"%s" : "%s"' % (path, os.path.abspath(path)))
...
"." : "/mnt/Data/WorkSpace/PythonPersianTutorial"
".." : "/mnt/Data/WorkSpace"
"./one/two/three" : "/mnt/Data/WorkSpace/PythonPersianTutorial/one/two/three"
"../one/two/three" : "/mnt/Data/WorkSpace/one/two/three"
>>>
# Windows

>>> import os

>>> os.getcwd()
'C:\\Python34'

>>> for path in [ '.',
...               '..',
...               './one/two/three',
...               '../one/two/three']:
...     print ('"%s" : "%s"' % (path, os.path.abspath(path)))
...
"." : "C:\Python34"
".." : "C:\"
"./one/two/three" : "C:\Python34\one\two\three"
"../one/two/three" : "C:\one\two\three"
>>>

گاهی لازم است که یک مسیر بررسی شود که آیا مربوط به یک فایل است یا دایرکتوری یا لینک نمادین (

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
)، مسیر مطلق (Absolute) است یا خیر، اصلا وجود دارد یا خیر و ... برای این منظور می‌توان از توابع پایین استفاده کرد:

isabs(path): چنانچه مسیر مطلق باشد True برمی‌گرداند [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]

isfile(path): چنانچه مسیر مربوط به یک فایل که موجود نیز هست باشد True برمی‌گرداند. این تابع لینک‌های به فایل را نیز دنبال می‌کند، پس این تابع می‌تواند همراه با تابع islink برای یک مسیر مشخص مقدار True را برگرداند. [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]

isdir(path): چنانچه مسیر مربوط به یک دایرکتوری که موجود نیز هست باشد True برمی‌گرداند. این تابع لینک‌های به دایرکتوری را نیز دنبال می‌کند، پس این تابع می‌تواند همراه با تابع islink برای یک مسیر مشخص مقدار True را برگرداند. [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]

islink(path): چنانچه مسیر مربوط به یک لینک نمادین باشد True برمی‌گرداند. [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]

exists(path): چنانچه مسیر دریافتی صرف نظر از اینکه مربوط به یک فایل است یا دایرکتوری، موجود باشد True برمی‌گرداند. [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]

lexists(path):چنانچه مسیر لینک نمادین دریافتی موجود باشد True برمی گرداند. این تابع لینک را دنبال نمی‌کند و بررسی نمی‌کند که لینک سالم هست یا خیر. [

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
]

# Python 3.x
# File Name: file_script.py

import os

for path in [ __file__, os.path.dirname(__file__), '/', '/var/www/html/wordpress']:
    print ('Path            :', path)
    print ('Absolute        :', os.path.isabs(path))
    print ('Is File?        :', os.path.isfile(path))
    print ('Is Directory?   :', os.path.isdir(path))
    print ('Is Link?        :', os.path.islink(path))
    print ('Is Mount point? :', os.path.ismount(path))
    print ('Exists?         :', os.path.exists(path))
    print ('Link Exists?    :', os.path.lexists(path))
    print ()
Path            : /home/saeid/Desktop/file_script.py
Absolute        : True
Is File?        : True
Is Directory?   : False
Is Link?        : False
Is Mount point? : False
Exists?         : True
Link Exists?    : True

Path            : /home/saeid/Desktop
Absolute        : True
Is File?        : False
Is Directory?   : True
Is Link?        : False
Is Mount point? : False
Exists?         : True
Link Exists?    : True

Path            : /
Absolute        : True
Is File?        : False
Is Directory?   : True
Is Link?        : False
Is Mount point? : True
Exists?         : True
Link Exists?    : True

Path            : /var/www/html/wordpress
Absolute        : True
Is File?        : False
Is Directory?   : True
Is Link?        : True
Is Mount point? : False
Exists?         : True
Link Exists?    : True

متغیر __file__ در هر اسکریپتی به نام کامل آن اسکریپت اشاره دارد.

مسیر چهارم در نمونه کد بالا در واقع مسیر لینکی است به یک دایرکتوری دیگر.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

در ادامه آموزش های مربوط به پایتون که در سایت کتاب آموزش برخط گذاشته شده قرار میگیره.

افزودن به لیست متد append

در این آموزش از کتاب برخط پایتون (Python)، متدی را برای افزودن یا add کردن یک شیء به لیست را بررسی خواهیم کرد. متد append()، شیء یا آبجکت ارسال شده را، به انتهای List فعلی اضافه می کند و معادل این کد می باشد: a[len(a):] = [obj]

شکل دستوری

شکل دستوری این method به صورت زیر است:

list.append(obj)

پارامتر ها

obj شیء یا آبجکت اضافه شده در List است.

مقدار برگشتی (Return)

این method هیچ مقداری را باز نمی گرداند، ولی لیست فعلی را به روز رسانی می کند.

مثال

مثال زیر روش استفاده از این متد را نشان می دهد.

#!/usr/bin/python3
list1 = ['C++', 'Java', 'Python']
list1.append('Ruby')
print ("updated: ", list1)

خروجی

بعد از اجرا کردن کد بالا، خروجی زیر حاصل خواهد شد:

updated:  ['C++', 'Java', 'Python', 'Ruby']

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

متغیرها، عبارات و جمله ها در پایتون

مقادیر و نوع ها

مقدار (value) یکی از چیز های پایه می باشد که یک برنامه با آن سر و کار دارد، مانند یک حرف یا یک عدد.

این مقادیر متعلق به نوع های مختلفی می باشد: عدد 2 یک integer می باشد، و 'Hello, World!' یک رشته، زیرا رشته ای از حروف می باشد. شما (و مفسر) می توانید رشته ها را تشخیص دهید چرا که رشته ها درون علامت کتیشن قرار می گیرند.

در صورتی که نوع یک مقدار را نمی دانید، مفسر می تواند به شما نوع آن مقدار را نشان دهد.

>>> type('Hello, World!')
<type 'str'>
>>> type(17)
<type 'int'>

موضوع عجیبی نیست، رشته ها متعلق به نوع str و اعداد متعلق به نوع int می باشند. بدیهی است که اعداد اعشاری متعلق به نوع float می باشند. چرا که این اعداد در قالب اعشاری نمایش داده می شوند.

>>> type(3.2)
<type 'float'>

گاهی اوقات مقادیر به شکل '17' و یا '3.2' نمایش داده می شوند، تکلیف این مقادیر چه می شود؟ این مقادیر شبیه به اعداد هستند، ولی درون علامت کتیشن قرار گرفته اند مانند رشته ها.

>>> type('17')
<type 'str'>
>>> type('3.2')
<type 'str'>

نوع این نوع مقادیر نیز رشته می باشد.

زمانی که می خواهید یک عدد طولانی را تایپ کنید، ممکن است بخواهید بین آن رقم سه رقم از کاما استفاده کنید، مانند 1,000,000. این یک نوع integer قانونی در پایتون به شمار نمی آید، ولی موردی نخواهد داشت:

>>> 1,000,000
(1, 0, 0)

خوب، خروجی فوق به هیچ وجه چیزی نیست که ما انتظار داشتیم! پایتون 1,000,000 را ترتیبی از integer های جدا شده توسط کاما تفسیر می کند. این اولین مثال خطای معنایی است که مشاهده کردیم: کد بدون تولید هیج پیام خطایی اجرا می شود، ولی کاری درست را انجام نی دهد.

متغیرها

یکی از قدرتمند ترین خصوصیات یک زبان برنامه نویسی توانایی مدیریت متغیرها می باشد. متغیر نامی است که به یک مقدار نسبت داده می شود.

یک عبارت مقدار دهی، متغیرهای جدید را ایجاد و به آن ها مقادیر می دهد.

>>> message = 'And now for something completely different'
>>> n = 17
>>> pi = 3.1415926535897932

مثال فوق سه مورد مقدار دهی را نشان می دهد. اولی متغیری با نام message را مقدار دهی می کند. دومی عدد 17 را درون n می ریزد و سومی مقدار تقریبی عدد π را درون pi می ریزد.

رایج ترین روش برای نمایش متغیرها بر روی کاغذ، نوشتن نام نام متغیر به همراه یک پیکان که به مقدار متغیر اشاره می کند می باشد. این حالت نمایش را state diagram می نامند، به این دلیل که در این حالت وضعیتی که هر متغیر در آن است را نشان می دهد. شکل 1.1 نتیجه مثال قبل را نشان می دهد.

do.php?imgf=155784236260731.png

در واقع نوع یک متغیر، نوع مقداری است که به آن متغیر نسبت داده شده است.

>>> type(message)
<type 'str'>
>>> type(n)
<type 'int'>
>>> type(pi)
<type 'float'>

تمرین 1

در صورتی که یک مقدار integer را با یک صفر در اول آن تایپ کنید، ممکن است با یک خطای گیچ کننده مواجه شوید:

>>> zipcode = 02492
                  ^
SyntaxError: invalid token

اعداد دیگری با این حالت به نظر می رسد بدون خطا کار می کنند، ولی خروجی عجیب و غریب است:

>>> zipcode = 02132
>>> zipcode
1114

آیا می توانید بیابید که موضوع از چه قرار است؟ اشاره: مقادیر 01، 010، 0100 و 01000 را در خروجی امتحان کنید.

نام متغیرها و کلمات کلیدی

برنامه نویسان معمولا اسامی معناداری برای متغیرهای خود انتخاب می کنند، آن ها دلیل استفاده هر متغیر را توضیح می دهند.

نام متغیر می تواند به طور دلخواه نامی بلند باشد. نام متغیر می تواند ترکیبی از حروف و عدد باشد، ولی نام متغیر می بایست با حرف شروع شود. معمولا از حروف بزرگ استفاده نمیشود، ولی ایده بدی نیست که نام متغیرها با یک حرف کوچک شروع شود.

می توان از کاراکتر خط تیره (ـ) درون نام متغیر استفاده کرد. این کاراکتر معمولا برای نام هاییی که در آن ها چندین لغت به کار رفته استفاده می شود مانند my_name یا airspeed_of_unladen_swallow

در صورتی از یک نام غیر قانونی درون کد استفاده کنید، با خطای syntax مواجه خواهید شد.

>>> 76trombones = 'big parade'
SyntaxError: invalid syntax
>>> more@ = 1000000
SyntaxError: invalid syntax
>>> class = 'Advanced Theoretical Zymurgy'
SyntaxError: invalid syntax

متغیر 76trombones به دلیل اینکه با حرف شروع نشده است نامی غیر قانونی است. متغیر more@ به دلیل اینکه دارای یک کاراکتر غیر قانونی است استفاده از جایز نیس. ولی مشکل متغیر class چیست؟

نام class یکی از کلمات کلیدی پایتون می باشد. مفسر از کلمات کلیدی برای تشخیص ساختار برنامه استفاده می کند، و کلامت کلیدی نمی توانند برای نام متغیر استفاده شوند.

پایتون نسخه 2 دارای 31 کلمه کلیدی می باشد:

and       del       from      not       while    
as        elif      global    or        with     
assert    else      if        pass      yield    
break     except    import    print              
class     exec      in        raise              
continue  finally   is        return             
def       for       lambda    try

در پایتون نسخه 3، exec دیگر یک کلمه کلیدی نبوده، ولی nonlocal یک کلمه کلیدی می باشد.

ممکن است نگه داشتن این لیست را برای خود سودمند بدانید. در صورتی که مفسر در مورد نام یکی از متغیرهای شما شروع به ایراد گرفتن کرد و شما دلیل آن را نتوانستید تشخیص دهید، می توانید نگاهی به لیست بیاندازید.

عملگرها و عملوندها

عملگرها (Operators) نمادهای خاصی می باشند که محاسبات را نمایش می دهند، مانند عملات جمع و ضرب. مقادیری که عملگر بر آن ها اعمال می شود را عملوند (Operands) می نامند.

همانطور که در مثال زیر مشاهده می کنید، عملگرهای ، -، *، / و ** به ترتیب عملیات جمع، تفریق، ضرب، تقسیم و به توان رساندن را انجام می دهند.

20 32   hour-1   hour*60 minute   minute/60   5**2   (5 9)*(15-7)

در بعضی زبان های برنامه نویسی، علامت ^ برای عملات توان استفاده شده است، ولی در پایتون این علامت برای عمگر بیتی که XOR نامیده می شود استفاده شده است. در مورد عمگرهای بیتی بعدا صحبت خواهیم کرد، ولی در صورت تمایل می توانید به

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
مراجعه کنید.

در پایتون نسخه 2 عملگر تقسیم ممکن است کاری را که شما دقیقا انتظار انجام آن را دارید، انجام ندهد.

>>> minute = 59
>>> minute/60
0

مقدار متغیر minute عدد 59 می باشد، و بر طبق قوانین حساب، 59 تقسیم بر 60 می شود 0.9833، نه 0. دلیل این تفاوت به این خاطر است که پایتون برای تقسیم از floor division استفاده می کند بدین معنی که نتیجه تقسیم را به سمت عدد کمتر گرد می کند. در صورتی که مقادیر تقسیم شده بر یکدیگر هر دو integer باشند، نتیجه تقسیم نیز integer خواهد بود.

در پایتون نسخه 3، نتیجه تقسیم فوق یک مقدار اعشاری است. و عملگر جدید // کار floor division را انجام می دهد.

>>> minute/60.0
0.98333333333333328

عبارات و جمله ها

عبارت (expression) ترکیبی از مقادیر، متغیرها و عملگرهاست. یک مقدار به تنهایی می تواند یک عبارت باشد، متغیر نیز به همین ترتیب، بنابراین بنابراین 3 خط زیر همگی عبارات قانونی پایتون به حساب می آیند (با فرض اینکه مقداری به متغیر X تخصیص داده شده است):

17
x
x   17

یک جمله (statement) بخشی از کد می باشد که مفسر می تواند آن را اجرا کند. تا اینجا ما با دو جمله آشنا شدیم: print و تخصیص مقادیر (assignment).

از نظر تکنیکی یک عبارت همچنین یک جمله نیز هست، ولی شاید ساده تر باشد که فکر کنیم این دو از یکدیگر متفاوت هستند.

حالت interactive و script

یک از مزایای کار با زبان های اسکریپتی این است که می توان تکه کدها را قبل از اینکه درون script خود قرار دهید درون interactive امتحان کنید. ولی تفاوت هایی بین حالت interactive و حالت script وجود دارند که می توانند کمی گیج کننده باشند.

برای مثال، در صورتی که در حال استفاده از پایتون به عنوان یک ماشین حساب می باشید، ممکن است تایپ کنید

>>> miles = 26.2
>>> miles * 1.61
42.182

خط اول یک مقدار را درون متغیر miles قرار می دهد، ولی این عبارت هیچ خروجی ندارد. در خط دوم عبارت توسط مفسر پایتون محاسبه شده و نتیجه آن نمایش داده می شود.

ولی در صورتیکه شما کد فوق را درون script نوشته و اجرا کنید، به هیچ وجه، هیچ خروجی مشاهده نخواهید کرد. در حالت script یک عبارت به تنهایی، هیچ خروجی نخواهد داشت. در واقع پایتون عبارت را محاسبه می کند، ولی هیچ مقداری را نمایش نخواهد داد مگر اینکه به آن گفته شود:

miles = 26.2
print miles * 1.61

این رفتار می تواند در ابتدا کمی گیج کننده باشد.

script معمولا حاوی ترتیبی از جمله ها می باشد. در صورتیکه بیشتر از یک جمله وجود داشته باشد، نتیجه ها در یک زمان بعد از اجرا ظاهر خواهند شد.

برای مثال:

print 1
x = 2
print x

خروجی زیر را تولید می کند:

1
2

جمله انتساب مقدار هیچ خروجی تولید نمی کند.

تمرین 2

جملات زیر را درون interactive پایتون تایپ کنید و خروجی را مشاهده کنید:

5
x = 5
x   1

حالا کد فوق را درون یک script قرار داده و آن را اجرا کنید. خروجی آن چیست؟ script را ویرایش کرده و هر عبارت را درون یک جمله print قرار دهید و سپس آن را دوباره اجرا کنید.

ترتیب عملگرها

هنگامی که درون یک عبارت بیشتر از یک عملگر وجود داشته باشد، ترتیب محاسبات به قوانین اولویت بندی عملگرها بستگی دارد. برای عملگرهای ریاضی، پایتون از قراردادهای ریاضی پیروی می کند. کلمه مخفف PEMDAS یک راه مفید برای به خاطر سپردن اولیت های عملگرها می باشد.

  • پرانتزها (Parantheses) دارای بالاترین اولیت هستند و می توان برای مجبور کردن عبارت به همان اولویتی می خواهید از آن ها استفاده کنید. از آنجاییکه پرانتز ها اول از همه ارزیابی می شوند، 2 * (3-1) می شود 4 و (1 1) ** (5-2) می شود 8. همچنین می توان از پرانتز برای بالا بردن خوانایی کد نیز استفاده کرد، برای مثال (minute * 100) / 60، حتی اگر هیچ تاثیری در نتیجه ندارد.
  • توان (Exponentiation) دارای اولیت دوم می باشد، بنابراین 2 ** 1 1 می شود 3، نه 4 و 3 * 1 ** 3 می شود 3 نه 27.
  • ضرب و تقسیم دارای اولیت یکسانی می باشند، و جمع و تفریق نیز با هم دارای اولیت یکسانی می باشند، ولی اولیت ضرب و تقسیم از جمع و تفریق بالاتر است.
  • عملگرهای با اولویت یکسان از چپ به راست ارزیابی می شوند (به استثنای توان). بنابراین در عبارت در عبارت degrees / 2 * pi، ابتدا عملیات تقسیم انجام می شود و نتیجه در pi ضرب می شود. To divide by 2 π, you can use parentheses or write degrees / 2 / pi.

من تلاش بسیاری برای به خاطر سپردن اولویت عملگرها انجام نمی دهم، ترجیحم بر این است که برای خوانایی بیشتر از پرانتز استفاده کنم.

عملگرهای رشته

به طور کلی، نمی توان عملگرهای ریاضی را بر روی رشته ها انجام داد، حتی اگر رشته مورد نظر شبیه به عدد باشد، بنابراین عبارات زیر صحیح نمی باشند:

'2'-'1'    'eggs'/'easy'    'third'*'a charm'

عملگر برای رشته ها استفاده می شود، ولی ممکن است چیزی که شما انتظار دارید نباشد: این عملگر عمل contatenation را انجام می دهد، بدین معنی که رشته ها را به یکدیگر متصل می کند. برای مثال:

first = 'throat'
second = 'warbler'
print first   second

خروجی برنامه فوق کلمه throatwarbler می باشد.

همچنین عملگر * نیز برای رشته ها استفاده می شود. این عملگر باعث تکرار رشته می شود. برای مثال، 'Spam' * 3 می شود 'SpamSpamSpam'. در صورتیکه یکی از عملوند ها رشته باشد، دیگری باید یک integer باشد.

استفاده فوق از و * شباهت معناداری با جمع و ضرب را تداعی می کند. 3 * 4 برابر است با 4 4 4، ما فرض می کنیم که 'Spam' * 3 نیز به همین شکل است 'Spam' 'Spam' 'Spam'. از سوی دیگر تفاوت قابل توجهی در تکرار و به هم متصل کردن رشته ها با جمع و ضرب رشته وجود دارد.Can you think of a property that addition has that string concatenation does not?

کامنت ها

همانطور که برنامه ها بزرگتر و پیچیده تر می شوند، خواندن کد آن ها نیز مشکل تر می شود. زبان های رسمی بسیار متراکم هستند، و اغلب مشاهده بخشی از کد و تشخیص این که آن تکه کد چه کاری انجام می دهد بسیار مشکل می باشد.

به همین دلیل، ایده بدی نیست که برای توضیح قسمت هایی از کد، یادداشت هایی را درون برنامه اضافه کنیم. به این یادداشت ها کامنت می گویند که با علامت # آغاز می شوند:

# compute the percentage of the hour that has elapsed
percentage = (minute * 100) / 60

در مثال فوق، کامنت در یک خط قرار داده شده است. همچنین می توان کامنت را در انتهای یک خط نیز قرار داد.

percentage = (minute * 100) / 60     # percentage of an hour

همه چیز از علامت # به بعد تا انتهای خط نادیده گرفته خواهد شد، بدین معنی که هیچ تاثیری در برنامه نخواهد گذاشت.

مناسب ترین وقت برای کامنت گذاری زمانی است که یک قابلیت غیر واضع را در کد توضیح می دهید. فرض اینکه خواننده کد بتواند کارکرد کد را متوجه شود معقول می باشد.

کامنت زیر زائد و بدون استفاده است:

v = 5     # assign 5 to v

کامنت زیر حاوی اطلاعات مفیدی است که درون کد وجود ندارد:

v = 5     # velocity in meters/second.

انتخاب نام مناسب برای متغیرها می تواند نیاز به کامنت را کاهش دهد، از طرفی نام های بلد می توانند عبارت ها را برای خواندن پیچیده کنند، از این رو ایچاد نوعی تعادل لازم می باشد.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

رشته ها در پایتون

در این آموزش از کتاب برخط (Online) فارسی پایتون (Python)، نوع داده رشته (String) و کاربرد آن را مورد بررسی قرار می دهیم.

رشته یک ترتیب است

رشته ترتیبی از کارکترها می باشد. شما می توانید با استفاده از علامت کروشه به کارکترهای درون رشته دسترسی پیدا کنید:

>>> fruit = 'banana'
>>> letter = fruit[1]

خط دوم مثال فوق کارکتر اول fruit را انتخاب کرده و آن را درون letter می ریزد.

عبارت درون کروشه را اندیس می نامند. اندیس به کاراکترهای درون یک ترتیب اشاره می کند.

ولی ممکن است چیزی را انتظار خواهید داشت را دریافت نکنید:

>>> print letter
a

برای اکثر افراد، اولین حرف از کلمه 'banana' حرف b می باشد، نه حرف a. ولی در علوم کامپیوتر اندیس اولین قسمت از رشته می باشد، و اولین قسمت صفر می باشد.

>>> letter = fruit[0]
>>> print letter
b

بنابراین شاید بتوان به حالت طنز گفت که b صفرومین حرف 'banana' می باشد، a اولین و n نیز دومین حرف آن می باشد.

شما می توانید برای اندیس از هر عبارتی، شال متغیرها و عملگرهای استفاده کنید، ولی باید بخاطر داشت مقدار اندیس باید یک integer باشد، در غیر این صورت شما خطای زیر را دریافت خواهید کرد:

>>> letter = fruit[1.5]
TypeError: string indices must be integers

طول رشته

len یک تابع داخلی پایتون می باشد که تعداد کاراکترهای موجود در یک رشته را بر می گرداند.

>>> fruit = 'banana'
>>> len(fruit)
6

برای بدست آوردن آخرین حرف یک رشته، شما ممکن است همچین کاری را انجام دهید:

>>> length = len(fruit)
>>> last = fruit[length]
IndexError: string index out of range

دلیل خطای فوق این است که هیچ در 'banana' با اندیس 6 وجود ندارد. به این دلیل که ما شمارش را از صفر شروع کردیم 6 حرف مورد نظر از 0 تا 5 شماره گذاری شده اند. برای بدست آوردن آخرین کاراکتر، شما باید یک واحد از lenght کم کنید.

>>> last = fruit[length-1]
>>> print last
a

همچنین شما می توانید از اندیس های منفی استفاده کنید، که به صورت بر عکس، یعنی از ابتدا به انتها رشته را شمارش می کند. عبارت fruit[-1] نشان دهنده اندیس آخر، fruit[-2] نشان دهنده اندیس یکی مانده به آخر می باشد و الی آخر ...

پیمایش با حلقه for

بسیاری از محاسبات نیاز به پردازش رشته دارند به طوری بتوانند در هربار یکی از کاراکترهای رشته را در اختیار داشته باشند و به نوبت هر کاراکتر را انتخاب کرده و کاری را روی آن انجام دهند و این موضوع را تا پایان رشته ادامه دهند. این الگوی پردازش پیمایش نام دارد. یکی از راه های نوشتن پیمایش استفاده از حلقه while می باشد:

index = 0
while index < len(fruit):
    letter = fruit[index]
    print letter
    index = index   1

این حلقه رشته را پیمایش کره و حروف داخل رشته را جدا جدا نمایش می دهد. شرط حلقه index < len(fruit) می باشد، بنابراین زمانی که index برابر با طول رشته شود، شرط False می شود، و بدنه حلقه دیگر اجرا نخواهد شد. آخرین کاراکتر مورد دسترسی اندیس len(fruti) - 1 می باشد، که آخرین کاراکتر رشته خواهد بود.

تمرین 1

تابعی بنویسید که یک رشته را به عنوان آرگومان دریافت کرده و حروف آن را به صورت وارونه نمایش دهد.

روش دیگر نوشتن یک پیمایش با استفاده از حلقه for می باشد:

for char in fruit:
    print char

هر بار درون حلقه، کاراکتر بعدی درون رشته به متغیر char نسبت داده می شود. حلقه تا جایی ادامه پیدا می کند که دیگر هیچ کارکتری درون رشته باقی نماند.

مثال زیر نحوه استفاده از به هم متصل کردن رشته و یک حلقه for برای تولید یک سری حروف به ترتیب حروف الفبا را نشان می دهد. در کتاب make Way for Ducklings اثر Robert McCloskey نام جوجه اردک ها Jack، Kack، Lack، Mak، Nack، Ouack، Pack و Ouack می باشد، خروجی حلقه زیر این نام ها را به ترتیب چاپ می کند.

prefixes = 'JKLMNOPQ'
suffix = 'ack'

for letter in prefixes:
    print letter   suffix
The output is:
Jack
Kack
Lack
Mack
Nack
Oack
Pack
Qack

البته، خروجی به طور کامل صحیح نیست، "Oauck" و "Quack" از نظر املایی غلط می باشند.

تمرین 2

کد فوق را جهت رفع مشکل اصلاح کنید.

برش های رشته

یک بند از یک رشته را یک برش می گویند. انتخاب یک برش، دقیقا انتخاب یک کاراکتر است.

>>> s = 'Monty Python'
>>> print s[0:5]
Monty
>>> print s[6:12]
Python

عملگر [n:m] بخشی از رشته یعنی رشته را از کاراکتر n تا بر می گرداند، که شامل اولین برش یعنی عدد n می شود، ولی شامل m نمی شود. این رفتار کمی عجیب به نظر می رشد، ولی ممکن است همانطور که در تصویر 8-1 مشاهده می کنید به این تصور کمک کند که نقطه اندیس بین کارکترها می باشد.

do.php?imgf=15583584022911.png

در صورتیکه اندیس اول (قبل از : را) از قلم بیاندازید، برش از ابتدا رشته شروع می کند و همچنین در صورتیکه اندیس دوم را از قلم بیاندازید، برش تا انتهای رشته ادامه پیدا می کند.

>>> fruit = 'banana'
>>> fruit[:3]
'ban'
>>> fruit[3:]
'ana'

در صورتیکه اندیس اول بزرگتر یا مساوی اندیس دوم باشد، نتیجه یک رشته خالی خواهد بود که درون علامت کتیشن قرار خواهد گرفت.

>>> fruit = 'banana'
>>> fruit[3:3]
''

یک رشته خالی حاوی هیچ کارکتری نبوده و طول آن 0 می باشد، ولی با این حال مانند باقی رشته ها خواهد بود.

رشته ها تغییر ناپذیر هستند

به نظر وسوسه انگیز می رسد به منظور تغییر یک کاراکتر در رشته از عملگر [] در سمت چپ یک انتساب استفاده کرد برای مثال:

>>> greeting = 'Hello, world!'
>>> greeting[0] = 'J'
TypeError: object does not support item assignment

"object" در مثال فوق رشته و "item" کارکتری است که انتساب داده شده است. فعلا یک شیء همان مقدار می باشد، ولی بعدا شیء را به تفصیل توضیح خواهیم داد. item یکی از مقادیر موجود در ترتیب (sequence) می باشد.

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

>>> greeting = 'Hello, world!'
>>> new_greeting = 'J'   greeting[1:]
>>> print new_greeting
Jello, world!

مثال فوق یک حرف جدید را به عنوان اولین حرف به برش greeting متصل می کند. انتساب فوق هیچ تاثیری بر رشته اصلی ندارد.

جستجو کردن

تابع زیر چه کاری انجام می دهد؟

def find(word, letter):
    index = 0
    while index < len(word):
        if word[index] == letter:
            return index
        index = index   1
    return -1

در یک معنا، تابع فوق نقطه مقابل عملگر [] می باشد، بدین معنی که، به جای اینکه یک اندیس را گرفته و کاراکتر مرتبط با آن را بر گرداند، یک کاراکتر را گرفته و اندیس مربوط به کاراکتر را بر می گرداند. در صورتیکه کاراکتر مورد نظر پیدا نشود تابع -1 بر می گرداند.

این اولین مثالی است که جمله return درون حلقه قرار گرفته است. در صورتیکه word[index] == letter باشد، تابع حلقه را شکسته و به سرعت برگردانده می شود.

در صورتیکه کاراکتر در رشته وجود نداشته باشد، برنامه به طور عادی از حلقه خارج شده و -1 را بر می گرداند.

این توع الگوی محاسبه یعنی: پیمایش یک ترتیب و برگرداندن، هنگامی که چیزی که به دنبالش می باشیم را پیدا کردیم را جستجو می نامند.

استفاده از حلقه و شمارشگر

برنامه زیر تعداد کاراکتر a موجود در رشته را حساب می کند.

word = 'banana'
count = 0
for letter in word:
    if letter == 'a':
        count = count   1
print count

برنامه فوق الگوی محاسبه دیگری را نشان می دهد که شمارشگر نام دارد. متغیر count با مقدار اولیه 0 ایجاد شده و هر بار که کاراتر a در رشته یافت می شود یک واحد به آن اضافه می گردد. زمانی که حلقه خارج شود، متغیر count حاوی نتیجه خواهد بود یعنی تعداد a های موجود در رشته.

متدهای رشته

یک متد چیزی شبیه به تابع می باشد، بدین معنی که آرگون هایی را دریافت کرده و یک مقدار بر می گرداند، ولی در syntax با یکدیگر متفاوت هستند. برای مثال. برای مثال، متد upper یک رشته را دریافت کرده و یک رشته جدید بر می گرداند که در آن تمامی حروف به حروف بزرگ تبدیل شده اند.

به جای استفاده از یک تابع به عنوان مثال upper(word)، در مثال زیر از syntax متد استفاده شده است: word.upper().

>>> word = 'banana'
>>> new_word = word.upper()
>>> print new_word
BANANA

این حالت از نقطه گذاری نام متد را مشخص می کند، که upper می باشد، و نام رشته ای که متد بر روی آن اجرا می شود word می باشد. پرانتزهای خالی نشانگر این هستند که متد هیچ آرگومانی دریافت نمی کند.

اینگونه استفاده از متد را فراخوانی می نامند؛ در مورد فوق، خواهیم گفت که، ما در حال فراخوانی upper در word می باشیم.

همانطور که معلوم است، یک متد رشته با نام find وجود دارد که به طور قابل ملاحظه ای شبیه به تابعی است که پیش از این نوشتیم:

>>> word = 'banana'
>>> index = word.find('a')
>>> print index
1

در مثال فوق، ما متد find را فراخوانی کرده و حرف مورد نظر خود را به عنوان پارامتر به آن ارسال کردیم.

در واقع، متد find کلی تر از تابعی است که ما قبلا نوشتیم، این متد نه تنها می تواند کاراکتر را پیدا کند، بلکه زیر رشته ها را نیز پیدا می کند:

>>> word.find('na')
2

همچنین متد فوق یک آرگومان دیگر نیز دریافت می کند که مشخص می کند جستجو از کدام اندیس شروع شود:

>>> word.find('na', 3)
4

بعلاوه آرگومان سوم که مشخص می کند جستجو در کدام اندیس پایان یابد:

>>> name = 'bob'
>>> name.find('b', 1, 2)
-1

جستجوی فوق موفق نبود چرا که b در محدوده اندیس 1 تا 2 (نه خود 2) وجود نداشت.

عملگر in

کلمه in یک عملگر boolean می باشد که دو رشته را گرفته و در صورتی که رشته اول زیر رشته یا زیر مجموعه رشته دوم باشد مقدار True بر می گرداند.

>>> 'a' in 'banana'
True
>>> 'seed' in 'banana'
False

براث مثال، تابع زیر تمام حروف word1 را در صورتی که درون word2 باشد چاپ می کند.

def in_both(word1, word2):
    for letter in word1:
        if letter in word2:
            print letter

در صورتیکه از نام های درست استفاده کنید، پایتون گاهی اوقات مانند زبان انگلیسی خوانده می شود: “for (each) letter in (the first) word, if (the) letter (appears) in (the second) word, print (the) letter.”

در زیر نتیجه مقایسه apples با oranges را با استفاده از تابع نوشته مشاهده می کنید:

>>> in_both('apples', 'oranges')
a
e
s

مقایسه رشته ها

عملگرهای انتسابی برای رشته ها استفاده می شوند. مقایسه این که آیا دو رشته با هم مساوی هستند:

if word == 'banana':
    print 'All right, bananas.'

عملگرهای انتسابی دیگر برای قرار دادن لغات به ترتبی حروف الفبا کاربرد خواهند داشت:

if word < 'banana':
    print 'Your word,'   word   ', comes before banana.'
elif word > 'banana':
    print 'Your word,'   word   ', comes after banana.'
else:
    print 'All right, bananas.'

پایتون حروف بزرگ و کوچک را به همان روشی که در دنیای واقعی ما از آستفاده می کنیم، ‌کنترل نمی کند. تمامی حروف بزرگ قبل از حروف کوچک می آیند، ‌بنابراین:

Your word, Pineapple, comes before banana.

رایج ترین روش برای درست کردن این مشکل این است که، قبل از انجام عمل مقایسه، رشته ها را به حروف کوچک تبدیل کنیم.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

لیست در پایتون

در این آموزش از کتاب فارسی برخط پایتون، به نوع داده لیست پرداخته شده است. پایه ای ترین ساختار داده در پایتون sequence می باشد. هر المان از sequence با یک شماره مشخص می شود که مکان یا اندیس آن است. اندیس اول صفر، اندیس دوم یک و به همین ترتیب ادامه خواهد داشت.

پایتون دارای شش نوع از sequence ها می باشد، ولی رایج ترین آن ها لیست ها و Tuple ها می باشند، که در این آموزش به آن ها پرداخته شده است.

اعمال مشخصی وجود دارند که با نوع داده های sequence می توان انجام داد. این اعمال شامل فهرست کردن اعضاء، افزودن عضو، برش و چک کردن موجود بدون یک عضو می باشند. علاوه بر این ها، پایتون دارای توابع داخلی (built-in) برای بدست آوردن طول (length) ترتیب (sequence) و یافتن بزرگترین و کوچکترین المان می باشد.

لیست یک نوع داده به اصطلاح همه کاره در پایتون است، که مقادیر آن درون کروشه قرار گرفته و با کاما از یکدیگر جدا می شوند. نکته مهم این است که آیتم های درون لیست لزوما نیازی نیست که از یک نوع باشند، بدین معنی که آیتم های درون یک لیست می توانند از نظر نوع داده با یکدیگر متفاوت باشند.

ایجاد یک لیست به آسانی قرار دادن مقادیری که توسط کاما از یکدیگر جدا شده اند درون کروشه می باشد. برای مثال:

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

همانند برش ها در رشته، برش های لیست نیز از 0 شروع می شوند، همچنین لیست ها را می تواند به یکدیگر چسبانده یا برش داد.

دسترسی به مقادیر

برای دسترسی به مقادیر در لیست ها، از کروشه بعد از نام متغیر لیست همانند مثال زیر استفاده می شود:

#!/usr/bin/python3

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

خروجی کد بالا:

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

به روز رسانی لیست ها

شما می توانید یک آیتم یا بیشتر از مقادیر لیست را با دادن اندیس آن به روز رسانی کنید.

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])

list[2] = 2001
print ("New value available at index 2 : ", list[2])

خروجی کد بالا:

Value available at index 2 :  1997
New value available at index 2 :  2001

حذف کردن آیتم ها

برای حذف یک آیتم لیست، در صورتی که دقیقا می دانید کدام آیتم را می خواهید حذف کنید، می توانید از عبارت del استفاده کنید، در غیر اینصورت می توانید از متد remove() استفاده کنید که در بخش انتها به توضیح آن پرداخته ایم:

#!/usr/bin/python3
list = ['physics', 'chemistry', 1997, 2000]

print (list)
del list[2]
print ("After deleting value at index 2 : ", list)

خروجی کد بالا:

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :  ['physics', 'chemistry', 2000]

اعمال پایه ای List

لیست ها همانند رشته ها به عملگرهای و * پاسخ می دهند؛ در اینجا نیز این عملگرها برای اتصال و تکرار استفاده می شوند، با این تفاوت که نتیجه یک لیست جدید خواهد بود نه یک رشته.

در واقع، لیست ها به تمامی عملگرهای معمول sequence ها که در رشته استفاده می شوند، پاسخ می دهند.

عبارت پایتون نتیجه توضیح
len([1, 2, 3]) 3 Length
[1, 2, 3] [4, 5, 6] [1, 2, 3, 4, 5, 6] Concatenation
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] Repetition
3 in [1, 2, 3] True Membership
for x in [1,2,3] : print (x,end = ' ') 1 2 3

Iteration

برش در List

از آنجاییکه لیست یک sequence است، برش دادن آن هم همانند روش برش در رشته ها است.

ورودی های زیر را فرض کنید:

L = ['C', 'Java', 'Python']
عبارت پایتون نتیجه توضیح
L[2] 'Python' Offsets start at zero
L[-2] 'Java' Negative: count from the right
L[1:] ['Java', 'Python']

Slicing fetches sections

توابع و متدهای داخلی List

پایتون حاوی توابع List زیر می باشد:

  • cmp(list1, list2) در پایتون 3 دیگر در دسترس نیست.
  • len(list) طول لیست را بر می گرداند.
  • max(list) آیتمی را که بیشترین مقدار را دارد بر می گرداند.
  • min(list) آیتمی را که کمترین مقدار را دارد بر می گرداند.
  • list(seq) نوع داده tuple را به لیست تبدیل می کند.

پایتون حاوی متدهای List زیر می باشد:

  • list.append(obj) شیء obj را به list اضافه می کند.
  • list.count(obj) تعداد حضور obj در list را بر میگرداند.
  • list.extend(seq) محتویات seq را به لیست اضافه می کند.
  • list.index(obj) اولین اندیس حضور obj در لیست را بر می گرداند.
  • list.insert(index, obj) شیء obj را در مکان داده شده قرار می دهد.
  • list.pop(obj = list[-1]) آخرین شیء را حذف کرده و برمی گرداند.
  • list.remove(obj) شیء obj را از list حذف می کند.
  • list.reverse() اشیاء list را وارونه می کند.
  • list.sort([func]) اشیاء list را با استفاده از مقایسه func داده شده می چیند.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

دیکشنری در پایتون

در این آموزش از کتاب برخط (Online) فارسی پایتون (Python)، نوع داده دیکشنری (Dictionary) و کاربرد آن را مورد بررسی قرار می دهیم.

نوع داده دیکشنری (Dictionary) در زبان برنامه نویسی پایتون (Python)، به صورت لیستی از، کلیدها و value ها است، هر کلید توسط علامت کالن (:) از value جدا می شود، اندیس ها نیز توسط علامت کاما (,) از یکدیگر جدا می شوند. یک دیکشنری خالی بدون اندیس با استفاده از تنها دو آکولاد خالی به صورت {} نوشته می شود.

کلید ها در نوع داده dictionary یکتا می باشد (بدین معنی که نمی توان دو کلید یکسان داشت)، ولی value می تواند تکراری نیز باشد. value در دیکشنری می تواند هر نوعی باشد، ولی کلیدها باید یک نوع داده غیر قابل تغییر (immutable) مانند string، number، یا tuble باشد.

دسترسی به value ها در Dictionary

برای دسترسی به مقادیر دیکشنری، تنها کافی است از علامت کروشه و کلید متناظر با value مورد نظر استفاده کرد، در زیر مثالی ساده نشان داده شده است:

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

زمانی که کد بالا اجرا شود، خروجی زیر را تولید می کند:

dict['Name']:  Zara
dict['Age']:  7

در صورتی که کلید مورد نظر در دیکشنری موجود نباشد، خطای زیر رخ خواهد داد:

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Alice']: ", dict['Alice']

زمانی که کد بالا اجرا شود، خروجی زیر را تولید می کند:

dict['Zara']:
Traceback (most recent call last):
   File "test.py", line 4, in       print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

بروزرسانی Dictionary

برای تغییر مقادیر، افزودن آیتم جدید به صورت زیر عمل می کنیم:

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School" # Add new entry

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

زمانی که کد بالا اجرا شود، خروجی زیر را تولید می کند:

dict['Age']:  8
dict['School']:  DPS School

حذف مقادیر دیکشنری

شما می توانید یک آیتم یا اندیس خاص و یا تمامی مقادیر یک دیکشنری را حذف کنید، حتی می تواند خود دیکشنری را به طور کلی با یک عملیات حذف کرد.

برای حذف کل یک دیکشنری، تنها کافی است از عبارت del استفاده کنید. در زیر مثال ساده ای آورده شده است:

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

del dict['Name'] # remove entry with key 'Name'
dict.clear()     # remove all entries in dict
del dict         # delete entire dictionary

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

خروجی کد بالا.

بعد از del dict یک خطا (exception) ایجاد می شود، دیکشنری دیگر وجود ندارد.

dict['Age']:
Traceback (most recent call last):
   File "test.py", line 8, in       print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

متد del() در ادامه توضیح داده خواهد شد.

خصوصیات کلیدهای Dictionary

value ها هیچ محدودیتی ندارند. چرا که می توانند هر شیء دلخواهی از پایتون باشند، چه شیء های استاندارد و یا شیء های تعریف شده توسط کاربر. ولی این برای کلیدها صدق نمی کند.

دو نکته ی مهم درباره کلیدها در دیکشنری را باید بخاطر سپرد:

(الف) همانطور که گفته شد، کلیدها در این نوع داده نمی توانند تکراری باشند، زمانیکه کلید تکراری به یک دیکشنری اختصاص می دهید، آخرین مقدار جایگزین مقدار قبلی می شود. برای مثال:

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print ("dict['Name']: ", dict['Name'])

زمانی که کد بالا اجرا شود، خروجی زیر را تولید می کند:

dict['Name']:  Manni

(ب) کلیدها باید از نوع داده های غیر قابل تغییر (immutable) باشند. این بدان معناست که می توان از string، number و tuple ها در کلید های دیکشنری استفاده کرد، ولی چیزی شبیه به ['key'] را نمی توان استفاده کرد، در زیر مثال ساده ای آورده شده است:

#!/usr/bin/python3

dict = {['Name']: 'Zara', 'Age': 7}
print ("dict['Name']: ", dict['Name'])

زمانی که کد بالا اجرا شود، خروجی زیر را تولید می کند:

توابع و متدهای داخلی (built-in) در دیکشنری

پایتون حاوی توابع dictionary زیر می باشد:

  • cmp(dict1, dict2) در پایتون 3 دیگر قابل دسترس نیست.
  • len(dict) اندازه طول دیکشنری را بر می گرداند. این برابر با تعداد آیتم ها یا اندیس ها در دیکشنری است.
  • str(dict) یک رشته قابل نمایش از دیکشنری را تولید می کند.
  • type(variable) نوع داده مقدار ورودی بر می گرداند، در صورتی که مقدار ورودی یک دیکشنری باشد، نوع dictionary را برمی گرداند.

پایتون حاوی متدهای دیکشنری زیر می باشد:

  • dict.clear() تمامی اندیس های دیکشنری dict را حذف می کند
  • dict.copy() یک کپی از دیکشنری dict را بدون تغییر در مقادیر اصلی آن برمی گرداند.
  • dict.fromkeys() یک دیکشنری جدید با استفاده از کلید های seq ورودی ایجاد می کند.
  • dict.get(key, default=None) مقدار کلید key را برمی گرداند، و در صورتی که کلید در دیکشنری نباشد، مقدار default را بر می گرداند.
  • dict.has_key(key) این متد حذف شده است، بجای آن از عمل in استفاده کنید.
  • dict.items() لیستی از tuple های جفت شده از کلید و value های dict را بر می گرداند.
  • dict.keys() لیستی از کلیدهای دیکشنری را بر می گرداند.
  • dict.setdefault(key, default = None) شبیه به get() می باشد، با این تفاوت که در صورتیکه کلید وجود نداشته باشد مقدار default را در آن قرار می دهد.
  • dict.update(dict2) کلید ها و value های dict2 را به dict اضافه می کند.
  • dict.values() لیستی از value های دیکشنری dict را بر می گرداند.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

حلقه for در پایتون

در این آموزش از کتاب برخط پایتون، Loop یا حلقه for را مورد بررسی قرار می دهیم. با استفاده از حلقه for در پایتون، امکان جستجو و پیمایش بین آیتم های داده هایی نظیر لیست و رشته فراهم خواهد شد.

شکل دستور

for iterating_var in sequence:
   statements(s)

با توجه به مثال بالا آیتم های موجود در sequence یکی یکی به iterating_var اختصاص داده می شوند و درون بلاک statements(s) اجرا می شوند، این تا زمانی تکرار می شود که آیتم های درون sequence به پایان برسند. به مثال زیر توجه کنید:

#!/usr/bin/python3

myList = [1, 2, [3, 4], 5, 6]

for myItem in myList:
    print myItem

خروجی برنامه:

1
2
[3, 4]
5
6

تابع range() در پایتون

این تابع داخلی (build-in)، برای پیمایش درون ترتیبی از اعداد استفاده می شود. تابع range() یک iterator ایجاد می کند که برای حرکت و پیشروی در اعداد از 0 تا n-1 استفاده می شود. برای بدست آوردن شیء ای از لیست برای این ترتیب عددی از تابع تغییر تایپ list() استفاده می کنیم. حالا می توان با استفاده از Loop یا حلقه for درون این لیست پیمایش کرد:

>>> for var in list(range(5)):
   print (var)

خروجی

0
1
2
3
4

مثال

#!/usr/bin/python3

for letter in 'Python':     # traversal of a string sequence
   print ('Current Letter :', letter)
print()
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # traversal of List sequence
   print ('Current fruit :', fruit)

print ("Good bye!")

خروجی:

Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n

Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!

پیمایش با استفاده از اندیس ترتیب

روش دیگر پیمایش درون هر آیتم استفاده از عدد اندیس خود آن ترتیب است. به مثال ساده زیر توجه کنید:

#!/usr/bin/python3

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('Current fruit :', fruits[index])

print ("Good bye!")

خروجی

Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!

در اینجا، ما از تابع داخلی len() استفاده کرده ایم، که مجموع تعداد آیتم های درون لیست یا به عبارتی طول آن را بر میگرداند، همانطور هم تابع داخلی range() ترتیب عددی به اندازه طول لیست برای پیمایش در حلقه for در اختیار ما قرار می دهد.

استفاده از عبارت else در حلقه ها

زبان برنامه نویسی پایتون استفاده از عبارت else را به همراه حلقه for پشتیبانی می کند.

در صورتیکه عبارت else به همراه حلقه for استفاده شود، بلاک else تنها در صورتی اجرا می شود که حلقه به صورت معمول پایان یابد (و نه توسط عبارت break).
زمانیکه عبارت else به همراه حلقه while بیاید، عبارت else تنها در صورتی اجرا می شود که شرط آن false باشد.

مثال

مثال زیر ترکیب عبارت else با حلقه for را نشان می دهد، که عدد زوج را در لیست داده شده جستجو می کند.

#!/usr/bin/python3

numbers = [11,33,55,39,55,75,37,21,23,41,13]

for num in numbers:
   if num%2 == 0:
      print ('the list contains an even number')
      break
else:
   print ('the list doesnot contain even number')

خروجی

the list does not contain even number

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

فایل ها و دیتابیس ها

ماندگاری داده ها

اغلب برنامه هایی که تا به حال دیده ایم برنامه هایی گذرا هستند، به این معنی که این برنامه ها برای مدت زمان کوتاهی اجرا می شوند و برای خود خروجی تولید می کنند، ولی وقتی برنامه به پایان می رسد، تمامی داده ها از بین می روند. در صورتی که برنامه را دوباره اجرا کنید، برنامه خالی از هرگونه داده خواهد بود.

ولی برنامه های دیگر به اصطلاح ماندگار هستند: این برنامه ها حداقل برخی از داده های خود را درون یک مخزنی (به عنوان مثال، هارد درایو) ذخیره می کنند؛ و در صورتی که برنامه خاموش یا دوباره راه اندازی شود، داده های خود را برای استفاده در اختیار خواهند داشت.

از جمله برنامه های مانگار می تواند سیستم عامل ها را نام برد، که به خوبی تا هر زمان که کامپیوتر در روشن است اجرا می شوند، و وب سرور ها در تمام مدت در حال اجرا بوده و منتظر درخواست هایی که از شبکه می آید می باشند.

یکی از ساده ترین روش ها برای برنامه ها جهت مدیریت داده هایشان خواندن و نوشتن درون فایل متنی می باشد. پیش تر با برنامه هایی که فایل های متنی را می خوانند آشنا شده ایم؛ در این فصل با نوشتن بر روی فایل ها آشنا خواهید شد.

روش دیگر، ذخیره داده های یک برنامه درون یک دیتابیس یا پایگاه داده می باشد. در این فصل یک دیتابیس ساده و یک ماژول به نام pickle را برای ذخیره داده های یک برنامه نشان خواهیم داد.

خواندن و نوشتن درون فایل در پایتون

فایل متنی ترتیبی از کارکترهای ذخیره شده در یک هارد دائمی مانند هارد درایو، فلش یا CD-ROM می باشد. نحوه باز کردن و خواندن فایل را در فصل بازی با کلمات آشنا شدیم.

برای نوشتن بر روی فایل، باید از 'w' به عنوان پارامتر دوم در تابع open استفاده کرد:

>>> fout = open('output.txt', 'w')
>>> print fout
<open file 'output.txt', mode 'w' at 0xb7eb2410>

در صورتی که فایل مورد نظر وجود داشته باشد، باز کردن آن در حالت نوشتن ('w')، داده های قبلی را به طور کامل پاک کرده و یک فایل جدید را ایجاد می کند، بنابراین در این مورد باید کمی مواظب باشید! در صورتیکه فایل وجود نداشته باشد نیز یک فایل جدید ساخته می شود.

متد write داده ها را درون فایل قرار می دهد.

>>> line1 = "This here's the wattle,\n"
>>> fout.write(line1)

شیء فایل جایی را که قرار دارد را درون خود نگه می دارد، بنابراین در صورتیکه متد write را دوباره فراخوانی کنید، داده مورد نظر دوباره به انتهای فایل اضافه می شود.

>>> line2 = "the emblem of our land.\n"
>>> fout.write(line2)

هنگامی که نوشتن بر روی فایل خاتمه یافت، باید فایل را با استفاده از متد close ببندید

>>> fout.close()

عملگر فرمت (%)

آرگومان write باید یک رشته باشد، بنابراین در صورتیکه بخواهیم مقادیر دیگری غیر ار رشته به متد write ارسال کنید، باید آن مقدار را به رشته تبدیل کنیم. ساده ترین راه استفاده از تابع str می باشد:

>>> x = 52
>>> f.write(str(x))

روش دیگر برای تبدیل مقادیر دیگر به رشته، استفاده از عملگر فرمت (%) می باشد. در صورتیکه از این عملگر برای یک مقدار integer استفاده شود، کارکرد آن به شکل عملگر modulus (باقی مانده تقسیم) خواهد بود. ولی هنگامی که برای یک مقدار رشته از این عملگر استفاده شود به صورت عملگر فرمت رفتار خواهد کرد.

اولی عملوند در این حالت فرمت رشته می باشد، که حاوی یک یا چندین ترتیب فرمت می باشد و تعیین می کند که عملوند دوم به چه صورت قالب بندی شود.

برای مثال، '%d' بدین معنی است که عملوند دوم باید یک integer باشد (d مخفف decimal است):

>>> camels = 42
>>> '%d' % camels
'42'

نتیجه رشته '42' است، که هیچ تداخلی با 42 که یک integer است ندارد.

ترتیب فرمت می توانید در هر قسمتی از رشته قرار گیرد، بنابراین شما می توانید یک مقدار را درون یک جمله جای دهید:

>>> camels = 42
>>> 'I have spotted %d camels.' % camels
'I have spotted 42 camels.'

در صورتیکه بیشتر از یک فرمت درون رشته وجود داشته باشد، آرگومان دوم باید یک مقدار از نوع تاپل باشد. هر فرمت به ترتیب مطابق با یک المان از تاپل خواهد بود.

در مثال زیر از '%d' برای فرمت یک integer، از '%g' برای فرمت یک عدد اعشاری (نپرس چرا)، و از '%s' برای فرمت یک رشته استفاده شده است:

>>> 'In %d years I have spotted %g %s.' % (3, 0.1, 'camels')
'In 3 years I have spotted 0.1 camels.'

تعداد المان های درون تاپل باید با تعداد فرمت های استفاده شده درون رشته مطابق باشد. همچنین، نوع المان ها نیز باید با فرمت ها یکی باشد:

>>> '%d %d %d' % (1, 2)
TypeError: not enough arguments for format string
>>> '%d' % 'dollars'
TypeError: illegal argument type for built-in operation

در خط اول کد فوق، تعداد المان ها کافی نیستند، و در خط سوم نوع المان یک نوع اشتباه می باشد.

عملگر فرمت بسیار قدرتمند می باشد، ولی استفاده از آن می تواند کمی مشکل باشد. برای اطلاعات بیشتر در مورد این عملگر می توانید به مستندات پایتون مراجعه کنید.

نام فایل و مسیر

فایل ها اصولا درون دایرکتوری ها (فولدر نیز نامیده می شود) قرار می گیرند. هر بنامه ای که در حال اجرا می باشد، دارای یک دایرکتوری جاری می باشد، که دایرکتوری پیشفرض برای اغلب عملیات ها می باشد. برای مثال، هنگامی که شما فایلی را برای خواندن باز می می کنید، پایتون درون دایرکتوری جاری به دنبال آن می گردد.

ماژول os دارای توابعی برای کار با فایل ها و دایرکتوری ها می باشد (os مخفف "operating system" است). os.getcwd نام دایرکتوری جاری را بر می گرداند:

>>> import os
>>> cwd = os.getcwd()
>>> print cwd
/home/dinsdale

اصطلاح cwd مخفف "current working directory" به معنی دایرکتوری جاری در حال کار می باشد. نتیجه مثال فوق /home/aminpy می باشد، که دایرکتوری خانگی کاربری با نام aminpy می باشد (در سیستم عامل لینوکس).

شبه رشته (string like) فوق یعنی cwd یک فایل را که مسیر (path) نامیده می شود را شناسایی می کند. مسیر نسبی (relative path) از دایرکتوری جاری شروع می شود و مسیر کامل (absolute path) از بالاتری دایرکتوری سیستم فایل شروع می شود.

مسیرهایی که تا کنون دیدیم یک نام ها فایل ساده بوده اند، بنابراین این مسیرها مسیرهای نسبی از دایرکتوری جاری بوده اند. برای یافتن یک مسیر کامل به یک فایل، می توانیم از os.path.abspath استفاده کنیم:

>>> os.path.abspath('memo.txt')
'/home/dinsdale/memo.txt'

تابع os.path.exists وجود فایل یا دایرکتوری را بررسی می کند:

>>> os.path.exists('memo.txt')
True

در صورتیکه فایل مورد نظر وجود داشته باشد، os.path.isdir بررسی می کند که آن دایرکتوری است یا خیر:

>>> os.path.isdir('memo.txt')
False
>>> os.path.isdir('music')
True

به همین ترتیب، os.path.isfile نیز بررسی می کند که آیا آرگومان ارسالی به آن یک فایل است یا خیر.

تابع os.listdir لیستی از فایل ها و دایرکتوری موجود در دایرکتوری داده شده را بر می گرداند:

>>> os.listdir(cwd)
['music', 'photos', 'memo.txt']

برای شرح این توابع، مثال زیر درون یک دایرکتوری گشته، و اسامی تمامی فایل ها را چاپ کرده، و خودش را به صورت بازگشتی (recursively) درون تمام دایرکتوری ها فراخوانی می کند.

def walk(dirname):
    for name in os.listdir(dirname):
        path = os.path.join(dirname, name)

        if os.path.isfile(path):
            print path
        else:
            walk(path)

تابع os.path.join نام یک دایرکتوری و فایل را دریافت کرده و آن ها را در یک مسیر کامل شده به هم متصل می کند.

کنترل خطا در فایل

هنگام خواندن یا نوشتن درون فایل اشتباهات بسیاری می تواند رخ دهد. در صورتیکه سعی کنید فایلی را که وجود ندارد را باز کنید، خطای IOErro رخ خواهد داد:

>>> fin = open('bad_file')
IOError: [Errno 2] No such file or directory: 'bad_file'

در صورتیکه حق دسترسی به فایل را نداشته باشید با خطای زیر مواجه خواهید شد:

>>> fout = open('/etc/passwd', 'w')
IOError: [Errno 13] Permission denied: '/etc/passwd'

و در صورتیکه یک دایرکتوری را برای خواندن باز کنید، خطای زیر را خواهید دید:

>>> fin = open('/home')
IOError: [Errno 21] Is a directory

برای جلوگیری از خطاهای فوق، می توان از توابعی مانند os.path.exists و os.path.isfile استفاده کرد، ولی این کار زمان زیادی را خواهد گرفت و کد تمام احتمالات را باید بررسی کنید (if “Errno 21” is any indication, there are at least 21 things that can go wrong).

بهتر است زمانی که مشکل رخ داد با آن درگیر شویم، این دقیقا کاری است که عبارت try انجام می دهد. syntax آن شبیه به عبارت if است:

try:    
    fin = open('bad_file')
    for line in fin:
        print line
    fin.close()
except:
    print 'Something went wrong.'

پایتون با اجرای بلاک try آغاز می کند. در صورتیکه همه چیز بدون مشکل در بلاک try انجام شود، پردازش بلاک except نادیده گرفته خواهد شد. در صورتی که یک خطا رخ دهد، مفسر از بلاک try بیرون پریده و بلاک except را اجرا می کند.

مدیریت خطا با یک جمله try را کنترل خطا می گویند. در مثال فوق، بلاک except یک پیام خطا چاپ می کند که کمک زیاد نمی کند. به طور کلی، کنترل یک خطا به شما شانس این را می دهد که مشکل را حل کرده، یا دوباره سعی کرده و یا حداقل برنامه را به آرامی خاتمه دهید.

دیتابیس ها

دیتابیس یک فایل است که برای ذخیره سازی داده سازمان دهی شده است. اغلب دیتابیس ها همانند دیکشنری ساخته شده اند، بدین معنی که کلیدها را به مقادیر مرتبط می کنند. بزرگترین فرق آن این است که دیتابیس بر روی دیسک (یا هاردهای دائمی دیگر) می باشد، بنابراین بعد از اتمام برنامه نیز باقی خواهد ماند.

ماژول anydbm یک رابط برای ایجاد و به روز رسانی فایل های دیتابیس فراهم می کند. به عنوان مثال، ما یک دیتابیس که حاوی فایل های تصویری و عناوین آن می باشد را ایجاد خواهیم کرد:

>>> import anydbm
>>> db = anydbm.open('captions.db', 'c')

حالت 'c' بدین معنی است که دیتابیس در صورتی که وجود نداشته باشد ایجاد شود. نتیجه یک شیء دیتابیس است که می تواند (برای اغلب عملیات ها) مانند یک دیکشنری استفاده شود. در صورتیکه یک مورد جدید ایجاد کنیم، anydbm فایل دیتابیس را به روز رسانی می کند.

>>> db['cleese.png'] = 'Photo of John Cleese.'

هنگامی که به یک از موارد دسترسی پیدا می کنیم، anydbm فایل را می خواند:

>>> print db['cleese.png']
Photo of John Cleese.

در صورتیکه انتساب دیگری را برای یک کلید موجود ایجاد کنیم، anydbm مقدار جدید را با مقدار قدیمی جایگزین می کند:

>>> db['cleese.png'] = 'Photo of John Cleese doing a silly walk.'
>>> print db['cleese.png']
Photo of John Cleese doing a silly walk.

بسیاری از متدهای دیکشنری، مانند keys و items، با شیء های دیتابیس کار می کنند. بنابراین عملیات تکرار را با یک جمله for انجام می دهیم.

for key in db:
    print key

همانند فایل های دیگر، باید با استفاده از متد close شیء دیتابیس را مسدود کنیم:

>>> db.close()

Pickling

یکی از محدودیت های anydbm این است که نوع کلید و مقدار استفاده شده در آن باید رشته باشد. در صورتیکه از انواع دیگر در آن استفاده کنید، با خطا مواجه خواهید شد.

ماژول pickle در این مورد سودمند خواهد بود. این ماژول تقریبا تمامی نوع شیء ها را به رشته مناسب با آن برای ذخیره درون دیتابیس ترجمه کرده و رشته های ترجمه شده را به شیء های قبلی آن بر می گرداند.

تابع pickle.dumps یک شیء را به عنوان پارامتر دریافت کرده و یک رشته متناظر با آن بر می گرداند (dumps کوتاه شده "dump string" می باشد):

>>> import pickle
>>> t = [1, 2, 3]
>>> pickle.dumps(t)
'(lp0\nI1\naI2\naI3\na.'

فرمت رشته برگردانده شده واضح به نظر نخواهد رسید؛ این رشته جهت ساده شدن برای picke جهت تفسیر یه این شکل در آمده است. pickle.loads("loads string") شیء را بازسازی می کند:

>>> t1 = [1, 2, 3]
>>> s = pickle.dumps(t1)
>>> t2 = pickle.loads(s)
>>> print t2
[1, 2, 3]

هرچند شیء جدید مقداری مشابه با شیء قدیمی دارد، ولی به طور کلی این دو شیء با یکدیگر یکی نخواهند بود:

>>> t1 == t2
True
>>> t1 is t2
False

به عبارت دیگر، عمل pickling و سپس unpickling، تاثیری یکسان با کپی کردن شیء دارد.

می توان از pickle برای ذخیره داده هایی به غیر از رشته در دیتابیس استفاده کرد. در حقیقت، این ترکیبی بسیار رایج است که درون ماژولی به نام shelve قرار گرفته است.

Pipes

اغلب سیستم عامل ها دارای یک رابط خط فرمان شناخته شده به عنوان shell می باشند. shell ها معمولا دارای دستوراتی برای هدایت فایل سیستم و اجرای برنامه ها هستند. برای مثال در یونیکس می توان دایرکتوری ها را با دستور cd تغییر داد، می توان با دستور ls محتویات یک دایرکتوری را نمایش داد، و (به عنوان مثال) با تایپ دستور firefox مرورگر وب را اجرا کرد.

هر برنامه ای که را که از shell اجرا می کنید را، با استفاده از pipe می توان در پایتون نیز اجرا نمود. pipe یک شیء است که یک برنامه در حال اجرا را نشان می دهد.

به عنوان مثال، دستور یونیکس ls -l معمولا محتویات دایرکتوری فعلی (در یک فرمت بلند) نمایش می دهد. می توان دستور ls را با استفاده از os.popen (بهتر است از subprocess به جای آن استفاده کنید، ولی برای سادگی و درک مطلب در اینجا ما از این ماژول استفاده کردیم.) درون پایتون اجرا نمود.

>>> cmd = 'ls -l'
>>> fp = os.popen(cmd)

آرگومان ارسالی یک رشته حاوی دستور shell می باشد. مقدار برگشتی یک شیء است که درست مثل یک فایل باز شده رفتار می کند. می توان خروجی پردازش ls را خط به خط با readline بدست آورد و یا با read به کل خروجی دسترسی پیدا کرد:

>>> res = fp.read()

بعد از اتمام کار، مانند فایل شیء مورد نظر را close می کنیم:

>>> stat = fp.close()
>>> print stat
None

مقدار برگشتی آخرین وضعیت پردازش ls می باشد، None به معنای پایان یافتن عادی (بدون خطا) می باشد.

برای مثال، اغلب سیستم های Unix دستوری با نام md5sum را برای خواندن محتویات یک فایل و محاسبه یک "checksum" ارائه می کنند. برای اطلاعات بیشتر در مورد MD5 می توانید به

محتوای مخفی

    برای مشاهده محتوای مخفی می بایست در انجمن ثبت نام کنید.
مراجعه کنند. این دستور یک روش موثر برای بررسی یکی بودن محتویات دو فایل ارائه می کند. The probability that different contents yield the same checksum is very small (that is, unlikely to happen before the universe collapses).

می توان از pipe برای اجرای md5sum در پایتون و گرفتن نتیجه آن استفاده کرد:

>>> filename = 'book.tex'
>>> cmd = 'md5sum '   filename
>>> fp = os.popen(cmd)
>>> res = fp.read()
>>> stat = fp.close()
>>> print res
1e0033f0ed0656636de0d75144ba32e0  book.tex
>>> print stat
None

ماژول نویسی

هر فایلی که حاوی کد پایتون باشد می تواند به عنوان یک ماژول import شود. به عنوان مثال، فرض کنید فایلی به نام wc.py با محتویات زیر داریم:

def linecount(filename):
    count = 0
    for line in open(filename):
        count  = 1
    return count

print linecount('wc.py')

در صورتیکه برنامه فوق را اجرا کنیم، برنامه محتویات خود را خوانده و تعداد خطوط موجود در فایل را که عدد ۷ باشد را چاپ می کند. شما همچنین می توانید آن را import کنید:

>>> import wc
7

حالا ما یک شیء ماژول به نام wc در اختیار داریم:

>>> print wc
<module 'wc' from 'wc.py'>

این ماژول دارای تابعی به نام linecount می باشد:

>>> wc.linecount('wc.py')
7

و همه این ها مراحل نوشتن یک ماژول در پایتون نشان می دهند.

تنا مشکل موجود در مثال فوق این است که، زمانی که ما ماژول را import می کنیم، کد آزمایشی پایین ماژول اجرا می شود. به طور معمول زمانی که یک ماژول را import می کنیم، این کار توابع جدید را تعریف می کند، ولی آن ها را اجرا نمی کند.

برنامه هایی که به صورت ماژول import می شوند، اغلب از کد زیر استفاده می کنند:

if __name__ == '__main__':
    print linecount('wc.py')

__name__ یک متغیر داخلی پایتون است که زمانی که برنامه شروع می شود مقدار دهی می گردد. در صورتیکه برنامه مانند یک script اجرا شود، __name__ دارای مقدار __main__ می باشد؛ در این مورد، کد آزمایشی اجرا می شود. در غیر اینصورت، در صورتیکه ماژول import شود، کد آزمایشی نادیده گرفته می شود.

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

توابع در پایتون

تابع یک بلاک کد سازمان یافته با قابلیت استفاده دوباره برای انجام تنها یک کار مشخص و مرتبط می باشد. توابع ماژول بندی بهتری را برای برنامه شما فراهم کرده و قابلیت استفاده دوباره از کد برنامه را بیشتر می کند.

همانطور که می دانید، پایتون توابع داخلی بسیاری همانند print() و غیره را در اختیار شما قرار داده است. با این حال شما می توانید توابع خودتان را نیز ایجاد کنید. این توابع را، توابع تعریف شده توسط کاربر یا user-defined می نامند.

تعریف یک تابع

شما می توانید توابع را برای فراهم ساختن عملکردهای مورد نیاز تعریف کنید. در زیر قوانین ساده جهت تعریف تابع در پایتون آمده است.

  • بلاک تابع با کلمه کلیدی def شروع شده و نام تابع و پرانتز ( () ) باز و بسته بعد از آن می آید.
  • تمامی پارامترها و آرگومان های ورودی باید درون پرانتز قرار بگیرند. شما همچنین می توانید پارامترها را درون پرانتز حتی تعریف کنید.
  • عبارت اول یک تابع می تواند یک عبارت اختیاری باشد - رشته ای برای مستندات تابع یا docstring.
  • بلاک کد درون هر تابع با یک علامت کالن (:) شروع شده و به صورت تو رفته (indented) است.
  • عبارت return باعث خروج از یک تابع می شود، و به طور دلخواه می تواند یک مقدار را به قسمتی از کد که تابع را فراخوانی کرده است برگرداند. عبارت return با هیچ آرگومانی همانند return None است.

نحوه تعریف تابع

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

به طور پیشفرض، نحوه ترتیب قرار گرفتن پارامترهای تابع در علمکرد تابع موثر است و شما نیاز خواهید داشت آن ها را به همان ترتیبی که تعریف شده اند استفاده کنید.

مثال

تابع زیر یک پارامتر ورودی رشته دریافت کرده و آن را چاپ می کند.

def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

فراخوانی تابع

تعریف یک تابع، تعیین یک نام برای آن، تعیین پارامترها و ساختار بلاک کد آن. زمانیکه ساختار پایه ای یک تابع تمام شد، شما می توانید آن را از طریق فراخوانی از تابعی دیگر یا به طور مستقیم اجرا کنید. برنامه زیر فراخوانی تابع printme() را نشان می دهد:

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme("This is first call to the user defined function!")
printme("Again second call to the same function")

زمانیکه کد بالا اجرا شد، خروجی زیر ایجاد می شود:

This is first call to the user defined function!
Again second call to the same function

فراخوانی با مقدار و با reference

تمامی پارامترها در زبان پایتون با reference ارسال می شوند. این بدان معناست که اگر شما پارامتر را درون تابع تغییر دهید، این پارامتر همچنین در تابع فراخوانی شده نیز تغییر خواهد کرد. برای مثال:

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   mylist[2]=50
   print ("Values inside the function after change: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

خروجی:

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

در مثالی دیگر آرگومانی که با reference ارسال شده است و reference آن درون تابع فراخوانی شده تغییر می کند:

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4] # This would assi new reference in mylist
   print ("Values inside the function: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

پارامتر mylist درون تابع changeme داخلی می باشد، تغییر mylist درون تابع تاثیری در mylist نخواهد گذاشت. تابع در واقع هیچ کاری انجام نداده و خروجی زیر ایجاد می شود:

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

آرگومان های تابع

شما می توانید تابع را به از نظر آرگومان به شکل های زیر فراخوانی کنید:

  • آرگومان های اجباری
  • آرگومان های keyword
  • آرگومان های پیشفرض
  • آرگومان های variable-length

آرگومان های اجباری

آرگومان های اجباری آن های هستند که در مکان و ترتیب قرارگیری درست خود به تابع ارسال می شوند. در اینجا تعداد آرگومان های تابع فراخوانی شده باید دقیقا با تعریف تابع یکسان باشند.

جهت فراخوانی printme()، شما نیاز خواهید داشت دقیقا یک آرگومان به آن ارسال کنید، در غیر اینصورت خطای syntax همانند زیر ایجاد خواهد شد:

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme()

خروجی:

Traceback (most recent call last):
   File "test.py", line 11, in       printme();
TypeError: printme() takes exactly 1 argument (0 given)

آرگومان های Keyword

آرگومان های keyword وابسته به فراخوانی تابع می باشند. زمانیکه شما آرگومان keyword را در یک فراخوانی تابع استفاده می کنید، آن بخش فراخوانی کننده این آرگومان را توسط نام پارامتر تشخیص می دهد.

مثال زیر فراخوانی keyword در تابع printme() نشان داده شده است:

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme( str = "My string")

خروجی:

My string

مثال زیر تصویر واضح تری را ترسیم می کند. توجه داشته باشید که ترتیب پارامترها مشکلی ایجاد نمی کند.

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )

خروجی:

Name:  miki
Age  50

آرگومان پیشفرش

در صورتیکه هیچ مقداری به آرگومان فراخوانی شده اختصاص داده نشود، آرگومان پیشفرض مقدار آن را مشخص می کند. در مثال زیر در صورتی که مقدار age تعیین نشود مقدار پیشفرض آن چاپ می شود:

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )
Name:  miki
Age  50
Name:  miki
Age  35

آرگومان variable-length

شما ممکن است برای پردازش یک تابع نیاز به آرگومان هایی بیش از آن هایی که در تعریف تابع تعریف کرده اید داشته باشید. این آرگومان ها را variable-length می نامند و در تعریف تابع نام گذاری نمی شوند، به جز آرگومان های اجباری و پیشفرض.

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

علامت ستاره (*) قبل از نام متغیر قرار می گیرد و مقادیر تمامی آرگومان هایی که keyword نیستند را در خود نگه می دارد. این تاپل (tuple) در صورتیکه آرگومان اضافه ای در فراخوانی تابع تعیین نشود، خالی باقی می ماند.

#!/usr/bin/python3

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print ("Output is: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

خروجی:

Output is:
10
Output is:
70
60
50

توابع Anonymous

این توابع anonymous نامیده می شوند، چرا که به صورت استاندارد با کلمه کلیدی def تعریف نمی شوند. شما می توانید برای ایجاد توابع کوچک anonymous از کلمه کلیدی lambda استفاده کنید.

  • فرم lambda می تواند هر تعداد آرگومان دریافت کند، ولی تنها یک مقدار را بر می گرداند. lambda ها نمی توانند حاوی چندین عبارت و دستور باشند.
  • تابع anonymous نمی تواند به صورت مستقیم برای چاپ فراخوانی شود چرا که نیاز به یک عبارت دارد.
  • توابع lambda دارای namespace های داخلی خود می باشند و تنها به متغیر های موجود در لیست پارامترها و آن هایی که در global تعریف شده اند دسترسی دارند.
  • اگرچه اینطور به نظر می رسد که lambda ها نسخه تک خطی توابع می باشند، آن ها همانند عبارت inline در C یا C نمی باشند.

شکل دستوری

lambda [arg1 [,arg2,.....argn]]:expression

مثال زیر فرم lambda و نحوه کارکرد آن را نشان می دهد:

#!/usr/bin/python3

# Function definition is here
sum = lambda arg1, arg2: arg1   arg2


# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))

خروجی:

Value of total :  30
Value of total :  40

عبارت return

عبارت return برای خروج از یک تابع است، که می تواند به طور دلخواه حاوی مقداری برای برگرداندن به فراخوانی تابع باشد. مثال زیر نحوه برگرداندن مقدار توسط return را نشان می دهد:

#!/usr/bin/python3

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1   arg2
   print ("Inside the function : ", total)
   return total

# Now you can call sum function
total = sum( 10, 20 )
print ("Outside the function : ", total )

خروجی:

Inside the function :  30
Outside the function :  30

Scope متغیرها

تمامی متغیرهای موجود در برنامه ممکن است در همه جای برنامه در دسترس نباشند. این موضوع به مکانی که متغیر تعریف شده است بستگی دارد.

Scope یک متغیر تعیین می کند که یک متغیر در کدام بخش از برنامه قابل دسترسی می باشد. در پایتون دو scope برای متغیرها وجود دارد:

  • متغیرهای Global
  • متغیرهای Local

متغیرهای Local در برابر Global

متغیرهایی که درون بدنه تابع تعریف می شوند دارای محدوده local و آن هایی که بیرون از تابع تعریف می شوند دارای محدوده global می باشند.

این بدان معناست که متغیرهای local تنها درون تابعی که تعریف شده اند قابل دسترسی می باشند، در حالی که متغیرهای global در سراسر بدنه برنامه توسط تمامی توابع در دسترس می باشند. زمانیکه شما یک تابع را فراخوانی می کنید، متغیرهایی که درون آن تعریف شده اند به scope آورده می شوند:

#!/usr/bin/python3

total = 0 # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1   arg2; # Here total is local variable.
   print ("Inside the function local total : ", total)
   return total

# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )

خروجی:

Inside the function local total :  30
Outside the function global total :  0

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

چاپ هرم Pyramid در پایتون

در این بخش، مثالی از نحوه و چگونگی چاپ هرم در زبان برنامه نویسی پایتون را نشان خواهیم داد:

def half_pyramid(rows):
    print('Half pyramid...\n')
    for i in range(rows):
        print('*' * (i 1))

def full_pyramid(rows):
    print('\nFull pyramid...\n')
    for i in range(rows):
        print(' '*(rows-i-1)   '*'*(2*i 1))

def inverted_pyramid(rows):
    print('\nInverted pyramid...\n')
    for i in reversed(range(rows)):
        print(' '*(rows-i-1)   '*'*(2*i 1))

half_pyramid(5)
full_pyramid(5)
inverted_pyramid(5)

خروجی

Half pyramid...

*
**
***
****
*****

Full pyramid...

    *
   ***
  *****
 *******
*********

Inverted pyramid...

*********
 *******
  *****
   ***
    *

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

پردازش XML در پایتون

در این بخش، نحوه parse و پردازش XML توسط زبان برنامه نویسی پایتون را با استفاده از API های DOM و SAX را نشان خواهیم داد. XML یک زبان قابل حمل (Portable) و متن باز است که به برنامه نویسان این امکان را می دهد تا برنامه های خود را توسعه دهند به طوری که این برنامه ها قابلیت خوانده شدن توسط برنامه های دیگر را داشته باشد، بدون در نظر گرفتن آنکه سیستم عامل و یا زبان برنامه نویسی مورد نظر چه خواهد بود.

XML چیست؟

XML مخفف Extensible Markup Language می باشد، که یک زبان نشانه گذاری مانند HTML یا SGML است. XML برای کار با داده های کم تا متوسط بدون نیاز به SQL بسیار کاربرد دارد.

معماری های XML Parser و API ها

کتابخانه استاندارد پایتون رابط های مختصر ولی مفیدی برای کار با XML فراهم کرده است.

دو تا از پایه ای ترین و از نظر استفاده گسترده ترین API ها برای داده XML رابط های SAX و DOM هستند.

  • SAX مخفف Simple API for XML: در اینجا، شما فراخوان هایی را برای رخدادهای مورد نظر ثبت می کنید و سپس به parser اجازه می دهید درون سند حرکت کند. این حالت زمانیکه سندهای شما خیلی بزرگ هستند و یا محدودیت حافظه دارید سودمند می باشد. در این حالت فایل های خوانده شده از دیسک parse می شوند و کل فایل هرگز در حافظه ذخیره نمی شود.
  • DOM مخفف Document Object Model: این API توصیه ی کنسرسیوم World Wide Web می باشد و اینگونه است که تمام فایل از حافظه خوانده شده و در یک فرم سلسله مراتبی (hierarchical) و درختی برای نمایش تمام ویژگی های سند XML ذخیره می شود.

واضح است که SAX نمی تواند پردازش اطلاعات در فایل های بزرگ را به همان سرعتی که DOM انجام می دهد، انجام دهد. از طرف دیگر، استفاده از DOM می تواند به طور جدی منابع شما را نابود کند، بخصوص اگر با فایل های کوچک با تعداد بالا کار می کنید.

Sax فقط خواندی است، در حالیکه DOM اجازه تغییرات در فایل XML را به شما می دهد. با توجه به اینکه این دو API متفاوت کاملا کامل کننده یکدیگر می باشند، دلیل ندارد که شما نتوانید از هردوی آن ها برای پروژه های بزرگ استفاده کنید.

در تمامی مثال های این آموزش، اجازه دهید از فایل XML ساده movies.xml زیر به عنوان ورودی استفاده کنیم:

<collection shelf = "New Arrivals">
<movie title = "Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title = "Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

parse کردن XML با SAX

SAX یک رابط استاندارد برای parse کردن XML به صورت رویداد محور (event-driven) است. پردازش XML با استفاده از SAX به طور معمول نیاز به ایجاد ContentHandler شما توسط xml.sax.ContentHandler خواهد داشت.

ContentHandler شما تگ های خاص و attribute هایی XML شما را کنترل می کند. یک شیء ContentHandler متدهایی برای کنترل رویدادهای مختلفی را فراهم می کند. متدهای startDocument و endDocument در شروع و پایان فایل XML فراخوانی می شوند. متد characters(text) داده کاراکتر فایل XML توسط پارامتر text ارسال می کند.

ContentHandler در شروع و پایان هر المان (element) فراخوانی می شود. در صورتی که parser در مُد namespace نباشد، متد های startElement(tag, attributes) و endElement(tag) فراخوانی می شوند، در غیر اینصورت، متدهای متناظر startElementNS و endElementNS فراخوانی می شوند. در اینجا، tag المان تگ می باشد، و attributes یک شیء Attribute می باشد.

متد make_parser

متد زیر یک شیء جدید parser ایجاد کرده و آن را برمیگرداند. آبجکت parser ایجاد شده اولین نوع parser خواهد بود که سیستم پیدا می کند.

xml.sax.make_parser( [parser_list] )

در زیر جزئیات پارامترها را مشاهده می کنید

parser_list: آرگومان اختیاری شامل یک لیست از parser ها مورد استفاده که باید همگی متد make_parser را پیاده سازی کنند.

متد parse

این متد یک SAX parser را ایجاد کرده و از آن برای parse کردن یک سند استفاده می کند.

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

در زیر جزئیات پارامترها را مشاهده می کنید:

xmlfile: نام فایل XML ای که قرار است خوانده شود.
contenthandler: شیء ContentHandler می باشد.
errorhandler: در صورت تعیین، errorhandler باید یک شیء SAX ErrorHandler باشد.

متد parseString

یک متد دیگر برای ایجاد یک SAX parser و همچنین parse رشته XML تعیین شده وجود دارد.

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

در زیر جزئیات پارامترها را مشاهده می کنید:

xmlfile: نام فایل XML ای که قرار است خوانده شود.
contenthandler: شیء ContentHandler می باشد.
errorhandler: در صورت تعیین، errorhandler باید یک شیء SAX ErrorHandler باشد.

مثال:

#!/usr/bin/python3

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print ("Type:", self.type)
      elif self.CurrentData == "format":
         print ("Format:", self.format)
      elif self.CurrentData == "year":
         print ("Year:", self.year)
      elif self.CurrentData == "rating":
         print ("Rating:", self.rating)
      elif self.CurrentData == "stars":
         print ("Stars:", self.stars)
      elif self.CurrentData == "description":
         print ("Description:", self.description)
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

خروجی

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

parse یا پردازش XML با DOM

DOM یا Document Object Model یک API مستقل از زبان از کنسرسیوم World Wide Web یا W3C می باشد که برای دسترسی و ویرایش مستندات XML به کار می رود.

DOM برای برنامه های با دسترسی تصادفی (random-access) بسیار سودمند می باشد. SAX تنها اجازه دیدن یک بیت از سند را در یک زمان ان به شما می دهد. در صورتی که یک المان را در SAX مشاهده می کنید، به المان های دیگر دسترسی ندارید.

در اینجا ساده ترین راه برای بارگذاری سریع یک سند XML و ایجاد یک شیء minidom با استفاده از ماژول xml.dom است. شیء minidom یک روش ساده parser است که یک درخت DOM از فایل XML ایجاد می کند.

مثال

#!/usr/bin/python3

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)

خروجی

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

 

به اشتراک گذاری این ارسال


لینک به ارسال
به اشتراک گذاری در سایت های دیگر

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

مهمان
ارسال پاسخ به این موضوع ...

×   شما در حال چسباندن محتوایی با قالب بندی هستید.   حذف قالب بندی

  تنها استفاده از ۷۵ اموجی مجاز می باشد.

×   لینک شما به صورت اتوماتیک جای گذاری شد.   نمایش به عنوان یک لینک به جای

×   محتوای قبلی شما بازگردانی شد.   پاک کردن محتوای ویرایشگر

×   شما مستقیما نمی توانید تصویر خود را قرار دهید. یا آن را اینجا بارگذاری کنید یا از یک URL قرار دهید.


×
×
  • جدید...