Python学习—(2)Python高级数据类型

高级数据类型

1.常用字符串操作

（1）首字母大写

name = 'peter'
print('首字母大写:%s'%name.capitalize())

首字母大写Peter

（2）去除空格

• 去除两边空格

a = '   hello   '
print("a的值为:", a)
b = a.strip()
print("去除两边空格b的值为:", b)

a的值为: hello
去除两边空格b的值为: hello

• 去除左边空格

c = a.lstrip()
print("去除左边空格c的值为:", c)

去除左边空格c的值为: hello

• 去除右边空格

d = a.rstrip()
print("去除右边空格d的值为:", d)

去除右边空格d的值为: hello

（3）复制字符串

print('a的内存地址%d'%id(a)) # id函数，查看对象的内存地址
e = a
print('e的内存地址%d'%id(e))
print('e的值为:', e)

a的内存地址1419749899824
e的内存地址1419749899824
e的值为: hello

（4）查找

data = 'I love Python'
print('P的索引为:', data.find('P')) # 若找到，返回下标
print('M的索引为:', data.find('M')) # 若没找到，返回-1
print('P的索引为:', data.index('P')) # 若找到，返回下标
# print(data.index('M')) # 若没找到，报错

P的索引为: 7
M的索引为: -1
P的索引为: 7
ValueError: substring not found

• 查找开头、结尾

print('字符串是否以I作为开头:', data.startswith('I')) # 若是以I开头，则返回bool类型True
print('字符串是否以l作为开头:', data.startswith('l')) # 若不是，则返回False
print('字符串是否以n作为结尾:', data.endswith('n')) # 若是以n结尾，则返回bool类型True
print('字符串是否以o作为结尾:', data.endswith('o')) # 若不是以n结尾，则返回bool类型False

字符串是否以I作为开头: True
字符串是否以l作为开头: False
字符串是否以n作为结尾: True
字符串是否以o作为结尾: False

（5）大小写转换

print('字符串转换为大写:', data.upper())
print('字符串转换为小写:', data.lower())

字符串转换为大写: I LOVE PYTHON
字符串转换为小写: i love python

（6）字符串的切片操作

print(data[2:5]) # 左闭右开
print(data[2:]) # 从下标2一直到最后
print(data[:3]) # 等效于print(data[0:3])
print(data[::-1]) # 倒序，从右往左遍历
print(data[3:0:-1]) # 第一个索引为大于等于0的数，按[0,1,2..]排序，第一个索引为小于0的数按[...,-2,-1]排序，第三个数为正则从左往右，为负则从右往左

lov
love Python
I l
nohtyP evol I
ol

2.常用列表操作

（1）列表定义

li1 = [] # 空列表
li = [1, 2, 3, 'hi']
print('列表li的长度为:', len(li)) # 打印列表中的对象个数
strA = 'jkl'
print('字符串strA的长度为:', len(strA)) # 打印字符串中字符的个数
print('li多次输出的结果为:', li * 2) # 多次输出列表中的数据

列表li的长度为: 4
字符串strA的长度为: 3
li多次输出的结果为: [1, 2, 3, ‘hi’, 1, 2, 3, ‘hi’]

（2）追加数据

li.append([111])
print('追加数据后的列表数据li为:', li)

追加数据后的列表数据li为: [1, 2, 3, ‘hi’, [111]]

（3）在指定位置插入数据

li.insert(1, '插入')
print('在指定位置插入数据后的列表数据li为:', li)

在指定位置插入数据后的列表数据li为: [1, ‘插入’, 2, 3, ‘hi’, [111]]

（4）强制类型转换：转为列表

li2 = list(range(5))
print('强制类型转换后的列表数据li2为:', li2)

强制类型转换后的列表数据li2为: [0, 1, 2, 3, 4]

（5）将列表内容批量添加到另一个列表中

li.extend(li2) # 与append不同:append将整个列表添加, expend将列表的内容取出来再添加
print('将列表内容批量添加到另一个列表后的列表数据li为:', li)

将列表内容批量添加到另一个列表后的列表数据li为: [1, ‘插入’, 2, 3, ‘hi’, [111], 0, 1, 2, 3, 4]

（6）列表修改

li[0] = 'nihao'
print('将列表修改后的列表数据li为:', li)

[‘nihao’, ‘插入’, 2, 3, ‘hi’, [111], 0, 1, 2, 3, 4]

（7）列表删除和查找操作

del li[0] # 移除对应下标的数据项
print('将列表移除对应下标的数据项后的列表数据li为:', li)
del li[1:3] # 批量删除
print('将列表批量删除后的列表数据li为:', li)
li.remove(4) # 移除对应数据项
print('将列表移除对应数据项后的列表数据li为:', li)
li.pop(1) # 移除对应下标的数据项
print('将列表移除对应数据项后的列表数据li为:', li)
print(li)
print(li.index(3)) # 查找对应数据项的索引
print(li.index(3, 2, 6)) # 在对应下标范围[2,6)能查找到对应数据项的索引
print(li.index(2, 0, 5)) # 在对应下标范围[0,3)不能查找到对应数据项的索引

将列表移除对应下标的数据项后的列表数据li为: [‘插入’, 2, 3, ‘hi’, [111], 0, 1, 2, 3, 4]
将列表批量删除后的列表数据li为: [‘插入’, ‘hi’, [111], 0, 1, 2, 3, 4]
将列表移除对应数据项后的列表数据li为: [‘插入’, ‘hi’, [111], 0, 1, 2, 3]
将列表移除对应数据项后的列表数据li为: [‘插入’, [111], 0, 1, 2, 3]
5
5
4

3.常用元组操作

（1）元组定义

tupleA=() # 空元组
print('tupleA的地址:', id(tupleA)) # 两个元组的地址不同，不是在同一个元组上的修改
tupleA = ('jkl', 9.15, 456, [111,222], 456)
print('tupleA的地址:', id(tupleA))

tupleA的地址: 2644498006080
tupleA的地址: 2644498694032

（2）元组的查询

print(tupleA[1]) # 取出元组中的一个值，不是元组类型
print(tupleA[1:3]) # 切片取出元组的一部分，仍是元组类型
print(tupleA[1:2]) # 元组只有一个元素，要加","

9.15
(9.15, 456)
(9.15,)

（3）元组的修改

tupleA[2] = 789 #元组不能修改，否则会报错
print(tupleA)

TypeError: ‘tuple’ object does not support item assignment

• 可以对元组的列表数据修改

tupleA[3][0] = 147 # 可以对元组中的列表数据修改
print('tupleA的值为:', tupleA)

tupleA的值为: (‘jkl’, 9.15, 456, [147, 222], 456)

（4）统计数据项出现的次数

print('项456出现的次数', tupleA.count(456))

项456出现的次数 2

4.常用字典操作

（1）字典定义及添加字典操作

dict1 = {} # 空字典
# 创建字典
dictA = {'PRO':'艺术'}
# 添加字典数据 key:value
dictA['name'] = 'zqz'
dictA['age'] = '30'
dictA['pos'] = 'singer'
print("dictA = ", dictA)

dictA = {‘PRO’: ‘艺术’, ‘name’: ‘zqz’, ‘age’: ‘30’, ‘pos’: ‘singer’}

（2）获取数据项长度

print("dictA的长度:", len(dictA))

dictA的长度: 4

（3）通过键获取对应的值

print("通过键获取对应的值:", dictA['name'])

通过键获取对应的值: zqz

（4）修改键对应的值

dictA['name'] = 'y2j'
print("修改键对应的值后dictA:", dictA)

修改键对应的值后dictA: {‘PRO’: ‘艺术’, ‘name’: ‘y2j’, ‘age’: ‘30’, ‘pos’: ‘singer’}

（5）获取所有的键和值

print("dictA所有的键", list(dictA.keys()))
print("dictA所有的值", list(dictA.values()))
print("dictA所有的键和值", list(dictA.items()))

dictA所有的键 [‘PRO’, ‘name’, ‘age’, ‘pos’]
dictA所有的值 [‘艺术’, ‘y2j’, ‘30’, ‘singer’]
dictA所有的键和值 [(‘PRO’, ‘艺术’), (‘name’, ‘y2j’), (‘age’, ‘30’), (‘pos’, ‘singer’)]

（6）字典的修改

dictA.update({'age': 40}) # 修改已有的键值
print("update修改后dictA:", dictA)
dictA.update({'height': '170'}) # 若没有, 则添加
print("update修改后dictA:", dictA)

update修改后dictA: {‘PRO’: ‘艺术’, ‘name’: ‘y2j’, ‘age’: 40, ‘pos’: ‘singer’}
update修改后dictA: {‘PRO’: ‘艺术’, ‘name’: ‘y2j’, ‘age’: 40, ‘pos’: ‘singer’, ‘height’: ‘170’}

（7）字典的删除

del dictA['name'] # 通过指定键删除
print("通过指定键删除后的dictA:", dictA)
dictA.pop('age')
print("通过指定键删除后的dictA:", dictA)

通过指定键删除后的dictA: {‘PRO’: ‘艺术’, ‘age’: 40, ‘pos’: ‘singer’, ‘height’: ‘170’}
通过指定键删除后的dictA: {‘PRO’: ‘艺术’, ‘pos’: ‘singer’, ‘height’: ‘170’}（8）字典的排序

print(sorted(dictA.items(),key=lambda d:d[0])) # 按键排序
print(sorted(dictA.items(),key=lambda d:d[1])) # 按值排序

[(‘PRO’, ‘艺术’), (‘height’, ‘170’), (‘pos’, ‘singer’)]
[(‘height’, ‘170’), (‘pos’, ‘singer’), (‘PRO’, ‘艺术’)]

5.公用方法

（1）合并操作

stra = '111'
strb = '222'
print('合并操作的结果为:', stra+strb)

合并操作的结果为: 111222

（2）复制操作

print('复制操作的结果为:', stra*2)

复制操作的结果为: 111111

（3）in操作：查看对象是否存在,返回bool类型值

name = 'Peter'
print('P是否存在:', 'P' in name)
print('o是否存在:', 'o' in name)

P是否存在: True
o是否存在: False