koddla

Yazılımcıları bilgi ile güçlendirir.

Python’da Liste

Python Listeleri, Python programlarında yaygın olarak kullanılan genel bir veri yapısıdır. Diğer dillerde genellikle dinamik diziler olarak adlandırılar. Her ikisi de kesilebilir ve indexlenebilirdirler. Ayrıca dilimlenebilir ve içerikleri değiştirilebilirler. Listeler, diğer liste nesneleri de dahil olmak üzere farklı nesne türlerini içerebilirler.

list belirli bir yineleme türüdür, ancak Python’da bulunan tek tür değildir. Bazen set, demet veya sözlük türlerini kullanmak daha iyi olabilir. list Python’da dinamik dizilere (C++’ta vector<void*> veya Java’da ArrayList<Object>‘e benzer) verilen addır.

List öğelerine erişim çok hızlıdır. Yeni öğelerin listenin sonuna eklenmesi bazen tüm listenin kopyalamasını gerektirir.

Sözdizimi 

  • [değer, değer, …]
  • list([yinelenebilir])

Liste öğelerine erişme

Python listeleri sıfır indexi ile başlar ve diğer dillerdeki diziler gibi davranır.

lst = [1, 2, 3, 4]
lst[0]  # 1
lst[1]  # 2

Listenin sınırları dışında bir dizine erişmeye çalışmak bir IndexError hatası verir

lst[4]  # IndexError: list index out of range

Negatif indeksler listenin sonundan itibaren sayım olarak yorumlanır.

lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

Bu işlevsel olarak aşağıdakine eşdeğerdir

lst[len(lst)-1]  # 4

Listeler dilim notasyonunu kullanmaya izin verir; liste[başlangıc:son:adım]. Dilim notasyonunun çıktısı, başlangıç indexinden son‘a öğeleri içeren yeni bir listedir. başlangıç, son ve adım değerleri verilmezse, varsayılan olarak başlangıç listenin başına, son listenin sonuna ve adım 1’e eşit olur.

lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1] 
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] başlangıç listenin uzunluğundan büyük olduğu için boş liste döndürür
lst[1:10]    # [2, 3, 4] son indexinin verilmemesi ile eşdeğerdir

Bunu göz önünde bulundurarak, dilimleme ile listenin ters çevrilen bir sürümünü yazdırabilirsiniz

lst[::-1]    # [4, 3, 2, 1]

Negatif adım uzunlukları kullanırken başlangıç dizininin bitiş dizininden büyük olması gerekir, aksi takdirde sonuç boş bir liste olur.

lst[3:1:-1] # [4, 3]

Yukarıdaki negatif adım örneği aşağıdaki koda eşdeğerdir:

reversed(lst)[0:2] # 0 = 1 -1
                   # 2 = 3 -1

Burada kullanılan indeksler, negatif indekslemede kullanılan indexlerden 1 daha azdır.

Gelişmiş dilimleme

Listeler dilimlendiğinde, __getitem__() yöntemi slice ile birlikte çağrılır. Python, dilim nesneleri oluşturmak için yerleşik bir dilim yöntemine sahiptir. Böylece dilimleri saklayabilir ve daha sonra yeniden kullanabiliriz. 

data = 'chandan purohit    22 2000'  
name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)


print(data[name_slice]) #chandan purohit     
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

İç içe geçmiş listedeki değerlere erişme

Üç boyutlu bir listeyle başlayalım:

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

Listedeki öğelere aşağıdaki gibi erişebiliriz:

print(alist[0][0][1])
# 2
# İlk listedeki ilk listenin ikinci öğesine ulaşır

print(alist[1][1][2])
# 10
# İkinci listedeki ikinci listenin üçüncü öğesine ulaşır

Ekleme işlemlerinin gerçekleştirilmesi:

alist[0][0].append(11)
print(alist[0][0][2])
# 11
# 11 öğesini ilk listedeki ilk listenin son öğesi olarak ekler

İç içe geçmiş listelerde listeyi yazdırma:

for sira in alist: #İç içe geçmiş listeleri döndürme yöntemlerinden biri
    for sutun in sira:
        print(sutun)
# [1, 2, 11]
# [3, 4]
# [5, 6, 7]
# [8, 9, 10]
# [12, 13, 14]

Bu işlemin verimlilik düşünüldüğünde bir liste üreteci veya bir generator üretmek için de kullanılabileceğini de unutmayın, örneğin:

[sutun for sira in alist for sutun in sira]
# [[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

Dış listelerdeki tüm öğelerin kendilerinin de liste olması gerekmez:

alist[1].insert(2, 15)
# 15 öğesini ikinci listedeki üçüncü konuma yerleştirir

İç içe geçmiş döngüleri kullanmanın başka bir yolu da aşağıdaki gibidir. Diğer yollar daha iyi olsa da zaman zaman aşağıdakini de kullanmak gerekebilir:

for sira in range(len(alist)): #Liste döndürmenin daha az Pythonic yolu
    for sutun in range(len(alist[sira])):
       print(alist[sira][sutun])

# [1, 2, 11]
# [3, 4]
# [5, 6, 7]
# [8, 9, 10]
# 15
# [12, 13, 14]

İç içe geçmiş listede dilimlemeyi kullanma:

print(alist[1][1:])
# [[8, 9, 10], 15, [12, 13, 14]]

Dilimlemeden sonraki son liste:

print(alist)
# [[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

Listenin uzunluğu

Listenin tek boyutlu uzunluğunu almak için len() kullanabiliriz:

len(['one', 'two'])  # çıktı: 2

len(['one', [2, 3], 'four'])  # çıktı 3 olacaktır, 4 değil

len() ayrıca dizeler, sözlükler ve listelere benzer diğer veri yapıları üzerinde de çalışır.

len()‘in liste nesnesinin bir yöntemi değil de, yerleşik bir işlev olduğunu unutmayın.

Ayrıca, len()‘i çağırmanın maliyetinin O(1) olduğunu, yani uzunluğuna bakılmaksızın herhangi bir listenin uzunluğunu almanın aynı miktarda zaman alacağını unutmayın. 

Bir Listeyi Sabit Sayıda Öğe ile Başlatma

Değişmez öğeler için (örneğin, None veya dize değişmez değerleri gibi): 

my_list = [None] * 10
my_list = ['test'] * 10

Değiştirilebilir öğeler için aynı yapı kullanıldığında, listenin tüm öğeleri aynı nesneye, örneğin bir kümeye işaret eder:

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

Yukarıda 2 öğesini listenin sadece birinci öğesine eklemek istesek de, tüm öğeler aynı nesneye işaret ettikleri için 2 öğesi tüm öğelerde göründü.

Bunun yerine, listeyi sabit sayıda farklı değiştirilebilir nesneyle başlatmak için aşağıdakini kullanabiliriz:

my_list=[{1} for _ in range(10)]

Liste öğelerini tersine çevirme

reversed işlevi listeyi tersine döndürür ve yinelenebilen bir nesne döndürür.

In [3]: rev = reversed(sayi)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

“sayi” listesinin bu işlem tarafından değişmediğini ve başlangıçta olduğu gibi kaldığını unutmayın.

Ayrıca, dilimlemeyi kullanarak da listeyi tersine çevirebilirsiniz (aslında bir kopya elde ederiz ve özgün liste etkilenmez) :

In [1]: sayi = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: sayi[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Listenin boş olup olmadığını denetleme

Bir listenin boş olup olmaması boolean ile ilişkilidir. Bu nedenle listenin uzunluğunu, len(lst) == 0, kontrol etmek zorunda kalmazsınız. Sadece lst veya not lst yapmak yeterrlidir:

lst = []
if not lst:
    print("list boş")

# Çıktı: liste boş

Liste üzerinde yineleme

Python, listede doğrudan bir for döngüsü kullanmayı destekler: 

my_list = ['foo', 'bar', 'baz']
for oge in my_list:
    print(oge)
# Çıktı: foo
# Çıktı: bar
# Çıktı: baz

Her öğenin konumunu da aynı anda enumerate ile alabilirsiniz:

for (konum, oge) in enumerate(my_list):
    print('Öğe pozisyonu {}, öğe: {}'.format(konum, oge))
 
# Çıktı: Öğe pozisyonu 0, öğe: foo
# Çıktı: Öğe pozisyonu 1, öğe: bar
# Çıktı: Öğe pozisyonu 2, öğe: baz

Dizin değerine göre listeyi yinelemenin diğer bir yolu da aşağıdaki gibi olabilir:

for i in range(0,len(my_list)):
    print(my_list[i])
#Çıktı:
>>>
foo
bar
baz

Listedeki öğeleri yineleme yaparken değiştirmenin beklenmeyen sonuçlara neden olabileceğini unutmayın:

for oge in my_list:
    if oge == 'foo':
        del my_list[0]
    print(oge)

# Output: foo
# Output: baz

Bu son örnekte, yineleme yaparken ilk öğeyi sildik, ancak bu ikinci öğenin, bar, atlanmasına neden oldu.

Listelerin karşılaştırılması 

Karşılaştırma işleçleri ile listeleri ve diğer dizileri sözlüksel olarak karşılaştırmak mümkündür. Ancak, her iki işlenen öğe de aynı türde olmalıdır.

[1, 10, 100] < [2, 10, 100]
# True, çünkü 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, çünkü listeler eşit
[1, 10, 100] <= [1, 10, 100]
# True, çünkü listeler eşit
[1, 10, 100] < [1, 10, 101]
# True, çünkü 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, çünkü 0 < 1

Listelerden biri diğerini kapsıyorsa, en kısa liste kazanır.

[1, 10] < [1, 10, 100]
# True

Listeleri birleştirme ve birbirine ekleme

+ operatörü

Birleştirmenin en basit yolu:

merged = list1 + list2

zip

zip bir demete (tuple) döndürür. Döndürülen demetlerde n. sıradaki demet, birinci listenin n. öğesini ve ikinci listenin n. öğesini içerir.

alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']

for a, b in zip(alist, blist):
    print(a, b)
 
# çıktı:
# a1 b1
# a2 b2
# a3 b3

Listelerin uzunlukları farklıysa, çıktı yalnızca en kısa öğe kadar öğe içerir:

alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3', 'b4']
for a, b in zip(alist, blist):
    print(a, b)

# Çıktı:
# a1 b1
# a2 b2
# a3 b3

alist = []
len(list(zip(alist, blist)))

# Çıktı:
# 0

Kısa olan listelere None öğesi ekleyerek beslemek istiyorsak `itertools.zip_longest` kullanabiliriz. (Python 2'de `itertools.izip_longest`)

alist = ['a1', 'a2', 'a3']
blist = ['b1']
clist = ['c1', 'c2', 'c3', 'c4']

for a,b,c in itertools.zip_longest(alist, blist, clist):
    print(a, b, c)

# Çıktı: 
# a1 b1 c1
# a2 None c2
# a3 None c3
# None None c4

.insert()

Belirli bir dizin değerlerine ekleme:

alist = [123, 'xyz', 'zara', 'abc']
alist.insert(3, [2009])
print("Final List :", alist)

Çıktı:

Final List : [123, 'xyz', 'zara', 2009, 'abc']

Listedeki yinelenen değerleri kaldırma

Bir listedeki yinelenen değerleri kaldırmak, listeyi bir set‘e (nesnelerin sıralanmamış bir koleksiyonu) dönüştürerek yapılabilir. Sonuçta bir list yapısına ihtiyaç duyulursa, set tekrar list() işlevi kullanılarak bir listeye geri dönüştürülebilir: 

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Çıktı: ['duke', 'tofp', 'aixk', 'edik']

Bir listeyi sete dönüştürdüğünüzde orijinal sıralamanın kaybolduğunu unutmayın.

Listenin sırasını korumak için OrderedDict kullanılabilir:

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Çıktı: ['aixk', 'duke', 'edik', 'tofp']

Python listelerde Any ve All fonksiyonları

Listedeki tüm öğelerin True olarak değerlendirilip değerlendirilmeyeceğini belirlemek için all() metodunu kullanabiliriz: 

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

Aynı şekilde, bir veya daha fazla öğenin True olarak değerlendirilip değerlendirilmediğini any() belirler: 

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

Yukarıdaki örneklerde yinelenebilir olarak bir liste kullandık. Ancak, any() ve all() üreteçler de dahil olmak üzere herhangi bir yinelemeyle de çalışır:

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

Liste metotları ve desteklenen işleçler

Bir a listesiyle başlayalım:

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

append(değer) 

listenin sonuna yeni bir öğe ekler.

# Append 6, 7, ve 7'yi listenin sonuna ekler
a.append(6)
a.append(7)
a.append(7)
# a: [1, 2, 3, 4, 5, 6, 7, 7]

# Diğer bir listeyi listeye ekler
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]

# Farklı türden bir öğeyi listeye ekler, liste öğelerinin aynı türden olmasına gerek yoktur
my_string = "hello world"
a.append(my_string)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]

**Not: `append()` metodu listenin listenin sonuna sadece bir öğe ekler. Eğer eklediğimiz öğe de bir listeyse, bu eklenen öğe tek bir liste öğesi olarak eklenir. 

# Listeye liste öğesi ekleme
a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
a[8]
# Çıktı: [8,9]

extend(sıralanabilir_tür) 

başka bir sıralandırılabilir öğeyi alarak listeyi genişletir.

a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9, 10]

# b'deki öğeleri a'ya ekler
a.extend(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

# liste olmayan sıralanabilir bir türü alarak listeyi genişletir:
a.extend(range(3))
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]

Listeler aynı zamanda `+` operatörü ile de birbirlerine eklenebilirler. Bu orijinal listeyi değiştirmez:

a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

index(değer, [başlangıç_indexi]) 

değer parametresinin listedeki ilk karşılığının indexini alır. değer listede yoksa, bir ValueError özel durum hatası oluşturur. İkinci bir bağımsız değişken sağlanırsa, arama belirtilen dizinde başlatılır.

a.index(7)
# Çıktı: 6

a.index(49) # ValueError, 49 a listesinde yok.

a.index(7, 7)
# Çıktı: 7

a.index(7, 8) # ValueError, 8. indexten itibaren 7 değeri yok

insert(index, değer)

belirtilen değeri belirtilen indexten hemen öncesine ekler. Böylece eklemeden sonra yeni öğe index konumunda olur kaplar. 

a.insert(0, 0)  # 0 değerini 0. pozisyonna ekler
a.insert(2, 5)  # 5 değerini 2. pozisyona ekler
# a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

pop([index]) 

index’deki öğeyi kaldırır ve döndürür. Bağımsız değişken index verilmezse listenin son öğesini kaldırır ve döndürür. 

a.pop(2)
# Çıktı: 5
# a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
a.pop(8)
# Çıktı: 7
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


a.pop()
# Çıktı: 10
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

remove(değer) 

belirtilen değerin ilk karşılığını kaldırır. Sağlanan değer bulunamazsa, ValueError hatası verir

a.remove(0)
a.remove(9)
# a: [1, 2, 3, 4, 5, 6, 7, 8]
a.remove(10)
# ValueError, 10 listede yok

reverse() 

listeyi yerinde tersine çevirir ve None döndürür. 

a.reverse()
# a: [8, 7, 6, 5, 4, 3, 2, 1]

Not: Bir listeyi tersine çevirmenin başka yolları da bulunur.

count(değer) 

listedeki değerden kaç tane olduğunu sayar.

a.count(7)
# Çıktı: 2

sort() 

listeyi sayısal ve sözcükbilimsel olarak sıralar ve None döndürür.

a.sort()
# a = [1, 2, 3, 4, 5, 6, 7, 8]
# listeyi sıralar

Listeler, ‘sort()’ yönteminde paramatre olarak ‘reverse=True’ ile sıralanırsa sıralama tersine çevrilebilir.

a.sort(reverse=True)
# a = [8, 7, 6, 5, 4, 3, 2, 1]

Öğelerin özniteliklerine göre sıralamak istiyorsanız ‘key’ anahtar sözcüğünü kullanabilirsiniz:

import datetime

class Person(object):
    def __init__(self, name, birthday, height):
        self.name = name
        self.birthday = birthday
        self.height = height

    def __repr__(self):
        return self.name

l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
     Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
     Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]

l.sort(key=lambda item: item.name)
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item.birthday)
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item.height)
# l: [John Cena, Chuck Norris, Jon Skeet]

Dict listesi olduğunda da benzer şey söz konusudur. Her ne kadar dict ile liste farklı veri türleri olsa da, dict için de bir örnek verelim:

import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]

l.sort(key=lambda item: item['name'])
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item['birthday'])
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

alt dict öğelerine göre sıralama :

import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]

l.sort(key=lambda item: item['size']['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

attrgetter ve itemgetter kullanarak sıralamanın daha iyi yolu:

Listeler, operatör modülündeki işlevler kullanılarak da sıralanabilir. Bu yöntem okunabilirliği ve yeniden kullanılabilirliği artırmaya yardımcı olabilir.

from operator import itemgetter,attrgetter

people = [{'isim':'chandan','yaş':20,'maaş':2000},
          {'isim':'chetan','yaş':18,'maaş':5000},
          {'isim':'guru','yaş':30,'maaş':3000}]
yasa_gore = itemgetter('yaş')
maasa_gore = itemgetter('maaş')

people.sort(key=yasa_gore) 
people.sort(key=maasa_gore) 

itemgetter‘a ayrıca bir index’de verilebilir. Böylece bir dizinin indexlerine göre sıralama yapabiliriz.

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

Bir nesnenin özniteliklerine göre sıralamak istiyorsanız attrgetter kullanabiliriz:

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #yukarıdaki Person classını tekrar kullanıyoruz

person.sort(key=attrgetter('name')) #isme göre sırala
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #birthday'e göre sırala

clear() 

listedeki tüm öğeleri siler

a.clear()
# a = []

Çoğaltma 

varolan bir listeyi tamsayı ile çarpmak, özgün öğenin tamsayı kadar çok kopyasından oluşan daha büyük bir liste oluşturur:

b = ["şey"] * 3
# b = ["şey", "şey", "şey"]
b = [1, 3, 5] * 5
# [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]

Öğe silme 

del anahtar sözcüğü ve dilim notasyonunu kullanarak listedeki birden çok öğeyi silmek mümkündür: 

a = list(range(10))
del a[::2]
# a = [1, 3, 5, 7, 9]
del a[-1]
# a = [1, 3, 5, 7]
del a[:]
# a = []

Kopyalama 

    b = a

Yukarıdaki gibi bir işlemde, varsayılan atama işareti, “=”, özgün listenin referansını yeni isme atar. Bu şekilde: eski ad ve yeni ad aynı liste nesnesine işaret eder. Bunlardan herhangi biri aracılığıyla yapılan değişiklikler diğerine de yansıtılır. Bu çoğu zaman istediğiniz şey olmayabilir.

    b = a
    a.append(6)
    # b: [1, 2, 3, 4, 5, 6]

Listenin bir kopyasını oluşturmak istiyorsak:

Dilimleyebilirsiniz:

new_list = old_list[:]

Yerleşik list() işlevini kullanabilirsiniz:

new_list = list(old_list)

copy.copy():

import copy
    new_list = copy.copy(old_list) 

Bu list()’e göre biraz daha yavaştır, çünkü önce old_list veri türünü bulması gerekir. Liste nesneler içeriyorsa ve bunları da kopyalamak istiyorsanız, copy.deepcopy() kullanmalısınız:

import copy
new_list = copy.deepcopy(old_list) 

Açıkçası en yavaş ve en çok hafızaya ihtiyaç duyan yöntem budur, ama bazen kaçınılmaz olabilir.

copy() – Listenin sığ bir kopyasını verir

aa = a.copy()
# aa = [1, 2, 3, 4, 5]

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Back to top