day03

本节内容

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
>>> 

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'xe4xbdxa0xe5xa5xbd' 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
'''

关键参数

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

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)
# 1
# 2
# 3

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

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

#!/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)
# 1
# 3

# test(1,10)
# 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)
# 2
# 4
# 8

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

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

#!/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
# 34
# ()
# {'gender': 'F', 'hobby': 'tesla'}
# from TEST4

全局与局部变量

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

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

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

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

#!/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']

#!/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()

   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'>
'''

   插入知识点：嵌套函数                                                        

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

        函数可以多重嵌套。

请看以下代码：

#!/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.
'''

#!/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()

 

  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('33[31;1mthe number you finding is on the right of %s'% dataset[mid])
            return binary_search(dataset[mid + 1: ], find_num)
        else:
            print('33[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)

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

#!/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))                             # 32507656
print(data[0])                              # 1
print(id(data[0]))                          # 1727051440
print(data[data.index(0)])                  # 0
print(id(data[data.index(0)]))              # 1727051408
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))                             # 1726802688
print(data)                                 # [0, 1, 3, 4, 5, 10, 25, 50, 60, 66, 72, 99]
print(id(data))                             # 32507656
print(data[0])                              # 0
print(id(data[0]))                          # 1727051408
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
'''

 

 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
>>> 

 

 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)

#!/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)
# 6
# >>> calc = lambda n: 3 if n < 4 else n
# >>> calc(5)
# 5
# >>>
# >>> res = filter(lambda n: n > 5, range(10))
# >>> for i in res:
#    print(i)
#
# 6
# 7
# 8
# 9
# >>>

'''
>>> 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')

 本节作业                                      

有以下员工信息表

 

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

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"

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

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