تعریف لیست (List) در پایتون

لیست (List) یکی از ساختارهای داده‌ای (Data Structure) در زبان پایتون است که برای ذخیره‌سازی مجموعه‌ای از داده‌ها در یک متغیر واحد استفاده می‌شود. لیست‌ها در پایتون قابل تغییر (Mutable) هستند؛ یعنی می‌توان بعد از ایجاد، عناصر آن‌ها را تغییر، حذف یا اضافه کرد.

نوع داده‌هایی که می‌تونن داخل لیست باشن

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

my_list = [12, "hamid", True, 4.5, [1, 2, 3]]

انواع داده‌ای که می‌تونه داخل لیست قرار بگیره:

عدد صحیح (int)، عدد اعشاری (float)، رشته (str)، مقدار بولی (bool)، لیست تو در تو (nested list)، هر نوع داده‌ی دیگر (مثل tuple، dict، object و ...)

شکل ظاهری لیست

لیست‌ها با استفاده از براکت [ ] ساخته می‌شن و عناصر با کاما , از هم جدا می‌شن:

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

ویژگی‌های اصلی لیست در پایتون

1. دسترسی به اعضا (Accessing Elements)

در لیست‌ها می‌تونیم با استفاده از اندیس (index) به هر عضو دسترسی پیدا کنیم. اندیس‌ها از 0 شروع می‌شن.

names = ["Ali", "Sara", "Reza"]


print(names[0]) #output: Ali
print(names[2]) #output: Reza

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

print(names[-1])  #output: Reza

2. قابل تغییر بودن (Mutable بودن)

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

numbers = [10, 20, 30]


numbers[1] = 50 # تغییر مقدار دوم
numbers.append(40) # افزودن عضو جدید
print(numbers) #output: [10, 50, 30, 40]

3. پذیرفتن مقادیر تکراری (Duplicate Values)

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

nums = [1, 2, 2, 3, 3, 3]


print(nums) #output: [1, 2, 2, 3, 3, 3]

4. دارای ترتیب (Ordered بودن)

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

fruits = ["apple", "banana", "cherry"]


print(fruits) #output: ['apple', 'banana', 'cherry']

روش‌های ساخت لیست خالی در پایتون

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

روش 1: با استفاده از براکت‌های مربعی []

a = []

روش 2: با استفاده از تابع list()

b = list()

هر دو روش یه لیست خالی می‌سازن و هیچ تفاوت عملکردی ندارن. می‌تونیم با تابع type() بررسی کنیم:

print(type(a))      # output: <class 'list'>


print(type(b)) # output: 

دسترسی به اعضای لیست با اندیس و برش (Indexing & Slicing)

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

۱. دسترسی با اندیس (Indexing)

fruits = ["apple", "banana", "cherry", "date"]


print(fruits[0]) # output: apple
print(fruits[2]) # output: cherry

اندیس منفی

print(fruits[-1]) # output: date
print(fruits[-2]) # output: cherry

نکته مهم: اگر اندیسی وارد کنیم که خارج از محدوده‌ی لیست باشه، خطای IndexError می‌گیریم.

۲. برش یا اسلایسینگ (Slicing)

فرمول کلی اسلایس:

list[start:end:step]

fruits = ["apple", "banana", "cherry", "date", "fig"]


print(fruits[1:4]) # ['banana', 'cherry', 'date']
print(fruits[:3]) # ['apple', 'banana', 'cherry']
print(fruits[2:]) # ['cherry', 'date', 'fig']
print(fruits[::2]) # ['apple', 'cherry', 'fig']

مثال‌های عملی

مثال: تغییر عضو با اندیس

fruits = ["apple", "banana", "cherry"]


fruits[1] = "mango"
print(fruits)

output: ['apple', 'mango', 'cherry']

مثال: ادغام دو لیست

list1 = [1, 2, 3]


list2 = [4, 5, 6]
result = list1 + list2
print(result)

output: [1, 2, 3, 4, 5, 6]

مثال: ضرب لیست

fruits = ["apple", "banana"]


print(fruits * 2)

output: ['apple', 'banana', 'apple', 'banana']

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

fruits = ["apple", "banana", "cherry"]


for fruit in fruits:
print(fruit)

output:
apple
banana
cherry

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

متد append()

تعریف و کاربرد: append() یک عضو را در انتهای لیست اضافه می‌کند. لیست اصلی تغییر می‌کند و مقدار برگشتی None است.

numbers = []


for i in range(5):
num = int(input("enter your number: "))
numbers.append(num)

print("final_list:", numbers)

متد extend()

extend() چند عضو را از یک iterable جداگانه به لیست اضافه می‌کند.

numbers = [1, 2, 3]


numbers.extend([4, 5, 6])
print(numbers)

output: [1, 2, 3, 4, 5, 6]

متد insert()

قابلیت افزودن عضو در موقعیت دلخواه: list.insert(index, value)

numbers = [10, 20, 30]


numbers.insert(1, 15) # اضافه کردن 15 در اندیس 1
print(numbers)

output:
[10, 15, 20, 30]

متد index()

برمی‌گرداند اندیس اولین وقوع یک مقدار در لیست: list.index(value)

اگر مقدار وجود نداشته باشد، خطای ValueError می‌دهد.

متد pop()

حذف و برگرداندن عضو با اندیس مشخص (یا آخرین عضو در صورت عدم تعیین اندیس): list.pop(index)

numbers = [10, 20, 30, 40]


removed = numbers.pop()
print("Removed:", removed)
print("List after pop:", numbers)

output:
Removed: 40
List after pop: [10, 20, 30]

متد remove()

حذف اولین عضو مطابق مقدار مشخص شده: list.remove(value)

numbers = [10, 20, 30, 20, 40]


numbers.remove(20) # حذف اولین 20
print(numbers)

output: [10, 30, 20, 40]

متد count()

تعداد دفعات تکرار یک مقدار را برمی‌گرداند: list.count(value)

numbers = [10, 20, 30, 20, 40, 20]


count_20 = numbers.count(20)
print("Number of 20s:", count_20)

output:
Number of 20s: 3

متد sort()

مرتب‌سازی لیست (عمومی): list.sort(reverse=False). لیست اصلی تغییر می‌کند.

numbers = [30, 10, 40, 20]


numbers.sort()
print(numbers)

output:
[10, 20, 30, 40]
مرتب‌سازی نزولی

numbers = [30, 10, 40, 20]
numbers.sort(reverse=True)
print(numbers)

output:
[40, 30, 20, 10]

متد clear()

پاک کردن تمام اعضای لیست: list.clear()

numbers = [10, 20, 30, 40]


numbers.clear()
print(numbers)

output:
[]

متدهای مرتبط با رشته: split() و join()

متد split()

برای تبدیل یک رشته به لیست بر اساس یک جداکننده:

info = "Python - Django - Flask"


parts = info.split(" - ")
print(parts)

output:
['Python', 'Django', 'Flask']

متد join()

برای ترکیب اعضای یک لیست از رشته‌ها به یک رشته واحد با جداکننده مشخص:

words = ['apple', 'banana', 'cherry']


sentence = " ".join(words)
print(sentence)

output:
apple banana cherry

langs = ['Python', 'Django', 'Flask']
joined = " - ".join(langs)
print(joined)

output:
Python - Django - Flask

💡 تمرین‌ها و سوالات

# خروجی: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# راه حل:
numbers = []
for i in range(1, 11):
    numbers.append(i)
print(numbers)

# یا به صورت ساده‌تر:
numbers = list(range(1, 11))
print(numbers)

# لیست: [1, 2, 3, 4, 5]
# خروجی: 15

# راه حل:
numbers = [1, 2, 3, 4, 5]
total = 0
for num in numbers:
    total += num
print(total)

# یا با تابع sum:
print(sum(numbers))

# لیست: [12, 45, 23, 67, 34]
# خروجی: 67

# راه حل:
numbers = [12, 45, 23, 67, 34]
maximum = numbers[0]
for num in numbers:
    if num > maximum:
        maximum = num
print(maximum)

# یا با تابع max:
print(max(numbers))

# لیست: [1, 2, 3, 4, 5]
# خروجی: [5, 4, 3, 2, 1]

# راه حل 1:
numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)

# راه حل 2:
numbers = [1, 2, 3, 4, 5]
reversed_list = numbers[::-1]
print(reversed_list)

# لیست: [1, 2, 2, 3, 4, 4, 5]
# خروجی: [1, 2, 3, 4, 5]

# راه حل:
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = []
for num in numbers:
    if num not in unique_numbers:
        unique_numbers.append(num)
print(unique_numbers)

# یا با set:
unique_numbers = list(set(numbers))
print(unique_numbers)

# لیست: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# خروجی: [2, 4, 6, 8, 10]

# راه حل:
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = []
for num in numbers:
    if num % 2 == 0:
        even_numbers.append(num)
print(even_numbers)

# لیست 1: [1, 2, 3]
# لیست 2: [4, 5, 6]
# خروجی: [1, 2, 3, 4, 5, 6]

# راه حل 1:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined)

# راه حل 2:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)

# لیست: [1, 2, 3, 2, 4, 2, 5]
# عنصر: 2
# خروجی: 3

# راه حل:
numbers = [1, 2, 3, 2, 4, 2, 5]
element = 2
count = numbers.count(element)
print(count)

# لیست: [1, 2, 3, 4, 5]
# جایگزینی: 3 با 30
# خروجی: [1, 2, 30, 4, 5]

# راه حل:
numbers = [1, 2, 3, 4, 5]
old_value = 3
new_value = 30
if old_value in numbers:
    index = numbers.index(old_value)
    numbers[index] = new_value
print(numbers)

# لیست: [34, 12, 78, 23, 45]
# خروجی: [12, 23, 34, 45, 78]

# راه حل 1:
numbers = [34, 12, 78, 23, 45]
numbers.sort()
print(numbers)

# راه حل 2:
numbers = [34, 12, 78, 23, 45]
sorted_numbers = sorted(numbers)
print(sorted_numbers)

# لیست: [12, 45, 23, 67, 34]
# خروجی: 45

# راه حل:
numbers = [12, 45, 23, 67, 34]
numbers.sort()
second_max = numbers[-2]
print(second_max)

# یا بدون تغییر لیست اصلی:
sorted_numbers = sorted(numbers)
print(sorted_numbers[-2])

# ورودی: "Hello World Python"
# خروجی: ['Hello', 'World', 'Python']

# راه حل:
sentence = "Hello World Python"
words = sentence.split()
print(words)

# لیست: ['Hello', 'World', 'Python']
# خروجی: "Hello World Python"

# راه حل:
words = ['Hello', 'World', 'Python']
sentence = ' '.join(words)
print(sentence)

# لیست: [1, 2, 4, 5]
# عنصر جدید: 3
# خروجی: [1, 2, 3, 4, 5]

# راه حل:
numbers = [1, 2, 4, 5]
numbers.insert(2, 3)
print(numbers)

# لیست: [1, 2, 3, 4, 5]
# عنصر حذف شده: 5
# لیست جدید: [1, 2, 3, 4]

# راه حل:
numbers = [1, 2, 3, 4, 5]
removed = numbers.pop()
print(f"عنصر حذف شده: {removed}")
print(f"لیست جدید: {numbers}")

# لیست: [10, 20, 30, 40, 50]
# عنصر: 30
# خروجی: 2

# راه حل:
numbers = [10, 20, 30, 40, 50]
element = 30
index = numbers.index(element)
print(index)

# خروجی: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# راه حل:
squares = []
for i in range(1, 11):
    squares.append(i ** 2)
print(squares)

# یا با list comprehension:
squares = [i ** 2 for i in range(1, 11)]
print(squares)

# لیست: [10, 20, 30, 40, 50]
# خروجی: 30.0

# راه حل:
numbers = [10, 20, 30, 40, 50]
average = sum(numbers) / len(numbers)
print(average)

# لیست: [5, 10, 15, 20, 25]
# خروجی: True

# راه حل:
numbers = [5, 10, 15, 20, 25]
element = 15
exists = element in numbers
print(exists)

# لیست اصلی: [1, 2, 3, 4, 5]
# کپی لیست و تغییر اولین عنصر به 100
# لیست اصلی باید بدون تغییر بماند

# راه حل 1:
original = [1, 2, 3, 4, 5]
copied = original.copy()
copied[0] = 100
print(f"اصلی: {original}")
print(f"کپی: {copied}")

# راه حل 2:
original = [1, 2, 3, 4, 5]
copied = original[:]
copied[0] = 100
print(f"اصلی: {original}")
print(f"کپی: {copied}")