python中必须要会的四大高级数据类型（字符，元组，列表，字典）
2024-05-10 18:19:49
高级数据类型（字符，元组，列表，字典）
- 一. 字符串
- 二. 列表
- 三. 元组
- 四. 字典
前言
作者：神的孩子都在跳舞
关注我的csdn博客，更多python知识还在更新
一. 字符串
生活中我们经常坐大巴车，每个座位一个编号，一个位置对应一个下标。 字符串中也有下标，要取出字符串中的部分数据，可以用下标取。
python中使用切片来截取字符串其中的一段内容，切片截取的内容不包含结束下标对应的数据。
切片使用语法：[起始下标：结束下标：步长] ，步长指的是隔几个下标获取一个字符。
注意：下标会越界，切片不会
- 常用函数
- 练习：
Test='rodma '
print(type(Test))
print('Test的一个字符串%s'%Test[0])#跟数组差不多
#循环输出
for i in Test:print(i,end=" ")#也可以用‘ ’
print('\n')# count():统计出现的次数
print(Test.count('r'))# join():循环取出所有值用xx去连
str='-'
print(str.join(Test))#去除两边空格strip(),去除右边空格：lstrip()，去除右边空格：rstrip
print(Test.strip())#复制字符串，id函数可以查看对象的内存地址
print('Test的内存地址%d'%id(Test))
b=Test #在此只是把a对象的内存地址赋给了b
print('Test的内存地址%d'%id(Test))
print(b)#定义一个数接下来用
datastr='i love Python'
#find函数：可以查找目标对象在序列对象中的为值,如果没找到就返回-1
print(datastr.find('M'))
# index()函数：检测字符串中是否包含子字符串 返回的是下标值
print(datastr.index('i'))
#find 和 index 的区别：如果index没有找到对象就会报错，find输出-1，找到输出0#starswith()函数：判断开头,如果是就true
#endswith()函数是判断结尾
print(datastr.startswith('i'))# capitalize():首字母转换为大写
# isalnum():判断是否是字母和数字,全部是字母就输出true，有空格也不行
# isalpha() :判断是否是字母
# isdigit():判断是否全部是数字
# swapcase():大写变小写，小写变大写
# title() :把每个单词的首字母变成大写
# lower()：装换为小写。
# upper():转换为大写a='tsx'
print(type(a))
print(datastr.capitalize())
print(a.isalnum())
print(datastr.isalpha())
print('abc123'.isdigit())
print(datastr.swapcase())
print(datastr.title())
print(datastr.lower())
print(datastr.upper())# 切片：是指截取字符串中的其中一段内容。
# 切片使用语法：[起始下标：结束下标：步长]
# 切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符。
# slice [start:end:step] 左闭右开 start<=value<end 范围
# 下标会越界，切片不会
#记住左闭右开的原则# 定义一个对象
strmgs='Never give up'# 1——8之间的数据
print(strmgs[1:8])
# 第3个字符到最后
print(strmgs[2:])
# 第1个字符到第3个 温馨提示：记住左闭右开的原则
print(strmgs[:3])
# 步长是什么？比如定义2，就是从当前开始到2个下标获取一个字符，在通俗点就是隔一个获取下一个
print(strmgs[::2])
# 负方向是倒序输出，如果步长选为-1，则反方向输出
print(strmgs[::-1])
# 同理，如果步长是-2，则反方向隔两个下标获取一个字符
print(strmgs[::-2])# 共有方法有三种 + * in
# +:两个对象相加操作，会合并两个对象
# *:对象自身按指定次数进行 + 操作
# in:判断指定元素是否存在于对象中,输出的是bool值strA='I love'
strB='Python'
print(strA+strB)
print(strA*3)
print('I' in strA)'''输出
<class 'str'>
Test的一个字符串r
r o d m a 1
r-o-d-m-a- -
rodma
Test的内存地址1863907131504
Test的内存地址1863907131504
rodma
-1
0
True
<class 'str'>
I love python
True
False
False
I LOVE pYTHON
I Love Python
i love python
I LOVE PYTHON
ever gi
ver give up
Nev
Nvrgv p
pu evig reveN
p vgrvN
I lovePython
I loveI loveI love
True
'''
二. 列表
list是一种有序的集合[]，可以随时添加和删除其中的元素。
列表的下标取值/切片/是否越界与字符串一致，区别就是列表是获取元素。
练习
li=[] # 空列表
li=[1,2,3,4,'python',True]
print(type(li))
# #len函数可以获取到列表对象中的数据个数
print(len(li))# append()；在列表后面追加元素
# count(): 统计元素出现的次数
# extend(): 扩展，相当于批量添加
# index(): 获取指定元素索引号
# insert(): 在指定位置插入
# pop(): 删除后面一个元素
# remove():移除左边找到的第一个元素
# reverse(): 反转列表
# sort():列表排序 reverse=True为倒序listA=['abcd',785,12.23,'qiuzhi',True]
# print('--------------增加-----------------------')
print('追加之前',listA)
listA.append(['fff','ddd']) #追加操作
listA.append(8888)
print('追加之后',listA)
listA.insert(1,'这是我刚插入的数据') #插入操作 需要执行一个位置插入
print(listA)
rsData=list(range(10)) #强制转换为list对象
print(type(rsData))
listA.extend(rsData) #拓展 等于批量添加
listA.extend([11,22,33,44])
print(listA)
# print('-----------------修改------------------------')
# print('修改之前',listA)
# listA[0]=333.6
# print('修改之后',listA)
listB=list(range(10,50))
print(type(listB))
print('------------删除list数据项------------------')
print(listB)
# del listB[0] #删除列表中第一个元素
# del listB[1:3] #批量删除多项数据 slice
# listB.remove(20) #移除指定的元素 参数是具体的数据值
listB.pop(1) #移除制定的项 参数是索引值
print(listB)
#beg -- 开始索引，默认为0。
#end -- 结束索引，默认为字符串的长度。
print(listB.index(19)) #返回的是一个索引下标# 查找,跟元祖有点不一样，这是左开右闭print(type(listA))
print(listA) #输出完整的列表
print(listA[0]) #输出第一个元素
print(listA[1:3]) #从第二个开始到第三个元素
print(listA[2:]) #从第三个元素开始到最后所有的元素
print(listA[::-1]) #负数从右像左开始输出print(listA*3) #输出多次列表中的数据【复制】a=[21,45,66,78]
b=[1,2]def add100(x):i= 0for item in x:x[i]=item+100i+=1passreturn xpass
print(add100(b))
def add100(x):x+=100return x
list2=list(map(add100,a))
print(list2)
a=[21,45,66,78]
print(list(map(lambda x:x+100,a)))def Old(x):if x>50:return xpass
print(list(filter(Old,a)))
'''输出
<class 'list'>
6
追加之前 ['abcd', 785, 12.23, 'qiuzhi', True]
追加之后 ['abcd', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888]
['abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888]
<class 'list'>
['abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44]
<class 'list'>
------------删除list数据项------------------
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
[10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
8
<class 'list'>
['abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44]
abcd
['这是我刚插入的数据', 785]
[785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44]
[44, 33, 22, 11, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 8888, ['fff', 'ddd'], True, 'qiuzhi', 12.23, 785, '这是我刚插入的数据', 'abcd']
['abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 'abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 8888, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44]
[101, 102]
[121, 145, 166, 178]
[121, 145, 166, 178]
[66, 78]'''
三. 元组
元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，元组也是通过下标进行访问
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
元组的内置方法：
count：统计元素在元组中出现的次数
index：查找指定元素在元组中的下标索引练习
#空元组
tupleA=()
print(type(tupleA))
#元组也可以用for语句查询tupleA=(1,2,3,'cd','a')
for item in tupleA:print(item,end=' ')# 元组也可以使用切片,左闭右开
print(tupleA[-2:-1:])#倒着取下标 为-2 到 -1 区间的#假设元组中放入队列
tupleA=(1,2,3,'cd','a',[11,22,33])
print(tupleA)
#可以对队列的值进行修改（原本元组是不可以修改的）
print(type(tupleA[5]))
tupleA[5][0]=5500
print(tupleA)
tupleA[5].append('chen')
print(tupleA)
'''输出
<class 'tuple'>
1 2 3 cd a ('cd',)
(1, 2, 3, 'cd', 'a', [11, 22, 33])
<class 'list'>
(1, 2, 3, 'cd', 'a', [5500, 22, 33])
(1, 2, 3, 'cd', 'a', [5500, 22, 33, 'chen'])
'''
四. 字典
- 字典是Python的中重要的一种数据类型，可以存储任意对像。
- 字典是以键值对的形式创建的
{'key':'value'}利用大括号包裹着。 - 访问值的安全方式get方法，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值
注意：
- 字典的键（key）不能重复，值（value）可以重复。
- 字典的键（key）只能是不可变类型，如数字，字符串，元组。
- 常用方法
- 练习
# 空字典
dictA={}
print(type(dictA))
# 如何添加字典数据？ key:value
dictA['name']='陈运智'
dictA['age']=30
print(dictA)
# 批量添加
dictA={"pro":'艺术','shcool':'北京电影学院','age':30,'pos':'xueshen'}
print(dictA)
# 通过键位修改值
dictA['pro']='学生'
print(dictA)
# 添加更多数据
dictA.update({'name':'陈运智'})
print(dictA)
# 获取所有键和值
print(dictA.keys(),dictA.values())
print(dictA.items())
for key,value in dictA.items():print('%s==%s'%(key,value))
# 指定键删除
del dictA['name']
print(dictA)
# 按照key和value排序
print(sorted(dictA.keys()))
#print(sorted(dictA.values()))#拷贝， copy,deepcopy 会拷贝复杂类型，如 list、dict
import copy
dictB=copy.copy(dictA)#浅拷贝
dictc=copy.deepcopy(dictA)#深拷贝print(id(dictc))
print(id(dictA))
print(id(dictB))dictB['age']='20'
dictc['age']='20'
print(dictB)
print(dictc)
print(dictA)
print(type(dictB))
print(type(dictc))
本人博客：https://blog.csdn.net/weixin_46654114
本人b站求关注：https://space.bilibili.com/391105864
转载说明：跟我说明，务必注明来源，附带本人博客连接。
请给我点个赞鼓励我吧
python中必须要会的四大高级数据类型（字符，元组，列表，字典）相关推荐
- Python中第三方库Requests库的高级用法详解
Python中第三方库Requests库的高级用法详解 虽然Python的标准库中urllib2模块已经包含了平常我们使用的大多数功能,但是它的API使用起来让人实在感觉不好.它已经不适合现在的时代, ...
- Python高级数据类型-字符串，列表，元组，字典
0.序列 序列:在python中 序列就是一组按照顺序排列的值 python中三种内资的序列类型:字符串,列表,元组 优点:支持索引和切片的操作,从0开始 1.字符串 可以查询,修改 字符串常用的方法 ...
- python如果选择不在列表里_使用python中的in ,not in来检查元素是不是在列表中的方法...
使用python中的in ,not in来检查元素是不是在列表中的方法 更新时间:2018年07月06日 15:01:34 作者:mengtianwxs 今天小编就为大家分享一篇使用python中的i ...
- python包含多个元组的元组_Python数据结构(元组,列表,字典)
Python内置了 几种数据结构,元组,列表 字典 1.元组 元组可以由不同的元素组成,所有元素通过圆括号( )包含起来,并通过逗号","隔开.如变量名 = (元素1,元素2,. ...
- Python中and和or运算符的高级用法
在 Python 中,and 和 or 都是布尔运算符,用于比较两个或多个表达式的真假值.它们的行为有一些类似于逻辑运算符,但是有一些重要的区别. 基础用法 and 运算符用于比较两个表达式的真假值, ...
- python第2位的值_Python组通过匹配元组列表中的第二个元组值
在本教程中,我们将编写一个程序,该程序将列表中具有与第二个元素相同的元素的所有元组分组.让我们看一个例子来清楚地理解它. 输入值[('Python', 'nhooos'), ('Management' ...
- 第一章：Python的基本数据类型-第二节：Python中表示“有序”（序列）的数据类型
部分参考:菜鸟教程 文章目录 一:列表 (1)列表基本操作 A:元素访问 B:常用操作 C:函数和方法总结 (2)其他使用技巧 二:元组 (1)元组基本操作 A:元素访问 B:常用操作 C:常用函数方 ...
- python 元组 列表 字典区别_python编程：常用的数据结构之字典的方法总结，和列表和元组区别...
字典是一种键:值的形式,我们前面分享的文章学习了列表[],元祖(),字典是由{}引起来的,列表的键对应的是列表的下标,而字典的值对应的是字典的键,我们可以通过字典的键来获取字典的值 元组和列表是有序的 ...
- python 元组 列表 字典区别_Python列表、元组、字典、集合、字符串的异同总结
1.数据类型 列表.元组.字典.集合.字符串均属于python3的标准数据类型. 字符串和元组属于不可变数据,即创建后不可修改. 列表.字典.集合属于可变数据,即创建后可以修改元素. 2.创建有元素的 ...
最新文章
- C和C++安全编码笔记：动态内存管理
- 减肥难？别急，精准调控细菌的方法已横空出世！
- mogilefsd同步速度调优
- [Python3] 003 变量类型概述 数字类型详叙
- 使用IntelliJ IDEA11创建Java Web程序
- 使用Sidecar支持异构平台的微服务
- 可以自定义模板的ide_将IDE检查应用于自定义Java批注
- android学习笔记---android常用的软件布局方式，使用方法总结
- python界面开发工 跨平台具_python GUI开发常用工具
- C++数字与字符串的相互转换
- 如何使用Axure制作产品需求文档prd
- 计算机如何进入ping,电脑怎么ping网络,教你电脑怎么ping网络
- VersaBank开发“数字保险箱”区块链服务
- C语言一般考点笔试,c语言常见笔试题及答案
- Android群英传笔记-Android系统安全与安全机制
- Saber仿真教程视频 初级 中级 高级
- RabbitMQ 学习知识点总结
- 海关数据对外贸企业的重要性
- 用Python爬取彼岸图网图片
- 事件营销有哪些策略？