Storan data
Katakan anda telah membangunkan permainan komputer yang dipanggil "User Hostile" di mana pemain bersaing dengan antara muka komputer yang rumit dan tidak mesra. Kini anda perlu menulis program yang menjejaki jualan bulanan permainan ini dalam tempoh lima tahun. Atau katakan anda perlu menginventori Kad Dagangan Hero Penggodam.
Tidak lama lagi anda akan membuat kesimpulan bahawa anda memerlukan lebih daripada jenis data asas yang mudah untuk menyimpan dan memproses maklumat.
Senarai (tatasusunan)
Untuk memudahkan kerja dengan sejumlah besar data, sekumpulan sel diberi nama biasa. Kumpulan sel sedemikian dipanggil array.
Array – ia adalah sekumpulan sel memori daripada jenis yang sama, terletak bersebelahan dan mempunyai nama yang sama. Setiap sel dalam kumpulan mempunyai nombor unik.
Apabila bekerja dengan tatasusunan, anda perlu mempelajari cara menyelesaikan tiga tugas:
x memperuntukkan memori saiz yang diperlukan untuk tatasusunan;
x tulis data ke sel yang dikehendaki;
x membaca data daripada sel.
Array dalam Python
Tiada tatasusunan sedemikian dalam Python. Sebaliknya, senarai digunakan untuk menyimpan sekumpulan objek daripada jenis yang sama (tetapi bukan sahaja daripada jenis yang sama) - objek daripada jenis list. Perbezaan antara senarai dan tatasusunan ialah senarai ialah struktur dinamik, saiznya boleh diubah semasa pelaksanaan program (memadam, menambah elemen) tanpa memikirkan operasi pengurusan memori (ini dilakukan oleh pengkompil).
Pada masa hadapan, apabila menganalisis kerja dengan senarai, kami akan menggunakan perkataan "array", kerana paling kerap senarai digunakan dengan tepat dalam peranan tatasusunan (mereka menyimpan data daripada jenis yang sama).
Membuat tatasusunan
Apabila tatasusunan dicipta, ruang diperuntukkan dalam memori (sebilangan sel tertentu).
1) Tatasusunan boleh dibuat dengan hanya menghitung elemen:
A = [1, 4, 7, 12, 5]
cetak(jenis(A))
Program akan mengeluarkan
<kelas 'senarai'>
Iaitu, tatasusunan ialah objek jenis senarai (diterjemahkan daripada senarai bahasa Inggeris).
2) Tatasusunan boleh terdiri daripada data apa-apa jenis - integer atau nombor nyata, rentetan aksara
A = ["Vasya", "Petya", "Fedya"]
Beberapa cara untuk bekerja dengan tatasusunan
3) Tatasusunan boleh "ditambah".
A = [1, 5] + [25, 7]
4) Tambahan tatasusunan yang sama boleh digantikan dengan pendaraban. Jadi mudah untuk mencipta tatasusunan yang diisi dengan nilai yang sama, seperti:
A = [0]*10 # mencipta tatasusunan 10 elemen dan mengisinya dengan sifar
5) Suatu tatasusunan sentiasa "tahu" saiz anda. Fungsi len() digunakan untuk menentukan saiz tatasusunan. Selalunya saiz tatasusunan disimpan dalam pembolehubah yang berasingan supaya atur cara boleh ditukar dengan mudah untuk berfungsi dengan saiz tatasusunan yang berbeza.
Contoh
N = 10 # simpan saiz tatasusunan dalam pembolehubah N
A = [0] * N # buat tatasusunan saiz N
print(len(A)) # cetak saiz tatasusunan
Saiz tatasusunan boleh ditetapkan dari papan kekunci.
|
Bekerja dengan elemen tatasusunan
Kebanyakan kegunaan tatasusunan datang daripada fakta bahawa elemennya boleh diakses secara individu.
Cara untuk melakukannya ialah dengan menggunakan indeks untuk menomborkan elemen.
Indeksialah nilai yang menunjuk kepada elemen tatasusunan tertentu.
Untuk merujuk kepada elemen tatasusunan, anda mesti menyatakan nama tatasusunan diikuti dengan indeksnya dalam kurungan segi empat sama. Sebagai contoh, anda boleh menulis nilai 100 pada elemen tatasusunan pada indeks 1 seperti ini: A[1] = 100.
Anda perlu ingat!
SUSUNAN NUMERASI DALAM PYTHON BERMULA DARI SIFAR!
(Ini adalah prasyarat - anda mesti bermula dari awal. Ini amat penting untuk diingati.)
Contoh
x = (A[3] + 5) * A[1] # baca nilai A[3] dan A[1]
A[0] = x + 6 # tulis nilai baharu kepada A[0]
Mari analisa program untuk bekerja dengan elemen tatasusunan.
i = 1
A = [0] * 5 # cipta tatasusunan 5 elemen
A[0] = 23 # ke dalam setiap 5 elemen tatasusunan (indeks 0 hingga 4)
A[1] = 12 # tulis nilai tertentu
A[2] = 7
A[3] = 43
A[4] = 51
A[2] = A[i] + 2*A[i-1] + A[2*i] # tukar nilai unsur dengan indeks 2 kepada hasil ungkapan
# sejak i=1, kemudian menggantikan nilai pembolehubah i ke dalam ungkapan yang kita dapat
# ungkapan berikut A[2] = A[1] + 2*A[0] + A[2];
cetak(A[2] + A[4])
Akibat daripada larian atur cara ini nilai jumlah elemen tatasusunan dengan indeks 2 dan dengan indeks 4 bersamaan dengan 116 akan muncul pada skrin.Seperti yang anda lihat daripada contoh, kami boleh mengakses mana-mana elemen tatasusunan . Dan juga mengira nombor elemen yang diperlukan menggunakan pelbagai formula (contohnya, seperti dalam program A[i-1] atau A[2*i]). Dalam kes ini, indeks unsur akan dikira dan bergantung pada nilai i.
Dalam Python, anda boleh menggunakan nilai indeks negatif untuk tatasusunan, dan mengira dari penghujung tatasusunan. Sebagai contoh:
A[-1] - elemen terakhir tatasusunan
A[-2] - unsur kedua terakhir
dll.
Mari analisa program.
N=5
A = [0] * N
x=1
cetak(A[x - 3]) # mengakses elemen A[-2]
print(A[x - 3 + len(A)]) # elemen akses A[3]
# ini adalah elemen yang sama seperti A[-2]
A[x + 4] = A[x] + A[2 * (x + 1)] # selepas menggantikan x ke dalam ungkapan dan pengiraan
# dapatkan baris seterusnya A[5] = A[1] + A[4]
# A[5] tiada unsur sedemikian wujud
# ralat - tatasusunan di luar sempadan
Memandangkan tatasusunan diisytiharkan dengan 5 elemen, elemen akan diberi nombor daripada -5 kepada 4. Kami melihat bahawa atur cara dalam baris ke-6 merujuk kepada elemen yang tidak wujud: A[5].
Ternyata program itu telah melampaui batas tatasusunan.
Dalam kes sedemikian, program biasanya ranap dengan ralat masa jalan.
|
Lelaran pada elemen tatasusunan
Apabila bekerja dengan tatasusunan, anda biasanya perlu bekerja dengan semua elemen tatasusunan sekaligus.
Lelaran melalui elemen: gelung melalui semua elemen tatasusunan dan, jika perlu, lakukan beberapa operasi pada setiap daripadanya.
Untuk ini, gelung dengan pembolehubah paling kerap digunakan, yang berubah daripada 0 kepada N-1, dengan N ialah bilangan tatasusunan elemen.
Di bawah N kami akan mempertimbangkan saiz semasa tatasusunan, iaitu N = len(A).
...
untuk i dalam julat(N):
# di sini kami bekerjasama dengan A[i]
...
Dalam gelung yang ditentukan, pembolehubah i akan mengambil nilai 0, 1, 2, ..., N-1. Oleh itu, pada setiap langkah gelung, kami mengakses elemen khusus tatasusunan dengan nombor i.
Oleh itu, sudah cukup untuk menerangkan perkara yang perlu dilakukan dengan satu elemen tatasusunan A[i] dan meletakkan tindakan ini di dalam gelung sedemikian.
Mari tulis atur cara yang mengisi tatasusunan dengan N nombor asli, iaitu, pada penghujung atur cara, elemen tatasusunan harus menjadi sama
A[0] = 1
A[1] = 2
A[2] = 3
...
A[N - 1] = N
Ia adalah mudah untuk melihat corak: nilai elemen tatasusunan mestilah lebih besar sebanyak 1 daripada indeks elemen.
Gelung akan kelihatan seperti ini
untuk i dalam julat(N):
A[i] = i + 1
|
Senaraikan penjana
Bahasa Python membolehkan anda menyelesaikan banyak masalah dengan ringkas dan boleh dipercayai. Mari kita senaraikan kemungkinan utama untuk mengisi tatasusunan. 1) Mencipta dan mengisi array boleh ditulis seperti ini:
A = [i untuk i dalam julat(N)] # Dengan N = 5, tatasusunan A = [0,1,2,3,4]
A = [i*i untuk i dalam julat(N)] # Dengan N = 5, tatasusunan A = [0,1,4,9,16]
untuk i dalam julat(N) - gelung melalui semua nilai i dari 0 hingga N-1.
Elemen tatasusunan seterusnya akan mengandungi nilai yang datang sebelum perkataan for, dalam kes pertama i, dalam kes kedua - i*i.
Kami mendapat hasil yang sama menggunakan notasi berikut:
A = senarai(julat(N)) # dengan N = 5, tatasusunan A = [0,1,2,3,4]
2) Anda boleh menulis kepada tatasusunan bukan semua nilai, tetapi hanya nilai yang memenuhi syarat tertentu.
Contoh
Mengisi tatasusunan dengan semua nombor genap dalam julat 0 hingga 9.
A = [i untuk i dalam julat(10)
jika saya % 2 == 0]
print(*A) # tatasusunan A = [0,2,4,6,8]
Dalam kes ini, anda perlu memahami bahawa panjang tatasusunan akan kurang daripada 10.
3) Mengisi tatasusunan daripada papan kekunci dengan elemen yang terletak satu setiap baris boleh dilakukan dalam dua cara.
|
N=5
A = [0]*5
untuk i dalam julat(N):
A[i] = int(input())
|
A = [int(input()) untuk i dalam julat(N)]
# setiap kali gelung berulang,
# rentetan input ditukar
# kepada integer (menggunakan int)
# dan nombor ini ditambahkan pada tatasusunan
|
4) Mengisi tatasusunan dari papan kekunci dengan elemen yang semuanya terletak pada baris yang sama adalah sedikit lebih rumit. Anda perlu membaca rentetan, membahagikannya kepada elemen, dan kemudian menukar setiap elemen kepada integer
s = input().split()
A = [int(i) untuk i dalam s]
atau lebih
A = senarai(peta(int, input().split())) # senarai fungsi terbina dalam()
# mengubah urutan
# kepada senarai boleh ubah
Output tatasusunan
Anda juga boleh memaparkan tatasusunan pada skrin dengan cara yang berbeza.
| Cara standard, digunakan dalam banyak bahasa pengaturcaraan. |
Kitaran sedemikian boleh ditulis dengan lebih pendek. Nilai х pada setiap langkah gelung diisi dengan elemen tatasusunan seterusnya. |
Dalam Python, anda boleh menulis seperti ini. |
|
untuk i dalam julat(len(A)):
print(A[i], end=" ")
|
untuk x dalam A:
print(x, end=" ")
|
cetak(*A)
# tanda * di hadapan nama
# daripada tatasusunan bermakna itu
# perlu ditukar
# tatasusunan ke dalam set nilai individu
|
|