高阶使用 Python

Code PV:

人类大脑中，大约有1000亿个神经元，每个神经元与大约10万个神经元相连。从本质上说，这就是我们想要创造的，在某种程度上，这对机器来说是可行的。
深度学习的目的是模仿人类大脑的工作方式。这在神经元，轴突，树突等方面意味着什么？嗯，神经元有胞体，树突和轴突。来自一个神经元的信号沿着轴突传播并转移到下一个神经元的树突。传递信号的那个连接被称为突触。

原文地址: CSDN-兔兔RabbitMQ

原地交换

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

1
2
3
4
5
6
7
8
x, y = 10, 20
print(x, y)

x, y = y, x
print(x, y)

#1 (10, 20)
#2 (20, 10)

链状比较操作符

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

1
2
3
4
5
6
n = 10
result = 1 < n < 20
print(result)    # True

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

三元操作符进行条件赋值

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

1
2
3
4
5
6
7
8
9
# 给出一个你可以用来使代码紧凑简洁的例子。下面的语句是说“如果 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)

多行字符串

直接多行注释

1
2
3
4
5
a='''dvfssd
fsdfdsfsd
dsdsfbfdfasf
afasfaf'''
print(a)

in判断

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

1
2
3
4
可以使用下面的方式来验证多个值：
if m in [1,3,5,7]:
# 而不是：
if m==1 or m==3 or m==5 or m==7:

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 翻转列表本身
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]

一次初始化多个变量

可以直接赋值

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

可以利用列表

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

打印模块路径

1
2
3
import socket
print(socket)
#<module 'socket' from '/usr/lib/python2.7/socket.py'>

字典推导

python不光有列表推导式 字典/集合也有

1
2
3
4
5
6
7
8
9
10
11
12
13
#列表
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 range(10)}
testSet = {i * 2 for i in range(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中字符串可以相加

1
2
3
4
a="i "
b="love "
c="you"
print(a+b+c)

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

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

循环枚举索引

方便找到下标和对应元素

1
2
3
4
5
6
7
list = [10, 20, 30]
for i, value in enumerate(list):
    print(i, ': ', value)

#1-> 0 : 10
#2-> 1 : 20
#3-> 2 : 30

返回多个值

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

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

开启文件分享(这条还不是很理解 没具体用过)

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

1
python3 -m http.server

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

调试脚本

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

1
2
import pdb
pdb.set_trace()

直接迭代序列元素

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

1
2
3
4
5
6
7
>>> 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 等语句中使用，这个语言特性不是什么秘密，但却没有得到重视。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# for
l=[1,2,3,4,5]
for i in l:
    if i=='6':
        print(666)
        break
else:
    print(999)

# 如果不这么实现，只能设置一个变量来记录：
l=[1,2,3,4,5]
a = 1
for i in l:
    if i=='6':
        print(666)
        a = 0
        break
if a:
    print(999)

# while和for类似
try:
    a()
except OSError:
    #语句1
else:
    #语句2

# for: 仅当 for 循环运行完毕时（即 for 循环没有被 break 语句中止）才运行 else 块。
# while: 仅当 while 循环因为条件为假值而退出时（即 while 循环没有被break 语句中止）才运行 else 块。
# try:仅当 try 块中没有异常抛出时才运行 else 块。
# 如果异常或者 return、break 或 continue 语句导致控制权跳到了复合语句的主块之外，那么else 子句也会被跳过。
# 按正常的理解应该是“要么运行这个循环，要么做那件事”。可是，在循环中，else 的语义恰好相反：“运行这个循环，然后做那件事。”

except的用法和作用

1
2
3
4
5
6
7
8
try/except: 捕捉由PYTHON自身或写程序过程中引发的异常并恢复
except: 捕捉所有其他异常
except name: 只捕捉特定的异常
except name, value: 捕捉异常及格外的数据(实例)
except (name1,name2) 捕捉列出来的异常
except (name1,name2),value: 捕捉任何列出的异常，并取得额外数据
else: 如果没有引发异常就运行
finally: 总是会运行此处代码

python自省

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

python容器

1
2
3
4
列表：元素可变（任何数据类型），有序（可索引），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()实现如下：

1
2
3
4
5
6
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所有数字转为字符串：

1
2
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把结果继续和序列的下一个元素做累积计算

1
2
3
4
5
6
from functools import reduce
def fn(x,y):
    return x * 10 +y

reduce(fn,[1,3,5,7,9])
13579

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

1
2
3
4
5
6
7
8
9
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 个子字符串。

1
2
3
str.split(str="", num=string.count(str))
str.split("")

filter

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

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

简单例子，删掉偶数：

1
2
3
4
5
def is_odd(n):
    return n % 2 == 1

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

利用filter()不断产生筛选后的新的序列
Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#先构造一个从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) # 构造新序列

sorted

1
2
3
4
5
6
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]

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

1
2
orted(['bob', 'about', 'Zoo', 'Credit'])
# ['Credit', 'Zoo', 'about', 'bob']

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

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

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

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

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

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

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

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

Powered by Hexo and Hexo-theme-hiker

Copyright © 2013 - 2024 HELLO WORLD All Rights Reserved.

UV : | PV :