kode python

Cara membuat daftar bersarang dengan python

Ada unsur kebingungan mengenai istilah "daftar daftar" dengan Python. Saya menulis tutorial terlengkap ini pada daftar daftar di dunia untuk menghapus semua kebingungan yang dilakukan oleh pemula dalam bahasa pemrograman Python

Tutorial multi-modal ini terdiri dari

Kode sumber untuk menyalin tempel di proyek Anda sendiri
Kode interaktif yang dapat Anda jalankan di browser Anda
Teks penjelasan untuk setiap cuplikan kode
Video tangkapan layar yang saya rekam untuk membantu Anda memahami konsep lebih cepat
Grafik dan konsep bergambar untuk membantu Anda mendapatkan ide dengan cepat
Referensi untuk bacaan lebih lanjut dan tutorial terkait

Jadi, jika Anda bingung dengan daftar daftar, baca terus — dan selesaikan kebingungan Anda untuk selamanya

Apa itu Daftar Daftar?

Definisi. Daftar daftar di Python adalah objek daftar di mana setiap elemen daftar adalah daftar dengan sendirinya. Buat daftar daftar dengan Python menggunakan notasi kurung siku untuk membuat daftar bersarang [[1, 2, 3], [4, 5], [6, 7, 8]]1

Apakah Anda ingin mengembangkan keterampilan seorang profesional Python yang berpengetahuan luas—sambil mendapatkan bayaran dalam prosesnya?

Analisis Memori

Penting bagi Anda untuk memahami bahwa daftar hanyalah serangkaian referensi ke lokasi memori

Dengan bermain dengan code visualizer, Anda akan mendapatkan pemahaman yang lebih dalam tentang bagaimana Python bekerja pada intinya

Cukup klik tombol "Berikutnya" untuk melihat bagaimana setiap baris kode terungkap

Buat Daftar Daftar dengan Python

Buat daftar daftar dengan menggunakan notasi tanda kurung siku

Misalnya, untuk membuat daftar daftar nilai bilangan bulat, gunakan [[1, 2, 3], [4, 5], [6, 7, 8]]2. Setiap elemen daftar dari daftar luar adalah daftar bersarang itu sendiri

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

Ada banyak cara yang lebih canggih dan terprogram untuk membuat dan menginisialisasi daftar daftar dengan Python—jangan ragu untuk membaca panduan mendetail kami di blog Finxter

🌍 Tutorial Terkait. Buat dan Inisialisasi Daftar Daftar dengan Python

Konversi Daftar Daftar menjadi Satu Daftar

Katakanlah, Anda ingin mengonversi daftar daftar [[1, 2, 3], [4, 5], [6, 7, 8]]2 menjadi satu daftar [[1, 2, 3], [4, 5], [6, 7, 8]]4. Bagaimana cara mencapai ini?

Pemahaman daftar [[1, 2, 3], [4, 5], [6, 7, 8]]5 dengan asumsi Anda memiliki daftar daftar [[1, 2, 3], [4, 5], [6, 7, 8]]6
Membongkar [[1, 2, 3], [4, 5], [6, 7, 8]]_7 dengan asumsi Anda memiliki daftar dua daftar [[1, 2, 3], [4, 5], [6, 7, 8]]6
Menggunakan metode daftar Python [[1, 2, 3], [4, 5], [6, 7, 8]]_9 untuk memperluas semua daftar dalam daftar daftar

Temukan contoh dari ketiga metode tersebut dalam cuplikan kode berikut

Karena kesederhanaan dan efisiensinya, metode pemahaman daftar pertama lebih unggul dari dua metode lainnya

Konversi Daftar Daftar ke Kamus

Untuk beberapa aplikasi, cukup berguna untuk mengonversi daftar daftar menjadi kamus

Database. Daftar daftar adalah tabel di mana daftar dalam adalah baris basis data dan Anda ingin menetapkan setiap baris ke kunci utama dalam kamus baru
Spreadsheet. Daftar daftar adalah data spreadsheet dua dimensi dan Anda ingin menetapkan setiap baris ke kunci (=nama baris)
Analisis Data. Anda memiliki matriks dua dimensi (=array NumPy) yang awalnya direpresentasikan sebagai daftar daftar dan Anda ingin mendapatkan kamus untuk memudahkan akses data

Ada tiga cara utama untuk mengonversi daftar daftar menjadi kamus dengan Python (sumber)

Pemahaman Kamus
Ekspresi Generator
Untuk Loop

Mari selami masing-masing

1. Pemahaman Kamus

Masalah. Katakanlah, Anda memiliki daftar daftar di mana setiap daftar mewakili seseorang dan terdiri dari tiga nilai untuk nama, usia, dan warna rambut orang tersebut.

Untuk kenyamanan, Anda ingin membuat kamus tempat Anda menggunakan nama seseorang sebagai kunci kamus dan subdaftar yang terdiri dari usia dan warna rambut sebagai nilai kamus

Larutan. Anda dapat mencapai ini dengan menggunakan fitur pemahaman kamus yang indah (tetapi, yang mengejutkan, sedikit diketahui) dengan Python

persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}

Penjelasan. Pernyataan pemahaman kamus terdiri dari ekspresi # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''0 yang menetapkan nama seseorang # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''1 ke daftar # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''2 usia dan warna rambut orang tersebut

Selanjutnya, ini terdiri dari konteks # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''_3 yang mengulang semua "baris data"

2. Ekspresi Generator

Cara serupa untuk mencapai hal yang sama adalah dengan menggunakan ekspresi generator yang dikombinasikan dengan konstruktor # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''4 untuk membuat kamus

persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = dict((x[0], x[1:]) for x in persons) print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}

Cuplikan kode ini hampir identik dengan yang digunakan di bagian "pemahaman daftar". Satu-satunya perbedaan adalah Anda menggunakan tupel daripada pemetaan langsung untuk mengisi kamus

3. Untuk Loop

Tentu saja, tidak perlu mewah di sini

Anda juga dapat menggunakan loop for reguler dan menentukan elemen kamus satu per satu dalam loop for sederhana

Ini kode alternatifnya

persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {} for x in persons: persons_dict[x[0]] = x[1:] print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}

Sekali lagi, Anda memetakan nama setiap orang ke dalam daftar yang terdiri dari usia dan warna rambutnya

Konversi Daftar Daftar ke NumPy Array

Bagaimana cara mengonversi Daftar Daftar ke NumPy Array?

Tonton video ini di YouTube

Masalah. Diberikan daftar daftar dengan Python. Bagaimana cara mengubahnya menjadi array NumPy 2D?

Contoh. Konversikan daftar daftar berikut

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

ke dalam array NumPy

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

Larutan. Gunakan fungsi # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''5 untuk mengonversi daftar daftar menjadi larik NumPy dua dimensi

Ini kodenya

# Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5, 6]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [[1 2 3] [4 5 6]] '''

Cara Mengonversi Daftar Daftar ke Array NumPy Dengan Jumlah Elemen Berbeda

Masalah. Diberikan daftar daftar. The inner lists have a varying number of elements. How to convert them to a NumPy array?

Example. Say, you’ve got the following list of lists

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

What are the different approaches to convert this list of lists into a NumPy array?

Solution. There are three different strategies you can use. (source)

(1) Use the standard # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''6 function

# Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''

This creates a NumPy array with three elements—each element is a list type. You can check the type of the output by using the built-in # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''7 function

(2) Make an array of arrays

This is more logical than the previous version because it creates a NumPy array of 1D NumPy arrays (rather than 1D Python lists)

(3) Make the lists equal in length

You use list comprehension to “pad” # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''8 values to each inner list with smaller than maximal length

Read More. See the original article on this blog for a more detailed version of this content

Konversi Daftar Daftar ke Dataframe

How to Convert List of Lists to a Pandas Dataframe

Tonton video ini di YouTube

Problem. You’re given a list of lists. Your goal is to convert it into a Pandas Dataframe

Example. Say, you want to compare salary data of different companies and job descriptions

You’ve obtained the following salary data set as a nested list of list

How can you convert this into a Pandas Dataframe?

Solution. The straight-forward solution is to use the # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''9 constructor that creates a new Dataframe object from different input types such as NumPy arrays or lists

Here’s how to do it for the given example

This results in the following Dataframe

An alternative is the lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]00 method that generates the same output

If you want to add column names to make the output prettier, you can also pass those as a separate argument

If the first list of the list of lists contains the column name, use slicing to separate the first list from the other lists

Slicing is a powerful Python feature and before you can master Pandas, you need to master slicing

Convert List of Lists to List of Tuples

If you’re in a hurry, here’s the short answer

Use the list comprehension statement lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]02 to convert each element in your lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]03 to a tuple. This works also for list of lists with varying number of elements

How to Convert List of Lists to List of Tuples in Python? (And Back)

Tonton video ini di YouTube

But there’s more to it and studying the two main method to achieve the same objective will make you a better coder. So keep reading

Method 1. List Comprehension + tuple()

Problem. How to convert a list of lists into a list of tuples?

Example. You’ve got a list of lists lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]04 and you want to convert it into a list of tuples lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]05

Solution. There are different solutions to convert a list of lists to a list of tuples. Use list comprehension in its most basic form

This approach is simple and effective

List comprehension defines how to convert each value (lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06 in the example) to a new list element. As each list element is a new tuple, you use the constructor lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]07 to create a new tuple from the list lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06

If you have three list elements per sublist, you can use the same approach with the conversion

You can see the execution flow in the following interactive visualization (just click the “Next” button to see what’s happening in the code)

And if you have a varying number of list elements per sublist, this approach still works beautifully

You see that an approach with list comprehension is the best way to convert a list of lists to a list of tuples. But are there any alternatives?

Method 2. Fungsi Peta + tuple()

An alternative is to use the map function that applies a specified function on each element of an iterable

💡 Guido van Rossum, the creator of Python, didn’t like the lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]09 function as it’s less readable (and less efficient) than the list comprehension version. Feel free to read a detailed discussion on how exactly he argued in my blog article

So, without further ado, here’s how you can convert a list of lists into a list of tuples using the lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]09 function

The first argument of the lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]09 function is the lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]12 function name

This lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]13 function converts each element on the given iterable [[1, 2, 3], [4, 5], [6, 7, 8]]6 (the second argument) into a tuple

The result of the lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]09 function is an iterable so you need to convert it to a list before printing it to the shell because the default string representation of an iterable is not human-readable

How to Convert a List of Lists to a List of Tuples
How to Convert a List of Tuples to a List of Lists
Cara Mengonversi Daftar Daftar ke Bingkai Data Pandas
Cara Mengonversi Daftar Daftar ke NumPy Array
Cara Mengonversi Daftar Daftar ke Kamus dengan Python

Konversi Daftar Daftar ke File CSV

Cara Mengonversi Daftar Daftar ke File CSV dengan Python

Tonton video ini di YouTube

Masalah. Bagaimana cara mengonversi daftar daftar ke file ________10______16?

Contoh. Diberikan adalah daftar daftar — misalnya data gaji karyawan di perusahaan tertentu

Tujuan Anda adalah menulis konten daftar daftar ke dalam format file nilai yang dipisahkan koma (CSV)

Outfile Anda akan terlihat seperti ini

Larutan. Ada empat cara sederhana untuk mengonversi daftar daftar menjadi file CSV dengan Python

CSV. Impor modul lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_16 dengan Python, buat objek penulis csv, dan tulis daftar daftar ke file menggunakan metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]18 pada objek penulis
Panda. Impor pustaka panda, buat Pandas DataFrame, dan tulis DataFrame ke file menggunakan metode DataFrame lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]19
NumPy. Impor pustaka NumPy, buat larik NumPy, dan tulis hasilnya ke file CSV menggunakan metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]20
Piton. Gunakan implementasi Python murni yang tidak memerlukan pustaka apa pun dengan menggunakan fungsi I/O file Python

Preferensi saya adalah metode 2 (Panda) karena paling mudah digunakan dan paling kuat untuk berbagai jenis input (numerik atau tekstual)

Metode 1. Modul Python CSV

Anda dapat mengonversi daftar daftar menjadi file CSV dengan Python dengan mudah—dengan menggunakan pustaka lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]16

Ini adalah yang paling dapat disesuaikan dari keempat metode

Keluaran

Dalam kode, Anda pertama kali membuka file menggunakan perintah lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]22 standar Python. Sekarang, Anda dapat menulis konten ke objek file lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]23

Selanjutnya, Anda meneruskan objek file ini ke konstruktor penulis CSV yang mengimplementasikan beberapa metode pembantu tambahan—dan secara efektif membungkus objek file yang memberi Anda fungsionalitas khusus CSV baru seperti metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]18

Anda sekarang meneruskan daftar daftar ke metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_18 dari penulis CSV yang menangani konversi daftar daftar ke format CSV

Anda dapat menyesuaikan penulis CSV di konstruktornya (mis. g. , dengan memodifikasi pembatas dari koma lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]26 menjadi spasi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]27 karakter)

Lihat spesifikasi untuk mempelajari tentang modifikasi lanjutan

Metode 2. Pandas DataFrame to_csv()

Anda dapat mengonversi daftar daftar menjadi Pandas DataFrame yang memberi Anda kemampuan canggih seperti metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]28

Ini adalah metode termudah dan memungkinkan Anda untuk menghindari mengimpor perpustakaan lain (saya menggunakan Pandas di banyak proyek Python)

Keluaran

Anda membuat Pandas DataFrame—yang merupakan representasi default Python untuk data tabular. Anggap saja sebagai spreadsheet Excel dalam kode Anda (dengan baris dan kolom)

DataFrame adalah struktur data yang sangat kuat yang memungkinkan Anda melakukan berbagai metode. Salah satunya adalah metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_28 yang memungkinkan Anda menulis isinya ke dalam file CSV

Anda menyetel argumen lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]30 dan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]31 dari metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]28 ke lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]33 karena Pandas, secara default, menambahkan indeks baris dan kolom bilangan bulat 0, 1, 2, …

Sekali lagi, anggap mereka sebagai indeks baris dan kolom di spreadsheet Excel Anda. Anda tidak ingin mereka muncul di file CSV sehingga Anda menyetel argumen ke lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]33

Jika Anda ingin menyesuaikan keluaran CSV, Anda memiliki banyak argumen khusus untuk dimainkan. Lihat artikel ini untuk daftar lengkap semua argumen

Artikel terkait. Cheat Sheets Pandas untuk Disematkan ke Dinding Anda

Metode 3. NumPy savetxt()

NumPy adalah inti dari ilmu data dan fungsi pembelajaran mesin Python. Bahkan Panda menggunakan array NumPy untuk mengimplementasikan fungsionalitas kritis

Anda dapat mengonversi daftar daftar menjadi file CSV dengan menggunakan fungsi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]35 NumPy dan meneruskan larik NumPy sebagai argumen yang muncul dari konversi daftar daftar

Metode ini paling baik jika Anda hanya memiliki data numerik—jika tidak, akan menyebabkan konversi tipe data yang rumit yang tidak disarankan

Keluaran

Outputnya tidak terlihat cantik. itu menyimpan nilai sebagai pelampung

Tapi jangan khawatir, Anda dapat memformat ulang keluaran menggunakan argumen format lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]36 dari metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]37 ()

Namun, saya sarankan Anda tetap menggunakan metode 2 (Panda) untuk menghindari kerumitan yang tidak perlu dalam kode Anda

Terkait

[Dapatkan Buku Anda] Coffee Break NumPy dan jadilah master ilmu data

Metode 4. Python Murni Tanpa Ketergantungan Eksternal

Jika Anda tidak ingin mengimpor pustaka apa pun dan masih mengonversi daftar daftar menjadi file CSV, Anda juga dapat menggunakan implementasi standar Python. tidak rumit dan efisien

Namun, jika memungkinkan Anda harus mengandalkan perpustakaan yang melakukan pekerjaan untuk Anda

Metode ini paling baik jika Anda tidak mau atau tidak bisa menggunakan dependensi eksternal

Keluaran

Dalam kode, Anda pertama kali membuka objek file lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]23. Kemudian Anda mengulangi setiap baris dan setiap elemen dalam baris dan menulis elemen tersebut ke file—satu per satu

Setelah setiap elemen, Anda menempatkan koma untuk menghasilkan format file CSV. Setelah setiap baris, Anda menempatkan karakter baris baru lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]39

💡 Catatan. Untuk menghilangkan tanda koma, Anda dapat memeriksa apakah elemen lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06 adalah elemen terakhir pada baris di dalam badan loop dan lewati penulisan koma jika itu adalah

Tutorial Terkait. Bergabunglah dengan komunitas Finxter dan unduh 8+ lembar contekan Python untuk menyegarkan kembali pemahaman kode Anda

Urutkan Daftar Daftar berdasarkan Kunci

Setiap ilmuwan komputer suka menyortir sesuatu. Di bagian ini, saya akan menunjukkan kepada Anda bagaimana Anda dapat mengubah perilaku pengurutan Python default dengan argumen kunci

Definisi dan Penggunaan. Untuk menyesuaikan perilaku penyortiran default metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]41 dan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]42, gunakan argumen opsional lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]43 dengan meneruskan fungsi yang mengembalikan nilai sebanding untuk setiap elemen dalam daftar

Python List sort() – Panduan Utama

Tonton video ini di YouTube

Sintaksis. Anda dapat memanggil metode ini pada setiap objek daftar dengan Python (Python versi 2. x dan 3. x)

Inilah sintaksnya

ArgumentDescriptionlst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_43(Opsional. Standar ________12______8. ) Lewati fungsi yang mengambil satu argumen dan mengembalikan nilai yang sebanding. Fungsi tersebut kemudian diterapkan ke setiap elemen dalam daftar. Kemudian, metode mengurutkan berdasarkan hasil fungsi kunci daripada elemen itu sendiri. lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_47(Opsional. Standar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_33. ) Urutan elemen daftar. Jika lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_33, pengurutan dalam urutan menaik. Jika lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_50, itu dalam urutan menurun

Artikel terkait

Metode Daftar Python [Ikhtisar]
Daftar Python lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_51 – Panduan Utama
Daftar Python – Semua yang Perlu Anda Ketahui untuk Memulai

Metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_41 mengambil fungsi lain sebagai argumen lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]43 opsional yang memungkinkan Anda mengubah perilaku pengurutan default

Fungsi kunci kemudian dipanggil pada setiap elemen daftar dan mengembalikan nilai lain berdasarkan penyortiran yang dilakukan. Oleh karena itu, fungsi kunci mengambil satu argumen masukan (elemen daftar) dan mengembalikan satu nilai keluaran (nilai yang dapat dibandingkan)

Ini sebuah contoh

Anda dapat melihat bahwa dalam dua contoh pertama, daftar diurutkan berdasarkan nilai daftar dalam pertama

Dalam contoh ketiga, daftar diurutkan menurut nilai daftar dalam kedua

Anda mencapainya dengan mendefinisikan fungsi kunci lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]54 yang mengambil satu elemen daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06 (daftar dengan sendirinya) sebagai argumen dan mengubahnya menjadi nilai yang sebanding lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]56 (nilai daftar kedua)

Pengantar Fungsi Lambda dengan Python

Sortir Daftar Daftar berdasarkan Elemen Pertama

Baik metode daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_51 dan fungsi Python bawaan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]58 mengurutkan daftar daftar berdasarkan elemen pertamanya

Ini sebuah contoh

Rutinitas penyortiran default mengambil elemen daftar pertama dari setiap daftar dalam sebagai kriteria keputusan. Hanya jika elemen pertama akan sama untuk dua nilai, elemen daftar kedua akan diambil sebagai tiebreaker

Urutkan Daftar Daftar Secara Leksikografis

Masalah. Diberikan daftar daftar. Urutkan daftar string dalam urutan leksikografis

💡 Urutan leksikografis adalah mengurutkan berdasarkan elemen daftar dalam pertama. Jika sama, Anda mengurutkan berdasarkan elemen daftar dalam kedua, dan seterusnya

Contoh

Kami ingin mengurutkan daftar berikut di mana elemen pertama dari daftar dalam adalah sama

Larutan. Gunakan metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_41 tanpa argumen untuk menyelesaikan daftar dalam urutan leksikografis

Urutkan Daftar Daftar Berdasarkan Panjangnya

Masalah. Diberikan daftar daftar. Bagaimana Anda bisa mengurutkannya berdasarkan panjangnya?

Contoh. Anda ingin mengurutkan daftar daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_60 berdasarkan panjangnya—dimulai dengan daftar terpendek

Jadi, hasil target Anda adalah lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_61. Bagaimana cara mencapai itu?

Larutan. Gunakan fungsi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_62 sebagai argumen kunci dari metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]41 seperti ini. lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_64

Karena fungsi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_65 adalah fungsi bawaan Python, Anda tidak perlu mengimpor atau mendefinisikan apa pun

Ini solusi kodenya

Outputnya adalah daftar yang diurutkan berdasarkan panjang string

Anda juga dapat menggunakan teknik ini untuk mengurutkan daftar string berdasarkan panjangnya

Daftar Pemahaman Python Daftar Daftar

Tonton video ini di YouTube

Anda akan mempelajari tiga cara bagaimana menerapkan pemahaman daftar ke daftar daftar

untuk meratakan daftar daftar
untuk membuat daftar daftar
untuk mengulangi daftar daftar

Selain itu, Anda akan mempelajari cara menerapkan pemahaman daftar bersarang. Jadi mari kita mulai

Pemahaman Daftar Python Meratakan Daftar Daftar

Masalah. Diberikan daftar daftar. Bagaimana cara meratakan daftar daftar dengan menyingkirkan daftar bagian dalam—dan mempertahankan elemennya?

Contoh. Anda ingin mengubah daftar tertentu menjadi daftar datar seperti di sini

Larutan. Gunakan pernyataan pemahaman daftar bersarang [[1, 2, 3], [4, 5], [6, 7, 8]]5 untuk meratakan daftar

Penjelasan. Dalam pernyataan pemahaman daftar bersarang [[1, 2, 3], [4, 5], [6, 7, 8]]5, Anda pertama-tama mengulangi semua daftar dalam daftar daftar (lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]68)

Kemudian, Anda mengulangi semua elemen dalam daftar saat ini (lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]69). Elemen ini, Anda cukup tempatkan di daftar terluar, tidak berubah, dengan menggunakannya di bagian "ekspresi" dari pernyataan pemahaman daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]70

Pemahaman Daftar Python Buat Daftar Daftar

Masalah. Bagaimana cara membuat daftar daftar dengan memodifikasi setiap elemen dari daftar daftar asli?

Contoh. Anda diberi daftar

Anda ingin menambahkan satu ke setiap elemen dan membuat daftar daftar baru

Larutan. Gunakan dua pernyataan pemahaman daftar bersarang, satu untuk membuat daftar daftar luar, dan satu lagi untuk membuat daftar dalam

Penjelasan. Ide utamanya adalah untuk menggunakan sebagai "ekspresi" dari pernyataan pemahaman daftar luar pernyataan pemahaman daftar dengan sendirinya

Ingat, Anda dapat membuat objek apa pun yang Anda inginkan di bagian ekspresi dari pernyataan pemahaman daftar Anda. Baca selengkapnya di sini

Cetak Daftar Daftar Tanpa Tanda Kurung

Masalah. Diberikan daftar daftar, cetak satu baris per baris—tanpa tanda kurung

Contoh. Perhatikan daftar contoh berikut

Anda ingin mencetak daftar daftar dengan karakter baris baru setelah setiap daftar dalam

Larutan. Gunakan for loop dan pernyataan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_71 sederhana di mana Anda membongkar semua elemen daftar dalam menggunakan operator asterisk

Ini sebuah contoh

Output memiliki bentuk yang diinginkan

Penjelasan. Operator asterisk "membongkar" semua nilai dalam daftar dalam lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06 ke dalam pernyataan cetak

Anda harus tahu bahwa pernyataan print juga mengambil banyak input dan mencetaknya, dipisahkan dengan spasi, ke shell

Artikel terkait

Operator Pembongkar *
Cara Mencetak Daftar dengan Indah
Daftar Daftar Python
Cetak Daftar Daftar

Cetak Daftar Daftar Dengan Baris Baru & Sejajarkan Kolom

Masalah. Bagaimana cara mencetak daftar daftar dengan baris baru setelah setiap daftar sehingga kolomnya rata?

Contoh. Katakanlah, Anda akan mencetak daftar daftar

Bagaimana cara menyelaraskan kolom?

Larutan. Gunakan cuplikan kode berikut untuk mencetak daftar daftar dan menyelaraskan semua kolom (tidak peduli berapa banyak karakter yang ditempati setiap string dalam daftar daftar)

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

Outputnya adalah yang diinginkan

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

Penjelasan

Pertama, Anda menentukan panjang lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_73 (dalam karakter) dari string terbesar dalam daftar daftar menggunakan pernyataan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]74. Kode menggunakan loop for bersarang dalam ekspresi generator untuk mencapai ini
Kedua, Anda mengulangi setiap daftar dalam daftar daftar (disebut lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]75)
Ketiga, Anda membuat representasi string dengan kolom yang disejajarkan dengan 'mengisi' setiap elemen baris sehingga menempati lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]76 karakter ruang. Karakter yang hilang diisi dengan ruang kosong

Anda dapat melihat kode beraksi di visualizer memori berikut. Cukup klik "Berikutnya" untuk melihat objek mana yang dibuat di memori jika Anda menjalankan kode dengan Python

Artikel terkait. Anda mungkin perlu menyegarkan kembali pemahaman Anda tentang fitur Python berikut yang digunakan dalam kode

Daftar pemahaman dan ekspresi generator
Penggabungan string()
Daftar pencetakan

Daftar Daftar Python Menghitung

Katakanlah, Anda telah memberikan kode berikut yang menggunakan fungsi enumerate pada daftar daftar

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

Keluarannya adalah

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

Fungsi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_77 membuat iterator pasangan (indeks, elemen) untuk semua elemen dalam daftar yang diberikan

Jika Anda memiliki daftar daftar, elemen daftar adalah daftar itu sendiri

Jadi, fungsi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_78 menghasilkan pasangan (indeks, daftar). Anda bisa menggunakannya di badan loop—misalnya, untuk mencetak panjang elemen daftar ke-i

Hapus Kosong – Daftar Daftar Python

Bagaimana Anda bisa menghapus semua daftar kosong dari daftar daftar?

Katakanlah, Anda memiliki daftar daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]79 dan Anda ingin semua daftar kosong dihapus untuk mendapatkan daftar daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]80

Larutan. Gunakan pemahaman daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_81 untuk memfilter daftar dan menghapus semua daftar yang kosong

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

Kondisi jika lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06 bernilai lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]33 hanya jika daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06 kosong. Dalam semua kasus lainnya, ini dievaluasi menjadi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]50 dan elemen tersebut disertakan dalam daftar baru

Hapus Duplikat – Daftar Daftar Python

Bagaimana Cara Menghapus Duplikat Dari Daftar Daftar Python?

Tonton video ini di YouTube

Apa cara terbaik untuk menghapus duplikat dari daftar daftar Python?

Ini adalah pertanyaan wawancara pengkodean yang populer di Google, Facebook, dan Amazon. Berikut ini, saya akan menunjukkan kepada Anda bagaimana (dan mengapa) cara kerjanya—jadi teruslah membaca

Metode 1. Metode Naif

Algoritma

Telusuri setiap elemen dan periksa apakah elemen ini sudah ada dalam daftar
Jika demikian, hapus

Masalahnya adalah bahwa metode ini memiliki kompleksitas waktu kuadrat karena Anda perlu memeriksa setiap elemen jika ada dalam daftar (yaitu lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]86 untuk lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]73 elemen)

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

Metode 2. Konversi Kamus Sementara

Algoritma. Cara yang lebih efisien dalam hal kerumitan waktu adalah membuat kamus dari elemen dalam daftar untuk menghapus semua duplikat dan mengonversi kamus kembali ke daftar

Ini mempertahankan urutan elemen daftar asli

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

Semua dari empat sub-metode berikut adalah operasi runtime linier

Oleh karena itu, algoritme memiliki kompleksitas runtime linier dan lebih efisien daripada pendekatan naif (metode 1)

Ubah menjadi daftar tupel menggunakan pemahaman daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]88. Tuple dapat di-hash dan dapat digunakan sebagai kunci kamus—sementara daftar tidak bisa
Ubah daftar tupel menjadi kamus dengan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]89 untuk memetakan tupel ke nilai dummy. Setiap kunci kamus hanya dapat ada satu kali sehingga duplikat dihapus pada saat ini
Ubah kamus menjadi daftar tupel dengan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]90
Ubah daftar tupel menjadi daftar daftar menggunakan pemahaman daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]91

Setiap elemen daftar (= daftar) menjadi tupel yang menjadi kunci baru untuk kamus

Misalnya, daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_92 menjadi daftar lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]93 kamus lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]94. Tidak ada}

Semua elemen yang muncul berkali-kali akan ditetapkan ke kunci yang sama. Dengan demikian, kamus hanya berisi kunci unik—tidak boleh ada beberapa kunci yang sama

Sebagai nilai kamus, Anda mengambil nilai dummy (per default)

Kemudian, Anda mengonversi kamus kembali ke daftar daftar, membuang nilai dummy

Apakah Kamus Python Mempertahankan Urutan Kunci?

Anehnya, kunci kamus di Python mempertahankan urutan elemen. Jadi, ya, urutan elemen dipertahankan. (sumber)

Hal ini mengejutkan banyak pembaca karena sumber daring yang tak terhitung jumlahnya seperti ini berpendapat bahwa urutan kunci kamus tidak dipertahankan

Mereka berasumsi bahwa implementasi dasar dari kunci kamus iterables menggunakan set—dan set terkenal agnostik terhadap pemesanan elemen

Tapi anggapan ini salah. Implementasi kamus Python bawaan di cPython mempertahankan urutannya

Ini contohnya, silakan buat contoh dan tes Anda sendiri untuk memeriksa apakah urutannya dipertahankan

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

Anda melihat bahwa urutan elemen dipertahankan sehingga saat mengonversinya kembali, urutan asli elemen daftar tetap dipertahankan

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

Namun, Anda tidak dapat mengandalkannya karena implementasi Python apa pun dapat, secara teoritis, memutuskan untuk tidak mempertahankan pesanan (perhatikan "BISA" di sini adalah 100% teoretis dan tidak berlaku untuk implementasi cPython default)

Jika Anda perlu memastikan bahwa pesanan dipertahankan, Anda dapat menggunakan. Di cPython, ini hanyalah pembungkus untuk implementasi default dict

Metode 3. Tetapkan Konversi

Diberikan daftar daftar, tujuannya adalah untuk menghapus semua elemen yang ada lebih dari satu kali dalam daftar

Set di Python hanya mengizinkan satu instance elemen. Jadi dengan mengonversi daftar menjadi satu set, semua duplikat dihapus

Berbeda dengan pendekatan naif (memeriksa semua pasangan elemen jika merupakan duplikat) yang memiliki kompleksitas waktu kuadrat, metode ini memiliki kompleksitas runtime linier

Mengapa?

Karena kompleksitas runtime membuat satu set linear dalam jumlah elemen set. Sekarang, Anda mengonversi set kembali ke daftar, dan voila, duplikatnya dihapus

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

Namun, mengonversi daftar menjadi satu set tidak menjamin untuk mempertahankan urutan elemen daftar. Set kehilangan semua informasi pemesanan

Selain itu, Anda tidak dapat membuat kumpulan daftar karena daftar adalah tipe data yang tidak dapat di-hash

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

Tetapi kami dapat menemukan solusi sederhana untuk kedua masalah tersebut seperti yang akan Anda lihat dalam metode berikut

Metode Linear-Runtime dengan Set untuk Menghapus Duplikat Dari Daftar Daftar

Pendekatan ketiga ini menggunakan satu set untuk memeriksa apakah elemen sudah ada dalam daftar bebas duplikat

Karena memeriksa keanggotaan pada set jauh lebih cepat daripada memeriksa keanggotaan pada daftar, metode ini juga memiliki kompleksitas runtime linier (keanggotaan memiliki kompleksitas runtime konstan)

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

Pendekatan menghapus duplikat dari daftar sambil mempertahankan urutan elemen memiliki kompleksitas runtime linier juga

Dan itu berfungsi untuk semua bahasa pemrograman tanpa Anda harus mengetahui detail implementasi tentang kamus dengan Python. Tapi, di sisi lain, ini sedikit lebih rumit

Artikel terkait

Bagaimana Cara Menghapus Duplikat Dari Daftar Daftar dengan Python?
Hapus Daftar Python
Panduan Utama untuk Kamus Python
Hapus Duplikat Dari Daftar Python
Daftar Daftar Python

Terbalik – Daftar Daftar Python

lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_95 membalikkan urutan unsur-unsur dalam lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]03. Jika Anda ingin membuat daftar baru dengan elemen terbalik, gunakan mengiris dengan ukuran langkah negatif lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]97

Ini contoh singkatnya

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

Di baris pertama contoh, Anda membuat daftar [[1, 2, 3], [4, 5], [6, 7, 8]]6. Anda kemudian membalikkan urutan elemen dalam daftar dan mencetaknya ke shell

Terbalik Datar

Tetapi jika Anda menggunakan metode lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]_99 pada daftar daftar, Anda hanya mendapatkan pembalikan "datar"—hanya daftar luar yang dibalik tetapi bukan daftar dalam

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

Jadi urutan dari dua daftar dalam sekarang dibalik tetapi bukan urutan elemen daftar mereka

Terbalik Jauh

Bagaimana jika Anda tidak hanya ingin membalikkan daftar tetapi menjalankan kebalikan yang dalam di mana semua daftar bersarang juga dibalik secara rekursif?

Inilah cara Anda melakukannya

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

Tidak hanya daftar tingkat pertama yang dibalik tetapi juga daftar tingkat kedua. Kode ini secara longgar terinspirasi dari artikel ini

Zip Python Daftar Daftar

Fungsi persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_00 mengambil sejumlah iterables dan menggabungkannya menjadi satu dengan menggabungkan nilai ke-i dari setiap iterable menjadi sebuah tuple

Misalnya, zip bersama daftar persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_01 dan persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}02 ke persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}03

Masalah. Meneruskan daftar daftar ke dalam fungsi zip tidak berfungsi karena fungsi zip memerlukan sejumlah iterables yang berubah-ubah (dan bukan iterables dari iterables)

Contoh. Katakanlah, Anda ingin meng-zip daftar daftar

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

🛑 PERHATIAN. KODE INI TIDAK MENYELESAIKAN INI

Larutan. Buka kemasan daftar dalam daftar daftar menggunakan operator tanda bintang "membongkar" persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}04

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

Pikirkan seperti ini. operator asterisk menghapus braket "luar" dari daftar dan meneruskan semua daftar dalam sebagai argumen

Perhatikan bahwa Anda juga mengonversi objek zip yang dikembalikan oleh fungsi zip ke daftar menggunakan konstruktor persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}05

Buka Paket Daftar Daftar Python

Anda telah melihat contoh membongkar daftar daftar di bagian sebelumnya (fungsi persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}06)

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

Untuk mengatasi masalah ini, Anda mengekstrak daftar dalam ke dalam fungsi zip untuk menggunakannya sebagai argumen untuk iterables. Dengan cara ini, persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_00 berjalan dengan tiga argumen yang dapat diulang. persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_09, persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}10, dan persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}11

Artikel terkait. Operator Pembongkar (Asterisk)

Rata-rata – Daftar Daftar Python

Bagaimana Rata-Rata Daftar Daftar dengan Python?

Tonton video ini di YouTube

Masalah. Anda memiliki daftar daftar dan Anda ingin menghitung rata-rata kolom yang berbeda

Contoh. Diberikan daftar berikut daftar dengan empat baris dan tiga kolom

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

Anda ingin memiliki nilai rata-rata dari tiga kolom

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

Metode 1. Rata-rata dalam Python (Tanpa Perpustakaan)

Satu baris sederhana dengan pemahaman daftar dalam kombinasi dengan fungsi persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}00 pada daftar yang belum dibongkar untuk mengubah daftar daftar melakukan pekerjaan dengan Python

Apakah Anda suka Python one-liners? . Klik untuk memeriksa buku di tab baru

Anda dapat memvisualisasikan eksekusi kode dan objek memori dari kode ini di alat berikut (cukup klik "Berikutnya" untuk melihat bagaimana satu langkah kode dibuka)

Metode 2. Rata-rata dengan Perpustakaan NumPy

Anda membuat larik NumPy dari data dan meneruskannya ke fungsi persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}13

Argumen persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_14 dari fungsi rata-rata menentukan sepanjang sumbu mana Anda ingin menghitung nilai rata-rata

Jika Anda ingin rata-rata kolom, tentukan persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}15
Jika Anda ingin rata-rata baris, tentukan persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}16
Jika Anda ingin menghitung rata-rata semua nilai, lewati argumen ini

Metode 3. Perpustakaan Statistik Rata-Rata + Peta()

Hanya untuk menunjukkan kepada Anda alternatif lain, inilah salah satu yang menggunakan fungsi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]09 dan trik persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}18 kami untuk mengubah urutan "matriks" persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}19

Fungsi persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_20 menerapkan persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}21 ke setiap elemen di persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}22

Sebagai alternatif, Anda juga dapat menggunakan pemahaman daftar seperti yang ditunjukkan pada metode 1 dalam tutorial ini

💡 Faktanya, Guido van Rossum, pencipta Python dan diktator baik hati seumur hidup (BDFL) Python, lebih memilih pemahaman daftar daripada fungsi lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]09

Daftar Daftar Jumlah Python

Bagaimana Cara Menjumlahkan Daftar Daftar dengan Python?

Tonton video ini di YouTube

Masalah. Diberikan daftar daftar yang mewakili matriks data dengan n baris dan m kolom. Bagaimana cara menjumlahkan kolom matriks ini?

Berikut ini, Anda akan mempelajari berbagai cara untuk melakukannya dengan Python

Mari pastikan bahwa Anda berada di halaman yang sama. Berikut adalah representasi grafis dari daftar daftar dan apa yang ingin Anda capai

Contoh. Diberikan kode berikut

Selanjutnya, Anda akan mempelajari tiga metode berbeda untuk menjumlahkan kolom

Artikel terkait

Bagaimana cara Rata-Rata pada Daftar Daftar dengan Python?

Salinan Datar – Daftar Daftar Python

Sebelum Anda benar-benar memahami metode persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_24 dengan Python, Anda harus memahami konsep "salinan dangkal" atau "salinan datar"

Dalam bahasa berorientasi objek seperti Python, semuanya adalah objek. List adalah objek dan elemen dalam list juga merupakan objek

Salinan daftar yang dangkal membuat objek daftar baru—salinan—tetapi tidak membuat elemen daftar baru tetapi hanya menyalin referensi ke objek ini

Anda dapat melihat bahwa daftar di bawah ini hanyalah salinan dangkal yang menunjuk ke elemen yang sama dengan daftar aslinya

Dalam Python, metode persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}_25 hanya menghasilkan salinan dangkal yang memiliki kompleksitas runtime lebih cepat

Berikut adalah contoh yang menunjukkan skenario ini dengan tepat

Mengubah elemen daftar ketiga dari daftar yang disalin berdampak pada elemen daftar ketiga dari daftar asli

Dengan demikian, outputnya adalah

Anda dapat melihat visualisasi eksekusi langsung di alat hebat berikut untuk memvisualisasikan penggunaan memori potongan Python ini di setiap tahap eksekusi. Cukup klik "Berikutnya" untuk melihat bagaimana memori terbuka

Petunjuk. Jika Anda menyalin daftar daftar menggunakan metode persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}25, ketahuilah bahwa setiap perubahan yang Anda lakukan pada daftar di daftar daftar yang disalin akan terlihat di daftar asli

Jika Anda tidak setuju dengan itu, lihat bagian berikut tentang salinan mendalam dari daftar Python

Deep Copy – Daftar Daftar Python

Setelah memahami konsep salinan dangkal, kini mudah untuk memahami konsep salinan dalam

Baca artikel saya dalam vs salinan dangkal untuk mendapatkan pemahaman yang lebih dalam

Salinan dangkal hanya menyalin referensi elemen daftar
Salinan yang dalam menyalin elemen daftar itu sendiri yang dapat menyebabkan perilaku yang sangat rekursif karena daftar elemen mungkin merupakan daftar itu sendiri yang perlu disalin secara mendalam dan seterusnya

Ini salinan sederhana dari daftar yang sama seperti yang ditunjukkan sebelumnya

Berbeda dengan salinan dangkal, daftar persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}09 disalin secara terpisah untuk daftar salinan dalam. Jika seseorang mengubah daftar bersarang ini di daftar asli, perubahan itu tidak akan terlihat di salinan yang dalam. (Karena daftar bersarang dari daftar salinan dalam adalah objek independen di memori. )

Perhatikan bahwa dalam salinan yang dalam, objek string tidak boleh disalin. Mengapa?

Untuk mendapatkan salinan mendalam di Python, impor modul persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}28 dan gunakan metode persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}29

Sekali lagi, visualisasikan aliran eksekusi potongan kode berikut di sini di browser Anda dengan mengeklik "Berikutnya"

Bagaimana Cara Memfilter Daftar Daftar Python?

Jawaban singkat. Untuk memfilter daftar daftar untuk kondisi di daftar dalam, gunakan pernyataan pemahaman daftar persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}30 dan ganti persons = [['Alice', 25, 'blonde'], ['Bob', 33, 'black'], ['Ann', 18, 'purple']] persons_dict = {x[0]: x[1:] for x in persons} print(persons_dict) # {'Alice': [25, 'blonde'], # 'Bob': [33, 'black'], # 'Ann': [18, 'purple']}31 dengan kondisi pemfilteran Anda yang mengembalikan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]50 untuk menyertakan daftar dalam lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]06, dan lst = [[1, 2], [3, 4]] # Method 1: List Comprehension flat_1 = [x for l in lst for x in l] # Method 2: Unpacking flat_2 = [*lst[0], *lst[1]] # Method 3: Extend Method flat_3 = [] for l in lst: flat_3.extend(l) ## Check results: print(flat_1) # [1, 2, 3, 4] print(flat_2) # [1, 2, 3, 4] print(flat_3) # [1, 2, 3, 4]33 jika tidak

Bagaimana Cara Memfilter Daftar dengan Python?

Tonton video ini di YouTube

Daftar termasuk dalam struktur data paling penting di Python—setiap master pembuat kode mengetahuinya dengan hati. Anehnya, bahkan pembuat kode perantara tidak tahu cara terbaik untuk memfilter daftar—apalagi daftar daftar dengan Python. Tutorial ini menunjukkan kepada Anda bagaimana melakukan yang terakhir

Masalah. Katakanlah, Anda punya daftar daftar. Anda ingin memfilter daftar daftar sehingga hanya tersisa daftar dalam yang memenuhi kondisi tertentu. Kondisinya adalah fungsi dari daftar dalam—seperti rata-rata atau jumlah dari elemen daftar dalam

Contoh. Diberikan daftar berikut dengan pengukuran suhu mingguan per minggu — dan satu daftar dalam per minggu

Bagaimana cara menyaring minggu-minggu yang lebih dingin dengan nilai suhu rata-rata

Apa itu Daftar Daftar?

Analisis Memori

Buat Daftar Daftar dengan Python

Konversi Daftar Daftar menjadi Satu Daftar

Konversi Daftar Daftar ke Kamus

1. Pemahaman Kamus

2. Ekspresi Generator

3. Untuk Loop

Konversi Daftar Daftar ke NumPy Array

Cara Mengonversi Daftar Daftar ke Array NumPy Dengan Jumlah Elemen Berbeda

(1) Use the standard # Import the NumPy library import numpy as np # Create the list of lists lst = [[1, 2, 3], [4, 5], [6, 7, 8]] # Convert it to a NumPy array a = np.array(lst) # Print the resulting array print(a) ''' [list([1, 2, 3]) list([4, 5]) list([6, 7, 8])] '''6 function

(2) Make an array of arrays

(3) Make the lists equal in length

Konversi Daftar Daftar ke Dataframe

Convert List of Lists to List of Tuples

Method 1. List Comprehension + tuple()

Method 2. Fungsi Peta + tuple()

Konversi Daftar Daftar ke File CSV

Metode 1. Modul Python CSV

Metode 2. Pandas DataFrame to_csv()

Metode 3. NumPy savetxt()

Metode 4. Python Murni Tanpa Ketergantungan Eksternal

Urutkan Daftar Daftar berdasarkan Kunci

Sortir Daftar Daftar berdasarkan Elemen Pertama

Urutkan Daftar Daftar Secara Leksikografis

Urutkan Daftar Daftar Berdasarkan Panjangnya

Daftar Pemahaman Python Daftar Daftar

Pemahaman Daftar Python Meratakan Daftar Daftar

Pemahaman Daftar Python Buat Daftar Daftar

Cetak Daftar Daftar Tanpa Tanda Kurung

Cetak Daftar Daftar Dengan Baris Baru & Sejajarkan Kolom

Daftar Daftar Python Menghitung

Hapus Kosong – Daftar Daftar Python

Hapus Duplikat – Daftar Daftar Python

Metode 1. Metode Naif

Metode 2. Konversi Kamus Sementara

Apakah Kamus Python Mempertahankan Urutan Kunci?

Metode 3. Tetapkan Konversi

Metode Linear-Runtime dengan Set untuk Menghapus Duplikat Dari Daftar Daftar

Terbalik – Daftar Daftar Python

Terbalik Datar

Terbalik Jauh

Zip Python Daftar Daftar

Buka Paket Daftar Daftar Python

Rata-rata – Daftar Daftar Python

Metode 1. Rata-rata dalam Python (Tanpa Perpustakaan)

Metode 2. Rata-rata dengan Perpustakaan NumPy

Metode 3. Perpustakaan Statistik Rata-Rata + Peta()

Daftar Daftar Jumlah Python

Salinan Datar – Daftar Daftar Python

Deep Copy – Daftar Daftar Python

Bagaimana Cara Memfilter Daftar Daftar Python?

Pos Terkait

Toplist

Postingan terbaru

LIHAT SEMUA