Python基础-07

1.匿名函数
     *函数名=lambda 形参：表达式（即返回值，此表达式一般都是简单逻辑）
     *匿名函数一般不独立使用，一般和其他函数结合使用
     *注意：匿名函数返回多个值时，自己手动加上括号。即自己手动把数值组装成元组。
           一般函数返回多个值时，函数会自动把多个数值组装成元组
2.编程方法：
     面向过程
     面向对象
     函数式：编程语言去实现数学函数。
3.函数式编程：
      特点：不可变，不用变量去保存状态，不修改变量
      高阶函数：函数参数是函数名或是函数返回值包含函数
      尾调用：在函数的最后一步去调用另外一个函数（最后一步不一定是最后一行）
      尾递归：在函数的最后一步去调用自身
4.内置函数：
      *map(func,可迭代对象):返回值是一个可迭代对象（迭代器），其只能迭代一次。
           for循环打印或是list(map(func,可迭代对象))转化成列表都可以。list(可迭代对象)
           注意：Python2中，map(func,可迭代对象)返回值就是一个列表，不需要list()转化
      *filter函数：过滤，功能以及使用同上
      *reduce函数：reduce(func,sequence，init=None)
                          nums=[1,2,3]
            例如：    reduce(lambda x,y:x+y,nums) 求nums列表中元素的和
                          reduce(lambda x,y:x+y,nums，init=1) 求nums列表中元素的和再加1
                          reduce(lambda x,y:x*y,nums) 求nums列表中元素的积
                          reduce(lambda x,y:x*y,nums,init=1) 求nums列表中元素的积再乘1
            注意：lambda表达式里面一次性拿出2个参数进行运算，其reduce函数的内部原理
              nums=[1,2,3]
              def chen(x,y)
                   return x*y
              def reduce_test(func,array,init=None):
                   if init is None:
                        res=array.pop(0)
                   else:
                        res=init
                   for i in array:
                        res=func(res,i)
                   return res
       
              reduce_test(chen,nums,10)
      
      上述复杂的操作其实就是reduce(lambda x,y:x*y,nums,init=10)实现的内部原理
  *all(序列)：判断序列中元素的布尔结果，如果存在一个元素的布尔结果是False，即返回结果就是False，反之为True;
                注意：如果序列为一个空串，返回结果是True。
 *any(序列)： 序列中存在一个元素的布尔结果为True，则返回结果就是True。
 * bin(int): 把整数转化成二进制数值 例如：bin(3)--->0b11
     hex(int)： 把整数转化成十六进制数值
     oct(int): 把整数转化成八进制数值
* bool()： 判断布尔值（0，None，‘’，（），[],{}）
 *bytes(字符串，encoding): 把字符串对象按照encoding的编码格式转换成字节，注意不要写unicode编码
      bytes(字符串，encoding).decode('utf-8'):注意编码与解码的格式要一致，decode默认编码是utf-8
 *chr(integer): 按照ASCII的规范，把数值转换成对应的字符

        ord()：与上述方法刚好相反，把字符按照ASCII规则转换成数值
 *divmod(integer,integer):返回值是：(商，余数)。一般该方法会用来做分页，如果余数！=0，则分‘商+1’页
 *eval(str)： 把字符串中的数据结构提取出来
 *hash(): 可hash的数据类型即不可变类型，反之...
 * isinstance(数据，数据类型):返回结果是布尔结果 例如：isinstance(1,int) 返回值是True
 *globals()：返回结果是字典形式的全局变量（包括用户自定义的全局变量以及系统提供的全局变量）
 *locals():返回结果是字典形式的全局变量或是局部变量。具体看locals()方法的位置，就近原则

*zip(sequence1，sequence2)：返回可迭代对象，可以通过list()把其转换成列表。如果sequence1与sequence2长度不等，参照最短的
      例如：list(zip(('a','b'),(1,2,3)))--->[('a', 1), ('b', 2)]
  *max(可迭代对象)：原理就是for循环遍历对象，对每一个元素逐一比较。不同的数据类型是不可以进行比较的。
   li=[
    {"age":10},
    {"age":12},
    {"age":14}
   ]
   print(max(li,key=lambda item:item["age"]))：返回值是：{"age":14}
   或是
   dic={"age1":10,"age2":12,"age3":14}
   print(max(zip(dic.keys(),dic.values())))
   或是：
   li=[(1,2),(3,4)]
   print(max(li))
   例子很多，可以自行练习
  *pow(integer1,integer2)-->integer1**integer2
   pow(integer1,integer2,integer3) -->integer1**integer2%integer3
  *reversed(object):返回一个可迭代对象（逆置）
  *round(数值)：四舍五入
  *set(object)：把对象转换成集合，如果对象是字典，只会把key放置在对应的集合中
  *slice(start,end,step)：切片 等价于[start,end,step]
   例：   nums=(1,2,3,4,5,6,7)
            s=slice(1,5,2)
            print(nums[s])
            print(nums[1:5:2])
  *sorted() ：用法与max()基本一致（默认排序的递增的）
   例：li=[
            {"age":15},
            {"age":12},
            {"age":14}
           ]
           print(sorted(li,key=lambda item:item["age"]))
   运行结果：[{'age': 12}, {'age': 14}, {'age': 15}]
   例：li={"age1":13,"age2":10,"age3":2}
        #按照key对应的value对key进行排序，与max（）比较起来，其比较特殊
        print(sorted(li,key=lambda x:li[x]))
  *str(obejct):任意类型的数据都可以转换成字符串
  *vars()等价于locals()
   vars(object)返回结果是：object.__dict__ 。注意：前提是对象必须有__dict__属性
  *__import()__
    1.#引入当前目录的test.py文件，调用其中的hi()方法
      #注意import test 其底层调用的还是__import__()方法来引入文件
     import test
     test.hi()
    2.name='test'
      file=__import__(name)
      file.hi()
      作用同上