Python高级数据类型—Python Day3

知识点1 字符串
序列：在python当中，序列就是一组按照顺序排列的值【数据集合】
在python中，存在三种内置的序列类型：字符串、列表、元祖
优点：可以支持索引和切片的操作
特征：第一个正索引为0，指向的是左端，第一个正索引为负数，指向的是右端
字符串及常用方法

切片是指截取字符串中的其中一段内容。 切片使用语法：[起始下标：结束下标：步长] 切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符，默认步长为1。
切片高级特征：可以根据下标来获取序列对象的任意【部分】数据
语法结构：[start🔚step] step默认为1
下标会越界，切片不会
字符串操作方法：
1.capitalize() # 首字母变大写
2.endswith/startswith() # 是否 x结束/开始
3. find()#检测x是否在字符串中
4. isalnum()#判断是否是字母和数字
5. isalpha()#判断是否是字母
6. isdigit()#判断是否是数字’abc123’.isdigit()
7. islower()#判断是否是小写
8. join()#循环取出所有值用xx去连接
9. lower/upper #大小写转换
10. swapcase#大写变小写，小写变大写
11. lstrip/rstrip/strip# 移除左/右/两侧空白
12. split()#切割字符串
13. title()#把每个单词的首字母变成大写
14. replace(old, new, count=None)
#old被换字符串，new替换字符串，count换多少个。无count表示全
部替换。
15.count()#统计出现的次数

name = 'python'
name2 = '                hello                '
print('姓名首字母转换成大写%s' % name.capitalize())  # 变首字母大写
print(name2)
print(name2.rstrip())   # 删除右边空格
print(name2.lstrip())    # 删除左两边空格
print(name2.strip())     # 删除左右两边空格

name2 = 'hello'
print(name2.find('o'))  #find返回的是下标值，找不到，不存在的值返回-1
print(name2.index('l'))   #index返回的是下标值，找不到，不存在会报错
print(name2.startswith('h'))  # 判断开头
print(name2.endswith('o'))  # 判断开头
print(name2.upper())  # 小写转大写

切片

strMsg = 'hello world'
print(strMsg)     # hello world
print(strMsg[2:5])  # 后面下标不包含，左闭右开 2-5下标之间的数据 llo
print(strMsg[2:])  # 从第2个开始到最后 llo world
print(strMsg[:3])  # 第1个到第3个的，前面的0可以省略  hel
print(strMsg[::-1])  # 倒叙输出，符号表示方向，从右往左边去遍历  dlrow olleh

列表及常用方法
1.append() # 在列表后面追加元素
2.count() #统计元素出现的次数
3.extend() #扩展，相当于批量添加
4.index() # 获取指定元素索引号
5.insert() #在指定位置插入
6.pop() #删除最后一个元素
7.remove() #移除左边找到的第一个元素
8.reverse() #反转列表
9.sort() #列表排序reverse=True 倒序

list是一种有序的集合，
可以随时添加和删除其中的元素。
Li=[]
Li=[1,2,3,"你好"]
print(len(Li)) # len函数可以获取到列表对象中的数据个数  运行结果4
strA='我喜欢python'
print(len(strA))  # 运行结果9
print(type(Li))     # 运行结果<class 'list'>
print(type(strA))      # 运行结果<class 'str'>

列表常用方法

# -*-coding:utf-8-*-
# Li=[]
# Li=[1,2,3,"你好"]
# print(len(Li)) # len函数可以获取到列表对象中的数据个数  运行结果4
# strA='我喜欢python'
# print(len(strA))  # 运行结果9
# print(type(Li))     # 运行结果<class 'list'>
# print(type(strA))      # 运行结果<class 'str'>
print('--------------查找-----------------------')
listA=['abcd',785,12.23,'qiuzhi',True]
print(listA) #输出完整的列表 运行结果['abcd', 785, 12.23, 'qiuzhi', True]
print(listA[0]) #输出第一个元素  运行结果abcd
print(listA[1:3]) #从第二个开始到第三个元素  [785, 12.23]
print(listA[2:]) #从第三个元素开始到最后所有的元素 [12.23, 'qiuzhi', True]
print(listA[::-1]) #负数从右像左开始输出   [True, 'qiuzhi', 12.23, 785, 'abcd']
print(listA*2) #输出多次列表中的数据【复制】
#输出结果 ['abcd', 785, 12.23, 'qiuzhi', True, 'abcd', 785, 12.23, 'qiuzhi', True]
print('--------------增加-----------------------')
print('追加之前',listA)
listA.append(['fff','ddd']) #追加操作
print('追加之后',listA)  #['abcd', 785, 12.23, 'qiuzhi', True,['fff','ddd']]
listA.append(8888)
print('追加之后',listA)  #['abcd', 785, 12.23, 'qiuzhi', True,['fff','ddd'],8888]
listA.insert(1,'这是我刚插入的数据') #插入操作 需要执行一个位置插入
print(listA)  #['abcd','这是我刚插入的数据', 785, 12.23, 'qiuzhi', True,['fff','ddd'],8888]
rsData=list(range(10)) #强制转换为list对象
print(type(rsData))  #<class 'list'>
listA.extend(rsData) #拓展  等于批量添加
listA.extend([11,22,33,44])
# ['abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44]
print(listA)
print('-----------------修改------------------------')
print('修改之前',listA)
listA[0]=333.6
print('修改之后',listA)
listB=list(range(10,50))

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

元组：是一种不可变的序列，在创建后不可做任何修改
1.不可变
2.小括号（）创建元组类型
3.可以是任何类型
4.当元组中只有一个元素时，要加上逗号，不然解释器会当做整型来处理，同样可以支持切片操作

print('---------------------元组-----------------------')
# 元组的创建,不能进行修改,只能查找
tupleA=() #空元组
print(type(tupleA))
tupleA=('abcd',89,9.12,'peter',[11,22,33])
print(tupleA)
tupleB=('1',)  # 当元组中只有一个数据时，后面要加一个，号
print(type(tupleA))
print('--------------------元组查询---------------------')
for item in tupleA:
    print(item)
print(tupleA[2])  #取元组中的第二个元素9.12
print(tupleA[2:4])  #取元组中的第二个元素(9.12, 'peter')
print(tupleA[::-1])  #负数是反向取元组中元素([11, 22, 33], 'peter', 9.12, 89, 'abcd')
print(tupleA[::-2])  #负数是反向取元组中元素,隔一个取一个
print(tupleA[-2:-1:])  #最后一个-1 倒数第二个-2 取出来就是peter
#可以对元组中的列表进行修改
print(tupleA[4][0])
tupleA[4][0]=123
print(tupleA[4][0])
print('-----------------元组出现次数-------------------')
tupleC=(1,2,3,4,3,4,4,1)
print(tupleC.count(4)) #可以统计元素出现的次数
print(tupleC.index(3)) #可以统计元素3出现的位置，运行出3所在的位置2

字典及常用方法
字典是Python的中重要的一种数据类型，可以存储任意对像。
字典是以键值对的形式创建的{‘key’:‘value’}利用大括号包裹着。
字典中找某个元素时，是根据键、值字典的每个元素由2部分组成，键:值
访问值的安全方式get方法，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值
注意点：
1、字典的键（key）不能重复，值（value）可以重复。
2、字典的键（key）只能是不可变类型，如数字，字符串，元组。
3、字典也可以跟list一样支持添加、修改、删除
4、字典是无序的，键值的集合

print('----------------字典添加-----------------')
#dictA={}  #  空字典，没有任何数据
dictA={'Pro': '艺术', 'School': '北京音乐'}
dictA['Name']='李易峰'
dictA['Age']='30'
dictA['Pos']='歌手'
print(dictA)
print(len(dictA))
print('----------------字典查找修改----------------')
print(dictA['Name'])    #  通过键获取对应的值
dictA['Name']='谢霆锋'  #  修改键获取对应的值
dictA['School']='香港大学'  #  修改键获取对应的值
dictA.update({'Age':32})  #update修改
dictA.update({'High':1.85})  #update增加
print(dictA)
print('----------------获取所有键/值----------------')
print(dictA.keys())    #获取所有键
print(dictA.values())   #获取所有值
print(dictA.items())    #获取所有键值对
for key,value in dictA.items():
    print('%s==%s'%(key,value))
print('----------------字典删除----------------')
del dictA['High']
print(dictA)
dictA.pop('Age')
print(dictA)
print('----------------字典排序----------------')
print(sorted(dictA.items(),key=lambda d:d[0]))  #按sky进行排序
print(sorted(dictA.items(),key=lambda d:d[1]))  #按value进行排序

共有方法
合并操作 +
两个对象相加操作，会合并两个对象
适用于字符串，列表，元组
复制
对象自身按指定次数进行 + 操作
适用于字符串，列表，元组
in 判断元素是否存在
判断指定元素
是否存在于对象中，返回一个bool值
适用于字符串,列表,元组,字典

print('---------------合并(+/*)-------------')
print('----------字符串合并---------')
strA='人生苦短'
strB='我用python'
print(strA+strB)
print(strA*3)
print('----------列表合并---------')
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)
print(listA*3)
print('----------元组合并---------')
tupleA=('a','b','d')
tupleB=('e','f','g')
print(tupleA+tupleB)
print(tupleA*3)
print('---------------in 判断元素-------------')
print('生' in strA)
print(9 in listA)
print('a' in tupleA)
dictA={'Name':'李易峰','Age':'30','School':'北京电影',}
print('Name' in dictA)