Python学习 Task4：列表、元组和字符串

1、列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为

[元素1, 元素2, ..., 元素n] 。

列表的数据项不需要具有相同的类型,创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

1. 关键点是「中括号 []」和「逗号 ,」
2. 中括号把所有元素绑在一起
3. 逗号将每个元素一一分开
   代码如下：

list1 = ['baidu', 'bing', 'google', ，1994，20,20]
list2 = [1, 2, 3, 4, 5,6,7,8,9,10 ]
list3 = ["a", "b", "c", "d","e", "f", "g", "h"]

1.1 列表创建

1、创建普通列表

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] <class 'list'>
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(x, type(x))
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] <class 'list'>

2、使用range()函数创建列表

x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>

3、使用推导式创建列表

x = [1] * 5
print(x, type(x))
# [1, 1, 1, 1, 1] <class 'list'>
x = [1 for i in range(5)]
print(x, type(x))
# [1, 1, 1, 1, 1] <class 'list'>
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
x = [i for i in range(1, 20, 3)]
print(x, type(x))
# [1, 4, 7, 10, 13, 16, 19] <class 'list'>
x = [i for i in range(20, 1, -3)]
print(x, type(x))
#[20, 17, 14, 11, 8, 5, 2]<class 'list'>
x = [i ** 3 for i in range(1, 10)]
print(x, type(x))
# [1, 8, 27, 64, 125, 216, 343, 512, 729] <class 'list'>
x = [i for i in range(100) if (i % 3) != 0 and (i % 4) == 0]
print(x, type(x))
# [4, 8, 16, 20, 28, 32, 40, 44, 52, 56, 64, 68, 76, 80, 88, 92]<class 'list'>

4、创建一个 4×3的二维数组

x = [[1, 2, 3], [1, 2, 1], [3, 2, 1], [0, 0, 0]]
print(x, type(x))
# [[1, 2, 3], [1, 2, 1], [3, 2, 1], [0, 0, 0]] <class 'list'>
for i in x:
   print(i, type(i))
# [1, 2, 3] <class 'list'>
# [1, 2, 1] <class 'list'>
# [3, 2, 1] <class 'list'>
# [0, 0, 0] <class 'list'>
x = [[0 for col in range(3)] for row in range(4)]
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

5、 创建一个混合列表

name= [1, 'htls', 3.14, [1, 2, 3]]
print(name) # [1, 'htls', 3.14, [1, 2, 3]]

6、创建空列表

empty = []
print(empty) # []

注：列表不像元组，列表内容可更改 (mutable)，因此附加 ( append , extend )、插入 ( insert )、删除 ( remove ,pop ) 这些操作都可以使用。

1.2 更改列表中的元素

1、向列表中添加元素
list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.append('Saturday')
print(list)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
print(len(list)) # 6

或者

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.append(['Saturday','Sunday'])
print(list)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Saturday', 'Sunday']]
print(len(list)) # 6

而list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.extend(['Saturday','Sunday'])
print(list)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Saturday', 'Sunday']]
print(len(list)) # 7

list.insert(index, obj) 在编号 index 位置前插入 obj。

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.insert(4, 'Sunday')
print(list)
#['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Sunday', 'Friday']
print(len(list)) # 6

2、删除列表中的元素
list.remove(obj) 移除列表中某个值的第一个匹配项

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.remove('Tuesday')
print(list) # ['Monday', 'Wednesday', 'Thursday', 'Friday']
print(len(list)) # 4

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = list.pop()
print(y) # Friday
print(list) # ['Monday', 'Tuesday', 'Wednesday', 'Thursday']
y = list.pop(0)
print(y) # Monday
y = list.pop(-2)
print(y) # Wednesday
print(list) # ['Tuesday', 'Thursday']

remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。而del var1[, var2 ……] 删除单个或多个对象。要删除的元素在列表中的位置，可使用 del 语句。

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del list[0:3]
print(list) # ['Thursday', 'Friday']

如果从列表中删除一个元素，且不再以任何方式使用它，建议使用 del 语句；如果删除元素后还能继续使用它，建议使用方法 pop()。

3、获取列表中的元素

1. 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
2. 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(list[1], type(list[1])) # Tuesday <class 'str'>
print(list[-3], type(list[-3])) # Wednesday <class 'str'>
print(list[-2], type(list[-2])) # Thursday <class 'str'>

切片的通用写法是 start : stop : step
3.11、情况 1 - "start :"以 step 为 1 (默认) 从编号 start 往列表尾部切片。

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(list[2:]) # ['Wednesday', 'Thursday', 'Friday']
print(list[-2:]) # ['Thursday', 'Friday']

3.2、情况 2 - “: stop”， 以 step 为 1 (默认) 从列表头部往编号 stop 切片。

list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(list[:2]) # ['Monday', 'Tuesday']
print(list[:-2]) # ['Monday', 'Tuesday', 'Wednesday']

3.3、情况 3 - "start : stop"以 step 为 1 (默认) 从编号 start 往编号 stop 切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']

3.4、情况 4 - "start : stop : step"以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2])# ['Tuesday', 'Thursday']
print(week[:4:2])# ['Monday', 'Wednesday']
print(week[1::2])# ['Tuesday', 'Thursday']
print(week[::-1])# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

3.5、情况 5 - " : "复制列表中的所有元素（浅拷贝）。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday','Saturday','Sunday']
print(week[:])
# week的拷贝 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
list1 = [123, 121, 852, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 121, 852, 213]
print(list3) # [123, 121, 852, 213]
list1.sort()
print(list2) # [121, 123, 213, 852]
print(list3) # [123, 121, 852, 213]
list1 = [[123, 321], [963, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 321], [963, 213]]
print(list3) # [[123, 321], [963, 213]]
list1[0][0] = 111
print(list2) # [[111, 321], [963, 213]]
print(list3) # [[111, 321], [963, 213]]

1.3 列表的常用操作符

列表常用操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下表所示：

表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x	1 2 3	循环
1==1	True	判断

1.4 列表的其他常用方法

1.4.1、list.count(obj) 统计某个元素在列表中出现的次数

list = [123, 456] * 3
print(list) # [123, 456, 123, 456, 123, 456]
num = list.count(123)
print(num) # 3

1.4.2、list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置

list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4

1.4.3、list.reverse() 反向列表中元素

list = [123, 456, 789]
list.reverse()
print(list) # [789, 456, 123]

1.4.4、list.sort(key=None, reverse=False) 对原列表进行排序。
1）key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
2）reverse – 排序规则， reverse = True 降序， reverse = False 升序（默认）。
3）该方法没有返回值，但是会对列表的对象进行排序。

list = [123, 456, 789, 213]
list.sort()
print(list) # [123, 213, 456, 789]
list.sort(reverse=True)
print(list) # [789, 456, 213, 123]
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
list = [(2, 2), (3, 4), (4, 1), (1, 3)]
list.sort(key=takeSecond)
print(list)# [(4, 1), (2, 2), (1, 3), (3, 4)]
list.sort(key=lambda a: a[0])
print(list)# [(1, 3), (2, 2), (3, 4), (4, 1)]

2 元组

元组与列表类似，不同之处是元组的元素不能修改，元组使用小括号，而列表使用方括号。元组创建简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('physics', 'chemistry', 1994, 2020)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
print("tup1:",tup1)#tup1: ('physics', 'chemistry', 1994, 2020)
print("tup2:",tup2)#tup2: (1, 2, 3, 4, 5)
print("tup3:",tup3)#tup3: ('a', 'b', 'c', 'd')
tup4=()
tup5=(20,)
print("tup4:",tup4)#tup4: ()
print("tup5:",tup5)#tup5: (20,)

2.1 访问元组

元组可以使用下标索引来访问元组中的值。

tup1 = ('physics', 'chemistry', 1994, 2020)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
print("tup1[3]:",tup1[3])#tup1[3]: 2020
print("tup3[2]:",tup3[2])#tup3[2]: c

2.2 修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合.

week = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday','Saturday','Sunday')
week = week[:2] + ('Wednesday',) + week[2:]
print("week:",week) # week:('Monday', 'Tuesday', 'Wednesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')

2.3 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

tup = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday','Saturday','Sunday')
print("tup:",tup) #tup: ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')
del tup
print("After deleting tup :" )
print(tup)

2.4 解压元组

1、解压（unpack）一维元组（有几个元素左边括号定义几个变量）

tup = (10, 1.31, 'python3')
(a, b, c) = tup
print(a, b, c) # 10 1.31 python3

2、解压二维元组（按照元组里的元组结构来定义变量）

tup = (10, 1.31, ('OK', 'python3'))
(a, b, (c, d)) = tup
print(a, b, c, d) # 10 1.31 OK python3

3 字符串

3.1 访问字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。创建字符串很简单，只要为变量分配一个值即可。字符串被定义为引号之间的字符集合，Python 支持使用成对的单引号或 双引号。

var1 = 'Hello World!!!'
var2 = "Welcome to Python"
print(var1) # Hello World!!!
print(var2) # Welcome to Python

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串。

var1 = 'Hello World!!!'
var2 = "Welcome to Python"
print(var1[2]) # l
print(var2[1:6]) # elcom

3.2 字符串连接

对字符串进行截取并与其他字符串进行连接。

var1 = 'Hello World!!!'
var2 = "Welcome to Python"
print(var1[:6]+var2[11:17]) # Hello Python

3.3 转义字符

假设变量 a 为字符串 “Hello”，b 为 “Python”：

操作符	描述	实例
+	字符串连接	a+b=‘HelloPython’
*	重复输出字符串	a * 2=‘HelloHello’
[]	通过索引获取字符串中字符	a[2]=l
[ : ]	截取字符串中的一部分	a[1:4]=‘ell’
in	如果字符串中包含给定的字符返回 True	“H” in a =True
not in	如果字符串中不包含给定的字符返回 True	“F” in a =True

3.4 字符串格式化

format 格式化函数

str = "{0} Love {1}".format('I', 'Python') # 位置参数
print(str) # I Love Python
str = "{a} Love {b}".format(a='I', b='Python') # 关键字参数
print(str) # I Love Python
str = "{0} Love {b}".format('I', b='Python') # 位置参数要在关键字参数之前
print(str) # I Love Python
str = '{0:.2f}{1}'.format(127.658, 'GB') # 保留小数点后两位
print(str) # 127.66GB