七叶笔记 » golang编程 » Python 函数、高级语法和用法

Python 函数、高级语法和用法

分类: golang编程 | 浏览: 246

1. 什么是python函数以及如何定义一个函数

函数是组织好的，可重复使用的，用来实现单一或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。 

 # 函数
def function(param):
    pass
    return 'this is function'
result = function('param')
print(result)

2. 函数使用

参数说明：参数 函数里面参数：行参 调用函数里面参数：实参

函数返回多个结果，优雅的接受参数 

 # 函数返回多个结果，优雅的接受参数
def function1(param1, param2):
    param1 = param1 * 3
    param2 = param2 * 2 + 20
    return param1, param2
param1, param2 = function1(2, 3)
print(param1)
print(param2)

指定参数（无参、必须参数、指定实参、默认参数、可变参数） 

 # 无参
def function1():
    print(' 没有参数 ')
print('无参无return返回结果：' ,function1())
# 指定实参
param1,param2 = function1(param2 = 4, param1 = 2)
print(param1, param2)
# 行参默认值  
# 行参顺序：默认参数在后
def function1(param1=4, param2=4):
    param1 = param1 * 3
    param2 = param2 * 2 + 20
    return param1, param2
param1,param2 = function1()
print(param1, param2)
# 可变参数
def function2(*param):
    print(param)
# 没有*输出结果：((1, 2, 3),)
function2((1,2,3))
function2(*(1,2,3))
# 关键字可变参数
def function3(**param):
    # 返回结果：{'x': 1, 'y': 2, 'z': 3}
    print(param)
    # dict
    print(type(param))
function3(x=1, y=2, z=3)
# 什么都不传返回 {}
function3()

这里需避坑 

 # 避坑 必须参数 > 可变参数 > 默认参数
def function3(param1, *param3, param2=2):
    print('必须参数：', param1)
    print('可变参数：', param3)
    print('默认参数：', param2)
# param1 = str,param3 = 1,2,3,param2 = param
function3('str', 1, 2, 3, 'param')
# 输出结果：必须参数： str ，可变参数： (1, 2, 3, 'param') ，默认参数： 2 不符合预期
function3('str', 1, 2, 3, param2='param')

3. Python 函数式编程

函数本身可以赋值给变量（即变量可以指向函数）。而其实函数名本身就是指向函数的变量。

一个函数可以接受另一个函数作为参数。这种函数称为高阶函数，例如以下几个例子：

3.1 lambda 表达式 – 匿名函数 

 # 匿名函数
function = lambda x, y: x + y
print(function(1,2))

3.2 map与lambda

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

 # map 使用
# 求arr每个元素平方
arr = [1, 2, 3, 4, 5, 6, 7, 8]
def square(x):
    return x * x
result = map(square, arr)
print(list(result))
# lambda 与 map 一起使用
result1 = map(lambda x: x * x, arr)
print(list(result1))
# lambda 与 map 一起使用 多个参数; 如果arr与arr1个数不同，只计算到最少个数，如下arr1个数比arr少 只会返回 5个元素，反之 arr个数比arr1少 只会计算到arr个数位
arr1 = [1, 2, 3, 4, 5, 6]
result2 = map(lambda x, y: x * x + y, arr, arr1)
print(list(result2))

列表推倒式，适用于：list、dict、tuple、set 

 # 列表推导式 - list
arr = [1, 2, 3, 4, 5, 6, 7, 8]
result = [x * x for x in arr]
print(result)
# 添加条件判断(x指下标)
result1 = [x * x for x in arr if x >=4]
print(result1)
# 列表推导式 - dict
sex = {
    0 : '男',
    1 : '女',
    2 : '中性'
}
result2 = {value:key for key,value in sex.items()}
print(result2)

3.3 reduce 连续计算数据

使用reduce 引入functools库 

 from functools import reduce
# reduce 使用：必须有两个参数
# reduce 作用：连续的计算，只会得到一个结果
arr = [1, 2, 3, 4, 5, 6, 7, 8]
result = reduce(lambda x, y: x + y, arr)
# 计算如下：（（（（1 + 2） + 3） + 4） + 5）... + 6 + 7 + 8
print(result)
# reduce 第三个参数，起始值
result1 = reduce(lambda x, y: x + y, arr, 14)
# 计算如下：14 +（（（（1 + 2） + 3） + 4） + 5）... + 6 + 7 + 8
print(result1)

3.4 filter 过滤数据

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

 # filter 使用 第一参数必须返回bool
arr = [1, 0, 0, 1, 1, 4, 0, 5]
result = filter(lambda x:True if x==1 else False, arr)
print(list(result))

3.5 装饰器

装饰器本质是一个Python函数，它可以让其它函数在没有任何代码变动的情况下增加额外功能。有了装饰器，我们可以抽离出大量和函数功能本身无关的雷同代码并继续重用。经常用于具有切面需求的场景：包括插入日志、性能测试、事务处理、缓存和权限校验等 

 # 装饰器
# func指函数
def decorator(func):
    def wrapper(*args, **kwargs):
        # 执行函数内部逻辑 打印时间
        print(time.time(), args, kwargs)
        # 执行调用函数中逻辑 打印不同参数
        func(*args, **kwargs)
    return wrapper
# 一个参数
@decorator
def function(param):
    print('function : this is decorator ' + param)
# 两个参数
@decorator
def function1(param1, param2):
    print('function1 : this is decorator ' + param1)
    print('function1 : this is decorator ' + param2)
# 三个参数（可变参数）
@decorator
def function2(param1, param2, **kwargs):
    print('function2 : this is decorator ' + param1)
    print('function2 : this is decorator ' + param2)
    print(kwargs)
function('param')
function1('param1' , 'param2')
function2('param1' , 'param2', x=1,y=2,z=3)

4. Python 高级语法和用法

4.1 海象运算符 3.8以上

它的英文原名叫 Assignment Expressions ，翻译过来也就是 赋值表达式 ，不过现在大家更普遍地称之为海象运算符，就是因为它长得真的太像海象了。

1.第一个用法：if/else

若在 Python 3.8 之前，Python 必须得这样子写

但有了海象运算符之后，你可以和 Golang 一样（如果你没学过 Golang，那这里要注意，Golang 中的 := 叫短变量声明，意思是声明并初始化，它和 Python 中的 := 不是一个概念） 

 # 海象运算符 :=
str = 'Python'
if len(str) > 5:
    print('str 长度大于5，str长度为：', len(str))
# 等同于
if (x:=len(str)) > 5:
    print(f'str 长度大于5，str长度为：{x}')

4.2 枚举 

 from enum import Enum
from enum import IntEnum,unique
# 定义枚举类
class PEOPLE(Enum):
    YELLOW_RACE = '黄种人'
    WHITE_PERSON = '白种人'
    BLACK_RACE = '黑种人'
    DEFULT = 0
# 定义int类型枚举类 @unique value指相同会报错
@unique
class PEOPLE1(IntEnum):
    YELLOW_RACE = 0
    WHITE_PERSON = 1
    BLACK_RACE = 2
# 枚举取值
print(PEOPLE.YELLOW_RACE.name, ' : ',PEOPLE.YELLOW_RACE.value)
# 遍历枚举
for item in PEOPLE:
    print(item.name, ' : ', item.value)

Enum不仅可以是一个好的枚举也可以拿来代替一些繁琐的类、状态、顺序等东西。比如说：`life = Enum(‘life’, ‘born baby teenager adult older die’)。

相关文章