【Python】进阶语法

一、异常捕获

a = 1
b = '2'

try:
    print('运算开始')
    print(a + b)
except Exception as e:
    print('运行报错')
    print(e)
else:
    print('未出现异常')
finally:
    print('运行完毕')

二、数据结构

列表 []：无类型限制

元组 ()：无类型限制，不可修改

集合 {}：无序，自动排序

字典 {}：{}的默认类型

_list = [10, 20, 3, 8, 11]
_list.sort()
print(_list)
_list.sort(reverse=True)    #降序
print(_list)

_list = ['a', 'hello', '1', 2, 'b']
try:
    _list.sort()
    print(_list)
except Exception as e:
    print('出现异常')
    print(e)

_list = ['hello', 'world', 'nihao', 'a', 'c', 'b']
print(_list)
_list.reverse()     # 逆置
print(_list)

_list.clear()   # clear可用于清空列表/元组/集合/字典
print(_list)

_list = [1, 2, 3]
_list *= 3
print(_list)
# 元组也可进行乘法，不过会进行重构

四、迭代器

# 1 2 3 4 这四个数字可以组成多少个各个位数不同的数字
count = 0
_list = [1, 2, 3, 4]
for i in _list:
    for j in _list:
        for k in _list:
            for l in _list:
                if len({i, j, k, l}) == 4:
                    sum = i * 1000 + j * 100 + k * 10 + l
                    print(sum, end=' ')
                    count += 1
print(f'\ncount = {count}')

x = 'python'
y = iter(x)
print(y)
print(next(y, '已经迭代结束了'))
print(next(y, '已经迭代结束了'))
print(next(y, '已经迭代结束了'))
print(next(y, '已经迭代结束了'))
print(next(y, '已经迭代结束了'))
print(next(y, '已经迭代结束了'))
print(next(y, '已经迭代结束了'))   #防报错
print(next(y, '已经迭代结束了'))
print(next(y, '已经迭代结束了'))

五、拆包、聚合、映射

# 拆包
i, j, k, l = [1, 2, 3, 4]
print(i, end=" ")
print(j, end=" ")
print(k, end=" ")
print(l)

# 聚合, 短板效应
x = [1, 2]
y = [1, 2, 3]
z = ['hello', 'world', '!']
print(zip(x, y, z))
for e in zip(x, y, z):
    print(e)

# 映射
x = [2, 3, 10]
y = [5, 2, 2]
a = map(pow, x, y)  # pow()幂函数，pow(2, 5), pow(3, 2), pow(10, 2)
for e in a:
    print(e)

六、filter()函数

filter()函数：筛选出符合某个函数的数据

函数会根据 提供的函数对指定的可迭代对象的每个元素进行遍历

将遍历的运算结果为真的元素，以迭代器的形式返回

def Even(n):
    return n % 2 == 0

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = list(filter(Even, a))
print(b)    # [2, 4, 6, 8, 10]

七、random随机数

import random

a = random.randint(1, 100)  # 生成[1, 100)之间的随机整数
b = random.uniform(1, 100)  # 生成[1, 100)之间的随机浮点数
print(a, b)

八、闭包

def func():
    name = 'python'
    def inner():
        print('hello world')
        return name
    return inner

f = func()
f()     # hello world

print(f())
# hello world
# python

九、匿名函数

lambda是匿名函数关键字

func = lambda x, y : x + y
print(func(2, 5))   # 7

func = lambda x : x if x % 2 == 0 else None
print(func(4))      # 4
print(func(5))      # None

十、装饰器

闭包：本质也是函数，参数和返回值都是函数，对函数进行增强

语法糖：没有增加新功能，对语言没影响，更方便程序员使用

import time

def CountTimeWrapper(func):
    #闭包
    def ImproveFunc(*args, **kwargs):   # 增强函数应该把接收到的参数传给原函数
        start_time = time.perf_counter()
        ret = func(*args, **kwargs)     # 传入参数并记录返回值
        end_time = time.perf_counter()
        print(f'函数的执行时间为{end_time - start_time}')
        return ret
    return ImproveFunc

@CountTimeWrapper       # @闭包函数名，就是装饰器，自增强一次
def PrintOdds(lim=100):
    cnt = 0
    for i in range(lim):
        if i % 2 == 0:
            cnt += 1
    return cnt

if __name__ == '__main__':
    # PrintOdds = CountTimeWrapper(PrintOdds)
    # 装饰器等价于在第一次调用时执行上面语句
    print(PrintOdds())