python基础1——函数

python基础1——函数

一、函数的定义

一段经过组织、用来实现单一功能、可重复使用的代码。
你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

1、语法：

2、说明：

–def： 函数定义关键字，全称：define。
–函数名： 对函数体功能的描述词，命名要符合驼峰命名法与下划线法。
–形参： 函数调用时需传入的参数信息
–函数体 ： 函数的功能代码语句

3、实例

def func1():
	print("我是一个函数")

func1是一个不带参数的函数

def func2(mark):
	print("数学分数为：%d" % mark)

func2是一个带一个参数的函数

4、函数名命名一般规则：函数名一律小写，如有多个单词，用下划线隔开，如：my_len，run_with_env

二、函数的作用

1、简化代码，代码层次结构更清晰；
2、提高代码的复用性；
3、代码可扩展和便于维护。
将一段具有特定功能的代码以函数的形式保存，不但便于以后调用，还更易于修改和维护，避免重复造轮子。

三、函数的参数

函数定义和调用时所用的参数，可以没有，多个参数之间用逗号隔开。

1、形参：函数定义时函数要接收的参数，

2、实参：实参是函数调用时实际传入的参数。

形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。
实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

def calc(x,y):    #定义一个函数，参数有x和y，x和y就是形参
   print(x*y)    
calc(5,2)        #调用上面定义的函数，5和2就是实参

3、函数的四种形参类型

1）位置参数

位置参数，是按照参数的位置来进行传参，有几个位置参数在调用的时候就要传几个，否则就会报错了。

def my(name,sex):
    print(name,sex)
my('小强','男')

2）默认参数

默认参数就是在定义形参的时候，给函数默认赋一个值

def connect(ip,port=3306):
    print(ip,port)
connect('118.1.1.1',3307)  #如果给一个port值，则传新给的值
connect('118.1.1.1')  #如果不填，则使用默认参数

3）可变参数

使用原则：
1、可变参数用*来接收，不是必传的；
2、它把传入的元素全部都放到了一个元祖里；
3、不显示参数个数，后面想传多少个参数就传多少个，它用在参数比较多的情况下
4、如果位置参数、默认值参数、可变参数一起使用的的话，可变参数必须在位置参数和默认值参数后面。

def send_sms(*phone_num):
    print(phone_num)
send_sms()	# 不传参数
send_sms(150)	# 传1个
send_sms(151,152,153)	# 传N个

# 执行后结果是：
# ()
# (150,)
# (151, 152, 153)

4) 关键字参数

使用原则：
1、关键字参数使用**来接收
2、返回的是字典
3、不限制参数个数，非必传
4、当然也可以和上面的几种一起来使用，如果要一起使用的话，关键字参数必须在最后面

def send_sms2(**phone_num):
    print(phone_num)

send_sms2()
send_sms2(name='xiaohei',sex='男')
send_sms2(addr='北京',country='中国',aa='hahaha')

# 执行后结果是：
# {}
# {'name': 'xiaohei', 'sex': '男'}
# {'addr': '北京', 'country': '中国', 'aa': 'hahaha'}

5）四种参数在一起的使用

如果一定要一起用的话，要按下面的顺序写，不能换顺序，否则会出错
1、位置参数；2、默认值参数；3、可变参数；4、关键字参数

def my(name,country='china',*args,**kwargs):
    print(name)
    print(country)
    print(args)
    print(kwargs)
my('xiaohong','2','3','4','5',a='6',b='7')
#xiaohong
#2
#('3', '4', '5')
#{'a': '6', 'b': '7'}

6）强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

以下使用方法会发生错误:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

四、函数的返回值（return）

1、定义：函数的计算结果
2、语法：return [表达式]
3、说明：
1）每个函数都有返回值
2）有return语句的函数返回值为表达式的值
3）没有return语句的函数返回值为None
4）函数如果有多个返回值的话，返回的是一个元组
5）函数中的返回值使用return，函数在遇到return就立即结束。
实例：

def my3():
    a=1
    b=2
    c=3
    return a,b,c
a,b,c=my3()
s=my3()
print(s)
print(a,b,c)
# 返回结果分别是
# (1, 2, 3)    # 元祖
# 1 2 3        # int

五、局部变量和全局变量

1、局部变量只在局部生效的，出了这个变量的作用域，这个变量就失效了。
2、全局变量是在整个程序里面都生效的，在程序最前面定义的都是全局变量。
3、全局变量如果要在函数中修改的话，需要加global关键字声明，如果是list、字典和集合的话，则不需要加global关键字，直接就可以修改。
4、尽量少用全局变量。原因1不够安全，原因2全局变量一直占用内存。

#如果两种变量都有，会先用局部变量，当没有局部变量则用全局变量
name='wangcan'   #全局变量，在函数的外面
def get_name():
    global name  # 声明修改全局变量
    name='hailong'  # 局部变量，定义在函数内部
    print('函数里面的name：'+name)

def get_name2():
    print('get_name2：',name)

get_name2()  #第一调用，打印wangcan

get_name()  #第二调用，打印函数内的name:hailong
print('函数外面的name：'+name)# 最后打印,因为有函数声明了全局变量，所以打印的是：hailong

#最后的结果是
# get_name2： wangcan
# 函数里面的name：hailong
# 函数外面的name：hailong

六、函数的调用

1、同一程序文件内调用：
函数名（参数）
2、不同程序文件之间调用：
import 文件名
文件名.函数名（参数）
或
from 文件名 import 函数名
函数名（参数）

七、匿名函数（lambda）

没有名字的函数
lambda 函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方。lambda的主体是一个表达式，而不是一个代码块。

语法
lambda [arg1 [,arg2,…argn]]:expression
实例：

def area(w,h):  #一般函数写法
  s = w*h
  return s
s = lambda w,h:w*h  #lambda写法
print(area(4,6))
print(s(4,6))

八、高阶函数

将函数作为参数传入另一个函数
实例

def Sum(fun,x1,x2):
    return fun(x1,x2)
def add(x1,x2):
    return x1+x2
a=Sum(add,2,3)
print(a)
## 5

1、map(f, list)函数

返回每个元素通过f计算完的value的list
map()函数接收两个参数，一个是函数f，一个是序列list，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
实例

def square(x) :            # 计算平方数
  return x ** 2

map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
# [1, 4, 9, 16, 25]
map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
# [1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# [3, 7, 11, 15, 19]

2、reduce(f,list)函数

reduce把一个函数作用在一个序列[x1, x2, x3…]上，得到总和
实例

def add(x, y) :            # 两数相加
    return x + y
reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
# 15
reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
# 15

3、filter(f,list)函数

filter函数接收一个函数f和一个list，函数f的作用是对每个元素进行判断，返回True或者False，filter()根据判断结果自动过滤掉不符合条件的元素，返回符合要求的元素组成的list
实例

def is_odd(n):
    return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
# [1, 3, 5, 7, 9]

4、sorted()函数

sorted(list，key= None，reverse = False)
对list进行排序，默认为从小到大排序。
实例

m = dict(a=1,b=8,c=3,d=20)
print(sorted(m.items(),key = lambda d:d[1],reverse=True))
# [('d', 20), ('b', 8), ('c', 3), ('a', 1)]

5、返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

def index():
    print('from index')
    
def func(a):
    return a
    
a = func(index)
a()
#>>> from index

九、函数递归调用

一个函数在内部调用自身本身，这个函数就是递归函数
递归调用的特性：
1、递归调用必须有一个明确的结束条件
2、在python中没有尾递归优化,递归调用的效率不高
3、进入下一次递归时,问题的规模必须降低
【在python中默认最大递归次数是998】
实例
计算阶乘n! = 1 x 2 x 3 x … x n

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)