python学习道路(day4note)(函数,形参实参位置参数匿名参数，匿名函数，高阶函数，镶嵌函数)

1.函数 2种编程方法              关键词
面向对象：华山派  ---》》 类-----》class
面向过程：少林派  -—》》 过程---》def 
函数式编程：逍遥派 -—》》函数---》def

函数的定义：x自变量 y因变量 y是x的函数
编程语言中的函数定义：函数是逻辑结构化和过程化的一种编程方法
python中函数定义方法：

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def test(x):
     "The function definitions"
     x+=1
     return x

def:定义函数的关键字
test：函数名
（）：内可定义形参
"":文档描述（非必要，但是强烈建议为你的函数添加描述信息）
x+=1：泛指代码块或程序处理逻辑
return：定义返回值

2.看下面2个列子

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def func1():
     #testing1
     pring("in the func1")
     return 0
 def func2():
     #testing2
 pring("in the func2")
 x=func1()
 y=func2()
 pring("form func1 return is $s" % x)  结果0
 pring("form func2 return is $s" % y)  结果none

过程和函数都可以被调用 实体，过程实际上就是没有返回值的函数
func1 函数式编程
func2 面向过程   就是一段段功能逻辑包含到def当中，通过函数名来调用的过程
为什么使用函数：
http://egon09.blog.51cto.com/9161406/1834777  例子可以访问
函数重复利用
函数一致性
函数扩展性

3.函数的返回值 return
可以返回 对象 true false 元祖 字典
什么要有返回值，这个函数整个执行的结果，后面其他的逻辑要根据前一个逻辑返回的结果来继续不同操作

4.看下面代码

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def test(x,y):
     print(x)
     print(y)
 test(1,2) 位置关系调用，与形参一一对应

1 2 叫做实参    实际存在的，占用空间的
x y 叫做形参    （也是位置参数）
test(y=1,x=1) 关键字调用，与形参数续无关
既有关键字又有位置关系调用，会按照位置关系调用
关键字参数不能写位置关系前面

5.默认参数

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def test(x,y=2):
     print(x)
     print(y)
 test(1,3/y=3)

用途！一些默认值得地方
特点！调用函数的时候，默认参数可有可无非必须传递

6.参数组
因为这里功能比较多，所以写入了一个Code里面，后面加了注释。

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def test(*args):     接收的位置参数，转化为元祖的形式接收不了关键字参数
     print(args)
 test(1,2,3,4,5)
 在传递多个实参的时候，形参可以用*加个随意变量名，输出来的是元组形式*就是不固定的形参
 test(*[1,2,3,4,5])   传列表    args=tuple([1,2,3,4,5])  第一种类型

 def test(**kwargs):  接收的关键字参数，转化为字典的形式
     print(kwargs['name'])
     print(kwargs['age'])
 test(name='alex',age=8,sex='f') 会把关键字k v处理
 test(**{name='alex',age=8,sex='f'})

 def test(name,**kwargs):
     print(name)
     print(kwargs)
 test('alex',age=8,sex='m') 字典参数跟位置参数结合

 def test(name,age=18,**kwargs):
     print(name)
     print(age)
     print(kwargs)
 test('alex',sex='m') 字典参数跟位置参数,默认参数结合

7.局部变量
因为这里功能比较多，所以写入了一个Code里面，后面加了注释

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 school = "oldboy"   这个就是全局变量，外面的是改变不了的
 def change_name(name)：
     school = "mage"
     print("before change",name，school)
     name = "Alex li"   这个就是局部变量，这个函数就是这个变量的作用域，出了这个函数就没用了
     print("after change",name)

 print(school)
 name = "alex"
 change_name(name)
 print(name)

 默认局部变量改不了全局变量，但是也是可以的就是
 def change_name(name)：
     global school     也可在这里定义全局，也可以改全局
     school = "mage"
     print("before change",name，school)
 change_name(name)
 print(school)

 *** 字符串和整数遵循局部改不了全局  但是列表 字典 集合是可以在局部改的

8.递归
因为这里功能比较多，所以写入了一个Code里面，后面加了注释

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def calc(n):
     print(n)
     return calc(n+1)
 clac(0)    最大递归 999 不能超过
 必须有个明确的结束条件
 每次进入更深一层，问题规模相比上次递归都应有所减少
 递归效率不高，递归 层次过多会导致栈溢出
 def calc(n):
     print(n)
     if int(n/2) > 0:
         return calc( int(n/2) )
     print(">>",n)
 calc(10)
 ***二分查找  这是个找15的例子
 data = [3,5,10,1,12,14,17,11,19,20,19]
 #先变成有序的
 def binary_search(datasets,find_num):
     if len(datasets) > 0:
         middle_pos = int(len(datasets/2))
         if datasets[middle_pos] == find_num
             print("find it")
         elif datasets[middle_pos] > find_num:
             print("left inside")
             binary_search(datasets[0:middle_pos],find_num)
         else:
             print("right inside")
             binary_search(datasets[middle_pos+1:],find_num)
     else:
         pring("find not 15")

 binary_search(data,15)

9.匿名函数
因为这里功能比较多，所以写入了一个Code里面，后面加了注释

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def calc(n):
     return n*n
 calc2 = lambda x:x*x  x相当于n   x*x相当于n*n   这一行叫做匿名函数  只能用于最简单最基本的判断
 print(calc2(8))
 print(calc(8))

 def calc(n):
     return n*2
 data = map(lambda n:n*2, range(10))   匿名函数搭配其他的方法用 相等于上下的结合起来一句
 data = map(calc,rang(10))
 for i in data:
     print(i)

 def calc(n):
     if n>5:
         print("hello")
     return n*2
 data = map(lambda n:n*2 if n>5 else n, range(10))  可以加入三元运算，其他的就不行了
 data = map(calc,rang(10))
 for i in data:
     print(i)
 data = map(lambda n:n*2 if n>5 else calc(n), range(10)) 可以调用函数，一般不要这么做，太乱

 10.高阶函数

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 高阶函数   就是一个函数接收另一个函数作为参数，就叫做高阶函数
 def add(a,b,f):
     return f(a)+(b)
 res = add(3,-6,abs)
 print(res)    abs就是内置函数绝对值

11.内置参数
因为这里功能比较多，所以写入了一个Code里面，后面加了注释

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 内置函数  就是python自带的函数
 all() 判断列表的所有值是否为真
 a=[1,2,3]
 all(a)  返回真，
 a=[0,2,3]
 all(a)  返回假

 any() 列表里的任何一个值为真就为真  只有0是假 或者列表空也是假
 print（ascii("地方")）  返回unicode格式显示
 print(bin(10))  返回二进制

 b = b'abc'
 b[1]
 bytes 就是 bytes 0 - 255之间的数字 并且不能改
 bytearray  就可以改

 callable() 就是判断一个对象可以调用
 print(callable(函数名)) 返回true false

 print(chr(97)) assci 对应的关系返回a
 print(ord('a')) 返回的是97

 compile() 把文件的字符串解释成python的代码区执行  相当于import 不
 f = open("返回值.py")
 code = compile(f.read(),'','exec')
 print(code)
 exec(code)
 eval只能做数字运算的字符串

 complex()复数 没有用
 dict() 生成字典

 dir() 就是返回用法
 f = open("fanhuizhi.py,encoding="utf-8"")
 pring(dir(f))

 print(divmod(10,3))  返回地板除(3,1)

 filter()过滤
 for i in filter(lambda x:x>5,rang(10)):过滤
     print(i)

 float()浮点
 frozenset()把一个集合变成只读的
 print(globals()) 当前程序在内存里的所有程序都以字典的形式打印出来全局
 print(locals()) 打印局部的

 hex() 求16进制   pring(hex(8)) 返回0x8  0x就是16进制表示方法
 0123456789abcdef
             10 11 12 13

 id()内存地址
 print(max([]))列表里面的最大值
 min 最小
 oct()八进制   0o oct(8)返回的是 0o10
 pow(4,9)多少次方 4de 9cifang

 msg = "yiduanhua"
 f = open("tofile","w",encoding="utf-8")
 print(msg,"lingyiduanhua",sep="|",end="=",file=f)   sep分隔符 =结束符

 data = [3,5,7,4,6,4]
 data = reversed(data)
 for i in data:print(i) 反转 列表 字符串可以I的

 round()5舍6入
 print(round(10.26,1)) 1保留一个小数    五舍六入

 set()  把一个列表变成集合
 slice(3,8,1)切片 没啥用

 a = "alex"
 a = sorted(a)
 print(a)   按照assci码排序呢

 sum() 一个列表的求和 里面的数字加在一起
 print(vars()) 跟globals一样

 a = [1,3,5,7]  会对应少的来
 b = [2,4,6,8]
 for i in zip(a,b):     拉链
     print(i)