python高级数据类型

序列（字符串、列表、元组）

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

python中存在三种内置的序列类型：

• 字符串
• 列表
• 元组

优点：支持索引和切片的操作
特征：第一个正索引为0，指向的是左端；第一个索引为负数，指向的是右端；

字符串

切片【高级特性】

• 指截取字符串中的其中一段内容。可以根据下标获取序列对象的任意数据（部分或全局）
• 语法结构：[起始下标：结束下标：步长]（[start : end : step])，步长默认为1
• 下标会越界，切片不会

Test='python'
# print(type(Test))
# print('获取第一个字符%s'%Test[0])
# print('获取第二个字符%s'%Test[1])
 for item in Test:
     print(item,end=' ')

# name='peter'
 print('姓名首字母转换大写%s'%name.capitalize())
# a='     hello     '
# # print(a)

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

 print(a.lstrip())   #删除左边空格
 print(a.rstrip())   #删除右边空格

#print('a的内存地址%d'%id(a)) #id()用于查看一个对象的内存地址
 b=a  #复制字符串，在此只是把a对象的内存地址赋给了b，
# print(b)
print('a的内存地址%d'%id(b))
# #### a和b的内存地址是一样的

# find()查找目标对象在序列对象中的位置，返回下标值; 如果目标对象不存在，则返回-1
# index()也可以检测字符串中是否包含子字符串，返回的是下标值;如果目标不存在，会报错，但是find()函数返回-1；
# dataStr='I love python'
print(dataStr.find('on'))
print(dataStr.index('m'))
#
# #startswith()/endwith()来判断字符串以x开始/结尾
print(dataStr.startswith('I'))#判断开头
print(dataStr.endswith('on'))#判断结尾
# #lower()/upper()将字符串数据全部转换为小写/大写；注意这里dataStr本身不变
print(dataStr.lower())#小写
print(dataStr.upper())#大写

##切片
strMsg='hello world'
# slice[start:end:step],左包含右不包含，start<=value<end范围
print(strMsg)   #输出完整的数据
print(strMsg[0])
print(strMsg[2:5])  #2-5下标之间的数据，包括下标2数据，不包括下标5的数据
print(strMsg[2:])   #从下标2一直取到最后，指定一个头，不写尾即可
print(strMsg[0:3])  #第1-3个字符，
print(strMsg[:3])   #取第1-3个字符，前面0可以省略
print(strMsg[::-1]) #倒序输出，负号代表从右往左去遍历

列表list

是一种有序的集合，可以随时添加和删除其中的元素
特点：

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

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可；
列表的下标取值/切片/是否越界与字符串一致，区别就是列表是获取元素；
用for循环可将列表中的元素一个一个取出，取完后退出循环

 li=[]#空列表
 li=[1,2,3,'你好']
 print(len(li)) #len函数可以获取到列表对象中的数据个数
 strA='我喜欢python'
 print(len(strA)) #返回列表元素个数
 print(type(li))

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

 print('*******************增加**********************')
 print('追加之前',listA)
 listA.append(['fff','ddd']) #追加操作
 listA.append(8888)
 print('追加之后',listA)
 listA.insert(1,'这是我刚插入的数据') #插入操作，需要执行一个位置插入
 print(listA)
#
 print(type(range(10)))  #输出为<class 'range'>
 rsData=list(range(10))  #range动态生成一个包含10个元素的序列容器，强制转换为list对象，
 print(type(rsData)) # 输出为<class 'list'>，通过此方法可以快速构建一个列表对象
#
 listA.extend(rsData) #扩展，等于批量添加
 listA.extend([11,22,33,44])  #也是批量增加
 print(listA)

 print('-----------------修改-----------------------')
 print('修改之前',listA)
 listA[0]=33444.8
 print('修改之后',listA)

listB=list(range(10,50)) #生成10-19
print(listB)
print('----------------删除list数据项----------------')
del listB[0] #删除了列表中第一个元素，根据下标
print(listB)
del listB[1:3] # 批量删除多个数据 切片slice，不包括末尾数据
print(listB)
listB.remove(10) #移除指定元素，参数是数据值
listB.pop(5) #pop()移除指定项，参数是索引值
print(listB)
print('----------------index查找----------------')
print(listB.index(19)) #根据元素值返回索引下标
print(listB.index(33,20,25)) #还可以在后面指定查找范围在下标20-25的范围内，查找元素值33，返回下标；如果不存在的话，会报错

元组：不能修改

特点：

• 是一种不可变序列，不能做任何修改
• 用（）创建元组类型，数据项用逗号分割
• 可以是任何的类型
• 当元组中只有一个元素时，要加上逗号，不然解释器会当作整型处理
• 同样可以支持切片操作

元组与列表相似，不同之处在于元组的元素不能修改。元组使用小括号，元组也是通过下标访问
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可；

方法：

• 元组的内置方法count，统计元素在元组中的出现次数
• 元组内置方法index查找指定元素在元组中的下标索引

 元组的创建，不能进行修改，主要为查询、查找
# tupleA=() #空元组
 print(id(tupleA))

 tupleA=('abcd',89,9.12,'petet',[11,22,33]) # 一旦初始化就不能修改

 print(id(tupleA))#两次内存地址不同
# print(tupleA)
 print(type(tupleA)) #类型为<class 'tuple'>

==========================元组的查询===================================
 for item in tupleA:
     print(item,end=' ')
# print()
 print(tupleA[2]) #取下标为2的元素# print(tupleA[2:4]) 
 #输出(9.12, 'petet')，是元组类型，用切片取下标为2-3的元素

 print(tupleA[::-1]) #逆序输出全部元素，输出是元组类型
# #输出([11, 22, 33], 'petet', 9.12, 89, 'abcd')
#
 print(tupleA[::-2]) #反转字符串，2代表步长，负号表示从右到左，因此这里是从右到左输出，步长为2，即下标每次加-2
# #输出([11, 22, 33], 9.12, 'abcd')
#
 print(tupleA[::-3]) #反转字符串，步长为3
# #输出([11, 22, 33], 89)
#
 print(tupleA[-2:-1:])#倒着取下标为-2 到 -1 区间的，包括-2的，不包括-1的
# #输出('petet',)
#
 print(tupleA[-4:-2:])#倒着取下标为-4 到 -2 区间的，包括-4的，不包括-2的，
# #输出(89, 9.12)

 print('===========================是否可以修改元组里面的元素：不可以==========================')
 tupleA[0]='PythonHello'#错误的
 print(tupleA) #报错，不支持修改，错误
 print('===========================是否可以修改元组里面的列表：可以==========================')
 print(type(tupleA[4]))  # <class 'list'>
 tupleA[4][0]=285202 #修改列表中的第一个元素，
 print(tupleA) #修改成功

 tupleB=(1)
 print(tupleB)
 print(type(tupleB)) #<class 'int'>

 tupleB=('1')
 print(type(tupleB)) #<class 'str'>

 tupleB=(1,) #当元组中只有一个数据项时，必须要在数据项后面加上逗号，才是元组类型
 print(type(tupleB)) #<class 'tuple'>
print('==========================count用法:统计元素出现的次数========================')
# tupleC=tuple(range(10)) #将range强类型转换为tuple
tupleC=(1,2,3,4,3,4,4,1)
print(tupleC)
print(tupleC.count(4)) #统计数据项出现的次数

字典：不是序列，不能通过下标访问

• 也是python中重要的数据类型，字典是由 键值对 组成的集合，通常使用键来访问数据，效率非常高，和列表一样，支持对数据的添加、修改和删除操作

特点：

• 不是序列类型，没有下标概念，即不能用索引，是一个无序的键值集合，是内置的数据类型
• 用{}来表示字典对象，每个键值对用逗号分割
• 键必须是不可变的类型【元组、字符串】，值可以是任意类型
• 每个键是唯一的，如果存在重复的键，那么后者会覆盖前者

 如何创建一个字典
# dictA={} #空字典
print('========================添加字典数据=========================')
初始化时候添加
dictA={'pro':'艺术','school':'北京电影学院'}

key:value单独添加
dictA['name']='李易峰'
dictA['age']=30
dictA['pos']='歌手'
#结束添加
# print(type(dictA))
print(dictA) # 输出完整字典
 print(len(dictA)) # 数据长度，有5项，每一项是一个键值对
#
 print('=========================通过键获取值================================')
# print(dictA['name']) #获取name这个键对应的值
#
 print('=========================修改键对应的值：直接修改=======================')
# dictA['name']='谢霆锋'#修改键对应的值
# dictA['school']='香港大学'
# print(dictA)

 print('=========================修改键对应的值：update()=======================')
# #如果update的参数已经存在就修改，不存在的就添加进去
# dictA.update({'age':32})#修改键值
# dictA.update({'height':1.80})#增加身高
# print(dictA)


 print('=========================获取所有的键=======================')
# print(dictA.keys())
# dict_keys(['pro', 'school', 'name', 'age', 'pos'])

 print('=========================获取所有的值=======================')
# print(dictA.values())
# dict_values(['艺术', '香港大学', '谢霆锋', 30, '歌手'])

 print('=========================获取所有的数据项，即键值对=======================')
 print(dictA.items())
 #输出dict_items([('pro', '艺术'), ('school', '香港大学'), ('name', '谢霆锋'), ('age', 30), ('pos', '歌手')])
 #这通常用于for循环输出数据项
 print('=========================for循环获取所有的数据项，即键值对=======================')
 for item in dictA.items():
     print(item)
# ('pro', '艺术')
# ('school', '香港大学')
# ('name', '谢霆锋')
# ('age', 30)
# ('pos', '歌手')
# 进行处理
 for key,value in dictA.items():
     print('%s==%s'%(key,value))
# pro==艺术
# school==香港大学
# name==谢霆锋
# age==30
# pos==歌手

 print('=========================删除操作,del,pop()=======================')
 del dictA['name'] #通过指定键进行删除
 print(dictA)
 dictA.pop('age') #通过指定键进行删除
 print(dictA)

print('=========================对字典进行排序,按照ASCII码=======================')
# 按照key排序
print(sorted(dictA.items(),key=lambda d:d[0]))
# 按照value排序，但是这里value的类型不一致
print(sorted(dictA.items(),key=lambda d:d[1]))

公用方法

print('==========================共有方法操作 +  * in=======================')
# 字符串合并 +
strA='人生苦短'
strB='python是岸'
print(strA+strB)
# 列表合并
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)

# 复制 *
print(strA*3)#打印三次
print(listA*3)

# 判断对象是否存在in,结果是bool类型数据
print('生' in strA) #True
print('我' in strA) #False
print(8 in  listA) #True
dictA={'name':'peter'}
print("name" in dictA) #True
print("age" in dictA) #False