python中的数据容器

发表于 | 分类于

数字类型

整数(int)

  1. 包含正整数，0，负整数
  2. 没有大小限制
  3. 可以表示为十进制，十六进制，八进制，二进制等。十进制为默认，其它进制需要加前缀。

浮点数(float)

  1. 以十进制小数形式表示
  2. 指数形式表示 1.2E2
  3. 浮点数只能以十进制书写
  4. 由于计算机存储有限以及内部使用二进制的原因，计算机不能够精确的表示浮点数，因此比较和运算时建议使用round()函数限定保留位数。
    1
    2
    0.1+0.2 == 0.3	>> False
    round(0.1+0.2,1) == 0.3   >> True

复数(complex)

布尔值

  1. True False
  2. 0，””,None 为False
  3. 其他数值和非空字符串为True

数据容器概论

  1. 避免定义大量变量，只用一个变量定义更多数据
  2. 一种可以存储多个数据元素的数据类型。
  3. 批量存储和使用多份数据。
  4. 根据是否能修改，是否支持重复元素，是否有序分为列表(list)，元组(tuple)，字符串(str)，集合(set)，字典(dict)

list 列表

定义

1
2
3
4
5
6
7
8
9
# 字面量
[元素1,元素2,元素3]

# 变量定义
a = [元素1,元素2,元素3]

# 定义空列表
a = []
a = list()

特点

可以存储不同的数据类型，存储类型不受限制，并且允许嵌套列表。定义后可以被修改。有序，任意数量元素，允许重复元素。

1
2
["abc",236,25]
[[1,2,3],[4,5,6]]

列表的下标索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = [1,2,3]
# 从左到右取列表值
print(a[0])  # 1
print(a[1])  # 2
print(a[2])  # 3

# 从右往左取列表值
print(a[-1]) # 3
print(a[-2]) # 2
print(a[-3]) # 1

# 取嵌套列表值
b=[[1,2,3],[4,5,6]]
print(b[1][1])  # 5

列表的方法

什么是方法？
下面演示了一个对象中的方法(add)，以及其是如何被使用的。

1
2
3
4
5
6
7
# 方法的定义与使用
class Student :
    def add (x,y) :
       return = x + y

student = Student()
num = student.add(1,2)

image

1
2
3
4
5
6
7
8
9
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
2. 增加元素
list = list1 + [3,4]	
list.append(3)	# 将参数是视为元素
list.extend([3,4])  # 讲参数视为列表拼接
list.insert(num,“x”)	# num 是插入位置

3. 删除元素
del list[num]	# num是待删除的下标索引
list.remove("x")  # 移除最左边的数据“x”，找不到会报错
list.pop()	弹出最后一个元素，空列表时报错
list.pop(num)	# num是索引
list.clear()   # 清空列表

4. 检索元素
list.index("x")		# 返回指定元素首次出现的位置
list.count("x")		# 返回指定元素在列表中出现的次数
in   not in 		# 检查列表中是否存在指定元素
num = len(list)     # 计算列表元素的个数

5. 排序
sorted(list,reverse=True)  # 对列表做降序排序，不改变原列表
sorted(list)		# 对列表做升序排序，不改变原列表

sort(list)		# 对列表做升序排序，改变原列表
sort(list,reverse=True)	# 对列表做降序排序，改变原列表

list.reverse()	# 列表逆序存放

6. 列表解析
在一个序列的值上应用一个表达式，返回一个新序列。
[<表达式> for i in <序列>]
[2*i for i in range(6)]  # [0, 2, 4, 6, 8, 10]

[<表达式> for i in <序列> if <表达式>]
[i for i in range(10) if i % 2 == 1]    # [1, 3, 5, 7, 9]

[random.randint(10,99) for i in range(10)] 	# 产生10个随机数

循环的遍历

1
2
3
4
5
6
7
8
9
10
11
12
mylist = [1,2,3,4,5]

1. while遍历循环
index = 0
while index < len(mylist) :
   element = mylist[index]
   print(f"元素是{element}")
   index += 1

2. for遍历循环
for a in mylist :
    print(f"元素是{a}")
  1. while循环可以控制循环条件，for循环只能一个一个取
  2. for循环无法无限循环，而while可以
  3. while用于任何循环场景更灵活，for用于处理容器更简单

元组

特点和描述

  1. 列表可以被修改，元组一但定义后无法修改。
  2. 元组用于在程序内封装无法被篡改的数据，通常作为参数传递给函数调用，或者从函数调用那里获得参数。
  3. 原组元素可以不同类型
  4. 允许嵌套
  5. 如果元组里嵌套了list，那么list的内容可以改变。(1,2,["3","4"])

定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 字面量
(元素1,元素2,元素3)

# 变量定义
a = (元素1,元素2,元素3)

# 定义空元组
a = ()
a = tuple()

# 定义单个元素的元组
("tan",)

# 定义嵌套元组
((1,2,3),(4,5,6))

元组的下标索引

1
2
3
a = (1,2,3)
# 从左到右取列表值
print(a[0])  # 1

元组的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
1. index方法 (获取内容对应索引值，元素不存在会报错)
a = (1,2,3,4)
index = a.index(2)

2. count方法 统计元组内某元素的数量
count = a.count(5)   # 统计元组内5的数量

3. len方法  计算元组元素的个数
num = len(a)   

4. 元组与列表的转换
list1 = list((1,2,3,4)) 	# [1,2,3,4]
tuple1 = tuple([1,2,3,4])		# (1,2,3,4)

元组遍历同列表

字符串

字符串定义

  1. 普通字符串

    1
    2
    3
    str1 = 'hello world'
    str2 = "hello world"
    str3 = """hello world"""

  2. 字符串嵌套

    1
    2
    3
    str1 = "输出单引号' "
    str2 = '输入双引号" '
    str3 = "\'  \" "

特点

  1. 支持正向下标索引，和反向下标索引。
    1
    2
    3
    str = "hello world"
    str[0]		# "h"
    str[-1]		# "d"
  2. 只可以存储字符串
  3. 长度任意
  4. 允许重复字符串存在
  5. 字符串无法修改
  6. 支持while 和for循环
  7. Python中字符串以Unicode编码存储

转义字符

使用\标识

转义字符 符号
\ 续行符
\ \ 反斜杠
\‘ 单引号
\ “ 双引号

常用方法

image
演示：

1
2
3
4
5
6
7
8
1. index方法 (获取内容对应索引值，元素不存在会报错)
a = "ABCD"
index = a.index(A)

2. strip 方法
# 移除首尾的字符串"1" "2"  
a = "12abcde21"  
b = a.strip("12")   # b = "abcde"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
s.upper() s.lower  # 大小写
s.capitalizze()	# 首字母大写
s.title()		# 首字母大写，其它小写
s.swapcasw()	# 大小写交换

s.strip()	删除首尾空格
s.rstrip()	从右边删除
s.lstrip()	从左边删除

s.count("x")	计数
s.find("x")		从左往右找，找到第一个出现该字符的位置
s.rfind("X")	从右往左找，找到第一个出现该字符的位置
找不到返回-1

s.index("x")	和find一样，但是找不到不抛出异常

s.replace("old","new",num)	替换字符串，替换不超过num次

s.isalnum()	是否全是字母和数字，并且至少一个字符
s.isalpha()	是否全是字母，并且至少一个字符
s.isdigit()	是否全是数字，并且至少一个字符
s.isspace()	是否全是空白字符，并且至少一个字符
s.islower()	是否全是小写
s.isupper()	是否全是大写
s.istitle()	是否首字母大写

s.split("分割符",num) 	分割文本，num表示分割次数。
"分隔符".join("python")		以分隔符链接字符串

序列

特点

  1. 序列是指内容连续，有序，可使用下标索引的一类数据容量。
  2. 元素之间存在先后关系，每个元素分配一个数字表示它的位置
  3. 元素之间不排他
  4. 常见序列字符串，列表，元组

序列的切片操作

从一个序列中取出一个子序列

序列[起始下标:结束下标:步长]
起始下标表示从何处开始，留空表示从头开始
结束下标是不包含本身的，结束下标是5则取到4就结束。留空表示取到结尾。
步长表示取元素的间隔。正数从头向尾，负数从尾向头。省略步长默认为1 

1
2
3
4
a = "ABCDEF"  
a[1:3]   # 步长是1可以省略  BC
a[:]     # 从头开始，到尾结束
a[5:2:-1]  # FED

set集合

特点

  1. 不支持元素重复(自带去重功能)
  2. 内容无序，不支持下标索引访问
  3. 允许修改
  4. 不支持while循环(没法用下标索引)，支持for循环
  5. 元素只能是固定数据类型，如整数，浮点数，字符串，元组

集合的定义

1
2
3
4
5
6
7
8
1. 字面量定义
{1,2,3}

2. 定义集合变量
a = {1,2,3}

3. 定义空集合
a = set()

方法

image

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1. 创建集合
	sets = set()
	sets = {1,2,3,4,5}

2. 集合解析
{x for x in "abcdefg" if  x not in "abc"}	# {'d', 'f', 'e', 'g'}

3. 并集 A | B

4. 差集 A - B

5. 交集 A & B

6. 补集 A^ B

7. 添加元素
	s.add("x")	# 添加元素到集合
	s.update(x1,x2,x3)	# 添加元素，参数可以是列表，元组，字典，集合。
	
8. 移除元素
	sets.remove(”x“)	# 移除元素，元素不存在会报异常
	sets.discard("x")	# 移除元素，如果元素不存在不会报异常
	sets.pop()		# 移除集合中的第一个元素，如果集合为空抛出异常。
	sets.clear()	# 清空集合

字典

key与value一一对应

定义

1
2
3
4
5
6
7
8
9
1. 定义字典字面量
{key:value ，key:value ，key:value}

2. 定义字典变量
a = {key:value ，key:value ，key:value}

3. 定义空字典
a = {}
a = dict()

特点

  1. 通过key获取value，key值不允许重复，重复会覆盖。
  2. 元素之间无顺序，无法使用下标索引，只能通过key值去找内容
  3. 字典的key和value可以是任意数据类型(key不可为字典)
  4. 每一份数据都是key-value 的键值对
  5. 可以用for循环遍历，但是不支持while
  6. 字典值支持修改，字典的建是唯一的，必须是不可变的数据类型

读取和嵌套

  1. 通过key获取value
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    dic = [a:1 ,b:2 ,c:3]
    num = dic[a]
    ```  

    2. 字典嵌套  

    | 姓名  | 语文  | 数学  |
    | --- | --- | --- |
    | a   | 36  | 39  |
    | b   | 69  | 58  |
    name = {“a”:{
    “语文”:36，
    “数学”:39} ,
    “b”:{
    “语文”:69，
    “数学”:58}}

c = name[“a”][“语文”]

1
2
3
4
5
6
7
8
9
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

#### 操作方法  
![image](IMG_20221118_084249.png)
```python
1. 创建字典
	dict = {}
	
	dict([("语文",89),("数学",86)])	
		# 包含键值的序列对，建立字典
		# {'语文': 89, '数学': 86}
		
	dict(语文=89,数学=86)	# 通过关键字建立字典
	
	{}.fromkeys(["A","B","C"],"默认值")	# 创建只有关键字，没有值的字典。自动去重。
		# {'A': '默认值', 'B': '默认值', 'C': '默认值'}
	
2. 访问字典的值
	dict["数学"]
	"数学" in dict
	dict.get(键,默认值)	# 找不到会返回默认值
	
3. 返回字典所有建，值，项
		1. 通常与for配合遍历。
		2. 可以通过list()将返回值转换成列表
	dict.keys()
	dict.values()
	dict.items()
	
4. 字典遍历
	for di in dict:
  	  print(f"key={di},value={dict[di]}")
	
5. 清空与删除
	dict.clear() # 清空字典元素
	del dict   # 删除字典

字典遍历

image

总结

image

image

image

数据容器的通用操作

image

  1. 字典在参与转换和排序时都会丢掉value值。
  2. 排序后都会返回列表。
  3. 字符串的比较是比较其ASCII码值，按位从前到后比较，第一位都是a则比较第二位，直到某一位的字符比另一个字符串对应字符大，则字符串大。所以abd>abc 。