کدهای پایتون آماده کاربردی و ضروری برای برنامه نویسان مبتدی تا حرفه ای

۲۴۸ بازدید
آخرین به‌روزرسانی: ۰۳ تیر ۱۴۰۳
زمان مطالعه: ۱۷۸ دقیقه
کدهای پایتون آماده کاربردی و ضروری برای برنامه نویسان مبتدی تا حرفه ای

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

فهرست مطالب این نوشته
997696

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

نمونه کدهای پایتون آماده

تمرین کردن با نمونه کدها انتخاب بسیار خوبی برای تقویت ادراکات منطقی مغز و مهارت‌های برنامه‌نویسی است. بنابراین سعی کردیم که در این مطلب بهترین مجموعه را از نمونه کدهای پایتون آماده کنیم. در این بخش مجموعه گسترده‌ای از نمونه کدهای پایتون آماده را بررسی خواهیم کرد که شامل مفاهیم پایه‌ای زبان برنامه‌نویسی پایتون مانند «لیست» (List)، String، دیکشنری، تاپل، Set و غیره می‌شوند. در هر نمونه هم تلاش می‌کنیم که در‌صورت امکان چند روش متفاوت را برای حل مسئله بررسی کنیم.

نمونه کد برنامه های ساده

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

اضافه کردن دو عدد مختلف به یکدیگر در پایتون

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

دو عدد num1  و num2  داده شده‌اند. وظیفه ما این است کدی بنویسیم که این دو عدد را با هم جمع ببندد و نتیجه را به کاربر نمایش دهد. روش‌های متفاوتی برای اجرای عمل جمع در پایتون وجود دارد. در این مطلب از روش‌های زیر برای انجام این کار کمک می‌گیریم.

  • استفاده از عملگر +
  • تعریف کردن تابعی برای جمع کردن ۲ عدد
  • به‌کار گرفتن متد operator.add
کامپیوتر روی میز روشن است. دو چرامغ مطالعه دو طرف کامپیوتر قرار دارند.

در ادامه هر کدام از این متدها را همراه با توضیح به‌طور کامل کدنویسی کرده‌ایم.

جمع کردن دو عدد با استفاده از عملگر «+»

در این مسئله num1  و num2  متغیرهای مسئله هستند و می‌خواهیم این متغیرها را با استفاده از عملگر + جمع ببندیم. به کد زیر نگاه کنید.

1num1 = 15
2num2 = 12
3
4# Adding two nos
5sum = num1 + num2
6
7# printing values
8print("Sum of", num1, "and", num2 , "is", sum)

خروجی کد بالا به صورت زیر است.

Sum of 15 and 12 is 27

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

اضافه کردن دو عدد در پایتون به کمک تعریف تابع سفارشی

در برنامه‌ نوشته شده روش انجام عمل جمع را با تابع سفارشی خودمان پیاده‌سازی کرده‌ایم. بسیار ساده می‌توان تابعی تعریف کرد که دو «عدد صحیح» (Integer) بپذیرد و نتیجه جمع این دو عدد را برگرداند. به کد آورده‌ شده در زیر توجه کنید.

1def add(a,b):
2  return a+b
3
4#initializing the variables
5num1 = 10
6num2 = 5
7
8#function calling and store the result into sum_of_twonumbers
9sum_of_twonumbers = add(num1,num2)
10
11#To print the result
12print("Sum of {0} and {1} is {2};" .format(num1,
13						num2, sum_of_twonumbers))

خروجی کد بالا به صورت زیر است.

Sum of 10 and 5 is 15;

جمع بستن دو عدد با استفاده از متد operator.add

در این کد ابتدا دو متغیر num1  و num2  را مقداردهی کرده‌ایم. سپس کتابخانه برنامه‌نویسی operator را «وارد» (Import) محیط کدنویسی خود کرده و متد add() را از این کتابخانه فراخوانی کردیم. سپس متغیرها را به عنوان پارامتر به این متد ارسال کردیم و بعد از آن نتیجه عمل جمع را به متغیر su تخصیص می‌دهیم.

1num1 = 15
2num2 = 12
3
4# Adding two nos
5import operator
6su = operator.add(num1,num2)
7
8# printing values
9print("Sum of {0} and {1} is {2}" .format(num1,
10									num2, su))

خروجی کد بالا به صورت زیر است.

Sum of 15 and 12 is 27

در نهایت هم با کمک تابع print() نتیجه را به کاربر نمایش می‌دهیم.

پیداکردن بیشترین مقدار بین دو عدد Maximum

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

  • استفاده از عبارت شرطی if-else
  • استفاده از تابع max()
  • استفاده از «عملگر سه‌تایی» (Ternary Operator)
دو مانیتورروشن بر روی میز قرار دارند. رنگ قابل بنفش است

کار خود را با اولین روش یعنی عبارت شرطی if-elseشروع می‌کنیم.

پیداکردن بیشترین مقدار با کمک عبارت شرطی if-else

استفاده از عبارت شرطی if-else برای مقایسه بین دو عدد یکی از رویکردهای بسیار ساده در پایتون است. با کمک عبارت شرطی if-else به راحتی می‌توان دو عدد را مقایسه کرد و نتیجه نهایی را به کاربر نمایش داد. به کدی که در ادامه آمده توجه کنید.

1def maximum(a, b):
2	
3	if a >= b:
4		return a
5	else:
6		return b
7	
8# Driver code
9a = 2
10b = 4
11print(maximum(a, b))

خروجی کد بالا به صورت زیر است.

4

استفاده از تابع max برای پیدا کردن بیشترین مقدار

تابع max() بیشترین مقدار را بین مقادیری که به عنوان پارامتر دریافت کرده پیدا می‌کند. به کدی که در ادامه پیاده‌سازی شده توجه کنید.

1a = 2
2b = 4
3
4maximum = max(a, b)
5print(maximum)

خروجی کد بالا به صورت زیر است.

4

استفاده از عملگر سه تایی برای پیدا کردن بیشترین مقدار

عملگر سه‌تایی نوعی از عبارت‌های شرطی if-else است. به این صورت که در این نوع از عبارت شرطی، چیزی را بر اساس شرطی ارزیابی می‌کنند که دو حالت True  یا False دارد. این تکنیک شرط نویسی کمک می‌کند که به‌سادگی عبارتی را در یک خط کد بسنجیم. به مثال زیر توجه کنید.

1a = 2
2b = 4
3
4# Use of ternary operator
5print(a if a >= b else b)

خروجی کد بالا به صورت زیر است.

4

محاسبه مقدار فاکتوریل یک عدد

فاکتوریل برای عدد صحیح مثبت غیر صِفر، برابر است با حاصل ضرب همه‌ اعداد کوچکتر مساوی همان عدد در یکدیگر. این اعداد از یک شروع می‌شوند و صِفر جزو این اعداد نیست. برای مثال فاکتوریل عدد 6 برابر با 6*5*4*3*2*1 است که مساوی با عدد 720 می‌شود.

برای این مسئله هم سه روش را پیاده‌سازی کرده‌ایم.

  • محاسبه فاکتوریل با رویکرد توابع بازگشتی
  • محاسبه فاکتوریل با رویکرد اشیای پیمایشی
  • محاسبه فاکتوریل با استفاده از عملگر سه‌تایی

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

محاسبه فاکتوریل با رویکرد توابع بازگشتی

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

1def factorial(n):
2	
3	# single line to find factorial
4	return 1 if (n==1 or n==0) else n * factorial(n - 1) 
5
6# Driver Code
7num = 5
8print("Factorial of",num,"is",factorial(num))

خروجی کد بالا به صورت زیر است.

Factorial of 5 is 120

محاسبه فاکتوریل با رویکرد اشیای پیمایشی

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

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

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

1def factorial(n):
2	if n < 0:
3		return 0
4	elif n == 0 or n == 1:
5		return 1
6	else:
7		fact = 1
8		while(n > 1):
9			fact *= n
10			n -= 1
11		return fact
12
13# Driver Code
14num = 5
15print("Factorial of",num,"is",
16factorial(num))

خروجی کد بالا به صورت زیر است.

Factorial of 5 is 120

محاسبه فاکتوریل با استفاده از عملگر سه تایی

همان‌طور که قبلا اشاره کردیم منظور از «عملگر سه‌تایی» (Ternary Operator) عبارت شرطی یک‌خطی است که انجام رفتار بسته به شرطی است که بین دو حالت True یاFalse قرار می‌گیرد. برای این حالت نیز تابعی به نام factorial  تعریف می‌کنیم. به کد زیر نگاه کنید.

1def factorial(n):
2
3	# single line to find factorial
4	return 1 if (n==1 or n==0) else n * factorial(n - 1) 
5
6
7# Driver Code
8num = 5
9print ("Factorial of",num,"is",
10	factorial(num))

خروجی کد بالا به صورت زیر است.

Factorial of 5 is 120

بررسی عدد آرمسترانگ

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

فرمول این عدد به صورت زیر است.

abcd... = pow(a,n) + pow(b,n) + pow(c,n) + pow(d,n) + ....

برای مثال عدد 153 یک عدد آرمسترانگ است. محاسبه زیر را نگاه کنید.

1*1*1 + 5*5*5 + 3*3*3 = 153

اگر برنامه ما عدد 153 را به عنوان ورودی دریافت کند باید در خروجی مقدار Yes را چاپ کند اما عدد 120 عدد آرمسترانگ نیست. به محاسبه زیر توجه کنید.

1*1*1 + 2*2*2 + 0*0*0 = 9

اگر برنامه ما عدد 120 را به عنوان ورودی دریافت کند باید در خروجی مقدار No را چاپ کند.

برای حل این مسئله هم از سه روش مختلف استفاده خواهیم کرد. ولی روش‌های دیگری نیز برای حل این مسئله وجود دارند.

  1. بررسی عدد آرمسترانگ با کمک تابع سفارشی power
  2. بررسی عدد آرمسترانگ بدون استفاده از تابع power
  3. بررسی عدد آرمسترانگ با تبدیل عدد به رشته

از شماره اول شروع می‌کنیم.

بررسی عدد آرمسترانگ با کمک تابع سفارشی power

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

در کد زیر توابع توصیف شده بالا به ترتیب تعریف شده‌اند.

1def power(x, y):
2	
3	if y == 0:
4		return 1
5	if y % 2 == 0:
6		return power(x, y // 2) * power(x, y // 2)
7		
8	return x * power(x, y // 2) * power(x, y // 2)
9
10# Function to calculate order of the number
11def order(x):
12
13	# Variable to store of the number
14	n = 0
15	while (x != 0):
16		n = n + 1
17		x = x // 10
18		
19	return n
20
21# Function to check whether the given 
22# number is Armstrong number or not
23def isArmstrong(x):
24	
25	n = order(x)
26	temp = x
27	sum1 = 0
28	
29	while (temp != 0):
30		r = temp % 10
31		sum1 = sum1 + power(r, n)
32		temp = temp // 10
33
34	# If condition satisfies
35	return (sum1 == x)
36
37# Driver code
38x = 153
39print(isArmstrong(x))
40
41x = 1253
42print(isArmstrong(x))

خروجی حاصل از اجرای کد بالا به صورت زیر است.

True

False

بررسی عدد آرمسترانگ بدون استفاده از تابع power

عدد آرمسترانگ سه رقمی به عددی می‌گویند که مجموع مکعب همه رقم‌هایش برابر با خود عدد باشد. همان‌طور که اشاره کردیم عدد 153 نمونه‌ای از اعداد آرمسترانگ است.

1*1*1 + 5*5*5 + 3*3*3 = 153

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

کامپیوتر روشن برروی میز رنگ بنفش

درون حلقه اول از همه یکان عدد را به صورت باقی‌مانده تقسیم عدد بر 10 بدست می‌آوریم. حاصل عبارت 153%10 برابر با عدد 3 است. در مرحله بعد مکعب رقم یکان «3» را به متغیر sum1  اختصاص می‌دهیم. سپس در مرحله بعد رقم یکان را از عدد اصلی خارج می‌کنیم. به‌این صورت که با اجرای تقسیم صحیح بر 10 روی عدد اصلی رقم یکان حذف می‌شود 153//10=15 . این دو رقم را دوباره در حلقه while به گردش در می‌آوریم. حلقهwhile تا وقتی که عدد دریافتی برابر با صِفر شود به گردش ادامه ‌می‌دهد.

کدی که در پایین آمده روند اجرای این پردازش را نمایش می‌دهد.

1n = 153 # or n=int(input()) -> taking input from user
2s = n # assigning input value to the s variable
3b = len(str(n))
4sum1 = 0
5while n != 0:
6	r = n % 10
7	sum1 = sum1+(r**b)
8	n = n//10
9if s == sum1:
10	print("The given number", s, "is armstrong number")
11else:
12	print("The given number", s, "is not armstrong number")

خروجی کد بالا به صورت زیر است.

The given number 153 is armstrong number

بررسی عدد آرمسترانگ با تبدیل عدد به رشته

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

الگوریتمی که در بالا توضیح دادیم را به صورت مرحله به مرحله باید اجرا کنیم. پیاده‌سازی که ما انجام دادیم شامل 8 مرحله زیر می‌شود.

  1. با استفاده از تکه کد str(num) عدد ورودی را به رشته تبدیل می‌کنیم.
  2. با کمک تکه کد len(num_str) طول رشته را بدست می‌آوریم و در متغیر n ذخیره می‌کنیم.
  3. متغیری به نام اختیاری sum  ایجاد می‌کنیم و با مقدار صِفر مقداردهی می‌کنیم.
  4. با استفاده از حلقه forبر روی هر کارکتر رقمی در رشته پیمایش می‌کنیم و با کمک تابع int(digit) هر رقم را به عدد صحیح تبدیل می‌کنیم.
  5. با به‌کار بردن تکه کد int(digit)**n هر رقم را به توان n  می‌رسانیم و نتیجه توان را با مقدار متغیر sum جمع می‌بندیم.
  6. بعد از اینکه فرایند حلقه کامل شد بررسی می‌کنیم که آیا مقدار sum با مقدار عدد ورودی num  برابر است یا نه.
  7. اگر sum برابر با num باشد بنابراین مقدار True یا Yes را برمی‌گردانیم. این مقدار برگشتی به معنی این است که عدد دریافتی برنامه از نوع اعداد آرمسترانگ است.
  8. اگر sum برابر با num نباشد باید مقدار False یا No را بر‌گردانیم. این مقدار برگشتی به معنی این است که عدد دریافتی برنامه از نوع اعداد آرمسترانگ نیست.

فرایند پیاده‌سازی این مراحل به صورت زیر است.

1def is_armstrong(num):
2	num_str = str(num)
3	n = len(num_str)
4	sum = 0
5	for digit in num_str:
6		sum += int(digit)**n
7	if sum == num:
8		return True
9	else:
10		return False
11num=153
12print(is_armstrong(num))

خروجی کد بالا با عدد فرضی دریافتی 153 به صورت زیر است.

True

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

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

مساحت دایره را می‌توان به‌سادگی با کمک فرمول Area = pi * r2 بدست آورد. در این فرمول «r» نمایانگر شعاع دایره و «pi» نمایانگر همان عدد پی معروف 3.14  است.

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

  1. نوشتن تابع سفارشی خودمان برای محاسبه مساحت دایره
  2. استفاده از کتابخانه math در پایتون

نوشتن تابع سفارشی برای محاسبه مساحت دایره

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

1def findArea(r):
2	PI = 3.142
3	return PI * (r*r);
4
5# Driver method
6print("Area is %.6f" % findArea(5));

خروجی کد بالا به صورت زیر است.

Area is 78.550000

استفاده از کتابخانه math در پایتون

کتابخانه math در پایتون یکی از قوی‌ترین و کاربردی‌ترین کتابخانه‌های پایتون است که برای کمک به حل محاسبات ریاضی به‌کار می‌رود. می‌توانیم از این کتابخانه برای دسترسی به عدد پی با دقت بالا هم استفاده کنیم.

1import math
2def area(r):
3area = math.pi* pow(r,2)
4return print('Area of circle is:' ,area)
5area(4)

خروجی کد بالا به صورت زیر است.

Area of circle is: 50.26548245743669

یافتن همه اعداد اول در یک محدوده خاص

فرض کنیم که دو عدد صحیح مثبت به عنوان نقاط شروع و پایان یک محدوده عددی داده شده‌اند. مسئله این است که برنامه پایتون بنویسیم که تمام اعداد اول داخل این محدوده را برای ما پیدا و در نهایت بر روی صفحه نمایش کاربر چاپ کند.

کامپیوتر و لپتاپ روشن بر روی میز کنار یک چراغ مطالعه قرار گرفته ‌اند

اول از همه به تعریف عدد اول توجه کنید: عدد اول به عددی می‌گویند که صحیح، مثبت و بزرگتر از ۱ باشد، همچنین به هیچ عددی به‌جز خودش و ۱ بخش‌پذیر نباشد. برای مثال می‌توان از مجموعه اعداد {2, 3, 5, 7, 11, ….} به عنوان چند عدد اول نام برد.
در این بخش از مطلب کدهای پایتون آماده، برای یافتن عدد اول چهار روش کلی را پیاده‌سازی کردیم. نام این روش‌ها را در فهرست زیر می‌بینید.

  1. روش عادی و ساده برای پیدا کردن عدد اول
  2. روش بهینه‌سازی شده
  3. روش «الک اراتوستن» (Sieve of Eratosthene)
  4. روش بهینه الک اراتوستن یا «الک بیتی» (Bitwise Sieve)

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

روش عادی پیدا کردن عدد اول با پیاده سازی آسان

ساده‌ترین ایده‌ای که برای حل این مسئله به ذهن می‌رسد پیمایش محدوده مورد نظر از اول تا انتها با استفاده از حلقه‌‌های پایتونی است. هر عدد n که بزرگتر از 1 باشد را بررسی می‌کنیم که آیا بر اعداد کوچکتر از نصف خودش بخش‌پذیر است یا نه. هر عددی که بر اعداد کوچکتر از نصف خودش به‌جز عدد یک بخش‌پذیر نبود را در لیست اعداد اول وارد می‌کنیم.

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

1def prime(x, y):
2	prime_list = []
3	for i in range(x, y):
4		if i == 0 or i == 1:
5			continue
6		else:
7			for j in range(2, int(i/2)+1):
8				if i % j == 0:
9					break
10			else:
11				prime_list.append(i)
12	return prime_list
13
14# Driver program
15starting_range = 2
16ending_range = 7
17lst = prime(starting_range, ending_range)
18if len(lst) == 0:
19	print("There are no prime numbers in this range")
20else:
21	print("The prime numbers in this range are: ", lst)

خروجی کد بالا به صورت زیر است.

The prime numbers in this range are:  [2, 3, 5]

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

ایده اصلی برای حل این مسئله این است که مثل روش اول کل محدوده را از ابتدا تا انتها با استفاده از حلقه for پیمایش کنیم. سپس برای هر عددی که به اعدادی به غیر از خودش و یک بخش‌پذیر است – همان‌طور که در تعریف اعداد اول آمده- متغیر تعریف شده به عنوان «پرچم» (flag) را برابر با مقدار یک قرار می‌دهیم. در بلاک بعدی هر عددی که پرچم متناظرش برابر با صِفر باشد به لیست اعداد اول اضافه می‌شود.

مراحل پیاده‌سازی این کد را قدم به قدم در 5 بخش پایین شرح دادیم.

  • مرحله اول: متغیری برای پرچم و لیست به صورت جداگانه تعریف می‌کنیم.
  • مرحله دوم: بخش‌پذیری هر عنصر داخل محدوده را بر اعداد کوچک‌تر می‌سنجیم. در این مرحله در واقع اول بودن هر عدد را بررسی می‌کنیم.
  • مرحله سوم: اگر هر عنصر مورد بررسی به عددی بخش‌پذیر بود بلافاصله پرچم برابر یک می‌شود. سپس دستور break  را اجرا می‌کنیم که دور بعدی حلقه شروع شود. در غیر این‌صورت مقدار پرچم متناظر این عنصر مقدار صِفر می‌گیرد.
  • مرحله چهارم: برای هر عنصر اگر مقدار پرچم صِفر باشد، عنصر را با استفاده از متد append به لیست اعداد اول اضافه می‌شود.
  • مرحله پنجم: لیست را برمی‌گردانیم.

در ادامه کد پیاده‌سازی شده مراحل بالا را می‌بینید.

1def prime(starting_range, ending_range):
2lst=[]
3flag=0				 #Declaring flag variable
4for i in range(starting_range, ending_range):#elements range between starting and ending range 
5	for j in range(2,i): 
6	if(i%j==0):	 #checking if number is divisible or not
7		flag=1	 #if number is divisible, then flag variable will become 1
8		break
9	else:
10		flag=0	
11	if(flag==0): #if flag variable is 0, then element will append in list 
12	lst.append(i)
13return lst
14
15# Driver program
16starting_range = 2
17ending_range = 7
18lst = prime(starting_range, ending_range)
19if len(lst) == 0:
20	print("There are no prime numbers in this range")
21else:
22	print("The prime numbers in this range are: ", lst)

خروجی کد بالا به صورت زیر است.

The prime numbers in this range are:  [2, 3, 5]

روش الک اراتوستن

روش «الک اراتوستن» (The Sieve Of Eratosthene) یکی از کارآمدترین روش‌ها برای پیدا کردن همه اعداد اول کوچک‌تر از N است وقتی که N برابر با 10 میلیون یا حتی بیشتر باشد.

میز کار و کامپیوتری بر روی آن

مراحل مورد استفاده در این روش به شرح زیر توصیف شده است.

  1. یک آرایه از نوع داده بولین به صورت prime[srt to n] ایجاد می‌کنیم. سپس همه محتویات داخل آن را با True مقداردهی اولیه می‌کنیم.
  2. عناصر prime[0] و prime[1] را برابر False قرار می‌دهیم. زیرا این عناصر عدد اول نیستند.
  3. برای هر عدد اول p که کوچک‌تر یا مساوی جزر n  باشد از p = srt  شروع می‌کنیم و همه مضارب عدد p  را که بزرگتر یا مساوی p*p  باشند را به عنوان عدد غیر اول علامت‌گزاری می‌کنیم. این علامت‌گزاری با اختصاص دادن مقدار False به prime[i]  انجام می‌گیرد.
  4. در نهایت هم همه اعداد اول بین str  و n را با تابع print()  نمایش می‌دهیم.

پیاده‌سازی این مراحل را می‌توانید در کد زیر ببینید.

1import math
2
3def SieveOfEratosthenes(srt, n):
4	# Create a boolean array "prime[srt to n]" and
5	# initialize all entries it as true. A value in
6	# prime[i] will finally be false if i is Not a prime,
7	# else true.
8	prime = [True for i in range(n + 2 - srt)]
9	prime[0] = False
10	prime[1] = False
11
12	for p in range(srt, int(math.sqrt(n))+1):
13		# If prime[p] is not changed, then it is a prime
14		if prime[p] == True:
15			# Update all multiples of p greater than or
16			# equal to the square of it numbers which are
17			# multiple of p and are less than p^2 are
18			# already been marked.
19			for i in range(p*p, n+1, p):
20				prime[i] = False
21
22	# Print all prime numbers
23	for p in range(srt, n+1):
24		if prime[p]:
25			print(p, end=" ")
26
27# Driver Code
28if __name__ == "__main__":
29	srt = 1
30	end = 10
31	SieveOfEratosthenes(srt, end)

اعداد اول حاصل از اجرای کد بالا را در پایین می‌بینید.

2 3 5 7

پیچیدگی زمانی: «پیچیدگی زمانی» (Time Complexity) الک اراتوستن برابر با O(n×log(log(n)))O(n\times\log(\log(n))) است. چون که این الگوریتم روی همه اعداد از 2 تا n پیمایش می‌کند و مضارب هر عدد اولی را که می‌بیند حذف می‌کند.

در این کد الگوریتم را فقط بر روی محدوده [srt, n] اعمال کرده‌ایم که باعث می‌شود پیچیدگی زمانی در محدوده [srt, n] به میزان O((nsrt+1)×log(log(n)))O((n-srt+1)\times\log(\log(n))) کاهش یابد. حلقه‌ای که قرار است پرچم همه مضارب هر عدد اول را علامت‌گذاری کند از p*p تا n پیمایش می‌کند. این پیمایش به اندازه O((nsrt+1)×log(log(n)))O((n-srt+1)\times\log(\log(n))) زمان می‌برد. بنابراین کل پیچیدگی زمانی این کد برابر با O((nsrt+1)×log(log(n)))O((n-srt+1)\times\log(\log(n))) است.

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

یکی از تکنیک‌های بهینه‌سازی شده روشی که در مرحله قبل مشاهد کردیم به این شکل است که از اجرای عملیات روی همه اعداد زوج به صورت یک‌جا صرف نظر کنیم. با این کار اندازه آرایه prime را به نصف کاهش می‌دهیم. ضمنا زمان مورد نیاز برای هر پیمایش را به‌نصف کاهش می‌دهیم. به این روش «الک بیتی» (Bitwise Sieve) هم‌ می‌گویند.

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

1def bitwiseSieve(srt, n):
2
3	# prime[i] is going to store
4	# true if if i*2 + 1 is composite.
5	prime = [0]*int(n / 2);
6
7	# 2 is the only even prime so
8	# we can ignore that. Loop
9	# starts from 3.
10	if (srt%2 == 0):
11		srt += 1
12	if(srt <= 2):
13		srt = 3
14	i = srt
15	while(i * i < n):
16		# If i is prime, mark all its
17		# multiples as composite
18		if (prime[int(i / 2)] == 0):
19			j = i * i;
20			while(j < n):
21				prime[int(j / 2)] = 1;
22				j += i * 2;
23		i += 2;
24
25	# writing 2 separately
26	print(2,end=" ");
27
28	# Printing other primes
29	i = 3;
30	while(i < n):
31		if (prime[int(i / 2)] == 0):
32			print(i,end=" ");
33		i += 2;
34
35
36# Driver code
37if __name__=='__main__':
38	srt = 1
39	end = 10
40	bitwiseSieve(srt, end)

خروجی کد بالا به صورت زیر است.

2 3 5 7 

«پیچیدگی زمانی» (Time Complexity) این الگوریت برابر با O(n×log(log(n)))O(n\times\log(\log(n))) است. در این فرمول n برابر با فاصله بین محدوده اعداد است.

بررسی اول بودن عدد مشخص شده

در فرض این مسئله N را به عنوان یک عدد صحیح مثبت داده شده فرض می‌کنیم. مسئله این است که برنامه پایتون بنویسیم که اول بودن عدد N را بررسی کند.

توجه کنید که عدد اول، عددی صحیح، مثبت و بزرگتر از یک است که به هیچ عددی به‌جز ۱ و خودش بخش‌پذیر نیست. برای حل کردن این مسئله از دو روش استفاده می‌کنیم ولی بازهم روش‌های بیشتری برای حل این مسئله در دسترس‌ هستند.

  • برنامه ساده پایتونی برای بررسی اول بودن هر عدد
  • بررسی اول بود اعداد با استفاده از تابع بازگشتی
کامپیوتری با دو مانیتور روشن بر روی میز قرار دارد

برنامه ساده پایتونی برای بررسی اول بودن هر عدد

ایده اصلی این روش برای حل مسئله در بررسی عدد N بر پایه پیمایش همه اعداد از 2 تا « N/2» با استفاده از حلقه forبنا شده است. به این صورت بررسی می‌کنیم که آیا N بر اعداد پیمایش شده بخش‌پذیر است یا نه. اگر در این بررسی عددی پیدا کردیم که N بر آن بخش‌پذیر بود مقدار False را برگشت می‌دهیم. در غیر این‌صورت اگر هیچ عددی از 2 تا « N/2» پیدا نکردیم که N بر آن بخش‌پذیر باشد، این به معنای اول بودن عدد N است. پس مقدار True را برمی‌گردانیم.

فرایند ساده حل این مسئله را در کد پایین پیاده کرده‌ایم.

1num = 11
2# If given number is greater than 1
3if num > 1:
4	# Iterate from 2 to n / 2
5	for i in range(2, int(num/2)+1):
6		# If num is divisible by any number between
7		# 2 and n / 2, it is not prime
8		if (num % i) == 0:
9			print(num, "is not a prime number")
10			break
11	else:
12		print(num, "is a prime number")
13else:
14	print(num, "is not a prime number")

خروجی کد بالا به صورت زیر است.

11 is a prime number

بررسی اول بودن اعداد با استفاده از تابع بازگشتی

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

1from math import sqrt
2
3def Prime(number,itr): #prime function to check given number prime or not
4if itr == 1: #base condition
5	return True
6if number % itr == 0: #if given number divided by itr or not
7	return False
8if Prime(number,itr-1) == False: #Recursive function Call
9	return False
10	
11return True
12
13num = 13
14
15itr = int(sqrt(num)+1)
16
17print(Prime(num,itr))

خروجی کد بالا برای عدد فرضی 13 به صورت زیر است.

True

پیدا کردن عدد فیبوناچی شماره n

در ریاضیات دنباله Fn فیبوناچی با رابطه‌ای بازگشتی تعریف می‌شود. این رابطه بازگشتی بیان می‌کند مقدار هر جایگاه در دنباله برابر با مجموع اعداد جایگاه‌ قبلی خود با عدد قبل از آن در دنباله است. فرمول رابطه فیبوناچی به صورت Fn = Fn-1 + Fn-2 است. در این فرمول به صورت قراردادی مقدار جایگاه F0 برابر با 0 و مقدار جایگاه F1 برابر با 1 است. چند عنصر اول این دنباله به صورت زیر هستند.

۰، ۱، ۱، ۲، ۳، ۵، ۸، و ...

در این مسئله باید برنامه‌ای بنویسیم که شماره جایگاه را به صورت n دریافت کند و مقدار عددی n-اُمین جایگاه را در دنباله فیبوناچی پیدا کند. این مسئله را به 4 روش مختلف حل می‌کنیم.

  • پیداکردن n-اُمین عدد فیبوناچی با استفاده از تابع بازگشتی
  • پیداکردن n-اُمین عدد فیبوناچی با استفاده از «برنامه‌نویسی پویا» (Dynamic Programming)
  • پیداکردن n-اُمین عدد فیبوناچی با استفاده از برنامه‌نویسی پویا به همراه «بهینه‌سازی فضا» (Space Optimization)
  • پیداکردن n-اُمین عدد با استفاده از فرمول اصلی دنباله فیبوناچی

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

استفاده از تابع بازگشتی

در این روش حل مسئله از تابع بازگشتی استفاده می‌کنیم. در کد تابعی به نام Fibonacci(n) تعریف می‌شود که n-اُمین عنصر فیبوناچی را به صورت بازگشتی محاسبه می‌کند. کد نوشته شده، در ابتدا مقدار ورودی را اعتبارسنجی می‌کند. سپس با توجه به اعداد اول سری که 0 و 1 هستند عدد فیبوناچی مورد نظر را محاسبه می‌کند. در نهایت مقدار صحیح جواب را برمی‌گرداند یا مقدار سری اول را از عدد n کم می‌کند و دوباره خود را فراخوانی می‌کند. کدی که در ادامه نوشته‌ایم مقدار 10-اُمین عدد فیبوناچی را برمی‌گرداند.

1def Fibonacci(n):
2	if n<= 0:
3		print("Incorrect input")
4	# First Fibonacci number is 0
5	elif n == 1:
6		return 0
7	# Second Fibonacci number is 1
8	elif n == 2:
9		return 1
10	else:
11		return Fibonacci(n-1)+Fibonacci(n-2)
12
13# Driver Program
14
15print(Fibonacci(10))

خروجی کد بالا برابر با عدد 34  است.

استفاده از برنامه نویسی پویا

در این روش در کد، تابعی به نام fibonacci(n) را برای محاسبه اعداد فیبوناچی با استفاده از تکنیک برنامه‌نویسی پویا تعریف کرده‌ایم. سپس لیستی به نام FibArray  را با دو عدد اول سری فیبوناچی -0 و1- مقداردهی کردیم.

دو کامپیوتر روشن بر روی میز قرار دارند.

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

1FibArray = [0, 1]
2
3def fibonacci(n):
4	if n<0:
5		print("Incorrect input")
6	elif n<= len(FibArray):
7		return FibArray[n-1]
8	else:
9		temp_fib = fibonacci(n-1)+fibonacci(n-2)
10		FibArray.append(temp_fib)
11		return temp_fib
12
13# Driver Program
14
15print(fibonacci(9))

خروجی کد بالا به صورت زیر است.

21

استفاده از برنامه نویسی پویا به همراه بهینه سازی فضا

این روش همانند روش قبلی است با این تفاوت که لیستی برای نگهداری مقادیر فیبوناچی وجود ندارد و در نتیجه هیچ فضای حافظه‌ای برای نگهداری لیستی استفاده نمی‌شود. لیستی که به‌مرور زمان اندازه‌اش بزرگتر نیز می‌شود.

این فرایند در کد زیر پیاده‌سازی شده است.

1def fibonacci(n):
2	a = 0
3	b = 1
4	if n < 0:
5		print("Incorrect input")
6	elif n == 0:
7		return a
8	elif n == 1:
9		return b
10	else:
11		for i in range(2, n):
12			c = a + b
13			a = b
14			b = c
15		return b
16
17# Driver Program
18
19print(fibonacci(9))

خروجی کد بالا نیز برابر با عدد 21  است.

استفاده از فرمول اصلی دنباله فیبوناچی

این کد، تابعی به نام fibonacci(n)تعریف می‌کند. تابع fibonacci(n) به وسیله ساخت آرایه‌ای که شامل سری فیبوناچی تا n-اُمین عدد است، n-اُمین عدد سری فیبوناچی را محاسبه می‌کند. این تابع، داده‌های آرایه مورد نظر را با اولین اعداد سری فیبوناچی یعنی 0 و 1 مقداردهی اولیه می‌کند و سپس به صورت پیمایشی اعداد بعدی زنجیره را محاسبه می‌کند. برنامه‌ای که در ادامه می‌بینید 9-اُمین مقدار فیبوناچی را با استفاده از این روش محاسبه می‌کند.

(1)Fn=Fn1+Fn2,F1=1,F2=2(2)Fn=(1+5)n(15)n2n5(1) F_{n} = F_{n-1}+F_{n-2}, F_{1} =1,F_{2} =2 \\(2) F_{n} = \frac{(1+\sqrt{5})^{n}-(1-\sqrt{5})^{n}}{2^{n}\sqrt{5}}

1from math import sqrt 
2# import square-root method from math library
3def nthFib(n):
4	res = (((1+sqrt(5))**n)-((1-sqrt(5)))**n)/(2**n*sqrt(5))
5	# compute the n-th fibonacci number
6	print(int(res),'is',str(n)+'th fibonacci number')
7	# format and print the number
8	
9# driver code
10nthFib(12)

خروجی کد بالا هم برابر با عدد 144 است.

برنامه ای که بررسی می کند آیا عدد داده شده فیبوناچی هست یا نه؟

در این مسئله عدد n داده شده است. باید بررسی کنیم که آیا n جزو اعداد فیبوناچی است یا نه. در پایین چند عدد از زنجیره اعداد فیبوناچی را نمایش داده‌ایم.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ..

قانون جالبی درباره اعداد فیبوناچی وجود دارد که از آن می‌توان برای بررسی فیبوناچی بودن اعداد نیز استفاده کرد. این قانون بیان می‌کند، عددی فیبوناچی است که اگر و تنها اگر یکی یا هر دو فرمول (n2+4×5)(n^{2}+4\times5) یا &&(n^{2}-4\times5)&& مربع کامل باشند.

کد زیر برای بررسی اعداد با کمک این قانون پیاده‌سازی شده است.

1import math
2
3# A utility function that returns true if x is perfect square
4
5
6def isPerfectSquare(x):
7	s = int(math.sqrt(x))
8	return s*s == x
9
10# Returns true if n is a Fibonacci Number, else false
11
12
13def isFibonacci(n):
14
15	# n is Fibonacci if one of 5*n*n + 4 or 5*n*n - 4 or both
16	# is a perfect square
17	return isPerfectSquare(5*n*n + 4) or isPerfectSquare(5*n*n - 4)
18
19
20# A utility function to test above functions
21for i in range(1, 11):
22	if (isFibonacci(i) == True):
23		print(i, "is a Fibonacci Number")
24	else:
25		print(i, "is a not Fibonacci Number ")

خروجی کد بالا به صورت زیر است.

1 is a Fibonacci Number
2 is a Fibonacci Number
3 is a Fibonacci Number
4 is a not Fibonacci Number 
5 is a Fibonacci Number
6 is a not Fibonacci Number 
7 is a not Fibonacci Number 
8 is a Fibonacci Number
9 is a not Fibonacci Number 
10 is a not Fibonacci Number 

نمایش مقدار کد ASCII هر کاراکتر

در این بخش از کدهای پایتون، آماده نوشتن برنامه‌ای می‌شویم که هر کاراکتری بگیرد مقدار کد ASCII آن را نمایش می‌دهد.

برای پیدا کردن مقدار کد ASCII کاراکتر داده شده در پایتون از تابع ord() استفاده می‌کنیم. این تابع رشته داده شده به طول یک کاراکتر را به عنوان پارامتر تبدیل به کد ASCII می‌کند و عدد صحیح متناظر با کاراتر مورد نظر را برمی‌گرداند. برای مثال ord(‘a’) مقدار عدد صحیح 97 را برمی‌گرداند.

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

1c = 'g'
2# print the ASCII value of assigned character in c
3print("The ASCII value of '" + c + "' is", ord(c))

خروجی حاصل از کد بالا به صورت زیر است.

("The ASCII value of 'g' is", 103)

محاسبه مجموع مربعات اعدد طبیعی از 1 تا N

در این مسئله عدد صحیح مثبتی داده می‌شود و سوال این است که مجموع مربعات همه اعداد کوچک‌تر مساوی N را بدست بیاورید. رفتار برنامه باید مانند مثال آمده در پایین باشد.

Input : N = 4
Output : 30
= 1 + 4 + 9 + 16
= 30

Input : N = 5
Output : 55

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

  • روش اول یک برنامه ساده پایتونی
  • روش دوم استفاده از تکنیک List Comprehension
  • روش سوم استفاده از ساختار داده پیمایشی

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

برنامه ساده پایتونی

ایده این روش به این صورت است که برای هر iبه شرطی که 1 <= i <= n باشد مقدار i<sup>2</sup> را پیدا می‌کنیم و با متغیر sm  جمع می‌بندیم. این کار را با کمک یک حلقه انجام می‌دهیم. متغیر sm را در ابتدای عملیات با مقدار 0 مقداردهی می‌کنیم.

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

1def squaresum(n):
2
3	# Iterate i from 1
4	# and n finding
5	# square of i and
6	# add to sum.
7	sm = 0
8	for i in range(1, n+1):
9		sm = sm + (i * i)
10
11	return sm
12
13
14# Driven Program
15n = 4
16print(squaresum(n))

خروجی کد بالا برابر با عدد 30 است.

تکنیک List Comprehension

در این روش می‌خواهیم از تکنیک «Comprehension» برای لیست‌ها استفاده کنیم. در ابتدای کار لیستی از همه مربعات اعداد طبیعی مشخص شده ایجاد می‌کنیم. سپس عناصر لیست را با کمک تابع sum() جمع می‌بندیم. مراحل انجام این کار را در ادامه فهرست کرده‌ایم.

  1. با استفاده از تابع input عددی را از کاربر به عنوان ورودی دریافت کنید و بررسی کنید که صحیح و مثبت باشد.
  2. رشته ورودی را با استفاده از تابع int()  به نوع داده «عدد صحیح» (Integer) تبدیل کنید و در متغیر N ذخیره کنید.
  3. از روش Comprehension برای ساخت لیستی استفاده کنید که عناصر آن شامل مربع اعداد از 1 تا N می‌شود. این Comprehension باید شبیه به [i*i for i in range(1, N+1)] باشد. این تکه کد لیستی از مربع‌های همه اعداد از 1 تا N را تشکیل می‌دهد.
  4. از تابع sum() برای محاسبه مجموع همه عناصر لیست جدید ساخته شده استفاده کنید و نتیجه را در متغیر sum_of_squares ذخیره کنید.
  5. نتیجه را با استفاده از تابع print() در خروجی نمایش دهید.
از پنجره آفتاب به داخل اتاق می‌تابد. ۴ مانیتور روشن بر روی میز قرار دارند

کد پیاده‌سازی شده مربوط به مراحل بالا را در پایین می‌بینید.

1N = 5
2
3# Use list comprehension to create list of squares
4squares_list = [i*i for i in range(1, N+1)]
5
6# Find sum of squares using sum() function
7sum_of_squares = sum(squares_list)
8
9# Print the result
10print("Sum of squares of first", N, "natural numbers is", sum_of_squares)

خروجی ناشی از کد بالا به صورت زیر است.

Sum of squares of first 5 natural numbers is 55

استفاده از ساختار داده پیمایشی

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

  1. متغیری به نام sum را با مقدار صِفر مقداردهی اولیه می‌کنیم.
  2. از حلقه‌ای برای پیمایش بر روی اعداد طبیعی از 1 تا n استفاده می‌کنیم.
  3. درون حلقه هر عدد را به توان دو می‌رسانیم و با مقدار متغیر sum جمع می‌بندیم.
  4. بعد از اینکه پیمایش حلقه کامل شد مقدار متغیر sum را بر روی خروجی نمایش می‌دهیم.

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

1n = 4
2sum = 0
3for i in range(1, n+1):
4	sum += i**2
5
6print("The sum of squares of first", n, "natural numbers is", sum)

خروجی کد بالا به صورت زیر است.

The sum of squares of first 4 natural numbers is 30

برنامه نویسی حرفه ای پایتون با فرادرس

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

مجموعه آموزش برنامه نویسی پایتون از مقدماتی تا پیشرفته

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

برنامه های مربوط ساختارهای داده پیمایش پذیر

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

محاسبه مجموع عناصر آرایه

در مسئله فعلی، آرایه‌ای از اعداد صحیح داده شده و باید مجموع عناصر آرایه را بدست بیاوریم. در این برنامه باید جمع کل عناصر را با پیمایش همه اعضای آرایه محاسبه کنیم و به هر عنصر که می‌رسیم آن را به مجموع کل اضافه کنیم. چند مثال کاربردی را برای نمایش جمع همه عناصر آرایه در ادامه فهرست کرده‌ایم.

  • محاسبه مجموع عناصر آرایه با کدنویسی ساده پایتونی
  • محاسبه مجموع عناصر آرایه با استفاده از تابع sum()
  • محاسبه مجموع عناصر آرایه با استفاده از متد reduce()
  • محاسبه مجموع عناصر آرایه با استفاده از تابع enumerate()

کدنویسی ساده پایتونی

در این روش کل آرایه را پیمایش می‌کنیم و یک به یک عناصر را به مقدار متغیر sum اضافه می‌کنیم و در نهایت مقدار متغیر sum را نمایش می‌دهیم.

1def _sum(arr):
2
3	# initialize a variable
4	# to store the sum
5	# while iterating through
6	# the array later
7	sum = 0
8
9	# iterate through the array
10	# and add each element to the sum variable
11	# one at a time
12	for i in arr:
13		sum = sum + i
14
15	return(sum)
16
17
18# main function
19if __name__ == "__main__":
20	# input values to list
21	arr = [12, 3, 4, 15]
22
23	# calculating length of array
24	n = len(arr)
25	# calling function ans store the sum in ans
26	ans = _sum(arr)
27	# display sum
28	print('Sum of the array is ', ans)

خروجی کد بالا به صورت زیر است.

Sum of the array is  34

استفاده از تابع sum

در این روش از تابع درونی sum()استفاده می‌کنیم. پایتون تابع «درونی» (Built-In) به نام sum() فراهم کرده که برای محاسبه مجموع عناصر درون لیست به‌کار می‌رود.

1arr = [12, 3, 4, 15]
2
3# sum() is an inbuilt function in python that adds
4# all the elements in list,set and tuples and returns
5# the value
6ans = sum(arr)
7
8# display sum
9print('Sum of the array is ', ans)

خروجی کد بالا به صورت زیر است.

Sum of the array is  34

استفاده از متد reduce

در این روش از متد کتابخانه‌ای reduce() استفاده می‌کنیم. متد Array.reduce()  برای پیمایش آرایه‌ها و خلاصه‌سازی همه عناصر آرایه‌ها به‌کار می‌رود. این متد را باید در ابتدا از کتابخانه functools  به محیط کدنویسی وارد کرد. سپس متد reduce() تمام عناصر آرایه را با توجه به خواست و کدنویسی برنامه‌نویس، به یک مقدار تبدیل می‌کند. در کد زیر روش استفاده از این متد را پیاده‌سازی کرده‌ایم.

1def _sum(arr):
2
3	# iterate over array
4	# using reduce and get 
5	# sum on accumulator
6	sum = reduce(lambda a, b: a+b, arr) 
7
8	return(sum)
9
10
11# driver function
12arr = []
13# input values to list
14arr = [12, 3, 4, 15]
15
16# calculating length of array
17n = len(arr)
18
19ans = _sum(arr)
20
21# display sum
22print('Sum of the array is ', ans)

خروجی کد بالا به صورت زیر است.

('Sum of the array is ', 34)

استفاده از تابع enumerate

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

1list1 = [12, 3, 4, 15]
2s=0
3for i,a in enumerate(list1): 
4  s+=a 
5print(s)

خروجی کد بالا هم عدد 34 را نمایش می‌دهد.

پیدا کردن بزرگترین عنصر درون آرایه

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

Input : arr[] = {10, 20, 4}
Output : 20
Input : arr[] = {20, 10, 20, 4, 100}
Output : 100

این مسئله را به سه روش مختلف حل می‌کنیم. این روش‌ها را در فهرست زیر نام برده‌ایم.

  • روش عادی کدنویسی بدون استفاده از ابزار اختصاصی پایتون
  • پیدا کردن بزرگترین عنصر آرایه با کمک تابع درونیmax()
  • پیدا کردن بزرگترین عنصر آرایه با کمک تابع درونی sort()

بررسی روش‌های حل مسئله را به‌ترتیب از روش اول شروع می‌کنیم.

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

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

1def largest(arr, n):
2
3	# Initialize maximum element
4	max = arr[0]
5
6	# Traverse array elements from second
7	# and compare every element with
8	# current max
9	for i in range(1, n):
10		if arr[i] > max:
11			max = arr[i]
12	return max
13
14
15# Driver Code
16arr = [10, 324, 45, 90, 9808]
17n = len(arr)
18Ans = largest(arr, n)
19print("Largest in given array ", Ans)

خروجی حاصل از کد بالا به‌شکل زیر است.

Largest in given array  9808

پیدا کردن بزرگترین عنصر آرایه با کمک تابع درونی max

در این روش از تابع درونی max() استفاده خواهیم کرد تا بیشترین عنصر آرایه را پیدا کنیم. در کد آمده پایین این رویکرد حل مسئله را پیاده‌سازی کرده‌ایم.

1def largest(arr, n):
2	ans = max(arr)
3	return ans;
4
5# Driver code
6if __name__ == '__main__':
7	arr = [10, 324, 45, 90, 9808]
8	n = len(arr)
9	print ("Largest in given array ", largest(arr, n))

خروجی کد بالا به‌شکل زیر است.

Largest in given array  9808

پیدا کردن بزرگترین عنصر آرایه با کمک تابع درونی sort

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

1def largest(arr, n):
2
3	# Sort the array
4	arr.sort()
5
6	# The last element of the
7	# array is the largest element
8	return arr[n-1]
9	# or return arr[-1]
10
11# Driver Code
12arr = [10, 324, 45, 90, 9808]
13n = len(arr)
14Ans = largest(arr, n)
15print("Largest in given array ", Ans)

خروجی کد بالا به صورت زیر است.

Largest in given array  9808

این مسئله را با روش‌های دیگری مانند استفاده از تابع reduce()یا تکنیک تعریف تابع Lambda نیز می‌توان حل کرد.

اجرای عملیات چرخش آرایه ها

در تصویر زیر نمایشی از چرخش آرایه‌ها را می‌بینید.

دو آرایه بر روی هم و فلش آبی از بالا به پایین شاره می‌کند.
چرخش آرایه از راست به چپ به اندازه یک خانه

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

برای حل این مسئله از چهار روش مختلف فهرست شده در زیر استفاده کرده‌ایم.

  • روش عادی کدنویسی برای حل مسئله
  • چرخاندن عناصر آرایه با استفاده از لیست temp
  • چرخش عناصر آرایه به صورت یک‌ به‌ یک
  • چرخش آرایه با استفاده از الگوریتم چهارگانه Juggling

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

روش عادی کدنویسی برای حل مسئله

در این روش از عملیات قطعه‌بندی آرایه اصلی به زیرمجموعه‌های کوچک و معکوس کردن آن‌ها استفاده می‌کنیم. فرایند حل مسئله به صورت مرحله بندی‌شده زیر است. برای شروع فرض کنید آرایه arr[] = [1, 2, 3, 4, 5, 6, 7, 8] را در اختیار داریم.

  1. در ابتدا کل لیست را با جابه‌جا کردن اعداد اول و آخر لیست معکوس می‌کنیم.
  2. سپس اولین زیر مجموعه را انتخاب می‌کنیم. اولین زیر مجموعه، از خانه اول لیست تا خانه یکی مانده‌ به آخر لیست را شامل می‌شود.
  3. بعد از آن دوباره زیر مجموعه شماره یک را معکوس می‌کنیم.
  4. دفعه بعد زیر مجموعه شماره دو را انتخاب می‌کنیم و آن را معکوس می‌کنیم.
  5. و این کار را می‌توانیم تا آخر انجام بدهیم تا لیست به‌طور کامل یک بار بچرخد.

برای درک بهتر الگوریتم بالا به تصویر زیر نگاه کنید.

«برای مشاهده تصویر در اندازه اصلی، روی آن کلیک کنید»

کد آمده در پایین فرایند ذکر شده بالا را به صورت یک برنامه پایتون پیاده‌سازی کرده است.

1def reverse(start, end, arr):
2
3	# No of iterations needed for reversing the list
4	no_of_reverse = end-start+1
5
6	# By incrementing count value swapping 
7	# of first and last elements is done.
8	count = 0
9	while((no_of_reverse)//2 != count):
10		arr[start+count], arr[end-count] = arr[end-count], arr[start+count]
11		count += 1
12	return arr
13
14# Function takes array, length of
15# array and no of rotations as input
16
17
18def left_rotate_array(arr, size, d):
19
20	# Reverse the Entire List
21	start = 0
22	end = size-1
23	arr = reverse(start, end, arr)
24
25	# Divide array into twosub-array
26	# based on no of rotations.
27	# Divide First sub-array
28	# Reverse the First sub-array
29	start = 0
30	end = size-d-1
31	arr = reverse(start, end, arr)
32
33	# Divide Second sub-array
34	# Reverse the Second sub-array
35	start = size-d
36	end = size-1
37	arr = reverse(start, end, arr)
38	return arr
39
40
41arr = [1, 2, 3, 4, 5, 6, 7, 8]
42size = 8
43d = 1
44print('Original array:', arr)
45
46# Finding all the symmetric rotation number
47if(d <= size):
48	print('Rotated array: ', left_rotate_array(arr, size, d))
49else:
50	d = d % size
51	print('Rotated array: ', left_rotate_array(arr, size, d))

خروجی کد بالا به صورت زیر است.

Original array: [1, 2, 3, 4, 5, 6, 7, 8]
Rotated array:  [2, 3, 4, 5, 6, 7, 8, 1]

چرخاندن عناصر آرایه با استفاده از لیست temp

در این روش تابع rotate(ar[], d, n) را تعریف می‌کنیم که آرایه arr[] با اندازه n را به تعداد d عنصر می‌چرخاند.

یک آرایه سبز رنگ با ۷ خانه

چرخاندن آرایه‌ای که در بالا می‌بینید به اندازه ۲ خانه آرایه‌ را به شکل زیر می‌سازد.

آرایه ۷خانه ای سبز رنگ که عناصرش جا به جا شده اند.

فرایند حل مسئله با این روش به صورت زیر است.

  1. در ابتدا برنامه، آرایه ورودی را به همراه اندازه و تعداد خانه‌ای که باید بچرخد، دریافت می‌کند. مانند arr[] = [1, 2, 3, 4, 5, 6, 7] و d = 2 و n =7
  2. عناصر مربوط به d را که همان عناصری اند که باید بچرخند و از انتهای آرایه وارد شوند را در لیست temp  ذخیره می‌کند. temp[] = [1, 2]
  3. بقیه عناصر آرایه را به سمت راست حرکت می‌دهد. arr[] = [3, 4, 5, 6, 7, 6, 7]
  4. عناصر d را در انتهای آرایه دوباره وارد می‌کند. arr[] = [3, 4, 5, 6, 7, 1, 2]

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

1def rotateArray(arr, n, d):
2	temp = []
3	i = 0
4	while (i < d):
5		temp.append(arr[i])
6		i = i + 1
7	i = 0
8	while (d < n):
9		arr[i] = arr[d]
10		i = i + 1
11		d = d + 1
12	arr[:] = arr[: i] + temp
13	return arr
14
15
16# Driver function to test above function
17arr = [1, 2, 3, 4, 5, 6, 7]
18print("Array after left rotation is: ", end=' ')
19print(rotateArray(arr, len(arr), 2))

خروجی کد بالا به صورت زیر است.

Array after left rotation is:  [3, 4, 5, 6, 7, 1, 2]

چرخش عناصر آرایه به صورت یک به یک

برای اینکه بتوانیم عناصر آرایه را به صورت یک‌ به‌ یک بچرخانیم باید مقدار خانه arr[0] را در متغیر موقتی temp ذخیره کنیم. سپس مقدار موجود در خانه arr[1] را به خانه arr[0] انتقال دهیم و مقدار موجود در خانه arr[2] را به خانه arr[1] انتقال دهیم. این رفتار را ادامه می‌دهیم تا آخر که مقدار درون متغیر temp  را به خانه arr[n-1] انتقال بدهیم.

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

به عنوان مثال اگر آرایه arr[] = [1, 2, 3, 4, 5, 6, 7] به همراه d = 2 بابت اندازه چرخش آرایه در متن سوال آمده باشد. d = 2به معنای چرخش آرایه به اندازه دو خانه است. در ابتدا که آرایه را به صورت یک‌ به‌ یک می‌چرخانیم، بعد از حرکت اول آرایه به شکل [2, 3, 4, 5, 6, 7, 1] در می‌آید و بعد از حرکت دوم آرایه به‌شکل [ 3, 4, 5, 6, 7, 1, 2] در می‌آید.

می‌توانید کدهای مربوط به پیاده‌سازی این روش حل مسئله را در پایین ببینید.

1def leftRotate(arr, d, n):
2	for i in range(d):
3		leftRotatebyOne(arr, n)
4
5#Function to left Rotate arr[] of size n by 1*/ 
6def leftRotatebyOne(arr, n):
7	temp = arr[0]
8	for i in range(n-1):
9		arr[i] = arr[i+1]
10	arr[n-1] = temp
11		
12
13# utility function to print an array */
14def printArray(arr,size):
15	for i in range(size):
16		print ("%d"% arr[i],end=" ")
17
18
19# Driver program to test above functions */
20arr = [1, 2, 3, 4, 5, 6, 7]
21leftRotate(arr, 2, 7)
22printArray(arr, 7)

خروجی کد بالا به صورت زیر است.

3 4 5 6 7 1 2 

چرخش آرایه با استفاده از الگوریتم چهارگانه Juggling

این روش حالت گسترش‌داده‌ شده‌ای از روش دوم است. به‌جای اینکه یک‌ به‌ یک خانه‌ها را حرکت بدهیم آرایه را به مجموعه‌های جداگانه‌ای تقسیم می‌کنیم. تعداد مجموعه‌ها برابر با «بزرگترین مقسوم علیه مشترک» (GCD) است و باید عناصر را درون مجموعه‌ها جابه‌جا کنیم. اگر بزرگترین مقسوم علیه مشترک یا GCD برابر 1 باشد، همانطور که برای مثال بالا بود -GCD بین n = 7 وd =2 برابر 1 است- پس عناصر فقط درون یک مجموعه جا‌به‌جا می‌شوند. ما فقط کافی است که با temp = arr[0] شروع کنیم و به جا‌به‌جا کردن مقادیر از خانهarr[I+d]  به خانه arr[I] بپردازیم و در نهایت مقدار متغیر temp  را در جایگاه درست آن جایگذاری کنیم.

برای مثال فرض کنید که آرایه‌ای به شکل زیر در اختیار داریم. در این آرایه مقدار nبرابر با ۱۲ و مقدار d برابر با ۳ است. پس GCD نیز برابر با ۳ است.

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

در مرحله اول عناصر را در مجموعه اول جابه‌جا می‌کنیم. به دیاگرام زیر درباره این حرکت توجه کنید.

یک صف از آرایه‌ها در حال جابه‌جا شدن هستند.

آرایه arr[] بعد از مرحله بالا به شکل زیر در می‌آید.

{4 2 3 7 5 6 10 8 9 1 11 12} 

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

{4 5 3 7 8 6 10 11 9 1 2 12}

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

{4 5 6 7 8 9 10 11 12 1 2 3}

فرایند بالا را به صورت زیر در کدهای پایتون آماده کرده‌ایم.

1def leftRotate(arr, d, n):
2	for i in range(gcd(d, n)):
3
4		# move i-th values of blocks
5		temp = arr[i]
6		j = i
7		while 1:
8			k = j + d
9			if k >= n:
10				k = k - n
11			if k == i:
12				break
13			arr[j] = arr[k]
14			j = k
15		arr[j] = temp
16
17# UTILITY FUNCTIONS
18# function to print an array
19
20
21def printArray(arr, size):
22	for i in range(size):
23		print("%d" % arr[i], end=" ")
24
25# Function to get gcd of a and b
26
27
28def gcd(a, b):
29	if b == 0:
30		return a
31	else:
32		return gcd(b, a % b)
33
34
35# Driver program to test above functions
36arr = [1, 2, 3, 4, 5, 6, 7]
37leftRotate(arr, 2, 7)
38printArray(arr, 7)

خروجی کد بالا به صورت زیر است.

3 4 5 6 7 1 2

الگوریتم واژگون سازی برای چرخش آرایه

در این بخش از مطلب، الگوریتم Reversal را برای چرخاندن آرایه‌ها بررسی و کدهای مربوط به این فرایند را پیاده‌سازی می‌کنیم. در مسئله استفاده از «الگوریتم واژگون‌سازی» (Reversal Algorithm) برای چرخش آرایه ابتدا باید تابعی برای چرخش آرایه به‌شکل rotate(arr[], d, n) تعریف کنیم. این تابع باید آرایه arr[] را با تعداد n عنصر به اندازه d  بچرخاند.

فرض کنید آرایه‌ای به‌شکل زیر در اختیار داریم.

 arr[] = [1, 2, 3, 4, 5, 6, 7]

بعد از اینکه آرایه بالا را به اندازی ۲ واحد بچرخانیم آرایه زیر بدست می‌آید.

arr[] = [3, 4, 5, 6, 7, 1, 2] 

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

1def rverseArray(arr,n):
2	c=(arr[n:])+(arr[:n])
3	return c
4# Driver function to test above functions
5arr = [1, 2, 3, 4, 5, 6, 7]
6n=2
7print(rverseArray(arr,d))

خروجی کد بالا به صورت زیر است.

[3, 4, 5, 6, 7, 1, 2]

جدا کردن ابتدای آرایه و اتصال آن به انتهای آرایه

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

دو آرایه مختلف از اعداد در کنار هم قرار دارند.

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

  • روش اول: استفاده از تکنیک‌های عادی کدنویسی پایتون
  • روش دوم: استفاده از روش List Comprehension
  • روش سوم: استفاده از ماژول deque موجود در کتابخانه collections

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

استفاده از تکنیک های عادی کدنویسی پایتون

در این روش برای جدا کردن قسمتی از ابتدای آرایه و انتقال آن به انتهای آرایه از روش «برش زدن» (Slicing) لیست‌ها استفاده می‌کنیم. به کد نوشته شده در زیر دقت کنید.

1def splitArr(arr, n, k):
2	for i in range(0, k):
3		x = arr[0]
4		for j in range(0, n-1):
5			arr[j] = arr[j + 1]
6
7		arr[n-1] = x
8
9
10# main
11arr = [12, 10, 5, 6, 52, 36]
12n = len(arr)
13position = 2
14
15splitArr(arr, n, position)
16
17for i in range(0, n):
18	print(arr[i], end=' ')

خروجی کد بالا به صورت زیر است.

5 6 52 36 12 10 

استفاده از روش List Comprehension

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

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

فرایند حل این مسئله را در چهار مرحله به صورت قدم به قدم توصیف می‌کنیم.

  1. تابعی به شکل split_and_add(arr, n) تعریف می‌کنیم که در آن پرامتر arr نمایانگر آرایه‌ای است که می‌پذیرد. پارامتر n نیز نمایانگر عدد صحیحی است که از ورودی می‌گیرد.
  2. اندازه طول آرایه ورودی را با استفاده از تابع len() محاسبه می‌کنیم و درون متغیری به نام arr_len ذخیره می‌کنیم.
  3. از روش «List Comprehension» استفاده می‌کنیم تا لیستی تعریف کنیم که به اندازه آرایه ورودی باشد. هر عنصر لیست جدید با استفاده از فرمول (i + n) % arr_len محاسبه می‌شود. در این فرمول i شماره ایندکس عنصر موجود در آرایه ورودی است. لیست جدید را به عنوان خروجی تابع برمی‌گردانیم.
  4. خروجی تابع را در متغیری به نام result قرار داده و در نهایت بر بروی خروجی به کاربر نمایش می‌دهیم.

کد لازم برای پیاده‌سازی مراحل بالا به صورت زیر است.

1def split_and_add(arr, n):
2	return [arr[(i + n) % len(arr)] for i in range(len(arr))]
3
4
5arr = [12, 10, 5, 6, 52, 36]
6n = 2
7
8result = split_and_add(arr, n)
9
10print(*result)

خروجی کد بالا به صورت زیر است.

5 6 52 36 12 10

استفاده از ماژول deque موجود در کتابخانه collections

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

  1. ماژول deque را از کتابخانه collections به محیط کدنویسی خود Import می‌کنیم.
  2. تابعی به نام splitArr() تعریف می‌کنیم که پارامترهای آرایه a را به همراه طول آرایهn و عدد صحیحی با علامتk به عنوان ورودی می‌پذیرد.
  3. با استفاده از متد سازنده deque()  یک شی از کلاس deque  با نام q تعریف می‌کنیم.
  4. شی q از کلاس deque را به اندازه k موقعیت با استفاده از تابع rotate()  می‌چرخانیم. این عملیات به‌طور کارآمدی تعداد Kعدد از عناصر آرایه را به انتهای deque حرکت می‌دهد عناصر باقی مانده را به ابتدای آرایه انتقال می‌دهد.
  5. با استفاده از متد سازنده list()شی deque به نام q  را دوباره به لیست تبدیل می‌کنیم و نتیجه را برمی‌گردانیم.

در برنامه اصلی آرایه arr  را مقداردهی می‌کنیم. طول این آرایه به مقدار n خواهد بود. همچنین متغیری برای موقعیت به نام Kتعریف می‌کنیم. تابع splitArr()  را به همراه پارامترهای ورودی arrبه عنوان آرایه، n به عنوان طول آرایه و Kبه عنوان موقعیت درون آرایه که باید تغییر کند، فراخوانی می‌کنیم.

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

1from collections import deque
2
3def splitArr(a, n, k):
4q = deque(a)
5q.rotate(-k)
6return list(q)
7
8# main
9arr = [12, 10, 5, 6, 52, 36]
10n = len(arr)
11position = 2
12arr = splitArr(arr, n, position)
13for i in range(0, n):
14print(arr[i], end=' ')

خروجی کد بالا به صورت زیر است.

5 6 52 36 12 10

پیدا کردن باقی مانده تقسیم حاصل ضرب همه اعضای آرایه در یکدیگر بر n

در این مسئله آرایه‌ای از اعداد به همراه عدد n داده شده است. مسئله این است که اول همه اعضای آرایه را در یکدیگر ضرب کنیم. سپس حاصل ضرب را بر عدد n تقسیم کنیم و باقی‌مانده را برگردانیم.

به عنوان مثال فرض کنیم که آرایه arr[] = {100, 10, 5, 25, 35, 14} به همراه n=11 داده شده است. فرایند راه حل محاسبه جواب به صورت زیر است.

Explanation: 100 x 10 x 5 x 25 x 35 x 14 = 61250000 % 11 = 9
Output: 9

مثال بعدی را برای آرایه arr[] = {100, 10} به همراه n = 5 ببینید.

Explanation: 100 x 10 = 1000 % 5 = 0
Output : 0

این مسئله را به سه روش مختلف حل خواهیم کرد. روش‌های مورد نظر را در فهرست زیر نام‌برده‌ایم.

  • پیدا کردن باقیمانده تقسیم n بر حاصل ضرب اعضای آرایه با رویکرد ساده
  • استفاده از رویکرد ساده با جلوگیری از «سرریز» (Overflow) برای اعداد بزرگ
  • حل مسئله با استفاده از متد «functools.reduce»
خانم مهندس در حال کد نویسی در کامیپوتر است. دو مانیتور در مقابل او قرار دارند

برای ادامه مطلب، از ساده‌ترین روش که همان اولین روش است به حل مسئله خواهیم پرداخت.

پیدا کردن باقیمانده تقسیم n بر حاصل ضرب اعضای آرایه با رویکرد ساده

در این روش کافی است که به‌سادگی در ابتدای کار همه اعضای آرایه را در یکدیگر ضرب کنیم، سپس با کمک عملگر ٪ باقیمانده مقدار حاصل ضرب را در عدد n بدست می‌آوریم. اما نقطه ضعف این روش این است که برای اعداد بزرگتر از 2^64 جواب اشتباه می‌دهد.

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

1def findremainder(arr, len, n):
2	product = 1
3	for i in range(len):
4		product = product * arr[i]
5	return product % n
6
7
8arr = [100, 10, 5, 25, 35, 14]
9len = len(arr)
10n = 11
11print(findremainder(arr, len, n))

خروجی کد بالا برابر با عدد 9 است.

استفاده از رویکرد ساده با جلوگیری از سرریز برای اعداد بزرگ

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

( a * b) % c = ( ( a % c ) * ( b % c ) ) % c

در ادامه کدهای آماده پایتون را برای این روش ارائه داده‌ایم.

1def findremainder(arr, lens, n):
2	mul = 1
3
4	# find the individual
5	# remainder and 
6	# multiple with mul.
7	for i in range(lens): 
8		mul = (mul * (arr[i] % n)) % n
9	
10	return mul % n
11
12# Driven code
13arr = [ 100, 10, 5, 25, 35, 14 ]
14lens = len(arr)
15n = 11
16
17# print the remainder
18# of after multiple
19# all the numbers
20print( findremainder(arr, lens, n))

خروجی کد بالا برابر با عدد 9 است.

حل مسئله با استفاده از متد functools.reduce

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

1from functools import reduce
2
3def remainderAfterMultiplication(arr, n):
4	result = reduce(lambda x, y: (x * y) % n, arr)
5	return result
6
7# Driver Code
8arr1 = [100, 10, 5, 25, 35, 14]
9n1 = 11
10result1 = remainderAfterMultiplication(arr1, n1)
11print(result1)
12
13arr2 = [100, 10]
14n2 = 5
15result2 = remainderAfterMultiplication(arr2, n2)
16print(result2)

خروجی این کد به صورت زیر است.

9
0

بررسی یکنواخت بودن آرایه

در این مسئله فرض بر این است که آرایه A شامل n تعداد عدد صحیح داده شده است. سوال اینجاست که باید بررسی کنیم آیا این آرایه «یکنواخت» (Monotonic) است یا نه. آرایه‌ای «یکنواخت» (Monotonic) است که عناصر آن آرایه با آهنگ دائم و به‌طور یکنواختی کم یا زیاد شوند.

از پنجره ماه شب دیده می‌شود. کامپیوتر روشن است و بر روی میز قرار دارد - کدهای پایتون آماده

یا به این صورت می‌توان تعریف کرد که: آرایه A یکنواخت افزایشی است اگر برای همه i-های کوچکتر مساوی j i <= j رابطه A[i] <= A[j] برقرار باشد و آرایه A یکنواخت کاهشی است اگر برای همه i-های کوچکتر مساوی j i <= j رابطه A[i] >= A[j] برقرار باشد.

نوع داده برگشتی برنامه حل این مسئله از نوع Boolean است. اگر آرایه داده شده Monotonic باشد مقدار True و اگر آرایه داده شده Monotonic نباشد مقدار False برمی‌گردد. به‌عنوان مثالی از آرایه‌ها و خروجی برنامه به نمونه زیر نگاه کنید.

Input : 6 5 4 4
Output : true

Input : 5 15 20 10
Output : false

برای حل این مسئله از سه نمونه پیاده‌سازی شده متفاوت کدهای پایتون آماده استفاده کرده‌ایم.

  • استفاده از توابع sort و extend
  • کدنویسی تعریف Monotonic
  • به وسیله بررسی طول آرایه

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

استفاده از توابع sort و extend

برای حل مسئله به این روش کل فرایند را در ۴ بخش کلی دسته‌بندی کرده‌ایم.

  1. در ابتدا با استفاده از تابع extend() آرایه گرفته شده را در دو آرایه متفاوت کپی می‌کنیم.
  2. آرایه اول را با استفاده از تابع sort() به ترتیب افزایشی یا «صعودی» (Ascending) منظم می‌کنیم.
  3. آرایه دوم را با استفاده از تابع sort(reverse=True) به ترتیب کاهشی یا «نزولی» (Descending) منظم می‌کنیم.
  4. اگر آرایه گرفته شده با یکی از دو آرایه برابر بود نتیجه می‌گیریم که آرایه «یکنواخت» (Monotonic) است.

در پایین می‌توانید شکل کدنویسی شده این مراحل چهارگانه را ببینید.

1def isMonotonic(A):
2	x, y = [], []
3	x.extend(A)
4	y.extend(A)
5	x.sort()
6	y.sort(reverse=True)
7	if(x == A or y == A):
8		return True
9	return False
10
11
12# Driver program
13A = [6, 5, 4, 4]
14
15# Print required result
16print(isMonotonic(A))

خروجی کد بالا برابر با مقدار True  است.

کدنویسی تعریف Monotonic

آرایه‌ای «یکنواخت» (Monotonic) است اگر و تنها اگر که به صورت متناوبی کاهشی یا به صورت متناوبی افزایشی باشد. از آنجا که اگر p <= q باشد و q <= r باشد می‌توان نتیجه گرفت که p <= r است. بنابراین تنها کاری که باید بکنیم این است که عناصر مجاور یکدیگر را بررسی کنیم تا بفهمیم که آیا آرایه‌ای یکنواخت -افزایشی یا کاهشی- است یا نه. می‌توان هر دوی این ویژگی‌ها را به صورت همزمان در یک پیمایش بررسی کرد.

برای اینکه بررسی کنیم آیا آرایه A به صورت «یکنواختی افزایشی» (Monotonic Increasing) است باید رابطه A[i] <= A[i+1] را برای همه i-ها از ایندکس 0 تا len(A)-2 بررسی کنیم. به همین‌صورت می‌توانیم «یکنواختی کاهشی» (Monotonic Decreasing) را با بررسی رابطه A[i] >= A[i+1] برای همه i-ها از ایندکس 0 تا len(A)-2بررسی کنیم.

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

رویکرد بالا را برای حل مسئله در کدهای پایین پیاده‌سازی کرده‌ایم.

1def isMonotonic(A):
2
3	return (all(A[i] <= A[i + 1] for i in range(len(A) - 1)) or
4			all(A[i] >= A[i + 1] for i in range(len(A) - 1)))
5
6
7# Driver program
8A = [6, 5, 4, 4]
9
10# Print required result
11print(isMonotonic(A))

خروجی کد بالا برابر با مقدار True  است.

بررسی یک نواختی به وسیله اندازه گیری طول آرایه

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

کامپیوتری با یک مانیتور بر روی میز. شب است

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

1def isMonotonic(arr):
2	if len(arr) <= 2:
3		return True
4	direction = arr[1] - arr[0]
5	for i in range(2, len(arr)):
6		if direction == 0:
7			direction = arr[i] - arr[i - 1]
8			continue
9		if (direction > 0 and arr[i] < arr[i - 1]) or (direction < 0 and arr[i] > arr[i - 1]):
10			return False
11	return True
12
13# Example usage
14arr1 = [1, 2, 3, 4, 5] # True
15arr2 = [5, 4, 3, 2, 1] # True
16arr3 = [1, 2, 2, 3, 4] # True
17arr4 = [1, 2, 3, 4, 5, 4] # False
18
19print(isMonotonic(arr1)) # should return True
20print(isMonotonic(arr2)) # should return True
21print(isMonotonic(arr3)) # should return True
22print(isMonotonic(arr4)) # should return False

خروجی کد بالا به صورت زیر است.

True
True
True
False

به این نکته توجه کنید که این برنامه فرض را بر این می‌گذارد که آرایه داده شده لیستی از اعداد «صحیح» (Integer) است. اگر آرایه داده شده شامل نوع داده‌های دیگری باشد به‌طوری که مورد انتظار است کار نخواهد کرد.

در ادامه بررسی کدهای پایتون آماده به دیدن و تمرین بر روی برنامه‌های مربوط به لیست‌ها خواهیم پرداخت.

کدهای پایتون آماده برای کار با لیست ها

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

جابه جا کردن عناصر اول و انتهای لیست با هم

در این مسئله لیستی داده شده و باید برنامه‌ای بنویسیم که عناصر ابتدا و انتهای لیست را با یکدیگر جابه‌جا کند. به مثال زیر توجه کنید.

Input : [12, 35, 9, 56, 24]
Output : [24, 35, 9, 56, 12]

Input : [1, 2, 3]
Output : [3, 2, 1]

روش‌های بسیار زیادی برای انجام این عملیات بر روی لیست وجود دارد ولی از آنجا که تقریبا مثال‌هایی شبیه به این مسئله را در بخش آرایه‌ها حل کردیم فقط به ذکر ساده‌ترین روش با استفاده از کدهای معمولی پایتون می‌پردازیم. برای این کار طول لیست را پیدا می‌کنیم و به سادگی عنصر اول را با عنصر «n-1» در لیست جابه‌جا می‌کنیم.

به کدی توجه کنید که از روی روش توضیح داده شده بالا پیاده‌سازی کردیم.

1def swapList(newList):
2	size = len(newList)
3	
4	# Swapping 
5	temp = newList[0]
6	newList[0] = newList[size - 1]
7	newList[size - 1] = temp
8	
9	return newList
10	
11# Driver code
12newList = [12, 35, 9, 56, 24]
13
14print(swapList(newList))

خروجی کد بالا به صورت زیر است.

[24, 35, 9, 56, 12]

جابه جا کردن دو عنصر مختلف در جایگاه های مختلف در لیست

در این مسئله لیستی در پایتون داده شده است به همراه دو عدد که نماد جایگاه برای دو عنصر مختلف هستند. این دو عدد به شماره ایندکس اشاره نمی‌کنند. باید برنامه‌ای بنویسیم که این دو عنصر را در لیست با یکدیگر جابه‌جا کند. فرض کنید لیست [23, 65, 19, 90] داده شده است به همراه موقیعت‌هایpos2 = 3 و pos1 = 1 خروجی این برنامه باید لیستی به‌شکل[19, 65, 23, 90] باشد.

این مسئله را به چهار روش مختلف حل خواهیم کرد و کدهای پایتون آماده برای این روش‌ها را نمایش می‌دهیم.

  • جابه‌جایی دو عنصر مختلف با استفاده از عملگر کاما و تخصیص یا کاما-مساوی
  • استفاده از تابع درونی list.pop() برای جابه‌جایی عناصر مختلف
  • جابه‌جایی دو عنصر مختلف با استفاده از متغیر Tuple
  • جابه‌جایی دو عنصر مختلف با استفاده از تابع enumerate()
کامپیوتری با دو مانیتور روشن بر روی میز قرار دارد. از پنجره مشخص است که شب است

بررسی کدهای پایتون آماده را برای این مسئله از روش اول شروع می‌کنیم.

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

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

1def swapPositions(list, pos1, pos2):
2	
3	list[pos1], list[pos2] = list[pos2], list[pos1]
4	return list
5
6# Driver function
7List = [23, 65, 19, 90]
8pos1, pos2 = 1, 3
9
10print(swapPositions(List, pos1-1, pos2-1))

خروجی کد بالا به صورت زیر است.

[19, 65, 23, 90]

جابه جایی دو عنصر مختلف با استفاده از تابع درونی list.pop

برای حل مسئله با کمک تابع pop() فقط کافی است که عنصری که در موقعیت pos1 قرار دارد را بیرون بکشیم و در متغیری ذخیره کنیم به همین صورت، عنصری که در موقعیت pos2 قرار دارد را نیز بیرون بکشیم و در متغیر دیگری ذخیره کنیم. الان می‌توانیم هر دو عنصر را در مکان مرتبط با دیگری وارد کنیم. به کدی که درپایین از این فرایند پیاده‌سازی شده نگاه کنید.

1def swapPositions(list, pos1, pos2):
2	
3	# popping both the elements from list
4	first_ele = list.pop(pos1) 
5	second_ele = list.pop(pos2-1)
6	
7	# inserting in each others positions
8	list.insert(pos1, second_ele) 
9	list.insert(pos2, first_ele) 
10	
11	return list
12
13# Driver function
14List = [23, 65, 19, 90]
15pos1, pos2 = 1, 3
16
17print(swapPositions(List, pos1-1, pos2-1))

خروجی کد بالا به صورت زیر است.

[19, 65, 23, 90]

جابه جایی دو عنصر مختلف با استفاده از متغیر Tuple

برای این کار مقادیر موجود در جایگاه‌های pos1  وpos2 را به عنوان یک جفت داده در متغیر Tuple پایتون ذخیره کنید. نام این متغیر را به صورت دلخواه get  گذاشتیم. سپس هر دو عنصر را از متغیر خارج کرده و با جایگاه‌های مختلف در لیست وارد کنید. اکنون جایگاه این دو مقدار در لیست تغییر کرده است.

به کدی پیاده‌سازی شده در پایین توجه کنید.

1def swapPositions(list, pos1, pos2):
2
3	# Storing the two elements
4	# as a pair in a tuple variable get
5	get = list[pos1], list[pos2]
6	
7	# unpacking those elements
8	list[pos2], list[pos1] = get
9	
10	return list
11
12# Driver Code
13List = [23, 65, 19, 90]
14
15pos1, pos2 = 1, 3
16print(swapPositions(List, pos1-1, pos2-1))

خروجی کد بالا به صورت زیر است.

[19, 65, 23, 90]

جابه جایی دو عنصر مختلف با استفاده از تابع enumerate

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

به کدی که در ادامه از روی این روش حل مسئله نوشته شده نگاه کنید.

1def swapPositions(lis, pos1, pos2):
2	for i, x in enumerate(lis):
3		if i == pos1:
4			elem1 = x
5		if i == pos2:
6			elem2 = x
7	lis[pos1] = elem2
8	lis[pos2] = elem1
9	return lis
10
11List = [23, 65, 19, 90]
12pos1, pos2 = 1, 3
13print(swapPositions(List, pos1-1, pos2-1))

خروجی کد بالا به صورت زیر است.

[19, 65, 23, 90]

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

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

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

چند نفر به دور میزی نشسته‌اند و با لپتاپهایشان کار می‌کنند

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

  • استفاده از تابع len()
  • استفاده از روش ساده
  • استفاده از تابع length_hint()

بررسی تکنیک‌های پیدا کردن طول لیست را از روش اول یعنی تابع len()شروع می‌کنیم.

استفاده از تابع len برای پیدا کردن طول لیست

تابع len() یکی از توابع درونی پایتون است. از این تابع می‌توان برای پیدا کردن طول هر شی استفاده کرد. شی مورد نظر را باید به عنوان پارامتر به این تابع ارسال کرد. استفاده از این تابع کدنویسی بسیار ساده‌ای نیز دارد. به کد آمده در پایین توجه کنید.

1li = [10, 20, 30]
2n = len(li)
3print("The length of list is: ", n)

خروجی کد بالا به‌‌صورت زیر است.

The length of list is: 3

استفاده از روش ساده برای پیدا کردن طول لیست

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

1test_list = [1, 4, 5, 7, 8]
2
3# Printing test_list
4print("The list is : " + str(test_list))
5
6# Finding length of list using loop
7# Initializing counter
8counter = 0
9for i in test_list:
10
11	# incrementing counter
12	counter = counter + 1
13
14# Printing length of list
15print("Length of list using naive method is : " + str(counter))

خروجی حاصل از کد بالا به صورت زیر است.

The list is : [1, 4, 5, 7, 8]
Length of list using naive method is : 5

استفاده از تابع length_hint برای پیدا کردن طول لیست

این روش یکی از روش‌های کمتر شناخته شده برای شناسایی طول لیست‌ها است. این متد خاص در کلاس operator  تعریف شده است و می‌تواند تعداد عناصر حاضر در لیست را نیز محاسبه کند. در این بخش ما با استفاده از توابع len() و length_hint() طول لیست را پیدا خواهیم کرد.

به کدی که در ادامه آمده توجه کنید.

1from operator import length_hint
2
3# Initializing list
4test_list = [1, 4, 5, 7, 8]
5
6# Printing test_list
7print("The list is : " + str(test_list))
8
9# Finding length of list using len()
10list_len = len(test_list)
11
12# Finding length of list using length_hint()
13list_len_hint = length_hint(test_list)
14
15# Printing length of list
16print("Length of list using len() is : " + str(list_len))
17print("Length of list using length_hint() is : " + str(list_len_hint))

خروجی کد بالا به صورت زیر است.

The list is : [1, 4, 5, 7, 8]
Length of list using len() is : 5
Length of list using length_hint() is : 5

جست وجو به دنبال عنصر خاصی در لیست

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

دو مانیتور همراه با یک کیس نورپردازی شده در کنار هم به‌صورت روشن بر روی میز قرار گرفته اند

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

  • استفاده از عبارت in
  • استفاده از حلقه‌ برای بررسی لیست
  • استفاده از تابع any()
  • استفاده از تابع count()

برای انجام این عملیات روش‌های دیگری مانند استفاده از تابع sort() ، find() و غیره هم وجود دارند که البته می‌توانید با کمی خلاقیت یا جست‌وجو در اینترنت از این روش‌ها هم استفاده کنید. این بخش را با استفاده از عبارت inشروع می‌کنیم.

استفاده از عبارت in

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

در صورتی که عنصر مورد جست‌وجو در لیست وجود داشته باشد این برنامه مقدار Trueو اگر عنصر در لیست وجود نداشته باشد مقدار False برمی‌گرداند. برای کار کردن با این روش بررسی، نیازی نیست که لیست را منظم کنیم. به کد پیاده‌سازی شده این برنامه در ادامه توجه کنید.

1lst=[ 1, 6, 3, 5, 3, 4 ] 
2#checking if element 7 is present
3# in the given list or not
4i=7
5# if element present then return
6# exist otherwise not exist
7if i in lst: 
8	print("exist") 
9else: 
10	print("not exist")

خروجی کد بالا به صورت زیر است.

not exist

استفاده از حلقه‌ برای بررسی وجود آیتم خاصی در لیست

کد پایتونی که در این مثال داده شده در ابتدا لیستی به نام test_list را با چند «عدد صحیح» (Integer) مقداردهی می‌کند. سپس با کمک حلقه forبر روی همه عناصر درون لیست پیمایش می‌کند. بر روی هر عنصر با به‌کار بردن عبارت شرطی if چک می‌کند که آیا محتوای عنصر iبا مقدار 4 برابر است یا نه. عدد 4 اینجا فقط گزینه‌ای فرضی و آزمایشی است که در لیست به دنبالش می‌گردیم. اگر که شرط برقرار بود و عنصری پیدا شد که مقدار برابر 4 داشت برنامه جمله «Element Exists» را در خروجی نمایش می‌دهد. فقط به‌شرط موجود بودن آیتمی که به دنبال آن می‌گردیم در لیست، برنامه این خروجی را نمایش می‌دهد. در لیست آزمایشی ما [1, 6, 3, 5, 3, 4] این جمله بر روی خروجی نمایش داده خواهد شد.

در ادامه به کد زیر توجه کنید. کد زیر را از روی برنامه توصیف شده در بالا نوشته‌ایم.

1# Initializing list
2test_list = [1, 6, 3, 5, 3, 4]
3
4# Checking if 4 exists in list
5for i in test_list:
6	if(i == 4):
7		print("Element Exists")

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

Element Exists

استفاده از تابع any برای بررسی وجود داشتن آیتم در لیست

در این روش با استفاده از تابع any() همراه با عبارت «مولد» (Generator) به بررسی عناصر درون لیست برای پیدا کردن جواب می‌پردازیم. عبارت Generator بر روی همه اعضای لیست test_listپیمایش و بررسی می‌کند که آیا این عنصر بیشتر از یک‌بار در لیست ظاهر شده است یا نه. نتایج این بررسی لیست در متغیری به نام result  ذخیره می‌شود. در نهایت، کد پیامی را نمایش می‌دهد که به وضعیت تکرار عنصرها درون لیست اشاره می‌کند. اگر عنصر خاصی درون لیست تکرار شده باشد پیام « Does string contain any list element: True» را نمایش می‌دهد و اگر عنصر تکراری درون لیست پیدا نکند پیام «Does string contain any list element: False» را نمایش می‌دهد.

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

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

1# Initializing list
2test_list = [1, 6, 3, 5, 3, 4]
3
4result = any(item in test_list for item in test_list)
5print("Does string contain any list element : " +str(bool(result)))

خروجی کد بالا به صورت زیر است.

Does string contain any list element : True

بررسی وجود داشتن عنصر خاص در لیست با استفاده از تابع count

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

اگر عنصری که به برنامه داده شده در لیست موجود بود متد count() تعداد کل دفعاتی را که این عنصر در تمام لیست تکرار شده را نمایش می‌دهد. اگر خروجی متد count()عدد صحیح بزرگتر از صِفر بود به این معنی است که این عنصر در لیست وجود دارد.

در کد پایین روش استفاده از متد count() را برای بررسی وجود داشتن عنصر مشخص شده در لیست، پیاده‌سازی کرده‌ایم.

1# Initializing list
2test_list = [10, 15, 20, 7, 46, 2808]
3
4print("Checking if 15 exists in list")
5
6# number of times element exists in list
7exist_count = test_list.count(15)
8
9# checking if it is more than 0
10if exist_count > 0:
11	print("Yes, 15 exists in list")
12else:
13	print("No, 15 does not exists in list")

خروجی کد بالا به صورت زیر است.

Checking if 15 exists in list
Yes, 15 exists in list

روش های مختلف حذف عناصر داخل لیست یا خالی کردن لیست

در این مسئله باید لیستی را که در اختیار داریم به‌طور کامل خالی کنیم. پس چند مدل از روش‌های موجود برای حذف عناصر داخل لیست را باهم می‌بینیم. به‌واسطه ساختارهای متنوعی که زبان برنامه‌نویسی پایتون ارا‌ئه می‌دهد، روش‌های مختلفی نیز برای پاک‌سازی درون لیست‌ها وجود دارد. در این بخش از مطلب به بررسی سه نوع مختلف از کدهای پایتون آماده این روش‌ها می‌پردازیم.

  • استفاده از متد clear()
  • روش مقداردهی دوباره لیست
  • روش استفاده از *= 0

حذف داده های درون لیست با استفاده از متد clear

در این روش از متد clear() برای حذف داده‌های درون لیست استفاده می‌کنیم. این متد به صورت اختصاصی برای این کار تولید شده است و با کمترین کدنویسی این عملیات را انجام می‌دهد. در کد زیر استفاده از این متد را نمایش داده‌ایم.

1lst_test = [6, 0, 4, 1]
2print('lst_test before clear:', lst_test)
3
4# Clearing list
5lst_test.clear()
6print('lst_test after clear:', lst_test)

خروجی کد بالا به صورت زیر است.

lst_test before clear: [6, 0, 4, 1]
lst_test after clear: []

حذف داده های درون لیست با مقداردهی دوباره

در روش مقداردهی دوباره لیست، این‌بار لیست را با مقدار هیچی initialize می‌کنیم. در واقع لیستی با اندازه 0 را مقداردهی می‌کنیم. کد آمده در پایین این روش را نشان می‌دهد.

1list1 = [1, 2, 3]
2
3# Printing list2 before deleting
4print("List1 before deleting is : " + str(list1))
5
6# deleting list using reinitialization
7list1 = []
8
9# Printing list2 after reinitialization
10print("List1 after clearing using reinitialization : " + str(list1))

خروجی کد بالا به صورت زیر است.

List1 before deleting is : [1, 2, 3]
List1 after clearing using reinitialization : []

پاک کردن اعضای لیست با استفاده از عبارت 0=*

استفاده از عبارت *= 0 برای پاک کردن اعضای لیست روشی کمتر شناخته شده است. این روش همه اعضای داخل لیست را حذف می‌کند و باعث می‌شود لیست کاملا خالی شود. در واقع در این روش از عبارت تخصیص مرکب استفاده می‌کنیم. به این صورت که لیست را ضرب در 0  می‌کنیم و در خودش جای‌گذاری می‌کنیم. به کدی که در ادامه از پیاده‌سازی این روش بدست آمده توجه کنید.

1# Initializing lists
2list1 = [1, 2, 3]
3
4# Printing list2 before deleting
5print("List1 before clearing is : "
6	+ str(list1))
7
8list1*=0
9# Printing list2 after reinitialization
10print("List1 after clearing using *=0 : "
11	+ str(list1))

خروجی کد بالا به صورت زیر است.

List1 before clearing is : [1, 2, 3]
List1 after clearing using *=0 : []

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

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

  • استفاده از تکنیک «برش زدن» (Slicing)
  • معکوس کردن لیست از طریق جابه‌جا کردن اعداد ابتدا و انتهای لیست
  • استفاده از توابع درونی revese()  و reversed() در پایتون
  • معکوس کردن لیست با استفاده از ابزار کتابخانه Numpy
دو مانیتور روشن و یک کیبورد و یک موس بر روی میز قرار دارند.

با بررسی روش اول این مبحث را شروع می‌کنیم.

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

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