【Python】第四课 列表，元组和字符串的使用

4.1 列表

python中的列表类似于Java中的Object的list集合，可以在同一个列表中存放不同数据类型的数据。

4.1.1 创建列表

创建列表和创建普通变量一样，用中括号括一堆数据就可以了，数据之间用逗号隔开：

# 列表的使用
numbers=[1,2,3,4,5]
# 列表中的数据的数据类型可以不一致,也可以列表中嵌套列表使用
texts=["图片",3.14,True,1000,"abc",[1,2,3]]
# 列表的定义也可以为空，后期再进行存入数据
empty=[]

4.1.2 向列表中添加元素

列表相当灵活，所有它的内存大小是不固定的，向列表中添加元素，可以使用append()方法,

# 列表中添加元素
numbers.append(6)
print(numbers) #输出结果:[1, 2, 3, 4, 5, 6]

但只能一个个元素添加，而不能一次添加多个,则需要使用extend()方法:

# 列表中添加多个元素
numbers.extend([7,8,9])
print(numbers) #输出结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]

该方法实际上是将一个列表追加在原列表之后，扩充了原列表。

向列表中任意位置插入元素:

# 任意位置添加元素
# 下标为0的位置上添加0
numbers.insert(0,0)
print(numbers)
# 下标为0的位置上添加一个子列表
numbers.insert(0,[-2,-1])
print(numbers)

但不能给某一个位置上插入多个元素

4.1.3 从列表中获得元素

python的列表取值和Java的数组或者list集合是一样的，通过下标来获得单个元素，列表的索引值是从0开始的。

# 根据下标获得列表中元素
names=["张三","李四","王五","赵六"]
print(names[0]) #输出结果:张三
print(names[3]) #输出结果:赵六
# 修改列表中指定的元素，元素之间交换数据
names[1],names[3]=names[3],names[1]
print(names) #输出结果:['张三', '赵六', '王五', '李四']

4.1.4 从列表中删除元素

从列表删除元素，这里介绍三种方法:remove(),del和pop().

# 使用remove()方法根据内容删除列表中的元素
numbers.remove(2)
print(numbers)

该方法只能删除指定的单个元素。

# 使用del方法根据下标删除列表中的元素
del numbers[0]
print(numbers)
# 使用del方法删除整个列表
del numbers

# 使用pop方法根据下标删除列表中的元素
# 该方法默认是将列表中末尾的元素取出来，并从列表中删除
n=numbers.pop()
print("从列表中取出的元素为:%d"%n)
print(numbers)
# 指定下标取出元素，并从列表中删除
# 取出下标为5的元素
n=numbers.pop(5)
print("从列表中取出的元素为:%d"%n)
print(numbers)

4.1.5 列表分片

利用索引值每次可以从列表获取一个元素，但是这个效率还是太慢，如果能一次性获得更多的元素那就更好，这里列表的分片就能简单方便的实现:

# 列表分片
names=["张三","李四","王五","赵六"]
print(names[:2]) # ['张三', '李四']
print(names[0:2])# ['张三', '李四']
print(names[1:2])# ['李四']
print(names[1:])# ['李四', '王五', '赵六']
print(names[:])# ['张三', '李四', '王五', '赵六']

通过以上的案例可以总结出，列表的分片是包头不包尾，就是根据开始的下标值获得元素，一直到结束的下标位置，但是不会输出结束下标位置的元素。如果没有开始位置，python会默认开始位置为0，同样道理，如果要得到从指定索引值到列表末尾的所有元素，把结束位置省去即可。如果没有放入任何索引值，而只有一个冒号，将得到整个列表的拷贝。

再次强调：列表分片就是建立原列表的一个拷贝，一个副本，所有如果你想对列表做出某些修改，但同时还想保持原本的哪个列表，那么直接使用分片的方法来获得拷贝就很方便了。

列表分片实际上有三个参数，第一个参数表示开始的索引下标，第二个参数表示结束的索引下标，第三个参数表示步长，用于从列表中根据下标的迭代的增值。

# 取出列表中步长为2的值
numbers=[1,2,3,4,5]
print(numbers[0:9:2]) # [1, 3, 5]
# 当步长为负数时，表示倒序获取
print(numbers[::-1]) #[5, 4, 3, 2, 1]
print(numbers[::-2])#[5, 3, 1]

对列表进行分片后的赋值和原列表的直接赋值的操作情况是不同的。

#分片处理，是对原列表的拷贝，而不对原列表造成影响
list3=[1,1,22,3,4,5,33]
x1=list3[:]
x2=list3
print("x1是对list3列表的分片后的存储:%s"%x1)
print("x2是对list3列表的引用地址的存储:%s"%x2)
# 对原列表进行从小到大排序，并观察x1和x2列表的变化
list3.sort()
print("原列表排序后%s"%list3)#原列表排序后[1, 1, 3, 4, 5, 22, 33]
print("x1列表的变化%s"%x1)#x1列表的变化[1, 1, 22, 3, 4, 5, 33]
print("x2列表的变化%s"%x2)#x2列表的变化[1, 1, 3, 4, 5, 22, 33]
#通过观察可发现，分片处理是对原列表的拷贝，不受元列表的影响，是独立的。
#但x2列表是被原列表的地址赋值，也就是说list3与x2都指向原列表，属于同一块内存。

4.1.6 列表的常用操作

列表可以用来比较大小，也可以用来做加减乘除的快速生成列表操作。

# 比较两个列表的大小
x1=[123,234,345]
x2=[234,123,345]
print(x1>x2) #False

列表之间的比较与Java中字符串之间的比较是类似的，取各自的第一个元素进行比较，如果第一个元素的结果是True才会去比较第二个元素，如果第一个元素为False，那么不再继续比较，直接得到结果为False。

# 两列表做+法拼接
x3=x1+x2
print(x3)# [123, 234, 345, 234, 123, 345]
# 但需要需要给列表中添加单个元素，不能使用加法连接符，只能使用insert或者append方法

#快速创建列表的模拟数据
a1=[8]
a1=a1*4
print(a1) # [8, 8, 8, 8]

#判断列表中是否存在某个元素
print(123 in x1) # True
print(123 not in x1) #False
print(123 in x2[1]) # True
print(123 not in x2[1]) #False

关键字in和not in只能判断一个层次的成员关系，与break，continue的概念是一致的，如果出现列表嵌套列表，该关键字是判断不了多层嵌套内部的元素是否存在。

4.1.7 列表的其他常用方法

以上我们学习了很多列表的增删改查的方法，其实列表还有很多方法，我们可以使用dir()函数将列表中的方法都列举出来。

#查看列表中的所有可用方法
print(dir(list)) #list就是列表的类名

运行结果:

['add', 'class', 'contains', 'delattr', 'delitem', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'gt', 'hash', 'iadd', 'imul', 'init', 'init_subclass', 'iter', 'le', 'len', 'lt', 'mul', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'reversed', 'rmul', 'setattr', 'setitem', 'sizeof', 'str', 'subclasshook', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

以后可以通过dir()方法来查看某一个对象的常用方法。

接着我们再来学习列表中的几个常用方法:

count()这个方法的作用是计算它的参数在列表中出现的次数:

# 查找列表中某个元素出现的次数
list1=[1,1,2,3,4,8,13,21]
print("1在列表中出现的次数为:%d"%list1.count(1))# 1在列表中出现的次数为:2

index()找出列表中某个元素在列表中的下标索引位置:

# 获得元素索引位置
print(list1.index(8)) # 5
#找出第一个1的索引位置 
print(list1.index(1)) # 0
#找出第二个1的索引位置
print(list1.index(1,list1.index(1)+1,len(list1))) #1
#index函数的第一个参数表示要查找的元素，第二个参数表示从列表中开始搜索的索引值
#第三个参数表示结束搜索的索引值

使用index函数时，如果搜索不到该元素，则会使程序报错。

reverse()方法的作用是将整个列表原地翻转，也就是倒序排列。注意这个倒序不是拷贝副本，而是原列表进行倒序。

#将列表进行倒序
list1.reverse()
print(list1) # [21, 13, 8, 4, 3, 2, 1, 1]

sort()方法将乱序的列表进行排序，默认为从小到大排序

#列表排序,默认为从小到大排序
list2=[2,3,42,54,5,12,9,100]
list2.sort()
print(list2)# [2, 3, 5, 9, 12, 42, 54, 100]
#从大到小排序
list2.sort(reverse=True)
print(list2)

其实sort函数中有三个参数，第一个参数func用于设置排序的算法，默认为归并排序，属于分治算法。第二个参数key用于设置关键字，第三个参数reverse用于设置是升序排序还是降序排序。

4.2 元组

Python中的元组类似与Java中的数组，也类似于字符串，长度是固定的，不能进行随意的删减添加元素。

4.2.1 创建和访问元组

元组的创建大部分时候用的是小括号，在特殊情况创建的形式会不同。

# 元组的创建和访问
tuple1=(1,2,3,4,5,6,7,8)
print(tuple1)#(1, 2, 3, 4, 5, 6, 7, 8)
# 根据索引值获得元组中的元素
print(tuple1[2],tuple1[4],tuple1[6])#3 5 7
#元组中使用分片
print(tuple1[3:])#(4, 5, 6, 7, 8)
print(tuple1[:6])#(1, 2, 3, 4, 5, 6)

元组的创建并不是完全由(小括号)决定的，而是有(,)逗号决定的。

# 初始化定义元组
temp=(1)
print(type(temp))#显示是<class 'int'>，说明小括号并不是定义元组的关键写法
temp=1,
print(type(temp))#显示是<class 'tuple'>,说明逗号才是定义元组的关键写法
#当需要初始化一个空元组的时候，可以使用小括号表示
temp=()
print(type(temp))#<class 'tuple'>
#当定义有值的元组时，有以下两种用法
temp=(1,)
print(type(temp))#输出结果为:<class 'tuple'>
temp=1,
print(type(temp))#输出结果为:<class 'tuple'>
#快速生成元组数据
temp=8,
temp=temp*8
print(temp)#(8, 8, 8, 8, 8, 8, 8, 8)

4.2.2 更新和删除元组

元组不能和列表的使用一样在原列表中进行修改和删除数据，元组是固定的，那么如果要修改和删除数据，只能和字符串拼接的操作一样去处理元组的数据的更新。

# 元组的修改和删除
texts=("苹果","香蕉","西瓜","脐橙")
#该元组中香蕉的后面插入一个榴莲,使用+加法连接符将三个元组连接起来
texts=texts[:2]+("榴莲",)+texts[2:]
print(texts)# ('苹果', '香蕉', '榴莲', '西瓜', '脐橙')
#将元组中的西瓜删除
texts=texts[:3]+texts[4:]
print(texts)# ('苹果', '香蕉', '榴莲', '脐橙')
#如果要删除整个元组，只需要del即可
del texts

在日常生活中，很少使用del去删除整个元组，因为Python的回收机制会在这个元组不再被使用到的时候自动删除。在元组中，也可以正常使用拼接操作符，关系运算符，逻辑运算符，算术运算符以及in，not in。

4.3 字符串

在学习列表和元组的知识中，我们掌握了一个很重要的知识就是分片，实际上字符串和元组很像，因此字符串中也能使用分片技术。在Python中是没有字符这个类型的，单个字符只会认为是长度为1的字符串。

#字符串的使用
text="hello python!!!"
print(text[6:])#python!!!
#根据索引值获得单个字符串
print(text[6])#p
#在字符串中插入子字符串
text=text[:6]+"P"+text[7:]
print(text)#hello Python!!!

字符串的更新与元组的更新是一致的，将原字符串组合成一个新的字符串，存储在新的内存中，原字符串的内存会被Python的垃圾回收机制进行自动回收。

4.3.1 常用内置方法

# 将字符串全部变为小写字母
s1="I'm Chinese"
s1=s1.casefold()
print(s1)#i'm chinese
# 查找某个子字符串在字符串中出现的次数,该方法是区分大小写的
s2="aBabAbababAABBAB"
print(s2.count("ab",0,len(s2)))# 3
# find()和index()都是用来查找子字符串在原字符串中的索引值
#到哪前者如果没找到则返回值为-1，后者则会直接报错，后期可以通过异常捕获处理
print(s2.find("AA",0,len(s2)))#10
print(s2.index("BB",0,len(s2)))#12
#给字符串中插入分隔符
s3="I is boy"
s3="_".join(s3)
print(s3)#I_ _i_s_ _b_o_y
#使用join()方法可以快速的将列表或者元组转换成字符串格式，做大量的字符串的拼接
print(" ".join(["abc","123","456","True","3.14","123"]))#abc 123 456 True 3.14 123
print(" ".join(("abc","123","456","True","3.14","123")))#abc 123 456 True 3.14 123
#将原字符串中某个子字符串查找后使用新的子字符串进行替换
s4="I Love You"
print(s4.replace("You","girl"))# I Love girl
# 将字符串按某个分隔符进行分割成列表，该方法与join()方法是刚好相反
s5="I_ _i_s_ _b_o_y"
s5=s5.split("_")
print(s5)# ['I', ' ', 'i', 's', ' ', 'b', 'o', 'y']

4.3.2 格式化

这里的格式化其实类似于占位符，将不确定的数据用某种符号格式进行占位，等确定了数据后将数据替换占位符。

#格式化
s6="{0} Love {1}"
print(s6.format("You","Me"))#You Love Me
print(s6.format("boy","girl"))#boy Love girl
s7="{a} eat {b} and {c}"
print(s7.format(a="I",b="apple",c="banana"))#I eat apple and banana
#通过以上代码的演示用数字作为占位符是直接按顺序替换即可，用字母作为占位符时，替换的时候一定需要加上占位符的变量名
#python中可以将两种用法综合使用，但是数字的占位符一定要放置在字母占位符之前使用，否则会产生语法异常
#打印出大括号，需要嵌套一层大括号，这里就不再表示占位符了
print("{{0}}".format())#{0}
#控制浮点数的位数,表示为1位整数，两位小数，需要注意的是小数前需要添加.，表示四舍五入保留两位小数
print("{0}:{1:.2f}".format("圆周率",3.1415926))

格式化操作符: %

#将字符a的ASCII码的值97转换成字符
print("ASCII码为%d对应的字符是%c"%(97,97))#ASCII码为97对应的字符是a
print("%c%c%c%c"%(70,105,115,104))#Fish
print("%d转换成八进制为%o"%(123,123))#123转换成八进制为173
print("%d转换成十六进制为%x"%(123,123))#123转换成十六进制为7b
print("%f用科学计数法表示%e"%(149500000,149500000))#149500000.000000用科学计数法表示1.495000e+08
print("%f用科学计数法表示%E"%(149500000,149500000))#149500000.000000用科学计数法表示1.495000E+08

格式化操作符的辅助指令

# 将该浮点数保留5位整数，1位小数进行四舍五入的浮点数
print("%5.1f"%27.658)#27.7
# 将该浮点数保留1位整数，2位小数进行四舍五入的科学计数法
print("%.2e"%27.658)#2.77e+01
# 将数字保留10位数的整数,默认靠右对齐，前面以空白填充
print("%10d"%27.658)#        27
# 将数字保留10位数的整数,靠左对齐，后面以空白填充
print("%-10d"%27.658)#27        
# 将数字保留10位数的整数,默认靠右对齐，前面以0填充
print("%010d"%27.658)#0000000027
# 将十进制转换成十六进制，并添加进制符号
print("%#X"%100)#0X64

转义字符及含义

4.4 序列

这里对列表，元组，字符串之间的共性做一个汇总，并使用常用的几个方法对列表，元组和字符串之间的互相转换进行操作。

• 都可以通过索引得到每一个元素

• 默认索引值总是从0开始

• 可以通过分片的方法得到一个范围内的元素的集合

• 有很多共同的操作符

下面介绍一下常用BIF（内建方法）:

4.4.1 list([iterable])

该方法可以将字符串，元组转换成列表

#创建空列表
list1=list()
print(list1)#[]
#将字符串转换为列表
list2=list("abcdefg")
print(list2)#['a', 'b', 'c', 'd', 'e', 'f', 'g']
#将元组转换为列表
list3=list((1,2,3,4,5,6,7))
print(list3)#[1, 2, 3, 4, 5, 6, 7]

4.4.2 tuple([iterable])

该方法可以将字符串，列表转换成元组

#创建空元组
t1=tuple()
print(t1)#[]
#将字符串转换为元组
t2=tuple("abcdefg")
print(t2)#('a', 'b', 'c', 'd', 'e', 'f', 'g')
#将列表转换为元组
t3=tuple([1,2,3,4,5,6,7])
print(t3)#(1, 2, 3, 4, 5, 6, 7)

4.4.3 str(obj)

将obj对象转换为字符串，这里包括各种数据类型，在前面已介绍过。

#将浮点型转换成字符串
r1=str(3.14)
print(r1)

4.4.4 len(sub)

该方法用于获得列表，元组或者字符串的长度

#获得字符串长度
str1="aaaaaaaaaaa"
print(len(str1))
#获得列表长度
list1=["a",123,True]
print(len(list1))
#获得元组长度
tuple1="a","b","c","d"
print(len(tuple1))

4.4.5 Max(……)和Min(……)

该方法用于获得字符串，列表，元组中最大值和最小值的元素，一般操作在数字上比较多。但一定要保证每一个元素的数据类型是一致的。

#  获得最大值，最小值
list1=[1,18,13,0,-98,34,54,76,32]
print("列表中最大值为:%d,最小值为:%d"%(max(list1),min(list1)))
str1="I Love fishc.com"
print("字符串中最大值为:%s,最小值为:%s"%(max(str1),min(str1)))
t1=(5,8,1,13,5,29,10,7)
print("元组中最大值为:%s,最小值为:%s"%(max(t1),min(t1)))

运行结果:

列表中最大值为:76,最小值为:-98 ​ 字符串中最大值为:v,最小值为: ​ 元组中最大值为:29,最小值为:1

4.4.6 sum(iterable[,start])

该方法用于做累加求和。

#累加求和
list1=[1,2,3,4,5]
print(sum(list1))#15
print(sum(list1,100))#115

4.4.7 sorted(iterable,key=none,reverse=False)

该方法用于返回一个排序的列表，与sort()内建方法实现的效果是一致的，但sort()函数是将原列表进行排序，而该方法是拷贝一个副本进行排序，原列表不受影响。

#列表排序
list1=[1,18,13,0,-98,34,54,76,32]
#将列表分片获得副本
list2=list1[:]
#将原列表进行sort内建方法排序
list1.sort()
print(list1)#[-98, 0, 1, 13, 18, 32, 34, 54, 76]
list3=sorted(list2)
print(list3)#[-98, 0, 1, 13, 18, 32, 34, 54, 76]
print(list2)#[1, 18, 13, 0, -98, 34, 54, 76, 32]

通过输出结果可以发现，sort内建函数直接将list1列表进行排序了，而通过分片获得的副本list2在通过sorted函数做排序之后，又获得一个副本list3，其原本list2并没有发现变化。

4.4.8 reversed(sequence)

该方法用于返回逆向迭代序列的值，其效果和reverse内建函数的效果是一致的，都是将列表数据进行倒序输出，但内建函数是将原列表进行倒序，而该方法是拷贝一个副本进行倒序，原列表并不受影响，但倒序后获得的不是列表而是迭代对象，不能进行直接输出。

#列表倒序
print(reversed(list1))# <list_reverseiterator object at 0x0000000002938B00>
for i in reversed(list1):
    print(i,end=",")
#76,54,34,32,18,13,1,0,-98,

通过输出结果发现反转后获得的是迭代对象，并不是列表也不是元组，因此输出的时候是一个列表反转后的迭代对象，打印的是地址编码。只能通过循环遍历获得，并在每次输出后面填逗号拼接。

4.4.9 enumerate(iterable)

该方法是将字符串，列表或者元组转换成枚举类型的迭代对象输出，该迭代由索引值和元素组成。

#转换成枚举类型迭代输出
str1="Fish"
for i in enumerate(str1):
    print(i)
for i in enumerate(list1):
    print(i)

第一个循环输出结果为:

(0, 'F') (1, 'i') (2, 's') (3, 'h')

第二个循环输出结果为:

(0, -98) (1, 0) (2, 1) (3, 13) (4, 18) (5, 32) (6, 34) (7, 54) (8, 76)

4.4.10 zip(iter1[,iter2[……]])

该方法用于返回由各个可迭代参数共同组成的元组。例如列表，字符串，元组进行每项组合压缩成一个元素显示，类似于打包，但要求项数保持一致。

#数据打包
list1=[2,4,6,8,10]
str1="abcde"
t1=1,3,5,7,9
for i in zip(list1,str1,t1):
    print(i)

结果为:

(2, 'a', 1) (4, 'b', 3) (6, 'c', 5) (8, 'd', 7) (10, 'e', 9)