一、原地交换

Python 提供了一个直观的在一行代码中赋值与交换（变量值）的方法

x, y = 10, 20print(x, y) x, y = y, xprint(x, y) #1 (10, 20)#2 (20, 10)

原理：赋值的右侧形成了一个新的元组，左侧立即解析（unpack）那个（未被引用的）元组到变量 <a> 和 <b>。一旦赋值完成，新的元组变成了未被引用状态并且被标记为可被垃圾回收，最终也完成了变量的交换。

二、链状比较操作符

Python不用很多条件一个一个写，比较操作符可以聚合。

n = 10result = 1 < n < 20print(result) # True result = 1 > n <= 9print(result) # False

三、三元操作符进行条件赋值

三元操作符是 if-else 语句也就是条件操作符的一个快捷方式：[表达式为真的返回值] if [表达式] else [表达式为假的返回值]

这里给出一个你可以用来使代码紧凑简洁的例子。下面的语句是说“如果 y 是 9，给 x 赋值 10，不然赋值为 20”。

x = 10 if (y == 9) else 20

在列表推导中：

[m**2 if m > 10 else m**4 for m in range(50)]

判断最小值：

def small(a, b, c):    return a if a <= b and a <= c else (b if b <= a and b <= c else c)

类中：

x = (classA if y == 1 else classB)(param1, param2)

四、多行字符串

这个比c方便多了，c打上换行符再加上转义，真的很难受

a='''dvfssdfsdfdsfsddsdsfbfdfasfafasfaf'''print(a)

五、in判断

可以直接用来判断某个变量是否在列表中

我们可以使用下面的方式来验证多个值：

if m in [1,3,5,7]:

而不是：

if m==1 or m==3 or m==5 or m==7:

六、 四种翻转字符串/列表的方式

# 翻转列表本身

testList = [1, 3, 5]testList.reverse()print(testList)#-> [5, 3, 1]

# 在一个循环中翻转并迭代输出

for element in reversed([1,3,5]):    print(element)  #1-> 5 #2-> 3 #3-> 1

# 一行代码翻转字符串

"Test Python"[::-1]#输出 “nohtyP tseT”

# 使用切片翻转列表

[1, 3, 5][::-1]   #输出 [5,3,1]。

七、一次性初始化多个变量

可以直接赋值：

a,b,c,d=1,2,3,4

可以利用列表：

List = [1,2,3]x,y,z=Listprint(x, y, z)#-> 1 2 3

（元素个数应与列表长度相同）

八、打印模块路径

import socketprint(socket)#<module 'socket' from '/usr/lib/python2.7/socket.py'>

九、字典推导

Python不光列表用推导式，字典/集合也有

#列表l=[[0 for i in range(4)] for i in range(4)]#生成二维列表print(l)#  [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

testDict = {i: i * i for i in xrange(10)}testSet = {i * 2 for i in xrange(10)} print(testSet)print(testDict) #set([0, 2, 4, 6, 8, 10, 12, 14, 16, 18])#{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

十、拼接字符串

众所周知，python中字符串可以相加：

a="i "b="love "c="you"print(a+b+c)

拼接列表中的所有元素为一个字符串

l=['a','b','c']print(''join(l))#以join左边的字符做分割

十一、循环枚举索引

list = [10, 20, 30]for i, value in enumerate(list):    print(i, ': ', value) #1-> 0 : 10#2-> 1 : 20#3-> 2 : 30

很方便的找到下标和对应元素

十二、返回多个值

并没有太多编程语言支持这个特性，然而 Python 中的方法确实（可以）返回多个值

def a():    return 1,2,3,4,5

十三、开启文件分享

Python 允许运行一个 HTTP 服务器来从根路径共享文件，下面是开启服务器的命令：

python3 -m http.server

上面的命令会在默认端口也就是 8000 开启一个服务器，你可以将一个自定义的端口号以最后一个参数的方式传递到上面的命令中。

十四、调试脚本

我们可以在 <pdb> 模块的帮助下在 Python 脚本中设置断点，例子：

import pdbpdb.set_trace()

十五、直接迭代序列元素

对序列（str、list、tuple等），直接迭代序列元素，比迭代元素的索引速度要更快。

>>> l=[0,1,2,3,4,5]>>> for i in l:print(i)#快>>> for i in range(len(l)):print(l[i])#慢

十六、巧用else语句（重要）

python的else 子句不仅能在 if 语句中使用，还能在 for、while 和 try 等语句中使用，这个语言特性不是什么秘密，但却没有得到重视。

for：l=[1,2,3,4,5]for i in l:    if i=='6':        print(666)        breakelse:    print(999)

如果不这么实现，我们只能设置一个变量来记录了：

l=[1,2,3,4,5]a=1for i in l:    if i=='6':        print(666)        a=0        breakif a:    print(999)

while和for类似

看一下try：

try:    a()except OSError:    #语句1else:    #语句2

仅当 try 块中没有异常抛出时才运行 else 块。

总结一下else：

for:

　　仅当 for 循环运行完毕时（即 for 循环没有被 break 语句中止）才运行 else 块。

while:

　　仅当 while 循环因为条件为假值而退出时（即 while 循环没有被break 语句中止）才运行 else 块。

try:

　　仅当 try 块中没有异常抛出时才运行 else 块。

即，如果异常或者 return、break 或 continue 语句导致控制权跳到了复合语句的主块之外，那么else 子句也会被跳过。

按正常的理解应该是“要么运行这个循环，要么做那件事”。可是，在循环中，else 的语义恰好相反：“运行这个循环，然后做那件事。”

十七、except的用法和作用

try/except: 捕捉由PYTHON自身或写程序过程中引发的异常并恢复

except: 捕捉所有其他异常

except name: 只捕捉特定的异常

except name, value: 捕捉异常及格外的数据(实例)

except (name1,name2) 捕捉列出来的异常

except (name1,name2),value: 捕捉任何列出的异常，并取得额外数据

else: 如果没有引发异常就运行

finally: 总是会运行此处代码

十八、Python自省

这个也是python彪悍的特性.自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.比如type(),dir(),getattr(),hasattr(),isinstance().

十九、python容器

列表：元素可变（任何数据类型），有序（可索引），append/insert/pop；

元组：元素不可变，但元素中的可变元素是可变的；有序（可索引）；而且元组可以被散列，例如作为字典的键。

集合：无序（不可被索引）、互异

字典：无序，键值对（key：value），key唯一不可重复

二十、map（）

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。（重点理解）

举例说明，比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：

>>> def f(x):...     return x * x...>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])>>> list(r)[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))['1', '2', '3', '4', '5', '6', '7', '8', '9']

二十一、reduce

reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

简单例子：

>>> from functools import reduce>>> def fn(x, y):        return x * 10 + y >>> reduce(fn, [1, 3, 5, 7, 9])13579

结合一下，我们可以自己写出int（）函数

from functools import reduce a={'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} def charnum(s):    return a[s] def strint(s):    return reduce(lambda x, y: x * 10 + y, map(charnum, s))

我们继续说一些好用的函数

二十二、split

Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num 个子字符串。

语法：

str.split(str="", num=string.count(str))

简化：

str.split("")

二十三、理论结合实际

1）结合第四期所学知识，我们可以写出这一行代码

print(" ".join(input().split(" ")[::-1]))

实现功能，leetcode原题：给定一个句子（只包含字母和空格），将句子中的单词位置反转，单词用空格分割，单词之间只有一个空格，前后没有空格。比如：（1）“hello xiao mi” – >“ mi xiao你好“

2）再举一例：

将两个整型数组按照升序合并，并且过滤掉重复数组元素

输入参数：

int* pArray1 ：整型数组1intiArray1Num：数组1元素个数int* pArray2 ：整型数组2intiArray2Num：数组2元素个数

对于python来说，给个数没什么卵用。

a,b,c,d=input(),list(map(int,input().split())),input(),list(map(int,input().split()))print("".join(map(str,sorted(list(set(b+d))))))

3）我们把最近的知识结合起来做一道题：

输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。

result=""for i in input()[::-1]:    if i not in result:        result+=iprint(result)

还有很多具体的简洁操作，这里就不再举例子了，多体会吧。

好，我们继续其它函数。

二十四、filter

Python内建的filter()函数用于过滤序列。

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

简单例子，删掉偶数：

def is_odd(n):    return n % 2 == 1 list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))# 结果: [1, 5, 9, 15]

我们可以用所学知识实现埃氏筛：

素数基本（埃氏筛法）

（1）检查n是否为素数

最简单思路：所有可能的因数全部试一遍。

int gg(int n)

{

for(int i=2;i<n;i++){

if((n%i)==0)return 0;//有因数就不是素数咯

}

return 1;

}

进一步思考：没必要枚举所有的数，每一个小于n^(1/2)的因数i，一定有一个大于n^(1/2)的因数j与之对应，也就是i*j=n，所以枚举小于等于n^(1/2)的因数即可

int gg(int n)

{

for(int i=2;i*i<=n;i++){

if((n%i)==0)return 0;

}

return 1;

}

（2）约数枚举

上面已经说过，不需要枚举所有因数，枚举出某小因数以后算出对应的大因数即可。

vector<int> gg(int n)

{

vector<int> a;

for(int i=2;i*i<=n;i++){

if((n%i)==0){

a.push_back(i);

if((n/i)!=i)a.push_back(n/i);//根号n的情况不要重复添加

}

}

return a;

}

（3）埃氏筛法

只对一个整数操作，O(N)，已经足够了，如果对许多整数进行素性检测，还有更高效的算法，比如埃氏筛法。

问题：枚举n以内所有素数

操作：先把所有整数列出来，然后把2的倍数全部剔除，然后是三的，以此类推，遍历所有素数，把倍数全部划去。

对于每个数字i，如果没被划去，他一定是素数，因为他不是任何2到i-1数字的倍数。然后就开始划它的倍数就好。

int a[maxx];

int b[maxx+1];

int gg(int n)

{

int p=0;//记录素数个数

for(int i=0;i<n+1;i++)b[i]=1;

b[0]=0;

b[1]=0;

//准备完毕

for(int i=2;i<=n;i++){

if(b[i]){

a[p++]=i;//记录素数和个数

for(int j=2*i;j<=n;j+=i)b[j]=0;//剔除倍数

}

}

return p;//返回素数个数

}

本代码非原创：

#先构造一个从3开始的奇数序列：def _odd_iter():    n = 1    while True:        n = n + 2        yield n#这是一个生成器，并且是一个无限序列。 #筛选函数def _not_divisible(n):    return lambda x: x % n > 0#生成器def primes():    yield 2    it = _odd_iter() # 初始序列    while True:        n = next(it) # 返回序列的第一个数        yield n        it = filter(_not_divisible(n), it) # 构造新序列

利用filter()不断产生筛选后的新的序列

Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

二十五、sorted

>>> sorted([36, 5, -12, 9, -21])[-21, -12, 5, 9, 36]#可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：>>> sorted([36, 5, -12, 9, -21], key=abs)[5, 9, -12, -21, 36]

我们再看一个字符串排序的例子：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])['Credit', 'Zoo', 'about', 'bob']

默认情况下，对字符串排序，是按照ASCII的大小比较的，由于’Z’ < ‘a’，结果，大写字母Z会排在小写字母a的前面。

现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能用一个key函数把字符串映射为忽略大小写排序即可。忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。

这样，我们给sorted传入key函数，即可实现忽略大小写的排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)['about', 'bob', 'Credit', 'Zoo']

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)['Zoo', 'Credit', 'bob', 'about']

从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。

sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。