高级数据类型

一组按照顺序排列的值称为序列，python中存在三种内置的序列类型：字符串、列表和元组。序列可以支持索引和切片的操作，第一个索引值为0表示从左向右找，第一个索引值为负数表示从右找。

1.字符串操作

1.1 切片
切片是指选取字符串中的某些数据，语法：字符串[开始下标:结束下标:步长]，切片截取的内容不包括结束下标对应的数据，步长是指隔几个下标获取一个字符，步长默认是1。

 test='hello world'
print('完整字符串%s'%test)
print('%s是第三个到第五个之间的数据'%test[2:5])  #包括下标为2的不包括下标为5的，步长默认为1
print('第三个开始到最后%s'%test[3:])
print('第一个开始到第三个%s'%test[:3])
print('倒叙输出%s'%test[::-1])  #负号表示方向，1是步长，从右向左输出

1.2 常用函数

test=' python '
print(type(test))    #打印test的类型
k=1
for i in test:
    print('第%d个字符是%s'%(k,i))
    k+=1
    pass
print('原本的值%s'%test)
print('首字母大写函数测试%s'%test.capitalize())
print('本身没变%s'%test)
print('stripe函数去除空格后%s这样的'%test.strip())
print('只删除左边的空格%s后'%test.lstrip())
print('只删除右边的空格%s后'%test.rstrip())
print('%s的内存地址%d'%(test,id(test)))
print('是否以p开头%s'%test.startswith('p')) #返回布尔值
print('是否以空格开头%s'%test.startswith(' '))
print('是否以p结尾%s'%test.endswith('p'))
print('是否以空格结尾%s'%test.endswith(' '))
print('大写转换%s'%test.upper())
test1='PYTHON'
print('小写转换%s'%test1.lower())
t=test   #字符串复制，把test的内存地址给了t
print('%s的内存地址是%d'%(t,id(t)))  #之所以叫复制不叫赋值是因为地址都是一样的
print(test.find('P'))  #find函数查找目标在序列中的位置，没有返回-1，有返回下标，如果查找到两个返回第一个
print(test.find('p'))
print(test.index('p'))   #index函数也是查找目标在字符串中的索引值，找到返回下标
print(test.index('P'))   #没找到会报错

2.列表操作

列表是一种有序的集合，可以增删改查其中的元素，数据项可以是任何类型的数据，支持索引和切片操作。

增加函数：append、extend、insert
修改：只要通过索引直接重新赋值就可以
删除函数：pop、remove、del

#定义一个空列表
li=[]
print(type(li))
#len函数可以获取列表中的数据个数或字符串的长度
li1=[1,2.4,"你好",True]
print(len(li1))   #返回列表li1的长度
str='snshj'
print(len(str))
print(li1)  #输出列表
print(li1[0])  #输出第一个元素
print(li1[1:3]) #输出第二个元素到第三个元素
print(li1[::-1]) #倒叙输出
print(li1*3)  #复制延长三次
#列表的增加
li1.append(['fff','ddd'])
li1.append(99)    #什么都能加，也可以加一个列表
print(li1)
li1.insert(1,'在索引值为1的地方插入数据')
#批量增加数据
rs=list(range(10))   #生成十个数并转为列表类型
li1.extend(rs)    #扩展、批量添加
print(li1)
#或者也可以直接扩展一个列表
li1.extend([1,12,34])
print(li1)    #可以从这里看到重复了也会加入进去
#修改
li1[0]='change'
print(li1)
#删除
del li1[0]   #删除列表中第一个元素
print(li1)
#批量删除
del li1[1:7:2] #按步长和范围批量删除
print(li1)
li1.remove(12)  #删除指定元素
print(li1)
li1.pop(2)  #删除指定下标的项
print(li1)
#查找
print(li1.index(1))  #返回元素1的下标，可以看出他返回的是第一个符合的位置
print(li1.index(1,5,19)) #表示返回从索引为5的数据开始查1这个元素，查到索引为19的元素，如果没找到就报错，找到就返回下标
#反转列表
li1.reverse()
print(li1)
print(li1.reverse())

len函数可以输出列表的数据项个数和求得字符串的长度

3.元组操作

元组是一种不可变的序列，创建后不能做任何修改，不能进行增删改，元组中的数据项用逗号分割，可以是任何数据类型，支持切片操作，和列表操作很像，都可以通过下标访问。但是元组中的元素不可以修改，而列表中的元素可以修改；元组使用小括号，列表使用中括号。当元组中只有一个元素时，要加逗号，不然会当作整型处理。
元组只能进行查询，但是可以对元组中的列表修改。

#元组的创建
tua=()   #创建一个空元组
print(type(tua))
print(id(tua))
tua=(1)
print(type(tua))   #如果只有一个数值不加逗号就会解释成int型
print(id(tua))    #重新赋值之后内存地址也变了
tua=(1,)
print(type(tua))   #加上逗号就好了
tua=('ji')
print(type(tua))   #只有一项解释成了字符型
tua=(1,2.3,'heihei',[1,2,'list'])  #创建一个正经元组
print(tua)
#元组的查询
for item in tua:
    print(item,end=" ")
    pass
print('用下标取%s'%tua[2])
print('用切片:')
print(tua[2:4])
print(tua[::-1])  #倒叙输出
print(tua)
print('下标-1的值也就是最后一个:',end=' ')
print(tua[-1])
print('下标-2的值是%s也就是倒数第二个'%tua[-2])
print('下标-3的值是%d也就是倒数第三个'%tua[-3])
print('下标-4的值是%d也就是倒数第四个'%tua[-4])
print(tua[-2:-1:])
#可以对元组中的列表进行修改
tua[3][0]=5678
print(tua)
tub=tuple(range(10))
print(tub)
#统计元组中到底有几个某元素
tub=(1,3,345,1,5,1)
print(tub.count(1))
print(tub.count(3))

4.字典操作

字典可以存储任意对象，是无序集合不是序列，以键值对的方式呈现，{‘key’,‘value’}。当在字典中查找元素时通过键查找。与列表一样，字典可以增删改查。
字典的键只能是不可变类型，比如数字、元组、字符串。

字典的键key不能重复，值value可以重复
如果存在重复的键，后者会覆盖前者

#创建一个空字典
dictA={}
print(type(dictA))
#增
dictA['name']='clis'   #name表示key，clis表示value
dictA['na']='clo'
print(dictA)
#改
dictA['name']='cli'
print(dictA)
print('dictA字典长度为%d'%len(dictA))
print('通过键查找键为name的值%s'%dictA['name'])
dictA.update({'name':'dsfd'})   #用update函数修改，也可以用于增加键值对
print(dictA)
dictA.update({'insert':'haha'})
print(dictA)
#遍历字典
print(dictA.keys())  #获取所有键
print(dictA.values())  #获取所有值
print(dictA.items())  #获取所有的数据项、键值对
for item in dictA.items():
    print(item)
    pass
for key,value in dictA.items():
    print('%s==%s'%(key,value))
    pass
#删除操作
del dictA['name']
print(dictA)
dictA.pop('insert')
print(dictA)
#声明一个有值的字典
dictB={'key2':'value1','key1':'value2'}
print(type(dictB))
print(dictB)
#对字典进行排序，按照ASCII码进行排序
print(sorted(dictB.items(),key=lambda d:d[0]))   #0指按照键排序
print(sorted(dictB.items(),key=lambda d:d[1]))   #1指按照值排序
#这里要注意，排序只能排相同类型的，如果是不同类型的，排不了，会报错

update函数，当更新的键值不存在时，就可以当做增加使用；存在时就更新。

5.共同的方法

#字符串
strA='diyige'
strB='dierge'
print(strA+strB)   #合并
print(strA*3)      #复制
print('yi' in strA)    #看对象是否存在,返回布尔类型的值
print('er' in strA)

#列表
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)      #合并
print(listA*3)          #复制
print(12 in listA)      #看对象是否存在
print(2 in listA)

#元组
tua=(1,3,45,5)
tub=('asd',234)
print(tua+tub)    #合并
print(tub*3)      #复制
print(3 in tub)   #看是否存在
print(3 in tua)  

#字典
dictA={'name':'paul','age':18}
print('aa' in dictA)    #看某值是否为字典的键值
print('name' in dictA)
print('paul' in dictA)