python函数基础学习

函数的定义与调用：

def 函数名（参数1，参数2）：

‘’’函数注释’’’

print(‘函数体’)

return 返回值

定义：def关键字开关，空格之后接函数名和圆括号，最后冒号结尾

def 是固定且不可变的

函数名：函数名是包含字母、数字、下划线的任意组合，（不能以数字开头）

函数调用：返回值 = 函数名（参数1，参数2）

函数返回值：

1- return的作用：结束一个函数的执行

2- 首先返回值可以是任何的数据类型

3- 函数可以有返回值：如有返回值，必须要用变量接受才有效果

也可以没有返回值：

不写return 的时候，函数返回值为 None
只写一个return的时候，函数返回值为 None
return Nonede 时候，函数返回值为None(几乎不用)

4- return返回一个值（一个变量）

5- return返回多个值（多个变量）：多个值之间用逗号隔开，以元组的形式返回

接受：可以用一个变量接受，也可以用多个变量接收（返回几个就用的几个变量）

函数的参数：

1- 实参和形参：

形参：是函数定义时候定义的参数

实参：函数调用的时候传进的参数

2- 传递多个参数：

可以传递多个参数，多个参数之间用逗号隔开。

从传参的角度上，调用函数是传参数有两种方式：

按照位置传参数
按关键字传参数

用法：1-位置参数必须在关键字参数的前面

2-对于一个参数只能赋值一次

3- 默认参数：

用法：为什么要用默认参数？将变化比较小的值设置成默认参数

定义：默认参数可以不传，不传的时候用的就是默认值，如果传会覆盖默认值

默认的值是在定义函数的时候就已经确定了

3- 动态参数：

按位置传值多余的参数都会有args统一接收，保存为一个元组（tuple）的形式

按关键字传值接收多个关键字参数，由 kwargs 接收，保存为一个字典（dict）的形式

小结：

1.定义：def 关键词开头，空格之后接函数名称和圆括号()。

2.参数：圆括号用来接收参数。若传入多个参数，参数之间用逗号分割。

　　　　参数可以定义多个，也可以不定义。

　　　　参数有很多种，如果涉及到多种参数的定义，应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。

　　　　如上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序

3.注释：函数的第一行语句应该添加注释。

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

5.返回值：return [表达式] 结束函数。不带表达式的return相当于返回 None

def 函数名(参数1,参数2,*args,默认参数,**kwargs):

"""注释：函数功能和参数说明"""

函数体

……

return 返回值

python函数进阶学习

三元运算符

结果 + if + 条件 + else + 结果

一、命名空间和作用域

命名空间的本质：存放着名字与值得绑定关系

命名空间一共分为三种：

全局命名空间

　　局部命名空间

　　　　内置命名空间

三者之间得加载与取值顺序：（命名空间和作用域是分不开的）

加载顺序：内置命名空间（运行前加载）->

>全局命名空间（运行中：从上到下加载） ->

>局部命名空间（运行中：调用才加载）<

取值：

在局部调用：局部命名空间->全局命名空间->内置命名空间

在全局调用：全局命名空间->内置命名空间

作用域：

为什么要有作用域的概念：

为了函数内的变量不会影响到全局

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域

全局作用域：包含内置名称空间，全局名称空间，在整个文件的任意位置都能被引用，全局有效

局部作用域：局部名称空间，只能在局部范围内生效

站在全局看：使用名字：

如果全局有用全局的：如果全局没有用内置的

二、函数嵌套与作用域链

函数的嵌套调用：

 #函数的嵌套调用

 def max2(x,y):

 m = x if x>y else y

 return m

 def max4(a,b,c,d):

 res1 = max2(a,b)

 res2 = max2(res1,c)

 res3 = max2(res2,d)

 return res3

 ...max4(23,-7,31,11)...

嵌套定义：定义在内部的函数无法直接在全局被调用

为了保护内部函数，确定内部函数只能在外部函数中被调用

    def animal():

    def tiger():

    print(‘ bark ’)

    print(‘ eat ’)

    tiger()

    animal()

函数的作用域链：

三、函数名的本质(——内存地址)

1- 可以被引用

2- 可以被当作容器类型的元素

3- 可以当作函数的参数和返回值（可以当做普通变量使用）

四、闭包

内部函数包含对外部作用域而非全局作用名字的引用。（函数对上层域名字的引用）

    def func():

    name = ‘eva’

    def inner():

    print(name)

装饰器

装饰器的本质：一个闭包函数

装饰器的功能：在不修改原函数及其调用方式的情况下对原函数的功能镜像扩展

语法糖：

 import time

 def timer(func):

 def inner():

 start = time.time()

 func()

 print(time.time() - start)

 return inner

 @timer# ==> func1 = timer(func1)===> 语法糖

 def func1():

 print(‘in func1’)

 func1()

·开放封闭原则：对扩展开放，对修改封闭

1- 对扩展是开放的

为什么要对扩展开放呢？

我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展，添加新功能。

2- 对修改是封闭的

为什么要对修改封闭呢？

就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。

装饰器完美的遵循了这个开放封闭原则。

装饰器的主要功能和固定格式：在不改变函数的调用方式的基础上函数前后添加某些功能。

固定格式：（固定万能格式）

 def timer(func):

 def inner(*args,**kwargs):

 ...执行函数之前要做的...

 re = func(*args,**kwargs)

 ...执行函数之后要做的...

 return re

 return inner

带参数的装饰器：

def outer(flag):

def timer(func):

def inner(*args,**kwargs):

if flag:

print(“执行函数之前要做的”)

re = func(*args,**kwargs)

if flag:

print(“执行函数之后要做的”)

return re

return inner

return timer

@outer(False)

def func():

print(111)

func()

多个装饰器修饰同一个函数：

def wrapper1(func):

def inner():

print(‘wrapper1,before func’)

func()

print(‘wrapper1,after func’)

return inner

def wrapper2(func):

def inner():

print(‘wrapper2,before func’)

func()

print(‘wrapper2,after func’)

return inner

@wrapper1

@wrapper2

def f():

print(‘in f’)

f()

递归与二分算法

递归：在一个函数里调用这个函数本身

 import sys

 print(sys.setrecursionlimit(100000))

递归实现三级菜单：

 menu = {

        ‘北京’:{

            ‘海淀’：{

 　　　　　　　　‘五道口’：{

 　　　　　　　　　　　　‘soho’：{},

 　　　　　　　　　　　　　‘网易’：{},

 　　　　　　　　　　　　　　‘google’：{},

 　　　　　　　　　　　　　},

 　　　　　　　　‘中关村’：{

 　　　　　　　　　　　　‘爱奇艺’：{},

 　　　　　　　　　　　　　　‘汽车之家’：{},

 　　　　　　　　　　　　　　　　‘youku’：{},

 　　　　　　　　　　　　　}，

 　　　　　　　　　‘上地’：{

 　　　　　　　　　　　　　　‘百度’:{},

 　　　　　　　　　　　　},

 　　　　　　　　　‘昌平’: {

 　　　　　　　　　　　　‘沙河’：{

 　　　　　　　　　　　　‘老男孩’：{},

 　　　　　　　　　　　　‘北  航’：{},

 　　　　　　　　　　　　　　}，

 　　　　　　　　‘天通苑’:{},

 　　　　　　　　‘回龙观’:{},

 　　　　　　　　　　},

 　　　　　　‘朝阳’:{},

 　　　　　　‘东城’:{},

 　　　　　　　　}，

 　　　　‘上海’：{

 　　　　　　‘闵行’：{

 　　　　　　‘人民广场’：{

 　　　　　　　　　　‘炸鸡店’：{}

 　　　　　　　　　　　　},

 　　　　　　　　　　},

 　　　　　　‘浦东’：{},

 　　　　　　　　},

 　　　　‘山东’：{},

 　　　　}

 def three(dic):

 for key in dic :

 print(key)

 k = input(“>>>>>>>>”)

 if k in dic:

 three(dic[k])

 three(dic)

二分查找算法：

 l = [ 2,3,5,10,15,16,18,22,26 ]

 def find ( l,aim,start,end ):

 mid = ( end+start ) // 2

 if (l[mid] > aim):

 end = mid

 return find(l,aim,start,end)

 elif (l[mid] < aim):

 start = mid

 return find(l,aim,start,end)

 else:

 return mid

 print( find( l,15,start=0,end=len(1)-1 ) )

巴特西

python函数基础学习

最新文章

热门文章