4. 列表一学完,Python 会一半,滚雪球学 Python

滚雪球学 Python,目标就是让 Python 学起来之后,越滚越大。

已完成的文章

标题 链接 1. 这才是 Python 学习的正确起手姿势,滚雪球学 Python
https://dream.blog.csdn.net/article/details/109586142

  1. 无门槛学会数据类型与输入、输出函数,滚雪球学 Python
    https://dream.blog.csdn.net/article/details/109697047

  2. 无转折不编程,滚雪球学 Python
    https://dream.blog.csdn.net/article/details/109785235

@

*
已完成的文章
* 四、列表一学完,Python 会一半
4.1 列表是个啥
+ 4.1.1 列表定义
+ 4.1.2 列表读取
+ 4.1.3 列表切片
+ 4.1.4 列表相关内置函数
+ 4.1.5 列表元素的修改与删除
+ 4.1.6 列表相加,相乘,删除
4.2 初识 Python 面向对象
+ 4.2.1 字符串对象的方法
+ 4.2.1 快速获取系统内置方法
4.3 通过方法增删列表元素
+ 4.3.1 列表追加元素
+ 4.3.2 列表插入元素
+ 4.3.3 删除列表元素
4.4 列表排序
+ 4.4.1 sort 排序
+ 4.4.2 sorted 排序
4.5 列表其它方法
+ 4.5.1 列表检索元素索引
+ 4.5.2 列表统计元素出现次数
+ 4.5.3 列表转换为字符串
+ 4.5.4 列表追加列表
4.6 多维列表
4.7 特殊的列表字符串
+ 4.7.1 字符串索引与切片
+ 4.7.2 可用于字符串的部分函数和方法
+ 4.7.3 将字符串转换成列表
4.8 这篇博客的总结

本系列文章将在2021年春节前完成,欢迎关注,点赞,评论 --- 梦想橡皮擦

四、列表一学完,Python 会一半

4.1 列表是个啥

列表,先记住英文为 list ,它是 Python 中一种可以动态添加删除内容的数据类型,由一系列的元素组成。直白点说列表是将多个变量组合在一起的那么一个容器。

很多文章会找一个与列表相似的编程概念,一般会说 Python 中的列表跟其他语言的 数组一样,但对于没有任何编程概念的同学来说, 数组也是一个陌生概念。其实你可以简单理解一下即可,Python 中的列表就是一个容器,里面可以放任意数据类型的变量。

4.1.1 列表定义

列表定义的格式如下

my_list = [元素1,元素2,元素3...]

列表的每一个数据都称作元素或者项,列表用 [] 包裹,每一个元素用英文 , 分隔,列表可以直接打印输出。

my_list = ["apple", "orange", "grape", "pear"]
print(my_list)

列表中的元素可以为相同数据类型,也可为不同数据类型,所以列表嵌套列表也是可行的。

[En]

The elements in a list can be of the same data type or different data types, so it is also possible for lists to be nested within lists.

my_list = [1, "orange", True, 1.0, [1, 2, 3]]
print(my_list)

4.1.2 列表读取

列表的读取需要先学习两个名词,一个是索引,另一个是下标,这两个词是同一个意思,都是为了准确的获取列表中的元素。索引先简单理解成序号一类的概念即可。

[En]

To read the list, you need to learn two nouns, one is the index, the other is the subscript, these two words have the same meaning, in order to accurately obtain the elements in the list. The index can be simply understood as a concept such as a serial number.

首先你要学会的是列表中索引是从 0 开始的,这个概念第一次接触有点楞,熟悉了就会好很多。就像我们数数字都是从 1 开始数,忽然间需要变成从 0 开始数了,需要适应期。

例如在看一下刚才的列表,尝试用中文读取出来每一个元素的索引。

[En]

For example, take a look at the list just now and try to read the index of each element in Chinese.

my_list = ["apple", "orange", "grape", "pear"]

索引为 0 的元素是字符串 apple,索引为 1 的元素是字符串 orange,依次类推。

列表读取的语法格式如下:

# 列表名[索引]
my_list[i]

以上内容转换成 Python 代码为:

my_list = ["apple", "orange", "grape", "pear"]
print("索引为0的元素是:", my_list[0])
print("索引为1的元素是:", my_list[1])
print("索引为2的元素是:", my_list[2])
print("索引为3的元素是:", my_list[3])

通过索引获取元素的时候,一定要注意索引是从 0 开始的,从 0 开始的,虽然反复写,但是还是很容易被忘记…… 唉~

索引除了为正数以外,还可以为负数,获取列表的最后一个元素的索引是 -1,代码如下:

[En]

In addition to being positive, the index can also be negative. The index of the last element of the list is-1. The code is as follows:

nums = [1,2,3,4,5,6]
print("列表最后一个元素为:",nums[-1])

依据顺序,-1 表示最后一个元素,-2 表示倒数第 2 项…

4.1.3 列表切片

编写程序时对列表的操作经常会有如下场景。

  • 获取 1~3 项元素;
  • 获取 4~7 项元素;
  • 获取第 1,3,5…项元素。

这些内容转换到列表的实际编码中,被称为切片操作,就是你脑中现在呈现的切肉片动作。

[En]

These contents are converted to the actual coding of the list, which is called slicing, which is the slicing action that is now present in your brain.

具体的语法格式如下:

# 读取从索引 m 到 n-1 的列表元素
my_list[m:n]
# 读取列表的前 n 项元素
my_list[:n]
# 读取列表从 m 开始到结尾的元素
my_list[m:]
# 间隔 s,读取从 m 到 n 的列表元素
my_list[m:n:s]

以上内容反映到代码中呈现如下,该部分呈现到代码中如下,尤其注意 m 与 n 的取值。

my_list = ["a","b","c","d","e","f"]

# 输出 ['a', 'b', 'c'] 注意 a,b,c 的索引分别是 0,1,2
print(my_list[0:3])
# 输出 ['b', 'c', 'd', 'e'] 注意 b,c,d,e 的下标分别是 1,2,3,4
print(my_list[1:5])
# 输出 ['b', 'c', 'd', 'e', 'f']
print(my_list[1:])
# 输出 ['a', 'b', 'c', 'd', 'e']
print(my_list[:5])
# 输出 ['b', 'd']  从索引 1 到索引 3,间隔 1 个索引取
print(my_list[1:4:2])

列表切片在后续的 Python 学习中属于非常重要的知识点,核心还是理清楚索引是如何对应到列表中每一项元素。

4.1.4 列表相关内置函数

在 Python 中与列表相关的内置函数常见的有 4 个,分别是获取最大值 max、最小值 min、求和 sum 以及获取列表元素个数 len。

最大值与最小值

使用 max 与 min 函数可以直接获取列表中的最大值与最小值,该函数使用有些注意事项需要了解下,具体还是参照代码:

my_list1 = ["a","b","c","d","e","f"]
my_list2 = [1,2,3,4,5,6]
my_list3 = ["a",1,2,3,4]

# 输出 f
print(max(my_list1))
# 输出 6
print(max(my_list2))
# 报错
print(max(my_list3))

上述代码在运行时发现,前面 2 个列表可以输出最大值,但是第三个直接报错,这是因为 max 与 min 只能用于元素全是数字或者全是字符串的列表,如果列表中有其他数据类型或者数字与字符串混合就会报错。

min 用法和 max 完全一致,不在编写代码尝试。

求和
sum 函数可以获取列表元素总和,但是需要注意下 sum 不能用于元素非数值情况,也就说下面的代码是错误的。

my_list1 = ["a","b","c","d","e","f"]
print(sum(my_list1))

获取列表元素个数
该函数使用频次极高,在很多地方都需要获取列表元素个数,使用 len 函数即可,由于代码非常简单,自行测试即可。

4.1.5 列表元素的修改与删除

对于一个列表数据类型的变量来说,它是可以进行修改与删除元素的,这就是本文开篇提及的列表是 Python 中一种可以动态添加删除内容的数据类型(该小节暂时还无法对列表进行动态添加,后文会讲解到)。
列表的元素可以通过索引进行获取修改。

my_list1 = ["a","b","c","d","e","f"]
print("修改前的列表",my_list1)
my_list1[4] = "橡皮擦"
print("修改后的列表",my_list1)

列表元素的删除操作分为两种情况,简单说一种是删除单个元素,一种是删除多个元素。删除与列表切片关联度极高,可比对下述代码进行学习。

[En]

The deletion of list elements can be divided into two cases, one is to delete a single element, and the other is to delete multiple elements. Deletion is highly related to list slices and is comparable to learning from the following code.

my_list1 = ["a","b","c","d","e","f"]

# 通过索引删除某一元素
del my_list1[0]
print(my_list1)

my_list1 = ["a","b","c","d","e","f"]
# 通过索引删除列表区间元素
del my_list1[0:3]
print(my_list1)

my_list1 = ["a","b","c","d","e","f"]
# 通过索引删除列表区间元素
del my_list1[0:3:2]
print(my_list1)

删除操作使用的关键字是 del,关键点相信你也已经发现,通过索引找到元素然后在通过 del删除元素。

以上内容,请注意是对列表中的元素进行操作,下面我们将学习如何对一个完整的列表进行操作。

[En]

The above, please note that you are manipulating the elements in the list. Let’s learn how to manipulate a complete list.

4.1.6 列表相加,相乘,删除

在 Python 中可以直接对列表进行相加与相乘操作,列表与列表之间的相加可以理解为列表的连接,代码如下:

my_list1 = ["a","b"]
my_list2 = ["c"]
my_list3 = my_list1 + my_list2
print(my_list3)

任意多个列表直接如果用 “+” 进行操作,那么这些列表将会连接起来形成一个新的大列表。

列表可以与一个数字进行乘法计算,表示重复前面的列表多次,例如下述代码:

[En]

The list can be multiplied by a number, indicating that the previous list is repeated multiple times, such as the following code:

my_list1 = ["a","b"]
my_list2 = ["c"]
my_list3 = my_list1 * 4
# 输出结果为 ['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']
print(my_list3)

上述代码用 [a,b] * 4 得到结果为列表 [a,b] 重复出现了 4 次。

4.2 初识 Python 面向对象

Python 是一门面向对象的编程语言,所以在 Python 中所有的数据都是对象,例如之前学习到的整数、浮点数、字符串、列表都是对象,关于面向对象的概念不做过多的解释(毕竟现在解释也没啥用,具体等学到面向对象部分在进行说明)。

我们可以给各种对象设计一些 方法,这些 方法 也是广义上的 函数,是不是听起来有些绕,在 Python 中已经为一些基本对象内置了一些方法,从列表开始我们将逐步接触对象的内置方法。

对象方法的调用语法格式为:

对象.方法()

4.2.1 字符串对象的方法

你首先要知道在 Python 中任意一个数据都是对象,那声明一个字符串变量之后,那这个字符串变量就是一个对象,是对象就会有对象的方法。字符串常用的方法有:

  1. lower 将字符串转换成小写
  2. upper 将字符串转换成大写
  3. title 将字符串首字母大写,其余小写
  4. rstrip 移除字符串右侧空白
  5. lstrip 移除字符串左侧空白
  6. strip 移除字符串两侧空白

字符串大小写说明

my_str = "good moring"
my_strU = my_str.upper()
my_strL = my_str.lower()
my_strT = my_str.title()

# 大写
print(my_strU)
# 小写
print(my_strL)
# 首字母大写
print(my_strT)

输出结果对应如下:

GOOD MORING
good moring
Good Moring

移除字符串开始或者结尾的空白是非常有用的方法,该内容留给你自己来完成。代码可以参考 my_str.strip()

4.2.1 快速获取系统内置方法

在实际开发中,我们很难记住一个对象的所有方法,对于橡皮擦来说编写代码的时候也要借助于手册,方法太多不可能记住的,常用的记住就好了,那如何查询一个对象的所有方法呢,用到的是一个内置函数 dir
例如,你想知道一个字符串对象的所有方法,可以编写如下代码。

my_str = "good moring"
print(dir(my_str))

代码运行之后,会得到如下内容,其中红框内容就是刚才提及到的方法。

[En]

After the code runs, you will get the following content, where the red box content is the method just mentioned.

4. 列表一学完,Python 会一半,滚雪球学 Python
对于某个方法是如何使用的,可以调用之前学习的 help 内置函数进行学习,语法格式如下:

help(对象.方法)

例如获取字符串对象的 rfind 方法。

my_str = "good moring"

print(help(my_str.rfind))

结果如下,稍微阅读一下即可了解 rfind 方法的使用方式。

4. 列表一学完,Python 会一半,滚雪球学 Python
查看一下列表的方法
因为后续将继续学习列表的方法,所以先进行简单展示。
my_list1 = ["a","b"]
print(dir(my_list1))

本篇博客后续内容将对红框部分的方法进行讲解,肯定有人会关心没有在红框里面的哪些以两个_开头的是啥,它们也是方法,不过现在还不到学习它们的时候。

4. 列表一学完,Python 会一半,滚雪球学 Python

4.3 通过方法增删列表元素

4.3.1 列表追加元素

在操作列表时候经常会出现如下场景,需要往已经存在的列表中追加元素,例如原列表有一个元素,现在想追加到两个。如果直接设置,会出错提示索引值超过列表长度,请注意该错误在操作列表时经常出现。

[En]

The following scenarios often occur when manipulating a list, where you need to append elements to an existing list. For example, there is one element in the original list, but now you want to append it to two. If you set it directly, there will be an error indicating that the index value exceeds the length of the list. Note that this error often occurs when manipulating the list.

my_list = ["apple", "orange", "grape"]
my_list[3] = "pear"

该错误提示为 IndexError: list assignment index out of range ,这里需要注意下,在学习或编写代码的过程中要熟悉一些常见的错误,以便当这些错误出现的时候能够快速发现原因。

在列表追加元素,Python 中列表对象内置了一个方法,具体格式如下。

my_list.append("新增元素")

例如接下来可以声明一个空列表,然后往该列表追加元素。

my_list = []
my_list.append("pear")
my_list.append("apple")
my_list.append("orange")

print(my_list)

通过 append 方法,每次都会在列表的末端追加一个元素,用该方法就可以无限制的将列表扩展下去。

4.3.2 列表插入元素

append 方法是在列表末尾固定插入元素,如何在任意位置插入元素是一个新的方法,名称叫做 insert,语法格式如下:

my_list.insert(索引位置,"新增元素")

尝试在索引 1,索引 2,索引 0 的位置插入元素,代码如下:

my_list = ["pear", "apple", "orange"]
my_list.insert(0, "插入")
print(my_list)
my_list = ["pear", "apple", "orange"]
my_list.insert(2, "插入")
print(my_list)

这里需要注意下当索引超过列表长度时,默认插入末尾。

4.3.3 删除列表元素

之前的内容中已经介绍过一种删除列表元素的方式,通过关键字 del,该方式存在一个问题就是删除元素之后没有获取到被删除的元素。接下来的方法将解决该问题,你将能获取到被删除的值,该方法是 pop ,语法格式如下:

item = my_list.pop()
item = my_list.pop(索引)

注意在 pop 方法中可以携带一个索引值,直接删除索引位置的元素,如果没有默认删除最后一项。变量 item 用于获取被删除的值。注意该方法删除元素的时候,索引不能超过列表长度。

my_list = ["pear", "apple", "orange"]
item = my_list.pop()
print(item)

print("删除元素之后")
print(my_list)

代码运行结果为:

orange
删除元素之后
['pear', 'apple']

pop 方法是按照索引删除元素,你还可以直接删除指定元素,具体方法是 remove,该方法的语法格式如下。

my_list.remove(待删除元素内容)

注意 remove 删除元素之后,不会返回被删除的元素,还存在一个问题是如果待删除的元素不在列表中,会提示代码错误。

如果待删除的元素在列表中出现多个,默认只删除第一个,如果想要删除多个,需要用到后面的循环知识。

[En]

If there are multiple elements to be deleted in the list, only the first one is deleted by default. If you want to delete more than one, you need to use the following loop knowledge.

4.4 列表排序

对于列表除了增删改以外还会涉及排序相关内容,该操作对于列表对象也非常简单,使用固定的方法即可。

[En]

In addition to adding, deleting and modifying the list, it will also involve sorting related content, and this operation is also very simple for list objects, using fixed methods.

4.4.1 sort 排序

sort 方法可以对列表元素进行排序,默认从小到大,当然也可以修改成从大到小,该方法一般用于纯数字或者纯英文字符列表排序,如果列表中的元素数据类型比较复杂,该方式不在适用,需要注意一下。

sort 方法的语法格式如下:

my_list.sort()

声明一个所有元素都是数字的列表,然后进行排序。

my_list = [3, 4, 1, 2, 9, 8, 7]
print("排序前:", my_list)

my_list.sort()
print("排序后:", my_list)

输出结果如下:

排序前: [3, 4, 1, 2, 9, 8, 7]
排序后: [1, 2, 3, 4, 7, 8, 9]

如果希望按照从大到下进行排序,只需要增加参数(参数概念后面还会继续学习) reverse=True 即可。

my_list = [3, 4, 1, 2, 9, 8, 7]
print("排序前:", my_list)

my_list.sort(reverse=True)
print("排序后:", my_list)

英文字符串的排序结果希望你可以进行一下测试,需要注意对英文字符列表进行排序,建议将字符串英文全部修改为小写。

[En]

I hope you can test the sorting results of English strings. You need to pay attention to sorting the list of English characters. It is recommended that all strings be changed to lowercase.

注意上述 sort 方法排序之后是对原列表中元素顺序修改,即修改的是 my_list 列表的顺序,如果不想修改原列表的顺序,想要新生成一个列表,需要用到的是下述方法。

4.4.2 sorted 排序

sort 排序将造成列表元素顺序永久修改,很多时候并不需要修改原列表,这种情况下需要借助 sorted 函数,注意 sorted 是一个内置函数,并不是列表对象的一个方法,也就是说 sorted 可以用于很多对象的排序。

sorted 函数的语法格式如下:

sorted(待排序列表) # 正序,从小到大
sorted(待排序列表,reverse=True) # 逆序,从大到小

该函数使用之后会返回一个新的列表,你可以用新变量接收一下,具体代码如下:

[En]

After using this function, a new list will be returned. You can receive it with the new variable. The specific code is as follows:

my_list = [3, 4, 1, 2, 9, 8, 7]
print("排序前:", my_list)

new_list = sorted(my_list)
print("排序后:", my_list)
print("排序后:", new_list)

注意排序后新变量为 new_list 对于原 my_list 列表中元素的顺序并无影响。

4.5 列表其它方法

4.5.1 列表检索元素索引

通过 index 方法可以获取某内容在列表中第一次出现的索引值,格式如下:

索引值 = my_list.index(待查找值)

该方法注意如果没有检索到索引值,会提示错误。

my_list = [3, 4, 1, 2, 9, 8, 7]
ke = my_list.index(4)
ke = my_list.index(10)
print(ke)

4.5.2 列表统计元素出现次数

通过 count 方法可以获取列表特定元素出现的次数,它的语法格式如下:

次数 = my_list.count(待查找值)

该方法同样当在列表中找不到待查找值时会返回 0。

my_list = [3, 4, 3, 2, 3, 8, 7]
nums = my_list.count(3)

print(nums)

4.5.3 列表转换为字符串

通过 join 方法可以将列表中的所有元素组合成一个字符串,语法格式如下:

连接字符串.join(待转换列表)

该方法其实准确的说应该是 字符串对象的一个方法。

my_list = ["pear", "apple", "orange"]
my_str = "#".join(my_list)

print(my_str)

该方法在使用的时候需要注意,列表中所有元素都必须是字符串,否则会出现 expected str instance, int found 错误。

4.5.4 列表追加列表

append 方法可以给列表追加元素,extend 可以给一个列表追加一个列表,相当于将两个列表进行连接。

列表1.extend(列表2)

注意追加的列表默认在原列表末尾追加,所以追加之后原列表中的元素已经发生了改变。

[En]

Note that the appended list is appended at the end of the original list by default, so the elements in the original list have changed since the append.

my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]

my_list1.extend(my_list2)
print(my_list1)

4.6 多维列表

列表中的元素可以为任意数据类型,故列表嵌套列表也是可以的。

my_list = [1,2,3,[4,5,6]]

该方法需要注意获取嵌套列表中的元素的时候,需要按照层级获取,例如希望获取元素 5,首先要获取最外层列表中的第 4 项元素,即 my_list[3],然后获取到它之后再获取它索引位置为 1 的元素,即 my_list[3][1],具体代码可以自行尝试,也可以在内层列表中在嵌套列表,无限循环下去。

4.7 特殊的列表字符串

现在回过头来再看一下字符串格式为 "abcsdasa",可以将字符串看成一个字符组成的列表,一般也称作字符序列(有顺序的列表),字符串也不能完全等价于列表,因为字符串中不能修改单个元素。

4.7.1 字符串索引与切片

字符串也可以通过索引访问某个元素,索引使用方式与列表一致,例如下述代码:

[En]

A string can also access an element through an index, which is used in the same way as the list, such as the following code:

my_str = "abcdefghi"
print(my_str[5])
print(my_str[4])
print(my_str[3])

列表切片也可用于字符串,相当于获取字符串子串。

4.7.2 可用于字符串的部分函数和方法

列表相关的内置方法,例如 len、max、min 也可用于字符串,具体内容你可自行尝试。

4.7.3 将字符串转换成列表

通过内置函数 list 可以将字符串转换成列表,也就是将字符串中每个字符都拆解开。

my_str = "abcdefghi"
print(list(my_str))

输出内容为:

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

4.8 这篇博客的总结

列表在 Python 基础部分属于非常重要的数据类型,在写这篇博客的时候也在考虑是否将所有内容都包含进去,结果发现内容太多了,很多都与后面产生的极强的关联性,在本篇博客中也初步了解了面向对象的一些最简单概念。

本篇博客省略的部分,后续将补充完整,具体内容先埋个坑。

  • 深复制与浅复制
  • 地址的概念
  • in、not in 表达式
  • is、is not 表达式
  • enumerate 对象

希望在讲解这些内容的时候,还能看到坚持学习的你的留言。

最后一碗毒鸡汤

只要我肯努力 就没有搞不砸的事情 O(∩_∩)O 哈哈~ 👗👗

想学Python爬虫,可以订阅橡皮擦专栏哦~ 👗👗👗 点击发现惊喜 👗👗👗

💎💎💎💎💎💎💎💎💎💎💎

今天是持续写作的第 3/100 天。
如果你有想要交流的想法、技术,欢迎在评论区留言。

如果你想跟博主建立亲密关系,可以关注同名公众号 ” 梦想橡皮擦“,近距离接触一个逗趣的互联网高级网虫。
博主 ID:梦想橡皮擦,希望大家点赞、评论、收藏。

Original: https://www.cnblogs.com/happymeng/p/15374069.html
Author: 梦想橡皮擦
Title: 4. 列表一学完,Python 会一半,滚雪球学 Python

原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/116684/

转载文章受原作者版权保护。转载请注明原作者出处!

(0)

大家都在看

免费咨询
免费咨询
扫码关注
扫码关注
联系站长

站长Johngo!

大数据和算法重度研究者!

持续产出大数据、算法、LeetCode干货,以及业界好资源!

2022012703491714

微信来撩,免费咨询:xiaozhu_tec

分享本页
返回顶部