python函数基础学习


 

函数的定义与调用:

def 函数名(参数1,参数2):

‘’’函数注释’’’

print(函数体)

return 返回值

 

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

def 是固定且不可变的

函数名:函数名是包含字母、数字、下划线的任意组合,(不能以数字开头)

 

函数调用: 返回值 = 函数名 (参数1,参数2

 

函数返回值:

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

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

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

也可以没有返回值:

  1. 不写return 的时候,函数返回值为 None
  2. 只写一个return的时候,函数返回值为 None
  3. return Nonede 时候,函数返回值为None(几乎不用)

4- return返回一个值(一个变量)

5- return返回多个值(多个变量):多个值之间用逗号隔开,以元组的形式返回

接受:可以用一个变量接受,也可以用多个变量接收(返回几个就用的几个变量)

 

函数的参数:

1- 实参和形参:

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

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

2- 传递多个参数:

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

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

  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 + 结果

 

一、命名空间和作用域

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

命名空间一共分为三种:

全局命名空间

  局部命名空间

    内置命名空间

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

加载顺序:内置命名空间(运行前加载)->

>全局命名空间(运行中:从上到下加载) ->

   >局部命名空间(运行中:调用才加载)<

 

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

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

作用域:

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

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

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

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

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

站在全局看:使用名字:

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

 

 

二、函数嵌套与作用域链

函数的嵌套调用:

 1 #函数的嵌套调用
 2 
 3 def max2(x,y):
 4 
 5 m = x if x>y else y
 6 
 7 return m
 8 
 9  
10 
11 def max4(a,b,c,d):
12 
13 res1 = max2(a,b)
14 
15 res2 = max2(res1,c)
16 
17 res3 = max2(res2,d)
18 
19 return res3
20 
21  
22 
23 ...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)

 


 


装饰器

 

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

 

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

 

语法糖:

 1 import time
 2 
 3 def timer(func):
 4 
 5 def inner():
 6 
 7 start = time.time()
 8 
 9 func()
10 
11 print(time.time() - start)
12 
13 return inner
14 
15 @timer# ==> func1 = timer(func1)===> 语法糖
16 
17 def func1():
18 
19 print(‘in func1’)
20 
21 func1()

 

·开放封闭原则:对扩展开放,对修改封闭

1- 对扩展是开放的

为什么要对扩展开放呢?

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

 

2- 对修改是封闭的

为什么要对修改封闭呢?

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

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

 

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

固定格式:(固定万能格式)

 

 1 def timer(func):
 2 
 3  
 4 
 5 def inner(*args,**kwargs):
 6 
 7  
 8 
 9 ...执行函数之前要做的...
10 
11  
12 
13 re = func(*args,**kwargs)
14 
15  
16 
17 ...执行函数之后要做的...
18 
19  
20 
21 return re
22 
23  
24 
25 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()

 



递归与二分算法

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

1 import sys
2 
3 print(sys.setrecursionlimit(100000))

递归实现三级菜单:

 1 menu = {
 2        ‘北京’:{
 3            ‘海淀’:{
 4         ‘五道口’:{
 5             ‘soho’:{},
 6              ‘网易’:{},
 7               ‘google’:{},
 8              },
 9         ‘中关村’:{
10             ‘爱奇艺’:{},
11               ‘汽车之家’:{},
12                 ‘youku’:{},
13              },
14          ‘上地’:{
15               ‘百度’:{},
16             },
17          ‘昌平’: {
18             ‘沙河’:{
19             ‘老男孩’:{},
20             ‘北  航’:{},
21               },
22         ‘天通苑’:{},
23         ‘回龙观’:{},
24           },
25       ‘朝阳’:{},
26       ‘东城’:{},
27         },
28     ‘上海’:{
29       ‘闵行’:{
30       ‘人民广场’:{
31           ‘炸鸡店’:{}
32             },
33           },
34       ‘浦东’:{},
35         },
36     ‘山东’:{},
37     }
38 
39 def three(dic):
40 for key in dic :
41 print(key)
42 k = input(“>>>>>>>>”)
43 if k in dic:
44 three(dic[k])
45 three(dic)


二分查找算法:

 

 1 l = [ 2,3,5,10,15,16,18,22,26 ]
 2 
 3 def find ( l,aim,start,end ):
 4 
 5 mid = ( end+start ) // 2
 6 
 7 if (l[mid] > aim):
 8 
 9 end = mid
10 
11 return find(l,aim,start,end)
12 
13 elif (l[mid] < aim):
14 
15 start = mid
16 
17 return find(l,aim,start,end)
18 
19 else:
20 
21 return mid
22 
23 print( find( l,15,start=0,end=len(1)-1 ) )

 


 

 

 

 

 

posted @ 2018-11-28 17:57  Mirror王宇阳  阅读(247)  评论(0编辑  收藏  举报