python数据模型和各种实用小技巧，保证让你更PYTHONIC

前话： python简单易用，库多就是这么强大，笔者也长期使用过java、c、c++等语言，嗯不多说，最后选择了python! 但其实很多python程序猿都是其他语言转过来的，而且python兼容性也很高，所以比如java程序猿在写python的时候总能感觉到一股浓浓的java味，一个字：尬，两个字：尴尬！因此本文就是简单的通过介绍python数据模型和各种实用的小技巧来体现一下：PYTHONIC ，感受一下python语言的美妙之处，如果想更多了解python语言的风格，强烈推荐：流畅的Python

一、python数据模型

python数据模型是对python框架的描述，也就是说它规范了python这门语言自身构建模块的接口，这些自带模块中就含有一些特殊方法，在python框架下写程序，当python解释器碰到一些特殊的句法时，便会调用这些特殊方法去执行对象操作，这些特殊方法总结了一下几个特点：

1、特殊方法的存在是为了被解释器调用的，自己并不需要调用他们
2、大多数特殊方法的调用都是隐式的，但如__init__() 便显示调用超类的构造器
3、调用特殊方法执行速度上很快，因为是在内置模块中的
4、通过实现特殊方法，自定义数据类型可以表现的跟内置类型一样

下面我们便通过实现特殊方法，自定义数据对象，来感受一下PYTHONIC

import collections
Card = collections.namedtuple('Card', ['rank', 'suit'])

class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits 
                                        for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

上述代码中首先用collections.namedtuple()常见了一个的纸牌对象，并定义了FrenchDeck类，类中实现了python的特殊方法： __len__()、__getitem__()方法，由于特殊方法__len__()定义我们可以直接对FrenchDeck对象进行len()操作，同时__getimtem__()方法把 [] 操作交给了self._cards列表，我们可以直接把FrenchDeck对象当做list进行操作，可以直接根据索引取值，而且可以进行list的切片操作，演示如下：

deck = FrenchDeck()
print(len(deck))  #52
deck[0]           #Card(rank='2', suit='spades')
deck[1:3]  #[Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]
from random import choice
choice(deck)   #随机对deck对象进行选择

简而言之， python中含有很多特殊方法，可以方便的实现且快速的实现特定功能，同时我们也可以在定义的数据类型中去实现特殊方法，这样自定义数据类型就可以表现的和python内置类型一样，写出更具有python风格的代码，下面通过一些python中实用技巧再看一下python的独到之处

二、python各种使用小技巧

1、python一行代码定义list

利用python的列表推导式，可通过一行代码定义list

numbers = [1, 2, 3, 4, 5, 6]
list1 = [n * 2 for n in numbers]
list2 = [n**2 for n in numbers]

2、字典推导式

字典推导式类似于列表推导式，在用于字典key、value翻转时十分方便

sample = ['a', 'b', 'c', 'd', 'e']
s_dict = {key:value for value,key in enumerate(sample)}
print(s_dict)   #{'d': 3, 'a': 0, 'b': 1, 'e': 4, 'c': 2}
inversed_sdict = {value:key for key,value in s_dict.items()}
print(inversed_sdict)  #{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}

3、python中两个变量值交换

看下面，一行代码，无需构建中间变量，可以说是相当方便了

a, b = 1, 2
a, b = b, a
print('a=%d, b=%d'%(a, b))

4、lambda创建匿名函数

python中构建函数可以不适用函数定义，直接如下一条语句定义一次性匿名函数

double = lambda x: x*2
double(5)   #10

5、map操作和filter操作

map操作和filter操作可以结合lambda函数一起使用，利用简单的实现一些高效的操作

(1)、map(func, s): 对集合s中每个元素执行func函数操作;
(2)、filter(func, s): 筛选集合s中满足func函数定义的元素

seq = [1, 2, 3, 4, 5]
print(list(map(lambda x:x*2, seq)))     #[2, 4, 6, 8, 10]
print(list(filter(lambda x:x>2, seq)))  #[3, 4, 5]

6、python中join操作

join操作可以有效的实现字符串的拼接操作

a = ['my', 'name', 'is', 'CHEONG]
print(' '.join(a))                     #my name is CHEONG
b = [1, 2, 3, 4, 5, 6]
print(''.join(str(ele) for ele in b))  #123456

7、操作符链式调用、函数链式调用

(1) 操作符链式调用

num = 5
if 7 > num > 4:
    print('链式比较操作符')

(2) 函数链式调用

class Person:
    def name(self, name):
        self.name = name
        return self

    def age(self, age):
        self.age = age
        return self

    def show(self):
        print("My name is", self.name, "and I am", self.age, "years old.")

p = Person()
p.name("CHEONG").age(8).show() #My name is CHEONG and I am 8 years old.

8、字符串和list倒转

直接使用list切片操作，超简单，当然也可以使用reversed() 函数

s = 'abcdef'                   
print(s[::-1])               #fedcba
a = [5, 4, 3, 2, 1]
print(a[::-1])               #[1, 2, 3, 4, 5]
num = 123456789
print(int(str(num)[::-1]))   #987654321

9、按value值排序字典

sorted()函数、items()函数、lambda()函数综合使用

sample = ['C', 'H', 'E', 'O', 'N', 'G']
s_dict = {key:value for value,key in enumerate(sample)}
print(s_dict)      #{'O': 3, 'E': 2, 'H': 1, 'C': 0, 'N': 4, 'G': 5}
sort_sdict = sorted(s_dict.items(), key = lambda x:x[1])
print(sort_sdict)  #[('C', 0), ('H', 1), ('E', 2), ('O', 3), ('N', 4), ('G', 5)]

10、list中最大和最小值索引

有时候我们对list元素不感兴趣，而对list元素的索引十分感兴趣,，此时便排上用场

lst = [4, 1, 2, 3, 5]
min_idx = min(range(len(lst)), key=lst.__getitem__)
max_idx = max(range(len(lst)), key=lst.__getitem__)
print(min_idx)   #min_idx=1
print(max_idx)   #max_idx=4

11、list赋值技巧以及深拷贝浅拷贝

python中list对象lst1=lst2，其中对象lst1指向的是lst2的对象所在指针，在内存中lst1、lst2指向的是同一块内存，所以有时候使用浅拷贝还是深拷贝要注意

(1) list赋值技巧

lst1 = [1, 2, 3， 4]
lst2 = lst1
lst2[2] = 4
print(lst1)   #[1, 2, 4, 4]

注意到上面修改lst2，则lst1也相应发生了变化，如果想要lst2指向另一个内存空间，用下面操作

#方式1
lst1 = [1, 2, 3, 4]
lst2 = list(a)
lst2[2] = 4
print(lst1)   #[1, 2, 3, 4]

#方式2
lst1 = [1, 2, 3, 4]
lst2 = lst1[:]
lst2[2] = 4
print(lst1)   #[1, 2, 3, 4]

(2) python中浅拷贝和深拷贝
python中的浅拷贝copy()函数，b浅拷贝a后则b、a指向同一个内存空间；但python中copy模块有深拷贝函数deepcopy()函数，当b深拷贝a后，则b、a指向不同的内存空间

import copy
a = {1:[1, 2, 3], 2:[1, 2, 3, 4]}
b = a.copy()
a[1].append(4)
print(a)     #{1: [1, 2, 3, 4], 2: [1, 2, 3, 4]}
print(b)     #{1: [1, 2, 3, 4], 2: [1, 2, 3, 4]}

c = copy.deepcopy(a)
a[1].append(5)
print(a)     #{1: [1, 2, 3, 4, 5], 2: [1, 2, 3, 4]}
print(b)     #{1: [1, 2, 3, 4, 5], 2: [1, 2, 3, 4]}
print(c)     #{1: [1, 2, 3, 4], 2: [1, 2, 3, 4]}

12、collections集合模块

(1) collections.namedtuple定义简单对象

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)    #1 2

(2) collections.Counter代替字典进行统计

from collections import Counter
c = Counter()
lst = [1, 1, 2, 2, 2, 3, 4, 5, 5]
for ele in lst:
    c[ele] += 1
print(dict(c))  #{1: 2, 2: 3, 3: 1, 4: 1, 5: 2}

(3) collections.deque双向列表

python中列表list按照索引访问元素速度快，但是插入和删除就很慢了，因此可以使用collections.deque实现快速的插入和删除，并且collections.deque提供了从序列头部插入和删除

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('d')
print(q)          #deque(['a', 'b', 'c', 'd'])
q.appendleft('x')
print(q)          #deque(['x', 'a', 'b', 'c', 'd'])
q.pop()
print(q)          #deque(['x', 'a', 'b', 'c'])
q.popleft()
print(q)          #deque(['a', 'b', 'c'])

后话：本文自然只是列举了部分常用的显示PYTHONIC风格的实用技巧，想了解更多多看看流畅的Python，绝对良心书籍！欢迎大家交流分享！