Python线性数据结构

Python线性数据结构
python线性数据结构
目录
- 1 线性数据结构
- 2.内建常用的数据类型
  2.1 数值型
  2.2 序列(sequence)
  2.2.1 list 列表
  2.2.2 tuple 元组
  2.2.3 string 字符串
  2.2.4 bytes 字节
  2.2.5 bytearray 字节数组
```
<center>码好python的每一篇文章.</center>
```
1 线性数据结构

本章要介绍的线性结构：list、tuple、string、bytes、bytearray。
- 线性表：是一种抽象的数学概念，是一组元素的序列的抽象，由有穷个元素组成(0个或任意个)。
  
  线性表又可分为顺序表和链接表。
- 顺序表：一组元素在内存中有序的存储。列表list就是典型的顺序表。
- 链接表：一组元素在内存中分散存储链接起来，彼此知道连接的是谁。
  
  对于这两种表，数组中的元素进行查找、增加、删除、修改，看看有什么影响：
- 查找元素
  
  对于顺序表，是有序的在内存中存储数据，可快速通过索引编号获取元素，效率高。。
  
  对于链接表是分散存储的，只能通过一个个去迭代获取元素，效率差。
- 增加元素
  
  对于顺序表，如果是在末尾增加元素，对于整个数据表来说没什么影响，但是在开头或是中间插入元素，后面的所有元素都要重新排序，影响很大(想想数百万或更大数据量)。
  
  对于链接表，不管在哪里加入元素，不会影响其他元素，影响小。
- 删除元素
  对于顺序表，删除元素和增加元素有着一样的问题。
  对于链接表，不管在哪里删除元素，不会影响其他元素，影响小。
- 修改元素
  对于顺序表，可快速通过索引获取元素然后进行修改，效率高。
  
  对于链接表，只能通过迭代获取元素然后进行修改，效率低。
总结：顺序表对于查找与修改效率最高，增加和删除效率低。链接表则相反。

2.内建常用的数据类型

2.1 数值型
- int 整数类型
  
  说明：整数包括负整数、0、正整数（... -2,-1,0,1,2, ...）。
```
x1 = 1
x2 = 0
x3 = -1
print(type(x1), x1)
print(type(x2), x2)
print(type(x3), x3)

# 输出结果如下：
<class 'int'> 1
<class 'int'> 0
<class 'int'> -1
```
  int( )方法：可以将数字或字符串转为整数，缺省base=10,表示10进制，无参数传入则返回0。
```
x1 = int()
x2 = int('1')
x3 = int('0b10',base=2)  #base=2，表二进制，与传入参数类型一致。
x4 = int(3.14)
print(type(x1), x1)
print(type(x2), x2)
print(type(x3), x3)
print(type(x4), x4)

# 输出结果如下：
<class 'int'> 0
<class 'int'> 1
<class 'int'> 2
<class 'int'> 3
```
- float 浮点类型
  说明：由整数和小数部分组成，传入的参数可以为int、str、bytes、bytearray。
```
x1 = float(1)
x2 = float('2')
x3 = float(b'3')
print(type(x1), x1)
print(type(x2), x2)
print(type(x3), x3)

# 输出结果如下：
<class 'float'> 1.0
<class 'float'> 2.0
<class 'float'> 3.0
```
- complex (复数类型)
  
  说明：由实数和虚数部分组成，都是浮点数。
  
  传入参数可以为int、str，如果传入两参，前面一个为实数部分，后一个参数为虚数部分。
```
x1 = complex(1)
x2 = complex(2,2)
x3 = complex('3')
print(type(x1), x1)
print(type(x2), x2)
print(type(x3), x3)

# 输出结果如下：
<class 'complex'> (1+0j)
<class 'complex'> (2+2j)
<class 'complex'> (3+0j)
```
- bool (布尔类型)
  
  说明：为int的子类，返回的是True和False，对应的是1和0。
```
x1 = bool(0)
x2 = bool(1)
x3 = bool()
x4 = 2 > 1
print(type(x1), x1)
print(type(x2), x2)
print(type(x3), x3)
print(type(x4), x4)

# 输出结果如下：
<class 'bool'> False
<class 'bool'> True
<class 'bool'> False
<class 'bool'> True
```
2.2 序列(sequence)

2.2.1 list 列表

说明： 列表是由若干元素对象组成，且是有序可变的线性数据结构，使用中括号[ ]表示。
- 初始化
```
lst = []  # 空列表方式1
#或者
lst = list()  # 空列表方式2
print(type(lst),lst)

# 输入结果如下：
<class 'list'> []
```
- 索引
  
  说明： 使用正索引(从左至右)、负索引(从右至左)访问元素，时间复杂度为O(1)，效率极高的使用方式。
  
  按照给定区间获取到数据，叫做切片。
  
  正索引：
  
  从左至右，从0开始索引，区间为[0，长度-1]，左包右不包。
```
lst = ['a','b','c','d']
print(lst[0])  # 获取第一个元素
print(lst[1:2])  # 获取第二个元素,左包右不包，切片
print(lst[2:])  # 获取第三个元素到最后一个元素，切片
print(lst[:])  # 获取所有元素，切片

# 输出结果如下：
a
['c']
['c', 'd']
['a', 'b', 'c', 'd']
```
  负索引：
  
  从右至左，从-1开始索引，区间为[-长度，-1]
```
lst = ['a','b','c','d']
print(lst[-1])
print(lst[-2:])

# 输出结果如下：
d
['c', 'd']
```
- 查询
  
  index( )方法：L.index(value, [start, [stop]]) -> integer
  
  返回的是索引id，要迭代列表，时间复杂度为O(n)。
```
lst = ['a','b','c','d']
print(lst.index('a',0,4))  # 获取区间[0,4]的元素'a'的索引id

# 输出结果如下：
0
```
  备注：如果查询不到元素，则抛出ValueError。
  
  count( ) 方法：L.count(value) -> integer
  
  返回的是元素出现的次数，要迭代列表，时间复杂度为O(n)。
```
lst = ['a','b','a','b']
print(lst.count('a'))

# 输出结果如下：
2
```
  len( ) 方法：返回的是列表元素的个数，时间复杂度为O(1)。
```
lst = ['a','b','c','d']
print(len(lst))

# 输出结果如下：
4
```
  备注：所谓的O(n) 是指随着数据的规模越来越大，效率下降，而O(1)则相反，不会随着数据规模大而影响效率。
- 修改
  
  列表是有序可变，所以能够对列表中的元素进行修改。
```
lst = ['a','b','c','d']
lst[0] = 'A'
print(lst)

# 输出结果如下：
['A', 'b', 'c', 'd']
```
- 增加
  
  append( ) 方法：L.append(object) -> None
  
  尾部追加元素，就地修改，返回None。
```
lst = ['a','b','c','d']
lst.append('e')
print(lst)

# 输出结果如下：
['a', 'b', 'c', 'd', 'e']
```
  insert( )方法：L.insert(index, object) -> None ,
  
  在指定索引位置插入元素对象，返回None。
```
lst = ['a','b','c','d']
lst.insert(0,'A')  # 在索引0位置插入'A',原有的元素全部往后移，增加了复杂度
print(lst)

# 输出结果如下：
['A', 'a', 'b', 'c', 'd']
```
  extend( )方法： L.extend(iterable) -> None
  
  可以增加多个元素，将可迭代对象的元素追加进去，返回None。
```
lst = ['a','b','c','d']
lst.extend([1,2,3])
print(lst)

# 输出结果如下：
['a', 'b', 'c', 'd', 1, 2, 3]
```
  还可以将列表通过 + 和 * ，拼接成新的列表。
```
lst1 = ['a','b','c','d']
lst2 = ['e','f','g']
print(lst1 + lst2)
print(lst1 * 2)  # 将列表里面的元素各复制2份

# 输出结果如下：
['a', 'b', 'c', 'd', 'e', 'f', 'g']
['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']
```
  这里还有一个特别要注意情况如下：
```
lst1 = [[1]] * 3  # 结果：[[1], [1], [1]]
print(lst1)
lst1[0][0] = 10  # 结果：[[10], [1], [1]]，是这样嘛？？
print(lst1)

# 输出结果如下：
[[1], [1], [1]]
[[10], [10], [10]]  # 为什么结果会是这个？请往下看列表复制章节，找答案！
```
- 删除
  
  remove()方法：L.remove(value) -> None
  
  从左至右遍历查找，找到就删除该元素，返回None，找不到则抛出ValueError。
```
lst = ['a','b','c','d']
lst.remove('d')
print(lst)

# 输出结果如下：
['a', 'b', 'c']  # 元素'd'已经被删除
```
  pop() 方法：L.pop([index]) -> item
  
  缺省删除尾部元素，可指定索引删除元素，索引越界抛出IndexError。
```
lst = ['a','b','c','d']
lst.pop()
print(lst)

# 输出结果如下：
['a', 'b', 'c']
```
  clear() 方法：L.clear() -> None
  
  清空列表所有元素，慎用。
```
lst = ['a','b','c','d']
lst.clear()
print(lst)

# 输出结果如下：
[]  # 空列表了
```
- 反转
  
  reverse( ) 方法：L.reverse()
  
  将列表中的元素反转，返回None。
```
lst = ['a','b','c','d']
lst.reverse()
print(lst)

# 输出结果如下：
['d', 'c', 'b', 'a']
```
- 排序
  
  sort() 方法：L.sort(key=None, reverse=False) -> None
  
  对列表元素进行排序，缺省为升序，reverse=True为降序。
```
lst = ['a','b','c','d']
lst.sort(reverse=True)
print(lst)

# 输出结果如下：
['d', 'c', 'b', 'a']
```
- in成员操作
  
  判断成员是否在列表里面，有则返回True、无则返回False。
```
lst = ['a','b','c','d']
print('a' in lst)
print('e' in lst)

# 输出结果如下：
True
False
```
- 列表复制
  
  说明： 列表复制指的是列表元素的复制，可分为浅copy和深copy两种。列表元素对象如列表、元组、字典、类、实例这些归为引用类型(指向内存地址)，而数字、字符串先归为简单类型，好让大家理解。
  
  示例一：这是属于拷贝嘛？
```
lst1 = [1,[2,3],4]
lst2 = lst1
print(id(lst1),id(lst2),lst1 == lst2, lst2)  # id() 查看内存地址

# 输出结果如下：
1593751168840 1593751168840 True [1, [2, 3], 4]
```
  显然不是属于任何copy，说白了都是指向同一个内存地址。
  
  示例二：浅拷贝copy
  
  说明： 浅拷贝对于引用类型对象是不会copy的，地址指向仍是一样。
```
lst1 = [1,[2,3],4]
lst2 = lst1.copy()
print(id(lst1),id(lst2),lst1 == lst2, lst2)
print('=' * 30)
lst1[1][0] = 200  # 修改列表的引用类型，所有列表都会改变
print(lst1, lst2)

# 输出结果如下：
1922175854408 1922175854344 True [1, [2, 3], 4]
==============================
[1, [200, 3], 4] [1, [200, 3], 4]
```
  示例三：深拷贝deepcopy
  
  说明： 深拷贝对于引用类型对象也会copy成另外一份，地址指向不一样。
```
import copy

lst1 = [1,[2,3],4]
lst2 = copy.deepcopy(lst1)
print(id(lst1),id(lst2),lst1 == lst2, lst2)
print('=' * 30)  
lst1[1][0] = 200  # 修改列表的引用类型，不会影响其他列表
print(lst1, lst2)

# 输出结果如下：
2378580158344 2378580158280 True [1, [2, 3], 4]
==============================
[1, [200, 3], 4] [1, [2, 3], 4]
```
2.2.2 tuple 元组

说明： 元组是由若干元素对象组成，且是有序不可变的数据结构，使用小括号( )表示。
- 初始化
```
t1 = ()  # 空元素方式1，一旦创建将不可改变
t2 = tuple()  # 空元素方式2，一旦创建将不可改变
t3 = ('a',)  # 元组只有一个元素，一定要加逗号','
t4 = (['a','b','c'])  # 空列表方式2
```
  备注： 元组如果只有一个元素对象，一定要在后面加逗号, 否则变为其他数据类型。
- 索引
  同列表一样，不再过多举例。
```
t = ('a','b','c','d')
print(t[0])
print(t[-1])
# 输出结果如下：
a
d
```
- 查询
  
  同列表一样，不再过多举例。
```
t = ('a','b','c','d')
print(t.index('a'))
print(t.count('a'))
print(len(t))

# 输出结果如下：
0
1
4
```
- 增删改
  
  元组是不可变类型，不能增删改元素对象。
  
  但是要注意如下场景：
  
  元组中的元素对象(内存地址)不可变，引用类型可变。----这里又出现引用类型的情况了。
```
# 元组的元组不可修改(即内存地址)
t = ([1],)
t[0]= 100
print(t)
# 结果报错了
TypeError: 'tuple' object does not support item assignment
    
############################################

# 元组里面的引用类型对象可以修改（如嵌套了列表）
t = ([1],2,3)
t[0][0] = 100  # 对元组引用类型对象的元素作修改
print(t)

# 输出结果如下：
([100], 2, 3)
```
2.2.3 string 字符串

说明： 字符串是由若干字符组成，且是有序不可变的数据结构，使用引号表示。
- 初始化
  多种花样，使用单引号、双引号、三引号等。
```
name = 'tom'
age = 18
str1 = 'abc'  # 单引号字符串
str2 = "abc"  # 双引号字符串
str3 = """I'm python"""  # 三引号字符串
str4 = r"c:windows
ote"  # r前缀，没有转义(转义字符不生效)
str5 = f'{name} is {age} age.'  # f前缀，字符串格式化，v3.6支持
print(type(str1), str1)
print(type(str2), str2)
print(type(str3), str3)
print(type(str4), str4)
print(type(str5), str5)

# 输出结果如下：
<class 'str'> abc
<class 'str'> abc
<class 'str'> I'm python
<class 'str'> c:windows
ote
<class 'str'> tom is 18 age.
```
- 索引
  
  同列表一样，不再过多举例。
```
str = "abcdefg"
print(str[0])
print(str[-1])

# 输出结果如下：
a
g
```
- 连接
  
  通过加号 + 将多个字符串连接起来，返回一个新的字符串。
```
str1 = "abcd"
str2 = "efg"
print(str1 + str2)

# 输出结果如下：
abcdefg
```
  join( ) 方法：S.join(iterable) -> str
  
  s表示分隔符字符串，iterable为可迭代对象字符串，结果返回字符串。
```
str = "abcdefg"
print('->'.join(str))

# 输出结果如下：
a->b->c->d->e->f->g
```
- 字符查找
  
  find( ) 方法：S.find(sub[, start[, end]]) -> int
  
  从左至右查找子串sub，也可指定区间，找到返回正索引，找不到则返回 -1 。
```
str = "abcdefg"
print(str.find('a',0,7))
print(str.find('A'))

# 输出结果如下：
0
-1
```
  rfind( ) 方法：S.rfind(sub[, start[, end]]) -> int
  
  从右至左查找子串sub，也可指定区间，找到返回正索引，找不到则返回 -1 。
```
str = "abcdefg"
print(str.rfind('a'))
print(str.rfind('A'))

# 输出结果如下：
0
-1
```
  还有index()和find() 类似，不过找不到会抛异常，不建议使用。
  
  像s.count() 还可以统计字符出现的次数。
  
  像len(s) 还可以统计字符串的长度。
- 分割
  
  split( ) 方法：S.split(sep=None, maxsplit=-1) -> list of strings
  
  sep表示分隔符，缺省为空白字符串，maxsplit=-1表示遍历整个字符串，最后返回列表。
```
str = "a,b,c,d,e,f,g"
print(str.split(sep=','))

# 输出结果如下：
['a', 'b', 'c', 'd', 'e', 'f', 'g']
```
  rsplit( ) 方法与上面不同就是，从右至左遍历。
  
  splitlines() 方法： S.splitlines([keepends]) -> list of strings
  
  按行来切割字符串，keepends表示是否保留行分隔符，最后返回列表。
```
str = "a
b
c
d"
print(str.splitlines())
print(str.splitlines(keepends=True))

# 输出结果如下：
['a', 'b', 'c', 'd']
['a
', 'b
', 'c
', 'd']
```
  partition() 方法 ： S.partition(sep) -> (head, sep, tail)
  
  从左至右查询分隔符，遇到就分割成头、分隔符、尾的三元组，返回的是一个元组tuple。
```
str = "a*b*c*d"
print(str.partition('*'))
# 输出结果如下：
('a', '*', 'b*c*d')
```
  rpartition() 方法 ：S.rpartition(sep) -> (head, sep, tail)
  
  与上方法不同，就是从右至左，不过这个比较常用，可以获取后缀部分信息。
```
str1 = "http://www.python.org:8843"
str2 = str1.rpartition(':')
port = str2[-1]
print(port)
```
- 替换
  
  replace() 方法：S.replace(old, new[, count]) -> str
  
  遍历整个字符串，找到全部替换，count表示替换次数，缺省替换全部，最后返回一个新的字符串。
```
str = "www.python.org"
print(str.replace('w','m'))  # 返回的是一个新的字符串
print(str)  # 字符串不可变，保持原样

# 输出结果如下：
mmm.python.org
www.python.org
```
- 移除
  
  strip() 方法：S.strip([chars]) -> str
  
  在字符串两端移除指定的字符集chars , 缺省移除空白字符。
```
str = " * www.python.org  *"
print(str.strip("* "))  # 去掉字符串首尾带有星号'*' 和 空白' '

# 输出结果如下：
www.python.org
```
  还有lstrip() 和 rstrip 分别是移除字符串左边和右边字符集。
- 首尾判断
  
  startswith() 方法：S.startswith(prefix[, start[, end]]) -> bool
  
  缺省判断字符串开头是否有指定的字符prefix,也可指定区间。
```
str = "www.python.org"
print(str.startswith('www',0,14))
print(str.startswith('p',0,14))
# 输出结果如下：
True
False
```
  endswith() 方法：S.endswith(suffix[, start[, end]]) -> bool
  
  缺省判断字符串结尾是否有指定的字符suffix,也可指定区间。
```
str = "www.python.org"
print(str.startswith('www',0,14))
print(str.startswith('p',0,14))
# 输出结果如下：
True
False
```
```
str = "www.python.org"
print(str.endswith('g',11,14))
# 输出结果如下：
True
```
- 格式化
  
  c风格格式化：
  
  格式字符串：使用%s(对应值为字符串)，%d(对应值为数字)等等，还可以在中间插入修饰符%03d。
  
  被格式的值：只能是一个对象，可以是元组或是字典。
```
name = "Tom"
age = 18
print("%s is %d age." % (name,age))
# 输出结果如下：
Tom is 18 age.
```
  format格式化：
  
  格式字符串：使用花括号{ }, 花括号里面可以使用修饰符。
  
  被格式的值：*args为可变位置参数，**kwargs为可变关键字参数。
```
# 位置传参
print("IP={} PORT={}".format('8.8.8.8',53))  # 位置传参
print("{Server}: IP={1} PORT={0}".format(53, '8.8.8.8', Server='DNS Server'))  # 位置和关键字传参传参

# 输出结果如下：
IP=8.8.8.8 PORT=53
DNS Server: IP=8.8.8.8 PORT=53
```
```
# 浮点数
print("{}".format(0.123456789))
print("{:f}".format(0.123456789))    #  小数点默认为6位
print("{:.2f}".format(0.123456789))  # 取小数点后两位
print("{:15}".format(0.123456789))   # 宽度为15，右对齐

# 输出结果如下：
0.123456789
0.123457     # 为什么是这个值？大于5要进位
0.12
    0.123456789  # 左边有4个空格
```
- 其他常用函数
```
str = "DianDiJiShu"
print(str.upper())  # 字母全部转化为大写
print(str.lower())  # 字母全部转化为小写

# 输出结果如下：
DIANDIJISHU
diandijishu
```
2.2.4 bytes 字节

bytes 和 bytearray从python3引入的两种数据类型。

在计算机的世界里，机器是以0 和 1 组成的，也叫二进制(字节)来通信的，这套编码我们叫做ASCII编码。

所以机器通信的语言就叫做机器语言。然而我们人类想要跟机器通信，那么需要怎么做呢？
- 把人类的语言编码成机器能够识别的语言，通常叫做编码（字符串转换为ASCII码）。
- 把机器的语言解码成人类能够识别的语言，通常叫做解码（ASCII码转换为字符串）。
至今现代编码的发展史过程大概是这样的：ASCII(1字节) -> unicode(2~4字节) -> utf-8(1_{6字节)，utf8是多字节编码，一般使用1}3字节，特殊使用4字节(一般中文使用3字节)，向下兼容ASCII编码。

中国也有属于自己的编码：gbk

ASCII码表常用的必须牢记(整理部分)：

详细ASCII码下载链接：
```
链接：https://pan.baidu.com/s/1fWVl57Kqmv-tkjrDKwPvSw 提取码：tuyz
```
所以，机器上的进制就是字节，1字节等于8位，例如：十进制2，用2进制和16进制表示：
```
# 二进制
0000 0010  # 一个字节bytes

# 16进制，机器基本都是显示16进制
0x2
```
bytes 是不可变类型
```
bytes()     # 空bytes，一旦创建不可改变
bytes(int)  # 指定字节的大小，用0填充
bytes(iterable_of_ints)  # [0.255]整数的可迭代对象
bytes(string, encoding[, errors])  # 等价于string.encoding(),字符串编码成字节
bytes(bytes_or_buffer)  # 复制一份新的字节对象
```
- 初始化
```
b1 = bytes()
b2 = bytes(range(97,100))
b3 = bytes(b2)
b4 = bytes('123',encoding='utf-8')
b5 = b'ABC'
b6 = b'xe4xbdxa0xe5xa5xbd'.decode('utf-8')
print(b1, b2, b3, b4, b5, b6, sep='
')

# 输出结果如下：
b''
b'abc'
b'abc'
b'123'
b'ABC'
你好
```
2.2.5 bytearray 字节数组

bytearray 是可变数组，可以进行增删改操作，类似列表。
```
bytearray()  # 空bytearray,可改变
bytearray(iterable_of_ints)  # [0.255]整数的可迭代对象
bytearray(string, encoding[, errors])  # 等价于string.encoding(),字符串编码成字节
bytearray(bytes_or_buffer)   # 复制一份新的字节数组对象
bytearray(int)  # 指定字节的大小，用0填充
```
- 增删改
```
# 初始化
b = bytearray()
print(b)
# 输出结果如下：
bytearray(b'')
#--------------------------
# 增加元素对象
b.append(97)
print(b)
b.extend([98,99])
print(b)
# 输出结果如下：
bytearray(b'a')
bytearray(b'abc')
#--------------------------
# 插入元素对象
b.insert(0,65)
print(b)
# 输出结果如下：
bytearray(b'Aabc')
#--------------------------
# 删除元素对象
b.pop()
print(b)
# 输出结果如下：
bytearray(b'Aab')
```
今天就到这了，下一回合咱再接着唠嗑 set (集合) 和 dict (字典) ，敬请耐心等待。

如果喜欢的我的文章，欢迎关注我的公众号：点滴技术，扫码关注，不定期分享
相关阅读:
leetCode 53. maximum subarray
leetcode strStr()
DCNN models
1*1 的卷积核
 leetcode 14. longest common prefix
springMVC接受json并打开新页面
 jsp取addFlashAttribute值深入理解即springMVC发redirect传隐藏参数
 hive安装教程本地模式
 poi excel超出65536行数限制自动扩展Invalid row number (65536) outside allow
java 构造json对象数组
原文地址：https://www.cnblogs.com/singvis/p/12578929.html

Python线性数据结构

1 线性数据结构

2.内建常用的数据类型

2.1 数值型

2.2 序列(sequence)

2.2.1 list 列表

2.2.2 tuple 元组

2.2.3 string 字符串

2.2.4 bytes 字节

2.2.5 bytearray 字节数组