Penjelasan terperinci tentang penggunaan senarai dan tupel dalam pembelajaran Python

Artikel ini membawakan anda pengetahuan yang berkaitan tentang Python terutamanya memperkenalkan penjelasan terperinci tentang penggunaan senarai dan tuple, termasuk sintaks pengisytiharan senarai, bacaan senarai dan operasi senarai , pengetahuan asas dan operasi elemen , dsb. Mari kita lihat bersama-sama. Saya harap ia akan membantu semua orang.

[Cadangan berkaitan: Tutorial video Python3]

Pengenalan kepada senarai dan tupel

Jika anda bercakap Mengenai Python Mencari jenis data terbaik dalam bahasa, sudah pasti ia adalah senarai Jika saya ingin mengesyorkan satu, maka saya memilih Tuple kami dalam blog ini akan menjadi senarai yang tidak boleh diubah suai. Jadi gunakan sahaja sebagai hadiah untuk belajar.

Senarai ialah struktur data yang sangat fleksibel yang boleh menampung banyak kelemahan jenis rentetan sebelumnya.

Sebelum pembelajaran formal, anda perlu mengingati dua perkataan Inggeris, list dan tuple.

Senaraikan perkara pembelajaran

Mari kita lihat definisi senarai dahulu:

Senarai ialah jujukan pembolehubah dan bekas yang boleh menyimpan sebarang jenis data Gunakan kurungan segi empat sama ([]) mewakili permulaan dan akhir Setiap elemen dalaman dipisahkan dengan koma bahasa Inggeris (, Setiap elemen boleh dipanggil item, dan setiap elemen mempunyai indeks, juga dikenali sebagai subskrip.

Sintaks pengisytiharan senarai

Untuk mengisytiharkan senarai, anda boleh merujuk kepada format berikut.

Gunakan kurungan udara [] untuk mengisytiharkan senarai kosong

my_list = []
print(my_list)

Isytihar senarai yang mengandungi satu elemen

my_list = [1]
print(my_list)

Isytihar senarai yang mengandungi berbilang elemen

my_list = [1,2]
print(my_list)

Isytiharkan senarai yang mengandungi berbilang elemen jenis data yang berbeza

my_list = [1,'a',True]
print(my_list)

Mengisytiharkan bahawa senarai mengandungi senarai

my_list = [1,['a'],[True,1,1]]
print(my_list)

Membaca senarai

Konsep paling penting dalam membaca senarai ialah subskrip, juga dipanggil kedudukan atau indeks. Subskrip mula dikira dari 0, iaitu indeks elemen pertama dalam senarai ialah 0. Sebagai contoh, kod berikut membaca nombor 2.

my_list = [1,2,3,4,5]
print(my_list[1]) # 数字2所在的下标为1

Operasi senarai

Senarai ialah bekas dinamik yang menyokong penambahan, pemadaman, pengubahsuaian, pertanyaan, penggabungan dan operasi lain pada elemennya. Semua kaedah yang digunakan adalah objek kamus nama kaedah bagi operasi asas adalah seperti berikut:

• append(): Tambahkan elemen pada penghujung
• extend(): Tambahkan senarai di hujung, yang juga boleh menjadi; difahami sebagai menggabungkan dua senarai;
• insert(): Masukkan elemen pada kedudukan yang ditentukan; senarai;
• copy(): Kira bilangan elemen yang ditentukan dalam senarai
• clear(): Padam dan
kembali elemen yang sepadan dengan
• subskrip yang ditentukan; 🎜>count()
: Padamkan elemen yang dinyatakan dalam senarai ; 🎜>
• pop(): Isih elemen senarai.
• Kaedah untuk menambah elemen senarairemove()
• Dari senarai di atas, anda boleh melihat bahawa menambah elemen pada senarai boleh dilakukan dengan dua cara gunakan kaedah index(), yang kedua ialah menggunakan kaedah
, kod sampel adalah seperti berikut:
• reverse()
Membandingkan perbezaan antara dua kaedah di atas, anda dapat melihat bahawa
• boleh hanya tambah elemen pada penghujung senarai , dan kaedah sort() boleh memasukkan elemen pada sebarang kedudukan, iaitu, parameter pertama kaedah
ialah indeks, yang menunjukkan kedudukan sisipan.

Kaedah carian elemen senarai

Untuk mencari elemen dalam senarai, gunakan kaedah append() Format sintaks kaedah ini adalah seperti berikut: insert()

my_list = [1,2,3,4,5]
my_list.append(888)
my_list.insert(1,666)
print(my_list)

di mana

ialah senarai sasaran untuk ditemui, append() mewakili nilai yang akan ditemui, insert() dan insert() ialah parameter pilihan, menunjukkan nilai indeks untuk mula mencari dan indeks nilai untuk menamatkan carian. Apabila kaedah menjumpai elemen, ia akan mengembalikan kedudukan indeks elemen pertama yang ditemui Sebagai contoh, kod berikut akan mengembalikan

.

Jika kaedah ini tidak menemui elemen dalam senarai sasaran, ralat akan dilaporkan dengan jenis ralat

.

index()Selain kaedah

, membaca senarai juga merupakan kaedah carian elemen Contohnya, membaca elemen dengan subskrip 2, kodnya adalah seperti berikut:

my_list.index(value,[start[,stop]])

my_list Anda juga boleh menggunakan operator ahli value, menilai senarai, dan mempunyai lebih banyak pengetahuan tentang operator ahli. Saya akan menerangkannya secara terperinci kemudian apabila saya meringkaskan operator. Kod berikut mengembalikan start, yang bermaksud nombor 2 ada dalam senarai. stop3

Terdapat satu lagi titik pengetahuan penting dalam senarai, iaitu penghirisan senarai Untuk mempelajari perkara pengetahuan ini, anda perlu menguasai sintaks yang berkaitan dengan senarai bacaan mengikut indeks adalah seperti berikut:

my_list = [1,2,3,4,5]
ret = my_list.index(4)
print(ret)

ValueErrorAnda boleh melihat baris kedua kod di atas berdasarkan peraturan untuk membaca senarai asal, format telah berubah kepada

Tukarkan kepada arahan tatabahasa Cina seperti berikut :

my_list[起始索引:结束索引:步长]

使用切片的时候，英文冒号不能缺少，起始索引为必选项，结束索引和步长为可选项。

如果理解困难，最好的办法就是反复用代码校验。

# 缺省结束索引，默认获取到列表结尾元素
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:]
print(ret) # 输出 [2, 3, 4, 5, 6, 7, 8, 9, 10]

# 缺少步长，默认按照索引+1解决，同时不包含结束索引代表的元素
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:5]
print(ret) # 输出 [2, 3, 4, 5]

# 步长设置为2，表示索引每次+2
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:6:2]
print(ret) # 输出 [2, 4, 6]

上述代码如何理解已经在注释中进行说明，重点要掌握的切片知识点整理如下：

一首打油诗送给大家~

切片不能丢冒号 结束步长可不要 默认索引都加一 左闭右开要牢记

列表元素的修改和删除

前文已经掌握了列表的读取，将读取到的元素重新赋值就是列表的修改，例如下述代码。

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
print(my_list)

列表元素删除 在 Python 中，提出了多种列表元素删除的方式，本小节学习三个列表元素删除的方法，即 clear()，pop()，remove()，除此之外还可以使用 del() 函数对列表元素进行删除。

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
my_list.clear() # 列表清空
print(my_list)

使用 pop() 方法删除列表元素，默认从尾部删除，并返回被删除的元素。

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
ret = my_list.pop()
print(my_list) # 删除最后一项
print(ret) # 返回被删除的元素

pop() 方法中可以传递一个 index 值，该值表示下标值，即删除指定位置的元素，与之对应的是 remove() 方法的参数，该值表示待删除的目标元素，例如在列表中删除元素 5，使用的代码如下：

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
ret = my_list.remove(5)
print(my_list)
print(ret)

测试之后，可以发现 remove() 方法无返回值，并且该方法只删除第一个匹配到的元素，也就是当列表中有多个目标元素时，只有最先匹配到的元素被删除。

del() 函数可以删除列表中指定元素，也可以直接删除列表对象，代码如下：

# 删除索引位置为5的元素
my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
del(my_list[5])
print(my_list)


# 删除整个列表对象
my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
del my_list
print(my_list)

列表元素合并

使用 extend() 方法可以将列表进行合并：

my_list1 = [1,2,3]
my_list2 = [666,777,888]
my_list1.extend([666,777,888])
print(my_list1)

注意 extend() 方法不会生成新的列表。

列表合并也可以使用加号（+） 实现，该语法会产生一个新的列表。

my_list1 = [1,2,3]
my_list2 = [666,777,888]
my_list = my_list1 + my_list2
print(my_list)

列表元素顺序变化

列表排序用到的方法是 sort()，该方法默认按照 ASCII 进行增序或者减序排列，测试代码如下所示：

my_list = [4,1,2,6,7,3,8,12,10]
my_list.sort()
print(my_list)

在 sort() 方法中也有 2 个参数，格式如下：

my_list.sort(key=None,reverse=False)

参数 key 为可选参数，可以传入一个函数名，该函数会作用与列表中的每一项元素，例如将列表中每一项元素都转换为小写字母。

my_list = ['ABC','CDS','Juejin','YUE']
my_list.sort(key=str.lower)
print(my_list)

sort() 方法会对原列表进行排序，如果想生成一个新列表，可以使用 sorted() 函数，代码如下：

my_list = ['ABC','CDS','Juejin','YUE']
ret = sorted(my_list)
print(ret)

除此之外，还可以使用 reverse() 方法。

my_list = ['ABC','CDS','Juejin','YUE']
my_list.reverse()
print(my_list)

元组学习要点

元组定义与列表基本一致，只需要做好如下区分即可。

• 元组不能对其包含的元素进行修改，即元组不可变；
• 元组用小括号（()）表示。

再次进行简单总结：

元组是不可变序列，也是可以包含任意数据类型的容器，用小括号（()）表示，元素之间用逗号（,）分隔 。一定要注意的就是不可变序列，不可变的含义是不能对元组进行增加，修改，删除，位置变换等操作。

元组基本知识

声明一个元组

my_tuple = ()
print(my_tuple)
print(type(my_tuple))

声明一个只包含 1 个值的元组，要求必须带一个逗号，否则会按照整数处理。

my_tuple = (1,)
print(my_tuple)
print(type(my_tuple))

声明包含多个值的元组：

my_tuple = (1,2,3,4,5,6,[1])
print(my_tuple)
print(type(my_tuple))

元组的基本操作

由于元组对象的方法使用与列表一致，接下来仅对元组进行罗列。

• count()：统计元组中元素个数；
• index()：返回指定元素的下标。

其余可作用于元组的内置函数如下所示：

• len()：获取元组元素个数；
• max()：返回元组中最大值；
• min()：返回最小值；
• tuple()：将列表转换为元组；
• type()：返回对象类型；
• del()：删除整个元组对象，注意不能删除元组内元素；
• sum()：求和。

【相关推荐：Python3视频教程 】

Atas ialah kandungan terperinci Penjelasan terperinci tentang penggunaan senarai dan tupel dalam pembelajaran Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!