当前位置： 移动技术网 > IT编程>脚本编程>Python > 荐 Python从0到1之函数

荐 Python从0到1之函数

2020年07月08日  | 移动技术网IT编程  | 我要评论

定义

函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要 的位置调用这个名称即可完成对应需求，可以更高效的实现代码重用
Python中函数必须先定义后使用，如果先调用会报错,如果没有调用函数，函数里面的代码不会执行，当调用函数时，解释器会回到定义函数的地方执行函数中代码，函数代码执行完，回到调用函数的地方继续向下执行

函数定义格式
def function_name():
pass

def count(a,b):
    return a + b
print(count(1,2)) # 3

说明文档

说明文档就是对函数功能的解释说明

def count(a,b):
    """求2个数相加的和"""
    return a + b
# 查看说明文档
help(count) # count(a, b) 求2个数相加的和
count.__doc__ # '求2个数相加的和'

参数

函数的参数可有可无
定义的时候是形参，调用的时候是实参
return 作用：负责函数返回值，退出当前函数，return下方代码都不执行

def count(a,b):
    return a + b
print(count(1,2)) # 3

定义函数同时定义了接收用户数据的参数a和b, a和b是形参
调用函数时传输人真实数据1和2，真实数据为实参

无参数

def testA():
    print("hello world")
testA() # hello world

位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数
传递和定义参数的顺序和个数必须一致

def user_info(name,gender,age):
    print(f"我的姓名是{name}性别是{gender}年龄是{age}")

user_info("张三","男",18) # 我的姓名是张三性别是男年龄是18

关键字参数

关键字参数函数调用时，通过键=值得形式加以指定，可以让函数更加清晰，容易使用，同时也清除了参数的顺序需求
关键字参数 如果有位置参数，位置参数要在关键字参数前，关键字参数之间不存在 先后顺序

def user_info(name,gender,age):
    print(f"我的姓名是{name}性别是{gender}年龄是{age}")

user_info("张三",gender="男",age=18) # 我的姓名是张三性别是男年龄是18

默认参数

默认参数也叫缺省参数，用于定义函数，为参数提供默认值，调用函数时可不传默认参数的值
位置参数必须在默认参数前，包括函数的定义和调用

def user_info(name,age,gender="男"):
    print(f"我的姓名是{name}性别是{gender}年龄是{age}")

user_info("张三",age=18) # 我的姓名是张三性别是男年龄是18
user_info("张三",18,"女") # 我的姓名是张三性别是女年龄是18

可变参数

可变参数也叫不定长参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景，此时可以用包裹位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便

包裹位置参数

*args可变参数包裹位置，元组类型

def user_info(*args):
    print(args)

user_info() # ()
user_info("张三") # ('张三',)
user_info("张三","男",18) # ('张三', '男', 18)

包裹关键字参数

**kwargs 可变参数包裹关键字，字典类型

def user_info(**kwargs):
    print(kwargs)

user_info() # {}
user_info(name="张三") # {'name': '张三'}
user_info(name="张三",gender="男",age=18) # {'name': '张三', 'gender': '男', 'age': 18}

返回值

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None
函数有2个return，只执行第一个return，return可以退出当前函数，导致return下方 的代码不执行

def return_num():
    return 1
    return 2

return_num() # 1

函数有多个返回值，也可以直接写出，也可以组成列表，元组、字典返回多个值

def return_num():
    return 1,2

return_num() # (1, 2)
def return_num():
    return [1,2]

return_num() # [1, 2]

变量作用域

变量作用域是指变量生效的范围，主要分两类局部变量和全局变量

全局变量

是指函数体内、外都能生效的变量

a = 100
print(a) # 100
def testA():
    print(a)
def testB():
    print(a)

testA() # 100
testB() # 100

global

修改全局变量

a = 100

def testA():
    global a
    a = 200
    print(a)

print(a) # 100
testA() # 200
print(a) # 200

局部变量

局部变量是定义在函数体内部的变量，即只在函数体内部生效
作用：在函数内部，临时保存数据，当函数调用完成后销毁局部变量

def testA():
    x = 100
    print(x)

testA() # 100
print(x) # NameError: name 'x' is not defined

执行流程

函数嵌套 一个函数里面调用了另外一个函数

def testB():
    print("B开始")
    print("B结束")
def testA():
    print("A开始")
    testB()
    print("A结束")

testA() # A开始\nB开始\nB结束\nA结束

lambda

如果一个函数只有一个返回值，并且只有一句代码，可以使用lambda简化
lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
lambda函数能接收任何数量的参数，但只能返回一个表达式的值
lambda 参数列表：表达式/返回值

f = lambda : 100
# 直接打印lambda表达式，输出的是lambda的内存地址
print(f) # <function <lambda> at 0x108b77320>
print(f()) # 100

参数

无参数

f = lambda : 100
f() # 100

位置参数

f = lambda a : a
f(20) # 20s

默认参数

默认参数如果是可变类型，那么所有的默认值调用都会操作内存中同一个变量的值，不建议使用可变类型作为默认参数值

f = lambda a,b=20:a+b
f(1) # 21
f(1,2) # 3

可变参数

包裹位置参数

*args

f = lambda *args:args
f(1) # (1,)
f(1,2) # (1, 2)

包裹关键字参数

**kwargs

f = lambda **kwargs:kwargs
f(a=1) # {'a': 1}
f(a=1,b=2) # {'a': 1, 'b': 2}

lambda应用

带判断的lambda

f = lambda a,b:a if a > b else b
f(1,2) # 2

排序

sort(key = lambda…,reverse = bool数据)

students = [{'name':'Tom','age':20},{'name':'Rose','age':19},{'name':'Lily','age':18}]
# 按name升排序
students.sort(key=lambda x:x["name"])
students # [{'name': 'Lily', 'age': 18}, {'name': 'Rose', 'age': 19}, {'name': 'Tom', 'age': 20}]
# 按name降排序
students.sort(key=lambda x:x["name"],reverse = True)
students # [{'name': 'Tom', 'age': 20}, {'name': 'Rose', 'age': 19}, {'name': 'Lily', 'age': 18}]
# 按age升排序
students.sort(key=lambda x:x["age"])
students # [{'name': 'Lily', 'age': 18}, {'name': 'Rose', 'age': 19}, {'name': 'Tom', 'age': 20}]

高阶函数

高阶函数 把函数作为参数传入,高阶函数时函数式编程的体现，减少代码重复，开发速度快

map()

map(func,lst),将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新 的列表（Python2）/迭代器（Python3）返回

def func(x):
    return x**2

list(map(func,[2,3])) # [4, 9]

reduce()

educe(func(x,y),lst),函数会对参数序列中元素进行累加
其中func必须有2个参数，每次func计算的结果继续和序列的下一个元素做累计计算
注意：reduce()传入的参数func必须接收2个参数

import functools
def func(a,b):
    return a + b
    
functools.reduce(func,[1,2,3]) # 6

filter()

filter(func,lst) 函数用来过滤序列，过滤掉不符合条件的元素，返回一个filter() 对象，如果要转换为列表，可以用list()转换

def func(x):
    return x % 2 == 0

list(filter(func,[1,2,3,4,5])) # [2, 4]

递归

函数内部自己调用自己，必须有出口
递归是一种编程思想，应用在堆排序、汉诺塔、图的深度遍历

# 求累加和
def sum_num(num):
    if num == 1:
        return 1
    return num + sum_num(num-1)

sum_num(3) # 6
sum_num(100) # 5050

深浅拷贝

Python中，值是靠引用传递的
直接赋值：其实就是对象的引用（别名）

a = 10
b = a
id(a) # 4438367440
id(b) # 4438367440

浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象,引用拷贝

l = [1,2,[3,4]]
m = l.copy()
id(l[2]) # 4443010784
id(m[2]) # 4443010784

深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。值拷贝

import copy
l = [1,2,[3,4]]
m = copy.deepcopy(l)
id(l[2]) # 4442942592
id(m[2]) # 4442113680

重载

方法名一样，参数个数或类型不一样的实现叫重载
Python 中没有重载，因为变量不限定类型

本文地址：https://blog.csdn.net/pyhacker/article/details/107163569

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网