En Yaygın 18 Python Liste Sorusu

Python Listesi Tam Olarak Nedir?

Listeler, demetler (tuples), sözlükler (dictionaries) ve kümeler (sets) ile birlikte Python’daki dört yerleşik veri yapısından biridir. Farklı türlerde olabilen ancak genellikle aynı türden olan öğelerin sıralı bir koleksiyonunu saklamak için kullanılırlar. Bir listedeki öğeler virgülle ayrılır ve köşeli parantez içine alınır. Şu örnekte olduğu gibi:

# These list elements are all of the same type
zoo = ['bear', 'lion', 'panda', 'zebra']
print(zoo)

# But these list elements are not
biggerZoo = ['bear', 'lion', 'panda', 'zebra', ['chimpanzees', 'gorillas', 'orangutans', 'gibbons']]
print(biggerZoo)

İkinci değişken biggerZoo’nun zoo değişkenine benzer bir liste olduğunu görüyorsunuz. Ancak biggerZoo içinde farklı maymun türlerinin olduğu başka bir listenin de yer aldığını fark ediyorsunuz.

Python’daki listeler sıralı öğe veya nesne koleksiyonları sakladığı için, bunların birer dizi türü (sequence type) olduğunu söyleyebiliriz; çünkü bir dizi gibi davranırlar. Dizi olarak kabul edilen diğer türler ise string’ler ve demetlerdir (tuples).

Peki dizi türlerini bu kadar özel yapan nedir diye düşünebilirsiniz. Basitçe söylemek gerekirse, program onların üzerinde yineleme (iterate) yapabilir! Bu yüzden listeler, string’ler, demetler ve kümeler “iterable” olarak adlandırılır.

Bu kavramın özellikle önemli olduğunu unutmayın; örneğin Scala gibi veri biliminde kullanılan diğer programlama dillerinde de karşınıza çıkabilir!

Şimdi esas işe geçiyoruz! Python programcısı olarak sizi meşgul eden veya aklınızı kurcalayan liste sorularına biraz daha derinden dalalım. Bu eğitimde yanıtlayacağımız tüm soruların listesi aşağıda:

1. Python Listeleri Ne Zaman, Demetler (Tuples), Sözlükler (Dictionaries) veya Kümeler (Sets) Ne Zaman Kullanılır?

Giriş bölümünü okumak oldukça açık görünebilir; ancak küçük bir Python betiği ya da kapsamlı bir proje üzerinde çalışırken, liste mi yoksa başka bir dizi türü mü seçeceğiniz o kadar net olmayabilir.

Oysa veriniz için doğru veri yapısını seçmek hayati önem taşır!

Daha fazlasını öğrenmek için okumaya devam edin.

# Import the `collections` library
____ ____

# Check if a dictionary is hashable
print(isinstance({}, collections.Hashable))

# Check if a float is hashable
print(isinstance(0.125, collections.Hashable))

2. Bir Listeden Bir Öğeyi Nasıl Seçersiniz?

Bu listelerle doğru düzgün çalışmak istiyorsanız, onlara nasıl erişileceğini bilmeniz gerekir.

Listelere genellikle belirli değerleri değiştirmek, güncellemek veya silmek ya da başka türden bir işlem yapmak için erişirsiniz. Listelere ve dolayısıyla tüm diğer dizi türlerine erişme yolu, indis operatörü [ ] kullanmaktır. İçine bir tamsayı değeri koyarsınız.

Bir örnek göstereyim:

# Select the first list element
oneZooAnimal = biggerZoo[0]

# Print `oneZooAnimal`
print(____)

Kodu çalıştırın ve bu kod parçasından ne döndüğünü görün. biggerZoo değişkeninin ilk öğesinin döndürüldüğünü fark edeceksiniz. Başta biraz kafa karıştırıcı olabilir, ancak indisler 1’den değil 0’dan başlar.

# Pass -1 to the index operator on `biggerZoo`
monkeys = ___
print(monkeys)

# Pass -2 to the index operator on `biggerZoo`
zebra = ___
print(zebra)

# Run this code to trigger an "Index Out Of Range" Error
biggerZoo[6]

# Use the slice notation like this
someZooAnimals = biggerZoo[2: ]

# Print to see what you exactly select from `biggerZoo`
print(someZooAnimals)

# Try putting 2 on the other side of the colon
otherZooAnimals = biggerZoo[____]

# Print to see what you're getting back
print(otherZooAnimals)

# items start through the end (but the end is not included!)
a[start:end]

# items start through the rest of the array
a[start:]    

# items from the beginning through the end (but the end is not included!)
a[:end]Altyapı:

# start through not past end, by step
a[start:end:step]Altyapı:

# Print to see how the step value influences your result
print(biggerZoo[2::2])
print(biggerZoo[1::3])

# Import `choice` from the `random` library
from ____ import ____

# Construct your `list` variable with a list of the first 4 letters of the alphabet
list = ['_','_','_','_']

# Print your random 'list' element
print(choice(list))

# Import `randrange` from the `random` library
from ____ import ____

# Construct your `randomLetters` variable with a list of the first 4 letters of the alphabet
randomLetters = ['_','_', '_', '_']

# Select a random index from 'randomLetters`
randomIndex = randrange(0,len(randomLetters))

# Print your random element from `random`
print(randomLetters[randomIndex])

3. Python Listelerini Diğer Veri Yapılarına Nasıl Dönüştürürsünüz?

Bazen ihtiyaç duyduğunuz şey tam olarak bir liste olmayabilir. Bu durumlarda, listenizi daha uygun bir veri yapısına nasıl dönüştüreceğinizi bilmek isteyebilirsiniz. Aşağıda, en yaygın dönüşüm sorularından bazılarını ve yanıtlarını bulacaksınız.

# List of Strings to a String
listOfStrings = ['One', 'Two', 'Three']
strOfStrings = ''.join(listOfStrings)
print(strOfStrings)

# List Of Integers to a String
listOfNumbers = [1, 2, 3]
strOfNumbers = ''.join(str(n) for n in listOfNumbers)
print(strOfNumbers)

# Pass your list to `tuple()`
tuple(___)

# Transform your list into a set
set(___)

helloWorld = ['hello','world','1','2']Altyapı:

list(zip(helloWorld))

# Convert to a dictionary
helloWorldDictionary = dict(zip(helloWorld[0::2], helloWorld[1::2]))

# Print out the result
print(helloWorldDictionary)

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

# Create a list iterator object
i = iter(a)

# Zip and create a dictionary
print(dict(zip(i, i)))

4. Python’da Listenizin Boyutunu Nasıl Belirlersiniz?

Listenizi len() fonksiyonuna geçirerek listenizin uzunluğunu alabilirsiniz.

Aşağıda deneyin! Kullanabileceğiniz justAList adında bir listeyi zaten oluşturduk.

# Pass `justAList` to `len()`
len(____)

Not: len() fonksiyonu yalnızca listelerinizin uzunluğunu almak için değildir; sözlükler, kümeler, string’ler vb. gibi diğer diziler veya koleksiyonlarla da kullanılabilir. Daha genel yerleşik fonksiyonları burada bulabilirsiniz.

5. Python append() ve extend() Yöntemleri Arasındaki Fark Nedir?

Bu soruyu, yazının ilk bölümünde açıkladığımız “iterable” kavramını yeniden ele alarak yanıtlamaya başlayalım:

Unutmayın: Bir değerin üzerinde programınız yineleme yapabiliyorsa, ona “iterable” deriz. Başka bir deyişle, iterable bir veya daha fazla değerden oluşan bir diziyi temsil eden bir değerdir. İlk bölümde okumuş olabileceğiniz gibi, listeler birer dizidir ve Python’un tüm dizi türlerinin örnekleri iterable’dır.

İpucu: Bir değişkenin .__iter__ yöntemi varsa, onun iterable olup olmadığını anlayabilirsiniz; şu kod parçasında olduğu gibi:

# This is your list
list = [5, 6, 7, 8, 9]

# Check whether it's iterable
list.__iter__

Yukarıdaki kodu çalıştırın ve IPython kabuğunda başka basit örnekler de deneyin!

Artık “iterable” kavramı netleştiğine göre, iki yöntem arasındaki farkı anlamaya başlayabiliriz. extend() bir yandan bir iterable alır (evet, bir liste, küme, demet ya da string alır!) ve bu iterable’daki her bir öğeyi teker teker listeye ekler.

Öte yandan append(), argümanını listenin sonuna tek bir öğe olarak ekler; bu da append() fonksiyonu argüman olarak bir iterable aldığında onu tek bir nesne gibi işleyeceği anlamına gelir.

Aşağıdaki kod parçalarını inceleyin ve bu iki yöntem arasındaki farkları anlamak için kodla kendiniz oynayın:

# Append [4,5] to `shortList`
shortList.append([4, 5])

# Use the print() method to show shortList
print(____)

# Extend `longerList` with [4,5]
longerList.extend([4, 5])

# Use the print() method to see longerList
print(____)

extend()’in, append()’i birden çok kez çağırmaya kıyasla daha verimli bir sürüm olduğunu görebilirsiniz.

6. Python’da Listeler Nasıl Birleştirilir (Concatenate)?

Listeleri birleştirmek için + operatörünü kullanırsınız. Bu, iki listenizin birleştirilmiş hâlinden yeni bir liste döndürür ve orijinal listeleri değiştirmez.

Not: Birleştirme ile ekleme (append) kafa karıştırıcı olabilir. append(), + operatöründen farklıdır; + operatörü ise extend() yöntemine çok benzer ama tam olarak aynı değildir… append() ve extend() ile orijinal listenizi değiştirirsiniz; oysa + operatörüyle başka bir liste değişkeni oluşturabilirsiniz.

Bunu kendiniz deneyin ve önceki kod parçasındaki örneklerle karşılaştırın:

# Concatenate `shortList` with `[4,5]`
plusList = shortList + [4,5]

#Use the `print()` method to see `plusList`
print(____)

7. Python’da Bir Liste Nasıl Sıralanır?

Listelerinizdeki değerleri artan veya azalan düzende sıralamanın iki basit yolu vardır:

• sort() yöntemini kullanırsınız
• Veya sorted() fonksiyonunu kullanır ve bir listeyi ona geçirirsiniz

sorted() fonksiyonu herhangi bir Iterable nesneye uygulanabilir; bu da ona string, set, dictionary gibi yapıları da geçebileceğiniz anlamına gelir!

İpucu: Bunu kendiniz deneyin! rooms ve orders adında iki listeyi zaten oluşturduk; yukarıda anlatılan iki teknikle bunları sıralayabilirsiniz :)

# Use sort() on the rooms list
____.sort()

# Print out rooms to see the result
print(____)

# Now use the sorted() function on orders
sorted(____)

# Print out orders
print(____)

Not: Sıralama yaptıktan sonra orijinal listenizin değiştiğine dikkat edin. Orijinal listeye artık ihtiyacınız yoksa bu yaklaşımı kullanmanız tavsiye edilir.

8. Python’da Bir Liste Nasıl Klonlanır veya Kopyalanır?

Bir listeyi klonlamanın veya kopyalamanın birçok yolu vardır:

• Orijinal listenizi dilimleyip yeni bir değişkende saklayabilirsiniz: newList = oldList[:]
• Yerleşik list() fonksiyonunu kullanabilirsiniz: newList = list(oldList)
• copy kütüphanesini kullanabilirsiniz:
  • copy() yöntemiyle: newList = copy.copy(oldList)
  • Listeniz nesneler içeriyorsa ve onları da kopyalamak istiyorsanız, copy.deepcopy() kullanabilirsiniz: copy.deepcopy(oldList)

Aşağıda deneyin! Arkadaşlarınızla paylaşmanız için bir groceries listesi oluşturduk.

# Copy the grocery list by slicing and store it in the `newGroceries` variable
newGroceries = groceries[__]

# Copy the grocery list with the `list()` function and store it in a `groceriesForFriends` variable
groceriesForFriends = list(____)

# Import the copy library as c
import ____ as __

# Create a `groceriesForFamily` variable and assign the copied grocery list to it
groceriesForFamily =  c.copy(____)

# Use `deepcopy()` and assign the copied list to a `groceriesForKids` variable
groceriesForKids= c.deepcopy(____)

Not: ‘Basit’ kopyalama yöntemlerini kullandığınızda, orijinal listeleriniz değiştirilecektir. Ancak deepcopy() yöntemini kullanırsanız bu engellenir. Aşağıdaki kodu çalıştırarak ne olduğunu görün:

# This is your list
objectList = ['a','b',['ab','ba']]

# Copy the `objectList`
copiedList = objectList[:]

# Change the first list element of `copiedList`
copiedList[0] = 'c'

# Go to the third element (the nested list) and change the second element
copiedList[2][1] = 'd'

# Print out the original list to see what happened to it
print(objectList)

Python listeleri konusunda zaten ileri düzeye geçmiş olanlar için, aşağıdaki bölüm karmaşık sorularınıza basit yanıtlar sunuyor.

Ancak listelerin ötesinde neler olduğunu, yerleşik liste yapısı yerine kütüphanelerin ne gibi avantajlar sunabileceğini merak edenler için sonraki bölüm mutlaka işinize yarayacaktır.

Daha fazlasını öğrenmek için okumaya devam edin!

9. Python’da Liste Anlamaları (List Comprehension) Nasıl Çalışır?

Basitçe söylemek gerekirse, liste anlamaları listelerinizi zarif bir şekilde oluşturmanın bir yoludur. Matematiği sevenler için en güzel yanı, matematiksel listelere çok benzemeleridir. Kendiniz görün:

[x**2 for x in range(10)]

Bu ne anlama geliyor? 0’dan 10’a (10 hariç) kadar olan tüm sayıları alır ve her birini 2 ile çarparsınız. Sonucun beklentilerinizi karşılayıp karşılamadığını görmek için yukarıdaki kod parçasını çalıştırın.

Çok zor değil, değil mi? Bir seviye yükseltelim!

Öncekiyle aynı listeyi yapmak istediğinizi, ancak yalnızca 2’ye bölünebilen sayıları çarpmak istediğinizi düşünelim. Liste anlamalarının yardımıyla bu bile kolaydır:

[x**2 for x in range(10) if x%2==0]

Orijinal ifadenize if ile belirtilen bir koşul eklersiniz. Bu koşul DOĞRU ise, sayı 2 ile çarpılmak üzere değerlendirilir. Bu örnekte koşulumuz, sayının 2’ye bölünebilmesidir (bölme işleminden kalan olmadan).

Daha genel bir anlamda, liste anlamalarını listelerinizi başka listelere dönüştürmek için de kullanabilirsiniz; bu kulağa biraz daha zor geliyor, değil mi?

Şu örneği düşünün:

myList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[(lambda x: x*x)(x) for x in myList]

Bu örnekte, zaten bir myList listeniz var ve onu liste anlamasıyla dönüştürüyorsunuz: for x in myList ifadesini tekrar görüyorsunuz; myList’teki her bir liste öğesi için bir işlem yapılacak.

Ardından (lambda x: x*x) ifadesinin dâhil edildiğini görürsünüz. Sizi zorlamamak için şunu bilmeniz yeterli: lambda fonksiyonları, çalışma zamanında oluşturulan anonim fonksiyonlardır. Bu kod parçasının yalnızca bir gösterge olduğunu düşünebilirsiniz; onu görmezden gelip x*x kısmına odaklanabilirsiniz.

Bu fonksiyon, tek bir öğe alır ve onu kendisiyle çarpar. Anonim bir fonksiyondur; bu yüzden lambda fonksiyonunun o öğeyi girdi olarak almasını sağlamak için liste öğenizi ona geçirmeniz gerekir. Bu yüzden (lambda x: x*x)(x) görürsünüz.

Başka bir deyişle, yukarıdaki kod parçasının ikinci satırını tamamen şöyle yazabilirsiniz:

f = lambda x: x*x
[f(x) for x in range(10)]Altyapı:

İlk satırda bir öğeyi kendisiyle çarpmak istediğinizi söyleyen lambda fonksiyonunu tanımlar, ardından ikinci satırda liste öğenizi geçirerek her bir liste öğesinin kendisiyle çarpılmasını sağlarsınız.

Not: Liste anlamalarının yanı sıra küme ve sözlük anlamaları da vardır.

Bu bile epey fazlaydı; ancak liste anlamaları hakkında keşfedilecek daha çok şey var.

Nested (iç içe) liste anlamaları hakkında daha fazla bilgi edinmek ve Python ile programlamada liste anlamalarının pratikte neler sağlayabileceğine dair daha fazla örnek görmek için aşağıdaki sık sorulan soruları okumaya devam edin!

10. Python’da Bir Liste Öğesinin Görülme Sıklığı Nasıl Sayılır?

Listelerde küme gibi öğe benzersizliği kriteri bulunmadığından, yalnızca belirli bir liste öğesinin listenizde kaç kez geçtiğini değil, her bir liste öğesinin kaç kez görüldüğünü de bilmek isteyebilirsiniz.

Aşağıda her iki sorunun da yanıtlarını bulacaksınız!

# Count the occurrences of the number 4
print([1, 2, 9, 4, 5, 4, 1].count(4))

# Count the occurrences of the letter "a"
list = ["d", "a", "t", "a", "c", "a", "m", "p"]
list.count("a")

list= ["a","b","b"]
[[x,list.count(x)] for x in set(list)]

# Import `Counter` from the `collections` library
from collections import Counter

# This is your list
list = ["a","b","b"]

# Pass `list` to `Counter()`
Counter(list)

11. Python Listesini Eşit Boyutlu Parçalara Nasıl Ayırırsınız?

Listenizi aynı boyuttaki parçalara bölmek için iter() ile birlikte zip() fonksiyonuna başvurabilirsiniz:

# Your list `x`
x = [1,2,3,4,5,6,7,8,9]

# Split `x` up in chunks of 3
y = zip(*[iter(x)]*3)

# Use `list()` to print the result of `zip()`
list(y)

Yukarıdaki kod şu şekilde çalışır:

• iter(), bir dizi üzerinde bir iteratördür.
• [iter(x)] * 3, üç listiterator nesnesinden oluşan bir liste üretir: her bir liste iteratörü x’in bir iteratörüdür.
• zip() fonksiyonuna başına konulan *, diziyi argümanlara açar; böylece zip() fonksiyonuna aynı iteratörü üç kez geçirirsiniz ve her seferinde iteratörden bir öğe çekilir.

Bekleyin. Bu son adım hâlâ net değil.

Adım adım ilerleyeyim:

1. Üç adet liste iteratörü nesneniz olur; bunları şöyle düşünebilirsiniz:

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

2. İlk seferde zip(), listeden sırayla birer öğe alır ve geriye şu kalır:

[1][2][3]

Not: İteratör nesneleri, yinelemede sıradaki öğenin hangisi olduğunu sizin için takip eder!

3. İkinci seferde, az önce oluşturduğunuz üç listeye öğeler eklenir ve şu sonuç oluşur:

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

4. Son seferde aynı prosedürü izlersiniz ve şu sonuç oluşur:

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

5. Bu üç listeyi birbirine ziplediğinizde elinizde şu kalır:

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

Yine de bu mantığı bir fonksiyona koymak isterseniz, şu yaklaşımla ilerleyebilirsiniz:

# Method to split up your lists into chunks
def chunks(list, chunkSize):
    """Yield successive chunkSize-sized chunks from list."""
    for i in range(0, len(list), chunkSize):
        yield list[i:i + chunkSize]

# Use your `chunks` function to print out chunks of the same size
import pprint
pprint.print(list(chunks(range(10, 75), 10)))

chunks() fonksiyonunuz girdi olarak bir liste ve parça boyutu alır. Ardından şu çıktıyı verir: “Yield successive (girdiğiniz parça boyutu) - sized chunks from list” (yani chunks() yöntemine verdiğiniz listeden).

Sonra range(0, len(list), chunkSize) görürsünüz: Bu liste 0’dan başlar ve listenizin uzunluğunu belirten tamsayıda biter. Adım değeri, chunks()’a geçirdiğiniz chunkSize değeriyle aynıdır.

range() ile oluşturulan bu listedeki her bir öğe için, orijinal listenin bir parçasını üretirsiniz; başlangıç, verilen öğenin indisi; bitiş, o indis + parça boyutudur.

Örneğin, 0 indisi döngüden geçtiğinde [0:2] listesi üretilir. Sonraki yinelemede (adım değerini hatırlayın!) 2 indisi döngüden geçer ve orijinal listenizin [2:4] parçası üretilir.

Not: Sonucunuzu yazdırmak için pprint() (pretty print) kullanırsınız.

Fonksiyon yazmak yerine doğrudan liste anlaması da kullanabilirsiniz:

# Set up your list and chunk size
list = range(0, 50)
chunk = 5

# Split up your list into chunks
[list[i:i + chunk] for i in range(0, len(list), chunk)]

12. Python’da Bir Liste Üzerinde Nasıl Döngü Kurulur?

Herhangi bir liste üzerinde bir for döngüsüyle kolayca dolaşabilirsiniz. For döngüleriyle fazla çalışmamış olanlar için çalışma şekli şöyledir: For döngüsü, listenizdeki her bir öğe için bir eylem gerçekleştirmenizi sağlar.

Python’da bir for döngüsü şöyle görünür:

# This is your list
mylist = [[1,2,3],[4,5,6,7],[8,9,10]]

# Loop over your list and print all elements that are of size 3
for x in mylist:
      if len(x)==3:
        print(x)

mylist adında bir listeniz var ve Python’a her bir liste öğesinin uzunluğunun 3’e eşit olup olmadığını kontrol etmesini söylüyorsunuz. Listelerimizde üçer öğe içeren iki liste olduğundan, yani [1,2,3] ve [8, 9,10], yalnızca bunlar yazdırılır.

Not: Yukarıdaki kod parçasında x ifadesi element, listElement ya da istediğiniz başka bir adla değiştirilebilir. Konsolda deneyin!

Burada sonucun öğelerin indislerini göstermediğini görürsünüz. Yinelemeyi indis kullanarak yapmak isterseniz, bunu şu şekilde yapabilirsiniz:

# This is your list
myList = [3,4,5,6]

# Loop over `myList` and print tuples of all indices and values 
for i, val in enumerate(myList):
     print(i, val)

Yalnızca liste öğelerini değil, indislerini de yazdırmak istediğiniz için, bunu for döngünüzde göstermeniz gerekir. Bu nedenle enumerate(myList) kullanırız; bu, bir indis ve bir değer döndürür. Doğal olarak, bunu for ifademizin başında da göstermeliyiz: Bir indis ve bir değer beklediğimizi belirtmek için i, val’i görürsünüz.

Not: Bir liste üzerinde yineleme yapmak için liste anlaması da kullanabilirsiniz. Burada sonuçlar, print() çağırmanıza gerek kalmadan zaten yazdırılır:

[x for x in myList if len(x)==3]

13. Listelerden Düz (Flat) Listeler Nasıl Oluşturulur?

Listeler listesinden basit bir liste yapmak için sum() fonksiyonunu kullanabilirsiniz. Yalnızca listenizi ve boş bir listeyi ona geçirmeyi unutmayın:

# Your initial list of lists
list = [[1,2],[3,4],[5,6]]

# Flatten out your original list of lists with `sum()`
sum(list, [])

Listelerinizi düzleştirmek için iki farklı yaklaşımı daha kullanabilirsiniz:

# You can reduce the lists of lists of lists like this
from functools import reduce
print(reduce(lambda x,y: x+y,listOfLists))

# Or you can use list comprehension
print([item for sublist in listOfLists for item in sublist])

• reduce() yöntemini kullanır ve ona bir lambda fonksiyonu geçirirsiniz. reduce() yöntemi, iterable’ınızın tek bir değere indirgenmesini sağlar. Nasıl indirgeneceğini, ona geçirdiğiniz fonksiyonla belirlersiniz. Bu örnekte öğelerin kümülatif olarak toplanmasını istiyorsunuz: [1,2] [3,4] ile toplanır ve bu sonuç [5,6] ile toplanır. Görsel olarak şöyle:

([1,2]+[3,4])+[5,6]Altyapı:

Unutmayın: + operatörü listeleri birleştirir (concatenate).

• Listelerin listelerinden düz listeler yapmanın ikinci seçeneği, liste anlaması kullanmaktır. Bu iç içe for döngüsü ifadesi ilk bakışta kolay değildir. Esasen önce sublist in list yani [1, 2], [3, 4], [5, 6] alır, ardından item for item in sublist ifadesiyle alt listedeki her öğeyi yazdırırsınız.

Bu iç içe liste anlamasını, normal bir for döngüsü olarak da şöyle görebilirsiniz:

list1 = []

for sublist in list:
  for item in sublist:
    list1.append(item)Altyapı:

14. İki Python Listesinin Kesişimi Nasıl Alınır?

# Intersect both lists with list comprehension
intersection = [list(filter(lambda x: x in list1, sublist)) for sublist in list2]

# Print the result of the intersection
print(____)

# An intersection of both lists, stored in `intersection`
intersection = [[x for x in sublist if x in list1] for sublist in list2]

# Print the result of the intersection
print(intersection)

# Make use of the list and set data structures
print(list(set(list1) & set(list2)))

# Use `intersection()`
print(list(set(list1).intersection(list2)))

15. Python’da Bir Listeden Yinelenenler Nasıl Kaldırılır?

Bu blog yazısının ilk bölümünde açıklandığı gibi, benzersiz ve sırasız öğeler saklamak istiyorsanız en iyi seçenek küme kullanmaktır.

Herhangi bir iterable’dan bir küme oluşturmak için onu yerleşik set() fonksiyonuna geçirmeniz yeterlidir. Daha sonra yeniden gerçek bir listeye ihtiyaç duyarsanız, aynı şekilde kümeyi list() fonksiyonuna geçirebilirsiniz.

Unutmayın: Bir iterable, bir liste, sözlük, … olabilir. Bir değişkenin iterable olup olmadığını .__iter__ yöntemini uygulayarak kontrol edin.

Aşağıdaki örnek, listenizdeki tüm yinelenenleri silmek için set() kullanımını açıkça gösterir:

# Your list with duplicate values
duplicates = [1, 2, 3, 1, 2, 5, 6, 7, 8]

# Print the unique `duplicates` list
print(list(set(duplicates)))

# A list with small numbers 
smallNumbers = [1, 2, 3]

# Print the unique `duplicates` list without the small numbers
list(set(duplicates) - set(smallNumbers))

Son sonuçtan da görebileceğiniz gibi, smallNumbers küme öğelerini çıkardıktan sonra listenizin orijinal sırası korunmaz. Bildiğiniz gibi, kümelerin kendisi sırasız koleksiyonlardır; dolayısıyla listede sahip olduğunuz herhangi bir sıra kaybolur. Kümeyi tekrar listeye dönüştürdüğünüzde, sizin için rastgele bir sıra oluşturulur.

Öğelerinizin sırası sizin için önemliyse, farklı bir mekanizma kullanmanız gerekir. Bu konu hakkında daha fazla ayrıntı için bu sayfaya bakın.

16. Neden Python Listeleri Yerine NumPy?

Genel olarak, Python programcılarının NumPy dizilerini Python listelerine tercih etmelerinin dört nedeni vardır:

• NumPy dizileri listelerden daha kompakt olduğu için.
• Öğeleri okuma ve yazmada erişim NumPy ile daha hızlı olduğu için.
• NumPy ile çalışmak daha kullanışlı olabildiği için; çünkü birçok vektör ve matris işlemini hazır sunar
• NumPy ile çalışmak daha verimli olabildiği için; zira daha verimli şekilde uygulanmışlardır.

17. Boş NumPy Dizileri Nasıl Oluşturulur?

Yalnızca boş bir NumPy dizisi oluşturmak istiyorsanız, aşağıdakini çalıştırabilirsiniz:

import numpy
numpy.array([])

Ancak amacınız bir NumPy dizisini başlatmaksa, şu yaklaşımlardan birini de izleyebilirsiniz:

# Make a NumPy array of four rows and two columns and filled with 0
numpy.zeros(shape=(4,2))

# Make a NumPy array of 1 values of three columns
numpy.ones(3)

# Make an empty NumPy array
numpy.empty(shape=(0,0))

NumPy dizinizi başlatmanın diğer yollarını arıyorsanız bu dokümantasyona göz atın.

18. Python Listeleriyle Matematiksel İşlemler Nasıl Yapılır?

Çoğu zaman listeleri yalnızca bir değer koleksiyonu saklamak için değil, üzerinde bazı matematiksel işlemler yapmak için de kullanırız. Bu bölüm, listelerle matematik yapma konusunda en sık sorulan bazı soruları kapsar.

cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413]
cases = [10, 20, 30, 40, 50]Altyapı:

for c in range(len(cost)):
   cost[c] = (cost[c] * cases[c] / sum(cases))
cost = sum(cost)
print(cost)

sum(cost[c] * cases[c] / sum(cases) for c in range(len(cost)))

sum(cost[c] * cases[c] for c in range(len(cost))) / sum(cases)

# See what `zip()` does to your `cost` and `cases`
print(list(zip(____, ____)))

# Calculate the weighted average
print(sum([x * y for x, y in zip(cost, cases)]) / sum(cases))

# Import numpy as np
import ____ as __

# Make a NumPy array
a = np.array([1,2,3,4,5])

# Return the 50th percentile of our NumPy array
p = np.percentile(a, 50)

#Print the result
print(____)

list1=[1, 2, 3]
list2=[4, 5, 6]Altyapı:

from operator import add
list(map(add, list1, list2))

[sum(x) for x in zip(list1, list2)]

# Import numpy as np
import ____ as __

# Make your lists into NumPy arrays
vector1 = np.array([1, 2, 3])
vector2 = np.array([4, 5, 6])

# Element-wise addition
sum_vector = vector1 + vector2 

# Print the result
print(____)

Python ile Veri Bilimi Yolculuğunuzda Sırada Ne Var?

Python’da listeler üzerine hazırladığımız interaktif eğitimin sonuna geldiniz. Oldukça fazla bilgi ve hatırı sayılır bir emek vardı; ama başardınız!

Listeler, Python ile veri bilimi yolculuğunuzda küçük ama vazgeçilmez bir öğedir. Keşfedecek daha çok şey var! İnteraktif Veri Bilimi için Python'a Giriş kursumuz, Python ve veri biliminde nasıl kullanıldığı hakkında daha fazla bilgi edinmek isteyenler için idealdir: Python’un en temelinden başlar ve sizi NumPy ile tanıştırarak kademeli ve nazik bir şekilde orta seviyeye taşır. (Python) programlamada az deneyimi olanlar için mükemmel!

Ancak hâlihazırda daha ileri düzey bir Python kullanıcısıysanız, veri bilimi ve Python becerilerinizi bir üst seviyeye taşımaya hazır olanlar için tasarlanmış Veri Bilimi için Orta Düzey Python kursumuza göz atmayı düşünebilirsiniz. Bu kurs, veri bilimi öğreniminizde sizi kesinlikle daha da ileri taşıyacak! Kurs; matplotlib ve pandas gibi daha fazla kütüphaneyi, mantık, kontrol akışı ve filtreleme gibi kavramları tanıtır ve becerilerinizi pekiştirmek için bir veri bilimi vaka çalışması içerir.

Zaten veri bilimi için Python kullanıyorsunuz ama daha da ileri gitmek mi istiyorsunuz? Python’da Veri İçe Aktarma kursumuzla ilgilenebilir veya Veri biliminde önişlemenin ve makine öğrenimi hattının önemi başlıklı eğitim serimizi okuyabilirsiniz!