[Python]常用数据存储结构.md

※ 以下代码运行于Python3

因工作需要，开始接触python语言，这大概是我用过最优雅的语言，非常的简洁。js再懒咱还会使用var，python甚至连声明的数据类型都省略了。
除了基本基本语法外，列表、字典等数据结构是工作中用的最为频繁的部分，所以在学习的时候整理了常用的函数与技巧来便于自己以后查询，若有新的技巧也会在后续更新上来。

序列切片Sequence

序列并不是一种明确的类型而是一种种类，列表、元组、字符串、range都属于序列。本质是浅拷贝指定的元素组成新的容器，各自具备的切片功能形式上有所差异。
序列的特征就是可以切片，如下

seq = [1,2,3,4,5,6]

seq[:]    # 从头到尾
# [1,2,3,4,5,6]

seq[0:4]    # 从0到第4位（不包括第4位）
# [1,2,3,4]

seq[0:-1]    # 从0到倒数第1位
# [1,2,3,4,5]

seq[0:-1:2]    # 从0到倒数第1位，步进为2
# [1,3,5]

seq2 = seq[::-1]    # 翻转序列

列表List

关键字为list，列表是一种可变的有序序列，就像字符串被定义为引号之间的字符一样，列表也是通过在方括号之间[]的值定义的。
创建

empty_list = []    # 空列表
sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

※（假设以下操作都是单独运行的，sea_creatures没有元素变化）
添加：添加元素至末尾

sea_creatures .append('dolphin')

插入：在某个位置插入一个元素

sea_creatures .insert(0, 'dolphin')

调用（或赋值）：通过索引取出元素，类似地有切片返回多个元素

sea_creatures[0]    # 'shark'
sea_creatures[-1]    # 'anemone'，-1表示倒数第一个，类似有-2、-3

拼接：将两个列表拼接为一个数组

oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']
sea_creatures.extend(oceans )    
# ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

数学运算符 +、+=、、=（使用+=或*=会多一步赋值操作，但会改变sea_creatures列表）

print(sea_creatures + oceans)
# ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']
print(sea_creatures * 2)
# ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

删除：删除指定元素

del sea_creatures[0]
# 或
sea_creatures.remove('tiger')    # 若'tiger'不存在则会报错（若有多个tiger则会删除序号小的那一个）
# 或
sea_creatures.pop(0)    # 返回指定位置元素并移除该元素，若不指定index默认移除最后一个元素

查找：

sea_creatures.index('tiger')    # 返回指定元素的index，若找不到该元素会报错
# 或者
'tiger' in sea_creatures    # 查找指定元素是否在列表中，返回布尔值

浅拷贝：会返回一个与sea_creatures相同元素的数组

sea_creatures.copy()

长度

len(sea_creatures)    # 5

遍历

for creature in sea_creatures:
    print(creature)
# 或者
for i in range(len(sea_creatures)):
    print(creature)

清空

namelist.clear()

反转：将列表中元素顺序翻转

list(reversed(sea_creatures))
# 或
sea_creatures.reverse()
# 或
sea_creatures = sea_creatures[::-1]

合并为字符串：将列表里的元素合并为字符串

''.join(map(str,sea_creatures))    # map(str,sea_creatures)表示对sea_creatures中的每一个元素进行str(element)操作
# 或
''.join(str(i) for i in arr)    # 这里使用了list comprehension，是一种简便用法，效果与上述相同    

sort()排序

# sort(key=None, reverse=False)
# key - 指向一个函数，这个函数只有一个传参，列表list中的每一个元素都会被作为参数传入这个函数，然后通过函数的返回值大小来排序
# reverse - False表示升序，反之降序，默认为False
# 使用list.sort()返回值为None，因为sort()函数直接改变了list本身，如果不希望改动原数据最好使用sorted()
# 例如按照元素原本大小排序
num_list = [5,2,48,6,23]
def sort_rule(num):
    return num
num_list.sort(key = sort_rule)
print(num_list)    # [2, 5, 6, 23, 48]

sorted()排序

# sorted(iterable, *, key=None, reverse=False)
# iterable - 可迭代的容器，一般是list、dictionary等
# 返回值是一个已经排好序的列表，所以这个函数不会改动原列表；可以进行多次排序例如先按年龄来再按名字排。
# 例如：使用sorted()先对分数排序，再对年龄排序，这里用到了operator库的两个函数。
from operator import itemgetter, attrgetter
student_tuples = [
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
]
student_objects = [
    Student('john', 'A', 15),
    Student('jane', 'B', 12),
    Student('dave', 'B', 10),
]
class Student:
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age
    def __repr__(self):
        return repr((self.name, self.grade, self.age))

sorted(student_tuples, key=itemgetter(1,2))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

sorted(student_objects, key=attrgetter('grade', 'age'))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

列表解析（List Comprehension）
List Comprehension是对for循环的一种简洁用法，其结构形如 x for x in iterable

# 例如
shark_letters = [letter for letter in 'shark']

# 等价于
shark_letters = []
for letter in 'shark':
    shark_letters.append(letter)    # ['s', 'h', 'a', 'r', 'k']

# 可以后接if语句来表示筛选：
shark_letters = [letter for letter in 'shark' if letter != 'a']

# 还可以后接for循环：
my_list = [x * y for x in [20, 40, 60] for y in [2, 4, 6]]

# 等价于
my_list = []
for x in [20, 40, 60]:
    for y in [2, 4, 6]:
        my_list.append(x * y)

元组Tuple

关键字为tuple，元组是一种不可变的有序元素序列，不可变这点类似字符串，元素的值一旦定义后不能再改变。
创建

empty_tuple2 = ()    # 空元组
one_tuple = ('just one', )    # 一个元素的元组
student1 = ('zhangsan', 'Math', 22, ['Hunan', 'Changsha'])
student2 = ('lisi', 'Machine', 21, ['Guangdong', 'Guangzhou'])

类似于list，tuple有取值和数学运算符（没有+=和*=）

student_name = student[0]    # 'zhangsan'
print(student1 +student2 )
# ('zhangsan', 'Math', 22, ['Hunan', 'Changsha'], 'lisi', 'Machine', 21, ['Guangdong', 'Guangzhou'])
print(student1 * 2)
# ['zhangsan', 'Math', 22, ['Hunan', 'Changsha'], 'lisi', 'zhangsan', 'Math', 22, ['Hunan', 'Changsha'], 'lisi']

tuple长度和遍历的使用同列表没有差别

字符串String

字符串关键字为str，是由一个或多个字符（字母，数字，符号）组成的不可改变的序列，可以是常量也可以是变量。注意python中不区分char类型.
创建

x1 = 'hello'
x2 = 'hello'

判断值是否相等

x1 == x2    # True

内存地址是否相等

x1 is x2    # False

查找

'x' in x1    # False
x1.find('llo')     # 2，返回子串第一次出现的位置，若子串不存在返回-1

取出单个字符串

x1[0]    # 'h'

合并：将两个字符串表示通过指定分隔符合并

x3 = '|'.join([x1, x2])    # 'hello hello'
x3 = x1 + x2 # 前提是x1和x2都是字符串，否则会报错

拆分：将字符串以指定分隔符拆分，返回拆分后的列表

splist_list = x3.split('|')

倒序

''.join(reversed('hello'))
# 或
s = 'hello'[::-1]

统计子串出现次数

x.count('l')

格式化

'my name is {0}'.format('hyjz')

以及一些快速判断类型的方法：

str.isalnum()    # 是否全为字母或数字
str.isalpha()    # 是否全为字母
str.islower()    # 小写
str.isnumeric()    # 数字
str.isspace()    # 空格
str.istitle()    # 是否是标题化的
str.isupper()    # 大写

字典Dictionary

字典由键值对组成，键值唯一；与列表不同，键值对存储时是无序的.
创建

detaildict = {}

修改或添加

detaildict['fire'] = 'a fire'
detaildict['water'] = 'a water'
detaildict['thunder'] = 'a thunder'
detaildict['noname'] = 'noname'

删除键值对

del detaildict['noname']    # 若该键值不存在则会报错

遍历

# 遍历键值对
for magic, detail in detaildict.items():
    print(magic, detail)

# 遍历键
for magic in detaildict:
    print(magic)
# 等价于
for magic in detaildict.keys():
    print(magic)

# 其它常用遍历
for detail in detaildict.values()    # 按值遍历
    print(detail)
for magic in iter(detaildict)    # 使用迭代器遍历
    print(detaildict[magic])

是否包含键值

'fire' in detaildict    # True

根据值找键

list = [k for k,v in d.items() if v == value]
# {'a':'001', 'b':'002'} => ['a']

集合Set

集合是一种无序元素不重复的容器；集合间可以计算联合、交集、差集、对称差集等。
创建

set1 = set(['a', 'b', 'c', 'd', 'e'])
set2 = set(['a', 'b', 'x', 'y', 'z'])

添加

set1.add('f')

添加多项，重复的元素不会被加入

set1.update(['f', 'g'])

移除

set1.discard('a')
set1.remove('a')    # 若元素不存在会报错

集合运算

set_a = set1 | set2 # 并集
set_b = set1 & set2 # 交集
set_c = set1 - set2 # 差集（项在set1中且不再set2中）
set_d = set1 ^ set2 # 对称差集（项在set1或set2中，且不会同时出现在两者中）

浅拷贝

set3 = set1.copy()

是否是父子集合

set1.issubset(set3) # set1 <= set3，即是否set1所有元素都在set3中
set1.issuperset(set3) # set1 >= set3，即是否set3所有元素都在set1中