字符串、列表和元组类型
1.字符串类型
字符串
- 介绍
- 字符串是Python中最常用的数据类型之一，使用单引号或双引号来创建字符串，使用三引号创建多行字符串。
- 创建
s1 = "hello oldamy"
print(s1)
s2 = 'hello oldamy'
print(s2)
s3 = '''hello oldamy'''
print(s3)
- 注意:
- 单引号跟双引号是一对对的
- 所有符号都是英文状态下的
存储方式介绍
- 字符串是不可变的序列数据类型，不能直接修改字符串本身，和数字类型一样！
字符串的下标
- 由于字符串是序列数据结构，所以当我们要从"hello world"当中取出某一个字母就索引(默认从0开始)来取。
>>> s1 = "hello world"
>>> s1[1]
'e'
>>> s1[10]
'd'
>>> s1[-1]
'd'
>>> s1[11]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
为什么说字符串是不可变数据类型？
>>> s2 = "hello world"
>>> s2[4] = 'l'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
字符串切片
- 在dos命令行中，输入help(slice)，查看切片说明文档。
- 切片参数：
- start起始位置，默认索引从0开始
- stop结束位置，默认最后一个元素
- step步长，默认为1
>>> help(slice)
Help on class slice in module builtins:
class slice(object)
| slice(stop)
| slice(start, stop[, step])
|
| Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).
- 切片实战
s3 = “hello world”
如何取出world值？
代码如下：
>>> s3 = "hello world"
>>> s3[6:10] # 注意,左闭右开
'worl'
>>> s3[6:11]
'world'
>>> s3[6:] # 不写默认取到最后一位
'world'
- 如何取出hlowrd值？发现是隔一个取一个，则步长为2
代码如下：
>>> s3[::2]
'hlowrd'
- s3如何逆序输出？
代码如下：
>>> s3[::-1]
'dlrow olleh'
字符串类型转换
- 将字符串转为整数类型
>>> int('1')
1
>>> int('a') # 报错 注意int()为十进制
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'a'
- 将整数类型转为字符串
>>> str(1)
'1'
字符串组成方式
- +号直接拼接
print('1'+'2') # 12
- %s %d %f
name = 'tly'
age = 18
print('%s年龄%d'%(name,age))
- str.format()
name = 'tly'
age = 18
print('{}年龄{}'.format(name,18))
print('{1}年龄{0}'.format(18,name))
- f’’
name = 'tly'
age = 18
print(f'{name}的年龄是{age}')
字符串的常见操作
- S.find(sub) --> 返回该元素最小的索引
>>> s4 = 'hello python'
>>> s4.find('e')
1
>>> s4.find('o') # 当元素有多个时,返回最小索引
4
>>> s4.find('c') # 找不到则为-1
-1
-
S.index(sub) --> 返回该元素最小的索引
实际上，该方法与s.find()实现的功能一样，但是唯一不同的就是当元素不存在时，s.index()方法会报错。所以建议使用s.find() -
S.replace(old, new[, count]) --> 替换
>>> s5 = "hello python"
>>> s5.replace('l','a') # 将'l'替换成'a',全部替换
'heaao python'
>>> s5
'hello python' # 注意：原来的字符串并没有被改变
>>> s5.replace('l','a',1) # 只替换一个,则指定count参数为1即可
'healo python'
- S.split(sep=None) --> 以sep来分割字符串,并返回列表。sep默认为None,分割默认为空格
>>> s6 = 'hello everyboby ye!'
>>> s6.split(' ')
['hello', 'everyboby', 'ye!']
- S.startswith(prefix[, start[, end]]) --> 判断字符串是否以前缀开始，返回为bool值。
>>> s7 = "hello world"
>>> s7.startswith("he")
True
- S.endswith(suffix[, start[, end]]) --> 判断字符串是否以尾缀结束，返回为bool值。
>>> s7
'hello world'
>>> s7.endswith('ld')
True
- S.lower() --> 将字符串全部转为小写
- S.upper() --> 将字符串全部转为大写
- S.strip([chars]) --> 默认去掉字符串左右的空格
>>> s8 = ' hello world '
>>> s8.strip()
'hello world'
- S.isalpha() --> 判断字符串是否全为字母，返回的是bool值
- S.isdigit() --> 判断字符串是否全为数字，返回的是bool值
- S.isalnum() --> 判断字符串是否全为数字或者字母，不存在特殊字符，返回的是bool值
- S.join(iterable) --> 将序列中的元素以指定的字符连接生成一个新的字符串
li = ["你好","世界"]
s = ','.join(li)
print(s)
2.列表类型
列表介绍
- 列表是Python中最基本也是最常用的数据结构之一。
- 列表中的每个元素都被分配一个数字作为索引，用来表示该元素在列表内所排在的位置。第一个元素的索引是0，第二个索引是1，依此类推。
- Python的列表是一个有序可重复的元素集合，可嵌套、迭代、修改、分片、追加、删除，成员判断。
- 从数据结构角度看，Python的列表是一个可变长度的顺序存储结构，每一个位置存放的都是对象的指针。
- 对于这个列表 alist = [1, “a”, [11,22], {“k1”:“v1”}]，其在内存内的存储方式是这样的：
创建方式
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
>>> li = [] # 定义一个空的列表 注意 命名不能是list
>>> li
[]
>>> li1 = [1,'amy',3.14] # 任何数据类型都可存储
>>> li1
[1, 'amy', 3.14]
>>> li2 = list()
>>> li2
[]
>>> li3 = list('hello') # list(iterable)
>>> li3
['h', 'e', 'l', 'l', 'o']
访问列表内的元素
列表从0开始为它的每一个元素顺序创建下标索引，直到总长度减一 。要访问它的某个元素，以方括号加下标值的方式即可。注意要确保索引不越界，一旦访问的 索引超过范围，会抛出异常。所以，一定要记得最后一个元素的索引是len(list)-1。
>>> lis = ["a", "b", "c"]
>>> lis[0]
'a'
>>> lis[1]
'b'
>>> lis[2]
'c'
>>> lis[3]
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
lis[3]
IndexError: list index out of range
修改元素的值
直接对元素进行重新赋值。
>>> li1 = [1,2,3]
>>> li1[1]
2
>>> li1[1] = 5
>>> li1
[1, 5, 3]
>>> li1[1:] = [6,7]
>>> li1
[1, 6, 7]
删除元素
使用del语句或者remove()，pop()方法删除指定的元素。
>>> lis = ["a", "b", "c"]
>>> del lis[0] # 根据索引删除
>>> lis
['b', 'c']
>>> lis.remove("b") # 直接根据值进行删除
>>> lis
['c']
>>> lis.pop() # 弹出最后一个
'c'
>>> lis
[]
l1 = [1, 'hello', 1]
l2 = l1.pop(1) # 根据索引来弹出 1为索引
print(l2)
列表的特殊操作
# 语句 结果 描述
[1, 2, 3] + [4, 5, 6] # [1, 2, 3, 4, 5, 6] 组合两个列表
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1.__add__(l2)) # 底层调用了__add__方法
['Hi!'] * 4 # ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 列表的乘法
l1 = [1, 2, 3]
print(l1.__mul__(3))
3 in [1, 2, 3] # True 判断元素是否存在于列表中
l1 = [1, 2, 3]
print(l1.__contains__(1))
列表的常用函数
# 函数 作用
>>> l1 = [1, 2, 3]
>>> len(l1) # 返回列表元素个数，也就是获取列表长度 l1.__len__()
3
>>> max(l1) # 返回列表元素最大值 max(l1) max(1,2,3,4)
3
>>> min(l1) # 返回列表元素最小值
1
>>> list('hello') # 将序列转换为列表
['h', 'e', 'l', 'l', 'o']
>>> s = list((1, "a", "b", 2))
>>> s
[1, 'a', 'b', 2]
>>> max(s) # 不能混合不同类型进行最大最小求值
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
max(s)
TypeError: '>' not supported between instances of 'str' and 'int'
排序和反转
>>> li = [1,2,3,4,5,2,1,3,1]
>>> li.reverse() # 将列表反转 修改本身 *IN PLACE*
>>> li
[1, 3, 1, 2, 5, 4, 3, 2, 1]
>>> li.sort() # 排序，默认升序 L.sort(key=None, reverse=False)
>>> li
[1, 1, 1, 2, 2, 3, 3, 4, 5]
>>> li.sort(reverse=True) # reverse=True 降序
>>> li
[5, 4, 3, 3, 2, 2, 1, 1, 1]
切片(截取)
- 切片指的是对序列进行截取，选取序列中的某一段。
- 切片的语法是：
list[start:end:step] - 以冒号分割索引，start代表起点索引，end代表结束点索引，step为步长默认为1。省略start表示以0开始，省略end表示到列表的结尾。注意，区间是左闭右开的！
- 如果提供的是负整数下标，则从列表的最后开始往头部查找。例如-1表示最后一个元素，-3表示倒数第三个元素。
- 切片过程中还可以设置步长，以第二个冒号分割，例如list[3:9:2]，表示每隔多少距离取一个元素。
>>> l3 = ['a','b','c','d','e','f']
>>> l3[1] # 取'b' 注意：index默认从0开始
'b'
>>> l3[2] # 取'c'
'c'
>>> l3[1:3] # 取['b', 'c'] 注意：左闭右开
['b', 'c']
>>> l3[:3] # 取['a', 'b', 'c'] 注意：start不写默认从头开始
['a', 'b', 'c']
>>> l3[2:] # 取['c', 'd', 'e', 'f'] 注意：end不写默认到最后
['c', 'd', 'e', 'f']
>>> l3[:] # 取全部
['a', 'b', 'c', 'd', 'e', 'f']
>>> l3[::2] # 取['a', 'c', 'e'] 注意：步长为2
['a', 'c', 'e']
>>> l3[::-1] # 逆序
['f', 'e', 'd', 'c', 'b', 'a']
多维列表（嵌套列表）
>>> a = [[1,2,3],[4,5,6],[7,8,9]]
>>> a[0][1]
2
列表的遍历
列表有好几种遍历方式：
a = [1,2,3,4,5,6]
for i in a: # 遍历每一个元素本身
print(i)
for i in range(len(a)): # 遍历列表的下标，通过下标取值
print(i, a[i])
x = 9
if x in a: # 进行是否属于列表成员的判断。该运算速度非常快。
print("True")
else:
print("False")
列表的内置方法
- append(obj) 在列表末尾添加新的对象
- count(obj)统计某个元素在列表中出现的次数
- extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
- index(obj) 从列表中找出某个值第一个匹配项的索引位置
- insert(index, obj) 将对象插入列表
- pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
- remove(obj) 移除列表中某个值的第一个匹配项
- reverse() 反向列表中元素
- sort([func]) 对原列表进行排序
- copy() 复制列表
- clear() 清空列表，等于del lis[:]
>>> li = [1,2,3]
>>> li.append([3,3])
>>> li
[1, 2, 3, [3, 3]]
>>> li = [1,2,3,[3,3]]
>>> li.count(3)
1
>>> li = [1,2,3]
>>> li.extend([4,5])
>>> li
[1, 2, 3, 4, 5]
>>> li = [1,2,3,2,3]
>>> li.index(3)
2
>>> li = ['happy','year']
>>> li.insert(1,'new')
>>> li
['happy', 'new', 'year']
>>> li = [1,2,3]
>>> li.clear()
>>> li
注意：其中的类似 append，insert, remove 等方法会修改列表本身，并且没有返回值（严格的说是返回None）。
3.元组类型
元组介绍
-
用圆括号括起来的是元组。
-
元组也是序列结构，但是是一种不可变序列，你可以简单的理解为内容不可变的列表。除了在内部元素不可修改的区别外，元组和列表的用法差不多。
元组创建
>>> tu = ()
>>> tu
()
>>> tu1 = tuple()
>>> tu1
()
>>> type(tu)
<class 'tuple'>
>>> type(tu1)
<class 'tuple'>
元组与列表相同的操作
使用方括号加下标访问元素
>>> tu = (1,2,3,4,5)
>>> tu[1]
2
切片（形成新元组对象）
>>> tu
(1, 2, 3, 4, 5)
>>> tu[2:4]
(3, 4)
tuple.count()/tuple.index()
>>> tu1 = (1,2,3,4,5,5,5,4)
>>> tu1.count(5)
3
>>> tu1.index(5)
4
- 列表中还有list.reverse()与list.sort(),但是元组没有，但是要实现反转与排序可以使用python中的内置函数:reversed()，sorted()
>>> tu1
(1, 2, 3, 4, 5, 5, 5, 4)
>>> reversed(tu1)
<reversed object at 0x000001B9FE543C88>
>>> tuple(reversed(tu1))
(4, 5, 5, 5, 4, 3, 2, 1)
>>> tu = (1,2,3,5,4,3)
>>> sorted(tu) # 升序
[1, 2, 3, 3, 4, 5]
len()/max()/min()/tuple()
元组中不允许的操作
不允许修改、新增元素
>>> tup = (1,2,3)
>>> tup[2] = 5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
一旦想改变该元组,就只能重新开辟一块内存,创建新的元组
>>> tup = (1,2,3)
>>> new_tup = tup+(4,)
>>> new_tup
(1, 2, 3, 4)
注意：元组只保证它的一级子元素不可变，对于嵌套的元素内部，不保证不可变
如下：
>>> tup = (1,2,3,['amy',5]) # 将'amy'改为4
>>> tup[3][0] = 4
>>> tup
(1, 2, 3, [4, 5])
>>> tup1 = (1,2,3,('amy',5)) # 将'amy'改为4
>>> tup1[3][0] = 4
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
不允许删除某个元素（但可以删除整个元组）
实际上，所有会对元组内部元素发生修改动作的方法。例如，元组没有remove，append，pop等方法
列表和元组的转换
元组转为列表
>>> tu = (1,2,3)
>>> list(tu)
[1, 2, 3]
列表转为元组
>>> li = [1,2,3]
>>> tuple(li)
(1, 2, 3)