Python函数基础

目录

• 函数的定义
  • 1.函数的三种定义方式
  • 2.函数的调用
  • 3.函数的返回值
  • 4.函数的参数
• 可变长参数
• 函数的对象
• 名称空间和作用域

函数的定义

'''
def 函数名():  # 定义阶段(造车轮阶段)
    """函数注释写在这里"""  # 函数相当于工具, 注释相当于工具的说明书
    <代码块>

# 使用  # 调用阶段(开车阶段)
函数名()
'''

1.函数的三种定义方式

# 参数,未知数,变量
# 1.无参函数 # 工具可以单独使用
def add():
    """无参函数"""
    x = input('num1:')
    y = input('num2:')

    print(int(x) + int(y))


# 2.有参函数
def add(x, y):  # 我这个工具不能单独使用,必须得加个配件,才能使用
    """有参函数"""
    print(int(x) + int(y))


print(1)
x = input('num1:')
y = input('num2:')
add(x, y)


# 3.空函数: 定义了函数,啥都没有
def func():  # 只知道工具叫什么名字,但不知道如何造出这个工具
    pass

2.函数的调用

def add(x, y):
    return x+y


res = add(10, 20)  # 函数的调用
print(res*12)

3.函数的返回值

def add(x, y):
    # return (x, y, x + y)  # return可以返回任意数据类型
    return x, y, x + y  # return可以返回任意数据类型,不加括号返回多个值时,默认用元祖的形式返回


x,y,z = add(1, 2)
print(x,y,z)

4.函数的参数

def add(num1, num2):  # 形参
    """有参函数"""
   print(int(num1) + int(num2))

add(1, 2)  # 实参


# 形参: 定义阶段才有形参,形式参数,啥也没用,只是占个位置,具有描述意义
# 实参: 调用阶段才有实参,实际的参数,具有具体的值

# 位置形参: 一个一个的写形参,就叫位置形参
def add(num1, num2):  # 形参
    """有参函数"""
    print(num1)
    print(num2)
    print(int(num1) + int(num2))

# 位置实参: 一个一个写过去,就叫位置实参
# add(1, 2)  # 实参

# 两个位置形参,就必须得要两个位置实参对应,从左到右一一对应

# 默认形参: 不需要传参,可以使用默认值; 传参就使用你传的值, 默认形参必须放到位置形参后面
def shopping(name='nick'):  # 形参经常会引用同一个值
    goods_dict = {1: '特斯拉', 2: '奔驰', 3: 'nick'}
    print(f'恭喜你这个小钢炮{name},得到{goods_dict[1]}一个')

shopping('yongjiu')


# 关键字实参: 按照形参名给定具体的值,可以打破位置形参必须得一一对应传值的规定,位置实参必须在关键字实参之前
def shopping(x, name='nick'):
    goods_dict = {1: '特斯拉', 2: '奔驰', 3: 'nick'}
    print(f'恭喜你这个小钢炮{name},得到{goods_dict[x]}一个')


shopping(1, name='yongjiu')

# 函数的参数尽量不要超过3个


# 需要的用的时候用,一般用位置形参+位置实参

可变长参数

# 形参
## 位置形参
## 默认形参

# 实参
## 位置实参
## 关键字实参

# 牢记
# 可变长参数之*
def func(name, pwd, *args):  # *abc会接收多余的位置实参,尽量不要使用abc,而应该使用args,args是约定俗称
	print('name:', name, 'pwd:', pwd)
	print(args)  # args就会接收多余的位置实参
	return 1

# 可变长参数之**
def func(name, pwd, **kwargs):
	print('name:', name, 'pwd:', pwd)
	print(kwargs)  # kwargs会接收多余的关键字实参,以字典形式存储
	return 1

res = func('nick', 123658, age=18, height=180)  # 'age':18
print(res)


# 可变长参数*和**联用

# 可变长参数之**
def func(name, pwd, *args, **kwargs):
	print('name:', name, 'pwd:', pwd)
	print(args)
	print(kwargs)  # kwargs会接收多余的关键字实参,以字典形式存储
	return 1

	res = func('nick', 123658, 1, 2, 3, 4, age=18, height=180)
	print(res)


# *、**的用法
def func(name, pwd, x, y, z):
	print('name:', name, 'pwd:', pwd)
	print(x, y, z)
	return 1

tup = (4, 2, 3)
res = func('nick', 123658, *tup)  # *会把元祖打散成位置实参传给形参
print(res)


def func(name, pwd, **kwargs):
    print('name:', name, 'pwd:', pwd)
    print(kwargs)
    return 1

dic = {'a': 1, 'b': 2}  # **dic  --> a=1 , b=2
res = func('nick', 123658, **dic)  # **会把字典打散成关键字实参传给形参
# res = func('nick', 123658, a=1, b=2)  # **会把字典打散成关键字实参传给形参
print(res)

函数的对象

def func():
    print('from func')

# 把函数当做 对象 来用
print(func)  # func指向一块内存地址, 函数名
a = 1
print(a)  # 变量名

# 变量名可以被引用,函数名也可以被引用
b = a  # b =1
f = func  # func可以加()调用,那么f也可以加()调用
print(f, func)
f()  # func()

# 变量名可以放入容器类数据类型
lt = [1, 2, a, func]
lt[-1]()

# 变量名还可以当做参数
def f2(name):  # name = func
    name()  # func()
# f2(a)
f2(func)

# 函数的返回值
def f3(name):  # name = func
    return name  # name = func

res = f3(func)  # res = func
print(res)
res()

# 函数名等同于变量名,即变量名有的方法,函数名同样也有, 被引用 ; 当做容器元素 ; 当做函数参数 ; 当做函数返回值

# 函数的嵌套
def func1():
    def func2():
        pass

名称空间和作用域

def f1():    
	x = 1
	print('from f1')
	def f2():
		print('from f2')
		print(x)

# 名称空间和作用域
# 名称空间: 存放名字(变量名/函数名)
# 内置名称空间: python解释器独有的
# 函数调用必须得定义, 从来都没定义过. Python解释器启动的时候python自动开辟内置名称空间存放了这些python的内置方法,python解释器停止解释之后才会销毁

# 全局名称空间: 除了内置和局部,其他的都是全局

# 全局需要自己定义, python文件执行之后才可能有全局名称空间,文件结束之后才会销毁

# 局部名称空间: 函数内定义的变量名/函数名都存放在局部名称空间

# 局部也需要自己定义, 必须得在函数调用之后才会生成, 调用结束之后就会销毁

# 三种名称空间的执行顺序: 内置 --> 全局 --> 局部

# 三种名称空间的查找顺序: 首先从自己当前位置开始 --> 局部 --> 全局 --> 内置

# 作用域: 产生作用的范围

# 全局作用域: 全局+内置名称空间中的变量,全局作用域中的变量只能在全局中使用

#局部作用域: 局部名称空间中的变量,局部作用域中的变量只能在局部中使用

# 声明x为全局变量
global x

# 建议使用

# lt = [1,2,3]  # 作用域关系仅适用不可变数据类型,不适用于可变数据类型
# def f1():
#     lt.append(4)
# f1()
# print(lt)