list_tuple_dic_titerator


from __future__ import print_function

列表list

list是有序的，可重复，元素类型可以不一样，通过下标来访问不同位置的元素


aList = [1, 2, 3, 4, 5, 6]
print(aList)
print(aList[::1])
print(aList[2:4])       # 下标[2:4),不包括4    结果: [3, 4]
print(aList[::-1])      # 逆序
print(aList[-1 : -len(aList)-1 : -1])       # 等同于 aList[::-1]   # -len(aList)-1 为 -7
print(aList[-1 : -3 : -1])      # 结果: [6, 5]

列表排序


x
l = ['Hello', 'apple', 'Zoom']

# 排序
l.sort()
print(l)

# 排序，忽略大小写
l.sort(key=str.lower)
print(l)

列表合并


x
A = [1, 2, 3]
B = [4, 5, 6]

C = [*A, *B]
print(C)  ## [1, 2, 3, 4, 5, 6]

列表复制

Python 中赋值语句不复制对象，而是在目标和对象之间创建绑定 (bindings) 关系。来源。

Python 中，列表的复制有两种方式：浅拷贝和深拷贝。它们之间的区别在于，新对象的元素是否与原对象里的元素共享内存。

浅拷贝，指的是重新分配一块内存，创建一个新的对象，但新对象里面的元素是原对象中各个子对象的引用。

深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。

直接赋值

原列表和新列表指向同一个列表对象，id相同。


a = [0, [1, 2, 3], [4, 5, 6]]

b = a

浅拷贝

浅拷贝会分配一个新的内存空间，创建一个新的对象，id互不相同。列表元素需要分可变对象和不可变对象讨论。

不可变对象（数值型、字符串型、元组）：根据不可变对象特性（值改变时，换地址），虽浅拷贝后两对象指向同一地址，但任一对象（如b）改变时，原来内存的值不变，而b指向新的内存地址，故互相不影响。即不可变对象的浅拷贝互不影响。

可变对象（列表、字典、集合）：根据可变对象特点（地址不变，值变化），可变对象改变时，指向同一地址的新对象、原对象都改变。


a = [0, [1, 2, 3], [4, 5, 6]]

b = a[:]         # 使用切片
d = list(a)      # 工厂函数list()
c = a.copy()     # copy()函数

import copy
d = copy.copy(a) # copy模块

e = []
e = e.extend(a)  # 列表方法extend

f = [i for i in a]   # 列表推导式

深拷贝

深拷贝是完全开辟新空间，将原对象中的所有元素通过递归的方式进行拷贝到新对象中。


a = [0, [1, 2, 3], [4, 5, 6]]

import copy
b = copy.deepcopy(a)

参考:

https://zhuanlan.zhihu.com/p/258097244 https://pythonjishu.com/vbrbsayfccmqakg/ https://www.zadmei.com/rhzpzsdf.html

元组tuple

tuple元组类型与list类似，但是tuple的元素不能修改


aTuple = ('robots', 77, 93, 'try')
print(aTuple)

字典dict

字典与列表最大的区别就是字典强调的是“键值对”，key与value一一对应。


aDict = {'host': 'earth', 'port': '80'}
print(aDict)
print(aDict.keys())
print(aDict['host'])
aDict['host'] = 'eeeee'     # 增加元素
print(aDict['host'])

判断dict中key是否存在


print(aDict.has_key('host'))  # python2
print('host' in aDict.keys())  # 不推荐
print('host' in aDict)

for key in aDict:
    print(key, aDict[key])

字典合并


a = {'host': 'earth', 'port': '80'}
b = {'user': 'root', 'passwd': '123456'}

【方法一】借助dict(d1.items() + d2.items())的方法仅Python2


c = dict(a.items() + b.items())

备注:

d1.items()获取字典的键值对的列表
d1.items() + d2.items()拼成一个新的列表
dict(d1.items()+d2.items())将合并成的列表转变成新的字典

【方法二】借助字典的update()方法


d = {}
d.update(a)
d.update(b)

【方法三】借助字典的dict(d1, **d2)方法


e = dict(a, **b)

【方法四】使用联合运算符方法 (Python 3.9)


f = a|b

collections.Counter

用于统计某序列中每个元素出现的次数，以键值对的方式存在字典中。但类型其实是Counter。


# 循环实现
ver_list = [15, 6, 3, 7, 4, 9, 13]
ver_dict = {}
for i, v in enumerate(ver_list):
    ver_dict[i] = v
print(ver_dict)     # {0: 15, 1: 6, 2: 3, 3: 7, 4: 4, 5: 9, 6: 13}

# collections.Counter实现
from collections import Counter

ver_dict_sort = Counter(ver_dict).most_common() # 对 ver_dict 按照dict的value从大到小排序，返回一个列表
print(ver_dict_sort)        # [(0, 15), (6, 13), (5, 9), (3, 7), (1, 6), (4, 4), (2, 3)]

for ver in ver_dict_sort[::-1]:
    print(ver, end=' ')
print()

多维列表


#创建多维列表
A = [[None] * 2] * 3
A[0][0] = 5
print(A)
#[[5, None], [5, None], [5, None]]

#创建多维列表
A = [None] * 3
for i in range(3):
    A[i] = [None] * 2
A[0][0] = 5
print(A)
#[[5, None], [None, None], [None, None]]

#创建多维列表
w, h = 2, 3
A = [[None] * w for i in range(h)]
A[0][0] = 5
print(A)
#[[5, None], [None, None], [None, None]]

#创建多维列表 2x3x4
A = [None] * 4
for i in range(4):
    A[i] = [None] * 3
    for j in range(3):
        A[i][j] = [None] * 2
print(A)
#[[[None, None], [None, None], [None, None]],
#[[None, None], [None, None], [None, None]],
#[[None, None], [None, None], [None, None]],
#[[None, None], [None, None], [None, None]]]

多层嵌套列表


def flatten(sequence):
    for item in sequence:
        if isinstance(item, list):
            for subitem in flatten(item):
                yield subitem
        else:
            yield item
a = [1, 'a', ['b', ['c'], [ ], [3, 4]]]
for x in flatten(a):
    print(x, end=',')
print()
# 1,a,b,c,3,4,

集合set

set集合与list也类似，但是集合中的元素是无序的，且会自动除去重复元素，通常是用来进行去重


{"student", "teacher", 1, 2, 3}

生成器/迭代器

迭代器 iterator

在Python中，我们把所有可以迭代的对象统称为可迭代对象Iterable。

可迭代对象 ：实现了 __iter__() 方法的对象是可迭代的，__iter__() 返回一个迭代器；
迭代器：实现了 __iter__() 和 __next__() 方法的对象，__next__() 返回迭代过程的下一个元素；
列表、元组、字符串、字典等对象只实现了 __iter__() 方法，所以它们是可迭代对象，而不是迭代器；
内建函数iter(iterable) -> iterator 用于访问 __iter__() ，可获取这些可迭代对象的迭代器；
__iter__() 返回的对象实现 或间接实现 了 __next__() 方法就可以正常迭代；
Python2中写做 next() , Python3内建函数next() 用于访问 __next__() 。

判断一个对象是否为可迭代对象或迭代器：


from collections.abc import Iterable
from collections.abc import Iterator

class A:
    def __iter__(self):
        return B()

class B():
    def __iter__(self):
        pass
    def __next__(self):
        pass

print('A() is Iterable: ', isinstance(A(), Iterable))  # True
print('A() is Iterator: ', isinstance(A(), Iterator))  # False
print('B() is Iterable: ', isinstance(B(), Iterable))  # True
print('B() is Iterator: ', isinstance(B(), Iterator))  # True

使用迭代器实现斐波那契数列：


class Fibs:
    def __init__(self):
        self.a = 0
        self.b = 1
    # def next(self):    # Python 2
    def __next__(self):  # Python 3
        self.a, self.b = self.b, self.a + self.b
        return self.a
    def __iter__(self):
        return self

fibs = Fibs()
for f in fibs:
    if f <= 1000:
        print(f)
    else:
        break

生成器 generator

如果一个函数体内部使用yield关键字，这个函数就称为生成器函数，生成器函数调用时产生的对象就是生成器。生成器是一个特殊的迭代器，在调用该生成器函数时，Python会自动在其内部添加 __iter__() 方法和 __next__() 方法。把生成器传给 next() 函数时，生成器函数会向前继续执行，执行到函数定义体中的下一个 yield 语句时，返回产出的值，并在函数定义体的当前位置暂停，下一次通过next()方法执行生成器时，又从上一次暂停位置继续向下……，最终，函数内的所有yield都执行完，如果继续通过yield调用生成器，则会抛出StopIteration 异常——这一点与迭代器协议一致。

使用生成器实现斐波那契数列：


def feb(x):
    a = 0
    b = 1
    for i in range(x):
        a, b = a + b, a
        yield a

for i in feb(10):
    print i,

使用普通循环实现斐波那契数列：


def feb(x):
    a = 0
    b = 1
    for i in range(x):
        a, b = a + b, a
        print a,

feb(10)

推导式

列表推导式

List comprehensions


# 书写形式:
[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 条件]
[表达式 for 变量 in 列表 if 条件 for 变量2 in 列表2 if 条件2]

li = [1,2,3,4,5,6,7,8,9]

print [x**2 for x in li]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

print [x**2 for x in li if x > 5]
[36, 49, 64, 81]

print [(x, y) for x in range(3) for y in range(4)]
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]

print sum([x**2 for x in li])

# 展开嵌套列表
mainList = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print [num for subList in mainList for num in subList]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 矩阵转置
matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
print [[row[i] for row in matrix]for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

字典推导式

Dictionary Comprehension

字典推导式的基本格式，和列表推导式相似，只是把 [] 改成了 {}


{ key_expr: value_expr for_loop_expression if condition }

集合推导式

Set comprehensions

集合推导式跟列表推导式也是类似的。唯一的区别在于它使用大括号{}，组成元素也只要一个。


{ expr for_loop_expression if condition }

生成器推导式

Generator Comprehensions

生成器推导式跟列表推导式，非常的像，只是把 [] 换成了 ()

列表推导式：生成的是新的列表
生成器推导式：生成的是一个生成器


(x**2 for x in li if x > 5)

# 可以直接在括号内使用，如：
sum((x**2 for x in li if x > 5))
sum(x**2 for x in li if x > 5)

其他函数

product

可以通过内置的 product() 函数避免 Python 中的嵌套循环。 product 用于求多个可迭代对象的笛卡尔积(Cartesian Product)，它跟嵌套的 for 循环等价.即: product(A, B) 和 ((x,y) for x in A for y in B) 和嵌套的 for 循环结果一样。

2层循环示例：


A = [1, 2, 3]
B = [4, 5, 6]

# 嵌套的 for 循环
for x in A:
    for y in B:
        print((x,y))

# 生成器推导式
C = (((x, y) for x in A for y in B))
for i in C:
    print(i)

# itertools 模块中的 product() 函数
import itertools
cp = itertools.product(A, B)
for i in cp:
    print(i)

3层循环示例：


A = [1,2]
B = [4,5]
C = [6,7]

# 嵌套的 for 循环
for x in A:
    for y in B:
        for z in C:
            print((x,y,z))

# 生成器推导式
D = (((x, y, z) for x in A for y in B for z in C))
for i in D:
    print(i)

# itertools 模块中的 product() 函数
cp = itertools.product([1,2],[4,5],[6,7])
for i in cp:
    print(i)

product改造


# itertools.product的实现逻辑大概如下：
def product(*args, repeat=1):
    pools = [tuple(pool) for pool in args] * repeat
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)

p = product([5], [3], [1, 2, 4], [2, 6], [7], [2, 4, 6, 8], [1, 4, 8, 9], [1, 2, 4, 9], [2, 4, 8])

# 改成接受一个二维列表
def product(args, repeat=1):
    pools = [tuple(pool) for pool in args] * repeat
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)

p = product([[5], [3], [1, 2, 4], [2, 6], [7], [2, 4, 6, 8], [1, 4, 8, 9], [1, 2, 4, 9], [2, 4, 8]])


def product(args, repeat=1):
    pools = [pool for pool in args] * repeat
    #print(pools)
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
##    for prod in result:
##        if len(set(prod)) == 9:
##            yield prod
    return result

def product2(args, repeat=1):
    pools = [pool for pool in args] * repeat
    #print(pools)
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield prod

p = [[], [], [], [], [], [], [], [], []]
for index, row in enumerate(sudo_ku_data):
    p[index] = product(row)

for i in p[8]:
    # print(i)
    pass

#for i in product2(p):
#    print(i)
#    pass

转换格式


# {'A': {'a': 1, 'b': 2}, 'C': {'c': 3, 'd': 4}} ->
# {'A': [{'k': 'a', 'v': 1}, {'k': 'b', 'v': 2}], 'C': [{'k': 'c', 'v': 3}, {'k': 'd', 'v': 4}]}

tmp_dict = {"A": {"a": 1, "b": 2}, "C": {"c": 3, "d": 4},}
print(tmp_dict)
data_dict_new = {}

for i in tmp_dict:
    data_dict_new[i] = []
    for j in tmp_dict[i]:
        data_dict_new[i].append({'k': j, 'v': tmp_dict[i][j]})
print(data_dict_new)

# {'a': 1, 'b': 2} ->
# [{'k': 'a', 'v': 1}, {'k': 'b', 'v': 2}]

tmp_dict = {"a": 1, "b": 2}
print(tmp_dict)
data_list_new = []

for i in tmp_dict:
    data_list_new.append({'k': i, 'v': tmp_dict[i]})
print(data_list_new)

map

map 函数会将函数应用于可迭代对象的每个元素


# map(func, *iterables) --> map object

l = [1, 2, 3, 4, 5, 6, 7]

def func(x):
    return x ** 2

m = map(func, xx)
print(list(m))  # [1, 4, 9, 16, 25, 36, 49]

reduce

将一个函数应用到一个可迭代对象中，并为其执行累积操作


from functools import reduce
# reduce(function, sequence[, initial]) -> value

l = [1, 2, 3, 4, 5]

def func(x, y):
    return x + y

r = reduce(func, l)  # ((((1+2)+3)+4)+5)
print(r)  # 15