《Python零基础快乐学习之旅》学习笔记6——列表（list）

已于 2022-08-12 08:57:27 修改
阅读量1.3k 收藏 1
点赞数 1
分类专栏： Python 读书笔记 文章标签： python 列表
于 2020-12-23 14:37:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/username666/article/details/111463110
版权

列表（list）

1. 认识列表（list）

列表（List）是Python的一种可以更改内容的数据类型，是由一系列元素所组成的序列数据。Python的列表功能除了可以存储相同数据类型，例如：整数、浮点数、字符串，通常称每一种数据为元素。
一个列表也可以存储不同数据类型，例如：列表内同时含有整数、浮点数和字符串。

1.1 列表基本定义

定义列表的语法格式如下：

list_name = [元素1,......,元素n,]

列表的每一组数据称为元素，这些元素放在中括号[]内，彼此之间用英文逗号“,”隔开（最后一个元素后可加可不加）。使用print()函数，将列表名称作为变量名，即可打印列表内容。

>>> fruits = ['apple', 'banana', 'orange', 'pear']
>>> print(fruits)
['apple', 'banana', 'orange', 'pear']
>>> heroes = ['关羽', '张飞', '赵云', '马超', '黄忠']
>>> print(heroes)
['关羽', '张飞', '赵云', '马超', '黄忠']

列表内可以有不同的数据类型：

>>> list1 = ['Java', 'PHP', 'C/C++', 'Go', 1, 2, 3]
>>> print(list1)
['Java', 'PHP', 'C/C++', 'Go', 1, 2, 3]

# ch6_1.py
james = [23, 19, 22, 31, 18] # 定义james列表
print("打印james列表", james)
James = ['Lebron James', 23, 19, 22, 31, 18] # 定义James列表
print("打印James列表", James)
fruits = ['apple', 'banana', 'orange', 'pear'] # 定义fruits列表
print("打印fruits列表", fruits)
cfruits = ['菠萝', '榴莲', '芒果', '西瓜'] # 定义cfruits列表
print("打印cfruits列表", cfruits)
score = [80.5, 89.5, 59.5, 88.0, 90] # 定义score列表
print("打印score列表", score)
# 列表中有列表
test = ['A', 'B', 'C', 'D',['Java', 'PHP', 'Python', 'C/C++', 'Go']]
print("打印test列表", test)
# 列出列表数据类型
print("列表test的数据类型为：", type(test))

执行结果：

===================== RESTART: E:/Python-Files/ch6/ch6_1.py ====================
打印james列表 [23, 19, 22, 31, 18]
打印James列表 ['Lebron James', 23, 19, 22, 31, 18]
打印fruits列表 ['apple', 'banana', 'orange', 'pear']
打印cfruits列表 ['菠萝', '榴莲', '芒果', '西瓜']
打印score列表 [80.5, 89.5, 59.5, 88.0, 90]
打印test列表 ['A', 'B', 'C', 'D', ['Java', 'PHP', 'Python', 'C/C++', 'Go']]
列表test的数据类型为： <class 'list'>
>>>

1.2 读取列表元素

可以通过列表名称与索引读取列表元素的内容，在Python中，元素的索引值是从0开始的。

读取列表元素的应用：

# ch6_2.py
fruits = ['apple', 'orange', 'pear'] # 定义fruits列表
print("打印fruits[0]",fruits[0]);
print("打印fruits[1]",fruits[1]);
print("打印fruits[2]",fruits[2]);


===================== RESTART: E:/Python-Files/ch6/ch6_2.py ====================
打印fruits[0] apple
打印fruits[1] orange
打印fruits[2] pear
>>>

传统处理列表元素内容方式与Python多重指定概念：

# ch6_2.py
fruits = ['apple', 'orange', 'pear'] # 定义fruits列表
print("打印fruits[0]",fruits[0]);
print("打印fruits[1]",fruits[1]);
print("打印fruits[2]",fruits[2]);

# 传统设计方式
fruit1 = fruits[0]
fruit2 = fruits[1]
fruit3 = fruits[2]
print("打印fruits中的元素",fruit1,fruit2,fruit3)

# Python多重指定
fruit1, fruit2, fruit3 = fruits; # 多重指定变量的数量需与列表元素的个数相同
print("打印fruits中的元素",fruit1,fruit2,fruit3)


===================== RESTART: E:/Python-Files/ch6/ch6_2.py ====================
打印fruits[0] apple
打印fruits[1] orange
打印fruits[2] pear
打印fruits中的元素 apple orange pear
打印fruits中的元素 apple orange pear
>>>

1.3 列表切片（list slices）

在设计程序时，常会需要取得列表前几个元素、后几个元素、某区间元素或是依照一定规则排序的元素，所取得的系列元素也可称子列表，这个概念称列表切片。

  • name_list[start:end]：读取从索引start到（end-1）索引的列表元素
  • name_list[:n]：获取列表前n个元素
  • name_list[n:]：获取列表索引n到最后
  • name_list[-n:]：获取列表后n个元素
  • name[:]：获取所有元素
  • name_list[start: end :step]：每隔step，读取从索引start到（end-1）索引的列表元素
# ch6_4.py
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] # 定义week列表
print("打印week第1-3个元素",week[0:3])
print("打印week第2-5个元素",week[1:5])
print("打印week第3,5,7元素",week[2:7:2])
print("打印week前3个元素",week[:3])
print("打印week后3个元素",week[-3:])
print("打印week第3个元素至末尾",week[2:])
print("打印week所有元素",week[:])
print("打印week最后一个元素",week[-1])


================================== RESTART: E:/Python-Files/ch6/ch6_4.py =================================
打印week第1-3个元素 ['Monday', 'Tuesday', 'Wednesday']
打印week第2-5个元素 ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
打印week第3,5,7元素 ['Wednesday', 'Friday', 'Sunday']
打印week前3个元素 ['Monday', 'Tuesday', 'Wednesday']
打印week后3个元素 ['Friday', 'Saturday', 'Sunday']
打印week第3个元素至末尾 ['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
打印week所有元素 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
打印week最后一个元素 Sunday
>>>

1.4 max()、min()、sum()

Python有内建一些执行统计运算的函数。

  • 如果列表内容全部是数值，则可以使用 max() 函数获得列表的最大值，min() 函数可以获得列表的最小值，sum() 函数可以获得列表的总和。
  • 如果列表内容全部是字符或字符串，则可以使用max()函数获得列表的Unicode码值的最大值，min()函数可以获得列表的Unicode码值最小值。sum()函数不可以在列表元素为非数值的情况下使用。
# ch6_7.py
scores = [59, 87, 89, 63, 74, 98]
print("最高分：",max(scores))
print("最低分：",min(scores))
print("总分：",sum(scores))

scores = ['Jack', 89, 92, 103, 68, 77, 88]
# 列表中元素有字符串，可使用切片方式处理
print("最高分：",max(scores[1:])) # 读取索引1到最后
print("最低分：",min(scores[-6:])) # 读取列表后6个元素
print("总分：",sum(scores[1:7]))   # 读取从索引1到索引6的列表元素

执行结果：

===================== RESTART: E:/Python-Files/ch6/ch6_7.py ====================
最高分： 98
最低分： 59
总分： 470
最高分： 103
最低分： 68
总分： 517
>>>

1.5 列表长度len()

使用len()函数可以获取列表的元素个数。

scores = [89, 92, 103, 68, 77, 88]
len = len(scores);
print("共记录了%d科成绩" % len) # 打印列表元素个数


===================== RESTART: E:/Python-Files/ch6/ch6_7.py ====================
共记录了6科成绩
>>>

1.6 更改列表元素的内容

可以使用列表名称和索引值更改列表元素的内容。

# ch6_9.py
fruits = ['apple', 'orange', 'pear', 'banana']
print("水果列表：",fruits)
fruits[2] = 'peach';
print("水果列表：",fruits)


===================== RESTART: E:/Python-Files/ch6/ch6_9.py ====================
水果列表： ['apple', 'orange', 'pear', 'banana']
水果列表： ['apple', 'orange', 'peach', 'banana']
>>>

1.7 列表的相加

Python允许列表相加，相当于将列表结合。

# ch6_11.py
cars1 = ['Toyota', 'Nissan', 'Honda']
print("汽车销售品牌",cars1)
cars2 = ['Audi', 'BMW']
cars1 += cars2;
print("汽车销售品牌",cars1)


==================== RESTART: E:/Python-Files/ch6/ch6_11.py ====================
汽车销售品牌 ['Toyota', 'Nissan', 'Honda']
汽车销售品牌 ['Toyota', 'Nissan', 'Honda', 'Audi', 'BMW']
>>>

1.8 删除列表元素

可以使用下列方式删除指定索引的列表元素：

del name_list[i] # 删除索引i的列表元素

以这种方式删除列表元素最大的缺点是，元素删除后，我们无法得知删除的是什么内容。

# ch6_11.py
cars1 = ['Toyota', 'Nissan', 'Honda']
print("汽车销售品牌",cars1)
cars2 = ['Audi', 'BMW']
cars1 += cars2;
print("汽车销售品牌",cars1)
del cars1[1] # 删除索引1的列表元素
print("汽车销售品牌",cars1)


==================== RESTART: E:/Python-Files/ch6/ch6_11.py ====================
汽车销售品牌 ['Toyota', 'Nissan', 'Honda']
汽车销售品牌 ['Toyota', 'Nissan', 'Honda', 'Audi', 'BMW']
汽车销售品牌 ['Toyota', 'Honda', 'Audi', 'BMW']
>>>

2. 列表操作之添加与删除

2.1 列表操作之添加

2.1.1 append()

Python为列表内建了新增元素的方法append()，该方法可在列表末端直接新增元素。

name_list.append('新增元素')


# ch6_17.py
fruits = [] # 定义空列表
print("当前列表内容：",fruits)
fruits.append('Apple')
print("当前列表内容：",fruits)
fruits.append('Banana')
print("当前列表内容：",fruits)
fruits.append('Orange')
print("当前列表内容：",fruits)

执行结果：

==================== RESTART: E:/Python-Files/ch6/ch6_17.py ====================
当前列表内容： []
当前列表内容： ['Apple']
当前列表内容： ['Apple', 'Banana']
当前列表内容： ['Apple', 'Banana', 'Orange']
>>>

2.1.2 insert()

append()方法是固定在列表末端插入元素，insert()方法则可以在任意位置插入元素。

insert(索引,元素内容)


# ch6_17.py
fruits = [] # 定义空列表
print("当前列表内容：",fruits)
fruits.append('Apple')
print("当前列表内容：",fruits)
fruits.append('Banana')
print("当前列表内容：",fruits)
fruits.append('Orange')
print("当前列表内容：",fruits)
fruits.insert(2, 'peach')
print("当前列表内容：",fruits)
fruits.insert(0,'pear')
print("当前列表内容：",fruits)
fruits.insert(6,'pear')
print("当前列表内容：",fruits)

执行结果：

==================== RESTART: E:/Python-Files/ch6/ch6_17.py ====================
当前列表内容： []
当前列表内容： ['Apple']
当前列表内容： ['Apple', 'Banana']
当前列表内容： ['Apple', 'Banana', 'Orange']
当前列表内容： ['Apple', 'Banana', 'peach', 'Orange']
当前列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange']
当前列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange', 'pear']
>>>

2.1.3 extend()

在列表结尾追加数据，如果数据是一个序列，则将该序列的数据逐一添加到列表。

# 列表序列.extend(数据)
name_list2 = ['张飞', '刘备', '武松', '贾宝玉']
name_list2.extend("李白")
print(name_list2) # ['张飞', '刘备', '武松', '贾宝玉', '李', '白']
list_2 = ['张无忌', '赵信']
name_list2.extend(list_2)
print(name_list2) # ['张飞', '刘备', '武松', '贾宝玉', '李', '白', '张无忌', '赵信']

列表操作之增加–示例：

# 增加指定数据到列表中
name_list = ['Tom', 'Lily', 'Rose']

# append()：列表结尾追加数据，如果追加的数据是一个序列，则追加整个序列到列表
name_list.append('James')
print(name_list)  # ['Tom', 'Lily', 'Rose', 'James']
list_1 = ['Jojo', 'Jack', 'Micheal']
name_list.append(list_1)
print(name_list)  # ['Tom', 'Lily', 'Rose', 'James', ['Jojo', 'Jack', 'Micheal']]

# extend()：列表结尾追加数据，如果数据是一个序列，则将该序列的数据逐一添加到列表
# 列表序列.extend(数据)
name_list2 = ['张飞', '刘备', '武松', '贾宝玉']
name_list2.extend("李白")
print(name_list2)  # ['张飞', '刘备', '武松', '贾宝玉', '李', '白']
list_2 = ['张无忌', '赵信']
name_list2.extend(list_2)
print(name_list2)  # ['张飞', '刘备', '武松', '贾宝玉', '李', '白', '张无忌', '赵信']
# insert()：指定位置新增数据
# 列表序列.insert(位置下标,数据)
name_list3 = ['后羿', '蔡文姬', '兰陵王']
name_list3.insert(3, '李云龙')
print(name_list3)  # ['后羿', '蔡文姬', '兰陵王', '李云龙']
name_list3.insert(1, ['夏侯惇', '公孙策'])
print(name_list3)  # ['后羿', ['夏侯惇', '公孙策'], '蔡文姬', '兰陵王', '李云龙']

2.2 列表操作之删除

2.2.1 del

list1 = ['三国演义', '西游记', '红楼梦', '水浒传', '金瓶梅', '神雕侠侣']

# del
# del 目标
del(list1[4])
print(list1) # ['三国演义', '西游记', '红楼梦', '水浒传', '神雕侠侣']

2.2.2 pop()

使用pop()方法删除元素最大的优点是，删除后将弹出所删除的值。使用pop()时，若未指明所删除元素的位置，一律删除列表末端的元素。pop()的使用方式如下：

value = name_list.pop() # 没有索引则删除列表末端元素
value = name_list.pop(i) # 删除指定索引值的列表元素


# ch6_17.py
fruits = [] # 定义空列表
print("当前列表内容：",fruits)
fruits.append('Apple')
print("当前列表内容：",fruits)
fruits.append('Banana')
print("当前列表内容：",fruits)
fruits.append('Orange')
print("当前列表内容：",fruits)
fruits.insert(2, 'peach')
print("当前列表内容：",fruits)
fruits.insert(0,'pear')
print("当前列表内容：",fruits)
fruits.insert(6,'pear')
print("当前列表内容：",fruits)
popped_fruit = fruits.pop() # 删除列表末端值
print("所删除的列表内容为：",popped_fruit)
print("新的列表内容：",fruits)
popped_fruit = fruits.pop(2) # 删除列表索引为2的值
print("所删除的列表内容为：",popped_fruit)
print("新的列表内容：",fruits)


==================== RESTART: E:/Python-Files/ch6/ch6_17.py ====================
当前列表内容： []
当前列表内容： ['Apple']
当前列表内容： ['Apple', 'Banana']
当前列表内容： ['Apple', 'Banana', 'Orange']
当前列表内容： ['Apple', 'Banana', 'peach', 'Orange']
当前列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange']
当前列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange', 'pear']
所删除的列表内容为： pear
新的列表内容： ['pear', 'Apple', 'Banana', 'peach', 'Orange']
所删除的列表内容为： Banana
新的列表内容： ['pear', 'Apple', 'peach', 'Orange']
>>>

2.2.3 remove()

在删除列表元素时，有时可能不知道元素在列表内的位置，此时可以使用remove()方法删除指定的元素，它的使用方式如下：

name_list.remove(想删除的元素内容)

如果列表内有相同的元素，则只删除第一个出现的元素，如果想要删除所有相同的元素，必须使用循环。

# ch6_20.py
cars = ['Honda', 'bmw', 'Toyota', 'bmw']
cars.remove('bmw')
print(cars)


==================== RESTART: E:/Python-Files/ch6/ch6_20.py ====================
['Honda', 'Toyota', 'bmw']
>>>

2.2.4 clear()

clear()函数可以清空列表。

list1 = ['三国演义', '西游记', '红楼梦', '水浒传', '金瓶梅', '神雕侠侣']
# clear()：清空列表
list1.clear()
print(list1)  # []

列表操作之删除–示例：

list1 = ['三国演义', '西游记', '红楼梦', '水浒传', '金瓶梅', '神雕侠侣']

# del
# del 目标
del(list1[4])
print(list1) # ['三国演义', '西游记', '红楼梦', '水浒传', '神雕侠侣']

# 删除指定数据
# pop()：删除指定下标的数据（默认最后一个），并返回该数据
# 无论是按照下标还是删除最后一个，pop函数都会返回这个被删除的数据
# 列表序列.pop(下标)
list1.pop()
print(list1) # ['三国演义', '西游记', '红楼梦', '水浒传']
del_name = list1.pop(2)
print(del_name)  # 红楼梦
print(list1) # ['三国演义', '西游记', '水浒传']

# remove()：移除列表中某个数据的第一个匹配项
# 列表序列.remove(数据)
list1.remove('西游记')
print(list1) # ['三国演义', '水浒传']

# clear()：清空列表
list1.clear()
print(list1)  # []

3. 列表排序

3.1 reverse()

reverse()可以颠倒排序列表元素，它的使用方式如下：

name_list.reverse()

列表经过颠倒排序后，就算是永久性更改了，需要再次执行reverse()方法才能复原。

# ch6_21.py
weekday = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
print("当前列表内容：",weekday)

# 倒排
weekday.reverse()
print("当前列表内容：",weekday)

# 复原
weekday.reverse()
print("当前列表内容：",weekday)


==================== RESTART: E:/Python-Files/ch6/ch6_21.py ====================
当前列表内容： ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
当前列表内容： ['Sunday', 'Saturday', 'Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
当前列表内容： ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
>>>

3.2 sort()

sort()方法可以对列表元素由小到大进行排序，对于纯数值和纯英文字符串元素排序有非常好的效果。经排序后，原列表的元素顺序会被永久更改。sort()方法的使用：列表对象.sort()。如果是对英文字符串进行排序，建议先将字符串英文字符全部转成小写或全部转成大写。

# ch6_22.py
languages = ['java', 'php', 'python', 'c/c++', 'go']
print("目前列表内容：",languages)
# 使用sort()排序
languages.sort()
print("目前列表内容：",languages)

nums = [3, 2, 1, 9, 8, 6]
print("目前列表内容：",nums)
# 使用sort()排序
nums.sort()
print("目前列表内容：",nums)
# sort()方法允许由大到小排序，只需在sort()内添加参数“reverse=True"即可
nums.sort(reverse=True)
print("目前列表内容：",nums)


==================== RESTART: E:/Python-Files/ch6/ch6_22.py ====================
目前列表内容： ['java', 'php', 'python', 'c/c++', 'go']
目前列表内容： ['c/c++', 'go', 'java', 'php', 'python']
目前列表内容： [3, 2, 1, 9, 8, 6]
目前列表内容： [1, 2, 3, 6, 8, 9]
目前列表内容： [9, 8, 6, 3, 2, 1]
>>>

3.3 sorted()

sorted()函数与sort()的区别在于：返回排序后的新列表，而不对原列表进行修改。

list1 = [2022, 8, 12, 8, 44, 110, 119]
list2 = [10, 9, 8, 7, 24, 37]
# sort()：直接在原列表上操作，会更改原列表
list1.sort()
print(list1)  # [8, 8, 12, 44, 110, 119, 2022]
# sorted()：返回排序后的新列表，不对原列表进行更改
list3 = sorted(list2)
print(list3)  # [7, 8, 9, 10, 24, 37]
print(list2)  # [10, 9, 8, 7, 24, 37]

4. 列表操作之查找

4.1 index()

这个方法可以返回特定元素内容第一次出现的索引值，它的使用格式如下：

索引值 = 列表名称.index(搜索值)


# ch6_24.py
city = ['beijing', 'shanghai', 'nanjing', 'guangzhou', 'chongqin', 'chengdu']
search_str = 'guangzhou'
i = city.index(search_str)
print("所搜寻元素 %s 第一次出现位置的索引为 %d" % (search_str, i))

nums = [3, 8, 4, 6, 1024]
search_val = 8
j = nums.index(search_val)
print("所搜寻元素 %d 第一次出现在列表中位置的索引为 %d" % (search_val, j))


==================== RESTART: E:/Python-Files/ch6/ch6_24.py ====================
所搜寻元素 guangzhou 第一次出现位置的索引为 3
所搜寻元素 8 第一次出现在列表中位置的索引为 1
>>>

4.2 count()

该方法可以返回特定元素内容出现的次数。使用格式：次数 = 列表名称.count(搜寻值)

nums = [3, 8, 4, 6, 10, 2, 4]
search_val = 8
num = nums.count(search_val)
print("所搜寻元素 %d 在列表中出现的次数为 %d" % (search_val, num))


所搜寻元素 8 在列表中出现的次数为 1

4.4 in和not in语句

主要用于判断一个对象是否属于另一个对象，对象可以是字符串、列表、元组、字典。其语法格式如下：

  • boolean_value = obj1 in obj2 --> 对象obj1在对象obj2内会返回True
  • boolean_value = obj1 not in obj2 --> 对象obj1不在对象obj2内会返回True
# ch6_38.py
fruits = ['apple', 'banana', 'watermelon', 'pear']
fruit = input("请输入水果名称：")
# 判断元素是否存在列表中，如果不存在，则将它加入列表内。
if fruit in fruits:
    print("该水果已存在！")
else:
    fruits.append(fruit)
    print("已成功将 %s 加入水果清单！" % fruit, fruits)


==================== RESTART: E:/Python-Files/ch6/ch6_30.py ====================
请输入水果名称：peach
已成功将 peach 加入水果清单！ ['apple', 'banana', 'watermelon', 'pear', 'peach']
>>>

列表操作之查找–示例：

# 查找
animal_list = ['Tiger', 'Panda', 'Frog', 'Cat', 'Dog', 'Monkey', 'Rabbit']
fruits_list = ['apple', 'peach', 'pineapple', 'pear', 'grape']
flowers_list = ['rose', 'peony', 'carnation', 'chrysanthemum', 'artichoke', 'sakura']
# 1.下标
print(animal_list[2])  # Frog

# 2.函数
# index()：返回指定数据所在位置的下标，不存在会报错
print(animal_list.index('Dog'))  # 4

# count()：统计指定数据在当前列表中出现的次数
print(fruits_list.count('pear'))  # 1

# len()：返回列表长度，即列表中数据个数
print(len(animal_list))  # 7

# 3.判断是否存在
# in：判断指定数字在某个列表序列，存在返回True，否则返回False
print('horse' in animal_list)  # False

# not in：判断指定数字不在某个列表序列，不存在返回True，否则返回False
print('pear' not in flowers_list)  # True

5. 列表的赋值与复制

5.1 列表赋值

# ch6_26.py
sports = ['basketball', 'baseball', 'football']
sports2 = sports
print(sports)
print(sports2)

# 添加元素
sports.append('table tennis')
sports2.append('badminton')
print(sports)
print(sports2)


==================== RESTART: E:/Python-Files/ch6/ch6_26.py ====================
['basketball', 'baseball', 'football']
['basketball', 'baseball', 'football']
['basketball', 'baseball', 'football', 'table tennis', 'badminton']
['basketball', 'baseball', 'football', 'table tennis', 'badminton']
>>>

使用这种方式，只要其中一个列表发生改变，同时也会影响到另一个列表同步更改。

5.2 列表的复制

复制的概念是，执行复制后，产生新的列表对象，当一个列表改变时，不会影响到另一个列表的内容（相当于副本）。

# ch6_26.py
sports = ['basketball', 'baseball', 'football']
# 复制列表
sports2 = sports[:]
print(sports)
print(sports2)

# 添加元素
sports.append('table tennis')
sports2.append('badminton')
print(sports)
print(sports2)


==================== RESTART: E:/Python-Files/ch6/ch6_26.py ====================
['basketball', 'baseball', 'football']
['basketball', 'baseball', 'football']
['basketball', 'baseball', 'football', 'table tennis']
['basketball', 'baseball', 'football', 'badminton']
>>>

6. 再谈字符串

在Python的应用中，可以将单一字符串当作是一个序列，这个序列由字符所组成，可想成字符序列。但与列表不同的是：字符串内的单一元素内容是不可更改的。

6.1 字符串的索引

可以使用索引值的方式取得字符串内容，索引方式则与列表相同。

使用正负值索引列车字符串元素内容：

# ch6_29.py
string = "Python"
# 正值索引
print(" string[0] = ", string[0],
      "\n string[1] = ", string[1],
      "\n string[2] = ", string[2],
      "\n string[3] = ", string[3],
      "\n string[4] = ", string[4],
      "\n string[5] = ", string[5])

# 负值索引
print(" string[-1] = ", string[-1],
      "\n string[-2] = ", string[-2],
      "\n string[-3] = ", string[-3],
      "\n string[-4] = ", string[-4],
      "\n string[-5] = ", string[-5],
      "\n string[-6] = ", string[-6])

# 多重指定概念
s1, s2, s3, s4, s5, s6 = string
print("多重指定概念的输出测试：",s1,s2,s3,s4,s5,s6)


==================== RESTART: E:/Python-Files/ch6/ch6_29.py ====================
 string[0] =  P 
 string[1] =  y 
 string[2] =  t 
 string[3] =  h 
 string[4] =  o 
 string[5] =  n
 string[-1] =  n 
 string[-2] =  o 
 string[-3] =  h 
 string[-4] =  t 
 string[-5] =  y 
 string[-6] =  P
多重指定概念的输出测试： P y t h o n
>>>

6.2 字符串切片

# ch6_30.py
string = "Deep Learning" # 定义字符串
print("打印string第0-2元素：", string[0:3])
print("打印string第1-3元素：", string[1:4])
print("打印string第1,3,5元素：", string[1:6:2])
print("打印string第1到最后元素：", string[1:])
print("打印string前3元素：", string[0:3])
print("打印string后3元素：", string[-3:])


==================== RESTART: E:/Python-Files/ch6/ch6_30.py ====================
打印string第0-2元素： Dee
打印string第1-3元素： eep
打印string第1,3,5元素： epL
打印string第1到最后元素： eep Learning
打印string前3元素： Dee
打印string后3元素： ing
>>>

6.3 函数或方法

# ch6_30.py
string = "Deep Learning" # 定义字符串
print("打印string第0-2元素：", string[0:3])
print("打印string第1-3元素：", string[1:4])
print("打印string第1,3,5元素：", string[1:6:2])
print("打印string第1到最后元素：", string[1:])
print("打印string前3元素：", string[0:3])
print("打印string后3元素：", string[-3:])

# 计算字符串长度
strlen = len(string)
print("字符串长度：",strlen)
# 最大值
maxstr = max(string)
print("字符串中最大的unicode码值和字符", ord(maxstr), maxstr)
# 最小值
minstr = min(string)
print("字符串中最小的unicode码值和字符", ord(minstr), minstr)


==================== RESTART: E:/Python-Files/ch6/ch6_30.py ====================
打印string第0-2元素： Dee
打印string第1-3元素： eep
打印string第1,3,5元素： epL
打印string第1到最后元素： eep Learning
打印string前3元素： Dee
打印string后3元素： ing
字符串长度： 13
字符串中最大的unicode码值和字符 114 r
字符串中最小的unicode码值和字符 32  
>>>

6.4 字符串转列表

list()函数可以将参数内的对象转成列表。

# ch6_30.py
string = "Deep Learning" # 定义字符串
print("打印string第0-2元素：", string[0:3])
print("打印string第1-3元素：", string[1:4])
print("打印string第1,3,5元素：", string[1:6:2])
print("打印string第1到最后元素：", string[1:])
print("打印string前3元素：", string[0:3])
print("打印string后3元素：", string[-3:])

# 计算字符串长度
strlen = len(string)
print("字符串长度：",strlen)
# 最大值
maxstr = max(string)
print("字符串中最大的unicode码值和字符", ord(maxstr), maxstr)
# 最小值
minstr = min(string)
print("字符串中最小的unicode码值和字符", ord(minstr), minstr)

list2 = list(string)
print(list2)


==================== RESTART: E:/Python-Files/ch6/ch6_30.py ====================
打印string第0-2元素： Dee
打印string第1-3元素： eep
打印string第1,3,5元素： epL
打印string第1到最后元素： eep Learning
打印string前3元素： Dee
打印string后3元素： ing
字符串长度： 13
字符串中最大的unicode码值和字符 114 r
字符串中最小的unicode码值和字符 32  
['D', 'e', 'e', 'p', ' ', 'L', 'e', 'a', 'r', 'n', 'i', 'n', 'g']
>>>

6.5 使用split()处理字符串

split()方法可以将字符串以空格或其他符号为分隔符，将字符串拆开，变成一个列表。

str1.split() # 以空为分隔符将字符串拆分成列表
str2.split(ch) # 以指定字符为分隔符将字符串拆分成列表


# ch6_30.py
string = "Deep Learning" # 定义字符串
print("打印string第0-2元素：", string[0:3])
print("打印string第1-3元素：", string[1:4])
print("打印string第1,3,5元素：", string[1:6:2])
print("打印string第1到最后元素：", string[1:])
print("打印string前3元素：", string[0:3])
print("打印string后3元素：", string[-3:])

# 计算字符串长度
strlen = len(string)
print("字符串长度：",strlen)
# 最大值
maxstr = max(string)
print("字符串中最大的unicode码值和字符", ord(maxstr), maxstr)
# 最小值
minstr = min(string)
print("字符串中最小的unicode码值和字符", ord(minstr), minstr)

list2 = list(string)
print(list2)

sList1 = string.split()
print(sList1)

sList2 = string.split('e')
print(sList2)


==================== RESTART: E:/Python-Files/ch6/ch6_30.py ====================
打印string第0-2元素： Dee
打印string第1-3元素： eep
打印string第1,3,5元素： epL
打印string第1到最后元素： eep Learning
打印string前3元素： Dee
打印string后3元素： ing
字符串长度： 13
字符串中最大的unicode码值和字符 114 r
字符串中最小的unicode码值和字符 32  
['D', 'e', 'e', 'p', ' ', 'L', 'e', 'a', 'r', 'n', 'i', 'n', 'g']
['Deep', 'Learning']
['D', '', 'p L', 'arning']
>>>

6.6 字符串的其他方法

  • startswith()：可列出字符串起始文字是否为特定子字符串，是则返回True，否则返回False。
  • endswith()：列出字符串结束文字是否为特定子字符串，是则返回True，否则返回False。
  • replace(ch1,ch2)：将ch1字符串由另一字符串替换。
  • join()：将字符串内的元素以特定字符连接，成为一个字符串。

往期文章：

梦里逆天
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
列表基本语法
jiajiajia800的专栏
03-21 3181
定义：列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。 创建及赋值格式： >>> list1 = [] >>> print(list1) [] >>> list2 = ['a','b',1,2,['test','case'],7-9j] >>> print(lis...
什么是列表？ 列表的定义格式-Python
weixin_43737594的博客
11-14 685
列表的定义
HTML中的有序列表、无序列表和自定义列表
Dreamer
10-17 3169
列表标签 表格是用来显示数据的，列表用来布局 列表最大的特点就是整齐、整洁、有序，它作为布局会更加的自由和方便。 列表可以分为三大类：无序列表、有序列表和自定义列表。 无序列表 <ul>标签标示HTML页面中项目的无序列表，一般会以项目符号呈现列表项，而列表项使用<li>标签定义。 无序列表的基本语法格式 <ul> <li>列表项1</li> <li>列表项2</li> ... </ul>
第六章 python 列表（List）
ihuxh26556的博客
09-29 1362
第六章 python 列表（Lint） 相信阅读至此章节，读者已经对 python 有一些基础了解了，这章笔者也将讲解简单的面向对象（Object Oriented）观念，同时指导读者学习利用 python 所提供的内置资源，未来将一步一步带领读者迈向高手之路。 6-1 认识列表（list） 其实在其他程序语言，相类似的功能是称数组（array），不过，python 的列表功能除了可以存储相同数据类型，例如，整数、浮点数、字符串，也可以存储不同数据类型，例如，列表内同时含有整数、浮点数和字符串。甚至一
HTML-列表、表格语法汇总及其案例
阿珂学cv
10-14 1695
本篇整理了列表、表格标签的语法和属性
Python学习笔记——大数据之SPARK核心
02-24
本文来自于csdn，文章讲解RDD的特点，RDD操作函数相关，穿插案例辣酱得段子，带大家理解MapReduce，通过哈姆雷特单词分析案例进行深度剖析。RDD（ResilientDistributedDatasets弹性分布式数据集），是spark中最重要...
Python学习笔记——大数据之Spark简介与环境搭建
02-24
其他Spark的库都是构建在RDD和SparkCore之上的。SparkSQL：提供通过ApacheHive的SQL变体Hive查询语言（HiveQL）与Spark进行交互的API。每个数据库表被当做一个RDD，SparkSQL查询被转换为Spark操作。对熟悉Hive和...
零基础入门学习Python_零基础入门学习Python_小甲鱼_
10-02
总的来说，《零基础入门学习Python》结合小甲鱼在B站的视频教程，提供了一个全面且易懂的学习路径，让初学者能够轻松踏入Python的世界，开启编程之旅。无论是为了个人兴趣，还是为了职业发展，这都是一个很好的起点...
学习笔记(07):Python零基础轻松从入门到实战-列表-2
01-20
dir(list) 查询列表的所有方法 1、增加 lst.append 在lst末尾追加对象 lst.insert(0, 10) 在索引0的前面插入一个对象10 lst.extend(‘book’) 列表和字符串都是“可迭代对象”。将’book’中的每个元素逐个加到...
列表的简单介绍
咸鱼!!!
06-18 1295
列表的基本认识列表简介列表的创建基本语法[]创建list()创建range()创建整数列表推导式生成列表(简介一下，重点在 for 循环后讲)列表元素的增加append()方法+运算符操作extend()方法insert()插入元素乘法扩展列表元素的删除del 删除pop()方法remove()方法列表元素访问和计数通过索引直接访问元素index()获得指定元素在列表中首次出现的索引count()...
列表详细介绍（通俗易懂）
m0_70228546的博客
05-29 1760
1.列表由一个或者多个数据构成，数据的类型可以不相同也可以相同； 2.列表中的数据需要写在[]中括号内部，数据与数据之间用逗号隔开； 3.列表是一个有序的集合，下标索引默认重 0 开始，和字符串类似； 定义列表 list1 = list() #定义一个空列表 print("list1 :",list1) list2 = [1,2,3,4] #定义一个整数类型的列表赋值给list2 print("...
5.4 HTML定义列表
mmsx2017的博客
03-10 356
一、定义列表简介 定义列表由两部分组成：定义条件和定义描述。 语法： &lt;dl&gt; &lt;dt&gt;定义名词&lt;/dt&gt; &lt;dd&gt;定义描述&lt;/dd&gt; …… &lt;/dl&gt; 效果： 定义名词 定义描述 …… &lt; dl&gt;即“definition list（定义列表）”，&a
Python基础语法【列表】
最新发布
早八人的上课笔记收录哈哈哈
02-09 336
python基础语法【列表】
html5笔记——html5列表
weixin_43730107的博客
03-19 1093
html5笔记——html5列表 作者：舒晴 上一篇：html5标记. 列表就是在网页中将项目有序或无序的罗列显示。HTML中有3种列表形式：有序列表、无序列表和定义列表。 有序列表 有序列表即为有排列顺序的列表，其各个列表项按照一定的顺序排列，例如网页中常见的歌曲排行榜、游戏排行榜等都可以通过有序列表来定义。 基本语法格式： <ol> <li>列表项</li&gt...
【C语言程序】英国某超市职工统计水果的品种，并显示输出水果的名称。(两种方式输出)
comelyboy的博客
01-20 1034
题出自------------------------------------------零基础学C语言 #include<stdio.h> int main() { int i; int j; char a[5][10] = { {'A','p','p','l','e'}, {'P','e','a','r'}, {'B','a','n','a','n','a'}, {'O','r','a','n','g','e'}, {'W','a','t','e','r','
Python简明教程--Dict
sgzqc的专栏
05-31 589
在Python中，字典Dict是常用的数据类型之一，本文就字典中相关常见的函数和操作进行汇总，方便大家查漏补缺。闲话少说，我们直接开始吧我们一般使用花括号创建列表，如下所示: 需要明确的是在Python中，我们一般使用花括号和来表示字典。 当然我们也可以创建包含初始值的字典，如下所示： 字典中包含多个键值对，它们之间用逗号分隔，其中键和值之间用冒号进行分隔。上述例子中：假设我们有如下字典： 上述字典中，的价格为4，的价格为5，的价格为6，我们可以直接通过索引来获取相应key的value值，如下所示： 简单来
菜鸟高飞路之HTML-列表
Whh_888的博客
06-12 527
HTML，创建列表的一些基础内容
HTML5+css3课后习题【二】
热门推荐
缘友一世的博客
11-05 1万+
HTML5+css3第5，6，7，8章课后习题
【小白从小学Python、C、Java】【Python-计算机等级考试二级】【Python中集合的add()方法】
liujingwei8610的专栏
10-26 408
选择题 以下python代码输出什么? fruits= {"apple", "banana", "cherry", "peach"} fruits.add("orange") fruits.add("peach") print(fruits) A {"apple", "banana", "cherry", "peach", "orange"} B {"apple", "banana", "cherry", "peach", "orange", "peach"} C {"apple", "b.
Python学习笔记：王纯业的编程之旅
"王纯业的Python学习笔记是作者王纯业分享的关于Python编程的学习资料，涵盖了Python的基础知识，包括变量、数据类型、列表操作、字符串、元组、序列、字典、流程控制以及函数和模块等内容。这份笔记旨在帮助读者...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦里逆天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值