python入门：列表、元组、字典及集合类型

http://blog.csdn.net/pipisorry/article/details/39234557

这篇文章是python基本数据结构的高级教程，一般的用法请自行参考python入门教程

python入门教程

基础

变量及其作用域

[python变量及其作用域]

运算符

python中运算符‘is’,'is not'和‘==’,’!=‘的区别
is，is not是地址比较
==，!= 是值比较

值和地址的比较

常量的地址是不变的：

k = -1
k == -1Truek is -1True

列表就不是常量了

a = [123.4, 234.4]b = [123.4, 234.4]print(a == b)True
print(a is b)
False

学习资源

[慕课网Python教程]

[简明Python教程]

[Python基本语法[二]，python入门到精通[四]]

[python有哪些好的学习资料或者博客？]

[[译]学习Python编程的19个资源]

[为什么Python中没有Switch/Case语句?]

[StarterLearningPython]

[Python 初学者的最佳学习资源]

[我是如何开始学Python的]

[学习Python的三种境界]lz感觉自己到了境界2，哈哈！！

python高级基础：python语法糖

if else表达式

fpython没有三目运算符，我挺苦恼的，比如把两个整数较大的那个复制给一个变量，有三目运算符的语言会这样写：
c = a > b ? a : b
后来发现Python的if语句可以写成一行完成上述功能：
c = a if a > b else b

执行字符串表达式eval

eval执行一个字符串表达式，并返回表达式的值。
print eval("1 + 1")
>> 2
再来个复杂点的：
def init():
    return 1
def func(num):
    return 2
action = {"num": init, "func": func}
expression = 'func(num)'
print eval(expression, action)
>> 2

python for循环高级用法

for/else我们经常使用for循环来查找元素，有两个场景会使循环停下来：
元素被找到，触发break。
循环结束。
但是我们并不知道是哪个原因导致循环结束，通常是设置一个标记，元素被找到，改变标记的值。for/else可以很优雅地解决这个问题：
for i in range(10):
if i > 10:
    print i
else:
    print("can't find result")

在分支语句中使用else子句在一些常见的编程语言中的用法基本相同，类似于提供了一条默认的执行路径，配合if等条件判断语句使用，相比其它的编程语言(c#, java, js等)在python中，else有一些特殊的用法，配合for, while等循环语句使用，甚至还能配合异常处理try except语句进行使用，能够让我们的代码更加的简洁。

配合for/while循环语句使用
在for循环语句的后面紧接着else子句，在循环正常结束的时候（非return或者break等提前退出的情况下），else子句的逻辑就会被执行到。先来看一个例子：
def print_prime(n):
    for i in xrange(2, n):
        # found = True
        for j in xrange(2, i):
            if i % j == 0:
                 # found = False 
                break
        else:
            print "{} it's a prime number".format(i)
        # if found:
                  # print "{} it's a prime number".format(i)
print_prime(7)

2 it's a prime number
3 it's a prime number
5 it's a prime number
一个简单打印素数的例子，判断某个数字是否是素数的时候需要遍历比它自己小的整数，任何一个满足整除的情况则判断结束，否则打印这是一个素数的info，有了else的加持，整个例子的逻辑相当的“self-expressive”，如同伪代码一般的好理解而且相比在判断整除的时候设置标志值然后在函数的结尾处判断标志值决定是否打印数字时素数的消息，代码更简洁没有那么多要描述如何做的“过程式”准备工作。
大家可以把例子中的被注释代码运行对比下效果。

[配合 try except错误控制使用]

[善用python的else子句]

python跳出多层循环

1、自定义异常
class getoutofloop(Exception): pass
try:
    for i in range(5):
        for j in range(5):
            for k in range(5):
                if i == j == k == 3:
                    raise getoutofloop()
                else:
                    print i, '----', j, '----', k
except getoutofloop:
    pass
2、封装为函数return
def test():
    for i in range(5):
        for j in range(5):
            for k in range(5):
                if i == j == k == 3:
                    return
                else:
                    print i, '----', j, '----', k
test()
3、for … else … 用法
上面的两种都是只能跳出多层而不能跳出特定层数的循环，接下来的这个正是为了跳出特定层数的循环。
for i in range(5):
    for j in range(5):
        for k in range(5):
            if i == j == k == 3:
                break
            else:
                print i, '----', j, '----', k
        else: continue
        break
    else: continue
    break
else在 while和for 正常循环完成之后执行，和直接写在 while和for 之后没有区别，但是如果用break结束循环之后else就不会执行了。

不过要是有多次跳出不同层的循环的需求，也没辙了。

[How to break out of multiple loops in Python?]

[Breaking out of nested loops [duplicate]]

[break two for loops [duplicate]]

序列迭代

复杂迭代实例

test_dict = {(1, 2): [3, 4, 5]}for e, (w, *f) in test_dict.items():    print(e, w, f)for e, w, *f in test_dict.items():    print(e, w, f)

(1, 2) 3 [4, 5]
(1, 2) [3, 4, 5] []

反向迭代

对于普通的序列（列表），我们可以通过内置的reversed()函数进行反向迭代：
# 通过 reversed 进行反向迭代
for i in reversed(list_example):
    print(i)
# 但无法作用于 集合 和 迭代器
除此以外，还可以通过实现类里的__reversed__方法，将类进行反向迭代：
class Countdown:
    def __init__(self, start):
        self.start = start

    # 正向迭代
    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

    # 反向迭代
    def __reversed__(self):
        n = 1
        while n <= self.start:
            yield n
            n += 1

皮皮Blog

python列表list

python列表的插入、抛出、拆箱操作

list的插入操作是调用函数listinsert来实现的。

该函数的流程如下：

1、解析参数。

2、调用静态函数ins1进行插入操作。

list的插入操作对索引值的处理在函数ins1中进行，相关处理过程如下：

1、将列表的条目数赋值给n；
2、如果索引值小于0，则将索引值增加n；如果仍小于0，则将索引值赋值为0；
3、如果索引值大于n，则将索引值赋值为n。

list中添加元素append

list.append()返回None

如果代码全写在同一行如列表解析中，不想返回None而是返回添加后的列表，可以使用list + [元素]也就是list+list。

一个神奇的示例

def extendList(val, list=[]):
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
 
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3

以上代码的输出为：
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']

许多人会错误的认为 list1 应该等于 [10] 以及 list3 应该等于 ['a']。认为 list 的参数会在 extendList 每次被调用的时候会被设置成它的默认值 []。
尽管如此，实际发生的事情是，新的默认列表仅仅只在函数被定义时创建一次。随后当 extendList 没有被指定的列表参数调用的时候，其使用的是同一个列表。这就是为什么当函数被定义的时候，表达式是用默认参数被计算，而不是它被调用的时候。
因此，list1 和 list3 是操作的相同的列表。而 list2是操作的它创建的独立的列表（通过传递它自己的空列表作为list 参数的值）。
extendList 函数的定义可以做如下修改，但，当没有新的 list 参数被指定的时候，会总是开始一个新列表，这更加可能是一直期望的行为。
def extendList(val, list=None):
    if list is None:
        list = []
    list.append(val)
    return list

抛出操作当条目索引为负数时的处理

list的抛出操作是将指定索引位置的条目从列表中删除并且返回该条目的值。list的抛出操作是调用函数listpop来实现的。

对索引值index的相关处理过程如下：

1、如果index小于0，则将index增加列表本身的条目数；

2、如果index仍小于0或大于列表条目数，则输出错误信息提示索引值超出范围。

源码中将操作位置初始化为-1，所以如果没有指定抛出位置，则默认抛出最后一个条目。

拆箱

>>> a, b, c = [1,2,3]

>>> a, b, c

(1,2,3)

>>> a, b, c = (2*i+1foriinrange(3))

>>> a, b, c

(1,3,5)

>>> a, (b, c), d=[1, (2,3),4]

>>> a

1

>>> b

2

>>> c

3

>>> d

4


扩展的拆箱(Python 3支持)

>>> a, *b, c=[1,2,3,4,5]

>>> a

1

>>> b

[2,3,4]

>>> c

5

python列表查找、索引和统计

List slices with step (a[start:end:step])带步长列表切片

如果从列表开头开始切割，那么忽略 start 位的 0，例如list[:4]
如果一直切到列表尾部，则忽略 end 位的 0，例如list[3:]
切割列表时，即便 start 或者 end 索引跨界也不会有问题
列表切片不会改变原列表。索引都留空时，会生成一份原列表的拷贝
b = a[:]
assert b == a and b is not a # true

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> a[::2][0, 2, 4, 6, 8, 10]

list = ['a', 'b', 'c', 'd', 'e']
print list[10:]
以上代码将输出 []，并且不会导致一个 IndexError。正如人们所期望的，试图访问一个超过列表索引值的成员将导致 IndexError（比如访问以上列表的 list[10]）。尽管如此，试图访问一个列表的以超出列表成员数作为开始索引的切片将不会导致 IndexError，并且将仅仅返回一个空列表。

List slice assignment列表切片赋值

>>> a = [1, 2, 3, 4, 5]>>> a[2:3] = [0, 0]>>> a[1, 2, 0, 0, 4, 5]>>> a[1:1] = [8, 9]>>> a[1, 8, 9, 2, 0, 0, 4, 5]>>> a[1:-1] = []>>> a[1, 5]

python列表取倒数n个数

a = [1,2,3,4,5,6]
print(a[-3:])

切片命名(slice(start, end, step))

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

>>> LASTTHREE = slice(-3,None)

>>> LASTTHREE

slice(-3,None,None)

>>> a[LASTTHREE]

[3,4,5]

python列表查找某个元素

1.

try:    k = l.index(4)    #index查找不存在的元素会出异常except:    k = 3

比2好，不用搜索列表两次，更快。

2.

if 4 not in l:    k = 3else:    k = l.index(4)

3. 如果列表元素很多（如大于10000），应先转换成字典再查找（更耗用内存），速度不只100倍的提升！

fs_dict = dict.fromkeys(fs_list, True)[(u, v) for u, v in fs_dict]

最大和最小元素(heapq.nlargest andheapq.nsmallest)

>>> a = [random.randint(0, 100) for __ in range(100)]>>> heapq.nsmallest(5, a)[3, 3, 5, 6, 8]>>> heapq.nlargest(5, a)[100, 100, 99, 98, 98]

python列表统计

统计某个元素个数count()

list支持count方法

>>> a = ['a', 'b', 'c', 3, '4', '2', '2', 2, 2]
>>> a.count(2)
2
>>> a.count('2')
2
>>> a.count('a')
1
>>> a.count('d')
0

[True,True,False].count(True)
2

当然统计True，False这种可以使用sum方法

>>> l = [1, 2, True, False]
>>> sum(bool(x) for x in l)
3

统计列表中所有元素出现次数

使用pandas顶级函数pd.value_counts，value_counts是一个顶级pandas方法，可用于任何数组或序列：

>>> pd.value_counts(obj.values, sort=False)

[pandas小记：pandas高级功能]

比列表解析要快2倍以上（时间包含了列表转换成ndarray的时间，如果已经是ndarray要快10倍左右）。

paths_len_dict_list = {len: values.count(len) for len in set(values)}

python列表删除操作

python列表中删除某个元素

使用del关键字删除指定位置的元素
input = [1,2,3,4]
del input[1]
使用pop方法删除指定位置的元素
input = [1,2,4,5,6]
input.pop(2)
注意list的pop方法如果指定参数的话，会删除指定索引位置的元素，如果未指定将删除list的最后一个元素。

python列表中删除某个元素所有的出现，如空字符串

while '' in classified_sentences:classified_sentences.remove('')

python清空列表的几种方式

1. s.clear() 

2. del s[:] 

3. s[:] = [] 

4. s *= 0

python列表、元组排序

list.sort()一般用法：指定轴axis；自定义comparator函数key; 升降序选择reverse。

list.sort(axis = None, key=lambda x:x[1], reverse = True)

python列表拷贝

python中怎么对一个列表赋值并修改不影响原来的列表?

1. 简单列表的拷贝

   已知一个列表，求生成一个新的列表，列表元素是原列表的复制

   a=[1,2]
   b=a

   这种其实并未真正生成一个新的列表，b指向的仍然是a所指向的对象。

   后果：如果对a或b的元素进行修改，a,b的值同时发生变化：a.remove(1)则对应b也变为[2]

2. 可以使用以下方法解决

   a=[1,2]
   b=a[:]

   这样修改a对b没有影响。修改b对a没有影响。

3. 列表拷贝

             a = [1,2,3]

             b = a.copy()

             print(id(a), id(b))

        4.复杂列表的拷贝

              可以使用copy模块中的deepcopy函数。修改测试如下：

              import copy
              a=[1,[2]]

              b=copy.deepcopy(a)

[图解 Python 深拷贝和浅拷贝]

python两个列表的操作

两个list相与操作

print([1,2] and [2,3])[2, 3]
print([] and [2,3])
[]

python两个列表相减

方法1. 用set（集合）操作
list3 = list(set(list1) - set(list2))
set操作会将一个list转换成一个集合，重复的项会被删除。
方法2.列表解析

list3 = [i for i in list1 if i not in list2]
但是在list很大的时候，没有set方法快。

python中求两个list的交集，两个list是否有交集

list1 = [1,2]list2 = [2,3]print(set(list1).intersection(set(list2))){2}

python两个列表合并extend

list.extend(seq)
Note:在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

返回none

如果不想改变原来list，可以用new_list = copy.deepcopy(list)

Flattening lists扁平列表

[Python模块 - itertools循环器模块]

python的for循环从两个不同列表中同时取出两个元素zip

zip()： 如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：

ta = [1,2,3]tb = [9,8,7]tc = ['a','b','c']for (a,b,c) in zip(ta,tb,tc):    print(a,b,c)

一个for循环中每次迭代输出两个列表对应的元素及对应的索引号enumerate&zip

users = [1,2,3]items = [4,5,6]for index, (user, item) in enumerate(zip(users, items)):    print(index, user, item)0 1 41 2 52 3 6

[python - 常用函数和全局变量--zip]

python列表其它操作

在python列表中每个元素间添加逗号,

（最后一个元素后面不加,，这里a中的元素必须是字符串）

a = ['12', '34', '45']s = ','.join(a)print(s)12,34,45

当然如果x中的元素不是字符串可以先转换一下

[''.join(xi) for xi in np.array(x).astype(str)]

列表解析和条件表达式

列表解析( List comprehensions)

列表解析一般都是下面的形式

[expr for iter_var in iterable if cond_expr]

迭代iterable里所有内容，每一次迭代后，把iterable里满足cond_expr条件的内容放到iter_var中，再在表达式expr中应该iter_var的内容，最后用表达式的计算值生成一个列表。

Note: iterable不能是None类型，否则会报错：notype is not iterable。

# times even numbers by 2 and odd numbers by 3
mul = [num * 3 if num % 2 else num * 2 for num in numbers]

如果没有else语句，只能将if语句放到后面

jiebaWords = [i for i in jiebaWords if len(i) >= 2]

虽然列表解析比for循环快很多，但是其实也没那么快，如

c = (np.array(a) ** 2).sum()b = sum([i ** 2 for i in a])

numpy的计算比列表解析快4倍，甚至

c  = np.sum(np.array(a))b = sum(a)

都比列表的直接计算sum快一丢丢。

Note: 数据多时，列表推导式可能会消耗大量内存，此时建议使用生成器表达式。

列表解析加速

列表解析中调用函数

lz提示，千万不要在列表解析中使用计算时间长的函数或者什么的，这样每次for解析时都会重新调用一次那个函数。所以不要过于依赖列表解析的代码简洁性。

It is very complex for the compiler/interpreter to determine that the function need not to be called many times. It is then very probable that the function is called many times.

[function inside list comprehension - is it evaluated multiple times [duplicate]]

列表解析的其它可参考优化

使用列表解析时，if语句中有in list语句时

[Python性能优化 ]

python列表和json格式的相互转换

[python对象与json的转换 ]

队列和栈实现

use a list as a stack: #像栈一样使用列表
stack = [3, 4, 5]
stack.append(6)
stack.append(7)
stack
[3, 4, 5, 6, 7]
stack.pop() #删除最后一个对象
7
stack
[3, 4, 5, 6]
stack.pop()
6
stack.pop()
5
stack
[3, 4]
use a list as a queue: #像队列一样使用列表
> from collections import deque #这里需要使用模块deque
> queue = deque(["Eric", "John", "Michael"])
> queue.append("Terry")           # Terry arrives
> queue.append("Graham")          # Graham arrives
> queue.popleft()                 # The first to arrive now leaves
'Eric'
> queue.popleft()                 # The second to arrive now leaves
'John'
> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

皮皮Blog

python元组操作

1个元素的tuple

元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义tup1 = (50,)

要定义一个只有1个元素的tuple，如果你这么定义：
>>> t = (1)
>>> t
1
定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

元组连接组合

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3;
#(12, 34.56, 'abc', 'xyz')

一个“可变的”tuple

复制代码 代码如下:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

[命名的tuples(collections.namedtuple)]

python列表和元组的区别和联系

相同点：

列表与元组都是容器，是一系列的对象。二者都可以包含任意类型的元素甚至可以是一个序列，还可以包含元素的顺序（不像集合和字典）。

异点：

列表和元组的“技术差异”是，列表是可变的，而元组是不可变的。这是在 Python 语言中二者唯一的差别。比如：列表有一个 append() 的方法来添加更多的元素，而元组却没有这个方法。元组并不需要一个 append() 方法，因为元组不能修改。比如你不能把列表当做字典的关键字，因为只有不可变的值才能进行哈希运算，因此只有不可变的值才能作为关键字。要使用列表做关键字，你需要把它转化为元组。

“文化差异“是指二者在实际使用中的差异：在你有一些不确定长度的相同类型队列的时候使用列表；在你提前知道元素数量的情况下使用元组，因为元素的位置很重要。

举个例子，假设你有一个函数是用来在目录中查找结尾为 *.py 的文件。函数返回的应该是一个列表，因为你并不知道你会找到多少个文件，而这些文件都有相同的含义：它们仅仅是你找到的另一个文件。另一方面，让我们假设你需要存储五个值来代表气象观测站的位置：id ,城市，国家，纬度，经度。元组就比列表更适用于这种情况。

把这种“文化差异”放到 C 语言来讲，列表像是数组，元组则像是 structs 结构体。

在参数数组中，位置很重要，因为他们是位置参数。但是在函数中，它会接收参数数组并传入另一个函数，它仅仅是一组参数，与其他参数并无不同。其中一些会在调用中变化。Python 之所以在这里使用元组是因为元组比列表更节省空间。列表被重复分配使得在添加元素上更快。这体现了 Python 的实用性：相比于在参数数组上，列表/元组的语义差别，在这种情况下，使用这种数据结构更好。

大部分情况下，你应该根据文化差异来选择使用列表还是元组。思考下你数据的含义。如果实际上根据你的程序来计算，你的数据长度并不固定，那么可能用列表更好。如果在写代码时你知道第三个元素的含义，那么用元组更好。另一方面，函数式编程强调使用不可变的数据结构来避免产生使代码变得更难解读的副作用。如果你喜欢使用函数式编程，那么你可能因为元组的不可变而更喜欢它们。

[Python 列表和元组的区别是什么？]

皮皮Blog

python字典dict

字典除了一般的映射使用，还可以从用于稀疏数据结构角度看：
例如多维数组中只有少数位置上有存储的值
>>> M={}
>>> M[(2,3,4)]=88
>>> M[(7,8,9)]=99  
{(2, 3, 4): 88, (7, 8, 9): 99}
键是元组，他们记录非空元素的坐标。我们并不是分配一个庞大而几乎为空的三维矩阵，而是使用一个简单的两个元素的字典。通过这一方式读取空元素的时，会触发键不存在的异常。因为这些元素实质上并没有被存储。

python字典构建

dict(zip(names, range(len(names)))) 

列表转换成字典fs_dict = dict.fromkeys(fs_list, True)

Note: dict.fromkeys函数返回的是一个新的dict，而不是改变原dict。所以dict1.fromkeys((1, 2, 3), 'new')是没有效果的。

python dict字典的key必须是hashable的：key不能是list, set(否则出错TypeError: unhashable type: 'list'), 但可以是tuple

{(1, 2): '5', (3, 2): '5'}

python dict字典的key应该会自动转换成同一类型（所有key类型的最小类型？），所以前面的1会被后面的1.0覆盖，而后面的浮点类型1.0会自动转换成int类型1。

In[4]: d = {1:2, 1.0:3}
In[5]: d[1]
3
In[6]: len(d)
1
In[7]: d.keys()
dict_keys([1])

d = {1.0:3}
In[9]: d.keys()
dict_keys([1.0])

python字典初始化

python字典设置value初始类型，指定字典的value类型

dict字典元素类型初始化设置

music_tag = dict()for music_name in music_names:    music_tag.setdefault(music_name, [])    for filename in filenames:        if music_name in [line.strip() for line in open(join(DIR, filename))]:            music_tag[music_name] += filename.split('.')[0]

dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
defaultdict的代码效率高于下面的等效代码：
>>> d = {}
>>> for k, v in s:
...     d.setdefault(k, []).append(v)

defaultdict字典初始化

[python模块 - collections模块: defaultdict]

python dict字典for循环输出

dict1 = {1: 1, 2: 1, 3: 1}for i in dict1: #等价于dic1.keys()

字典中添加元素add

dict.add()返回None

python 字典查找

1. 通过value 找出key

任何时刻dict.keys()和dict.values()的顺序都是对应的。
try:
    return dict.keys()[dict.values().index(value)]         #python3中要修改为list(dict.keys())[list(dict.values()).index(value)]
except ValueError:
    pass

Note:往dict中添加元素，keys和values加入后都是无序的！但是加入之后相对位置不变。

2. 从字典中获取元素

data = {'user': 1, 'name': 'Max', 'three': 4}

方法1：dict.get(key, default=None)

返回指定键的值，如果值不在字典中返回default值

is_admin = data.get('admin', False)

方法2：

try:

     is_admin = data['admin']

except KeyError:

     is_admin = False

python中两个字典的操作

python两个字典合并操作

dict1 = {1:1, 2:1, 3:1}dict2 = {3:2, 4:2, 5:2}dict1.update(dict2)print(dict1)

Note: dict key相同的value以更新值为主，也就是dict2。

Adding two dictionaries两个字典相加（合并）

x = {'a':1, 'b': 2}

y = {'b':10, 'c': 11, 'a':3, 'd':7}
方式1

for k, v in y.items():    if k in x:        x[k] += v    else:        x[k] = v

方式2

from collections import Counterz = Counter(x) + Counter(y)

方式3

z = {a: x.get(a, 0) + y.get(a, 0) for a in set(x) | set(y)}

print z

>>>{'a': 4, 'c': 11, 'b': 12, 'd': 7}
Note: 方式1最快，其次方式3。所以简单的程序还是自己手写比较好。

两个字典相减

pos = dict.fromkeys(random.randint(0, 1000000, size=1000000), True)gt1 = dict.fromkeys(random.randint(0, 1000000, size=1000000), True)

方式1r = {k: v for k, v in pos.items() if k not in gt1}

方式2from collections import Counterr = Counter(pos) - Counter(gt1)

Note: 方式1更快。

python字典排序

对字典按键/按值排序，用元组列表的形式返回，同时使用lambda函数来进行；

sorted(iterable[, cmp[, key[, reverse]]]
cmp和key一般使用lambda

对字典按键key排序，用元组列表的形式返回

1. 使用lambda函数

d = {3:5, 6:3, 2:4}ds = sorted(d.items(), key=lambda item:item[0], reverse=True) #d[0]表示字典的键print(ds)[(6, 3), (3, 5), (2, 4)]

2.采用operator模块的itemgetter函数

from operator import itemgettersorted(d, key=itemgetter(1))

[python - 常用函数和全局变量：sorted内置函数]

对字典按值value排序，用元组列表的形式返回

ds = sorted(ds.items(), key=lambda item:item[1], reverse=True)print(ds)[(3, 5), (2, 4), (6, 3)]
print(dict(ds))    #又变成无序的了
{2: 4, 3: 5, 6: 3}

分解代码：d.items() 得到[(键，值)]的列表。然后用sorted方法，通过key这个参数，指定排序是按照value，也就是第一个元素d[1]的值来排序。reverse = True表示是需要翻转的，默认是从小到大，翻转的话，那就是从大到小。

collections.OrderedDict有序字典

[collections模块- OrderedDict]

Dictionary Comprehensions字典解析

One use for generators can be to build a dictionary, like in the first example below. This proved itself to be common enough that now there is even a newdictionary comprehension syntax for it. Both of these examples swap the keys and values of the dictionary.

teachers = {
    'Andy': 'English',
    'Joan': 'Maths',
    'Alice': 'Computer Science',
}
# using a list comprehension
subjects = dict((subject, teacher) for teacher, subject in teachers.items())
 
# using a dictionary comprehension
subjects = {subject: teacher for teacher, subject in teachers.items()}

>>> m = {x: 'A' + str(x) for x in range(10)}

{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}

Note: 字典解析中的if判断是对value来说的，如：

loc2type_dict = {vid: vcat.split(',') if not pd.isnull(vcat) else ['notype'] for _, (vid, vcat) in df.iterrows()}

Inverting a dictionary using a dictionary comprehension翻转字典中的key和value

>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}>>> m{'d': 4, 'a': 1, 'b': 2, 'c': 3}>>> {v: k for k, v in m.items()}{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

Note: 也可以使用zip反相字典对象

皮皮Blog

python集合操作

集合加入、删除元素

add(elem)（已存在就不加入）

Add element elem to the set.

remove(elem)

Remove element elem from the set. Raises KeyError if elem isnot contained in the set.

discard(elem)

Remove element elem from the set if it is present.

pop()

Remove and return an arbitrary element from the set. RaisesKeyError if the set is empty.

clear()

Remove all elements from the set.

将整个新集合加入到本集合中

update(*others)¶

集合间操作

>>> a = set('abracadabra')

>>> b = set('alacazam')
>>> a                                  # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b                              # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b                              # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                              # letters in both a and b
set(['a', 'c'])
>>> a ^ b                              # letters in a or b but not both

set(['r', 'd', 'b', 'm', 'z', 'l'])

判断子集、父集


issuperset(other)¶


s = {1, 2, 3, 4}a = (1, 2)if s.issuperset([*a]):    print('***')

issubset(other)¶

[class set([iterable])¶]

[Multisets and multiset operations (collections.Counter) ]

皮皮Blog

数据类型转换

基本数据类型转换

float(str)

python ValueError: could not convert string to float.

原因：数据中存在空字符串''，导致无法转换成float。

列表，元组和字符串之间的互相转换

python中三个内建函数：str(),tuple()和list()

str<=>list | tuple

字符串转换为list、tuple

>>> s = "xxxxx"
>>> list(s)
['x', 'x', 'x', 'x', 'x']
>>> tuple(s)
('x', 'x', 'x', 'x', 'x')
>>> tuple(list(s))
('x', 'x', 'x', 'x', 'x')
>>> list(tuple(s))
['x', 'x', 'x', 'x', 'x']列表和元组转换为字符串则必须依靠join函数>>> "".join(tuple(s))
'xxxxx'
>>> "".join(list(s))
'xxxxx'
>>> str(tuple(s))
"('x', 'x', 'x', 'x', 'x')"

当然如果x中的元素不是字符串可以先转换一下

[''.join(xi) for xi in np.array(x).astype(str)]

dict<=>list | tuple

列表或元组直接转字典

1. rankDict = dict(rank)

元组不可以直接转为字典

但可以这样：

元组列表转换成字典

[('9', '7'), ('8', '5'), ('8', '4'), ('9', '3'), ('7', '3'), ('7', '2')]{i:j for i, j in bc_s}

如果有像上面重复的keys：

bc_ss = defaultdict(list)for bc in bc_s:    bc_ss[bc[0]].append(bc[1])

两个列表转换成字典：

post_data = dict(zip(["retcode", "servertime", "pcid", "nonce", "pubkey", "rsakv", "exectime"], post_ori_data))

2. dict.fromkeys(S)

S是一个列表或元组...，将S中的元素作为字典的key，value默认为None，也可以指定一个初始值，代码示例：

myDict = dict.fromkeys('hello', True)for k in myDict.keys():    print(k, myDict[k])h Truee Truel Trueo True

字典转元组列表

a = {1:23,8:43,3:34,9:28}
print(list(a.items()))
print(list(zip(a.keys(),a.values())))

from:http://blog.csdn.net/pipisorry/article/details/39234557

ref:30 Python Language Features and Tricks You May Not Know About

Hidden features of Python [closed]

Python: Tips, Tricks and Idioms

Python程序的执行原理