Python的内建数据结构总结

一、列表List

1. 性质

• 连续编址
• 元素可以任意，可以是数字、字符串、对象、列表等
• 列表是可变的

2. 方法

• index(value) ：返回第一个$value$匹配的索引，匹配不到抛异常，O(n)
• count(value) ：返回列表中$value$出现的次数，比较低效，O(n)
• len(list) ：返回列表长度，直接返回list中的长度属性，O(1)
• append(value) ：list尾部添加$value$，无返回值，高效
• insert(index,value) ：在索引$index$处插入$value$，无返回值
• extend(可迭代对象)：将可迭代对象添加到list，无返回值
• remove(value)：根据$value$删除第一个出现的值，没出现则抛异常，效率低
• pop(index)：根据$index$删除第一个出现的值，并返回。无参则删除最后一个，并返回
• clear() : 将当前列表标记为空，引用计数减1
• reverse() ：将列表元素反转，无返回值
• sort(key=None, reverse=False)：默认升序，$key$指一个函数，规定排序方法，无返回值，改变自身列表
• 操作符 in ：判断元素是否在列表，返回bool

3. 深拷贝与浅拷贝

浅拷贝：copy()，引用类型就是拷贝地址

	l1 = [1,2,3,[10,100]]
    l2 = l1.copy() # 浅拷贝，l1 = [1,2,3,房间号码A]，l2 = [1,2,3,房间号码A]
    l2[0] = 111 # l2 = [111,2,3,[10,100]]， l1 = [1,2,3,[10,100]]
    l2[3][0] = 222 # l2 = [111,2,3,[222,100]]， l1 = [1,2,3,[222,100]]

操作符 “*”

	l1 = [1,[10,100]]
    l2 = l1 * 3  # l1 = [1,房间号码A] l2 = [1,房间号码A,1,房间号码A,1,房间号码A]
    l2[1][0] = 111 # l1 = [1,[111,100]], l2 = [1,[111,100],1,[111,100],1,[111,100]] 

深拷贝：copy.deepcopy()

	l1 = [1,2,3,[10,100]]
    l2 = copy.deepcopy(l1)  # 生成全新列表，不再是引用同一个房间号
    l2[3][0] = 222 # l1 = [1,2,3,[10,100]]， l2 = [1,2,3,[222,100]]

二、随机模块random

	import random
	
	random.randint(1, 3) # [1,3]
    random.randrange(1, 3) # [1, 3)内的整数
    lst = list(range(1,10))
    a = random.choice(lst) # 在列表中随机取一个数
    random.shuffle(lst) # 就地打乱列表
    random.sample(lst, 2) # 从列表里随机取两个

三、元组tuple

1. 性质

• 不可变对象

2. 初始化操作

	t1 = ()
    t2 = tuple()
    t5 = (1) # 错误的初始化操作，只是使用括号改变优先级
    t3 = (1, [3,4], 'abc', ) # 或 (1, [3,4], 'abc')
    t4 = tuple(range(10))

3. 元组构造列表

	t1 = (1,2,3) * 3
    l1 = list(t1) # 只是根据元组的值构造了一个新列表 [1, 2, 3, 1, 2, 3, 1, 2, 3]
    l1[0] = 100   # [100, 2, 3, 1, 2, 3, 1, 2, 3]

4. 方法

• index(value,[start,[stop]])：在指定区间内根据$value$返回索引，匹配不到抛异常，$O(n)$
• count(value)：返回$value$出现的次数，$O(n)$
• len() ：返回元组长度，$O(1)$

5. namedtuple

	from collections import namedtuple
	
	Point = namedtuple('Point', ['x','y']) # 是namedtuple的子类
	# Point = namedtuple('Point', 'x y')
	# Point = namedtuple('Point', 'x, y')
    type(Point) # type ，Point是type类
    p1 = Point(4, 5) # Point(x=4, y=5)
    p1.x = 100 # 不允许修改

四、字符串Str

1. 性质

• 不可变对象，不可修改
• $Unicode$类型

2. $f$ 前缀

格式化字符串，功能等同于$format()$函数

	x = 1
    y = 10
    str1 = f'{x}->{y}' # 1->10，同'{}->{}'.format(x,y)
    str2 = '{x}->{y}' # {x}->{y}
    Point = namedtuple('Point', ['x', 'y'])
    p1 = Point(4, 5)
    str3 = f'{p1.x}' # '4'

3 . 连接

• $str.join(iterable)$：用字符串整体将可迭代对象的不同元素（必须是字符串）连接成一个字符串

	str1 = '   '.join(['1', '2', 'aa']) # 1   2   aa
    str2 = ':'.join(map(str, range(9))) # 0:1:2:3:4:5:6:7:8
    str3 = ':'.join(str(range(9)))  # r:a:n:g:e:(:0:,: :9:)
    str4 = ':'.join(['abc']) # abc

• 操作符 +
  重新生成字符串，赋值即重定义

4. 切分

• $str.split()$：默认使用空白字符串(包括 \t、\n、1至多个空格 )分割，立即返回列表，原字符串不变
• $str.splitlines()$ ：用换行符切分，包括 \r、\r\n 、\r

$sep$ 用于指定分割字符
$maxsplit$ 用于设置最大切割次数
$rsplit()$ 从右向左切

	str1 = ':'.join(map(str, range(5))) # 0:1:2:3:4
    str1.split() #['0:1:2:3:4']， 默认使用空白字符串(包括\t、\n、1至多个空格)分割，立即返回列表
    str1.split(':') # ['0', '1', '2', '3', '4']
    '1 2  3    4'.split() # ['1', '2', '3', '4']
    '1 2  3    4'.split(maxsplit = 2) # ['1', '2', '3    4']
    '1 2  3    4'.split(maxsplit = -1) # ['1', '2', '3', '4']，maxsplit = -1表示全部切完
    '1 2  3    4'.rsplit(maxsplit = 2) # ['1 2', '3', '4']
    '1\r\n2  3\n'.splitlines() # ['1', '2  3']
    

• $partition()$：必须指定分隔符，根据分隔符返回三元组(‘左边’,‘分隔符’,‘右边’)。且不到返回元组包括完整字符串、两个空字符

	'0:1:2:3:4'.partition(':') # ('0', ':', '1:2:3:4')
	'0:1:2:3:4'.partition(',') # 切不到， ('0:1:2:3:4', '', '')
	'0:1:2:3:4'.rpartition(',') # 切不到， ('', '','0:1:2:3:4')

5. $str.strip()$

默认去掉$str$两侧的空白字符，包括 一至多个空格、\r、\n、\r\n。返回新字符串，原字符串不变，非就地修改

	str1 = ' \r\n i am a coder \r '
    print(str1.strip()) # 'i am a coder'

参数$chars$：给一个字符串，切割的时候，碰到第一个非$chars$里的字符就停止切分

	str1 = '\r\n i am a coder\n'
    print(str1.strip()) # i am a coder
    print(str1.strip('\r\ni ')) # am a coder，碰到了a和r停止删除

6. 关于字符串判断

• $isalnum()$：是否由字母或数字组成
• $isalpha()$：是否是字母
• $isdecimal()$：是否只包含十进制数字
• $isdigit()$：是否全部是数字字符
• $isidentifier()$：是否是标识符（标识符要求：以字母或下划线开头，由字母、数字、下划线组成）
• $islower()$：是否全是小写字母
• $isupper()$：是否全是大写字母
• $isspace()$：是否只包含空白字符（空格、\r\n、\r、\n）

7. 其他常用的方法

• $str.lower()$
• $str.upper()$
• $str.replace(old,new[,count])$：返回将$str$中的$old$子串替换为$new$子串，替换$count$次的字符串，$str$不变，非就地修改
• $str.find(sub[,start[,end]])->int$：从左往右查找$sub$第一次出现的索引，找不到返回-1，$O(n)$
• $str.rfind(sub[,start[,end])->int$：从右往左查找$sub$第一次出现的索引，找不到返回-1，$O(n)$
• $str.index(sub[,start[,end])->int$：从左往右查找$sub$第一次出现的索引，找不到抛异常，$O(n)$
• $str.rindex(sub[,start[,end])->int$：从右往左查找$sub$第一次出现的索引，找不到抛异常，$O(n)$
• $str.count(sub[,start[,end])->int$：在$[start,end)$中统计$sub$出现的次数
• $len()$：返回字符串长度，$O(n)$
• $str.startswith(sub[,start[,end])->bool$：在$[start,end)$中的字符串是否以$sub$开头
• $str.endswith(sub[,start[,end])->bool$：在$[start,end)$中的字符串是否以$sub$结尾

8. 字符串格式化

• $format()原型$：$format(\ast args,\ast \ast kwargs)->str$
• $args$是可变位置参数，是一个元组
• $kwargs$是可变关键字参数，是一个字典

	'{0} {2}'.format(1,2,['a']) # 1 ['a']
    '{1} {1} {2[0]} {3[2]}'.format(1,2,['a'],'abc') # 2 2 a c
    'i am {}'.format(20) # i am 20
    '{} {server} {} {}'.format('2020-9-12','127.0.0.1',8888, server='web server') # 2020-9-12 web server 127.0.0.1 8888

五、bytes和bytearray

1. 性质

• 字符串是字符组成的有序序列，字符可用编码理解
• $bytes$是字节组成的 有序的 不可变 的序列
• $bytearray$是字节组成的 有序的 可变 的序列

2. bytes与字符串相互转换

	b1 = 'abc'.encode(encoding='gbk') # 默认使用utf-8编码，得到bytes： b'abc'
    str1 = b1.decode(encoding='gbk') # 默认使用utf-8解码，得到字符串 'abc'
    b2 = bytes([97,98]) # b'ab'

3. 方法

字符串中的大部分方法都可用

六、集合

1. 性质

• 可变的、无序的、不重复的元素的集合
• 和$dict$一样，底层使用$hash$值作为$key$，时间复杂度为$O(1)$，查询时间与数据规模无关

2. 初始化

	s1 = set() # 空集合
	d = {
    
    } # 空字典
    s2 = set(range(1,10))
    s3 = {
    
    2,3,4,2,'a','a'} # 无序，不重，{'a', 2, 3, 4}
    s4 = {
    
    1,'abc', (1,2,), b'abc', None, True} # 不可包含list、bytearray、dict、set等可变数据类型

3. 方法

• $add(value)$：一次添加一个元素
• $update(iterable1[,iterable2...])$：将多个可迭代对象合并到集合
• $intersection(\ast other)$ 和 & ： 返回多个集合的交集
• $intersection\_update(\ast others)$ 和 &=：获取多个集合的交集，并就地修改
• $difference(\ast other)$ 和 $-$ ： 返回多个集合的差集
• $difference\_update(\ast others)$ 和 $-=$ ：获取多个集合的差集，并就地修改
• $remove(value)$：根据值删除，不存在则抛 $keyerror$
• $discard(value)$：根据值删除，不存在不抛异常
• $pop()$：随机删除一个元素，空集则抛 $keyerror$
• $clear()$：将当前集合标记为空，引用计数减1
• $len()$：返回元素个数，$O(n)$
• 成员操作符$in$和$notin$：返回是否在集合中，由于哈希原理，时间复杂度为$O(1)$

七、字典

1. 性质

• 可变的、无序的、$key$不重复的 $k-v$ 集合
• $key$必须是可哈希类型，$value$无要求
• 和$dict$一样，底层使用$hash$值作为$key$，时间复杂度为$O(1)$，查询时间与数据规模无关

2. 初始化

	d1 = {
    
    }
    d2 = dict()
    d3 = {
    
    1:[1,2], 1:'1'} # {1: '1'}
    d4 = dict([(1,'a'), [2,'b'], {
    
    100,'a'}]) # {1: 'a', 2: 'b', 100: 'a'} 或 {1: 'a', 2: 'b', 'a':100}
    d5 = dict(a=1,b=2,c=3) # {'a': 1, 'b': 2, 'c': 3}
    d6 = dict(d5, d = 4, e = 5) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
    d7 = dict.fromkeys(range(2), [10,11]) # {0: [10, 11], 1: [10, 11]}
    d7[0][0] = 100 # d7为 {0: [100, 11], 1: [100, 11]}

3. 常用方法

• $get(key[,defalut])$：根据$key$返回$value$，若不存在则返回$default$，$default$默认为$None$
• $update()$：使用另一个字典更新本字典，$key$存在则更新，不存在则添加，就地修改

	d = dict(a=1,b=2,c=3) # {'a': 1, 'b': 2, 'c': 3}
    d.update(b = 300) # {'a': 1, 'b': 300, 'c': 3}
    d.update({
    
    'a':100, 'z':200}) # {'a': 100, 'b': 300, 'c': 3, 'z': 200}
    d.update([ ('a', 111), ('z',1000) ]) # {'a': 111, 'b': 300, 'c': 3, 'z': 1000}

• $pop(key[,default])$ : 根据$key$返回$value$并删除元素，不存在则返回缺省值 或 抛异常
• $popitem()$：随机返回一个元素并删除，无法删除时抛异常
• $del$：删除一个元素
• $keys()$：返回字典的键，用可迭代对象封装，类set对象
• $values()$：返回字典的值，用可迭代对象封装
• $items()$：返回字典的元素，用可迭代对象封装，类set对象

d = dict(a=1,b=2,c=3) # {'a': 1, 'b': 2, 'c': 3}
del d['a']

4. 遍历

	d = dict(a=1,b=2,c=3) # {'a': 1, 'b': 2, 'c': 3}
    for key in d.keys():
        print(key)
        print(d.get(key))
        
    for value in d.values():
        print(value)
    
    for item in d.items():
        print(item)
    
    for k, v in d.items():
        print(k, v)

注意以下错误写法：

• 增

    for k in d.keys():
        d['d'] = 1

• 删

    for k in d.keys():
        d.pop(k)

总之在遍历时，遍历的是 视图对象，字典元素个数不可变化