[深入python]大肚能容天下事——python元组和列表

几乎所有的编程语言都有一项核心的功能，就是提供可以存储大量数据的容器，比如java的map，list，数组等，
而python最核心的几个容器就是元组，列表和字典，在结束这两章的内容后，会附上一个使用python基础容器实现的NoSql数据库，
以便大家加强理解python的基础容器，也可以顺便学习基本的NoSql知识

"""
    预先需要知道的一些概念
    1）所有容器都会涉及【原容器操作】和【返回副本操作】，比如列表的append操作就是在原容器上进行拼接操作
       而列表的copy操作则是不改变原容器，返回一个副本，像字符串（字符串可以当做一个字符容器）由于是不可变
       对象，无法在原容器上进行操作，所以要获得新字符串，需要将原字符串的副本和新增字符串进行拼接，比如
       str_1 = '123',str_1 = str_1 + '456'，其实是str_1的副本字符串'123'和’456‘重新拼接成'123456',
       在重新赋值给str_1
    2）其实一般也有规律，是否返回副本，先要看对象本身是否可以修改，不可以修改的一般会返回副本，
       可以修改的，也要看情况，如果为了性能考虑，比如处理大数据，可能就不反回副本了

    列表
    1）初始化
    2）增，尾部新增，合并，插入，相乘，赋值
    3）删，改
    4）查，索引查询
    5）切片，切片功能就可以完成增，删，改，查，复制等操作
    5）高级操作，查找，反向排列，排序，统计，长度，最大，最小，复制，成员判断，栈操作
    6）列表推导式
    7）拆包

    元组，类似数组，长度固定，但是值不可以改变，数组可以
    1）初始化
    2）查
    3）转换
    4）遍历

    python实现的NoSql数据库系列

    元组在用法上和列表差不多，通常使用列表可以完成大部分的应用，这里就不在赘述
"""

# 相乘初始化，赋值初始化，函数初始化，列表推导式初始化
list_demo = [None] * 10
print(list_demo)
list_demo = [1, 2, 3, 4, 5, 'demo', ('d', 'e', 'm', 'o'), [6, 7, 8]]
print(list_demo)
list_demo = list('123456')
print(list_demo)
list_demo = [x for x in range(10)]
print(list_demo)

# 增，尾部新增append,extend和insert特别操作，append和insert会把新增对象当做一个对象
# extend则会拆分对象为多个对象在重新拼接，另外这三个操作都是属于原对象操作
list_demo = [1, 2, 3]
list_demo.append([4, 5])
print(list_demo)
list_demo.extend([6, 7])
print(list_demo)
list_demo.insert(len(list_demo), [8, 9])
print(list_demo)

# 合并，效果和extend相似
list_demo_merge = [1, 2, 3]
list_demo_merge += [3, 4, 5]
print(list_demo_merge)

# 插入
list_demo_ins = [1, 2, 3]
list_demo_ins.insert(1, [4, 5, 6])
print(list_demo_ins)

# 相乘，把列表进行复制多次的操作
list_demo_mul = [1, 2, 3]
print(list_demo_mul * 3)

# 赋值
list_demo[1] = '赋值'
print(list_demo)

# 修改和删除，删除可以用关键字del或者是方法remove
list_demo_upd = [1, 2, 3]
list_demo_upd[0] = 10
print(list_demo_upd)
del list_demo_upd[0]
print(list_demo_upd)
list_demo_upd.remove(list_demo_upd[0])
list_demo_upd.remove(3)
print(list_demo_upd)

# 查，索引查询，使用下标即可
list_demo_idx = [1, 3, 4, 7, 9]
print(list_demo_idx[1])

# 切片，切片功能就可以完成增，删，改，查，复制等操作
# 切片查询，单个或者范围查询，切片支持负数索引
list_demo_slice = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list_demo_slice[0:1])
print(list_demo_slice[0:4])
print(list_demo_slice[0:-5])
# 切片新增
list_demo_slice[len(list_demo_slice):] = [10, 11, 12]
print(list_demo_slice)
# 切片新增插入
list_demo_slice[3:3] = ['3-1', '3-2', '3-3']
print(list_demo_slice)
# 切片删除
list_demo_slice[3:6] = []
print(list_demo_slice)
# 切片修改
list_demo_slice[3:6] = ['four', 'five', 'six']
print(list_demo_slice)
# 切片复制
list_demo_copy = list_demo_slice[:]
print(list_demo_copy)
# 切片步长，第三个参数是步长参数，支持负数步长
print(list_demo_slice[0:10:2])
print(list_demo_slice[10:0:-2])

# 查找，反向排列，排序，统计，长度，最大，最小，复制，成员判断，栈操作
list_demo_adv = list_demo_slice[:]
print(list_demo_adv.index(1))
list_demo_adv.reverse()
print(list_demo_adv)
# 这里要注意了，反向排列操作是原容器操作，如果不想影响原容器，需要一个副本，再对副本操作
list_demo_adv_copy = list_demo_adv[:]
list_demo_adv_copy.reverse()
print(list_demo_adv_copy)
# 或者使用reversed，仅仅用于展示
print(list(reversed(list_demo_adv_copy)))
print(list_demo_adv_copy)
# 排序和反向排列都有一样需要注意的问题，就是sort是原容器操作，sorted是仅仅展示
# 长度，最大，最小，复制，成员判断属于通过操作，不再赘述
# 栈操作,pop,push使用append代替操作
list_demo_stack = [x for x in range(10)]
print(list_demo_stack.pop())
print(list_demo_stack)

python里有自己比较独到的语法，比如列表推导和生成器表达式就是其中之一，熟练使用这个强大的功能，可以让自己的语法更加精炼简洁，另外列表推导和lambda表达式也有异曲同工之妙

# 先看一个例子，把一个列表里的大写字母全部转为小写，一般情况下，我们这么写就能完成任务
list_demo = ['A', 'b', 'C', 'd', 'E']
list_demo_copy = list_demo.copy()
for idx in range(len(list_demo)):
    list_demo[idx] = list_demo[idx].lower()
print(list_demo)

# 采用这种方法就需要一个索引遍历，并重新赋值，如果采用列表推导式，那么就简洁多了
list_demo_copy = [val.lower() for val in list_demo_copy]
print(list_demo_copy)

# 使用列表推导来过滤元素或映射元素，先看一下filter和map方式
# 现在过滤掉含有b和e的元素，并将剩下的元素转成unocode码的列表
list_demo_filter = list(filter(lambda val: val not in ('b', 'e'), list_demo))
print(list_demo_filter)
list_demo_map = list(map(ord, list_demo_filter))
print(list_demo_map)

# 使用列表推导式的方案
list_demo_filter_map = [ord(val) for val in list_demo if val not in ('b', 'e')]
print(list_demo_filter_map)

# 这么看来是不是简洁很多，但是列表推导式也不能滥用，一般用来创建符合条件的新列表
# 使用列表计算的笛卡尔积
name = ['小明', '小红', '小刚']
age = [10, 9, 13]
name_age = [(name_val, age_val) for name_val in name for age_val in age]
print(name_age)

再看生成器表达式，语法和列表差不多，但是把方括号换成了圆括号，主要用于创建新列表和元组

# 使用生成器，可以逐个产出元素，而不是先建立一个完整的列表，在把这个列表传递到某个构造函数里，
# 可以有效的节省内存，生成器和推导式一样，可以
list_demo_build = list((x for x in range(10) if x % 2 == 0))
print(list_demo_build)

拆包

# 拆包，将序列的元素分配给相应的变量，列表和元组类似
param_1, param_2, param_3 = list([1, 2, 3])
print(param_1, param_2, param_3)

python实现的NoSql数据库系列

python实现的NoSql数据库系列