python基础之函数

Posted 2020-11-15 故俗

函数
使用函数的特点 多次调用
 格式： def （关键字）  函数名（变量名一样自己定义）加括号
返回的重要性 return
返回值的三种情况
1.无返回值 只写return：结束一个函数的继续   不写return   return None(最不常用)
2.返回一个值 可以返回任何数据类型，只要返回了就可以接收到
3.返回多个值 多个返回值用多个变量接收，有多少返回值就有多少个变量。  用一个变量接收时得到元组。

def fun1():
    return 1,2
r1,r2=fun1()
print(r1,r2)



s=‘fewgv‘
def my_len(): #定义函数 申明函数
    i=0
    for k in s:
        i+=1
    print(i)
    return i #返回值

my_len()#函数名加括号  函数的调用



def my_len(s): #定义函数 申明函数  自定义函数只需要0个参数  ？？？接收参数  实际参数：实参
#     i=0
#     for k in s:
#         i+=1
#     return i
# s=‘fegreg‘
# x=my_len(s) #传递参数：传参
# x=my_len(‘sdgr‘)
# print(x)


def f1(l1):
    for i in l1:
        print(i)

def f2(l1):
    f1(l1)
    for  i in l1:
        print(i)

f1([1,2,3,4])



参数
1.没有参数：定义函数和调用函数时括号内都不写内容
2.有一个参数：传什么就是什么
3.多个参数:位置参数
站在实参的角度上
1.按照位置传参
2.按照关键字传参
3.混着用可以但是必须先按照位置传参，在按照关键字传参
4.不能给同一个变量传多个值
站在形参的角度上
1.位置参数：必须传，且有几个参数就传几个值
2.默认参数：如果不传就用默认参数，传了就用已经传得参数


只有调用函数的时候
1.按照位置传：直接写参数的值
2.按照关键字：关键字=值

定义函数的时候
1.位置参数：直接定义参数
2.默认参数，关键字参数：参数名=‘默认的值’
3.顺序：必须先定义位置参数，*args,在定义默认
4.动态参数：多少个参数都可以 参数名之前一定要加* 习惯参数名args：接收按照位置传参的值，组成一个元祖
5.**kwargs  返回字典  接收的是按照关键字传参的值，a=25
6.args必须在kwargs前面


动态参数的另外一种传参方式
def lc(*args): #站在形 参的角度上，给变量加上*，就是组合所有传来的值
    print(args)


lc(1,2,3)
l=[1,2,3,4,5]
lc(l[0])
lc(*l)#站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打伞（按顺序输出）


def  sum(*args):  #默认参数   *xxxx
    n=0
    for i in args:
        n+=i
    return n


print(sum(1,3,6))


def classmate(name,sex):
    print(‘%s:%s‘%(name,sex))

classmate(‘erf‘,‘nv‘)
classmate(‘edgref‘,‘nan‘)


def lc(a,b):
    sum=a+b
    return sum

print(lc(1,4))

函数的注释
def lc():
    ‘‘‘
    这个函数实现了什么功能等等
    参数****
    参数****
    :return: 字符串或者列表的长度
    ‘‘‘


函数
可读性强，复用性强
函数的调用：函数名加返回值
#################################################################
函数的进阶
1.函数的命名空间
定义：存放名字与值得关系的空间
全局命名空间：代码在运行开始，创建的存储‘存储变量名与值得关系’的空间
局部命名空间：函数在运行中开辟的零时空间
命名空间的本质：存放名字与值得绑定关系
命名空间一共分为三种：

　　全局命名空间

　　局部命名空间

　　内置命名空间：存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。
三种命名空间的加载与取值顺序：
加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)
取值：

　　 在局部调用：局部命名空间->全局命名空间->内置命名空间
    在全局调用：全局命名空间->内置命名空间
a=1
def lc():
    print(a)

lc()  #必须调用一下他，不然不能显示a=1

2.函数的作用域
定义：作用范围，可分为：全局作用域和局部作用域
全局作用域：包含内置名称空间，全局名称空间在整个文件的任意位置都能被引用、全局有效
局部作用域：局部名称空间，只能在局部范围内生效

globals和locals方法
global语句：给函数内的全局变量赋值
局部变量覆盖全局变量
但可使用关键字global在函数体内对全局变量赋值
def lc():
    a=12
    b=23
    print(locals())
    print(globals())

lc()

结果：
{‘a‘: 12, ‘b‘: 23}
{‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x0000015FEFCD6128>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘D:/untitled/随机练习/初识函数和返回值.py‘, ‘__cached__‘: None, ‘lc‘: <function lc at 0x0000015FEFFC46A8>}

3.函数的嵌套和作用域链
函数的嵌套调用：
def lc1(x,y):
    z=x if x>y else y
    return z
def lc2(a,b,c,d):
    list1=lc1(a,b)
    list2=lc1(list1,c)
    list3=lc1(list2,d)
    return list3
print(lc2(1,2,3,4))
print(lc2(1,2,335,4))
函数的嵌套定义：
def f1():
    print("in f1")
    def f2():
        print("in f2")

    f2()
f1()
函数的作用域链

def f1():
    a = 1
    def f2():
        def f3():
            print(a)
        f3()
    f2()

f1()
def f1():
    a = 12

    def f2():
        a = 2

    f2()
    print(‘a in f1 : ‘, a)


f1()

4.nonlocal关键字

# 1.外部必须有这个变量
# 2.在内部函数声明nonlocal变量之前不能再出现同名变量
# 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效
def f1():
    a = 1
    def f2():
        nonlocal a
        a = 2
    f2()
    print(‘a in f1 : ‘,a)

f1()

5.函数名的本质：
1.可以被引用
2.可以被当作容器类型的元素
3.可以当作函数的参数和返回值

第一类对象（first-class object）指
1.可在运行期创建
2.可用作函数参数或返回值
3.可存入变量的实体。