Function(函数)

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 2.3k | 阅读时长 ≈ 9
Function(函数)

10

Function介绍

  Python中的Function一种重要的调用方式，和C/C++类似，通过参数的传递和数据的返回完成所预期的目的。

Python内建Function

Python进制转换函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = 100

# bin(x) 对x用二进制字符串表示
bin_a = bin(a)

# oct(x) 对x用八进制字符串表示
oct_a = oct(a)

# hex(x) 对x用十六进制字符串表示
hex_a = hex(a)

# int(x, mode) 2 <= mode <= 36，将x转换为mode进制
int(bin_a, 2)
int(oct_a, 8)
int(hex_a, 16)

112

Python求和函数，最大值最小值函数

1
2
3
4
5
6
7
8
9
10
11
# sum(iterable) 对于列表，元组， 集合来说sum是指所有元素之和，前提是元素可以求和，对于字典来说sum是指关键字Key求和
sum({1, 2, 3, 4})
sum({1:11, 2:22, 3:33, 4:44})

# max(iterable) 用法同sum，求元素的最大值
max({1, 2, 3, 4})
max({1:11, 2:22, 3:33, 4:44})

# min(iterable) 用法同sum，求元素的最小值
min({1, 2, 3, 4})
min({1:11, 2:22, 3:33, 4:44})

60

Python长度函数

1
2
3
4
# len(iterable) 求可迭代对象的长度，即其中包含的元素个数
len([1, 2, 3, 4])
len((1, 2, (3, [4, 5]), 6))
len({1:11, 2:22, 3:33, 4:44})

61

Python排序函数

1
2
3
4
5
6
7
8
9
10
a = [1,5,3,2,4]
b = {1:11, 5:55, 3:33, 2:22, 4:44}
c = [(1, 5), (4, 8), (3, 7), (2, 9)]

# sorted(iterable, key, reverse=False) 对可迭代对象按照key进行排序，如果对字典进行排序则对其关键字进行排序，reverse为True指从大到小排序，默认为从小到大排序
sorted(a)
sorted(b)
sorted(c)
sorted(c, key=lambda x:(x[1], x[0]))
sorted(c, key=lambda x:(x[1], x[0]), reverse=True)

62

Python翻转函数

1
2
3
4
5
6
7
a = [1,5,3,2,4]
b = [(1, 5), (4, 8), (3, 7), (2, 9)]

# reversed(iterable) 返回翻转后的迭代器对象，可以用list，tuple等进行转换，字典无法进行翻转操作
reversed(a)
list(reversed(a))
tuple(reversed(b))

63

Python枚举函数

1
2
3
4
5
6
7
8
9
10
a = [1,5,3,2,4]
b = {1:11, 5:55, 3:33, 2:22, 4:44}
c = [(1, 5), (4, 8), (3, 7), (2, 9)]

# enumerate(iterable) 返回从0开始枚举的迭代器对象，可以用list，tuple等进行转换，对字典枚举则对其关键字进行枚举
reversed(a)
enumerate(a)
list(enumerate(a))
list(enumerate(b))
tuple(enumerate(c))

64

Python打包函数

1
2
3
4
5
6
7
8
a = [1,5,3,2,4]
b = {1:11, 5:55, 3:33, 2:22, 4:44}
c = [(1, 5), (4, 8), (3, 7), (2, 9)]

# zip(iterable1, iterable2) 将两个迭代器对象打包，合并成一个迭代器对象，打包元素按照元素数量少的进行打包，对字典打包则对其关键字进行打包
zip(a, b)
list(zip(a, b))
tuple(zip(a, c))

65

Python删除函数

1
2
3
4
5
6
a = True
b = [1,5,3,2,4]

# del obj 将obj删除，不存在该对象
del a
del b

66

Python中input函数

1
2
# input() 从标准输入中读取一行文本，返回该内容的字符串
str = input('请输入:')

87

Python中print函数

1
2
3
# print(obj1, obj2, ..., end='\n') 将obj1, obj2, ...按顺序输出，以空格分开，end是输出后的结尾字符，默认为换行符
print([1, 2, 3], (4, 5, 6))
print('hello world' + '\n' + 'hello python ', end='end')

84

Python推导式

1
2
3
4
5
6
7
8
9
10
11
a = [1, 2, 3, 4, 5]

# [x for x in iterable] 从iterable中逐一获取元素，并生成列表
[2 ** x for x in a]
[[i + j * 3 for i in range(3)] for j in range(3)]

# {x for x in iterable} 从iterable中逐一获取元素，并生成集合
{2 ** x for x in a}

# {x: y for x in iterable} 从iterable中逐一获取元素，并生成字典
{x: 2 ** x for x in a}

67

Python中lambda表达式

1
2
3
# lambda arg1, arg2: function 一行表达式简单实现函数，参数为arg1, arg2, ...，函数体为function
f = lambda x, y: x * y
f(3, 4)

68

Python中filter函数

1
2
3
4
5
6
# filter(function or None, iterable) 若第一个参数为None则返回iterable中为真的元素，并生成迭代器对象，若第一个参数为function，则将iterable中的每个元素带入函数，将为真的元素生成迭代器对象
filter(None, [x % 3 for x in range(10)])
list(filter(None, [x % 3 for x in range(10)]))

filter(lambda x: x % 3, range(10))
list(filter(lambda x: x % 3, range(10)))

69

Python中map函数

1
2
3
4
5
6
7
8
9
a = '12345'
f = lambda x: 2 ** x

# map(function, iterable) 将iterable中的元素带入函数，返回函数生成的迭代器对象
map(int, a)
list(map(int, a))

map(f, range(5))
tuple(map(f, range(5)))

70

Python自定义Function

Python中def定义函数

1
2
3
4
5
6
7
8
9
10
11
# 定义名为function_name的函数，形式参数为arg1, arg2, ...，函数体为function，返回值为value(可以无返回值)，与C/C++不同，可以有多个返回值
# def function_name(arg1, arg2, ...): 
#     function
#     return value

def my_pow(a, b):
    return a ** b, b ** a

# function_name(x1, x2, ...) 调用名为function_name的函数，实际参数为x1, x2, ...，调用时将实参本身传递到形参，可以按顺序传入参数或者手动指定参数
c, d = my_pow(3, 4)
e, f = my_pow(b=4, a=3)

71

Python函数的默认参数

1
2
3
4
5
6
# def function_name(arg1, arg2=x) 设置函数的默认参数为arg2，其值为x，调用时如果没有赋值则赋值为x，注意默认参数只能放在非默认参数之后
def my_pow(a, b=2):
    return b ** a

a = my_pow(5)
b = my_pow(3, 3)

81

Python函数的收集参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# def function_name(*args) 将所有的参数都打包起来，调用时传入多少个都可以，都生成一个元组，如果没有传入参数则是一个空元组。

def my_func(*par):
    print(par)
    print('参数的个数为:', len(par))

my_func(1, 2, [3, 4], '56', {7, 8, 9})

# def function_name(**kwargs) 将所有的参数都打包起来，调用时传入多少个都可以，都生成一个字典，传入参数时必须使用键值对的形式，如果没有传入参数则是一个空字典。

def my_func(**par):
    print(par)
    print('参数的个数为:', len(par))

my_func(a=1, b=2, c=[1, 2])

82

Python星号的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 用作运算符，一个星号代表乘法，两个星号代表乘方
a, b = 2, 3
a * b
a ** b

# 定义函数时表示收集，*args表示将位置参数都装入元组args中，**kwargs表示将位置参数都装入字典kwargs中
def test(*args, **kwargs):
  print(args[0])
  print(kwargs['a'])

test(1, 2, 3, a='aa', b='bb')

# 调用函数时表示分散，*L表示将可迭代对象中的每个元素作为位置参数传入，**D表示将字典的键值对作为位置参数传入
def test(a, b, c):
  print(a)

L = [1, 2]
D = {'c': 3}
test(*L, **D)

110

Python函数的全局变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 在函数中使用和外部名称相同的变量时，会建立一个同名的局部变量，即使修改了其值，也只是修改了局部变量额值，函数调用完毕后，外部的变量仍然没有被修改
a = 10

def my_func():
    a = 5
    print(a)

my_func()
print(a)

# 如果想在函数中修改外部变量的值，则需要将其声明为全局变量，和C/C++不同，C/C++是在定义时将变量声明为全局，而Python中是在外部先定义，然后在函数内部使用关键字global将其声明为全局
a = 10

def my_func():
    global a
    a = 5
    print(a)

my_func()
print(a)

83

Python函数的非局部变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# nonlocal关键字修饰变量后标识变量是上一层函数中的局部变量，对变量进行修改就是修改上一层函数中的局部变量，如果上一层函数中不存在同名的局部变量，则会报错，经常用于闭包和装饰器中，有关闭包和装饰器的相关知识可以参考我的另一篇博客Closure & Decorators(闭包和装饰器)。
def decorators(func):
  a = 1
  print("正在装饰")
  print("外层局部变量a的值为: ", a)
  def wrapper():
    func()
    nonlocal a
    a += 1
    print("内层局部变量a的值为: ", a)
  return wrapper

@decorators
def say():
  print("hello world!")

111

Python内嵌函数

1
2
3
4
5
6
7
8
9
# 在函数内部可以定义另一个函数，这样外部函数无法调用该函数，仅仅能在定义该函数的函数中使用，这样可以使主程序更加清晰。内嵌函数的使用频率较低，了解即可。
def test1():
    print('This is test1')
    def test2():
        print('This is test2')
    test2()

test1()
test2()

104

Python偏函数

1
2
3
4
5
6
7
8
9
# 偏函数是指对函数参数中默认值的控制
# functools模块中有一个partial方法，可以完成对默认值的控制
# new_func = functools.partial(old_func, para=x) 将原函数old_func中的para参数固定为x
import functools

a = int('1010', base=2)

int2 = functools.partial(int, base=2)
b = int2('1010')

107

Function小结

  Function函数是计算机语言中一种重要的调用方式，无论是在何种语言中，函数的使用都是至关重要的，有了函数可以使代码更加整洁和清晰，模块与模块之间达到高内聚低耦合，大大提高代码的可读性。可以节省大因此使用的频率非常高，所以要灵活掌握Function的应用。

-------------本文结束感谢您的阅读-------------
0%