“`html

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

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

فهرست مطالب

• مبانی پایتون: متغیرها، انواع داده و عملگرها
• جریان کنترل: دستورات شرطی و حلقه‌ها
• توابع: تعریف، فراخوانی و آرگومان‌ها
• ساختارهای داده: لیست‌ها، تاپل‌ها، دیکشنری‌ها و مجموعه‌ها
• برنامه‌نویسی شیءگرا: کلاس‌ها، اشیاء و وراثت
• ماژول‌ها و پکیج‌ها: سازماندهی و استفاده از کد
• مدیریت خطا: Try-Except و استثناها
• ورودی/خروجی فایل: خواندن و نوشتن فایل‌ها
• مباحث پیشرفته: Decorators, Generators, Lambda Functions

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

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

انواع داده اصلی

• اعداد (Numbers): شامل اعداد صحیح (int)، اعداد اعشاری (float) و اعداد مختلط (complex).
• رشته‌ها (Strings): دنباله‌ای از کاراکترها که بین علامت‌های نقل قول (تک یا دوتایی) قرار می‌گیرند.
• بولین (Boolean): مقادیر True (درست) یا False (نادرست).

 # مثال‌هایی از انواع داده

 age = 30  # int
 price = 99.99  # float
 name = "John Doe"  # string
 is_student = True  # bool

 print(type(age))  # خروجی: <class 'int'>
 print(type(price)) # خروجی: <class 'float'>
 print(type(name))  # خروجی: <class 'str'>
 print(type(is_student)) # خروجی: <class 'bool'>
 

عملگرها

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

• عملگرهای حسابی: +, -, *, /, // (تقسیم صحیح), % (باقی‌مانده), ** (توان).
• عملگرهای مقایسه‌ای: == (برابر), != (نابرابر), >, <, >=, <=.
• عملگرهای منطقی: and, or, not.
• عملگرهای انتساب: =, +=, -=, *=, /=, //=, %=, **=.
• عملگرهای بیتی: & (AND), | (OR), ^ (XOR), ~ (NOT), << (شیفت به چپ), >> (شیفت به راست).
• عملگرهای عضویت: in, not in (بررسی وجود یک مقدار در یک دنباله).
• عملگرهای هویت: is, is not (بررسی اینکه آیا دو متغیر به یک شیء اشاره می‌کنند).

 # مثال‌هایی از عملگرها

 x = 10
 y = 5

 print(x + y)  # خروجی: 15
 print(x > y)  # خروجی: True
 print(x and y > 0)  # خروجی: True
 print(x % y)  # خروجی: 0

 numbers = [1, 2, 3, 4, 5]
 print(3 in numbers)  # خروجی: True

 a = [1, 2, 3]
 b = a
 c = [1, 2, 3]

 print(a is b)  # خروجی: True (a و b به یک شیء اشاره می‌کنند)
 print(a is c)  # خروجی: False (a و c دو شیء متفاوت هستند)
 

جریان کنترل: دستورات شرطی و حلقه‌ها

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

دستورات شرطی (if, elif, else)

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

 # مثال از دستور شرطی

 age = 18

 if age >= 18:
  print("شما مجاز به رای دادن هستید.")
 else:
  print("شما مجاز به رای دادن نیستید.")

 score = 85

 if score >= 90:
  print("A")
 elif score >= 80:
  print("B")
 elif score >= 70:
  print("C")
 else:
  print("D")
 

حلقه‌ها (for, while)

حلقه‌ها به برنامه اجازه می‌دهند یک بلوک کد را به طور مکرر اجرا کند.

• حلقه for: برای تکرار بر روی یک دنباله (لیست، تاپل، رشته و غیره) استفاده می‌شود.
• حلقه while: تا زمانی که یک شرط خاص درست باشد، یک بلوک کد را اجرا می‌کند.

 # مثال از حلقه for

 numbers = [1, 2, 3, 4, 5]

 for number in numbers:
  print(number)

 # مثال از حلقه while

 count = 0
 while count < 5:
  print(count)
  count += 1

 # استفاده از break و continue

 for i in range(10):
  if i == 3:
   continue  # پرش از تکرار فعلی
  if i == 7:
   break  # خروج از حلقه
  print(i)
 

توابع: تعریف، فراخوانی و آرگومان‌ها

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

تعریف تابع

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

 # تعریف یک تابع

 def greet(name):
  """این تابع یک اسم را به عنوان ورودی دریافت کرده و یک خوشامدگویی چاپ می‌کند."""
  print("Hello, " + name + "!")

 # فراخوانی تابع

 greet("Alice")  # خروجی: Hello, Alice!
 

آرگومان‌ها

توابع می‌توانند آرگومان‌هایی را به عنوان ورودی دریافت کنند. آرگومان‌ها می‌توانند موقعیتی ( positional ) یا کلیدواژه‌ای ( keyword ) باشند.

 # آرگومان‌های موقعیتی

 def add(x, y):
  return x + y

 print(add(5, 3))  # خروجی: 8

 # آرگومان‌های کلیدواژه‌ای

 def describe_person(name, age, city):
  print("Name:", name)
  print("Age:", age)
  print("City:", city)

 describe_person(name="Bob", age=25, city="New York")

 # آرگومان‌های پیش‌فرض

 def power(base, exponent=2):
  return base ** exponent

 print(power(5))  # خروجی: 25 (توان پیش‌فرض 2 است)
 print(power(5, 3))  # خروجی: 125
 

مقادیر بازگشتی

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

 # تابع با مقدار بازگشتی

 def multiply(x, y):
  return x * y

 result = multiply(4, 6)
 print(result)  # خروجی: 24
 

ساختارهای داده: لیست‌ها، تاپل‌ها، دیکشنری‌ها و مجموعه‌ها

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

لیست‌ها (Lists)

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

 # تعریف یک لیست

 my_list = [1, 2, 3, "apple", True]

 # دسترسی به آیتم‌ها

 print(my_list[0])  # خروجی: 1
 print(my_list[-1]) # خروجی: True

 # تغییر آیتم‌ها

 my_list[0] = 10
 print(my_list)  # خروجی: [10, 2, 3, "apple", True]

 # متدهای لیست

 my_list.append(6)  # اضافه کردن یک آیتم به انتها
 my_list.insert(2, "banana")  # اضافه کردن یک آیتم در یک موقعیت خاص
 my_list.remove("apple")  # حذف یک آیتم خاص
 my_list.pop(3)  # حذف یک آیتم در یک موقعیت خاص و بازگرداندن آن
 print(len(my_list))  # طول لیست

 # پیمایش لیست

 for item in my_list:
  print(item)
 

تاپل‌ها (Tuples)

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

 # تعریف یک تاپل

 my_tuple = (1, 2, 3, "apple", True)

 # دسترسی به آیتم‌ها

 print(my_tuple[0])  # خروجی: 1

 # تاپل‌ها غیرقابل تغییر هستند
 # my_tuple[0] = 10  # این خط خطا می‌دهد

 # متدهای تاپل (محدود)

 print(my_tuple.count(2))  # شمارش تعداد تکرار یک آیتم
 print(my_tuple.index("apple"))  # یافتن موقعیت یک آیتم
 

دیکشنری‌ها (Dictionaries)

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

 # تعریف یک دیکشنری

 my_dict = {
  "name": "Alice",
  "age": 30,
  "city": "London"
 }

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

 print(my_dict["name"])  # خروجی: Alice
 print(my_dict.get("age")) # خروجی: 30

 # تغییر مقادیر

 my_dict["age"] = 31
 print(my_dict)

 # اضافه کردن یک جفت کلید-مقدار

 my_dict["occupation"] = "Engineer"
 print(my_dict)

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

 print(my_dict.keys())  # لیست کلیدها
 print(my_dict.values()) # لیست مقادیر
 print(my_dict.items())  # لیست جفت‌های کلید-مقدار
 my_dict.pop("city")  # حذف یک کلید و مقدار آن
 print(my_dict)
 

مجموعه‌ها (Sets)

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

 # تعریف یک مجموعه

 my_set = {1, 2, 3, 4, 5, 5}  # تکراری‌ها حذف می‌شوند

 print(my_set)  # خروجی: {1, 2, 3, 4, 5}

 # متدهای مجموعه

 my_set.add(6)  # اضافه کردن یک آیتم
 my_set.remove(3)  # حذف یک آیتم
 print(len(my_set))  # طول مجموعه

 # عملیات مجموعه‌ای

 set1 = {1, 2, 3}
 set2 = {3, 4, 5}

 print(set1.union(set2))  # اجتماع
 print(set1.intersection(set2)) # اشتراک
 print(set1.difference(set2)) # تفاضل
 

برنامه‌نویسی شیءگرا: کلاس‌ها، اشیاء و وراثت

برنامه‌نویسی شیءگرا (OOP) یک رویکرد برنامه‌نویسی است که بر اساس مفهوم "اشیاء" است. اشیاء موجودیت‌هایی هستند که دارای داده (ویژگی‌ها) و رفتار (متدها) هستند. کلاس‌ها الگوهایی برای ایجاد اشیاء هستند.

کلاس‌ها

یک کلاس یک طرح یا الگو برای ایجاد اشیاء است. کلاس‌ها شامل متغیرها (ویژگی‌ها) و توابع (متدها) هستند.

 # تعریف یک کلاس

 class Dog:
  def __init__(self, name, breed):
   self.name = name
   self.breed = breed

  def bark(self):
   print("Woof!")

 # ایجاد یک شیء

 my_dog = Dog("Buddy", "Golden Retriever")

 # دسترسی به ویژگی‌ها

 print(my_dog.name)  # خروجی: Buddy
 print(my_dog.breed) # خروجی: Golden Retriever

 # فراخوانی متد

 my_dog.bark()  # خروجی: Woof!
 

وراثت

وراثت به یک کلاس (کلاس فرزند) اجازه می‌دهد ویژگی‌ها و متدهای کلاس دیگری (کلاس والد) را به ارث ببرد. وراثت باعث کاهش تکرار کد و افزایش قابلیت استفاده مجدد می‌شود.

 # وراثت

 class Animal:
  def __init__(self, name):
   self.name = name

  def speak(self):
   print("Generic animal sound")

 class Cat(Animal):
  def __init__(self, name, color):
   super().__init__(name)  # فراخوانی سازنده کلاس والد
   self.color = color

  def speak(self):
   print("Meow!")

 my_cat = Cat("Whiskers", "Black")
 print(my_cat.name)  # خروجی: Whiskers
 print(my_cat.color) # خروجی: Black
 my_cat.speak()  # خروجی: Meow!
 

ماژول‌ها و پکیج‌ها: سازماندهی و استفاده از کد

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

وارد کردن ماژول‌ها

برای استفاده از توابع و کلاس‌های موجود در یک ماژول، باید آن را با استفاده از کلمه کلیدی import وارد کنید.

 # وارد کردن یک ماژول

 import math

 # استفاده از توابع ماژول

 print(math.sqrt(16))  # خروجی: 4.0

 # وارد کردن با نام مستعار

 import math as m

 print(m.pi)  # خروجی: 3.141592653589793

 # وارد کردن توابع خاص

 from datetime import date

 today = date.today()
 print(today)
 

ایجاد ماژول‌ها

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

my_module.py:

 # my_module.py

 def my_function():
  print("Hello from my_module!")
 

 # استفاده از ماژول

 import my_module

 my_module.my_function()  # خروجی: Hello from my_module!
 

پکیج‌ها

پکیج‌ها دایرکتوری‌هایی هستند که حاوی ماژول‌ها و یک فایل __init__.py هستند. فایل __init__.py می‌تواند خالی باشد یا شامل کد инициализация پکیج باشد.

my_package/:

• __init__.py
• module1.py
• module2.py

module1.py:

 # module1.py

 def function1():
  print("Function 1 from module 1")
 

 # استفاده از پکیج

 import my_package.module1

 my_package.module1.function1() # خروجی: Function 1 from module 1

 from my_package import module2

 # ( assuming module2 exists)
 # module2.function2()
 

مدیریت خطا: Try-Except و استثناها

مدیریت خطا به برنامه اجازه می‌دهد به طور صحیح به خطاها و استثناها پاسخ دهد و از توقف غیرمنتظره برنامه جلوگیری کند. پایتون از ساختار try-except برای مدیریت خطاها استفاده می‌کند.

 # مدیریت خطا

 try:
  result = 10 / 0
 except ZeroDivisionError:
  print("Cannot divide by zero!")
 except Exception as e:
  print("An error occurred:", e)
 else:
  print("Result:", result)
 finally:
  print("This will always execute")
 

• try: بلوک کدی که ممکن است باعث بروز خطا شود.
• except: بلوک کدی که در صورت بروز خطا اجرا می‌شود. می‌توان چندین بلوک except برای مدیریت انواع مختلف خطاها داشت.
• else: بلوک کدی که در صورت عدم بروز خطا در بلوک try اجرا می‌شود.
• finally: بلوک کدی که همیشه اجرا می‌شود، صرف نظر از اینکه خطا رخ داده است یا نه.

ورودی/خروجی فایل: خواندن و نوشتن فایل‌ها

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

 # نوشتن در یک فایل

 try:
  with open("my_file.txt", "w") as f:
   f.write("Hello, world!\n")
   f.write("This is a new line.")
 except IOError as e:
  print("Error writing to file:", e)

 # خواندن از یک فایل

 try:
  with open("my_file.txt", "r") as f:
   content = f.read()
   print(content)
 except FileNotFoundError:
  print("File not found.")
 except IOError as e:
  print("Error reading from file:", e)

 # خواندن خط به خط

 try:
  with open("my_file.txt", "r") as f:
   for line in f:
    print(line.strip()) # remove newline character
 except FileNotFoundError:
  print("File not found.")
 except IOError as e:
  print("Error reading from file:", e)
 

حالت‌های باز کردن فایل:

• 'r': خواندن (فایل باید وجود داشته باشد).
• 'w': نوشتن (فایل را ایجاد می‌کند یا محتوای موجود را پاک می‌کند).
• 'a': افزودن (به انتهای فایل اضافه می‌کند).
• 'x': ایجاد (فایل را ایجاد می‌کند، اما اگر فایل از قبل وجود داشته باشد، خطا می‌دهد).
• 'b': حالت باینری (برای کار با فایل‌های باینری).
• 't': حالت متنی (حالت پیش‌فرض).

مباحث پیشرفته: Decorators, Generators, Lambda Functions

پایتون دارای ویژگی‌های پیشرفته‌ای است که به شما امکان می‌دهد کد خود را قدرتمندتر و انعطاف‌پذیرتر کنید.

Decorators

Decorators توابعی هستند که توابع دیگر را تغییر می‌دهند یا به آن‌ها اضافه می‌کنند. Decorators با استفاده از نماد @ قبل از تعریف تابع اعمال می‌شوند.

 # Decorator

 def my_decorator(func):
  def wrapper():
   print("Something is happening before the function is called.")
   func()
   print("Something is happening after the function is called.")
  return wrapper

 @my_decorator
 def say_hello():
  print("Hello!")

 say_hello()
 

Generators

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

 # Generator

 def my_generator(n):
  for i in range(n):
   yield i

 for number in my_generator(5):
  print(number)
 

Lambda Functions

Lambda functions توابع بی‌نام و کوچک هستند که می‌توانند در یک خط تعریف شوند. Lambda functions معمولاً برای ایجاد توابع ساده و کوتاه استفاده می‌شوند.

 # Lambda function

 square = lambda x: x * x

 print(square(5))  # خروجی: 25

 # استفاده از lambda function با map

 numbers = [1, 2, 3, 4, 5]
 squared_numbers = list(map(lambda x: x * x, numbers))
 print(squared_numbers)  # خروجی: [1, 4, 9, 16, 25]
 

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

```