python的高级数据类型

python的高级数据类型

学习python的学习笔记 1
内容大多数来自于B站《求知讲堂》，根据自己的学习，排版整理的笔记，作为自己复习时使用
《求知讲堂》视频链接：https://b23.tv/xwTPkP

一、序列

序列：在python当中 序列就是一组按照顺序排列的值【数据集合】

在python中 存在三种内置的序列类型：
列表、元组、字符串

优点：可以支持索引和切片的操作
特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端，也就是说，索引的正负号代表着方向。

切片：【高级特性】可以根据下表来获取序列对象的任意[部分]数据
语法结构：[start: end :step] step默认1

二、列表（list）：

python当中非常重要的数据结构，是一种有序的数据集合

特点：
1：支持增删改查
2：列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
3:用[ ] 来表示列表类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据
4：支持索引和切片来进行操作

（一）
li=[1,2,3,“你好”] #[ ]表示列表类型
print(len(li)) #len函数可以获取到列表对象中的数据个数

（二）

查找

listA=[‘abcd’,785,12.23,‘qiuzhi’,True]
print(listA) #输出完整的列表
print(listA[0]) #输出第一个元素
print(listA[1:3]) #从第二个开始到第三个元素
print(listA[2:]) #从第三个元素开始到最后所有的元素
print(listA[::-1]) #负数从右像左开始输出
print(listA*3) #输出多次列表中的数据【复制】

（三）

增加

listA=[‘abcd’,785,12.23,‘qiuzhi’,True]
print(‘追加之前’,listA)
listA.append([‘fff’,‘ddd’]) #追加操作
listA.append(8888)
print(‘追加之后’,listA)
listA.insert(1,‘这是我刚插入的数据’) #插入操作 需要执行一个位置插入，这里的1代表着位置。
print(listA)

listA=[‘abcd’,785,12.23,‘qiuzhi’,True]
rsData=list(range(10)) #强制转换为list对象
print(type(rsData))
listA.extend(rsData) #拓展，拓展的内容是（ ）中的内容， 可以理解为批量添加
listA.extend([11,22,33,44])
print(listA)

（四）

修改

listA=[‘abcd’,785,12.23,‘qiuzhi’,True]
print(‘修改之前’,listA)
listA[0]=333.6
print(‘修改之后’,listA)

（五）

删除list数据项

listB=list(range(10,40))

print(listB)
del listB[0] #删除列表中第一个元素
del listB[1:3] #批量删除多项数据 slice
listB.remove(20) #移除指定的元素 参数是具体的数据值
listB.pop(1) #移除制定的项 参数是索引值
print(listB)

print(listB.index(36,20,25)) #返回的是一个索引下标

三、元组：

是一种不可变的序列，在创建之后不能做任何的修改
特点：
1：不可变
2：用（ ）创建元组类型，数据项用逗号来分割
3：可以是任何的类型
4：当元组中只有一个元素时，要加上逗号，不然后解释器会当做其他类型来处理
5：同样可是支持切片操作

（一）

查找

tupleA=(‘abcd’,89,9.12,‘peter’,[11,22,33])
for item in tupleA:
print(item,end=’ ')

tupleA=(‘abcd’,89,9.12,‘peter’,[11,22,33])
print(tupleA[2:4])
print(tupleA[::-1])

print(tupleA[::-2]) #表示反转字符串 每隔两个去一次
print(tupleA[::-3]) #表示反转字符串 每隔三个去一次
print(tupleA[-2:-1 :]) #倒着取下标 为-2 到 -1 区间的
print(tupleA[-4:-2:]) #倒着取下标 为-2 到 -1 区间的

（二）

修改（只能修改元组中的列表）

tupleA=(‘abcd’,89,9.12,‘peter’,[11,22,33])
tupleA[4][0]=285202 #可以对元组中的列表类型的数据进行修改第一个[ ]代表元组的位置，第二个[ ]代表位于第四位的列表的内容位置
print(tupleA)
print(type(tupleA[4]))

（三）
tupleB=(‘1’,) # 当元组中只有一个数据项的时候，必须要在第一个数据项后面加上 逗号
print(type(tupleB))

（四）

统计

tupleC=(1,2,3,4,3,4,4,1)

print(tupleC.count(4)) #可以统计元素出现的次数

四、字典：

也是python中重要的数据类型，字典是有 键值对 组成的集合，通常使用 键来访问数据，效率非常高，和list一样 支持对数据的添加、修改、删除
特点：
1：不是序列类型 没有下标的概念，是一个无序的 键值集合，是内置的高级数据类型
2：用{} 来表示字典对象，每个键值对用逗号分隔
3：键 必须是不可变的类型【元组、字符串】 值可以是任意的类型
4: 每个键必定是惟一的，如果存在重复的键，后者会覆盖前者
（一）

创建及添加

dictA={“pro”:‘艺术’,‘shcool’:‘北京电影学院’} #创建一个字典
dictA[‘name’]=‘李易峰’ #添加字典数据，key:value，前者为键，后者为值
dictA[‘age’]=‘30’
dictA[‘pos’]=‘歌手’
print(dictA) #输出完整的字典
print(len(dictA)) #输出数据项长度
print(type(dictA))#输出数据类型

（二）

获取及修改

dictA={“pro”:‘艺术’,‘shcool’:‘北京电影学院’} #创建一个字典
dictA[‘name’]=‘李易峰’ #添加字典数据，key:value，前者为键，后者为值
dictA[‘age’]=‘30’
dictA[‘pos’]=‘歌手’
print(dictA[‘name’]) #通过键获取对应的值
dictA[‘name’]=‘谢霆锋’ #修改键对应的值
dictA[‘shcool’]=‘香港大学’
dictA.update({‘height’:1.80}) #可以添加或者更新
print(dictA)
print(dictA.keys())# 获取所有的键
print(dictA.values())# 获取所有的值

（三）

删除操作

dictA={“pro”:‘艺术’,‘shcool’:‘北京电影学院’} #创建一个字典
dictA[‘name’]=‘李易峰’ #添加字典数据，key:value，前者为键，后者为值
dictA[‘age’]=‘30’
dictA[‘pos’]=‘歌手’
del dictA[‘name’] #通过指定键进行删除
print(dictA)

dictA={“pro”:‘艺术’,‘shcool’:‘北京电影学院’} #创建一个字典
dictA[‘name’]=‘李易峰’ #添加字典数据，key:value，前者为键，后者为值
dictA[‘age’]=‘30’
dictA[‘pos’]=‘歌手’
dictA.pop(‘age’) #通过指定键进行删除
print(dictA)

以上两个注意对比
（四）

排序

dictA={“pro”:‘艺术’,‘shcool’:‘北京电影学院’} #创建一个字典
dictA[‘name’]=‘李易峰’ #添加字典数据，key:value，前者为键，后者为值
dictA[‘age’]=‘30’
dictA[‘pos’]=‘歌手’

print(sorted(dictA.items(),key=lambda d:d[0]))# 如何排序 按照key排序
print(sorted(dictA.items(),key=lambda d:d[1]))# 按照value排序

（五）

字典拷贝

dictA={“pro”:‘艺术’,‘shcool’:‘北京电影学院’} #创建一个字典
dictA[‘name’]=‘李易峰’ #添加字典数据，key:value，前者为键，后者为值
dictA[‘age’]=‘30’
dictA[‘pos’]=‘歌手’

import copy
dictB=copy.copy(dictA) #浅拷贝
dictC=copy.deepcopy(dictA) #深拷贝
print(id(dictC))
print(id(dictA))
dictB[‘name’]=‘peter’
dictC[‘name’]=‘刘德华’
print(dictC)
print(dictA)
print(dictB)

五、字符串操作

1、
Test=‘python’
print(type(Test))
print(‘获取第一个字符%s’%Test[0])
print(‘获取第二个字符%s’%Test[1])
for item in Test:
print(item,end=’ ') #对Test进行遍历

2、
name=‘peter’
print(‘姓名首字母转换大写%s’%name.capitalize()) #capitalize 首字母变大写

3、
a=’ hello ’
b=a.strip() #去除字符串中两边的空格
print(b)

a=’ hello ’
print(a.lstrip()) #删除左边的空格
print(a.rstrip()) #删除右边的空格

4、a=’ hello ’
print(‘a的内存地址%d’%id(a)) #id函数 可以查看一个对象的内存地址

5、dataStr=‘I love Python’
print(dataStr.find(‘M’)) #find函数可以查找目标对象在序列对象中的为值,如果没找到就返回-1

dataStr=‘I love Python’
print(dataStr.index(‘W’)) #index函数检测字符串中是否包含子字符串 返回的是下标值

#index如果没有找到对象的数据 便会报异常，而find函数不会，找不到返回-1

6、dataStr=‘I love Python’
print(dataStr.startswith(‘I’)) #判断开头
print(dataStr.endswith(‘n’))#判断结尾

7、dataStr=‘I love Python’
print(dataStr.lower()) #转换成小写
print(dataStr.upper())#转换成大写

8、strMsg=‘hello world’

#slice [start: end :step] 左闭右开 start<=value<end 范围

print(strMsg) #输出完整的数据
print(strMsg[0])
print(strMsg[2:5]) #2-5下标之间的数据
print(strMsg[2:]) #第三个字符到最后
print(strMsg[:3]) # strMsg[0:3]=strMsg[:3]
print(strMsg[::-1]) #倒叙输出 负号表示方向 从右边往左去遍历

9、# list 合并
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)

10、# 字符串合并
strA=‘人生苦短’
strB=‘我用Python’
print(strA+strB)

11、# 复制 *
listA=list(range(10))
print(listA*3)

12、# in 对象是否存在 结果是一个bool值
strA=‘人生苦短’
listA=list(range(10))
dictA={“name”:“peter”}
print(‘我’ in strA) #False
print(9 in listA) #True
print(“name” in dictA) #True

--------------------------------------------------end-----------------------------------------------------

文章来源: luckystar.blog.csdn.net，作者：爱打瞌睡的CV君，版权归原作者所有，如需转载，请联系作者。

原文链接：luckystar.blog.csdn.net/article/details/108456271