python-笔记（四）函数

一、函数是什么？

函数一次来源于数学，但是编程中的【函数】的概念，与数学中的函数还是有很大的不同的，编程中的函数在英文中也有很多不同的叫法。

在Basic中叫做subroutine(子过程或子程序)，在Pasacl中叫做procedure（过程）和funtion，在java中叫做method。

二、使用函数的好处：#函数即变量

1、简化代码

2、提高代码效率

3、代码可扩展

三、函数的定义：

定义函数的关键字是def,后面是函数名+()，函数名不能重复；调用函数：函数名+()

eg:
# def read_users(filename):#形参
#     with open(filename) as fr:
#         for line in fr:
#             up = line.strip().split(',')
#             s_username = up[0]
#             s_pwd = up[1]
#             all_users[s_username]=s_pwd
# read_users('a.txt')#调用参数叫做实参
# print(all_users)

四、函数在调用的时候，可以传入参数，有形参和实参

函数在调用的时候，可以传入参数，有形参和实参

形参：形参只有被调用的时候才分配内存单元，在调用结束后就是放所分配的内存单元，因此形参只在函数内部有效。

实参：

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，他们必须有确定的值，以便把这些值

传送给形参。函数调用结束返回主调用函数后则不能再使用该行参变量。

简单点说，形参就是函数接收的参数，实参就是实际传入的参数。

函数的四种参数：

1、位置参数：字面上的也就是按照参数的位置进行传参比如例子中的read_users函数种的filename，位置参数是必传的，

有几个位置参数在调用就必须传入几个参数，否则就会报错。那如果有多个位置参数的话，记不住那个位置穿那个参数了

怎么办，可以使用位置参数的名字来指定调用,这种调用方式叫做关键字传参

e.g:

def  cal(x,y):

　　return x*y

cal(x=4,y=6)

2、默认值参数：

默认值参数就是在定义形参的时候，给函数默认赋一个值，比如数据库的端口这样的，默认给它一个值，这样就算你在调用的时候

没传入这个参数，他也是有值的

所以，默认参数不是必填参数，如果给默认参数传值的话，他就会使用你传入的值。如果使用默认值参数的话，必须放在位置参数

后面定义

e.g:

# def regit(name,age,sex='男'):#age,name必填参数，位置参数，
#     # sex定义了一个默认值参数，非必传
#     print('hello %s,age is %s,sex is %s'%(name,age,sex))
#
# regit('周杰伦','9090')

非固定参数：
位置参数和默认参数都是参数是固定的，如果一个函数，参数不是固定的，非固定参数分为：可变参数、关键字参数

如果4种参数都有的话，必须按照位置参数、默认值参数可变参数、关键参数的顺序接受否则报错

3、可变参数
可变参数用*来接收，后面想传入多个参数就传入多少个，可变参数也是非必填的
e.g:

# def post(*args):#可变参数，也叫参数组，参数不固定,也不是必填参数
#     print(args)
# post('001','denglu','http://baidu.com','post','a=1')
# post('002','denglu')
#
# def other(name,age,country,*args):#接受的是元祖
#     print(name)
#     print(age)
#     print(country)
#     print(args)
# other('wubing','999','hehe','beijing','python')

4、关键字参数：
关键字参数**来接收，后面的参数也不固定的，想写多个多少个，当然也可以和上面的集中一起使用，如果一起使用的话，关键字参数必须在最后面
使用关键字参数的话，调用的时候必须使用关键字传参，关键字参数也是非必传的。

e.g:

def kw(**kwargs):
    #关键字参数，接受的是一个字典,也不是必填的
    #c传入字典的时候就得写**d
    print(kwargs)
kw(name='wubing',age='18',sex='女')
# d={'name': 'wubing', 'age': '18', 'sex': '女'}
#
# kw(**d)
# kw()

#
# def other2(name,country='China',*args,**kwargs):
#     #如果必填参数、默认值参数和可变参数、关键字参数一起用的话
#     #必须按照必填参数、默认值参数可变参数、关键参数的顺序接受否则报错
#     print(name)
#     print(country)
#     print(args)
#     print(kwargs)
# other2('wubing')
# other2('wubing','beijing','python','cahngping',user='niuhanyang')

五、函数的返回值
每个函数都有返回值，如果没有在函数里面指定返回值的话，在python里面函数执行完之后，默认会返回一个None,
函数也可以有多个返回值，如果有多个返回值的话，会把返回值都放到一个元祖里，返回的是一个元祖。
为什么要有返回值呢？是因为在这个函数操作完之后，它的结果的在后面的程序里里面需要用到。
函数中的返回值使用return，函数在遇到return就立刻结束。
def calc(x,y):
　　c =x*y
　　return c
resc = calc(5,6)
print(res)

e.g:

'''
这个函数是判断传入的是不是小数
return  True  or  False
param 传入一个字符串
'''
# def is_float(s):
#     s = str(s)
#     print(s)
#     if s.isdigit():
#         return False
#     else:
#         if s.count('.') == 1:
#             sl = s.split('.')#按照小数点分割
#             left = sl[0]
#             right = sl[1]
#             if left.startswith('-')and left.count('-')==1and right.isdigit():
#                 lleft= left.split('-')[1]
#                 if lleft.isdigit():
#                     return True
#                 else:
#                     return False
#             elif left.isdigit()and right.isdigit():
#                 return True
#             else:
#                 return False
#         else:
#             return False
# print(is_float('1.1'))

六、局部变量和全局变量

局部变量意思就是在局部生效的，出了这个变量的作用域，这个变量就失效了，比如上面的c就是一个局部变量，出了这个函数之后，就没有c这个值了

全局变量的意思就是在整个程序里面都生效的，在程序最前面定义的都是全局变量，全局变量如果要在函数中修改的话，需要加global关键字声明，如果是list、字典和集合的话，则不需要加global关键字，直接就可以修改。

# score3 ={'name':'adidas'}
# def my_open():
#     #在函数里定义的变量叫局部变量，他只能在函数里面用
#     #除了该函数外，就不能使用了
#     #在函数外定义的变量叫做全局变量，在函数内也可以使用
#     #如果变量在函数外和函数内都有定义那么函数内取值为函数内定义的变量值
#     #如果想在函数里修改全局变量那么要先用global关键字声明
#     #global要修改的是int,string类型必须得些global,如果是列表和字典不能加global
#     fw = open('a.txt','a+')
#     fw.seek(0)
#     print(fw.read())
#     score3['name'] = 'pppp'
#     global score3
#     score3['id']='1000'
#
#     print(score3)
# my_open()
# # fw.read()
# print(score3)
# #函数及变量

七、递归调用

如果一个函数在内部调用自身本身，这个函数就是递归函数。递归调用的意思就是，在这个函数内部自己调用自己，就有点循环的意思。

# def hello():
#      print('hello')
#      hello()
#
# hello()

递归调用的特性：

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

八、高阶函数

如果一个函数的入参是一个函数名的话，那这个函数就是一个高阶函数

# def add(x,y,z):
#     return z(x)+z(y)
# print(add('99','121',int))

# 函数里面也可以嵌套的定义函数
# 函数的作用域：是就近原则，从里往外找，如果自己的函数里面有就拿来用，
# 如果自己的函数里面没有的话，就去他的父级里面找
# 函数只有调用才会被执行

e.g:

# name ='python'
# def warpper():
#     name ='wubing'
#     print('我在外面')
#     def deco():
#         name = '陈冬瓜'
#         print('我在里面%s'%name)
#         def hhh():
#             name ='张莹'
#             print('xxx%s'%name)
#         hhh()
#     deco()
#     print('外面的name是%s' % name)
# warpper()