3.高级数据类型
文章目录
- 1、字符串操作
- 2、列表操作
- 3、元组操作
- 4、字典操作
- 5、公用方法
- 总结
1、字符串操作
切片是指截取字符串中的一段内容，语法：[起始下标：结束下标：步长]。
切片截取的内容不包含结束下标对应的数据，步长指的是间隔几个下标获取一个字符。
1.序列：在Python中，序列就是一组按照顺序排列的值(数据集合)；
2.三种内置的序列类型：字符串、列表、元组
3.优点：支持索引和切片的操作
4.特征：第一个正索引为0，索引指向的是左端，第一个正索引为负数，索引指向的是右端。
a = "python" # 定义一个字符串，长度为6，索引为0-5，下标会越界(报错)，切片不会！！！
print(len(a)) # 获取字符串的长度
print(type(a))print("获取第一个字符:%s" % a[0]) # 获取第一个字符
print("获取第二个字符:%s" % a[1])
print(a[1:10]) # 获取第二个到第十一个字符(下标会越界(报错)，切片不会)
print(a[0:7:2])# 遍历字符串(字符串就是一个序列)
for i in a:
print(i, end=' ')# 1 首字母变大写
a = "python"
b = a.capitalize()
print(a.capitalize())# 2 是否以x结束/开始 --> True or False
a = "python"
print(a.endswith("n"))
print(a.startswith("pyn"))# 3 检测x是否在字符串中 --> 返回的索引值
a = "I Love Python"
print(a.find("th"))
print(a.find("w")) # 没有检测到报-1a = "this is string example....wow!!!"
b = "Asc"
c = "123a"
# 4 判断是否是数字和字母 --> True or False
print(c.isalnum())
# 5 判断是否是字母 --> True or False
print(b.isalpha())
# 6 判断是否是数字 --> True or False
print(c.isdigit())
# 7 判断是否是小写 --> True or False
print(c.islower())# 8 循环取出所有值用x去连接
sub = "-";
seq = ("a", "b", "c"); # 字符串序列
b = sub.join(seq)
print(b)
a = "this is string example....wow!!!"
d=','.join(a)
print(d)# 9 大小写转换
a = "I Love Python"
print(a.upper())
# 9 大小写转换
print(a.lower())# 10 大写转小写，小写转大写
a = 'Ad24TRG'
print(a.swapcase())e = " i love you . "
# 11 移除左侧的空格
print(e.lstrip())
e = " i love you . "
# 11 移除右侧的空格
print(e.rstrip())
e = " i love you . "
# 11 移除两侧的空格
print(e.strip())f = 'i love you .'
# 12 切割字符串
print(f.split("o"))
# 13 把每个单词的首字母变成大写
print(f.title())
# 14 替换
print(f.replace("o","XX"))
# 15 统计出现的次数
print(f.count("o"))# 16 复制字符串
k = "qwer123QQQ"
j = k # 只是把k对象的内存地址赋值给了j，是一个对象
print("k的内存地址：", id(k))
print("j的内存地址：", id(j))# 17 检测字符串中是否包含子字符串，返回的是下标值，没找到时报异常
a = "I Love Python"
a.index('th')# 18 切片
strMsg = "Hello_world"
len(strMsg)
print(strMsg[2:5])
print(strMsg[2:])
print(strMsg[:5])
print(strMsg[::-1]) # 倒序输出，符号表示方向，从右往左去遍历
print(strMsg[2:-3])
print(strMsg[-6:-1])
print(strMsg[::2])2、列表操作
列表(list)是一种有序的集合，可以随时增加、删除、更改、查找其中的元素。
1.创建一个列表，只要把逗号分隔的不同的数据项使用方括号[]括起来即可，可以是任何类型的数据。
2.支持索引和切片，列表的下标取值、切片、是否越界与字符串一致，区别就是列表是获取元素。
3.用for循环可将列表中的元素一个一个的取出，取完后退出循环。
4.列表中的数据是可以变化的(数据项可以变化，内存地址不会改变)
a = [] # 创建一个空列表
print(type(a))
print(len(a))a = [1.1, 2, 3, "你好", "x", (3), {'Name': 'Mack'}] # 任何类型的数据的列表
print(type(a))
print(type(a[6]))
print(len(a)) # len()函数获取列表对象中的数据个数listA = ['abcd', 785, 12.25, "你好", True]
# 列表的切片操作
print(listA) # 输出完整的列表
print(listA[0]) # 输出第一个元素
print(listA[2:5])
print(listA[2:])
print(listA[:4])
print(listA[::-1])
print(listA[1:-2])
print(listA[-4:-1])
print(listA[::])
print(listA[::-2])
print(listA*2) # 输出多次列表中的数据# 1 追加操作
listA = ['abcd', 785, 12.25, "你好", True]
print("追加之前：", listA)
listA.append(['fff', 'ddd', 8888]) # 追加一个列表放入listA中(在列表中再声明一个列表)
listA.append("12112")
listA.append(121.12)
print("追加之后：", listA)# 2 插入操作，需要指定一个位置
listA = ['abcd', 785, 12.25, "你好", True]
print("插入之前：", listA)
listA.insert(1, "这是插入的数据！") # 在指定位置插入
print("插入之后：", listA)# 强制转换为list对象
rsData = list(range(10))
print(type(rsData))
print(rsData)# 3 扩展，批量添加
listA = ['abcd', 785, 12.25, "你好", True]
print("1扩展之前：", listA)
listA.extend(rsData)
print("1扩展之后：", listA)
listA = ['abcd', 785, 12.25, "你好", True]
print("2扩展之前：", listA)
listA.extend([11.11, 22.22, 33.33])
print("2扩展之后：", listA)# 4 修改
listA = ['abcd', 785, 12.25, "你好", True]
print("修改之前：", listA)
listA[0] = "teacher"
print("修改之后：", listA)# 5 删除列表中的第一个元素
listB = list(range(1, 10))
print("1删除之前：", listB)
del listB[3] # 按照索引进行删除
print("1删除之后：", listB)
listB = list(range(1, 10))
print("2删除之前：", listB)
del listB[2:6]
print("2删除之后：", listB)# 6 删除列表中指定元素
listB = list(range(1, 10))
print("1删除之前：", listB)
listB.remove(5) # 移除指定的元素(值)
print("1删除之后：", listB)
listB = list(range(1, 10))
print("2删除之前：", listB)
listB.pop(0) # 移除指定索引位置上元素(索引)
print("2删除之后：", listB)# 7 获取索引
listB = list(range(1, 10))
listB.index(5)# 8 统计
listB = list(range(1, 10))
listB.count(5)# 9 列表排序(不会生成新的列表，所以会返回None，在原列表进行排序),reverse=True倒序
listA = [1, 5, 69, 9, 8, 72, 52, 32, 5]
listA.sort(reverse=True)
print(listA)
listB = [1, 5, 69, 9, 8, 72, 52, 32, 5]
listB.sort(reverse=False)
print(listB)# 10 反转
listB = [1, 5, 69, 9, 8, 72, 52, 32, 5]
listB.reverse()
listB# 拷贝
listB = [1, 5, 69, 9, 8, 72, 52, 32, 5] # 可变对象
listC = listB[:] # 创建一个新对象，深拷贝
listD = listB # 赋值操作，指向同一个对象，浅拷贝
print("原列表：", id(listB))
print("深拷贝：", id(listC))
print("浅拷贝：", id(listD))
listC.sort()
listD.append('123456')
print("原列表B:", listB)
print("深拷贝C:", listC)
print("浅拷贝D:", listD)3、元组操作
元组是一种不可变的序列，在创建后不能做任何的修改。
1.重要：当元组中只有一个元素时，要加上逗号，否则解释器会当作整形(int)来处理
2.元组与列表类似，不同之处在于元组中的元素不能修改，元组使用小括号，元组可以通过下标进行访问。
3.元组使用括号创建，在括号中添加元素，并使用逗号隔开，可以是任何类型。
4.元组的内置方法count用于统计元素在元组中出现的次数。
5.元组的内置方法index用于查找指定元素在元组中的下标位置。
a = (1) # 创建一个只有一个元素的元组(逗号不能省略)
b = (1,)
print("a：", type(a))
print("b：", type(b))
tupleA = ("abcd", 89, 19.3, "你好", True, [1, 12, 2, 33])
print("A：", type(tupleA))
print("A的长度：", len(tupleA))# 元组的查询
for i in tupleA:
print(i, end=" ")# 元组的查询获取(切片)
tupleA = ("abcd", 89, 19.3, "你好", True, [1, 12, 2, 33])
print(tupleA[0])
print(tupleA[0:1]) # 输出第一个元素
print(tupleA[-1:])
print(tupleA[2:5])
print(tupleA[2:])
print(tupleA[:4])
print(tupleA[::-1])
print(tupleA[1:-2])
print(tupleA[-4:-1])
print(tupleA[::])
print(tupleA[::-2]) # 表示反转字符串，每隔两个取数据
print(tupleA*2)# 可以对元组中的列表进行修改
tupleA = ("abcd", 89, 19.3, "你好", True, [1, 12, 2, 33])
tupleA[5][0] = "HelloPython"
print(type(tupleA[5]))
print(tupleA)# 元组的转换
tupleB = tuple(range(10))
print(tupleB)# 查找指定元素在元组中的下标
tupleC = (1,2,2,5,5,6,6,8,5,6,4,8,5,2,3,5)
tupleC.index(8)# 统计数据项出现的次数
tupleC = (1,2,2,5,5,6,6,8,5,6,4,8,5,2,3,5)
tupleC.count(2)4、字典操作
字典是Python中重要的一种数据类型，不是序列类型，没有下标的概念，是一个无序的键值集合，可以存储任意对象，支持对数据的增加、修改、删除、查找。
1.字典是以键值对的形式创建的{“key”:“value”}利用大括号表示，每个键值对用逗号分隔。
2.字典中查找某个元素时，是根据键进行查找，每个字典的元素都含有2部分：键：值
3.访问值的安全方式为：get方法，在不确字典中是否含有某个键而又想获取其值时，可以使用get方法，还可以设置默认值。
4.字典的键(key)不能重复，必定是唯一的，如果存在重复的键，后者会覆盖前者；值(value)可以重复，值可以是任何类型。
5.字典的键(key)只能是不可变类型，如数字、字符串、元组。
# 创建字典
dictA = {} # 空字典
print(type(dictA))
dictB = {'pro': '艺术', 'school': '北京电影学院'}
print(type(dictB))
print(len(dictB)) # 获取数据项长度# 增加元素
dictA = {'pro': '艺术', 'school': '北京电影学院'}
dictA['name'] = '李易峰' # key:value
dictA['age'] = 30
dictA['pos'] = '歌手'
print(dictA) # 输出完整的字典
print(len(dictA)) # 获取数据项长度# 通过键获取对应的值
dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
print(dictA['name'])
print(dictA['age'])
print(dictA['pro'])# 修改键对应的值
dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
dictA['name'] = '谢霆锋'
dictA['school'] = '香港大学'
dictA['age'] = 35
print(dictA)dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
# 获取所有的键
print(dictA.keys())
# 获取所有的值
print(dictA.values())
# 获取所有的键值对
print(dictA.items())# 遍历获取所有的键值对
dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
for i, j in enumerate(dictA.items()):
print(i, j)# 遍历获取所有的键值对
dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
for i in dictA.items():
print(i)# 遍历获取所有的键值对
dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
for key, value in dictA.items():
print('%s==%s' % (key, value))# 遍历获取所有的键
dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
for i in dictA.keys():
print(i)# 遍历获取所有的值
dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
for i in dictA.values():
print(i)dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
# 更新字典
dictA.update({'age': 66})
dictA.update({'height': 175.50})
# 合并字典
dictB = {'sex': 'man', 'grade': 4}
dictA.update(dictB)
print(dictA)dictA = {'pro': '艺术', 'school': '北京电影学院',
'name': '李易峰', 'age': 30, 'pos': '歌手'}
# 关键字删除
del dictA['pro']
print(dictA)
# 根据键删除
dictA.pop('pos')
print(dictA)dictA = {'pro': '艺术', 'school': '香港大学', 'name': '谢霆锋',
'age': '66', 'pos': '歌手', 'height': '175.5'}
# 排序，按照key进行排序
print(sorted(dictA.items(), key=lambda d: d[0]))
# 排序，按照value进行排序
print(sorted(dictA.items(), key=lambda d: d[1]))# get()函数返回指定键的值，如果值不在字典中返回默认值。 语法dict.get(key, default=None)
# default -- 如果指定键的值不存在时，返回该默认值。
user_name = {1: "张三", 2: "李四", 3: "王五", }
def greeting(userid):
return print("Hi %s!" % user_name.get(userid, "陌生人"))
greeting(4) # 不存在，返回默认值
greeting(1) # 存在，返回字典值info = {'name': '班⻓', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国'}
print(info.get("name", "username")) # 默认值是username
print(info.get("pwd", "12345")) # 查询不到取默认值5、公用方法
1.合并操作 + ：两个对象相加操作，会合并两个对象，适用于字符串、列表、元组。
2.复制操作 * ：对象自身按指定次数进行合并操作，适用于字符串、列表、元组。
3.判断元素是否存在 in ：判断指定元素是否存在于对象中，，适用于字符串、列表、元组、字典。
# 1 合并操作(字符串)
strA = '人生苦短'
strB = '我用Python'
c = strA + strB
print(c)
# 1 合并操作(列表)
listA = list(range(3))
listB = list(range(55, 60))
c = listA + listB
print(c)
# 1 合并操作(元组)
tupleA = tuple(range(3))
tupleB = tuple(range(55, 60))
c = tupleA + tupleB
print(c)# 复制(字符串)
strA = '人生苦短'
print(strA*3)
# 复制(列表)
listA = list(range(3))
print(listA*3)
# 复制(元组)
tupleA = tuple(range(3))
print(tupleA*3)# 对象是否存在(字符串)
strA = '人生苦短'
print('生' in strA)
# 对象是否存在(列表)
listA = list(range(3))
print( 55 in listA)
# 对象是否存在(元组)
tupleA = tuple(range(3))
print(0 in tupleA)
# 对象是否存在(字典)
user_name = {'name': '班⻓', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国'}
print('name' in user_name)总结
Python的高级数据类型：字符串、列表、元组、字典的常用方法代码示例。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
