Python中的函数

Python中的函数

 函数的基本结构

函数的定义

def 函数名():
    # 函数内容
    pass

# 函数的执行
函数名()

无参函数

# 定义函数
def func():
    print('hello saiya')


# 执行函数
func()

hello saiya

有参函数

# 定义函数
def func(name):
    print('hello', name)


name = 'saiya'
# 执行函数
func(name)

hello saiya

返回值

# 无返回值的函数
def func():
    print('hello saiya')


# 有返回值的函数
def test(name):
    return name


name = 'saiya'
result = test(name)
print(result)

saiya

 函数的参数

参数的定义

# 定义位置参数
def func1(name, age):
    pass


# 定义有默认值的参数
def func2(name='saiya', age=23):
    pass


# 定义万能的位置参数，不限制数量
def func3(*args):
    print(args)


# 定义万能的关键字参数，传参的方式必须是key=value的形式
def func4(**kwargs):
    print(kwargs)


func3('saiya', 23, 'man')
func4(name='saiya', age=23, sex='man')

('saiya', 23, 'man')
{'name': 'saiya', 'age': 23, 'sex': 'man'}

传参方式

1. 位置传参

def func(name, age):
    print(name, age)


name = 'saiya'
age = 23
func(name, age)  # 位置传参，传入的时候在第几位，接收时就在第几位

saiya 23

2. 关键字传参

def func(name, age):
    print(name, age)


func(age=23, name='saiya')  # 关键字传参，指定将值传给哪个参数

saiya 23

3. 默认值传参

def func(name='saiya', age=23):
    print(name, age)


func(age=25)  # 默认传参， 有值就使用传入的值，没有则使用默认参数

saiya 25

 函数的作用域

函数自己的作用域

def func():
    name = 'saiya'
    print(name)  # 函数自己作用域内的变量


func()

saiya

函数父级以上的作用域

当函数本身的作用域找不到变量时，会往父级的作用域查找变量，一直查找到全局的作用域

name = 'saiya'


def func():
    print(name)  # name是全局作用域内的变量


func()

saiya

 函数的高级用法

函数作为变量来使用

def func():
    print('saiya06')


test = func  # 将函数赋值给变量
test()  # 变量当作函数来执行

函数作为参数来使用

def func(arg):
    arg()


def show():
    print('saiya')


func(show)

saiya

函数作为返回值使用

def func():
    print('saiya')


def bar():
    return func


test = bar()  # 返回一个函数，赋值给变量
test()  # 执行函数

匿名函数lambdal

func = lambda a: print(a)
func('saiya')

 内置函数

len()

s = 'saiya'
res = len(s)  # 获取长度大小
print(res)

open()

f = open('test.txt', mode='w', encoding='utf-8')  # 打开一个文件
f.write('saiya06')  # 写入数据
f.close()  # 关闭文件

range()

for i in range(5):  # range返回一个范围
    print(i)

数据类型定义或转换函数

a = int(1)  # 等价于 a = 1
b = str('saiya')  # 等价于 b = 'saiya'
c = list([1, 2, 3])  # 等价于 c = [1, 2, 3]
d = dict({'name': 'saiya'})  # 等价于 d = {'name': 'saiya'}
e = tuple((1, 2, 3))  # 等价于 e = (1, 2, 3)

输入输出

name = input("请输入：")
print(name)

数学相关

num = -1
res = abs(num)  # 获取绝对值
print(res)

res = max(5, 8, 16, 2, 9)  # 获取最大值
print(res)

res = min(5, 8, 16, 2, 9)  # 获取最小值
print(res)

res = sum([5, 8, 16, 2, 9])  # 求和
print(res)

res = divmod(9, 2)  # 求商和余数
print(res)

进制转换

num = 108
res = bin(num)  # 将十进制转换为二进制
print(num, '转换成二进制为：', res)

res = oct(num)  # 将十进制转换为八进制
print(num, '转换成八进制为：', res)

res = hex(num)  # 将十进制转换为八进制
print(num, '转换成十六进制为：', res)

num = '0b11011001'
res = int(num, base=2)  # 将其他进制转换为十进制
print(num, '转换成十进制为：', res)

108 转换成二进制为： 0b1101100
108 转换成八进制为： 0o154
108 转换成十六进制为： 0x6c
0b11011001 转换成十进制为： 217

map()

传入两个参数，第一个参数是一个函数，第二个参数是一个可迭代对象
将可迭代对象中的每一个元素，作为参数传给函数
执行函数，将函数的返回值保存到新的列表中

var_list = [11, 22, 33, 44]
result = map(lambda num: num + 100, var_list)
print(list(result))

[111, 122, 133, 144]

filter()

传入两个参数，第一个参数是一个函数，第二个参数是一个可迭代对象
将可迭代对象中的每一个元素，作为参数传给函数
执行函数，如果函数的返回值为True,则将元素保存到新的列表中

var_list = [11, 22, 'sai', 33, 'ya', 44]
result = filter(lambda num: type(num) == int, var_list)
print(list(result))

[11, 22, 33, 44]

 装饰器和生成器

装饰器

1. 无参装饰器

def wrapper(func):
    def inner():
        start_time = time.time()
        v = func()
        end_time = time.time()
        return end_time - start_time
    return inner


@wrapper
def show():
    print('saiya06')
    time.sleep(1)


res = show()
print('执行函数耗时：', res)

saiya06
执行函数耗时： 1.003974437713623

2. 带参数的装饰器

def outer(args):
    def wrapper(func):
        def inner():
            print('装饰器传入的参数是：', args)
            start_time = time.time()
            v = func()
            end_time = time.time()
            return end_time - start_time
        return inner
    return wrapper


@outer('hello')
def show():
    print('saiya06')
    time.sleep(1)


res = show()
print('执行函数耗时：', res)

装饰器传入的参数是： hello
saiya06
执行函数耗时： 1.0066015720367432

生成器

函数内部带有yield关键字的，称为生成器

def func():
    print('F1')
    yield 1
    print('F2')
    yield 2
    print('F3')
    yield 100
    print('F100')


# 执行生成器时，函数内部代码不会执行， 而是返回一个生成器对象
res = func()

# 生成器可以被for循环，一旦开始循环，函数内部的代码就会开始执行
for item in res:
    print(item)