Cara mengubah ukuran daftar dengan python

reshape_array. ndarray - Array baru dibentuk dari data di array lama, diulang jika perlu untuk mengisi jumlah elemen yang diperlukan. Data diulang dalam urutan yang disimpan dalam memori

Dengan bantuan Numpy numpy. resize(), kita dapat mengubah ukuran array. Array dapat berbentuk apa saja tetapi untuk mengubah ukurannya kita hanya membutuhkan ukuran i. e (2, 2), (2, 3) dan banyak lagi. Selama mengubah ukuran numpy tambahkan nol jika nilai di tempat tertentu tidak ada

Parameter
bentuk_baru. [tupel int, atau n int] Bentuk array yang diubah ukurannya
periksa ulang. [bool, opsional] Parameter ini digunakan untuk memeriksa pencacah referensi. Secara Default itu Benar

Pengembalian. Tidak ada

Sebagian besar dari Anda sekarang berpikir apa perbedaan antara membentuk kembali dan mengubah ukuran. Ketika kita berbicara tentang membentuk kembali maka array mengubah bentuknya sebagai sementara tetapi ketika kita berbicara tentang mengubah ukuran maka perubahan itu dilakukan secara permanen

Contoh 1
Dalam contoh ini kita dapat melihat bahwa dengan bantuan metode .resize(), kita telah mengubah bentuk array dari 1×6 menjadi 2×3

# importing the python module numpy

import numpy as np

# Making a random array

gfg=

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

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

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

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

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

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

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

Saat mengerjakan posting saya tentang tabel hash, saya menemukan konsep array/daftar yang diubah ukurannya secara dinamis, yang saya tidak tahu apa-apa tentangnya. Saya ingin menulis posting khusus tentang bagaimana kita dapat mengubah ukuran array atau daftar karena menurut saya detailnya berguna untuk diketahui ketika membahas struktur data yang lebih kompleks. Terima kasih banyak atas artikel Yasufumi Taniguchi yang sangat bagus untuk memandu posting ini [1]. Kami pertama-tama akan berbicara tentang di mana array dan daftar yang diubah ukurannya secara dinamis berperan dan beberapa faktor yang perlu dipertimbangkan saat mengubah ukurannya, kemudian kita akan membahas beberapa detail tentang seberapa efisien pengubahan ukuran dapat dilakukan.

Faktor Apa yang Perlu Dipertimbangkan dalam Pengubahan Ukuran Dinamis?

Beberapa bahasa pemrograman memungkinkan Anda membuat struktur data seperti daftar dan larik yang akan tumbuh secara otomatis saat Anda menambahkan item [2]. (Namun, kadang-kadang, Anda harus mendeklarasikan ukuran struktur di awal dan Anda tidak dapat melebihi kapasitas itu setelah instance dibuat [2]. ) Misalnya, jika kita membuat daftar dengan Python, kita dapat terus menambahkan atau menghapus item dari daftar tanpa mengatur ukuran daftar secara eksplisit - Python akan melakukannya untuk kita di latar belakang [1]. Mengubah ukuran berarti bahwa saat daftar berubah ukurannya - misalnya, saat kami menambahkan lebih banyak elemen - daftar disalin ke daftar baru yang lebih besar dengan lebih banyak ruang untuk entri tambahan [1]

Salah satu pendekatan tipikal untuk mengubah ukuran adalah menggandakan ukuran daftar setelah daftar penuh [2]. Penggandaan daftar dapat memakan waktu dan ruang tambahan, tetapi idenya adalah bahwa hal itu terjadi cukup jarang sehingga daftar tersebut masih merupakan struktur data yang cukup efisien (baik dalam hal waktu dan ruang) [2]

Faktanya, ada beberapa faktor yang harus diseimbangkan untuk memastikan bahwa ini benar - bahwa daftar yang diubah ukurannya secara dinamis adalah struktur yang efisien [1]. Misalnya, kita harus memutuskan seberapa banyak daftar akan diperluas - jika kita menambahkan terlalu sedikit memori, maka kita akan membuang waktu untuk melakukan operasi pengubahan ukuran terlalu sering [1]. Jika kita menambahkan terlalu banyak memori, maka ruang kita akan menjadi tidak efisien [1]. Demikian pula, ketika kita perlu mengurangi ukuran daftar, berapa banyak pengurangan ruang yang harus kita lakukan? . Pengurangan ruang yang terlalu banyak berarti kita perlu melakukan banyak pengubahan ukuran nanti saat kita menambahkan kembali elemen ke dalam daftar [1]

Kita dapat menggambarkan seberapa banyak kita menambah atau mengurangi ukuran daftar dengan setiap perubahan ukuran dinamis dengan faktor pengubahan ukuran k [1-2]. Bahasa yang berbeda menggunakan nilai yang berbeda untuk k (Python memiliki k = 1. 125, Java memiliki k = 2) tetapi secara umum, k lebih besar dari 1 sehingga pengubahan ukuran (atau realokasi) akan membuat larik yang k kali lebih besar dari larik sebelumnya [1]

Sekarang setelah kita memiliki intuisi dasar tentang cara kerja pengubahan ukuran daftar atau larik, mari kita lihat detail spesifik implementasinya

Kompleksitas Waktu Mengubah Ukuran Array dan Daftar

Katakanlah kita memiliki daftar dengan faktor pengubahan ukuran k = 2 - yaitu, setiap kali kita mengubah ukuran daftar, ukurannya menjadi dua kali lipat atau setengahnya (tergantung pada apakah kita menambahkan atau menghapus elemen). Ingatlah bahwa setiap kali kita mengubah ukuran daftar, kita harus menyalinnya ke daftar baru, dan membutuhkan waktu O(1) untuk menyalin satu elemen. Jadi mari kita lihat apa yang terjadi saat kita menambahkan item ke daftar yang dimulai dengan ukuran 2, dengan satu elemen di dalamnya [1]

Seperti yang Anda lihat pada Gambar 1, kita harus menyalin daftar beberapa kali saat kita terus menambahkan elemen ke dalamnya [1]. Setiap kali kita menyalin, dibutuhkan O(n) waktu di mana n adalah jumlah item dalam daftar. Secara total, kita dapat menulis kompleksitas waktu penambahan n item sebagai [1]

Pada dasarnya kita dapat mengabaikan istilah konstanta dan mengurangi ini untuk melihat bahwa kompleksitas waktu mengubah ukuran daftar atau larik adalah O(n) [1-2]

Tetapi runtime diamortisasi untuk mengubah ukuran daftar hanya O(1) [2]. Mengapa demikian? . Kami akan berasumsi bahwa k = 2 sehingga jika daftar adalah ukuran x, sebelum mengubah ukurannya adalah ukuran x/2 dan elemen x/2 harus disalin ke daftar baru ukuran x [2]

Peningkatan kapasitas akhir. N/2 elemen disalin

Peningkatan kapasitas sebelumnya. N/4 elemen disalin

Peningkatan kapasitas sebelumnya. N/8 elemen disalin

…

Peningkatan kapasitas kedua. 2 elemen disalin

Peningkatan kapasitas pertama. 1 elemen disalin

Sekarang mari tambahkan jumlah salinan yang harus kita buat untuk memasukkan N elemen ke dalam daftar [2]

Mengapa jumlahnya kurang dari N? . Jika Anda berjalan setengah dari jarak itu, lalu setengah dari jarak yang tersisa, dan kemudian setengah lagi, Anda akan hampir, tetapi tidak akan pernah sampai ke toko kelontong (i. e. Anda akan hampir, tetapi tidak pernah mencapai N) [2]. Jadi jumlah total penyisipan ke dalam daftar memerlukan waktu O(n), meskipun secara umum penyisipan dapat dilakukan dalam waktu yang konstan karena kita mengamortisasi biaya selama beberapa operasi pengubahan ukuran [2]. Runtime kasus terburuk adalah O(n) [2]

Saya harap penjelasan itu membantu. Ini adalah sesuatu yang perlu dipertimbangkan saat membuat struktur data yang lebih kompleks yang akan bergantung pada daftar atau larik yang mengubah ukuran secara dinamis, karena pengubahan ukuran dapat memakan waktu lama, seperti yang telah kita lihat di sini

Referensi

[1] Taniguchi, Y. “Yang Harus Anda Ketahui tentang Daftar Python. " Medium. 14 Januari 2019. https. //medium. com/@yasufumy/data-structure-dynamic-array-3370cd7088ec Dikunjungi 16 Jan 2021

Bagaimana cara membuat daftar lebih kecil dengan Python?

Bagaimana Anda menyesuaikan daftar dengan Python?

Bagaimana cara kerja pengubahan ukuran daftar Python?

Bagaimana cara mendapatkan ukuran daftar dengan Python?