Python数据类型

最新推荐文章于 2024-08-15 10:59:23 发布

dj_pyer

最新推荐文章于 2024-08-15 10:59:23 发布

阅读量4.6k

点赞数 3

本文链接：https://blog.csdn.net/dj_pyer/article/details/82082899

版权

数字(numbers)

Python中常用的是int（有符号整型）。

字符串(str)

1、定义

字符串是Python 中最常用的数据类型。双引号或者单引号中的数据，就是字符串。

2、下标和切片

下标：

所谓“下标”就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间。

字符串实际上就是字符的数组，所以也支持下标索引。

切片：

切片是指对操作的对象截取其中一部分的操作。

字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长]。

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

3、常见操作

<1>find

检测 str 是否包含在 mystr中，如果是，返回开始的索引值，否则返回-1

mystr.find(str, start=0, end=len(mystr))

<2>index

跟find()方法一样，只不过如果str不在 mystr中会报一个异常.

mystr.index(str, start=0, end=len(mystr))

<3>count

返回 str在start和end之间在 mystr里面出现的次数

mystr.count(str, start=0, end=len(mystr))

<4>replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

mystr.replace(str1, str2,  mystr.count(str1))

<5>split

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串。

mystr.split(str=" ", 2)

列表(list)

1、定义

列表是Python 中使用最频繁的数据类型，在其他语言中通常叫做数组，通过索引进行查找，使用方括号”[]”。

列表是有序的集合。

2、应用场景

定义列表使用[ ] 定义，数据之间使用“，”分割。

3、列表支持索引和下标

索引就是数据在列表中的位置编号，索引又可以被称为下标。

列表的索引从0 开始，从列表中取值时，如果超出索引范围,程序会产生异常（IndexError: list index out of range）。

4、列表的常用操作

name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]

1）增加

列表名.insert(index, 数据)：在指定位置插入数据(位置前有空元素会补位)。

1．# 往列表name_list 下标为0 的地方插入数据
2．In [3]: name_list.insert(0, "Sasuke")
3．In [4]: name_list
4．Out[4]: ['Sasuke', 'zhangsan', 'lisi', 'wangwu', 'zhaoliu']
5．# 现有的列表下标是0-4，如果我们要在下标是6 的地方插入数据，那个会自动插入到下标为5 的地方，也就是# 插入到最后
6．In [5]: name_list.insert(6, "Tom")
7．In [6]: name_list
8．Out[6]: ['Sasuke', 'zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'Tom']

列表名.append(数据)：在列表的末尾追加数据(最常用的方法)。

1．In [7]: name_list.append("Python")
2．In [8]: name_list
3．Out[8]: ['Sasuke', 'zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'Tom', 'Python']

列表.extend(Iterable)：将可迭代对象中的元素追加到列表。

1．# 有两个列表a 和b a.extend(b) 会将b 中的元素追加到列表a 中
2．In [10]: a = [11, 22, 33]
3．In [11]: b = [44, 55, 66]
4．In [12]: a.extend(b)
5．In [13]: a
6．Out[13]: [11, 22, 33, 44, 55, 66]# 有列表c 和字符串d c.extend(d) 会将字符串d 中的每个字符拆开作为元素插入到列表c
7．In [14]: c = ['j', 'a', 'v', 'a']
8．In [15]: d = "python"
9．In [16]: c.extend(d)
10．In [17]: c
11．Out[17]: ['j', 'a', 'v', 'a', 'p', 'y', 't', 'h', 'o', 'n']

2）取值和修改

取值：列表名[index]，根据下标来取值。

1．In [19]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
2．In [20]: name_list[0]
3．Out[20]: 'zhangsan'
4．In [21]: name_list[3]
5．Out[21]: 'zhaoliu'

修改：列表名[index] = 数据，修改指定索引的数据。

1．In [22]: name_list[0] = "Sasuke"
2．In [23]: name_list
3．Out[23]: ['Sasuke', 'lisi', 'wangwu', 'zhaoliu']

3）删除

del 列表名[index]：删除指定索引的数据。

1．In [25]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"] # 删除索引是1 的数据
2．In [26]: del name_list[1]
3．In [27]: name_list
4．Out[27]: ['zhangsan', 'wangwu', 'zhaoliu']

列表名.remove(数据)：删除第一个出现的指定数据。

5．In [30]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu", "lisi"] # 删除第一次出现的lisi 的数据
6．In [31]: name_list.remove("lisi")
7．In [32]: name_list
8．Out[32]: ['zhangsan', 'wangwu', 'zhaoliu', 'lisi']

列表名.pop()：删除末尾的数据,返回值: 返回被删除的元素。

9．In [33]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"] # 删除最后一个元素zhaoliu 并将元素zhaoliu 返回
10．In [34]: name_list.pop()
11．Out[34]: 'zhaoliu'
12．In [35]: name_list
13．Out[35]: ['zhangsan', 'lisi', 'wangwu']

列表名.pop(index)：删除指定索引的数据，返回被删除的元素。

14．In [36]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]# 删除索引为1 的数据lisi
15．In [37]: name_list.pop(1)
16．Out[37]: 'lisi'
17．In [38]: name_list
18．Out[38]: ['zhangsan', 'wangwu', 'zhaoliu']

列表名.clear()：清空整个列表的元素。

19．In [40]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
20．In [41]: name_list.clear()
21．In [42]: name_list
22．Out[42]: []

4）排序

列表名.sort()：升序排序从小到大。

23．In [43]: a = [33, 44, 22, 66, 11]
24．In [44]: a.sort()
25．In [45]: a
26．Out[45]: [11, 22, 33, 44, 66]

列表名.sort(reverse=True)：降序排序从大到小。

27．In [46]: a = [33, 44, 22, 66, 11]
28．In [47]: a.sort(reverse=True)
29．In [48]: a
30．Out[48]: [66, 44, 33, 22, 11]

列表名.reverse()：列表逆序、反转。

31．In [50]: a = [11, 22, 33, 44, 55]
32．In [51]: a.reverse()
33．In [52]: a
34．Out[52]: [55, 44, 33, 22, 11]

5）统计相关

len(列表名)：得到列表的长度。

35．In [53]: a = [11, 22, 33, 44, 55]
36．In [54]: len(a)
37．Out[54]: 5

列表名.count(数据)：数据在列表中出现的次数。

38．In [56]: a = [11, 22, 11, 33, 11]
39．In [57]: a.count(11)
40．Out[57]: 3

列表名.index(数据)：数据在列表中首次出现时的索引，没有查到会报错。

41．In [59]: a = [11, 22, 33, 44, 22]
42．In [60]: a.index(22)
43．Out[60]: 1

if 数据in 列表：判断列表中是否包含某元素。

44．a = [11, 22, 33, 44 ,55]
45．if 33 in a:
46． print("找到了....")

6）循环遍历

使用while 循环：

1. a = [11, 22, 33, 44, 55]
2.
3. i = 0
4. while i < len(a):
5. print(a[i])
6. i += 1

使用for 循环：

1. a = [11, 22, 33, 44, 55]
2. for i in a:
3. print(i)

元祖(tuple)

1、定义

元组将多样的对象集合到一起，不能修改，通过索引进行查找，使用小括号”()”;

元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

2、应用场景

把一些数据当做一个整体去使用，不能修改。

3、元祖的常用操作

<1>访问元组

<2>修改元组

说明： python中不允许修改元组的数据，包括不能删除其中的元素。

<3>count, index

index和count与字符串和列表中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

集合(set)

1、定义

在Python 中的书写方式的{}，集合与之前列表、元组类似，可以存储多个数据，但是这些数据是不重复的。

2、常用操作

集合对象支持union(并集), intersection(交集), difference(差集)和sysmmetric_difference(对称差集)等数学运算。

字典(dict)

1、定义

字典是一组键(key)和值(value)的组合，通过键(key)进行查找，没有顺序，使用大括号”{}”

2、应用场景

使用键和值进行关联的数据

3、字典和json的区别

字典是一种数据结构，json 是一种数据的表现形式，字典的key 值只要是能hash 的就行，json 的必须是字符串。

4、字典的常见操作（一）

<1>查看元素

除了使用key查找数据，还可以使用get来获取数据

 info = {'name':'吴彦祖','age':18}

    print(info['age']) # 获取年龄

    # print(info['sex']) # 获取不存在的key，会发生异常

    print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常

<2>修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

    info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

    newId = input('请输入新的学号')

    info['id'] = int(newId)

    print('修改之后的id为%d:'%info['id'])

<3>添加元素

demo:访问不存在的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    print('id为:%d'%info['id'])

结果：

如果在使用 变量名['键'] = 数据 时，这个“键”在字典中不存在，那么就会新增这个元素

demo:添加新的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    # print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键

    newId = int(input('请输入新的学号'))

    info['id'] = newId

    print('添加之后的id为:%d'%info['id'])

结果:

 请输入新的学号188
    添加之后的id为: 188

<4>删除元素

对字典进行删除操作，有一下几种：

del
clear()

demo:del删除指定的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    print('删除前,%s'%info['name'])

    del info['name']

    print('删除后,%s'%info['name'])

结果：

demo:del删除整个字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('删除前,%s'%info)

    del info

    print('删除后,%s'%info)

结果：

demo:clear清空整个字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('清空前,%s'%info)

    info.clear()

    print('清空后,%s'%info)

结果：

5、字典的常见操作（二）

<1>len()

测量字典中键值对的个数

<2>keys

返回一个包含字典所有KEY的列表

<3>values

返回一个包含字典所有value的列表

<4>items

返回一个包含所有（键，值）元祖的列表

<5>has_key （Python3 已取消）

dict.has_key(key)如果key在字典中，返回True，否则返回False

6、遍历

通过for ... in ... 我们可以遍历字符串、列表、元组、字典等。

字符串遍历

>>> a_str = "hello itcast"
>>> for char in a_str:
...     print(char,end=' ')
...
h e l l o   i t c a s t

列表遍历

>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
...     print(num,end=' ')
...
1 2 3 4 5

元组遍历

>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
...     print(num,end=" ")
1 2 3 4 5

字典遍历

<1> 遍历字典的key（键）

<2> 遍历字典的value（值）

<3> 遍历字典的项（元素）

<4> 遍历字典的key-value（键值对）

enumerate()

将一个可遍历的数据对象(如列表/元组/字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
...     print i, chr
...
0 a
1 b
2 c
3 d

dj_pyer

关注

3
点赞
踩
36

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫