python函数

函数

引子：

求 1-15的和：

求23-36的和：

求55-68的和：

def sum_of_num(i1,i2):
    result = 0
    for i in range(i1,i2+1):
        result += i
    return result

print(sum_of_num(1,15))

程序而言：函数就是对程序逻辑进行结构化或者过程化的一种编程方法。

built-in function 内置函数 —> BIF

函数的定义

声明函数的一般形式：

def function_name(arg1,arg2,...,argn):
#    '''statements'''
    func_statements
    return Value

说明如下：

1.函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()。

2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

3.函数的第一行语句可以选择性地使用文档字符串----用于存放函数说明。

4.函数内容以冒号起始，并且缩进。

5.return [表达式] 结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回 None。

其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。

对于return后没有返回值的和没有return语句的函数都会返回None值

有些函数可能既不需要传递参数,也没有返回值。

没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。

函数调用

a= {"name": "tom","age":18}
def info(name,age):
    info = {"name": name,"age": age}
    return info
print(info("city",1999))
>>> {'name': 'city', 'age': 1999}

函数文档说明

函数参数

• 不传参函数
• 参数函数
  • 顺序

函数返回值

函数参数种类

形参和实参

• 形参

  • 只有在调用时才分配内存单元。调用结束后，即释放所分配的内存单元。因此，形参只在内部有效，函数调用结束返回主调用函数后则不能再使用该形参变量

• 实参

  • 实参是一个确定的值，能够传递给形参。
    • 作为位置参数或者关键字参数传递

def usr_manage(name,age,job,hobby):
    print("用户管理系统".center(16,'-'))
    print("\tAge:\t",age)
    print("\tJob:\t",job)
    print("\tHobby:\t",hobby)
    print("用户管理系统".center(16,'-'))

usr_manage("tom",20,"it","coding")
usr_manage("kim",21,"stuent","reading")
>>>
-----用户管理系统-----
	Age:	 20
	Job:	 it
	Hobby:	 coding
-----用户管理系统-----
-----用户管理系统-----
	Age:	 21
	Job:	 stuent
	Hobby:	 reading
-----用户管理系统-----

只传递实参，位置一一对应----> 位置参数

使用位置参数时和函数头定义的形参在顺序，个数以及类型上匹配

默认值参数

def usr_manage(name,age,job,hobby="trip"):  
    print("用户管理系统".center(16,'-'))
    print("\tAge:\t",age)
    print("\tJob:\t",job)
    print("\tHobby:\t",hobby)
    print("用户管理系统".center(16,'-'))

usr_manage("tom",20,"it",)
usr_manage("kim",21,"stuent","reading")
>>>
-----用户管理系统-----
	Age:	 20
	Job:	 it
	Hobby:	 trip
-----用户管理系统-----
-----用户管理系统-----
	Age:	 21
	Job:	 stuent
	Hobby:	 reading
-----用户管理系统-----

关键字参数

def usr_manage(name,age,job,hobby="trip"):
    print("用户管理系统".center(16,'-'))
    print("\tAge:\t",age)
    print("\tJob:\t",job)
    print("\tHobby:\t",hobby)
    print("用户管理系统".center(16,'-'))
usr_manage("kim",21,hobby="reading",job="stuent")
>>>-----用户管理系统-----
	Age:	 21
	Job:	 stuent
	Hobby:	 reading
-----用户管理系统-----

默认值参数，关键字参数，必须放置于位置参数之后。

不定参数

在python中不定参数主要是指*args 和 **kwargs两个魔法变量

他们俩主要是用于函数定义，我们可以将不定数量的参数传递给一个函数

• *args 用来接收任意非键值对的任意数量的参数列表给函数

  def uncertain_para(para,para2,*args):
      print("普通位置参数:",para,para2)
      print("不定参数:",args)
      print(type(args))
  uncertain_para(1,2,3,4,'a','b')
  >>>普通位置参数: 1 2
  不定参数: (3, 4, 'a', 'b')
  <class 'tuple'>
  

• **kwargs 用来接收任意不定长度的键值对列表

def un_para_key(**kwargs):
    print(kwargs)
    print(type(kwargs))

un_para_key(a=1,b=2,c=3)
>>>{'a': 1, 'b': 2, 'c': 3}
<class 'dict'>

函数引用

函数属性

函数属性是python中另外一个使用了句点属性标识并拥有名字空间的领域
你可以获得每个 pyhon 模块，类，和函数中任意的名字空间。你可以在模块 foo 和 bar 里都有名为 x 的一个变量,，但是在将这两个模块导入你的程序后，仍然可以使用这两个变量。所以，即使在两个模块中使用了相同的变量名字，这也是安全的，因为句点属性标识对于两个模块意味了不同的命名空间，比如说，在这段代码中没有名字冲突。

内嵌函数

---->作用域

bar()整个函数都处于外部foo()函数的作用域里(fool()是我们可以从外部访问的一个对象区域)。除了在foo()内部，其他地方无法对bar()进行调用。

def foo():
    def bar():
        print("bar() called.")
    print("fool() called.")
    bar()
foo()

变量作用域

作用域的产生

就作用域而言，python和C有很大差别，只有当变量在module，Class，函数中定义的时候，才会有作用域的概念。

def foo():
    a = "foo"
    print(a)
foo()
print(a)

在作用域中定义的变量，一般只在作用域内有效。需要注意的是，在if-elif-else,for - else, while - else,try - except(else - finally)等关键字的语句块中不会产生作用域。

作用域的类型

python中，使用一个变量时并不要求需要预先声明它。但在真正使用的时候，他必须绑定到某个内存对象（被定义，赋值）。这种变量名的绑定将在当前作用域引入新的变量，同时，屏蔽外层作用域中的同名变量。

• 局部作用域（locale — L)

• 嵌套作用域（enclosing — E)

  • E也包含在def关键字中，E和L是相对的，E相对于跟上层的函数而言也是L。与L的区别在于，对于一个函数而言，L是定义在此函数内部的局部作用域。
  • 主要为了实现python的闭包，而增加的实现。

• 全局作用域（Global —G）

  • 即在模块层次中定义的变量。模块顶层申明的变量具有全局作用域。从外部来看，模块的全局变量就是一个模块对象的属性。

• 内置作用域（built-in —B）

  • 系统固定模块中定义的变量。

搜索变量名的优先级：局部作用域>嵌套作用域>全局作用域>内置作用域

全部变量和局部变量

gbl_str = "foo"
def foo():
    loc_str = "bar"
    return gbl_str + loc_str
print(foo())
print(gbl_str)
print(loc_str)

优先使用局部变量

a = 6688
def foo():
    a = 666
    print(a)
foo()
>>> 666

函数的补充

a = 6688
def foo():
    global a
    a = 666
    def inner_foo():
        a = 888
        print(a)
    inner_foo()
    print(a)

print(a)
foo()
print(a)
>>>6688
888
666
666

global

global—将变量定义为全局变量。可以通过定义为全局变量，实现在函数内部改变变量值

递归函数

在一个函数体的内部，调用函数本身，就被称为递归函数

匿名函数（lambda）

格式：

lambda para1, para2, ...,paraN : expression using paras
例：
f =lambda x,y,z: x+y+z
print(f(1,2,3))

高阶函数：

高阶函数：把一个函数名，以实参的形式，传递给这个函数的形参，这个函数就成为高阶函数。

def pow(x):
    return x**2
def add(a,b,func):
    return func(a) + func(b)
print(add(-1,8,pow))
>>>
65

filter函数

li = ['ii','lovety',"hkty","lzy"]
def filter_test(func,para):
    lis = []
    for i in para:
        if not func(i):
            lis.append(i)
    return lis
def judge(para1):
    return para1.endswith("ty")
def end(para):
    return para.startswith("l")
print(filter_test(judge,li))
# print(filter_test(lambda sr:sr.startswith("c"),li))
f1 = filter(lambda para:not para.endswith("ty"),li)
print(list(f1))
>>>
['ii', 'lzy']
['ii', 'lzy']

功能：

过滤掉序列中不符合函数条件的元素。当序列中要需要保留的元素可以用某些函数描述时，就应该想到filter函数

调用格式：

• filter（function，sequence）
  • function ----> 可以是自定义的函数，也可以匿名函数
  • sequence ----> 列表，元组，字符串

map 映射

功能

• 求一个序列或者多个序列进行函数映射后的值。（用list()强转）

格式

• map(function,iterable1,iterable2)
  • function的参数可以不止一个
  • iterable1，iterable2就是传入function的参数