本节内容

1. 函数基本语法及特性

2. 参数与局部变量

3. 返回值

嵌套函数

4.递归

5.匿名函数

6.函数式编程介绍

7.高阶函数

8.内置函数

 温故知新                                                                                  

1. 集合

主要作用:

  1. 去重
  2. 关系测试， 交集＼差集＼并集＼反向(对称)差集
  1.  >>> a = {1,2,3,4}
  2.  >>> b = {3,4,5,6}
  3.  >>> a
  4.  {1, 2, 3, 4}
  5.  >>> type(a)
  6.  <class 'set'>
  7.  >>> a.symmetric_difference(b)
  8.  {1, 2, 5, 6}
  9.  >>> b.symmetric_difference(a)
  10.  {1, 2, 5, 6}
  11.  >>>
  12.  >>>
  13.  >>> a.difference(b)
  14.  {1, 2}
  15.  >>> a.union(b)
  16.  {1, 2, 3, 4, 5, 6}
  17.  >>> a.issubset(b)
  18.  False
  19.  >>>

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. 使程序变得易维护

语法定义

  1. def sayhi():                             # sayhi 函数名
  2.     print("Hello, I'm nobody!")
  3.  
  4. sayhi()                                    # 调用函数

可以带参数

  1. # 下面这段代码
  2. a,b = 5,8
  3. c = a**b
  4. print(c)
  5.  
  6. # 改成用函数写
  7. def calc(x,y):
  8.     res = x**y
  9.     return res                   # 返回函数执行结果
  10.  
  11. c = calc(a,b)                   ＃ 结果赋值给c变量
  12. print(c)

2. 函数参数与局部变量

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

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

默认参数

  1. def stu_register(name,age,country,course):
  2.     print("----注册学生信息------")
  3.     print("姓名:",name)
  4.     print("age:",age)
  5.     print("国籍:",country)
  6.     print("课程:",course)
  7.  
  8. stu_register("王山炮",22,"CN","python_devops")
  9. stu_register("张叫春",21,"CN","linux")
  10. stu_register("刘老根",25,"CN","linux")

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

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

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

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

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  def stu_register(name, age, country='CN', course):
  6.      print("----注册学生信息------")
  7.      print("姓名:", name)
  8.      print("age:", age)
  9.      print("国籍:", country)
  10.      print("课程:", course)
  11.  
  12.  # stu_register("王山炮", 22, "python_devops")
  13.  # stu_register("张叫春", 21, "linux")
  14.  stu_register("刘老根", 25, "Japan", "linux")
  15.  
  16.  '''
  17.      def stu_register(name, age, country='CN', course):
  18.                      ^
  19.  SyntaxError: non-default argument follows default argument
  20.  '''

default_var_error

关键参数

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

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

非固定参数

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

  1. def stu_register(name,age,*args):           # *args 会把多传入的参数变成一个元组形式
  2.     print(name,age,args)
  3.  
  4. stu_register("Alex",22)
  5. # 输出
  6. # Alex 22 ()                #后面这个()就是args,只是因为没传值,所以为空
  7.  
  8. stu_register("Jack",32,"CN","Python")
  9. # 输出
  10. # Jack 32 ('CN', 'Python')

还可以有一个**kwargs：

  1. def stu_register(name,age,*args,**kwargs):     # *kwargs 会把多传入的参数变成一个dict形式
  2.     print(name,age,args,kwargs)
  3.  
  4. stu_register("Alex",22)
  5. # 输出
  6. # Alex 22 () {}        #  后面这个{}就是kwargs,只是因为没传值,所以为空
  7.  
  8. stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
  9. # 输出
  10. # Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}
  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  '''
  6.  def test(x,y):
  7.      print(x)
  8.      print(y)
  9.  
  10.  test(1,2)        # 位置参数，与形参一一对应
  11.  1
  12.  2
  13.  
  14.  test(y=2,x=1)    # 关键参数，与形参顺序无关
  15.  1
  16.  2
  17.  
  18.  test(x=2,3)        # 关键参数不能放于位置参数前
  19.  SyntaxError: non-keyword arg after keyword arg
  20.  
  21.  test(3,x=2)
  22.  TypeError: test() got multiple values for argument 'x'
  23.  
  24.  test(3,y=2)
  25.  3
  26.  2
  27.  
  28.  '''
  29.  
  30.  def test(x,y,z):
  31.      print(x)
  32.      print(y)
  33.      print(z)
  34.  
  35.  # test(y=2,x=1,z=3)
  36.  #
  37.  #
  38.  #
  39.  
  40.  # test(3,x=1,z=2)
  41.  # TypeError: test() got multiple values for argument 'x'
  42.  
  43.  # test(3,y=1,z=2)
  44.  #
  45.  #
  46.  #

positional & keyword argument

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  '''
  6.  def test(x, y):
  7.      print(x)
  8.      print(y)
  9.  
  10.  test(1)
  11.  TypeError: test() missing 1 required positional argument: 'y'
  12.  
  13.  test(1,2,3)
  14.  TypeError: test() takes 2 positional arguments but 3 were given
  15.  '''
  16.  
  17.  # def test(x, y=3):    # y = 3 为默认参数
  18.  #     print(x)
  19.  #     print(y)
  20.  
  21.  # test(1)
  22.  #
  23.  #
  24.  
  25.  # test(1,10)
  26.  #
  27.  #
  28.  
  29.  # 默认参数特点：函数调用时，默认参数非必传
  30.  
  31.  # def test(x=4, y):    # SyntaxError: non-default argument follows default argument
  32.  #     print(x)
  33.  #     print(y)
  34.  
  35.  def test(x,y,z=8):
  36.      print(x)
  37.      print(y)
  38.      print(z)
  39.  
  40.  # test(3)
  41.  # TypeError: test() missing 1 required positional argument: 'y'
  42.  
  43.  # test(2,4)
  44.  #
  45.  #
  46.  #
  47.  
  48.  # test(2,4,10)
  49.  #
  50.  #
  51.  #
  52.  
  53.  # test(2,z=4,y=10)
  54.  #
  55.  #
  56.  #

default argument

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  '''
  6.  # *args: 接收n个位置参数，转换成元组形式
  7.  def test(*args):      # 传递不固定参数
  8.      print(args)
  9.  
  10.  test(1,2,3,4,5,10)    # (1, 2, 3, 4, 5, 10)
  11.  test(*[1,2,4,5])      # args = tuple([1,2,4,5])     (1, 2, 4, 5)
  12.  
  13.  def test1(x,*args):
  14.      print(x)              # 1
  15.      print(args)           # (2, 4, 6, 7, 89, 10)
  16.  
  17.  test1(1,2,4,6,7,89,10)
  18.  '''
  19.  
  20.  '''
  21.  # **kwargs:接收n个关键字参数转换成字典的方式
  22.  def test2(**kwargs):
  23.      print(kwargs)
  24.      print(kwargs['name'])
  25.      print(kwargs['age'])
  26.      print(kwargs['gender'])
  27.  
  28.  test2(name='alex',age=8,gender='F')    # 关键字参数 {'gender': 'F', 'age': 8, 'name': 'alex'}
  29.  test2(**{'name':'alex','age':8,'gender':'F'})       # {'age': 8, 'name': 'alex'}
  30.  '''
  31.  
  32.  '''
  33.  def test3(name,**kwargs):
  34.      print(name)
  35.      print(kwargs)
  36.  
  37.  # test3('alex','xxxxx')
  38.  # TypeError: test3() takes 1 positional argument but 2 were given
  39.  
  40.  # test3('alex',age=18,gender='F')
  41.  # alex
  42.  # {'age': 18, 'gender': 'F'}
  43.  
  44.  # test3('alex')
  45.  # 'alex'
  46.  # {}
  47.  '''
  48.  
  49.  '''
  50.  def test4(name,**kwargs,age=18):    SyntaxError: invalid syntax
  51.      print(name)
  52.      print(age)
  53.      print(kwargs)
  54.  '''
  55.  
  56.  '''
  57.  def test5(name,age=18,**kwargs):
  58.      print(name)
  59.      print(age)
  60.      print(kwargs)
  61.  
  62.  # test5('alex',gender='F',hobby='tesla',age=3)
  63.  # alex
  64.  # 3
  65.  # {'gender': 'F', 'hobby': 'tesla'}
  66.  
  67.  # test5('alex',34,gender='F',hobby='tesla',age=3)
  68.  # TypeError: test5() got multiple values for argument 'age'
  69.  '''
  70.  
  71.  def test6(name,age=18,*args,**kwargs):
  72.      print(name)
  73.      print(age)
  74.      print(args)
  75.      print(kwargs)
  76.      logger('TEST4')
  77.  
  78.  def logger(source):
  79.      print('from %s' %source)
  80.  
  81.  test6('alex',34,gender='F',hobby='tesla')
  82.  
  83.  # alex
  84.  #
  85.  # ()
  86.  # {'gender': 'F', 'hobby': 'tesla'}
  87.  # from TEST4

*args & **kwargs

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始(一级结构)定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  '''
  6.  school = 'Fire'                         # 全局变量
  7.  
  8.  def change_name(name):
  9.      # global school                     # 修改全局变量
  10.      print('before changing ', name)
  11.      name = 'Alex Li'                    # 局部变量
  12.      school = 'Ted'
  13.      print('after changing ', name)
  14.  
  15.  name = 'alex'
  16.  change_name(name)
  17.  print(school)
  18.  print(name)
  19.  
  20.  # before changing  alex
  21.  # after changing  Alex Li
  22.  # Fire
  23.  # alex
  24.  '''
  25.  
  26.  '''
  27.  def change_name_1():
  28.      global name            坚决不能在函数内修改全局变量，容易发生异常，不利于维护
  29.      name = 'alex'
  30.  
  31.  change_name_1()
  32.  print(name)              # alex
  33.  '''
  34.  
  35.  name = ['Ted','Shooter','Kung']
  36.  def change_name(name):
  37.      name[0] = 'Alex Li'      # 引用关系，类似于C语言中的通过函数指针修改源数据
  38.      print(name)
  39.  
  40.  change_name(name)
  41.  print(name)
  42.  
  43.  # ['Alex Li', 'Shooter', 'Kung']
  44.  # ['Alex Li', 'Shooter', 'Kung']

local & global variate

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  def gandpa():
  6.      x = 'gandapa'
  7.      def dad():
  8.          # x = 'dady'
  9.          def son():
  10.             # x = 'sons'
  11.              print('x = ',x)
  12.          return son()
  13.      return dad()
  14.  
  15.  gandpa()

arg_overwrite

   3.  函数的返回值                                                                　

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

注意:

  1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
  2. 如果未在函数中指定return,那这个函数的返回值为None
  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  def func():
  6.      print('return values.')
  7.      return 1,'string',[1,2,{1,'list'}],{'key':'values','name':'Ted'}
  8.  
  9.  val = func()
  10.  print(val)
  11.  print(type(val))
  12.  
  13.  '''
  14.  >>> return values.
  15.  >>> (1, 'string', [1, 2, {1, 'list'}], {'key': 'values', 'name': 'Ted'})
  16.  >>> <class 'tuple'>
  17.  '''

return values

插入知识点：嵌套函数

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

函数可以多重嵌套。

请看以下代码：

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  def test1():
  6.      print('in the test1.')
  7.      def innertest():         # 函数的嵌套
  8.          print('inner func.')
  9.      test()                   # 外部函数的调用
  10.      innertest()              # 嵌套函数的调用
  11.  
  12.  def test():
  13.      print('in the test.')
  14.  
  15.  test1()
  16.  innertest()    # 嵌套函数的作用域仅限于其外部函数体范围
  17.  
  18.  '''
  19.  innertest()
  20.  NameError: name 'innertest' is not defined
  21.  in the test1.
  22.  in the test.
  23.  inner func.
  24.  '''

nested function and call

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  def gandpa():
  6.      x = 'gandapa'
  7.      def dad():
  8.          # x = 'dady'
  9.          def son():
  10.             # x = 'sons'
  11.              print('x = ',x)
  12.          return son()
  13.      return dad()
  14.  
  15.  gandpa()

multiple nested function

4.  递归

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

  1. def calc(n):
  2.     print(n)
  3.     if int(n/2) ==0:
  4.         return n
  5.     return calc(int(n/2))
  6.  
  7. calc(10)
  8.  
  9. 输出：
  10. 10
  11. 5
  12. 2
  13. 1

递归特性:

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

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

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

特点

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
递归算法解决问题的特点：
(1) 递归就是在过程或函数里调用自身。
(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

要求

递归算法所体现的“重复”一般有三个要求：
一是每次调用在规模上都有所缩小(通常是减半)；
二是相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)；
三是在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

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

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

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  data = [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]
  6.  
  7.  def binary_search(dataset, find_num):
  8.      dataset.sort()
  9.      print(dataset)
  10.  
  11.      length = len(dataset)
  12.      if length > 1:
  13.          mid = int(length/2)
  14.          if dataset[mid] == find_num:
  15.              print('got the number %s' %dataset[mid])
  16.          elif dataset[mid] < find_num:
  17.              print('\033[31;1mthe number you finding is on the right of %s'% dataset[mid])
  18.              return binary_search(dataset[mid + 1: ], find_num)
  19.          else:
  20.              print('\033[31;1mthe number you finding is on the left of %s' % dataset[mid])
  21.              return binary_search(dataset[ :mid + 1], find_num)
  22.      else:
  23.          if dataset[0] == find_num:
  24.              print('got the number %s' % dataset[0])
  25.          else:
  26.              print('Unfortunately, the number %s you finding is out of the list' %find_num)
  27.  
  28.  print(data)
  29.  num = int(input('input a search number: '))
  30.  binary_search(data, num)

binary_search

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

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  data = [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]
  6.  
  7.  print(data)                                 # [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]
  8.  print(id(data))                             #
  9.  print(data[0])                              #
  10.  print(id(data[0]))                          #
  11.  print(data[data.index(0)])                  #
  12.  print(id(data[data.index(0)]))              #
  13.  for i in range(len(data)):
  14.      print('data[%d] : %d' %(i, id(data[i])))
  15.  
  16.  print('=======================')
  17.  
  18.  DATA = data.sort()
  19.  print(DATA)                                 # None
  20.  print(type(DATA))                           # <class 'NoneType'>
  21.  print(id(DATA))                             #
  22.  print(data)                                 # [0, 1, 3, 4, 5, 10, 25, 50, 60, 66, 72, 99]
  23.  print(id(data))                             #
  24.  print(data[0])                              #
  25.  print(id(data[0]))                          #
  26.  for i in range(len(data)):
  27.      print('data[%d] : %d' % (i, id(data[i])))
  28.  
  29.  '''
  30.     在list排序操作中可以得出以下结论：
  31.         1、没有返回值
  32.         2、排序改变的只是索引关系，数据对象并未改变
  33.         3、变量名data指向的是数据对象的地址
  34.         4、数据对象索引的地址并非第一个元素的地址
  35.                (与C语言中数组的结构不同，
  36.                 数组名与数组的第一个元素变量的地址索引相同，
  37.                 且数组元素的地址是连续的)
  38.  '''
  39.  
  40.  '''
  41.  [1, 3, 5, 10, 50, 25, 60, 99, 72, 0, 4, 66]
  42.  32507656
  43.  1
  44.  1727051440
  45.  0
  46.  data[0] : 1727051440
  47.  data[1] : 1727051504
  48.  data[2] : 1727051568
  49.  data[3] : 1727051728
  50.  data[4] : 1727053008
  51.  data[5] : 1727052208
  52.  data[6] : 1727053328
  53.  data[7] : 1727054576
  54.  data[8] : 1727053712
  55.  data[9] : 1727051408
  56.  data[10] : 1727051536
  57.  data[11] : 1727053520
  58.  =======================
  59.  None
  60.  <class 'NoneType'>
  61.  1726802688
  62.  [0, 1, 3, 4, 5, 10, 25, 50, 60, 66, 72, 99]
  63.  32507656
  64.  0
  65.  data[0] : 1727051408
  66.  data[1] : 1727051440
  67.  data[2] : 1727051504
  68.  data[3] : 1727051536
  69.  data[4] : 1727051568
  70.  data[5] : 1727051728
  71.  data[6] : 1727052208
  72.  data[7] : 1727053008
  73.  data[8] : 1727053328
  74.  data[9] : 1727053520
  75.  data[10] : 1727053712
  76.  data[11] : 1727054576
  77.  '''

list_sort

 5. 匿名函数                                                      

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

一般定义的函数：

  1. def func(x,y):
  2.       return x*y

lambda函数定义：

  1. r = lambda x,y:x*y
  2. print r(2,3)
格式：
　　lambda 参数列表：表达式/变量
      关键字lambda表示匿名函数，冒号前面的表示函数参数。
　　由于lambda返回的是函数对象（构建的是一个函数对象），所以需要定义一个变量去接收此对象，故无需return 返回。
匿名函数优点：
　　- 使用Python写一些脚本时，使用lambda可以省去定义函数的过程，精简代码；
　　- 使用lambda不需要考虑函数命名的问题，避免函数名的冲突，且节省了为函数名分配的内存空间；
  1. >>> f = lambda x: x*x
  2. >>> f
  3. <function <lambda> at 0x0000000003575488>
  4. >>> f(5)
  5. 25
  6. >>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
  7. [1, 4, 9, 16, 25, 36, 49, 64, 81]
  8. >>> res = map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
  9. >>> res
  10. <map object at 0x000000000356E748>
  11. >>> for i in res:
  12.     print(i)
  13.  
  14. 1
  15. 4
  16. 9
  17. 16
  18. 25
  19. 36
  20. 49
  21. 64
  22. 81
  23. >>>

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. 返回值中包含函数名(不修改函数的调用方式)。

  1. def add(x,y,f):
  2.     return f(x) + f(y)
  3.  
  4. res = add(3,-6,abs)
  5. print(res)

8. 内置参数　　

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

  1.  #compile
  2.  f = open("函数递归.py")
  3.  data =compile(f.read(),'','exec')
  4.  exec(data)
  5.  
  6.  #print
  7.  msg = "又回到最初的起点"
  8.  f = open("tofile","w")
  9.  print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)
  10.  
  11.  # #slice
  12.  # a = range(20)
  13.  # pattern = slice(3,8,2)
  14.  # for i in a[pattern]: #等于a[3:8:2]
  15.  #     print(i)
  16.  #
  17.  #
  18.  
  19.  #memoryview
  20.  #usage:
  21.  #>>> memoryview(b'abcd')
  22.  #<memory at 0x104069648>
  23.  #在进行切片并赋值数据时，不需要重新copy原列表数据，可以直接映射原数据内存，
  24.  import time
  25.  for n in (100000, 200000, 300000, 400000):
  26.      data = b'x'*n
  27.      start = time.time()
  28.      b = data
  29.      while b:
  30.          b = b[1:]
  31.      print('bytes', n, time.time()-start)
  32.  
  33.  for n in (100000, 200000, 300000, 400000):
  34.      data = b'x'*n
  35.      start = time.time()
  36.      b = memoryview(data)
  37.      while b:
  38.          b = b[1:]
  39.      print('memoryview', n, time.time()-start)

build-in method

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  # Author: antcolonies
  4.  
  5.  # print(all([-1, 5, 3]))
  6.  # print(any([1,0]))
  7.  
  8.  # a = ascii([1,2,'这是中文'])
  9.  # print(type(a), [a])           # <class 'str'> ["[1, 2, '\\u8fd9\\u662f\\u4e2d\\u6587']"]
  10.  # print(repr(a))                  # "[1, 2, '\\u8fd9\\u662f\\u4e2d\\u6587']"
  11.  
  12.  # print(bin(123))     0b1111011
  13.  # print(bin(255))     0b11111111
  14.  # print(bin(8))       0b1000
  15.  # oct()
  16.  # hex()
  17.  
  18.  # a = bytes('abcde', encoding='utf-8')
  19.  # print(a.capitalize(), a)              #  b'Abcde' b'abcde'
  20.  
  21.  # b = bytearray('abcde', encoding='utf-8')
  22.  # print( b[0] )      # 97      a的ascii码
  23.  # print(b[1])        # 98
  24.  # b[1] = 50
  25.  # print(b)           # bytearray(b'a2cde')
  26.  
  27.  # print(callable([]))      # False
  28.  # def sayhi():pass
  29.  # print(callable(sayhi))   # True
  30.  
  31.  # print(chr(98))       # b
  32.  # print(chr(123))      # {
  33.  # print(ord('b'))        # 98
  34.  # print(ord('{'))        # 123
  35.  
  36.  '''
  37.  >>> code = 'for i in range(10):print(i)'
  38.  >>>
  39.  >>> code
  40.  'for i in range(10):print(i)'
  41.  >>> compile(code, '', 'exec')
  42.  <code object <module> at 0x000000000347AF60, file "", line 1>
  43.  >>> c = compile(code, '', 'exec')
  44.  >>> exec(c)
  45.  0
  46.  1
  47.  2
  48.  3
  49.  4
  50.  5
  51.  6
  52.  7
  53.  8
  54.  9
  55.  >>>
  56.  >>> code = '1+3/2*6'
  57.  >>> code
  58.  '1+3/2*6'
  59.  >>> c = compile(code, '', 'eval')
  60.  >>> c
  61.  <code object <module> at 0x0000000003451AE0, file "", line 1>
  62.  >>> eval(c)
  63.  10.0
  64.  >>> eval(code)
  65.  10.0
  66.  >>>
  67.  '''
  68.  
  69.  # >>> a = {}
  70.  # >>> dir(a)
  71.  # ['__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']
  72.  # >>>
  73.  
  74.  # >>> divmod(5,3)
  75.  # (1, 2)
  76.  # >>> divmod(100,7)
  77.  # (14, 2)
  78.  # >>>
  79.  
  80.  # eval()
  81.  # exec()
  82.  
  83.  # >>>
  84.  # >>> (lambda x: print(x + 1))(5)
  85.  #
  86.  # >>> calc = lambda n: 3 if n < 4 else n
  87.  # >>> calc(5)
  88.  #
  89.  # >>>
  90.  # >>> res = filter(lambda n: n > 5, range(10))
  91.  # >>> for i in res:
  92.  #    print(i)
  93.  #
  94.  #
  95.  #
  96.  #
  97.  #
  98.  # >>>
  99.  
  100.  '''
  101.  >>> res = map(lambda n:n>5,range(10))
  102.  >>> for i in res:
  103.      print(i)
  104.  
  105.  False
  106.  False
  107.  False
  108.  False
  109.  False
  110.  False
  111.  True
  112.  True
  113.  True
  114.  True
  115.  >>> res = map(lambda n:n*2,range(10))
  116.  >>> for i in res:
  117.      print(i)
  118.  
  119.  0
  120.  2
  121.  4
  122.  6
  123.  8
  124.  10
  125.  12
  126.  14
  127.  16
  128.  18
  129.  >>> res = [i*2 for i in range(10)]   # res = [lambda i*2 for i in range(10)]
  130.  >>> for i in res:
  131.      print(i)
  132.  
  133.  0
  134.  2
  135.  4
  136.  6
  137.  8
  138.  10
  139.  12
  140.  14
  141.  16
  142.  18
  143.  >>>
  144.  '''
  145.  
  146.  # import functools
  147.  # res = functools.reduce(lambda x,y:x+y,range(10))
  148.  # print(res)           # 45
  149.  #
  150.  # res = functools.reduce(lambda x,y:x*y,range(1,10))
  151.  # print(res)      # 362880    9!
  152.  
  153.  # a = set([1,4,5,88,34,33,5,1])
  154.  # print(a)          # {1, 34, 33, 4, 5, 88}
  155.  # b = frozenset([1,4,5,88,34,33,5,1])
  156.  # print(b)          # frozenset({1, 34, 33, 4, 5, 88})
  157.  
  158.  # print(globals())    # 打印全局变量
  159.  
  160.  # def test():
  161.  #     local_var = 333
  162.  #     print(locals())          # {'local_var': 333}
  163.  #     print(globals().get('local_var'))     # None
  164.  # test()
  165.  # print(globals().get('local_var'))         # None
  166.  
  167.  # print(hash('alex'))        # 8256347639460147595
  168.  # print(hash('alex'))        # 8256347639460147595
  169.  # print(hash('Ted'))         # 6081961024648288838
  170.  # print(hash('Ted'))         # 6081961024648288838
  171.  
  172.  # pow(2,8)
  173.  
  174.  # print(round(1.2345))          # 1
  175.  # print(round(1.2345,2))        # 1.23
  176.  
  177.  # d = range(20)
  178.  # print(d)                       # range(0, 20)
  179.  # print(d[slice(2,5)])           # range(2, 5)
  180.  # print(d[2:5])                  # range(2, 5)
  181.  
  182.  # a = {6:2,8:0,1:4,-5:6,99:11}
  183.  # print(a)
  184.  # print(sorted(a))
  185.  # print(sorted(a.items()))
  186.  # print(sorted(a.items(), key=lambda x:x[1]))     # 不懂
  187.  # print(a)
  188.  '''
  189.  {8: 0, 1: 4, -5: 6, 6: 2, 99: 11}
  190.  [-5, 1, 6, 8, 99]
  191.  [(-5, 6), (1, 4), (6, 2), (8, 0), (99, 11)]
  192.  [(8, 0), (6, 2), (1, 4), (-5, 6), (99, 11)]
  193.  {8: 0, 1: 4, -5: 6, 6: 2, 99: 11}
  194.  '''
  195.  
  196.  # a = [1,2,3,4,5,6]
  197.  # b = ['a','b','c','d']
  198.  # print(zip(a,b))          # <zip object at 0x0000000002213148>
  199.  # for i in zip(a,b):       # map(a,b)
  200.  #     print(i)
  201.  '''
  202.  (1, 'a')
  203.  (2, 'b')
  204.  (3, 'c')
  205.  (4, 'd')
  206.  '''
  207.  
  208.  # import encode
  209.  # __import__('encode')

build_in

本节作业

有以下员工信息表

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

  1. 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"

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

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

day03 - Python基础3的更多相关文章

  1. python之路:Day03 --- Python基础3 >>函数

    本节内容 1.函数基本语法及特性 2.参数 3.局部变量与全局变量 4.返回值 嵌套函数 5.递归 6.匿名函数 7.高阶函数 8.内置函数 一.函数基本语法及特性 区别 面向过程编程:根据业务逻辑从 ...

  2. Python学习day03 - Python基础（1）

    1. 执行Python程序的两种方式 (1)交互式(Jupyter) 优点:运行一句执行一句 缺点:关闭即消失# (2)命令行式(pycharm) 优点:可以一直保存 缺点:全部写完才能调试bug虽然 ...

  3. Python基础【day03】：入门知识拾遗（八）

    本节内容 1.作用域 2.三元运算 3.进制 一.作用域 对于变量的作用域,执行声明并在内存中存在,该变量就可以在下面的代码中使用. 1 2 3 if 1==1:     name = 'wupeiq ...

  4. 第一模块：python基础语法

    Python基础[day01]:python介绍发展史(一) Python基础[day01]:Hello World程序(二) Python基础[day01]:表达式if ...else语句(三) P ...

  5. python之最强王者（2）——python基础语法

    背景介绍:由于本人一直做java开发,也是从txt开始写hello,world,使用javac命令编译,一直到使用myeclipse,其中的道理和辛酸都懂(请容许我擦干眼角的泪水),所以对于pytho ...

  6. Python开发【第二篇】：Python基础知识

    Python基础知识 一.初识基本数据类型 类型: int(整型) 在32位机器上,整数的位数为32位,取值范围为-2**31-2**31-1,即-2147483648-2147483647 在64位 ...

  7. Python小白的发展之路之Python基础（一）

    Python基础部分1: 1.Python简介 2.Python 2 or 3,两者的主要区别 3.Python解释器 4.安装Python 5.第一个Python程序 Hello World 6.P ...

  8. Python之路3【第一篇】Python基础

    本节内容 Python简介 Python安装 第一个Python程序 编程语言的分类 Python简介 1.Python的由来 python的创始人为吉多·范罗苏姆(Guido van Rossum) ...

  9. 进击的Python【第三章】：Python基础(三)

    Python基础(三) 本章内容 集合的概念与操作 文件的操作 函数的特点与用法 参数与局部变量 return返回值的概念 递归的基本含义 函数式编程介绍 高阶函数的概念 一.集合的概念与操作 集合( ...

随机推荐

  1. [译]Javascript中的for循环

    本文翻译youtube上的up主kudvenkat的javascript tutorial播放单 源地址在此: https://www.youtube.com/watch?v=PMsVM7rjupU& ...

  2. JVM各区域的用途

    程序计数器 用于给字节码解释器来选取吓一跳需要执行的字节码指令.每个线程有一个独立的程序计数器去,且各个线程之间互不影响.如果线程正在执行一个Java方法,这个计数器记录的是正在执行的虚拟机字节码指令 ...

  3. Data Base System.Data.OracleClient requires Oracle client software version 8.1.7 or greater解决方案

    System.Data.OracleClient requires Oracle client software version 8.1.7 or greater解决方案 一.问题: 1.通过Syst ...

  4. sort排序bug乱序

    项目需要对组件的zIndex值进行降序排列,刚开始采用的是sort进行排序,排完之后感觉没问题,毕竟也是经常用的,可是昨天无意中把zIndex值打出来看,一看不知道,发现只要排序的组件超过10个就出问 ...

  5. Linux的SSH（Secure Shell Protocol）服务

    在数据传输前,SSH会对需要传输的数据进行加密,保证会话安全与会话中传输数据的安全,SSH客户端还包含一个远程拷贝scp. 1.SSH的结构 SSH服务由服务端软件(openssh)和客户端(SSH. ...

  6. 开窗函数Over用法

    比如我们有这个表: 销售记录表 日期 姓名 产品 销售额 201601 A 电脑 12560 201601 A 手机 6501 201601 A 平板 8510 201602 A 手机 1560 20 ...

  7. 02 Django web开发-html简介

    软件开发和网络 HTML是用于创建网页的标准标记语言 -HTML指的是超文本标记语言 -HTML不是一种编程语言,二十一种标记语言 -是用来描述网页的一种语言 -HTML描述使用标记的网页的结构 -是 ...

  8. pytorch实现squeezenet

    squeezenet是16年发布的一款轻量级网络模型,模型很小,只有4.8M,可用于移动设备,嵌入式设备. 关于squeezenet的原理可自行阅读论文或查找博客,这里主要解读下pytorch对squ ...

  9. SprimgMVC学习笔记（九）—— RESTful支持

    一.什么是restful? Restful就是一个资源定位及资源操作的风格,其核心是面向资源.不是标准也不是协议,只是一种风格.基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制.RES ...

  10. 使用Entity Framwork 保存数据时，提示不能在对象中插入重复键，违反了PRIMARY_KEY约束

    这种情况,大多发生在有外键存在的情况下,解决方法是: 把dataContext.Set<T>().Add(model)修改成dataContext.Models.Add(model);