python高级数据类型

目录

序列

切片

字符串

列表

元组

字典

共有操作

---

序列

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

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

字符串、列表、元组

优点：可以支持索引和切片的操作。

特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端。

切片

切片：可以根据下表来获取序列对象的任意部分数据。

语法结构：[start:end:step] step默认1。

slice [star:end:step] --左闭右开
strMsg="hello world"
print(strMsg)
print(strMsg[0])
print(strMsg[2:5]) #2-5下标之间的数据
print(strMsg[2:])
print(strMsg[0:3]) #strMsg[0:3]=strMsg[:3]
print(strMsg[::-1]) #倒序输出 负号方向 从右向左遍历

字符串

字符串是可以通过下标访问的。

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

 字符串中有一些常用的函数，我们举例说明。

1.capitalize()可以将首字母大写

name="peter"
print("首字母打写%s"%name.capitalize())

2.strip() 去除字符串中的空格

lstrip()去除字符串左边的空格，rstrip去除字符串右边的空格。

a="   hello   "
b=a.strip() #去除字符串中的空格
print(b)
print(a.lstrip())#去除字符串左边的空格
print(a.rstrip())#去除字符串右边的空格

3. id函数可以查看一个对象的内存地址。

print("a的内存地址%d"%id(a)) #id函数可以查看一个对象的内存地址
b=a #在此只是把a的内存地址赋给了b
print("a的内存地址%d"%id(b))
print(b)

4.

find()函数返回是下标值，如果没有找到返回-1

index()函数也是返回下标值，但是没有找到会报错

startswitch()函数判断字符串的开头

endswitch()函数判断字符串的结尾

lower()函数转换成小写

upper()函数转换成大写

dataStr="I love python"
print(dataStr.find("p")) #返回的是p的下标值,当没有找到就返回-1
print(dataStr.index("v")) #index函数作用与find相同--获取对象的下标，但是如果没找到就会报错
print(dataStr.startswith("I")) #判断开头
print(dataStr.endswith("n")) #判断结尾
print(dataStr.lower()) #转换成小写
print(dataStr.upper()) #转换成大写

列表

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

特点：

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

列表的创建：

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

查找：

listA=['abcd',785,12.23,'qqiuzhi',True]
print(listA) #输出完整的列表
print(listA[0]) #输出第一个元素
print(listA[1:3]) #2-3个元素
print(listA[2:]) #从3到最后
print(listA[::-1]) #倒序输出
print(listA*2)#输出两次

增加：

listA=['abcd',785,12.23,'qqiuzhi',True]
print("追加之前",listA)
listA.append(['fff','ddd']) #append追加
listA.append(8888)
print("追加之后",listA)
listA.insert(1,'这是我刚插入的数据') #插入到第二个数据之后
print(listA)
rsData=list(range(10)) #强制转换为list对象
listA.extend(rsData) #扩展--批量添加
listA.extend([11,22,33,44])
print(listA)

修改：

listA=['abcd',785,12.23,'qqiuzhi',True]
print("修改之前",listA)
listA[0]="peter"
print("修改之后",listA)

 删除：

listA=['abcd',785,12.23,'qqiuzhi',True]
del listA[0]  #del删除列表中第一个元素
del listA[1:3] #批量删除多项数据
listA.remove('abcd') #移除指定的元素
listA.pop(0) #移除指定索引值所对应的元素
print(listA)
print(listA.index('abcd')) #返回出对应的下标值
print(listA.index(785,1,3)) #从第一个元素开始查，查找的长度为3

元组

元组：是一种不可变的序列，在创建之后不能做任何的修改。

特点：

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

元组创建

tupleA=() #空元组
tupleA=('abcd',89,9.12,'peter',[11,22,33])
print(tupleA)

元组的查询

tupleA=('abcd',89,9.12,'peter',[11,22,33])
for item in tupleA:
    print(item,end=' ')
print(tupleA[2:4])
print(tupleA[::-1]) #从右向左
print(tupleA[::-2]) #表示反转字符串，隔一个取一个
print(tupleA[-2:-1:]) #包含下标为-2，不包含-1的
print(tupleA[-4:-2:])

元组中列表的修改

tupleA=('abcd',89,9.12,'peter',[11,22,33])
tupleA[4][0]=285
print(tupleA)  #表示元组中的列表进行修改

元组中需要注意的：

tupleB=(1,) #只有一个元素必须加逗号
print(type(tupleB))
tupleC=tuple(range(10)) #强制转换
print(tupleC.count(8)) #统计8在数据项出现的次数

字典

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

特点：

1：不是序列类型 没有下标的概念，是一个无序的键值集合，是内置的高级数据类型
2：用{} 来表示字典对象，每个键值对用逗号分隔
3：键必须是不可变的类型【元组、字符串】 值可以是任意的类型
4: 每个键必定是惟一的，如果存在重复的键，后者会覆盖前者

 字典创建和添加：

#创建字典
dictA={"pro":'艺术','shcool':'北京电源学院'} #key:value
dictA['name']="李易峰" #左边是key 右边是value
dictA['age']='30'
dictA['pos']='歌手'
print(dictA)

修改和键获取：

dictA={"pro":'艺术','shcool':'北京电源学院'}
dictA['name']="李易峰" #左边是key 右边是value
dictA['age']='30'
dictA['pos']='歌手'
print(dictA['name']) #通过键获取对应的值
dictA['name']='谢霆锋' #修改键对应的值
dictA['shcool']='香港大学'
dictA.update({'age':32}) #updata可以修改或者添加
dictA.update({'heigth':1.80})
print(dictA)

获取所有的键值：

dictA={"pro":'艺术','shcool':'北京电源学院'}
dictA['name']="李易峰" #左边是key 右边是value
dictA['age']='30'
dictA['pos']='歌手'
#获取所有的键
print(dictA.keys())
# 获取所有的值
print(dictA.values())
#获取所有的键和值
print(dictA.items())
for key,value in dictA.items():
    print("%s==%s"%s(key,value))

删除：

dictA={"pro":'艺术','shcool':'北京电源学院'}
dictA['name']="李易峰" #左边是key 右边是value
dictA['age']='30'
dictA['pos']='歌手'
del dictA['name'] #通过指定键进行删除
dictA.pop('age')#通过指定键进行删除
print(dictA)

字典排序：

dictA={"pro":'艺术','shcool':'北京电源学院'}
dictA['name']="李易峰" #左边是key 右边是value
dictA['age']='30'
dictA['pos']='歌手'
#按照key排序
print(sorted(dictA.items(),key=lambda d:d[0])) #sorted排序函数
#按照value排序
print(sorted(dictA.items(),key=lambda d:d[1])) #类型必须一直才可以排序

这里需要注意按照值排序时，一定要保证所有类型一致。

共有操作

共有方法：+ * 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(22 in listA) #False
dictA={'name':'peter'}
print('age' in dictA)