【Python知识点梳理】3.高级数据类型

3.高级数据类型

---

---

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"))  # 没有检测到报-1

a = "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的高级数据类型：字符串、列表、元组、字典的常用方法代码示例。