模块和包

· 高阶函数

1. map：对序列中的元素进行变换或合并

1. 用法1：变换

   1. map(函数， 序列)

   2. 将原序列中的元素，按照函数给定的标准转换成新的序列

   3. 函数的要求

      1. 是一个函数
      2. 有一个参数(指向后面的这个序列中的元素)
      3. 需要一个返回值(返回值是新序列中的元素)

      # 获取nums中所有元素的个位数，产生一个新列表
      nums = [19, 78, 66, 51, 34, 98, 22]
      result = map(lambda item: item % 10, nums)
      print(list(result))
      

2. 用法2：合并

   1. map(函数，序列1， 序列2)

   2. 函数的要求

      1. 是一个参数
      2. 有两个参数(参数个数看序列个数)，分别指向后面两个序列中的元素
      3. 需要一个返回值(返回值是新序列中的元素)

      # 产生一个新的序列，序列中的每个元素是math 和chinese的分数和
      math = [19, 23, 34, 56, 34]
      chinese = [10, 20, 30, 40, 50]
      result = map(lambda item1, item2: item1 + item2, math, chinese)
      print(list(result))
      
      
      # 练习：将以下两个列表按照下面的要求转换字典： {'苹果': 1823, '小爱同学':22221, '耳机': 891, '天猫精灵': 78}   保证新序列是一个小序列，因为字典对元素的要求就是序列中都是小序列
      names = ['苹果', '小爱同学', '耳机', '天猫精灵']
      nums = [1823, 22221, 891, 78]
      
      result = map(lambda item1, item2: (item1, item2), names, nums)
      print(dict(result))
      
      nums1 = [19, 78, 778, 90]
      nums2 = [1, 89, 9, 2]
      nums3 = [23, 54, 17, 187]
      result = map(lambda x, y, z: int(f'{x}{y}{z}'), nums1, nums2, nums3)
      print(list(result))     # [19123, 788954, 778917, 902187]
      

2. reduce：按照指定规则对序列中的元素进行合并操作

1. 需要对reduce进行导入

   from functools import reduce
   

2. 用法1：

   1. reduce(函数，序列，初始值)

   2. 函数的要求：

      1. 是一个函数

      2. 有且只有两个参数(第一个参数指向初始值，从第二次开始指向上一次的计算结果；第二个参数指向序列中的每个元素)

      3. 有一个返回值(返回值决定合并规则)

         from functools import reduce
         
         # 求所有元素的和
         nums = [23, 34, 56, 67, 8]
         result = reduce(lambda x, y: x + y, nums, 0)
         print(result)
         
         # 练习1：求所有的数的个位的和
         nums = [23, 34, 56, 67, 8]
         result = reduce(lambda x, y: x + y % 10, nums, 0)
         print(result)
         
         # 练习2：求所有的元素的数值和
         nums = [23, '78.9', 9, '10']
         result = reduce(lambda x, y: x + float(y), nums, 0)
         print(result)
         
         # 练习3：求所有数字的乘积
         nums = [23, 8.9, 'abc', True, '2']
         result = reduce(lambda x, y: x * (y if type(y) in [float, int] else 1), nums, 1)
         print(result)
         

· 模块

1. 模块：一个py文件就是一个模块

1. python可以在一个模块中去使用另外一个模块(命名规范)中所有的全局变量，但是得先导入

2. 导入模块(直接导入、导入模块中的变量、重命名)

   1. import 模块名：模块名就是py文件名；导入指定模块，导入后需用‘模块名.xxx’的形式使用模块中的内容(导入后可使用模块中所有的全局变量)

      import test
      print(test.a)
      test.func1()
      

   2. from 模块名 import 变量名1，变量名2……(导入指定模块中的指定变量；导入后直接使用变量)

      from test import a, func1
      print(a)
      func1()
      

   3. 重命名

      1. 给模块重命名

         1. import 模块名 as 新模块名(重命名后，使用新模块名，原名无效)

         import test as test2
         test2.func1()
         print(test2.a)
         

      2. 给变量重命名

         1. from 模块名import 变量名1 as 新变量名1，变量名2 as 新变量名2，……(导入时给变量重命名)

         from test import a as new_a, func1 as new_func1
         print(new_a)
         new_func1()
         

   4. 通配符

      1. from 模块名 import *：导入模块中所有的全局变量；导入后直接使用变量

         from test import *
         print(a)
         func1()
         

3. 导入模块的原理

   1. 不管以什么样的方式导入模块，再导入模块的时候系统会自动进入被导入的模块将模块中的代码全部都执行一遍
   2. 同一模块只会导入一次；导入时会自动检测之前是否导入过；重复后不在导入

4. # if 外面的代码才是会被其他模块执行的代码
   if __name__ == '__main__':
       # if 里面的代码不会被其他模块执行，只能被自己执行
   

· 包

1. 包

1. 包是用来管理多个模块的一种特殊的文件夹(包含有__ init _ _.py文件的文件夹)

2. 如何使用包中模块的内容

   # 方法1  import 包.模块    使用：包.模块.方法
   import files.jsonFile  
   files.jsonFile.json_read()
   
   # 方法2  import 包.模块 as 新模块名   使用：新模块名.方法
   import files.jsonFile  as jf
   jf.json_read()
   
   # 方法3  from 包 import 模块 使用：模块名.方法
   from files import jsonFile
   jsonFile.json_read()
   
   # 方法4  from 包.模块 import 方法  使用：方法
   from files.jsonFile import json_read()
   json_read()
   

3. 通过包导入内容的时候，会先执行_ _ init _ _.py文件的内容

   1. 用法一：批量导入
   2. 用法二：提取高频使用的部分内容
   3. 用法三：封装和提取通用功能