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 −
Demo Langsung#!/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 −
Demo Langsung#!/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 −
Demo Langsung#!/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 definedOperasi Tuple Dasar
Tuple merespons operator + dan * seperti string;
Nyatanya, tupel merespons semua operasi urutan umum yang kita gunakan pada string di bab sebelumnya −
Ekspresi PythonHasilDeskripsilen((1, 2, 3))3Panjang(1, 2, 3) + (4, 5, 6)(1, 2, 3, 4, 5, 6)Gabungan('Hai. ',) * 4('Hai. ', 'Hai. ', 'Hai. ', 'Hai. ')Pengulangan3 dalam (1, 2, 3)Keanggotaan Sejati untuk x dalam (1, 2, 3). cetak x,1 2 3IterasiPengindeksan, 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!') Python ExpressionResultsDescriptionL[2]'SPAM. 'Offset mulai dari nolL[-2]'Spam'Negatif. menghitung dari kananL[1. ]['Spam', 'SPAM. ']Mengiris mengambil bagianTidak 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! 0, >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 1, dan >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 2, dan kami menemukan >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 3
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! 4 dan >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 5) dan tupel dalam tanda kurung (>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 6 dan >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 7)
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! _4 >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 5) memilih satu elemen dari urutan. Ekspresi di dalam tanda kurung disebut indeks, dan harus berupa nilai bilangan bulat. Indeks menunjukkan elemen mana yang harus dipilih, maka namanya
>>> 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] 0 memilih karakter dengan indeks >>> last = seq[len(seq) - 1] 1 dari >>> last = seq[len(seq) - 1] 2, dan membuat string baru yang hanya berisi satu karakter ini, yang mungkin mengejutkan Anda adalah >>> last = seq[len(seq) - 1] 3
Anda mungkin mengira akan melihat >>> last = seq[len(seq) - 1] _4, tetapi ilmuwan komputer biasanya mulai menghitung dari nol, bukan satu. Pikirkan indeks sebagai angka pada penggaris yang mengukur berapa banyak elemen yang telah Anda pindahkan ke urutan dari awal. Penggaris dan indeks dimulai dari >>> last = seq[len(seq) - 1] 5
3. 2. 2. Panjang
Bab terakhir Anda melihat fungsi >>> last = seq[len(seq) - 1] _6 digunakan untuk mendapatkan jumlah karakter dalam sebuah string
>>> len('banana') 6
Dengan daftar dan tupel, >>> last = seq[len(seq) - 1] 6 mengembalikan jumlah elemen dalam urutan
>>> 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] _6, Anda mungkin tergoda untuk mencoba sesuatu seperti ini
>>> 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' 0 mengembalikan jumlah elemen dalam daftar, 16, tetapi tidak ada elemen pada posisi indeks 16 di >>> 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' 1
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' 2 menghasilkan elemen terakhir, >>> 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 menghasilkan elemen kedua hingga terakhir, dan seterusnya
>>> 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' 4 Python membuat traversal mudah diekspresikan
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' 4 loop melintasi urutan, itu menetapkan setiap nilai dalam urutan ke variabel loop dalam urutan itu terjadi dalam urutan. Terkadang berguna untuk memiliki nilai dan indeks dari setiap elemen. Fungsi >>> 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' _6 memberi kita ini
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 0
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! 4 >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 5) sebagai operator irisan, tetapi alih-alih satu nilai bilangan bulat di dalamnya, kami memiliki dua, dipisahkan oleh titik dua (prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 1)
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 1
Operator prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 2 mengembalikan bagian urutan dari elemen ke-n ke elemen ke-m, termasuk yang pertama tetapi tidak termasuk yang terakhir. Perilaku ini kontra-intuitif;
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) 2
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) 3?
Indeks negatif juga diperbolehkan, jadi
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 3
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) 4
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) _5 mengembalikan apakah elemen tertentu terkandung dalam daftar atau tuple
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 5
prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 5 bekerja agak berbeda dengan string. Itu mengevaluasi ke prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) _8 jika satu string adalah substring dari yang lain
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 6
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) 7
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) 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) _9 diikuti oleh operator titik dan kemudian metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 00, yang memiliki daftar parameter kosong. Kami mengatakan bahwa metode “>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 00 dipanggil pada string, prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 9. Memanggil metode menyebabkan tindakan terjadi menggunakan nilai yang metodenya dipanggil. Tindakan menghasilkan hasil, dalam hal ini nilai string >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 03. Kami mengatakan bahwa metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _00 mengembalikan string >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 03 ketika dipanggil (atau dipanggil) string prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 9
Pada contoh keempat, metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _07 (sekali lagi dengan daftar parameter kosong) dipanggil pada string >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 08. Karena setiap karakter dalam string mewakili satu digit, metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 07 mengembalikan nilai boolean prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 8. Memanggil >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 07 pada >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 12 menghasilkan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 13
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _14 menghapus spasi kosong di depan dan di belakang
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) 16 bawaan Python
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _9
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) _18, misalnya, kami melakukan ini
>>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> _0
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'> _1
Contoh pertama menggantikan semua kemunculan ________21______19 dengan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 20. Yang kedua menggantikan karakter tunggal >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _21 dengan dua karakter >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 22. Contoh ketiga menggantikan dua kejadian pertama dari >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 23 dengan string kosong
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) 24 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 25. Mari kita lihat dokumen mereka untuk melihat apa yang mereka lakukan
>>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> _2
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'> _3
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] 2 telah diubah dari >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 29 menjadi >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 30, dan yang terakhir dari >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 31 menjadi >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 32. Penugasan ke elemen daftar disebut penugasan item. Penetapan item tidak berfungsi untuk string
>>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> _4
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'> _5
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'> _6
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'> _7
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'> _8
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) 33 menghapus elemen dari daftar
>>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> _9
Seperti yang Anda duga, >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _33 menangani indeks negatif dan menyebabkan kesalahan runtime jika indeks berada di luar jangkauan
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') _0
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) 24 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 25, daftar memiliki beberapa metode yang berguna. Karena daftar dapat berubah, metode ini mengubah daftar tempat mereka dipanggil, daripada mengembalikan daftar baru
>>> 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') _1
Metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _38 sangat berguna, karena memudahkan penggunaan Python untuk mengurutkan data yang telah Anda masukkan ke dalam daftar
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') _2
kita tahu bahwa nama >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _39 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 40 akan merujuk ke daftar dengan nomor >>> last = seq[len(seq) - 1] 1, >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 42, dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 43. Tapi kami belum tahu apakah mereka menunjuk ke daftar yang sama
Ada dua kemungkinan keadaan
atau
Dalam satu kasus, >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _39 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 40 merujuk pada dua hal berbeda yang memiliki nilai yang sama. Dalam kasus kedua, mereka merujuk ke objek yang sama
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) 46
>>> 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
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') _4
Ini memberitahu kita bahwa >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _39 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 40 tidak merujuk ke objek yang sama, dan itu adalah yang pertama dari dua diagram keadaan yang menggambarkan hubungan
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') _5
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) 39 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 40, kita mengatakan bahwa itu adalah alias. Karena daftar dapat diubah, perubahan yang dibuat dengan satu alias memengaruhi yang lain
>>> 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') _6
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') _7
Mengambil potongan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _39 membuat daftar baru. Dalam hal ini potongan tersebut terdiri dari seluruh daftar
Sekarang kita bebas melakukan perubahan pada >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _40 tanpa mengkhawatirkan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 39
>>> 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') _8
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') _9
Jika kita mencetak >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _54, kita mendapatkan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 55. Untuk mengekstrak elemen dari daftar bersarang, kita dapat melanjutkan dalam dua langkah
>>> len('banana') 6 0
Atau kita bisa menggabungkannya
>>> len('banana') 6 _1
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) 56 dan mengekstrak elemen satu-eth darinya
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) _57 menggunakan tipe urutan sebagai argumen dan membuat daftar dari elemen-elemennya. Saat diterapkan ke string, Anda mendapatkan daftar karakter
>>> len('banana') 6 _2
Metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _58 dipanggil pada string dan memisahkan string ke dalam daftar string, memisahkannya setiap kali substring yang disebut pembatas terjadi. Pembatas default adalah spasi putih, yang mencakup spasi, tab, dan baris baru
>>> len('banana') 6 _3
Di sini kita memiliki >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _59 sebagai pembatas
>>> len('banana') 6 _4
Perhatikan bahwa pembatas tidak muncul dalam daftar
Metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _60 kira-kira kebalikan dari metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 58. Dibutuhkan daftar string sebagai argumen dan mengembalikan string dari semua elemen daftar yang digabungkan
>>> len('banana') 6 _5
Nilai string di mana metode >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _60 dipanggil bertindak sebagai pemisah yang ditempatkan di antara setiap elemen dalam daftar dalam string yang dikembalikan
>>> len('banana') 6 _6
Pemisah juga bisa berupa string kosong
>>> len('banana') 6 _7
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) _39 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 40
>>> len('banana') 6 _8
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 _9
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 _0
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) 8 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 13
>>> len(['a', 'b', 'c', 'd']) 4 >>> len((2, 4, 6, 8, 10, 12)) 6 >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')] >>> len(pairs) 3 _1
Kapitalisasi itu penting, karena >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _67 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 68 bukan nilai boolean di Python
>>> len(['a', 'b', 'c', 'd']) 4 >>> len((2, 4, 6, 8, 10, 12)) 6 >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')] >>> len(pairs) 3 _2
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) _46 membandingkan dua nilai dan menghasilkan nilai boolean
>>> 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
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) 8;
Operator >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _46 adalah salah satu dari enam operator perbandingan umum;
>>> len(['a', 'b', 'c', 'd']) 4 >>> len((2, 4, 6, 8, 10, 12)) 6 >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')] >>> len(pairs) 3 _4
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) 73) alih-alih tanda sama dengan ganda (>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 46). Ingatlah bahwa >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _73 adalah operator penugasan dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 46 adalah operator pembanding. Juga, tidak ada yang namanya ________21______77 atau >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 78
3. 18. Operator logika
Ada tiga operator logika. >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 79, >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 80, dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 81. Semantik (arti) dari operator ini mirip dengan artinya dalam bahasa Inggris. Misalnya, >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _82 benar hanya jika >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 83 lebih besar dari 0 dan pada saat yang sama, x lebih kecil dari 10
>>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 84 benar jika salah satu kondisi benar, yaitu, jika bilangan habis dibagi 2 atau habis dibagi 3
Terakhir, operator >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _81 meniadakan ekspresi boolean, jadi >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 86 benar jika >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 87 salah, yaitu jika >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 83 kurang dari atau sama dengan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 89
>>> len(['a', 'b', 'c', 'd']) 4 >>> len((2, 4, 6, 8, 10, 12)) 6 >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')] >>> len(pairs) 3 _5
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) 79 atau >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 80 yang dievaluasi ketika nilainya cukup untuk menentukan nilai seluruh ekspresi
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) 92 genap
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 _6
kecuali tentu saja tidak ada 5 elemen di >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 92, dalam hal ini Anda akan mendapatkan
>>> len(['a', 'b', 'c', 'd']) 4 >>> len((2, 4, 6, 8, 10, 12)) 6 >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')] >>> len(pairs) 3 _7
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 _8
Karena sisi kiri ekspresi >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _79 ini salah, Python tidak perlu mengevaluasi sisi kanan untuk menentukan bahwa seluruh ekspresi salah. Karena menggunakan evaluasi hubung singkat, tidak, dan kesalahan runtime dihindari
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
tipe numerikNilai sama dengan 0 salah, yang lainnya benar
jenis urutanUrutan 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 _9
3. 21. Glosarium
aliasBeberapa variabel yang berisi referensi ke objek yang sama
nilai booleanTepatnya 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) 8 dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 13. Nilai Boolean dihasilkan ketika ekspresi boolean dievaluasi oleh juru bahasa Python. Mereka memiliki tipe >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) _97
ekspresi booleanEkspresi yang bernilai benar atau salah
klonUntuk membuat objek baru yang memiliki nilai yang sama dengan objek yang sudah ada. Menyalin referensi ke objek membuat alias tetapi tidak mengkloning objek
operator pembandingSalah satu operator yang membandingkan dua nilai. >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 46, >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 99, >>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> 00, >>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> 01, >>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> 02, dan >>> singleton = (2,) >>> type(singleton) <class 'tuple'> >>> not_tuple = (2) >>> type(not_tuple) <class 'int'> >>> empty_tuple = () >>> type(empty_tuple) <class 'tuple'> 03
tipe data gabunganTipe data di mana nilai terdiri dari komponen, atau elemen, yang merupakan nilai itu sendiri
elemenSalah 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'> 04) pada urutan
tipe data yang tidak dapat diubahTipe data yang tidak dapat dimodifikasi. Penugasan ke elemen atau irisan dari tipe yang tidak dapat diubah menyebabkan kesalahan runtime
indeksVariabel atau nilai yang digunakan untuk memilih anggota koleksi terurut, seperti karakter dari string, atau elemen dari daftar atau tuple
operator logisSalah satu operator yang menggabungkan ekspresi boolean. >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 79, >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 80, dan >>> thing = 2, 4, 6, 8 >>> type(thing) <class 'tuple'> >>> thing (2, 4, 6, 8) 81
tipe data yang dapat diubahTipe data yang dapat dimodifikasi. Semua tipe yang bisa berubah adalah tipe majemuk. Daftar dan kamus adalah tipe data yang dapat diubah;
daftar bersarangDaftar yang merupakan elemen dari daftar lain
mengirisBagian 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'> 08)
ukuran langkahInterval 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'> 09 disebut ukuran langkah. Jika tidak ditentukan, standarnya adalah 1
melintasiUntuk beralih melalui elemen koleksi, lakukan operasi serupa pada masing-masing elemen
tupelTipe 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 tuplePenugasan untuk semua elemen dalam tuple menggunakan pernyataan penugasan tunggal. Penugasan tuple terjadi secara paralel daripada berurutan, membuatnya berguna untuk menukar nilai