绑定完请刷新页面
取消
刷新

分享好友

×
取消 复制
Python常用数据类型的基本操作
2021-11-29 14:52:03
来源:小詹学Python


Python原生数据类型主要有Number、String、Byte、Boolean、None、List、Tuple、Set、Dict这九种,这篇文章主要讲一下字符串、列表、元祖、集合、字典这五种,剩下的四种大家可以自己了解一下。

字符串

初始化一个字符串,方便后面在字符串上做一些操作。

In [5]: s1 = 'naitangmao'
In [6]: s1

Out[6]: 'naitangmao'

字符串的索引,需要注意的是索引下标从0开始。

In [9]: s1[2]
Out[9]: 'i'

字符串的切片,以冒号分隔首尾索引位置,是[start:end]结构,注意不包含end对应元素;冒号左边不写入索引表示从头开始,同理右边不写入索引表示截取到字符串末尾。

In [8]: s1[:3]#从0开始,0,1,2三个索引
Out[8]: 'nai'

还可以利用切片结合负索引实现翻转字符串。

In [35]: s1[::-1]
Out[35]: 'oamgnatian'

利用加法实现合并字符串。

In [49]: print('ab'+'%'+'cd')
ab%cd

查找,利用find方法查询元素时,会返回在字符串第一次出现的下标,未找到会返回-1。

In [11]: s1.find('a')
Out[11]: 1

替换,replace可以实现字符串中元素的替换,比如将'tang'替换成空格。

In [13]: s1.replace('tang',' ')
Out[13]: 'nai mao'

去空格,使用strip方法可以删除一个字符串首尾的空格,然后也支持指定要删除内容。

In [23]: s2 = '   aaabbbccc   '
In [24]: s2
Out[24]: '   aaabbbccc   '

In [25]: s2.strip()
Out[25]: 'aaabbbccc'

In [26]: s2 = s2.strip()
In [27]: s2.strip('a')#可以指定删除首尾的元素
Out[27]: 'bbbccc'

切割,split方法可以根据元素切割字符串,并存入列表;如果不输入参数,会直接将原字符串存入列表。

In [30]: s1 = 'naitangmao'
In [31]: s1.split('t')
Out[31]: ['nai''angmao']

In [32]: s1.split()
Out[32]: ['naitangmao']

判断一个元素是否存在于字符串中。

In [37]: 'nai' in s1
Out[37]: True

分隔,利用join方法可以将一个字符串作为分隔符,分隔另一个字符串。

In [38]: s1.join('!!!')
Out[38]: '!naitangmao!naitangmao!'

利用%向字符串中传入参数,%s传入字符串、%d传入整数、%f传入浮点数,且可以控制小数点后的位数。

In [40]: print('naitangmao是%s!' % '靓仔')
naitangmao是靓仔!
In [41]: print('naitangmao %d '66)
naitangmao 66
In [44]: print('naitangmao %.2f'3.1415)
naitangmao 3.14

也可以利用format向字符串中传入参数,且不需要在意参数类型。

In [46]: '{0}ai{1}ang{2}ao'.format('n','66','3.14')
Out[46]: 'nai66ang3.14ao'

利用反斜杠对字符串进行转义。

In [47]: print('\t')

In [48]: print('\\t')
\t

列表

同样初始化一个列表,然后方便对列表做一系列操作。

In [52]: list1
Out[52]: [1357911]

首先同样是列表的索引,列表也支持负索引。

In [53]: list1[2]
Out[53]: 5

In [55]: list1[-2]#负索引
Out[55]: 9

再拓展一下带有间隔的切片,字符串同样适用,就是在end之后再加上一个双引号,用来写入切片的间隔,这才是切片最完整的结构。

In [58]: list1[:6:2]
Out[58]: [159]

利用index方法可以获取某个元素在列表中的位置索引,未找到的则会报错。

In [60]: list1.index(3)
Out[60]: 1

利用join方法将列表中的各个元素合并为字符串。

In [121]: list1 = ['a','b','c']
In [122]: ''.join(list1)
Out[122]: 'abc'

count方法可以统计一个元素在列表中出现的次数。

In [63]: list1.count(5)
Out[63]: 1

enumerate可以直接获取列表的索引和对应元素。

In [133]: index_ = []
In [134]: value_ = []
In [135]: for i,v in enumerate(list1):
     ...:     index_.append(i)
     ...:     value_.append(v)
     
In [136]: index_
Out[136]: [1234]
In [137]: value_
Out[137]: [31425]

利用zip方法合并两个列表。

In [139]: list3 = list(zip(index_,value_))
In [140]: list3
Out[140]: [(3), (11), (24), (32), (45)]]

扩大列表的四种方法:

  • 1、append:将一个元素添至列表尾部
  • 2、insert:将一个元素插入至指定位置
  • 3、extend:将一个列表的所有元素都添加至另一个列表中
  • 4、+:将两个列表合并成一个新列表

In [68]: list1.append(12)
In [69]: list1
[135791112]

In [78]: list1.insert(,)
In [79]: list1
Out[79]: [135791112]

In [80]: list1.extend([2,4])
In [81]: list1
Out[81]: [13579111224]

In [82]: list2 = [6,8]
In [83]: list3 = list1+list2
In [84]: list3
Out[84]: [1357911122468]

删除列表元素的三种方法:

  • 1、pop:从列表指定位置删除元素,并将其返回。如果没有指定索引,pop()返回最后一个元素,并从列表中删去。
  • 2、remove:从列表中删去指定元素,没有则会报错。
  • 3、del:也是利用索引删去列表中的某部分。

In [91]: list1.pop(3)
Out[91]: 7
In [92]: list1
Out[92]: [135911]

In [94]: list1.remove(5)
In [95]: list1
Out[95]: [13911]

In [96]: del list1[1:3]
In [97]: list1
Out[97]: [111]

翻转列表的三种方式:

  • 1、reverse:就地倒排列表中的元素。
  • 2、reversed:函数对列表进行反转,并返回一个新的迭代器,需要用list转换
  • 3、切片结合负索引

In [99]: list1 = [1,3,5,7,9,11]
In [100]: print(list1.reverse())
[1197531]

In [102]: list2 = list(reversed(list1))
In [103]: print(list2)
[1197531]

In [105]: list1[::-1]
Out[105]: [1197531]

实现列表排序的两种方式:

  • 1、sort:对列表中的元素就地进行排序。
  • 2、sorted:函数对列表进行排序,形成一个新列表
  • 3、利用lambda自定义函数

这两种方法默认为升序,通过参数reverse可以更改排序方式。

In [106]: list2 = [3,5,2,7,1]
In [108]: list2.sort()
In [109]: list2
Out[109]: [12357]

In [116]: list3 = sorted(list2,reverse = True)
In [117]: list3
Out[117]: [75321]
#按照元祖中第二个元素的大小排序
In [141]: list4 = [(3), (11), (24), (32), (45)]
In [142]: print(sorted(list4,key = lambda x: x[1]))
[(11), (32), (3), (24), (45)]

sort和reverse这类就地处理列表的操作,针对可变的列表是可以的,但如果是不可变的元祖,只能用sorted和reversed这两种方式。

拷贝列表的三种方式:

  • 1、利用切片直接赋值,浅拷贝
  • 2、copy方法,浅拷贝
  • 3、deepcopy方法,深拷贝

In [25]: list2 = list1[:]
In [26]: list3 = list1.copy()
In [27]: import copy
In [29]: list4 = copy.deepcopy(list1)

深拷贝和浅拷贝的区别因为涉及到数据结构,口头叙述不容易理解,网上有很多图例讲解的博客,大家可以了解一下。

元组

元组和列表是非常相似的,有一种类似近亲的关系,也就是说列表中很多操作同样适用于元组,比如索引、切片等等,但也有一部分不同,这里主要来说一下元组的特别之处。

首先元组又被称作带锁的列表,就是元组内的元素是不能随意更改的,比如你不能给元组中的一个元素随意赋值。

In [2]: tuple1 = (1,2,3)
In [3]: tuple1[2] = 4
#会发生报错,告诉你不支持这样的操作
TypeError: 'tuple' object does not support item assignment

元组的标志并不是单纯的小括号,而是逗号,或者小括号与逗号的结合,看下面这个例子。

In [31]: tuple2 = (1)
In [32]: type(tuple2)
Out[32]: int
In [33]: tuple3 = (1,)
In [34]: type(tuple3)
Out[34]: tuple
In [35]: tuple4 = 1,2,
In [36]: type(tuple4)
Out[36]: tuple

那如何初始化一个空元组呢?

In [39]: tuple5 = ()
In [40]: type(tuple5)
Out[40]: tuple

上面刚刚说过元组是不可变对象,自然也不会有append、insert、pop这类的操作。元组中增添可以利用"+"实现,删除则可以利用del,因为这是python自带的回收机制。

In [42]: tuple5 = tuple5[:] + (1,2,3,4,)
In [43]: tuple5
Out[47]: (1234)

In [50]: del tuple5 #不支持切片
In [51]: tuple5
NameError: name 'tuple5' is not defined

"*"在数值型之间为乘积运算符,而在列表和元组之间可以表示为重复运算符。

In [53]: tuple5 = (1,2)
In [54]: tuple5 * 3

Out[54]: (121212)

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持联合、交、差和对称差集等数学运算。

首先可以利用大括号或set()函数创建集合,如果想要创建空集合,你必须使用set()而不是{},{}用来创建字典。

In [57]: set1 = set()
In [58]: type(set1)
Out[58]: set

集合会本身会带有去重功能。

In [55]: set1 = {1,1,2,2,3,3,4}
In [56]: set1
Out[56]: {1234}

将集合转化为列表时,会自动排序。

In [74]: set2 = {5,5,4,2,2,}
In [75]: list_ = list(set2)
In [76]: list_
Out[76]: [245]

集合之间的一些运算操作。

In [60]: set1 = {1,2,3,4}
In [61]: set2 = {3,4,5}
#差
In [62]: set1 - set2
Out[62]: {12}
#并
In [63]: set1 | set2
Out[63]: {12345}
#交
In [64]: set1 & set2
Out[64]: {34}
#只在set1或只在set2中
In [65]: set1 ^ set2
Out[65]: {125}

利用add向集合中增添元素,利用remove删除元素。

In [69]: set1 = {1,2,3}
In [70]: set1.add(5)
In [71]: set1
Out[71]: {1235}

In [72]: set1.remove(2)
In [73]: set1
Out[73]: {135}

字典

字典是Python中一个非常有用的原生数据类型,一般序列是用连续的整数作为索引,而字典是以关键字作为索引,且关键字要是任意不可变类型。理解字典时可以把它看做无序的键:值对(key:value对)集合,同一个字典中键必须互不相同,利用{}可以初始化一个空的字典。

In [77]: dict1 = {}
In [78]: type(dict1)
Out[78]: dict

如果确保一个键不在字典中,可以利用下面的方法向字典中添加元素。

In [81]: dict1 = {'a':1,'b':2}
In [82]: dict1['c'] = 3
In [83]: dict1
Out[83]: {'a'1'b'2'c'3}

而如果这个键已经存在于字典中了,就表示为这个键赋值。

In [84]: dict1['b']=4
In [85]: dict1
Out[85]: {'a'1'b'4'c'3}

keys()方法能够一次性获得字典中所有的键,values()方法则用来获取值,items()则是获取键值对的元组形式。

In [86]: list(dict1.keys())
Out[86]: ['a''b''c']

In [87]: list(dict1.values())
Out[87]: [143]

In [88]: list(dict1.items())
Out[88]: [('a'1), ('b'4), ('c'3)]

元组形式或者列表中嵌套的元组的形式都可以转换成字典,因为要保持不可变性。

In [89]: dict2 = dict([('e',5),('f',6)])
In [90]: dict2
Out[90]: {'e'5'f'6}

In [91]: dict3  = dict((('g',7),('h',8)))
In [92]: dict3
Out[92]: {'g'7'h'8}

当然也可以通过'='赋值的形式创建一个字典。

In [93]: dict5 = dict(i = 8,j = 9)
In [94]: dict5
Out[94]: {'i'8'j'9}

查询一个键是否存在一个列表中。

In [96]: 'i' in dict5
Out[96]: True

In [97]: 'a' in dict5
Out[97]: False

根据键查询对应值的两种方式:

  • 1、直接利用键的名字索引,不足的是如果字典中没有这个键则会发生报错。
  • 2、利用get方法,可以设置不存在键名的情况下的返回值,默认返回None。

In [98]: dict5['i']
Out[98]: 8
In [99]: dict5['a']
KeyError: 'a'

In [101]: dict5.get('i')
Out[101]: 8
In [103]: dict5.get('a',"没有")
Out[103]: '没有'

字典中的几种删除方式:

  • 1、pop()方法,与列表不同的是必须要传入一个字典中已有键的参数。
  • 2、popitem(),类似于列表中的pop(),随机删除一组键值对而非删除最后一个,因为字典本身无序。
  • 3、del方法,用于删除整个字典

In [107]: dict3
Out[107]: {'g'7'h'8}

In [109]: dict3.pop('g')
Out[109]: 7
In [110]: dict3.popitem()
Out[110]: ('h'8)

clear()方法可以清楚字典中所有的键值对。

In [104]: dict5.clear()
In [105]: dict5
Out[105]: {}

setdefault()方法可以传入一组键值对,如果字典中已有同名键,则返回键在字典中对应的值,否则将传入的键值对存入字典中。

In [115]: dict2
Out[115]: {'e'5'f'6}

In [117]: dict2.setdefault('e',1)
Out[117]: 5

In [118]: dict2.setdefault('g',7)
Out[118]: 7
In [119]: dict2
Out[119]: {'e'5'f'6'g'7}

update()方法可以用来更新字典:

  • 如果字典中已有传入的键,则更新键对应的值。
  • 如果没有,则将传入的键值对存入字典中。

In [121]: dict2.update({'g':10})
In [122]: dict2
Out[122]: {'e'5'f'6'g'10}

In [123]: dict2.update(dict1)
In [124]: dict2
Out[124]: {'e'5'f'6'g'10'a'1'b'4'c'3}

总结

上面就是五种数据类型基本操作的一个概括,其中比较常用的三种就是字符串、列表和字典,应该重点掌握,然后有的伙伴一定好奇为什么没写表达式?莫急,在后面文章中一定是会有的。上面的基操都是非常基础的,一定要熟悉,并且注意每个数据类型的特点,不要相互混淆啦。

-------- End --------



分享好友

分享这个小栈给你的朋友们,一起进步吧。

Python编程时光
创建时间:2020-06-09 15:11:01
专注输出 Python 高质量原创文章
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅:虚拟交易,一经交易不退款;若特殊情况,可3日内客服咨询

• 专区发布评论属默认订阅所评论专区(除付费小栈外)

栈主、嘉宾

查看更多
  • highhand
    栈主

小栈成员

查看更多
  • 孔庆杰
  • Pantj
  • 高岩
  • www1392617710
戳我,来吐槽~