Ukuran List Python: 8 Metode Berbeda untuk Menemukan Panjang List di Python

List Python merupakan struktur data fundamental yang penting untuk menyimpan dan memanipulasi kumpulan item. Fleksibilitas dan kemudahannya menjadikannya tak tergantikan untuk berbagai tugas pemrograman, mulai dari analisis data hingga pengembangan web. Mengingat penggunaannya yang luas, salah satu kebutuhan umum yang muncul adalah menentukan ukuran sebuah list. Meskipun fungsi len() sudah banyak dikenal, sintaks Python yang kaya dan dukungan pustakanya menawarkan berbagai cara lain untuk mencapai hal ini, masing-masing dengan nuansa dan penerapannya sendiri. Artikel ini membahas delapan metode tersebut, memberikan wawasan tentang cara kerjanya dan efisiensinya.

Mengapa List Python Penting?

List di Python adalah array dinamis yang dapat menampung campuran tipe data, menawarkan alat serbaguna untuk penyimpanan dan manipulasi data. List memudahkan operasi seperti iterasi, slicing, dan manipulasi komprehensif dengan metode bawaan seperti append(), remove(), dan sort(), antara lain. Anda dapat membaca lebih lanjut tentang manipulasi list dalam tutorial ini.

Cara Mendefinisikan List di Python

Untuk keperluan tutorial ini, kita akan menggunakan list sederhana untuk mendemonstrasikan setiap metode. Pertimbangkan list my_list yang didefinisikan sebagai berikut:

# Define a sample list to be used throughout the tutorial
my_list = ["I", "Love", "Learning", "Python"]Didukung oleh

List ini, meskipun sederhana, merupakan kandidat yang tepat untuk mengilustrasikan berbagai teknik dalam menentukan panjangnya.

8 Cara Menemukan Ukuran List Python

1. Menemukan Ukuran List Menggunakan Fungsi len()

Fungsi len() adalah pendekatan paling langsung untuk mengetahui ukuran sebuah list. Selain ringkas, metode ini juga sangat efisien, sehingga menjadi andalan dalam sebagian besar kasus.

# Use len() to find the size of the list
length = len(my_list)
print(length)  # Output: 4Didukung oleh

2. Menemukan Ukuran List Menggunakan For Loop

Sering disebut sebagai metode naif, pendekatan ini melibatkan inisialisasi penghitung dan menambahkannya untuk setiap elemen yang ditemui dalam for loop melalui list. Anda dapat mempelajari lebih lanjut tentang for loop dan jenis loop lain dalam tutorial ini.

# Naive method using a for loop to count the list's size
counter = 0
for item in my_list:
    counter += 1
print(counter)  # Output: 4Didukung oleh

3. Menemukan Ukuran List Menggunakan List Comprehension

List comprehension di Python menawarkan sintaks ringkas untuk melakukan operasi pada list. Di sini, kita menggunakannya bersama fungsi sum() untuk menghitung elemen.

# Using list comprehension to count the list's size
length = sum([1 for item in my_list])
print(length)  # Output: 4Didukung oleh

4. Menemukan Ukuran List Menggunakan reduce()

Fungsi reduce() sedikit lebih lanjut namun sangat kuat. Fungsi ini menerapkan sebuah fungsi dengan dua argumen secara kumulatif pada item-item dalam list, dari kiri ke kanan, sehingga mereduksi list menjadi satu nilai. Untuk tujuan kita, kita akan menggunakannya untuk menghitung jumlah item dalam list.

Agar lebih mudah dipahami, kita akan membaginya menjadi dua bagian:

1. Definisikan Fungsi Sederhana: Pertama, kita akan mendefinisikan fungsi sederhana yang menerima dua argumen: jumlah saat ini (yang akan kita sebut count_so_far) dan satu item dari list (yang akan kita beri nama _ untuk menunjukkan bahwa item ini tidak akan benar-benar kita gunakan).
2. Gunakan reduce(): Lalu, kita akan menggunakan reduce() untuk menerapkan fungsi ini ke setiap item dalam list, secara efektif menghitung item saat berjalan.

# Import the reduce function from the functools module
from functools import reduce

# Define a simple function to use with reduce
def update_count(count_so_far, _):
    """Increases the count by 1. The second parameter is not used."""
    return count_so_far + 1

# Use reduce to count the items in the list
# We start counting from 0, which is why we have '0' at the end
list_length = reduce(update_count, my_list, 0)

# Print out the result
print(list_length)  # Output will be 4Didukung oleh

5. Menemukan Ukuran List Menggunakan iter() dan next()

Memahami cara menghitung elemen dalam list menggunakan iter() dan next() melibatkan pemahaman tentang iterator. Iterator adalah objek di Python yang memungkinkan kita menelusuri semua elemen dalam list satu per satu. Fungsi iter() mengubah list menjadi iterator, dan fungsi next() berpindah ke elemen berikutnya dalam iterator.

Berikut pemaparannya langkah demi langkah:

1. Buat Iterator: Kita mulai dengan mengubah list menjadi iterator menggunakan fungsi iter(). Ini memungkinkan kita menelusuri list satu per satu item.
2. Hitung Menggunakan Loop: Kita menyiapkan loop yang akan terus berjalan hingga tidak ada lagi item dalam list. Di dalam loop, kita menggunakan fungsi next() untuk berpindah ke item berikutnya dalam list. Setiap kali berhasil berpindah ke item berikutnya, kita menambah hitungan sebesar 1.
3. Tangani Akhir List: Pada akhirnya, kita akan mencapai akhir list. Saat itu terjadi, next() akan memunculkan error StopIteration yang menandakan tidak ada lagi item. Kita menangkap error ini dengan blok try dan except dan berhenti menghitung.

Berikut kode yang disederhanakan dengan komentar untuk membantu memahami setiap langkah:

# Step 1: Turn the list into an iterator
list_iterator = iter(my_list)

# Initialize a counter to keep track of the number of items
count = 0

# Step 2: Loop through the list using the iterator
while True:
    try:
        # Use next() to get the next item from the iterator
        next(list_iterator)
        
        # If next() was successful, increase the count
        count += 1
    except StopIteration:
        # Step 3: If we reach the end of the list, break out of the loop
        break

# Print out the total count of items in the list
print(count)  # Output will be 4Didukung oleh

6. Menemukan Ukuran List Menggunakan enumerate()

Fungsi enumerate() di Python menambahkan penghitung ke sebuah iterable dan mengembalikannya dalam bentuk objek enumerate. Fungsi ini umum digunakan dalam loop untuk mendapatkan baik indeks maupun nilai setiap item dalam list. Meskipun enumerate() tidak lazim digunakan untuk mencari ukuran list, kita dapat memanfaatkannya untuk menggambarkan betapa fleksibelnya Python.

# Step 1: Enumerate the list and convert it to a list of tuples (index, element)
enumerated_list = list(enumerate(my_list))

# Step 2: Extract the last tuple (which contains the last index and the last element)
last_tuple = enumerated_list[-1]

# Step 3: The size of the list is the last index plus 1 (because of zero-based indexing)
list_size = last_tuple[0] + 1

# Print out the size of the list
print(list_size)  # Output will be 4Didukung oleh

7. Menemukan Ukuran List Menggunakan NumPy

NumPy adalah pustaka kuat di Python yang banyak digunakan dalam komputasi ilmiah. NumPy menyediakan dukungan untuk array dan matriks besar multi-dimensi, beserta sekumpulan fungsi matematika untuk mengoperasikannya. Bagi mereka yang bekerja dengan data numerik, NumPy adalah alat yang tak tergantikan, menawarkan penyimpanan dan operasi yang efisien pada dataset besar. Untuk menemukan ukuran list di Python menggunakan NumPy, kita dapat menggunakan atribut .size seperti ditunjukkan di bawah ini.

# Import the NumPy library
import numpy as np

# Step 1: Convert the list into a NumPy array
my_array = np.array(my_list)

# Step 2: Use the 'size' attribute of the NumPy array to find its size
array_size = my_array.size

# Print out the size of the array (which is the same as the length of the list)
print(array_size)  # Output will be 4Didukung oleh

8. Menemukan Ukuran List Menggunakan map() dan sum()

Mirip dengan list comprehension, metode ini menggunakan map() untuk menerapkan fungsi yang mengembalikan 1 untuk setiap elemen, lalu dengan sum() mengagregasikan nilai-nilai ini untuk menghitung elemen. Metode ini memerlukan pemahaman tentang fungsi lambda di Python. Untuk mengejar ketertinggalan, pastikan untuk melihat tutorial lambda Python ini.

# Using map() and sum() to count the list's size
length = sum(map(lambda x: 1, my_list))
print(length)  # Output: 4Didukung oleh

Membandingkan Performa Berbagai Metode Ukuran List Python

Mengetahui kedelapan metode untuk menemukan ukuran list adalah satu hal, tetapi menggunakan metode terbaik adalah hal lain. Untuk membandingkan performa kedelapan metode yang dibahas, kita akan menggunakan modul timeit Python, yang menyediakan cara sederhana untuk mengukur waktu potongan kode Python yang kecil. Ini akan memberi kita gambaran jelas tentang bagaimana setiap metode dibandingkan dalam hal kecepatan eksekusi. Perhatikan bahwa waktu eksekusi dapat berbeda tergantung pada mesin Anda atau tempat Anda menjalankan kode.

Menyiapkan eksperimen

Untuk memudahkan, kita mendefinisikan list dan fungsi untuk setiap metode. Tidak masalah jika Anda belum familiar dengan fungsi; yang kita lakukan di sini hanyalah menyistematisasi berbagai metode agar lebih mudah dibandingkan.

import timeit
from functools import reduce
import numpy as np

# Define the list
my_list = ["I", "Love", "Learning", "Python"] * 100  # Increased size for better statistical signifcance

# Method 1: Using len()
def method_len():
    return len(my_list)

# Method 2: Looping through the list
def method_loop():
    counter = 0
    for _ in my_list:
        counter += 1
    return counter

# Method 3: Using a list comprehension
def method_list_comprehension():
    return sum([1 for _ in my_list])

# Method 4: Using reduce()
def method_reduce():
    return reduce(lambda acc, _: acc + 1, my_list, 0)

# Method 5: Using iter() and next()
def method_iter_next():
    iterator = iter(my_list)
    counter = 0
    while True:
        try:
            next(iterator)
            counter += 1
        except StopIteration:
            break
    return counter

# Method 6: Using enumerate()
def method_enumerate():
    return max(enumerate(my_list, 1))[0]

# Method 7: Using numpy
def method_numpy():
    np_array = np.array(my_list)
    return np_array.size

# Method 8: Using map() and sum()
def method_map_sum():
    return sum(map(lambda _: 1, my_list))Didukung oleh

Mengukur Waktu Setiap Metode

Selanjutnya, kita akan menggunakan timeit.timeit() untuk mengukur waktu setiap fungsi sesuai urutan yang ditentukan:

# List to hold method names and their execution times
timing_results = []

methods = [method_len, method_loop, method_list_comprehension, method_reduce, 
           method_iter_next, method_enumerate, method_numpy, method_map_sum]

# Time each method
for method in methods:
 # Execute the operation 100000 times for better statistical significance  
    time_taken = timeit.timeit(method, number=100000)
    timing_results.append((method.__name__, time_taken))

# Sort results by time taken for better readability
timing_results.sort(key=lambda x: x[1])

# Print the timing results
for method_name, time_taken in timing_results:
    print(f"{method_name}: {time_taken:.5f} seconds")Didukung oleh

Dengan menjalankannya di DataLab, kami menerima hasil berikut:

Kesimpulan

Sebagai penutup, penjelajahan berbagai metode untuk menemukan ukuran list di Python ini tidak hanya menunjukkan fleksibilitas dan kekuatan Python sebagai bahasa pemrograman, tetapi juga menyoroti pentingnya memahami efisiensi dan keterterapan berbagai pendekatan.

Bagi pemula, sangat penting untuk memulai dengan metode yang paling sederhana dan efisien, seperti menggunakan fungsi bawaan len() yang dioptimalkan untuk performa dan keterbacaan. Untuk materi lebih lanjut tentang bekerja dengan list, lihat sumber daya berikut:

• Python Fundamentals skill track
• Introduction to Python course
• Lembar Contekan Python untuk Pemula