day03 - Python基础3

本节内容

1. 函数基本语法及特性

2. 参数与局部变量

3. 返回值

嵌套函数

4.递归

5.匿名函数

6.函数式编程介绍

7.高阶函数

8.内置函数

 温故知新                                                                                  

1. 集合

主要作用:

1. 去重
2. 关系测试， 交集＼差集＼并集＼反向(对称)差集

 >>> a = {1,2,3,4}
 >>> b = {3,4,5,6}
 >>> a
 {1, 2, 3, 4}
 >>> type(a)
 <class 'set'>
 >>> a.symmetric_difference(b)
 {1, 2, 5, 6}
 >>> b.symmetric_difference(a)
 {1, 2, 5, 6}
 >>>
 >>>
 >>> a.difference(b)
 {1, 2}
 >>> a.union(b)
 {1, 2, 3, 4, 5, 6}
 >>> a.issubset(b)
 False
 >>> 

set_operation

2. 元组　　

只读列表，只有count, index 2 个方法。

作用：如果一些数据不想被人修改， 可以存成元组，比如身份证列表。

3. 字典

key-value对特性：

1. 无顺序
2. 去重
3. 查询速度快，比列表快多了
4. 比list占用内存多

为什么会查询速度会快呢？因为他是hash类型的，那什么是hash呢？

哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法

dict会把所有的key变成hash 表，然后将这个表进行排序，这样，你通过data[key]去查data字典中一个key的时候，python会先把这个key hash成一个数字，然后拿这个数字到hash表中看没有这个数字， 如果有，拿到这个key在hash表中的索引，拿到这个索引去与此key对应的value的内存地址那取值就可以了。

待续 ...

4. 字符编码

先说python2

1. py2里默认编码是ascii。
2. 文件开头那个编码声明是告诉解释此代码（文件）的程序 以什么编码格式 把这段代码读入到内存（存储于内存的这段代码是以bytes二进制格式存储的，但是即使是2进制流，也可以按不同的编码格式转成2进制流）。
3. 如果在文件头声明了#_*_coding:utf-8_*_，就可以写中文了， 不声明的话，python在处理这段代码时按ascii，显然会出错， 加了这个声明后，里面的代码就全是utf-8格式了。
4. 在有#_*_coding:utf-8_*_的情况下，你在声明变量如果写成name=u"大保健"，那这个字符就是unicode格式，不加这个u,那你声明的字符串就是utf-8格式。
5. utf-8 to gbk怎么转，utf8先decode成unicode,再encode成gbk。

再说python3

1. py3里默认文件编码就是utf-8,所以可以直接写中文，也不需要文件头声明编码了。
2. 你声明的变量默认是unicode编码，不是utf-8, 因为默认即是unicode了（不像在py2里，你想直接声明成unicode还得在变量前加个u）, 此时你想转成gbk的话，直接your_str.encode("gbk")即可以。
3. 但py3里，你在your_str.encode("gbk")时，感觉好像还加了一个动作，就是就是encode的数据变成了bytes里，我擦，这是怎么个情况，因为在py3里，str and bytes做了明确的区分，你可以理解为bytes就是2进制流，你会说，我看到的不是010101这样的2进制呀， 那是因为python为了让你能对数据进行操作而在内存级别又帮你做了一层封装，否则让你直接看到一堆2进制，你能看出哪个字符对应哪段2进制么。　　
4. 那你说，在py2里好像也有bytes呀，是的，不过py2里的bytes只是对str做了个别名(python2里的str就是bytes, py3里的str是unicode)，没有像py3一样给你显示的多出来一层封装，但其实其内部还是封装了的。 这么讲吧， 无论是2还是三， 从硬盘到内存，数据格式都是 010101二进制到-->b'\xe4\xbd\xa0\xe5\xa5\xbd' bytes类型－－>按照指定编码转成你能看懂的文字

编码应用比较多的场景应该是爬虫了，互联网上很多网站用的编码格式很杂，虽然整体趋向都变成utf-8，但现在还是很杂，所以爬网页时就需要你进行各种编码的转换，不过生活正在变美好，期待一个不需要转码的世界。

步入正题：

1. 函数基本语法及特性

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

特性:

1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

语法定义

def sayhi():                             # sayhi 函数名
    print("Hello, I'm nobody!")

sayhi()                                    # 调用函数

可以带参数

# 下面这段代码
a,b = 5,8
c = a**b
print(c)

# 改成用函数写
def calc(x,y):
    res = x**y
    return res                   # 返回函数执行结果

c = calc(a,b)                   ＃ 结果赋值给c变量
print(c)

2. 函数参数与局部变量

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

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。

默认参数

def stu_register(name,age,country,course):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)

stu_register("王山炮",22,"CN","python_devops")
stu_register("张叫春",21,"CN","linux")
stu_register("刘老根",25,"CN","linux")

发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是 中国， 这就是通过默认参数实现的，把country变成默认参数非常简单。

def stu_register(name,age,course,country="CN"):

这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

另外，你可能注意到了，在把country变成默认参数后，我同时把它的位置移到了最后面，为什么呢？

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 def stu_register(name, age, country='CN', course):
     print("----注册学生信息------")
     print("姓名:", name)
     print("age:", age)
     print("国籍:", country)
     print("课程:", course)

 # stu_register("王山炮", 22, "python_devops")
 # stu_register("张叫春", 21, "linux")
 stu_register("刘老根", 25, "Japan", "linux")

 '''
     def stu_register(name, age, country='CN', course):
                     ^
 SyntaxError: non-default argument follows default argument
 '''

default_var_error

关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。

stu_register(age=22,name='alex',course="python"):

非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数。

def stu_register(name,age,*args):           # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)

stu_register("Alex",22)
# 输出
# Alex 22 ()                #后面这个()就是args,只是因为没传值,所以为空

stu_register("Jack",32,"CN","Python")
# 输出
# Jack 32 ('CN', 'Python')

还可以有一个**kwargs：

def stu_register(name,age,*args,**kwargs):     # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)

stu_register("Alex",22)
# 输出
# Alex 22 () {}        #  后面这个{}就是kwargs,只是因为没传值,所以为空

stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
# 输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 '''
 def test(x,y):
     print(x)
     print(y)

 test(1,2)        # 位置参数，与形参一一对应
 1
 2

 test(y=2,x=1)    # 关键参数，与形参顺序无关
 1
 2

 test(x=2,3)        # 关键参数不能放于位置参数前
 SyntaxError: non-keyword arg after keyword arg

 test(3,x=2)
 TypeError: test() got multiple values for argument 'x'

 test(3,y=2)
 3
 2

 '''

 def test(x,y,z):
     print(x)
     print(y)
     print(z)

 # test(y=2,x=1,z=3)
 #
 #
 #

 # test(3,x=1,z=2)
 # TypeError: test() got multiple values for argument 'x'

 # test(3,y=1,z=2)
 #
 #
 #

positional & keyword argument

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 '''
 def test(x, y):
     print(x)
     print(y)

 test(1)
 TypeError: test() missing 1 required positional argument: 'y'

 test(1,2,3)
 TypeError: test() takes 2 positional arguments but 3 were given
 '''

 # def test(x, y=3):    # y = 3 为默认参数
 #     print(x)
 #     print(y)

 # test(1)
 #
 #

 # test(1,10)
 #
 #

 # 默认参数特点：函数调用时，默认参数非必传

 # def test(x=4, y):    # SyntaxError: non-default argument follows default argument
 #     print(x)
 #     print(y)

 def test(x,y,z=8):
     print(x)
     print(y)
     print(z)

 # test(3)
 # TypeError: test() missing 1 required positional argument: 'y'

 # test(2,4)
 #
 #
 #

 # test(2,4,10)
 #
 #
 #

 # test(2,z=4,y=10)
 #
 #
 #

default argument

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 '''
 # *args: 接收n个位置参数，转换成元组形式
 def test(*args):      # 传递不固定参数
     print(args)

 test(1,2,3,4,5,10)    # (1, 2, 3, 4, 5, 10)
 test(*[1,2,4,5])      # args = tuple([1,2,4,5])     (1, 2, 4, 5)

 def test1(x,*args):
     print(x)              # 1
     print(args)           # (2, 4, 6, 7, 89, 10)

 test1(1,2,4,6,7,89,10)
 '''

 '''
 # **kwargs:接收n个关键字参数转换成字典的方式
 def test2(**kwargs):
     print(kwargs)
     print(kwargs['name'])
     print(kwargs['age'])
     print(kwargs['gender'])

 test2(name='alex',age=8,gender='F')    # 关键字参数 {'gender': 'F', 'age': 8, 'name': 'alex'}
 test2(**{'name':'alex','age':8,'gender':'F'})       # {'age': 8, 'name': 'alex'}
 '''

 '''
 def test3(name,**kwargs):
     print(name)
     print(kwargs)

 # test3('alex','xxxxx')
 # TypeError: test3() takes 1 positional argument but 2 were given

 # test3('alex',age=18,gender='F')
 # alex
 # {'age': 18, 'gender': 'F'}

 # test3('alex')
 # 'alex'
 # {}
 '''

 '''
 def test4(name,**kwargs,age=18):    SyntaxError: invalid syntax
     print(name)
     print(age)
     print(kwargs)
 '''

 '''
 def test5(name,age=18,**kwargs):
     print(name)
     print(age)
     print(kwargs)

 # test5('alex',gender='F',hobby='tesla',age=3)
 # alex
 # 3
 # {'gender': 'F', 'hobby': 'tesla'}

 # test5('alex',34,gender='F',hobby='tesla',age=3)
 # TypeError: test5() got multiple values for argument 'age'
 '''

 def test6(name,age=18,*args,**kwargs):
     print(name)
     print(age)
     print(args)
     print(kwargs)
     logger('TEST4')

 def logger(source):
     print('from %s' %source)

 test6('alex',34,gender='F',hobby='tesla')

 # alex
 #
 # ()
 # {'gender': 'F', 'hobby': 'tesla'}
 # from TEST4

*args & **kwargs

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始(一级结构)定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 '''
 school = 'Fire'                         # 全局变量

 def change_name(name):
     # global school                     # 修改全局变量
     print('before changing ', name)
     name = 'Alex Li'                    # 局部变量
     school = 'Ted'
     print('after changing ', name)

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

 # before changing  alex
 # after changing  Alex Li
 # Fire
 # alex
 '''

 '''
 def change_name_1():
     global name            坚决不能在函数内修改全局变量，容易发生异常，不利于维护
     name = 'alex'

 change_name_1()
 print(name)              # alex
 '''

 name = ['Ted','Shooter','Kung']
 def change_name(name):
     name[0] = 'Alex Li'      # 引用关系，类似于C语言中的通过函数指针修改源数据
     print(name)

 change_name(name)
 print(name)

 # ['Alex Li', 'Shooter', 'Kung']
 # ['Alex Li', 'Shooter', 'Kung']

local & global variate

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 def gandpa():
     x = 'gandapa'
     def dad():
         # x = 'dady'
         def son():
            # x = 'sons'
             print('x = ',x)
         return son()
     return dad()

 gandpa()

arg_overwrite

   3.  函数的返回值                                                                　

要想获取函数的执行结果，就可以用return语句把结果返回（可以是任何类型的数据对象和函数等）

注意:

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 def func():
     print('return values.')
     return 1,'string',[1,2,{1,'list'}],{'key':'values','name':'Ted'}

 val = func()
 print(val)
 print(type(val))

 '''
 >>> return values.
 >>> (1, 'string', [1, 2, {1, 'list'}], {'key': 'values', 'name': 'Ted'})
 >>> <class 'tuple'>
 '''

return values

插入知识点：嵌套函数

定义：在一个函数体内，定义的一个完整的函数（嵌套函数），嵌套函数又叫内部函数；被嵌套的函数叫做该嵌套函数的外部函数；

函数可以多重嵌套。

请看以下代码：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 def test1():
     print('in the test1.')
     def innertest():         # 函数的嵌套
         print('inner func.')
     test()                   # 外部函数的调用
     innertest()              # 嵌套函数的调用

 def test():
     print('in the test.')

 test1()
 innertest()    # 嵌套函数的作用域仅限于其外部函数体范围

 '''
 innertest()
 NameError: name 'innertest' is not defined
 in the test1.
 in the test.
 inner func.
 '''

nested function and call

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 def gandpa():
     x = 'gandapa'
     def dad():
         # x = 'dady'
         def son():
            # x = 'sons'
             print('x = ',x)
         return son()
     return dad()

 gandpa()

multiple nested function

4.  递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))

calc(10)

输出：
10
5
2
1

递归特性:

1. 必须有一个明确的结束条件；

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少；

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）。

特点

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

递归算法解决问题的特点：

(1) 递归就是在过程或函数里调用自身。

(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。

(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

要求

递归算法所体现的“重复”一般有三个要求：

一是每次调用在规模上都有所缩小(通常是减半)；

二是相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)；

三是在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

堆栈扫盲： http://www.cnblogs.com/ant-colonies/p/6654993.html

递归函数实际应用案例，二分查找

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 data = [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]

 def binary_search(dataset, find_num):
     dataset.sort()
     print(dataset)

     length = len(dataset)
     if length > 1:
         mid = int(length/2)
         if dataset[mid] == find_num:
             print('got the number %s' %dataset[mid])
         elif dataset[mid] < find_num:
             print('\033[31;1mthe number you finding is on the right of %s'% dataset[mid])
             return binary_search(dataset[mid + 1: ], find_num)
         else:
             print('\033[31;1mthe number you finding is on the left of %s' % dataset[mid])
             return binary_search(dataset[ :mid + 1], find_num)
     else:
         if dataset[0] == find_num:
             print('got the number %s' % dataset[0])
         else:
             print('Unfortunately, the number %s you finding is out of the list' %find_num)

 print(data)
 num = int(input('input a search number: '))
 binary_search(data, num)

binary_search

注意列表排序操作的特性：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 data = [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]

 print(data)                                 # [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]
 print(id(data))                             #
 print(data[0])                              #
 print(id(data[0]))                          #
 print(data[data.index(0)])                  #
 print(id(data[data.index(0)]))              #
 for i in range(len(data)):
     print('data[%d] : %d' %(i, id(data[i])))

 print('=======================')

 DATA = data.sort()
 print(DATA)                                 # None
 print(type(DATA))                           # <class 'NoneType'>
 print(id(DATA))                             #
 print(data)                                 # [0, 1, 3, 4, 5, 10, 25, 50, 60, 66, 72, 99]
 print(id(data))                             #
 print(data[0])                              #
 print(id(data[0]))                          #
 for i in range(len(data)):
     print('data[%d] : %d' % (i, id(data[i])))

 '''
    在list排序操作中可以得出以下结论：
        1、没有返回值
        2、排序改变的只是索引关系，数据对象并未改变
        3、变量名data指向的是数据对象的地址
        4、数据对象索引的地址并非第一个元素的地址
               (与C语言中数组的结构不同，
                数组名与数组的第一个元素变量的地址索引相同，
                且数组元素的地址是连续的)
 '''

 '''
 [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]
 32507656
 1
 1727051440
 0
 data[0] : 1727051440
 data[1] : 1727051504
 data[2] : 1727051568
 data[3] : 1727051728
 data[4] : 1727053008
 data[5] : 1727052208
 data[6] : 1727053328
 data[7] : 1727054576
 data[8] : 1727053712
 data[9] : 1727051408
 data[10] : 1727051536
 data[11] : 1727053520
 =======================
 None
 <class 'NoneType'>
 1726802688
 [0, 1, 3, 4, 5, 10, 25, 50, 60, 66, 72, 99]
 32507656
 0
 data[0] : 1727051408
 data[1] : 1727051440
 data[2] : 1727051504
 data[3] : 1727051536
 data[4] : 1727051568
 data[5] : 1727051728
 data[6] : 1727052208
 data[7] : 1727053008
 data[8] : 1727053328
 data[9] : 1727053520
 data[10] : 1727053712
 data[11] : 1727054576
 '''

list_sort

 5. 匿名函数                                                      

匿名函数lambda是一种快速定义单行的最小函数，可以用在任何需要函数的地方。

一般定义的函数：

def func(x,y):
      return x*y

lambda函数定义：

r = lambda x,y:x*y
print r(2,3)

格式：

　　lambda 参数列表：表达式/变量

      关键字lambda表示匿名函数，冒号前面的表示函数参数。

　　由于lambda返回的是函数对象（构建的是一个函数对象），所以需要定义一个变量去接收此对象，故无需return 返回。

匿名函数优点：

　　- 使用Python写一些脚本时，使用lambda可以省去定义函数的过程，精简代码；

　　- 使用lambda不需要考虑函数命名的问题，避免函数名的冲突，且节省了为函数名分配的内存空间；

>>> f = lambda x: x*x
>>> f
<function <lambda> at 0x0000000003575488>
>>> f(5)
25
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> res = map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> res
<map object at 0x000000000356E748>
>>> for i in res:
    print(i)

1
4
9
16
25
36
49
64
81
>>> 

lambda function

 6. 函数式编程                                                              

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程——Function Programming，虽也可归结于面向过程的程序设计，但其思想更接近数学计算。

计算机——CPU执行的是加减乘除指令，逻辑判断指令和跳转指令，因此汇编语言最接近计算机硬件的语言。

计算——数学意义上的计算，越是抽象的计算，离计算机硬件越远。

对应于编程语言，越低级的语言，越接近计算机语言，抽象程度越低，执行效率越高，比如C；

越高级的语言，越接近计算，抽象程度越高，执行效率越低，比如Lisp语言。

函数式编程是一种抽象程度很高的编程范式（programming paradigm），纯粹的函数式编程语言编写的函数没有变量，任意一个函数，只要输入参数确定，输出就唯一确定，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不定，同样的参数输入，可能得到不同的输出，这种函数具有副作用。

函数式编程的一个特点——允许把函数本身作为另一个函数的参数，并允许返回一个函数。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。

Python部分支持函数式编程。由于Python的函数中允许使用变量，因此，Python不是纯函数式编程语言。

一、定义

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：

　　(1 + 2) * 3 - 4

传统的过程式编程，可能这样写：

　　var a = 1 + 2;

　　var b = a * 3;

　　var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

　　var result = subtract(multiply(add(1,2), 3), 4);

这段代码再演进以下，可以变成这样

add(1,2).multiply(3).subtract(4)

这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：

merge([1,2],[3,4]).sort().search("2")

因此，函数式编程的代码更容易理解。

要想学好函数式编程，不要玩py,玩Erlang,Haskell。

7.高阶函数

函数即"变量"，变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

高阶函数的特性：

a. 把一个函数名当作实参传递给另一个函数(在不修改被装饰函数源代码的前提下为其添加新功能)；
      b. 返回值中包含函数名(不修改函数的调用方式)。

def add(x,y,f):
    return f(x) + f(y)

res = add(3,-6,abs)
print(res)

8. 内置参数　　

内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii

 #compile
 f = open("函数递归.py")
 data =compile(f.read(),'','exec')
 exec(data)

 #print
 msg = "又回到最初的起点"
 f = open("tofile","w")
 print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)

 # #slice
 # a = range(20)
 # pattern = slice(3,8,2)
 # for i in a[pattern]: #等于a[3:8:2]
 #     print(i)
 #
 #

 #memoryview
 #usage:
 #>>> memoryview(b'abcd')
 #<memory at 0x104069648>
 #在进行切片并赋值数据时，不需要重新copy原列表数据，可以直接映射原数据内存，
 import time
 for n in (100000, 200000, 300000, 400000):
     data = b'x'*n
     start = time.time()
     b = data
     while b:
         b = b[1:]
     print('bytes', n, time.time()-start)

 for n in (100000, 200000, 300000, 400000):
     data = b'x'*n
     start = time.time()
     b = memoryview(data)
     while b:
         b = b[1:]
     print('memoryview', n, time.time()-start)

build-in method

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author: antcolonies

 # print(all([-1, 5, 3]))
 # print(any([1,0]))

 # a = ascii([1,2,'这是中文'])
 # print(type(a), [a])           # <class 'str'> ["[1, 2, '\\u8fd9\\u662f\\u4e2d\\u6587']"]
 # print(repr(a))                  # "[1, 2, '\\u8fd9\\u662f\\u4e2d\\u6587']"

 # print(bin(123))     0b1111011
 # print(bin(255))     0b11111111
 # print(bin(8))       0b1000
 # oct()
 # hex()

 # a = bytes('abcde', encoding='utf-8')
 # print(a.capitalize(), a)              #  b'Abcde' b'abcde'

 # b = bytearray('abcde', encoding='utf-8')
 # print( b[0] )      # 97      a的ascii码
 # print(b[1])        # 98
 # b[1] = 50
 # print(b)           # bytearray(b'a2cde')

 # print(callable([]))      # False
 # def sayhi():pass
 # print(callable(sayhi))   # True

 # print(chr(98))       # b
 # print(chr(123))      # {
 # print(ord('b'))        # 98
 # print(ord('{'))        # 123

 '''
 >>> code = 'for i in range(10):print(i)'
 >>>
 >>> code
 'for i in range(10):print(i)'
 >>> compile(code, '', 'exec')
 <code object <module> at 0x000000000347AF60, file "", line 1>
 >>> c = compile(code, '', 'exec')
 >>> exec(c)
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 >>>
 >>> code = '1+3/2*6'
 >>> code
 '1+3/2*6'
 >>> c = compile(code, '', 'eval')
 >>> c
 <code object <module> at 0x0000000003451AE0, file "", line 1>
 >>> eval(c)
 10.0
 >>> eval(code)
 10.0
 >>>
 '''

 # >>> a = {}
 # >>> dir(a)
 # ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
 # >>>

 # >>> divmod(5,3)
 # (1, 2)
 # >>> divmod(100,7)
 # (14, 2)
 # >>>

 # eval()
 # exec()

 # >>>
 # >>> (lambda x: print(x + 1))(5)
 #
 # >>> calc = lambda n: 3 if n < 4 else n
 # >>> calc(5)
 #
 # >>>
 # >>> res = filter(lambda n: n > 5, range(10))
 # >>> for i in res:
 #    print(i)
 #
 #
 #
 #
 #
 # >>>

 '''
 >>> res = map(lambda n:n>5,range(10))
 >>> for i in res:
     print(i)

 False
 False
 False
 False
 False
 False
 True
 True
 True
 True
 >>> res = map(lambda n:n*2,range(10))
 >>> for i in res:
     print(i)

 0
 2
 4
 6
 8
 10
 12
 14
 16
 18
 >>> res = [i*2 for i in range(10)]   # res = [lambda i*2 for i in range(10)]
 >>> for i in res:
     print(i)

 0
 2
 4
 6
 8
 10
 12
 14
 16
 18
 >>>
 '''

 # import functools
 # res = functools.reduce(lambda x,y:x+y,range(10))
 # print(res)           # 45
 #
 # res = functools.reduce(lambda x,y:x*y,range(1,10))
 # print(res)      # 362880    9!

 # a = set([1,4,5,88,34,33,5,1])
 # print(a)          # {1, 34, 33, 4, 5, 88}
 # b = frozenset([1,4,5,88,34,33,5,1])
 # print(b)          # frozenset({1, 34, 33, 4, 5, 88})

 # print(globals())    # 打印全局变量

 # def test():
 #     local_var = 333
 #     print(locals())          # {'local_var': 333}
 #     print(globals().get('local_var'))     # None
 # test()
 # print(globals().get('local_var'))         # None

 # print(hash('alex'))        # 8256347639460147595
 # print(hash('alex'))        # 8256347639460147595
 # print(hash('Ted'))         # 6081961024648288838
 # print(hash('Ted'))         # 6081961024648288838

 # pow(2,8)

 # print(round(1.2345))          # 1
 # print(round(1.2345,2))        # 1.23

 # d = range(20)
 # print(d)                       # range(0, 20)
 # print(d[slice(2,5)])           # range(2, 5)
 # print(d[2:5])                  # range(2, 5)

 # a = {6:2,8:0,1:4,-5:6,99:11}
 # print(a)
 # print(sorted(a))
 # print(sorted(a.items()))
 # print(sorted(a.items(), key=lambda x:x[1]))     # 不懂
 # print(a)
 '''
 {8: 0, 1: 4, -5: 6, 6: 2, 99: 11}
 [-5, 1, 6, 8, 99]
 [(-5, 6), (1, 4), (6, 2), (8, 0), (99, 11)]
 [(8, 0), (6, 2), (1, 4), (-5, 6), (99, 11)]
 {8: 0, 1: 4, -5: 6, 6: 2, 99: 11}
 '''

 # a = [1,2,3,4,5,6]
 # b = ['a','b','c','d']
 # print(zip(a,b))          # <zip object at 0x0000000002213148>
 # for i in zip(a,b):       # map(a,b)
 #     print(i)
 '''
 (1, 'a')
 (2, 'b')
 (3, 'c')
 (4, 'd')
 '''

 # import encode
 # __import__('encode')

build_in

本节作业

有以下员工信息表

当然此表你在文件存储时可以这样表示

1,Alex Li,22,13651054608,IT,2013-04-01

现需要对这个员工信息文件，实现增删改查操作

1. 可进行模糊查询，语法至少支持下面3种:
   1. 　　select name,age from staff_table where age > 22
   2. 　　select  * from staff_table where dept = "IT"
   3. select  * from staff_table where enroll_date like "2013"
   4. 查到的信息，打印后，最后面还要显示查到的条数
2. 可创建新员工纪录，以phone做唯一键，staff_id需自增
3. 可删除指定员工信息纪录，输入员工id，即可删除
4. 可修改员工信息，语法如下:
   1. 　　UPDATE staff_table SET dept="Market" WHERE where dept = "IT"

 注意：以上需求，要充分使用函数，请尽你的最大限度来减少重复代码！

==================