python数据结构

目录

〇，数据类型

1，基本数据类型

2，可变与不可变

一，字符串

1，字符串表示

2，字符串截取

二，列表、双端队列

1，列表

（1）修改

（2）新增元素——append、insert

（3）删除——del、pop、remove

2，双端队列

三，元组

四，字典

（1）创建、新增

（2）修改

（3）查找

五，集合

六，矩阵、向量

1，一维矩阵的向量

2，二维矩阵的向量

3，矩阵的广播

（1）一维矩阵向量

（2）二维矩阵向量

（3）二维矩阵

七，张量

---

〇，数据类型

1，基本数据类型

常用基本数据类型有 int float str 三种。

定义变量不需要指定类型，相当于所有变量都是auto的。

变量之间可以强转。

代码：

num1 = '3.3'
num2 = '6'
print(float(num1)+int(num2))
stra = 5
print(str(stra))

输出：

9.3
5

2，可变与不可变

可变类型：

• 列表（List）
• 集合（Set）
• 字典（Dictionarie）
• 自定义类（User-Defined Classes 取决于用户的定义）

不可变类型：

• 数字 （Integer, Rational, Float, Decimal, Complex & Booleans）
• 字符串（String）
• 元组（Tuple）
• 冻结的集合（Frozen Set）
• 自定义类（User-Defined Classes 取决于用户的定义）

一，字符串

1，字符串表示

字符串可以用单引号，双引号，三引号。

单引号和双引号是一样的，可以引用单行字符串，需要换行的话在里面放\n即可。

三引号可以之间引用多行字符串

代码：

str1 = 'str1'
str2 = "str2\nstr2"
str3 = '''str3
'str3' '''
str4 = '''"str4"'''
print(str1)
print(str2)
print(str3)
print(str4)

输出：

str1
str2
str2
str3
'str3' 
"str4"

可以看出，三引号里面的单引号和双引号是不需要转义符的，只不过单引号和三引号需要隔开，双引号和三引号可以直接挨着。

2，字符串截取

str1 = 'abcdefg'
str2 = str1[0:3]
str3 = str1[1:-1]
str4 = str1[4:]
print(str2)
print(str3)
print(str4)

输出：

abc
bcdef
efg

二，列表、双端队列

1，列表

inputs_list = [1,2,3,6,7]
print(inputs_list)

[1, 2, 3, 6, 7]

（1）修改

inputs_list = [1,2,3,6,7]
inputs_list[0] = 'ereg'
inputs_list[1] += 3.5
print(inputs_list)

['ereg', 5.5, 3, 6, 7]

列表中的成员可以类型各不相同。

（2）新增元素——append、insert

inputs_list = [1,2,3,6,7]
inputs_list.append('sss')
print(inputs_list)

[1, 2, 3, 6, 7, 'sss']

inputs_list = [1,2,3,6,7]
inputs_list.insert(2,'sss')
print(inputs_list)

[1, 2, 'sss', 3, 6, 7]

第一个参数表示插入到某个id的元素之前，id可以是负数

inputs_list = [1,2,3,6,7]
inputs_list.insert(-1,'sss')
print(inputs_list)

[1, 2, 3, 6, 'sss', 7]

（3）删除——del、pop、remove

inputs_list = [1,2,3,6,7]
del inputs_list[1]
print(inputs_list)

[1, 3, 6, 7]

inputs_list = [1,2,3,6,7]
tail = inputs_list.pop()
print(tail)
print(inputs_list)

7
[1, 2, 3, 6]

pop是删掉列尾的元素

inputs_list = [1,2,3,6,7]
tail = inputs_list.pop(1)
print(tail)
print(inputs_list)

2
[1, 3, 6, 7]

inputs_list = [1,'2',3,'34','22','34',123]
inputs_list.remove('34')
print(inputs_list)

[1, '2', 3, '22', '34', 123]

remove会查找并删除第一个出现的元素

2，双端队列

import time
import collections

count=0
queue =  collections.deque()
start = time.time()
queue.append(1)
while(queue):
    queue.pop()
    count+=1
    if count<10000000:
        queue.append(1)
end = time.time()
print(end-start)
print(count)

1千万次插入删除，耗时2.6秒

对比C++：

int main()
{
	clock_t s, e;
	s = clock();
	deque<int> d;
	int count = 0;
	d.push_back(1);
	while (!d.empty()) {
		d.pop_front();
		count += 1;
		if (count < 10000000)d.push_back(2);
	}
	e = clock();
	cout << e - s;
	return 0;
}

C++才耗时22毫秒

三，元组

元组是不可改的，但是可以和list互转

t = (1,2,3)
print(t)

mylist = list(t)
print(mylist)

t2 = tuple(mylist)
print(t2)

(1, 2, 3)
[1, 2, 3]
(1, 2, 3)

四，字典

（1）创建、新增

dict = {}
dict['s'] = 123
print(dict)

{'s': 123}

（2）修改

dict = {'s':123}
dict['s'] = 456
print(dict)

{'s': 456}

（3）查找

dict = {'s':123}
print(dict.get('s',-1))
print(dict.get('a',-1))

123
-1

五，集合

list1 = [1,2,3,4,1,2,5]
set1 = set(list1)
print(set1)

输出：{1, 2, 3, 4, 5}

六，矩阵、向量

numpy里面有矩阵操作，但是和数学里面的概念稍微有些不同。

1，一维矩阵的向量

v = numpy.array([1,2,3,4])
v2 = v.T
print(v2)

用一维矩阵表示的向量，只有行向量，没有列向量，相当于像数组一样不分行列。

所以转置之后还是不变。

2，二维矩阵的向量

v = numpy.array([[1,2,3,4]])
v2 = v.T
print(v2)

默认的是行向量，用.T可以转换成列向量。

列表转向量（行向量）：

inputs_list2 = numpy.array(inputs_list, ndmin=2)
print(inputs_list2)

[[1 2 3 6 7]]

转置：

inputs = inputs_list2.T
print(inputs)

[[1]
 [2]
 [3]
 [6]
 [7]]
 

3，矩阵的广播

（1）一维矩阵向量

v = numpy.array([1,2,3,4])
print(v + 3)

输出：[4 5 6 7]

（2）二维矩阵向量

v = numpy.array([[1,2,3,4]])
print(v + 3)
print(v.T + 10)

输出：

[[4 5 6 7]]
[[11]
 [12]
 [13]
 [14]]

（3）二维矩阵

（3.1）矩阵加一个数

v = numpy.array([[1,2,3,4], [5,6,7,8]])
print(v + 3)
print(v.T + 10)

输出：

[[ 4  5  6  7]
 [ 8  9 10 11]]
[[11 15]
 [12 16]
 [13 17]
 [14 18]]

（3.2）矩阵加一个行向量

m = numpy.array([[1,2,3,4], [5,6,7,8]])
v = [1, 1, 0, 0]
print(m + v)

输出：

[[2 3 3 4]
 [6 7 7 8]]

（3.3）矩阵加一个列向量

m = numpy.array([[1,2,3,4], [5,6,7,8]])
v = numpy.array([[1,10]])
print(m + v.T)

输出：

[[ 2  3  4  5]
 [15 16 17 18]]

七，张量

from __future__ import print_function
import torch
x = torch.zeros(5, 3, dtype=torch.long)
print(x)

tensor([[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]])

输出的是一个5行3列的二维张量。