برنامه نویسی تابع گرا

برنامه نویسی تابع گرا یا functional programming

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

def apply_twice(func, arg):
   return func(func(arg))

def add_five(x):
   return x + 5

print(apply_twice(add_five, 10))

خروجی:

>>>
20
>>>

نکته:تابع apply_twice عمل دیگری را به عنوان استدلال آن انجام می دهد و آن را دو بار در داخل بدنه کد خود فرا خوانی می کند.

توابع خالص و ناخالص (pure and impure functions)

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

def pure_function(x, y):
  temp = x + 2*y
  return temp / (2*x + y)

عملکرد ناخالص:

some_list = []

def impure(arg):
  some_list.append(arg)

نکته:تابع بالا خالص نیست، زیرا حالت some_list را تغییر داد.

استفاده از توابع خالص هم مزایا و هم معایب دارد.
توابع خالص عبارتند از:
– ساده تر در شفاف سازی و تست کردن
– کارآمدتر. هنگامی که عملکرد برای یک ورودی ارزیابی می شود، نتیجه می تواند ذخیره شود و به دفعه بعد که عملکرد آن ورودی مورد نیاز است، نسبت دهد تا تعداد دفعاتی که تابع فراخوانی می شود کاهش یابد. به این مدل memoization یا به اصطلاح یادداشت برداری می گویند.
– راحت تر به صورت parallel یا موازی اجرا شود.

نکته:معایب اصلی استفاده از تنها توابع خالص این است که آنها وظیفه ساده و آسان I / O را به شدت پیچیده می کنند، زیرا به نظر می رسد به طور ذاتی نیاز به عوارض جانبی دارد. همچنین می توانند در بعضی موقعیت ها دشوار باشند.

مگه میشه؟؟؟؟

تاپل ها

Tuple در پایتون

Tuple ها به لیستها بسیار شبیه هستند، به جز اینکه Tuple ها غیرقابل تغییر هستند .
همچنین، آنها با استفاده از پرانتز، به جای براکت مربعی، ایجاد می شوند.
مثال:

words = ("spam", "eggs", "sausages",)

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

print(words[0])

تلاش برای تخصیص یک مقدار در یک Tuple، یک TypeError را ایجاد می کند.

words[1] = "cheese"

خروجی:

>>>
TypeError: 'tuple' object does not support item assignment
>>>

نکته:مانند لیست ها و dictionary ها، tuple ها را می توان در داخل یکدیگر قرار داد.

tuple ها را می توان فقط با جدا کردن مقادیر با کاما و بدون پرانتز ایجاد کرد.
مثال:

my_tuple = "one", "two", "three"
print(my_tuple[0])

خروجی:

>>>
one
>>>

یک tuple خالی با استفاده از یک جفت پرانتز خالی ایجاد می شود.

tpl = ()

نکته:tuple ها سریعتر از لیست ها هستند اما قابل تغییر نیستند.

توابع دیکشنری

توابع dictionary

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

squares = {1: 1, 2: 4, 3: "error", 4: 16,}
squares[8] = 64
squares[3] = 9
print(squares)

خروجی:

{8: 64, 1: 1, 2: 4, 3: 9, 4: 16}

برای تعیین اینکه آیا یک کلید در یک dictionary است، می توانید از in و not in استفاده کنید، همانطور که می توانید برای یک لیست نیز استفاده کنید.
مثال:

nums = {
  1: "one",
  2: "two",
  3: "three",
}
print(1 in nums)
print("three" in nums)
print(4 not in nums)

خروجی:

>>>
True
False
True
>>>

یکی از متد های مفید پایتون که در Dictionary می باشد get است. این همان چیزی است که نمایه سازی (index) می کند، اما اگر کلید در dictionary یافت نشد، مقدار دیگر مشخص شده را به جای آن (به صورت پیش فرض “none”) به دست می آید.
مثال:

pairs = {1: "apple",
  "orange": [2, 3, 4], 
  True: False, 
  None: "True",
}

print(pairs.get("orange"))
print(pairs.get(7))
print(pairs.get(12345, "not in dictionary"))

خروجی:

>>>
[2, 3, 4]
None
not in dictionary
>>>

دیکشنری یا dictionary

dictionary در پایتون

Dictionaries ساختارهای داده مورد استفاده برای نمایش کلیدهای دلخواه به ارزش هستند.
لیست ها را می توان به عنوان فرهنگ لغت با کلید های صحیح در یک محدوده خاص در نظر گرفت.
Dictionaries را می توان به صورت مشابه با لیست ها، با استفاده از براکت های حاوی کلیدها، نشان داد.
مثال:

ages = {"Dave": 24, "Mary": 42, "John": 58}
print(ages["Dave"])
print(ages["Mary"])

خروجی:

>>>
24
42
>>>

نکته:هر عنصری را در dictionary می توان به حالت keyLvalue نشان داد.

تلاش برای باز کردن فهرست یک کلید که بخشی از dictionary نیست، KeyError را باز می کند.
مثال:

primary = {
  "red": [255, 0, 0], 
  "green": [0, 255, 0], 
  "blue": [0, 0, 255], 
}

print(primary["red"])
print(primary["yellow"])

خروجی:

>>>
[255, 0, 0]

KeyError: 'yellow'
>>>

همانطور که می بینید، یک dictionary می تواند هر نوع داده را به عنوان مقادیر ذخیره کند.

نکته:یک dictionary خالی را با {} نشان می دهند.

تنها اشیاء غیر قابل تغییر می توانند به عنوان کلید های dictionary مورد استفاده قرار گیرند. اشیاء غیر قابل تعویض هستند که قابل تغییر نیستند. تاکنون، تنها اشیا قابل تغییر که شما در آن قرار داده اید، لیست ها و dictionary ها هستند. تلاش برای استفاده از یک شیء قابل تغییر به عنوان یک کلید واژه دیکشنری سبب ایجاد TypeError می شود.

bad_dict = {
  [1, 2, 3]: "one two three", 
}

خروجی:

>>>
TypeError: unhashable type: 'list'
>>>

کار کردن با فایل ها

کار کردن با فایل

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

try:
   f = open("filename.txt")
   print(f.read())
finally:
   f.close()

این تضمین می کند که فایل همیشه بسته است، حتی اگر یک خطا رخ دهد.

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

with open("filename.txt") as f:
   print(f.read())

نکته:فایل به طور خودکار در انتهای بیانیه With بسته می شود، حتی اگر با Exception برخورد کند.

نوشتن در فایل

نوشتن در فایل

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

file = open("newfile.txt", "w")
file.write("This has been written to a file")
file.close()

file = open("newfile.txt", "r")
print(file.read())
file.close()

خروجی:

>>>
This has been written to a file
>>>

نکته:حالت “w” یک فایل ایجاد می کند، اگر قبلا وجود نداشته باشد.

هنگامی که یک فایل در حالت نوشتن باز می شود، محتوای موجود در فایل حذف می شود.

file = open("newfile.txt", "r")
print("Reading initial contents")
print(file.read())
print("Finished")
file.close()

file = open("newfile.txt", "w")
file.write("Some new text")
file.close()

file = open("newfile.txt", "r")
print("Reading new contents")
print(file.read())
print("Finished")
file.close()

خروجی:

>>>
Reading initial contents
some initial text
Finished
Reading new contents
Some new text
Finished
>>>

نکته:همانطور که می بینید محتوای فایل رونویسی شده است.

متد write در صورتی که موفق باشد مقدار بایت نوشته شده رد فایل را فراخواهد خواند.

msg = "Hello world!"
file = open("newfile.txt", "w")
amount_written = file.write(msg)
print(amount_written)
file.close()

خروجی:

>>>
12
>>>

خواندن محتویات فایل

خواندن فایل در پایتون

محتویات یک پرونده که در حالت متن باز شده است می تواند با استفاده از متد read خوانده شود. (خواندن فایل در حال حاضر محدود به فایل متنی است)

file = open("filename.txt", "r")
cont = file.read()
print(cont)
file.close()

نکته:این همه محتویات فایل “filename.txt” را چاپ می کند.

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

file = open("filename.txt", "r")
print(file.read(16))
print(file.read(4))
print(file.read(4))
print(file.read())
file.close()

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

file = open("filename.txt", "r")
file.read()
print("Re-reading")
print(file.read())
print("Finished")
file.close()

خروجی:

>>>
Re-reading

Finished
>>>

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

file = open("filename.txt", "r")
print(file.readlines())
file.close()

خروجی:

>>>
['Line 1 text \n', 'Line 2 text \n', 'Line 3 text']
>>>

شما می توانید از یک حلقه برای تکرار از طریق خطوط در فایل استفاده کنید:

file = open("filename.txt", "r")

for line in file:
    print(line)

file.close()

خروجی:

>>>
Line 1 text

Line 2 text

Line 3 text
>>>

نکته:در خروجی، خطوط با خط خالی جدا می شوند، به عنوان تابع چاپ به طور خودکار یک خط جدید را در انتهای خروجی آن اضافه می کند.