2021小白Python入门学习记录Day3（win10系统、Python3.9、使用Pycharm）python高级数据类型(字符串、列表、元组、字典、集合) 及其操作

capitalize() #首字母变大写
endswith/startswith() #判断是否以x结束/开始
find() #检测x是否在字符串中，返回的是第一个的下标值,没有找到返回-1
isalnum() #判断是否是字母和数字
isalpha() #判断是否是字母
isdigit() #判断是否是数字
islower() #判断是否是小写
join() #循环取出所有值用xx去连接
lower/upper #大小写转换
swapcase #大写变小写，小写变大写
lstrip/rstrip/strip #移除左/右/两侧空格
split() #分割字符串
title() #把每个单词的首字母变成大写
replace(old,new,count=None) #old被换字符串，new替换字符串，count换多少个。无count表示全部替换
count() #统计出现的次数
index() #检测字符串中是否包含子字符串，返回的是第一个的下标值,没有找到报错
len()可获取字符串长度，列表中的数据个数
.reverse()反序

后续补充序列操作内置函数（在 #序列操作内置函数（补充））：

all() #判断可迭代参数（str、列表、元组）中所有元素是否都为True 除了0、空(''或None)、False外都算True（空列表，空元组返回True）类似and
any() #判断可迭代参数（str、列表、元组）中是否有一个元素为True 有一个为True 就返回True 类似or
sorted() #对所有可迭代的对象进行排序操作
list的sort()返回的是对已经存在的列表进行操作（修改），而内建函数sorted返回的是一个新的list，而不是在原来的基础上进行的操作
reversed() #对所有可迭代的对象进行反序操作
list的reverse() list反转对已经存在的列表进行操作（修改）
zip() # 将可迭代对象中的元素打包成一个个元组组成的列表或者元组每项为一个元组
enumerate() 将一个可遍历的数据对象组合成一个索引序列一般用于for循环每项为一个元组
list(enumerate(对象,[start=0]))

（一）字符串 str

1.字符串定义

Test='python'     # 定义一个字符串
print(type(Test))     #  查看数据类型
print('获取第一个字符%s'%Test[0])
print('获取第二个字符%s'%Test[1])
for item in Test:            # 序列遍历  这里是字符串 （列表、元组都适用）
    print(item,end=' ')  # 改变end参数为空格

运行结果：

序列的下标都是从0开始的Test[0]为第一个元素

2.部分字符串操作

（1）.capitalize() .lower() .upper() #大小写变换

name='peter'
print('姓名首字母转换大写%s'%name.capitalize()) # .capitalize首字母转换大写
print(name.lower())  # lower全变小写
print(name.upper())  # upper全变大写

运行结果：

（2）.strip() #去除空格 lstrip 、rstrip

a='       hello            '
b=a.strip()  #去除两边空格
print(b)
print(a.lstrip()) #删除左边空格
print(a.rstrip()) #删除右边空格

运行结果：

（3）id()函数可以查看一个对象的内存地址（变量都能使用，并非序列专用）

通过b=a来复制字符串只是把a对象的内存地址付给了b

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

运行结果：

（4）.find() 和 .index() 查找（find为字符串专用，）

dataStr='I love python p'
print(dataStr.find('p')) # .find找到目标对象在序列对象的第一个下标值 下标值从0开始
print(dataStr.find('love')) # .find找到第一个字母下标值
print(dataStr.find('1')) # .find没有找到返回-1
print(dataStr.index('p')) #检测字符串中是否包含子字符串，返回的是第一个的下标值  index没找到会报错

运行结果：

find 和 index 的区别：find没找到时返回 -1 ；index没找到会报错

都是返回首次找到的下标

（5）.startswith() 和 .endswith() 首尾判断

dataStr='I love python p'
print(dataStr.startswith('I')) #判断是否为 I 开头 这里返回True
print(dataStr.endswith('s'))   #判断是否以 s 结束 这里返回False

运行结果：

（6）len() 获取字符串长度（可以获取列表或元组的数据个数）

strA='我喜欢python'
print(len(strA)) #len()可获取字符串长度，列表中的数据个数

运行结果：

（7）split() #分割字符串

a='sad s a 4 6 87'
print(a.split(' '))  # 括号里填写把什么当作分隔符  这里我用空格 返回一个列表

运行结果：

3.字符串切片

# 字符串切片
strMsg='hello world'
# slice [start:end:step]
print('输出完整的数据：'+strMsg) # 输出完整的数据  可以用加号来合并字符串
print('输出第一个字符：'+strMsg[0]) #输出第一个字符
print('输出第一个到第8个字符步长为2：'+strMsg[0:9:2])
print('这里取到下标为2，3，4的数据：'+strMsg[2:5]) #不包含右侧  这里取到下标为2，3，4的数据
print('第三个字符到最后：'+strMsg[2:]) #第三个字符到最后
print('首位到下标为2的数据：'+strMsg[:3]) #0-2
print('倒序输出：'+strMsg[::-1]) #倒序输出 负号表示方向从右向左遍历
print('倒序输出-3到-8：'+strMsg[-3:-9:-1]) #倒序输出 负号表示方向从右向左遍历
print('错误示范：'+strMsg[-3:-2:-1]) #倒序输出 没有数据

运行结果：

这里注意在序列（字符串、链表、元组）中不管是正序还是倒序每个字符对应的下标都是不会变的

切片时首下标和尾下标要按步数规定的顺序写（可以正负下标混用），如果错误就会像错误示范一样没有数据输出

正序和倒序切片时都不含end下标（末位）的字符（左闭右开）

（二）列表 list

1.列表简介

列表list：python中非常重要的数据结构，是一种有序的数据集合
特点：
1.支持增删改查
2.列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
3.用[]来表示列表类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据
4.支持索引和切片来进行操作

2.定义一个列表

# 列表
li=[] #空列表
li=[1,2,3,'你好']
print(type(li))
print(li)

运行结果：

3.列表操作

append() 追加
insert(位置下标，插入内容) 插入
len() 获取数据个数前面讲过
extend() 扩展，相当于批量追加
index(查找物，从哪开始查，到哪结束) #检测字符串中是否包含子字符串，返回的是第一个的下标值,没有找到会报错
del 删除
remove() 移除具体数据项
pop() 移除某个下标对应的数据项

我们先定义一个列表

listA=['abcd',35,11.22,'q1i',True]

（1）.append() 追加

print('------------追加----------append-------')
print('追加之前',listA)
listA.append(['fff','ddd'])
listA.append('ppap')
listA.append(8888)
print('追加之后',listA)

运行结果：

（2）.insert(位置下标，插入内容) 插入

print('------------插入----------insert-------')
listA.insert(1,'这是我刚插入的数据')
listA.insert(1,8888)
print(listA)

运行结果：

（3）.extend() 扩展，相当于批量追加

print('------------批量追加-------extend-------')
rsdata=list(range(6)) #强制转换为list对象   0~5  range默认从0开始
# print(type(rsdata))
listA.extend(rsdata)
listA.extend([888,999,99])
print(listA)

运行结果：

（4）修改

print('------------修改-----------------------')
listA[0]=88888    #直接修改对应下标的项
print('修改之后',listA)

运行结果：

（5）del 删除（del可以用在很多地方这里不细讲）这里新定义了一个listB

print('------------删除-------------del-------')
listB=list(range(10,30))  #新定义一个列表
print(listB)   #输出完整列表
del listB[0]     #删除第一项的
print(listB)   
# 批量删除
del listB[1:3] #删除第二到第三项 相当于删除对应切片
print(listB)

运行结果：

（6）.remove() 移除具体数据项

print('------------移除具体数据项-------------remove-------')
listB.remove(20) #移除指定项
print(listB)

运行结果：

（7）.pop() 移除某个下标对应的数据项

print('------------移除相应下标的数据项-------------pop-------')
listB.pop(1)   #移除下标1对应的项
print(listB)

运行结果：

注意：.remove()和.pop() 是有区别的一个是移除具体的数据项后一个是移除对应下标的数据项

（8）.index(查找物，从哪开始查，到哪结束) #检测字符串中是否包含子字符串，返回的是第一个的下标值,没有找到会报错

print('------------查找具体数据项的下标-------------index-------')
print(listB.index(19,3,6))   
#这里相当于是在下标为3-5（不含右侧6）（相当于第4，5，6项）的数据项中查找 19 这个数据

运行结果：

4.列表切片

# 切片
listA=['abcd',35,11.22,'q1i',True]
print(listA) #输出完整的对象
print(listA[0]) #输出第一个元素
print(listA[1:3]) #第二个到第三个元素
print(listA[2:]) #从第三个开始到最后所有元素
print(listA[::-1]) #负数从右向左开始输出
print(listA*2) #输出两次  输出多次列表中的数据*n

运行结果：

序列的切片都是类似的这里有一个listA*2 相当于listA+listA 这种操作在序列中都可用

（三）元组 tuple

1.元组简介

元组tuple：是一种不可变的序列，在创建之后，不能做任何的修改
1.不可变（但是可以更改元组内的列表内的项）比如([0,2],'a',3)的[0,2]内数据可变
2.用()创建元组类型，数据项用逗号来分割
3.可以是任何的类型
4.定义一个元组时，当元组中只有一个元素时，要加上逗号，不然解释器会当作整形来处理
5.同样支持切片操作

2.定义一个元组

tupleA=() #空元组
tupleA=('abcde',89,9.12,[11,22,33],(11,2))  
print(type(tupleA))
print(tupleA)

运行结果：

3.元组操作和注意事项

（1）更改元组中的列表项（使用上面定义的tupleA）

元组不可变（但是可以更改元组内的列表内的项）比如([0,2],'a',3)的[0,2]内数据可变

print(type(tupleA[3]))  #该数据项为列表类型
tupleA[3][0]=12   # 则可以更改元组内的列表 相当于改变元组下标为3的项的列表的首项为12
print(tupleA)

运行结果：

（2）定义一个元组时，当元组中只有一个元素时，要加上逗号，不然解释器会当作整形来处理

tupleB=(1)
print(type(tupleB))  # 为int
tupleB=('1')
print(type(tupleB))  # 为str
tupleB=(1,)           #此时才为元组tuple
print(type(tupleB))

运行结果：

（3）.count() 统计元素个数序列通用（字符串使用时括号内要为字符串类型）

tupleC=(0,1,1,2,3,4,1)
print(tupleC.count(1)) #统计元素个数

运行结果：

4.元组切片

# 元组切片
print(tupleA[2:4]) #切片
print(tupleA[::-1]) # 倒序
print(tupleA[::-2]) # 倒序步长为2   步长决定顺序，下标不变
print(tupleA[-4:-1:1]) #下标0 1 2 3 4  分别负下标 -1 -2 -3 -4 -5 且不变
print(tupleA[:0:-1])  # 倒序到第一个
print(tupleA[-1:-4:-1])
print(tupleA[-1:-5:1]) #为空 步数规定顺序为正序 而start和end为倒序不一致  则没有数据

运行结果：

# 序列操作内置函数（补充）

all() #判断可迭代参数（str、列表、元组）中所有元素是否都为True 除了0、空(''或None)、False外都算True（空列表，空元组返回True）类似and
any() #判断可迭代参数（str、列表、元组）中是否有一个元素为True 有一个为True 就返回True 类似or
sorted() #对所有可迭代的对象进行排序操作
（list的sort()返回的是对已经存在的列表进行操作（修改），而内建函数sorted返回的是一个新的list，而不是在原来的基础上进行的操作）
reversed() #对所有可迭代的对象进行反序操作
（list的reverse() list反转对已经存在的列表进行操作（修改））
zip() # 将可迭代对象中的元素打包成一个个元组组成的列表或者元组每项为一个元组
enumerate() 将一个可遍历的数据对象组合成一个索引序列一般用于for循环每项为一个元组
list(enumerate(对象,[start=0]))

（1）all() #判断可迭代参数（str、列表、元组）中所有元素是否都为True 类似and

除了0、空(''或None)、False外都算True（空列表，空元组返回True）

# all()
print(all([]))   #True   空列表，空元组返回True
print(all(()))   #True   空列表，空元组返回True
print(all([1,2,3,4,False]))  #False
print(all([1,2,3,0]))  #False
print(all([1,2,3,'']))  #False
print(all([1,2,3,None]))  #False

运行结果：

（2）any() #判断可迭代参数（str、列表、元组）中是否有一个元素为True 有一个为True 就返回True 类似or

# any()
print(any([1,None,'',0,False]))    #结果为True
print(any([None,'',0,False]))      #False

（3）sorted() #对所有可迭代的对象进行排序但没有改变原对象

sort()为列表专用可以改变原列表

# sort()为列表专用
li1=[1,5,6,3]
print(li1)               #  运行结果：[1, 5, 6, 3]
li3=li1        # 前面介绍过这里相当于传的内存地址  所以后续变一个 两个都变 在其他操作中类似
li1.sort()            #直接在原列表中排序
print(li3,li1)               #运行结果：[1, 3, 5, 6] [1, 3, 5, 6]两都会变

sorted()内置函数就不会更改原对象

print(sorted(li2))     #[1, 5, 21, 51, 798] 默认升序
print(li2)          #[1, 5, 798, 51, 21] 不会变
print(sorted(li2,reverse=False))   #[1,5,21,51,798]   reverse=False升序
print(sorted(li2,reverse=True))   #[798,51,21,5,1]   reverse=True降序
print(sorted(['a','f','D','S','z']))  #['D','S','a','f','z'] 默认先大写A~Z再小写a~z
print(sorted(['a','f','D','S','z'],key=str.lower))        #['a','D','f','S','z'] 
# key=str.lower不区分大小写a~z排序
tupleA=(10,5,7,4,9)
print(sorted(tupleA,reverse=False))    #[4, 5, 7, 9, 10]   排元组返回列表

运行结果：

（4）reversed() #对所有可迭代的对象进行反序操作但没有改变原对象

reverse()为列表专用可以改变原列表对原列表进行反序变换

# reverse()列表专用
lia=[1,5,7,6]
lia.reverse()
print(lia)     # 结果为：[6, 7, 5, 1]  反序

reversed() 反序但不改变原对象打印时要加上类型

lib=[1,2,3,4,5]
print(tuple(reversed(lib)))    # 结果为：(5, 4, 3, 2, 1)  必须加类型
print(list(reversed(lib)))  # [5, 4, 3, 2, 1]
print(list(reversed(range(10))))  #[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

（5）zip() # 将可迭代对象中的元素打包成一个个元组组成的列表或者元组每项为一个元组

# 打印时必须加上类型不然报错

# zip()
print(list(zip([1,2,3],['a','b','c','d','e'],[11,12,13]))) 
# 打印时必须加上类型  [(1, 'a', 11), (2, 'b', 12), (3, 'c', 13)]
print(tuple(zip([1,2,3],['a','b','c','d','e'])))   ((1, 'a'), (2, 'b'), (3, 'c'))
print(tuple(zip([1,2,3],)))  ((1,), (2,), (3,))

运行结果：

（6）enumerate() 将一个可遍历的数据对象组合成一个有序号的索引序列一般用于for循环每项为一个元组

枚举序列：这里用列表

# enumerate()  #枚举对象
listobj=['a','b','c','d']
for index,item in enumerate(listobj,start=4):   #start默认从0开始
    print(index,item)
    pass
print('------------------------------')

运行结果

也可以用来枚举字典：

# 定义一个字典
dicobj={}
# 录入键值对
dicobj['name']='李飞'
dicobj['hobby']='体操'
dicobj['pro']='运动员'
print(dicobj)
for item in enumerate(dicobj.values()):
# 枚举字典的值 也可以用.key()枚举健 #用.item()枚举键值组成的元组
    print(item)

运行结果：

二、非序列类型（无序）字典和集合

（一）字典 dict

1.字典简介

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

2.字典的多种创建方式

（1）直接输入创建

#字典 dict
#如何创建字典
dictA={}  #空字典
# print(type(dictA)) #dict类型
dictA={'pro':'游泳','school':'北体'} #直接输入创建
# print(dictA)

运行结果：

（2）传入关键字法创建字典

dicB=dict(wds='wadfasd',agggee=188)    # 传入关键字
print(dicB)      #{'wds': 'wadfasd', 'agggee': 188}

运行结果：

（3）映射函数方式来构造字典

dicC=dict(zip(['one','tow','three'],[1,2,3]))   # 映射函数方式来构造字典
print(dicC)      #{'one': 1, 'tow': 2, 'three': 3}

运行结果：

（4）可迭代对象方式来构造字典

dicD=dict([('a',1),('b',2),('c',3)])     # 可迭代对象方式来构造字典
print(dicD)      #{'a': 1, 'b': 2, 'c': 3}

运行结果：

3.字典操作

.keys 获取所有键
.values 获取所有值
.items 获取所有项其中每一项都为一个元组item=(key,value)
.update({'':}) #update更新或新增
.pop 或 del 通过键删除取出

（1）添加字典数据接着上面（1）的 dictA

#添加字典数据
dictA['name']='李飞' #key:value    键：值
dictA['age']='21'
dictA['pos']='运动员'
#结束添加
print(dictA) #输出完整的字典
print(len(dictA)) #数据长度

运行结果：

（2）通过键获取值或修改值

print(dictA['name'])    #通过键获取对应的值
dictA['name']='吴凡'  #通过键修改值
print(dictA)

运行结果：

（3）.update() 更新键对应的值或者新增键值对

dictA.update({'age':'19'})  #update修改
dictA.update({'heigh':'1.86'})  #update新增
print(dictA)

运行结果：

（3）.keys() .value() .items()

# 获取所有的键
print(dictA.keys())
# 获取所有的值
print(dictA.values())
# #获取所有的键和值
print(dictA.items())

运行结果：

（4）挨个输出所有键值对

for item in dictA.items():
    print(item)     #挨个输出所有的键和值

运行结果：

结果为一个个的元组

也可以按自己定格式取：

for key,value in dictA.items():
    print('%s==%s'%(key,value))  #挨个按格式取

（5）del删除和 pop 取出

#删除
del dictA['name'] #删除
print(dictA)

print(dictA.pop('age'))  #pop 取出  pop是有返回值的
print(dictA)

运行结果：

del 是删除键是'name'的条目

pop() 方法删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。否则，返回 default值所以pop() 更相当于取出

（6）了解字典怎么排序（仅了解）

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

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

运行结果：

（二）集合 set

1.集合简介

set(集合) 也是python中的一种数据类型，是一个 无序 且 不重复 的元素集合  不支持索引和切片
类似于字典 但只有key 没有value

2.创建一个集合

# 创建集合
set1={1,2,'a',100}     #直接创建
print(type(set1))    # set类型
list1=[1,2,'c','a']
set2=set(list1)     #强转为集合
print(set2)

注意：空集合默认为字典类型

3.集合操作

# 集合操作内置函数
# add()         #增添
# clear()       #清空
# difference()  #a.difference(b) 两个集合的差集，a中存在，b中不存在的 也可用a-b
# intersection()  #a.intersection(b)   取交集     也可用a&b
# union()         #a.union(b)   取并集     也可用a | b
# pop()     #随机从集合中拿出某个数据（拿出后移除）
# discard()  #指定数据移除
# update()   #更新集合 a.update(b) 把b数据增添进a 改变了a

（1）.add() #增添

# add
set2.add('python')    #增添
print(set2)

运行结果：

注意：集合是无序的所以每次运行结果都可能不一样

（2）.clear() #清空

# clear
set2.clear()             #清空
print(set2)

运行结果：

# 下面（3）（4）（5）为集合的差集并集交集运算

（3）.difference() #a.difference(b) 两个集合的差集，a中存在，b中不存在的也可用a-b

# # 差集
set1={1,2,'a',100} 
set3={1,2,3}
print(set1.difference(set3))     #a.difference(b) 两个集合的差集，a中存在，b中不存在的
print(set1-set3)                #a.difference(b)相同作用

运行结果：

（4）.intersection() #a.intersection(b) 取交集也可用a&b

# 交集
print(set1.intersection(set3))     #a.intersection(b)   取交集
print(set1&set3)                  #a.intersection(b)相同作用

运行结果：

（5）.union() #a.union(b) 取并集也可用a | b

# 并集
print(set1.union(set3))          #a.union(b)   取并集
print(set1 | set3)                  #a.union(b)相同作用

运行结果：

（6）.pop() #随机从集合中拿出某个数据（拿出后移除）相当于取出

# pop  随机取出
print(set1)
qudata=set1.pop()
print(qudata)
print(set1)

运行结果：

（7）.discard() #指定数据移除

# discard()  #指定数据移除
print(set1)
set1.discard(100)
print(set1)

运行结果：

（8）.update() #更新集合 a.update(b) 把b数据增添进a 改变了a

# update
set4={3,4,5,'m'}
print(set4)
print(set3)
set4.update(set3)             #a.update(b) 把b数据增添进a 改变了a
print(set4)

运行结果：

（9）set 不重复特性

set0={1,1,0,0,0,3,3,3}
print(set0)

运行结果：

三、部分公有操作：合并+ 复制* 判断对象是否存在in

1.合并

# 合并+
# 字符串合并
strA='人生苦短'
strB='我用python'
print(strA+strB)
# 列表合并
listA=list(range(10))
listB=list(range(10,20))
print(listA+listB)

运行结果：

2.复制

# 复制*
print(strA*3)
print(listA*3)

运行结果：

3.判断对象是否存在

# 对象是否存在in
print('------字符串------')
print('生'in strA)  #结果为True

print('-------列表-------')
print(10 in listA)  #False

print('-------字典-------')
dictA={'name':'sam'}     
print('age'in dictA)   #False
print('name'in dictA)  #True
print('sam'in dictA)  #False 在字典中in 对象只能是键 不能是值否则返回False

print('--------集合-------')
setA={'wuhu',88}
print(88 in setA)    #True

运行结果：