Python之——高级特性总结

最新推荐文章于 2022-07-28 14:25:54 发布

Seven_0507

最新推荐文章于 2022-07-28 14:25:54 发布

阅读量442

点赞数

分类专栏： Python 文章标签： Python

本文链接：https://blog.csdn.net/KEEP_GIONG/article/details/80789754

版权

Python 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

本次主要介绍Python的一些高级特性

文章目录

1. 切片
2. 列表生成式
3. 生成器（generator）
4. 迭代器（Iterator）
5. 高级函数
6. 函数参数
7. 装饰器
8. Python常见错误

1. 切片

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
print('L[0:3] =', L[0:3])
print('L[:3] =', L[:3])
print('L[1:3] =', L[1:3])
print('L[-2:] =', L[-2:])

R = list(range(100))
print('R =', R)
print('R[:10] =', R[:10])
print('R[-10:] =', R[-10:])
print('R[10:20] =', R[10:20])
print('R[:10:2] =', R[:10:2])
print('R[::5] =', R[::5])

结果如下：
L[0:3] = [‘Michael’, ‘Sarah’, ‘Tracy’]
L[:3] = [‘Michael’, ‘Sarah’, ‘Tracy’]
L[1:3] = [‘Sarah’, ‘Tracy’]
L[-2:] = [‘Bob’, ‘Jack’]
R = [0, 1, 2, 3, …, 97, 98, 99]
R[:10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
R[-10:] = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
R[10:20] = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
R[:10:2] = [0, 2, 4, 6, 8]
R[::5] = [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

2. 列表生成式

print('list(range(1,10)) = ', list(range(1, 11)))
print([x * x for x in range(1, 11)])
print([x * x for x in range(1, 11) if x % 2 == 0])
print([m + n for m in 'ABC' for n in 'XYZ'])
print('-'*50)

# 列出当前目录下的所有文件和目录名
import os
print([d for d in os.listdir('.')])  # os.listdir可以列出文件和目录
print('-'*50)

# 列表生成式也可以使用两个变量来生成list
d = {'x': 'A', 'y': 'B', 'z': 'C'}  # 字典
print([k + '=' + v for k, v in d.items()])
print('-'*50)

# list中所有的字符串变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])
print('-'*50)

结果如下：
list(range(1,10)) = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[4, 16, 36, 64, 100]
[‘AX’, ‘AY’, ‘AZ’, ‘BX’, ‘BY’, ‘BZ’, ‘CX’, ‘CY’, ‘CZ’]
++++++++++++++++++++++++++++++++++++++++++++++++++
[‘matrix.py’, ‘test_basic.py’]
++++++++++++++++++++++++++++++++++++++++++++++++++
[‘x=A’, ‘y=B’, ‘z=C’]
++++++++++++++++++++++++++++++++++++++++++++++++++
[‘hello’, ‘world’, ‘ibm’, ‘apple’]
++++++++++++++++++++++++++++++++++++++++++++++++++

3. 生成器（generator）

一个列表生成式的[ ]改成( )，就创建了一个generator

# 生成器
g = (x * x for x in range(10))
for n in g:
    print(n)

# 斐波拉契数列（Fibonacci）：方法一
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'
print(fib(8))

# 斐波拉契数列（Fibonacci）：方法二
# 要把fib函数变成generator，只需要把print(b)改为yield b就可以
# 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'
# for循环来获取下一个返回值
g = fib(6)
while True:
	try:
		x = next(g)
		print('g:', x)
	except StopIteration as e:
		print('Generator return value:', e.value)
		break

结果如下
0
1
4
9
16
++++++++++++++++++++++++++++++++++++++++++++++++++
1
1
2
3
5
8
done
++++++++++++++++++++++++++++++++++++++++++++++++++
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

4. 迭代器（Iterator）

可以直接作用于for循环的对象统称为可迭代对象：Iterable
可以使用isinstance( )判断一个对象是否是Iterable对象
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
可以使用isinstance( )判断一个对象是否是Iterator对象
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator
把list、dict、str等Iterable变成Iterator可以使用iter()函数

# 判断是否为迭代器
from collections import Iterator
print(isinstance((x for x in range(10)), Iterator))
print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abc', Iterator))

# Iterable转化为Iterator
print(isinstance(iter([]), Iterator))
print(isinstance(iter('abc'), Iterator))

结果如下：True False False False True True

小结
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

5. 高级函数

5.1 map/reduce

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
reduce()把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

# map()函数
def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r), '\r', '+' * 50)

s = list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(s, '\r', '+' * 50)

# reduce函数
from functools import reduce
def add(x, y):
    return x + y
def fn(x, y):
    return x * 10 + y
print(reduce(add, [1, 3, 5, 7, 9]), '\r', reduce(
    fn, [1, 3, 5, 7, 9]), '\r', '+' * 50)

结果如下：
[1, 4, 9, 16, 25, 36, 49, 64, 81]
++++++++++++++++++++++++++++++++++++++++++++++++++
[‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’]
++++++++++++++++++++++++++++++++++++++++++++++++++
25
13579

5.2 fliter

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

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

def not_empty(s):
    return s and s.strip()
print(list(filter(not_empty, ['A', '', 'B', None, 'C', '  '])))

结果如下：
[1, 5, 9, 15]
[‘A’, ‘B’, ‘C’]

# 计算素数
def main():
    for n in primes():
        if n < 1000:
            print(n)
        else:
            break
 
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)

if __name__ == '__main__':
    main()

参考https://github.com/michaelliao/learn-python3/blob/master/samples/functional/prime_numbers.py

5.3 sorted

# 默认排序
print(sorted([36, 5, -12, 9, -21]))
# 使用key函数来实现自定义的排序
print(sorted([36, 5, -12, 9, -21], key=abs))
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower))
# 反向排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True))

结果如下：
[-21, -12, 5, 9, 36]
[5, 9, -12, -21, 36]
[‘about’, ‘bob’, ‘Credit’, ‘Zoo’]
[‘Zoo’, ‘Credit’, ‘bob’, ‘about’]

6. 函数参数

函数参数有五种类型：

（1）必选参数=位置参数：def power(x, n):
（2）默认参数：def power(x, n=2): // def add_end(L=None): ！= def add_end(L=[])?/
定义默认参数要牢记一点：默认参数必须指向不变对象！！！
（3）可变参数：def calc(*numbers):
*args是可变参数，args接收的是一个tuple 可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))
（4）关键字参数：def person(name, age, **kw)
**kw是关键字参数，kw接收的是一个dict 关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})
（5）命名关键字参数：def person(name, age, *, city, job):
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数，如上，*后面的参数被视为命名关键字参数。

注意：参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数、关键字参数

例如：
def f1(a, b, c=0, *args, **kw):
def f2(a, b, c=0, *, d, **kw):
##返回函数
函数作为返回值
高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

#不需要立即求和，可以不返回求和结果，直接返回求和的函数
def lazy_sum(*args):
	def sum():
		ax=0
		for n in args:
			ax=ax+n
		return ax
	return sum
f=lazy_sum(1,3,5,7,9)
print(f) #返回函数
print(f()) #真正计算结果

结果如下：
function lazy_sum..sum at 0x00000000028A0A60
25

需要注意：返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量（不要引用任何循环变量，或者后续会发生变化的变量）。

7. 装饰器

在函数调用前后自动打印日志，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

# 装饰器
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log  # 把@log放到now()函数的定义处，相当于执行了语句now = log(now)
def now():
    print("20180817")
f = now
print(f())
print(f.__name__)
print('+' * 50)

# 一个完整的decorator
import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def now():
    print("20180817")
f = now
print(f())
print(f.__name__)
print('+' * 50)

# 或者针对带参数的decorator
import functools
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print("20180817")
f = now
print(f())
print(f.__name__)

结果如下：
call now():
20180817
None
wrapper
++++++++++++++++++++++++++++++++++++++++++++++++++
call now():
20180817
None
now
++++++++++++++++++++++++++++++++++++++++++++++++++
execute now():
20180817
None
now

# 这里介绍一下装饰器的应用案例
# 请设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：
def metric(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kw):
        startTime = time.time() # 记录函数运行前的时间
        result = fn(*args, **kw) # 执行函数，同时保留返回值
        endTime = time.time() # 记录函数运行后的时间
        print('%s executed in %s ms' % (fn.__name__, endTime-startTime))  # 输出装饰器的内容
        return result # 返回函数的执行结果
    return wrapper

@metric
def fast(x, y):
    time.sleep(0.0012)
    return x + y;

@metric
def slow(x, y, z):
    time.sleep(0.1234)
    return x * y * z;

f = fast(11, 22)
s = slow(11, 22, 33)
if f != 33:
    print('测试失败!')
elif s != 7986:
    print('测试失败!')

结果如下：
fast executed in 0.002000093460083008 ms
slow executed in 0.12400007247924805 ms

引用：
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014318435599930270c0381a3b44db991cd6d858064ac0000

8. Python常见错误

（1）"SyntaxError"表示语法错误；
（2）“TypyError：str’ object is not callable”:漏写了字符串和变量之间的%；
（3）“TypyError：not all arguments converted during string formatting.”错误原因是你的字符串里的%格式化字符串数量比后面给的变量多；
（4）“Syntax：EOL while scanning string literal”错误是字符串结尾忘加引号了；