python 数据类型——字符串str、列表list、元组tuple、字典dict

python 数据类型——字符串str、列表list、元组tuple、字典dict

#---------------------字符串str------------------------------------
'''
python的序列：一组按照顺序排列的值【数据集合】
在python中存在三种内置的序列类型
字符串、列表、元组
优点：支持索引和切片的操作
特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端
切片：截取字符串中的一段内容，支持下标
切片的使用语法：[起始下标:结束下标：步长]，默认步长为1
下标会越界，切片不会
'''
test='python'
#print(type(test))
print("获取第一个字符%s"%test[0])

for item in test:
    print(item,end=" ")
    if item=="p":
        break
        pass
    pass

name="peter"
print("我的首字母发泄大写英文名：%s"%name.capitalize())

a='   hello '
b=a.strip() #删除字符串中所有空格
print(b,end=",")
print(a,end=",")
c=a.lstrip() #删除字符串左边空格
print(c,end=',')
d=a.rstrip()
print("%s,"%d) #删除字符串右边空格


a=1
b=3
a=b
print(id(a),id(b))  #id()查找内存地址


dataStr='i love pythonp'
print(dataStr.find('p'))  #返回查找对象在序列对象中第一个的下标值
#不存在时，找不到返回-1

print(dataStr.index('v'))
#与find()相似，检测字符串中是否包含子字符串，返回的是下标值
#区别是index如果找不到，便会报异常，而find函数和返回-1
print(dataStr.startswith('i'))
print(dataStr.lower())
'''
'''
strMsg='hello world'
print(strMsg[2:5])  #左闭右开
print(strMsg[2:]) #末尾可省略
print(strMsg[:3]) #从开头开始可省略
print(strMsg[::-1]) # 倒叙输出
'''
'''
-----------------list列表-------------------
list:python中非常重要的数据结构，一种有序的数据集合
特点：
1.支持增删改查
2.列表中的数据可变化
3.[]声明列表，数据项之间用逗号分隔，注意：数据项可以是任何类型的数据
4.支持索引和切片（与字符串一致）
'''
'''
li=[] #空列表
li=[1,2,3,'你好']
print(len(li)) #len函数可以获取到列表对象中的数据个数
strA='i like python'
print(len(strA)) #字符串本身就是一个序列
#查找
listA=['afd',1,3,4,'wf',True]
print(listA)
print(listA[1:4])  #切片获取
print(listA[2:])
print(listA[-1:-3:-1])
print(listA*2)  #输出多次列表数据

#增加 append、insert、extend
#append:手动追加
#insert：插入数据
#extend：批量追加
listA=['afd',1,3,4,'wf',True]
listA.append(['dg','we'])  #追加操作，追加什么都可以
print(listA)
listA.insert(1,'这是我插入的数据') #插入操作，需要指定插入数据的位置
print(listA)

rsData=range(10)  #类型是range
print(type(rsData))
rsData=list(range(10))  #类型转换操作
a=listA.extend(rsData)
b=listA.extend(range(10))
print(listA)
print(a,b)

#修改
listA=['afd',1,3,4,'wf',True]
listA[0]='peter'
print(listA)

#删除
# del关键字、remove、pop
listB=list(range(10,50))
print(listB)
del listB[0]
print(listB)
del listB[:10]
print(listB)
listB.remove(20)  #只能单个的移除“值”，参数是数据值
list.pop(1) #移除指定下标,参数是索引值

'''
'''
listB=list(range(10,50))
print(listB.index(20))  #str中才有find函数，list中无
'''


#------------------------元组---------------------
'''
元组：一种不可变的序列，在创建后不能做任何修改
1.不可变
2.用()声明，用逗号分隔
3.可以是任何类型
4.当元组中只有1个元素时，要加上逗号，不然解释器会当整形处理
5.支持切片
'''
'''
#元组的创建
tupleA=() #空元组

tupleA=('a','b',3,'perter',[1,2,4])
#print(tupleA)
#元组的查询

for item in tupleA:
    print(item,end=' ')
    pass
'''
'''
#print(tupleA[2:4])

tupleB=tuple(range(1,10))
print(tupleB)
print(tupleB[-5:-1:-1])  #这样是错误的，-1表示往左取
print(tupleB[-1:-5:-1])

#元组中列表的修改：
tupleA=('a','b',3,'perter',[1,2,4])
tupleA[4][0]=3432
print(tupleA)

tupleB=(1,) #当元组中只有1个数据项时，必须要在数据项后面加上,)
print(type(tupleB))

print(tupleB.count(8))  #统计元组中，8出现的次数

'''
'''

----------------------字典-----------------
字典中可以存储任意对象，以键值对{'key':'value'}
字典中的键（key）不能重复，键必定是唯一的，值（value）可以重复
字典的键只能是不可变的类型，如数字、字符串、元组
字典使用键来访问数据，效率非常高，和list一样 支持对数据的添加、修改、删除

特点：
1.不是序列类型 没有下标概念 是一个无序的 键值集合，是内置的高级数据类型
2.用{}表示字典对象，每个键值对用逗号分隔
3.键不可变
4.键必定是唯一的，如果存在重复的键，后者会覆盖前者的键

'''

'''
#创建字典
dictA={} #空字典
#添加字典数据
dictA['name']='李易峰' #key:value
dictA['age']=30
#结束添加
dictA={'name':'李易峰','pro':'艺术','school':'北京电影学院'}
print(len(dictA)) #数据项长度(有多少个)

#查找  通过键
print(dictA['name']) #只能通过键获取对应的值
dictA['school']='香港大学'  #修改键对应的值
print(dictA)
#获取所有的键
print(dictA.keys())
#获取所有的值
print(dictA.values())
#获取所有的数据项（键值对）
print(dictA.items())
'''
dictA={'name':'李易峰','pro':'艺术','school':'北京电影学院'}
#print(dictA)
#print(dictA.items())
'''
for i in dictA.items():
    print(i)
    pass

#下面的方法只取出了键
for i in dictA:
    print(i)
    pass

for key,values in dictA.items():
    print('%s==%s'%(key,values))
    pass
    
'''
dictA.update('height':1.99) #可以添加或修改
#删除操作  del pop 通过指定键删除
del dictA['school']

dictA.pop('age')

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

#排序的字段的数据必须类型一致