Saya ingin mendefinisikan sebuah array dua dimensi tanpa diinisialisasi panjang seperti ini:
Matrix = [][]
tapi itu tidak bekerja...
I've mencoba kode di bawah ini, tapi itu juga salah:
Matrix = [5][5]
Error:
Traceback ...
IndexError: list index out of range
Apa kesalahan saya?
Anda're teknis berusaha untuk indeks uninitialized array. Pertama-tama anda harus menginisialisasi luar daftar dengan daftar sebelum menambahkan item; Python panggilan ini "daftar pemahaman".
# Creates a list containing 5 lists, each of 8 items, all set to 0
w, h = 8, 5;
Matrix = [[0 for x in range(w)] for y in range(h)]
Matrix[0][0] = 1
Matrix[6][0] = 3 # error! range...
Matrix[0][6] = 3 # valid
Perhatikan bahwa matriks adalah "y" alamat utama, dengan kata lain, "y index" datang sebelum "x indeks".
print Matrix[0][0] # prints 1
x, y = 0, 6
print Matrix[x][y] # prints 3; be careful with indexing!
Meskipun anda dapat nama mereka seperti yang anda inginkan, saya melihat cara ini untuk menghindari kebingungan yang mungkin timbul dengan pengindeksan, jika anda menggunakan "x" untuk investasi dalam dan luar daftar, dan ingin non-Matriks persegi.
Jika anda benar-benar ingin matrix, anda mungkin akan lebih baik menggunakan numpy
. Operasi matriks dalam numpy
paling sering menggunakan sebuah tipe array dengan dua dimensi. Ada banyak cara untuk membuat array baru, salah satu yang paling berguna adalah nol
fungsi, yang mengambil bentuk parameter dan mengembalikan sebuah array dari bentuk tertentu, dengan nilai-nilai diinisialisasi ke nol:
>>> import numpy
>>> numpy.zeros((5, 5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
numpy
memberikan matrix
jenis juga. It's kurang umum digunakan, dan beberapa orang menyarankan menggunakan itu. Tapi itu's berguna untuk orang-orang yang datang untuk numpy
dari Matlab, dan dalam beberapa konteks lain. Saya pikir saya'a seperti itu sejak kami're berbicara tentang matriks!
>>> numpy.matrix([[1, 2], [3, 4]])
matrix([[1, 2],
[3, 4]])
Berikut ini adalah beberapa cara lain untuk membuat 2-d array dan matriks (dengan output dihapus untuk kekompakan):
numpy.matrix('1 2; 3 4') # use Matlab-style syntax
numpy.arange(25).reshape((5, 5)) # create a 1-d range and reshape
numpy.array(range(25)).reshape((5, 5)) # pass a Python range and reshape
numpy.array([5] * 25).reshape((5, 5)) # pass a Python list and reshape
numpy.empty((5, 5)) # allocate, but don't initialize
numpy.ones((5, 5)) # initialize with ones
numpy.ndarray((5, 5)) # use the low-level constructor
Di sini adalah yang lebih singkat notasi untuk menginisialisasi daftar list:
matrix = [[0]*5 for i in range(5)]
Sayangnya shortening ini untuk sesuatu seperti5*[5*[0]]
doesn't benar-benar bekerja karena anda berakhir dengan 5 salinan dari daftar yang sama, jadi ketika anda mengubah salah satu dari mereka, mereka semua berubah, misalnya:
>>> matrix = 5*[5*[0]]
>>> matrix
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
>>> matrix[4][4] = 2
>>> matrix
[[0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2]]
Jika semua yang anda inginkan adalah dua dimensi wadah untuk menampung beberapa elemen, anda bisa nyaman menggunakan kamus sebagai gantinya:
Matrix = {}
Maka yang dapat anda lakukan:
Matrix[1,2] = 15
print Matrix[1,2]
Ini bekerja karena 1,2
adalah sebuah tuple, dan anda're menggunakannya sebagai kunci untuk indeks kamus. Hasil ini mirip dengan yang bodoh matriks jarang.
Seperti yang ditunjukkan oleh osa dan Josap Valls, anda juga dapat menggunakan Matrix = koleksi.defaultdict(lambda:0)
sehingga unsur-unsur yang hilang memiliki nilai default 0
.
Vatsal lebih lanjut bahwa metode ini mungkin sangat tidak efisien untuk matriks besar dan hanya boleh digunakan dalam non-kinerja-bagian-bagian penting dari kode.
Di Python anda akan membuat daftar dari daftar. Anda tidak memiliki untuk menyatakan dimensi dari waktu ke depan, tetapi anda bisa. Misalnya:
matrix = []
matrix.append([])
matrix.append([])
matrix[0].append(2)
matrix[1].append(3)
Sekarang matrix[0][0] == 2 dan matriks[1][0] == 3. Anda juga dapat menggunakan daftar pemahaman sintaks. Contoh ini menggunakan dua kali lebih untuk membangun "dua dimensi daftar":
from itertools import count, takewhile
matrix = [[i for i in takewhile(lambda j: j < (k+1) * 10, count(k*10))] for k in range(10)]
Anda harus membuat sebuah daftar dari daftar, dan cara terbaik adalah dengan menggunakan nested pemahaman:
>>> matrix = [[0 for i in range(5)] for j in range(5)]
>>> pprint.pprint(matrix)
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
Pada [5][5]
contoh, anda membuat sebuah daftar dengan bilangan bulat "5" di dalam, dan mencoba untuk mengakses 5 item, dan itu tentu menimbulkan IndexError karena tidak ada 5 item:
>>> l = [5]
>>> l[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
rows = int(input())
cols = int(input())
matrix = []
for i in range(rows):
row = []
for j in range(cols):
row.append(0)
matrix.append(row)
print(matrix)
Mengapa seperti kode yang panjang, yang terlalu dalam Python
anda bertanya?
Panjang kembali ketika saya tidak nyaman dengan Python, saya melihat satu baris jawaban untuk menulis matriks 2D dan berkata pada diriku sendiri aku tidak akan menggunakan 2-D matrix di Python lagi. (Mereka satu garis yang cukup menakutkan dan tidak't memberikan informasi apapun pada apa Python itu lakukan. Juga perhatikan bahwa saya tidak menyadari ini shorthands.)
Lagian, di sini's kode untuk pemula yang berasal dari C, CPP dan Jawa latar belakang
Catatan untuk Python Pecinta dan Ahli: jangan memilih turun hanya karena saya menulis rinci kode.
Untuk menyatakan matriks nol (orang-orang):
numpy.zeros((x, y))
misalnya
>>> numpy.zeros((3, 5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
atau numpy.orang-orang((x, y)) misalnya
>>> np.ones((3, 5))
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
Bahkan tiga dimensi yang mungkin. (http://www.astro.ufl.edu/~warner/prog/python.html lihat --> array Multi-dimensi)
Menulis ulang untuk membaca mudah:
# 2D array/ matrix
# 5 rows, 5 cols
rows_count = 5
cols_count = 5
# create
# creation looks reverse
# create an array of "cols_count" cols, for each of the "rows_count" rows
# all elements are initialized to 0
two_d_array = [[0 for j in range(cols_count)] for i in range(rows_count)]
# index is from 0 to 4
# for both rows & cols
# since 5 rows, 5 cols
# use
two_d_array[0][0] = 1
print two_d_array[0][0] # prints 1 # 1st row, 1st col (top-left element of matrix)
two_d_array[1][0] = 2
print two_d_array[1][0] # prints 2 # 2nd row, 1st col
two_d_array[1][4] = 3
print two_d_array[1][4] # prints 3 # 2nd row, last col
two_d_array[4][4] = 4
print two_d_array[4][4] # prints 4 # last row, last col (right, bottom element of matrix)
I'm pertama saya script Python, dan aku sedikit bingung dengan matriks persegi contoh jadi saya berharap contoh di bawah ini akan membantu anda menghemat waktu:
# Creates a 2 x 5 matrix
Matrix = [[0 for y in xrange(5)] for x in xrange(2)]
sehingga
Matrix[1][4] = 2 # Valid
Matrix[4][1] = 3 # IndexError: list index out of range
Ini adalah bagaimana saya biasanya membuat array 2D di python.
col = 3
row = 4
array = [[0] * col for _ in range(row)]
Saya menemukan sintaks ini mudah diingat dibandingkan dengan menggunakan dua untuk loop dalam daftar pemahaman.
Menggunakan NumPy anda dapat menginisialisasi matriks kosong seperti ini:
import numpy as np
mm = np.matrix([])
Dan kemudian menambahkan data seperti ini:
mm = np.append(mm, [[1,2]], axis=1)
Jika anda ingin menjadi mampu berpikir itu sebagai 2D array daripada dipaksa untuk berpikir dalam istilah dari daftar list (jauh lebih alami dalam pendapat saya), anda dapat melakukan hal-hal berikut:
import numpy
Nx=3; Ny=4
my2Dlist= numpy.zeros((Nx,Ny)).tolist()
Hasilnya adalah daftar (tidak NumPy array), dan anda dapat menimpa posisi individu dengan angka, string, apapun.
matrix = {}
Anda dapat menentukan kunci dan nilai dalam dua cara:
matrix[0,0] = value
atau
matrix = { (0,0) : value }
Hasilnya:
[ value, value, value, value, value],
[ value, value, value, value, value],
...
Gunakan:
import copy
def ndlist(*args, init=0):
dp = init
for x in reversed(args):
dp = [copy.deepcopy(dp) for _ in range(x)]
return dp
l = ndlist(1,2,3,4) # 4 dimensional list initialized with 0's
l[0][1][2][3] = 1
Saya pikir NumPy adalah cara untuk pergi. Di atas adalah satu yang umum jika anda don't ingin menggunakan NumPy.
Jika anda don't memiliki ukuran informasi sebelum memulai kemudian membuat dua satu-dimensi daftar.
daftar 1: Untuk menyimpan baris daftar 2: Sebenarnya dua-dimensi matriks
Menyimpan seluruh baris dalam 1 daftar. Setelah selesai, tambahkan daftar 1 daftar 2:
from random import randint
coordinates=[]
temp=[]
points=int(raw_input("Enter No Of Coordinates >"))
for i in range(0,points):
randomx=randint(0,1000)
randomy=randint(0,1000)
temp=[]
temp.append(randomx)
temp.append(randomy)
coordinates.append(temp)
print coordinates
Output:
Enter No Of Coordinates >4
[[522, 96], [378, 276], [349, 741], [238, 439]]