Temukan elemen dalam daftar tupel python

Daftar dapat memiliki tupel sebagai elemennya. Pada artikel ini kita akan belajar bagaimana mengidentifikasi tupel yang berisi elemen pencarian tertentu yang merupakan string

Dengan dalam dan kondisi

Kami dapat merancang tindak lanjut dengan kondisi. Setelah di dalam kita bisa menyebutkan kondisi atau kombinasi dari kondisi

Contoh

Demo Langsung

listA = [('Mon', 3), ('Tue', 1), ('Mon', 2), ('Wed', 3)]
test_elem = 'Mon'
#Given list
print("Given list:\n",listA)
print("Check value:\n",test_elem)
# Uisng for and if
res = [item for item in listA
   if item[0] == test_elem and item[1] >= 2]
# printing res
print("The tuples satisfying the conditions:\n ",res)

Keluaran

Menjalankan kode di atas memberi kita hasil berikut -

Given list:
[('Mon', 3), ('Tue', 1), ('Mon', 2), ('Wed', 3)]
Check value:
Mon
The tuples satisfying the conditions:
[('Mon', 3), ('Mon', 2)]

Dengan saringan

Kami menggunakan fungsi filter bersama dengan fungsi Lambda. Dalam kondisi filter kami menggunakan operator in untuk memeriksa keberadaan elemen di tuple

Tuple adalah kumpulan objek yang teratur dan tidak berubah. Tuple adalah urutan, seperti daftar. Perbedaan antara tupel dan daftar adalah, tupel tidak dapat diubah tidak seperti daftar dan tupel menggunakan tanda kurung, sedangkan daftar menggunakan tanda kurung siku

Membuat tuple semudah meletakkan nilai yang dipisahkan koma. Secara opsional, Anda juga dapat menempatkan nilai yang dipisahkan koma ini di antara tanda kurung. Misalnya −

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

Tuple kosong ditulis sebagai dua tanda kurung yang tidak berisi −

tup1 = ();

Untuk menulis tuple yang berisi satu nilai, Anda harus menyertakan koma, meskipun hanya ada satu nilai -

tup1 = (50,);

Seperti indeks string, indeks tuple dimulai dari 0, dan dapat diiris, digabungkan, dan seterusnya

Mengakses Nilai di Tuple

Untuk mengakses nilai dalam tuple, gunakan tanda kurung siku untuk mengiris bersama dengan indeks atau indeks untuk mendapatkan nilai yang tersedia pada indeks tersebut. Misalnya −

#!/usr/bin/python

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0];
print "tup2[1:5]: ", tup2[1:5];

Ketika kode di atas dijalankan, menghasilkan hasil sebagai berikut -

tup1[0]:  physics
tup2[1:5]:  [2, 3, 4, 5]

Memperbarui Tuple

Tuple tidak dapat diubah yang berarti Anda tidak dapat memperbarui atau mengubah nilai elemen tuple. Anda dapat mengambil bagian dari tupel yang ada untuk membuat tupel baru seperti yang ditunjukkan contoh berikut −

#!/usr/bin/python

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# Following action is not valid for tuples
# tup1[0] = 100;

# So let's create a new tuple as follows
tup3 = tup1 + tup2;
print tup3;

Ketika kode di atas dijalankan, menghasilkan hasil sebagai berikut -

(12, 34.56, 'abc', 'xyz')

Hapus Elemen Tuple

Menghapus elemen tuple individual tidak dimungkinkan. Tentu saja, tidak ada salahnya menyusun tuple lain dengan membuang elemen yang tidak diinginkan

Untuk menghapus seluruh tuple secara eksplisit, cukup gunakan pernyataan del. Misalnya −

#!/usr/bin/python

tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
print "After deleting tup : ";
print tup;

Ini menghasilkan hasil berikut. Perhatikan pengecualian yang muncul, ini karena setelah del tup tuple tidak ada lagi −

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
   File "test.py", line 9, in 
      print tup;
NameError: name 'tup' is not defined

Operasi Tuple Dasar

Tuple merespons operator + dan * seperti string;

Nyatanya, tupel merespons semua operasi urutan umum yang kita gunakan pada string di bab sebelumnya −

Pengindeksan, Pemotongan, dan Matriks

Karena tupel adalah urutan, pengindeksan dan pemotongan bekerja dengan cara yang sama untuk tupel seperti halnya untuk string. Dengan asumsi masukan berikut -

L = ('spam', 'Spam', 'SPAM!')

Tidak Melampirkan Pembatas

Kumpulan beberapa objek apa pun, dipisahkan koma, ditulis tanpa simbol pengenal, mis. e. , tanda kurung untuk daftar, tanda kurung untuk tupel, dll. , default ke tupel, seperti yang ditunjukkan dalam contoh singkat ini −

Bab terakhir kami memperkenalkan tipe bawaan Python

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

Integer dan float adalah tipe numerik, yang berarti mereka menyimpan angka. Kita dapat menggunakan operator numerik yang kita lihat di bab sebelumnya untuk membentuk ekspresi numerik. Penerjemah Python kemudian dapat mengevaluasi ekspresi ini untuk menghasilkan nilai numerik, menjadikan Python kalkulator yang sangat kuat

String, list, dan tuple semuanya adalah tipe sequence, disebut demikian karena berperilaku seperti sequence - kumpulan objek yang terurut

Tipe urutan secara kualitatif berbeda dari tipe numerik karena merupakan tipe data majemuk - artinya terdiri dari bagian-bagian yang lebih kecil. Dalam kasus string, mereka terdiri dari string yang lebih kecil, masing-masing berisi satu karakter. Ada juga string kosong yang tidak berisi karakter sama sekali

Dalam kasus daftar atau tupel, mereka terdiri dari elemen, yang merupakan nilai dari tipe data Python apa pun, termasuk daftar dan tupel lainnya

Daftar diapit dalam tanda kurung siku (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

Daftar yang tidak berisi elemen disebut daftar kosong, dan tupel tanpa elemen disebut tupel kosong

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Contoh pertama adalah daftar lima bilangan bulat, dan berikutnya adalah daftar tiga string. Yang ketiga adalah tuple yang berisi empat bilangan bulat, diikuti oleh tuple yang berisi empat string. Yang terakhir adalah daftar yang berisi tiga tupel, yang masing-masing berisi sepasang string

Bergantung pada apa yang kita lakukan, kita mungkin ingin memperlakukan tipe data majemuk sebagai satu hal, atau kita mungkin ingin mengakses bagian-bagiannya. Ambiguitas ini berguna

Catatan

Dimungkinkan untuk menghapus tanda kurung saat menentukan tuple, dan hanya menggunakan daftar nilai yang dipisahkan koma

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Juga, diperlukan untuk menyertakan koma saat menentukan tuple dengan hanya satu elemen

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Kecuali untuk kasus tuple kosong, itu benar-benar koma, bukan tanda kurung, yang memberi tahu Python bahwa itu adalah tuple

3. 2. Bekerja dengan bagian-bagian urutan

Jenis urutan berbagi seperangkat operasi yang sama

3. 2. 1. Pengindeksan

Operator pengindeksan (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Ekspresi

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

Anda mungkin mengira akan melihat

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

3. 2. 2. Panjang

Bab terakhir Anda melihat fungsi

>>> last = seq[len(seq) - 1]

>>> len('banana')
6

Dengan daftar dan tupel,

>>> last = seq[len(seq) - 1]

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

3. 2. 3. Mengakses elemen di akhir urutan

Adalah umum dalam pemrograman komputer untuk mengakses elemen di akhir urutan. Sekarang setelah Anda melihat fungsi

>>> last = seq[len(seq) - 1]

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

Itu tidak akan berhasil. Ini menyebabkan kesalahan runtime ________26______9. Alasannya adalah

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

Karena kami mulai menghitung dari nol, enam belas indeks diberi nomor 0 hingga 15. Untuk mendapatkan elemen terakhir, kita harus mengurangi 1 dari panjangnya

>>> last = seq[len(seq) - 1]

Ini adalah pola yang umum sehingga Python menyediakan notasi tangan pendek untuk itu, pengindeksan negatif, yang menghitung mundur dari akhir urutan

Ekspresi

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

3. 2. 4. Traversal dan >>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] >>> prime_nums[-2] 29 >>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter") >>> classmates[-5] 'Ed' >>> word = "Alphabet" >>> word[-3] 'b' 4 loop

Banyak perhitungan melibatkan pemrosesan urutan satu elemen pada satu waktu. Pola yang paling umum adalah memulai dari awal, memilih setiap elemen secara bergiliran, melakukan sesuatu terhadapnya, dan melanjutkan hingga akhir. Pola pemrosesan ini disebut traversal

Loop

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

Catatan

Kami akan membahas perulangan secara lebih rinci di bab berikutnya. Untuk saat ini perhatikan saja bahwa titik dua (. ) di akhir baris pertama dan lekukan di baris kedua keduanya diperlukan agar pernyataan ini benar secara sintaksis

3. 3. ________39______6

Sebagai standar

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 3. 1. Irisan

Urutan dari urutan disebut irisan dan operasi yang mengekstrak urutan disebut pemotongan. Seperti pengindeksan, kami menggunakan tanda kurung siku (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Operator

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

Jika Anda menghilangkan indeks pertama (sebelum tanda titik dua), irisan akan dimulai di awal string. Jika Anda menghilangkan indeks kedua, potongan akan menuju ke ujung string. Jadi

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Menurut Anda apa artinya

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

Indeks negatif juga diperbolehkan, jadi

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Tip

Mengembangkan pemahaman yang kuat tentang cara kerja mengiris itu penting. Terus buat "eksperimen" Anda sendiri dengan urutan dan irisan hingga Anda dapat secara konsisten memprediksi hasil operasi pemotongan sebelum Anda menjalankannya

Saat Anda mengiris urutan, urutan yang dihasilkan selalu memiliki jenis yang sama dengan urutan asalnya. Ini umumnya tidak benar dengan pengindeksan, kecuali dalam kasus string

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Sementara elemen daftar (atau tupel) bisa dari jenis apa pun, tidak peduli bagaimana Anda mengirisnya, sepotong daftar adalah daftar

3. 3. 2. Operator prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 5

Operator

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Perhatikan bahwa string adalah substring dari dirinya sendiri, dan string kosong adalah substring dari string lainnya. (Perhatikan juga bahwa pemrogram komputer suka memikirkan kasus tepi ini dengan sangat hati-hati. )

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 4. Objek dan metode

String, daftar, dan tupel adalah objek, yang berarti bahwa mereka tidak hanya menyimpan nilai, tetapi memiliki perilaku bawaan yang disebut metode, yang bertindak berdasarkan nilai dalam objek.

Mari kita lihat beberapa metode string beraksi untuk melihat cara kerjanya

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Sekarang mari belajar mendeskripsikan apa yang baru saja kita lihat. Setiap string dalam contoh di atas diikuti oleh operator titik, nama metode, dan daftar parameter, yang mungkin kosong

Pada contoh pertama, string

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

Pada contoh keempat, metode

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 5. Fungsi >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 15 dan dokumen

Bagian sebelumnya memperkenalkan beberapa metode objek string. Untuk menemukan semua metode yang dimiliki string, kita dapat menggunakan fungsi

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Kami akan menunda pembicaraan tentang yang dimulai dengan garis bawah ganda (________21______17) hingga nanti. Anda dapat mengetahui lebih lanjut tentang masing-masing metode ini dengan mencetak dokumen mereka. Untuk mengetahui apa yang dilakukan metode

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Dengan menggunakan informasi ini, kami dapat mencoba menggunakan metode ganti untuk memverifikasi bahwa kami mengetahui cara kerjanya

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Contoh pertama menggantikan semua kemunculan ________21______19 dengan

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 6. >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 24 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 25 metode

Ada dua metode yang umum untuk ketiga jenis urutan.

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Kami akan mengeksplorasi fungsi-fungsi ini dalam latihan

3. 7. Daftar dapat diubah

Tidak seperti string dan tupel, yang merupakan objek yang tidak dapat diubah, daftar dapat diubah, yang berarti kita dapat mengubah elemennya. Menggunakan operator braket di sisi kiri tugas, kita dapat memperbarui salah satu elemen

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Operator tanda kurung yang diterapkan ke daftar dapat muncul di mana saja dalam ekspresi. Ketika muncul di sisi kiri tugas, itu mengubah salah satu elemen dalam daftar, jadi elemen pertama

>>> last = seq[len(seq) - 1]

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

tapi itu untuk daftar

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Dengan operator slice kita bisa mengupdate beberapa elemen sekaligus

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Kami juga dapat menghapus elemen dari daftar dengan menugaskan daftar kosong ke mereka

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Dan kita bisa menambahkan elemen ke daftar dengan meremasnya menjadi irisan kosong di lokasi yang diinginkan

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

3. 8. Penghapusan daftar

Menggunakan irisan untuk menghapus elemen daftar bisa menjadi canggung, dan karena itu rawan kesalahan. Python memberikan alternatif yang lebih mudah dibaca

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Seperti yang Anda duga,

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Anda dapat menggunakan irisan sebagai indeks untuk ________21______33

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Seperti biasa, irisan memilih semua elemen hingga, tetapi tidak termasuk, indeks kedua

3. 9. Mencantumkan metode

Selain

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Metode

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 10. Nama dan nilai yang dapat diubah

Jika kita menjalankan pernyataan penugasan ini,

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

kita tahu bahwa nama

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> last = seq[len(seq) - 1]

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Ada dua kemungkinan keadaan

atau

Dalam satu kasus,

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Kita dapat menguji apakah dua nama memiliki nilai yang sama menggunakan

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Kita dapat menguji apakah dua nama merujuk ke objek yang sama menggunakan operator is

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Ini memberitahu kita bahwa

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 11. Aliasing

Karena variabel merujuk ke objek, jika kita menugaskan satu variabel ke variabel lain, kedua variabel merujuk ke objek yang sama

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Dalam hal ini, yang kedua dari dua diagram keadaan yang menggambarkan hubungan antara variabel

Karena daftar yang sama memiliki dua nama yang berbeda,

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Meskipun perilaku ini bisa bermanfaat, terkadang tidak terduga atau tidak diinginkan. Secara umum, lebih aman untuk menghindari alias saat Anda bekerja dengan objek yang bisa berubah. Tentu saja, untuk objek yang tidak dapat diubah, tidak ada masalah, karena objek tersebut tidak dapat diubah setelah dibuat

3. 12. Daftar kloning

Jika kita ingin memodifikasi daftar dan juga menyimpan salinan aslinya, kita harus dapat membuat salinan dari daftar itu sendiri, bukan hanya referensi. Proses ini terkadang disebut kloning, untuk menghindari ambiguitas penyalinan kata

Cara termudah untuk mengkloning daftar adalah dengan menggunakan operator irisan

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Mengambil potongan

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Sekarang kita bebas melakukan perubahan pada

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

3. 13. Daftar bertingkat

Daftar bersarang adalah daftar yang muncul sebagai elemen dalam daftar lain. Dalam daftar ini, elemen dengan indeks 3 adalah daftar bersarang

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Jika kita mencetak

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len('banana')
6

Atau kita bisa menggabungkannya

>>> len('banana')
6

Operator tanda kurung mengevaluasi dari kiri ke kanan, jadi ekspresi ini mendapatkan elemen tiga-eth dari

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 14. String dan daftar

Python memiliki beberapa alat yang menggabungkan daftar string menjadi string dan memisahkan string menjadi daftar string

Perintah

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len('banana')
6

Metode

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len('banana')
6

Di sini kita memiliki

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len('banana')
6

Perhatikan bahwa pembatas tidak muncul dalam daftar

Metode

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len('banana')
6

Nilai string di mana metode

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len('banana')
6

Pemisah juga bisa berupa string kosong

>>> len('banana')
6

3. 15. Tuple tugas

Sesekali, berguna untuk menukar nilai dua variabel. Dengan pernyataan penugasan konvensional, kita harus menggunakan variabel sementara. Misalnya, untuk menukar

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len('banana')
6

Jika kita harus sering melakukan ini, pendekatan ini menjadi tidak praktis. Python menyediakan bentuk penugasan tuple yang menyelesaikan masalah ini dengan rapi

>>> len('banana')
6

Sisi kiri adalah sekumpulan variabel; . Setiap nilai ditugaskan ke variabel masing-masing. Semua ekspresi di sisi kanan dievaluasi sebelum tugas apa pun. Fitur ini membuat penugasan tuple cukup fleksibel

Secara alami, jumlah variabel di sebelah kiri dan jumlah nilai di sebelah kanan harus sama

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

3. 16. Nilai Boolean

Sekarang kita akan melihat jenis nilai baru - nilai boolean - yang dinamai dari ahli matematika Inggris, George Boole. Dia menciptakan matematika yang kita sebut aljabar Boolean, yang merupakan dasar dari semua aritmatika komputer modern

Catatan

Ini adalah kemampuan komputer untuk mengubah aliran eksekusi tergantung pada apakah nilai boolean benar atau salah yang membuat komputer tujuan umum lebih dari sekedar kalkulator

Hanya ada dua nilai boolean,

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

Kapitalisasi itu penting, karena

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

3. 17. Ekspresi Boolean

Ekspresi boolean adalah ekspresi yang mengevaluasi ke nilai boolean

Operator

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

Dalam pernyataan pertama, kedua operan adalah sama, sehingga ekspresi dievaluasi menjadi

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

Operator

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

Meskipun operasi ini mungkin sudah tidak asing lagi bagi Anda, simbol Python berbeda dari simbol matematika. Kesalahan umum adalah menggunakan tanda sama dengan tunggal (

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 18. Operator logika

Ada tiga operator logika.

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Terakhir, operator

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

3. 19. Evaluasi arus pendek

Ekspresi Boolean dalam Python menggunakan evaluasi hubung singkat, yang berarti hanya argumen pertama dari ekspresi

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Ini bisa sangat berguna dalam mencegah kesalahan runtime. Bayangkan Anda ingin memeriksa apakah angka kelima dalam tupel bilangan bulat bernama

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Ekspresi berikut akan bekerja

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

kecuali tentu saja tidak ada 5 elemen di

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

Evaluasi hubung singkat memungkinkan untuk menghindari masalah ini

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

Karena sisi kiri ekspresi

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

3. 20. “Kebenaran”

Semua nilai Python memiliki "kebenaran" atau "kepalsuan" yang artinya dapat digunakan di tempat yang membutuhkan boolean. Untuk tipe numerik dan sequence yang telah kita lihat sejauh ini, kebenaran didefinisikan sebagai berikut

Nilai sama dengan 0 salah, yang lainnya benar

Urutan kosong salah, urutan tidak kosong benar

Menggabungkan gagasan kebenaran ini dengan pemahaman tentang evaluasi hubung singkat memungkinkan untuk memahami apa yang dilakukan Python dalam ekspresi berikut

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

3. 21. Glosarium

Beberapa variabel yang berisi referensi ke objek yang sama

Tepatnya ada dua nilai boolean.

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Ekspresi yang bernilai benar atau salah

Untuk membuat objek baru yang memiliki nilai yang sama dengan objek yang sudah ada. Menyalin referensi ke objek membuat alias tetapi tidak mengkloning objek

Salah satu operator yang membandingkan dua nilai.

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Tipe data di mana nilai terdiri dari komponen, atau elemen, yang merupakan nilai itu sendiri

Salah satu bagian yang menyusun sebuah sequence type (string, list, atau tuple). Elemen memiliki nilai dan indeks. Nilai diakses dengan menggunakan operator indeks (

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Tipe data yang tidak dapat dimodifikasi. Penugasan ke elemen atau irisan dari tipe yang tidak dapat diubah menyebabkan kesalahan runtime

Variabel atau nilai yang digunakan untuk memilih anggota koleksi terurut, seperti karakter dari string, atau elemen dari daftar atau tuple

Salah satu operator yang menggabungkan ekspresi boolean.

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

>>> thing = 2, 4, 6, 8
>>> type(thing)
<class 'tuple'>
>>> thing
(2, 4, 6, 8)

Tipe data yang dapat dimodifikasi. Semua tipe yang bisa berubah adalah tipe majemuk. Daftar dan kamus adalah tipe data yang dapat diubah;

Daftar yang merupakan elemen dari daftar lain

Bagian dari string (substring) yang ditentukan oleh rentang indeks. Secara lebih umum, subsequence dari semua tipe sequence di Python dapat dibuat menggunakan operator slice (

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Interval antara elemen berurutan dari urutan linier. Argumen ketiga (dan opsional) ke fungsi

>>> singleton = (2,)
>>> type(singleton)
<class 'tuple'>
>>> not_tuple = (2)
>>> type(not_tuple)
<class 'int'>
>>> empty_tuple = ()
>>> type(empty_tuple)
<class 'tuple'>

Untuk beralih melalui elemen koleksi, lakukan operasi serupa pada masing-masing elemen

Tipe data yang berisi urutan elemen dari tipe apa pun, seperti daftar, tetapi tidak dapat diubah. Tuple dapat digunakan di mana pun tipe yang tidak dapat diubah diperlukan, seperti kunci dalam kamus (lihat bab selanjutnya)

Penugasan untuk semua elemen dalam tuple menggunakan pernyataan penugasan tunggal. Penugasan tuple terjadi secara paralel daripada berurutan, membuatnya berguna untuk menukar nilai

Bagaimana Anda menemukan elemen dalam daftar tupel di Python?

Bagaimana Anda memeriksa apakah suatu item ada dalam daftar tupel?

Bagaimana Anda mengekstrak elemen dari tuple ke daftar?

Bagaimana Anda menemukan indeks daftar tuple di Python?