7-python-bas

Python 基础

python弊端：没有声明语句

1. global:能不用就不用

a=1           #如果没有a=1也不会出错，global a相当于在外面声明一个a
def func_out():
    global a  #说明要修改外面的a
    a=a+1
    print(a)  #2
func_out()
print(a)      #2

改为：

def func_out():
    c=a
    c=c+1
    print(c)

2. 闭包——函数内嵌

   用到非常多，大多用于安全（加密）

   如果b函数有父函数a函数，B想用A的变量a,使用nonlocal声明a（尽量不要用）

   闭包用不好，不如不用，下面是典型用不好闭包的例子，按理说用完func_in()就会被回收，但a是外部变量也被回收掉了，会出现问题，一定要切记使用的闭包要与外部断了联系：

   a=1  #全局变量(函数外部)
   def func_out():   #全局函数，全局的运行完程序才会被回收
       a=2
       def func_in():  #闭包,局部函数，调用时出现，不调用时就相当于没有过
           nonlocal a
           print(a)
       return func_in
   func_out()()
   

   用完a让a=None或者直接用拷贝的值，一定要return，不然会把闭包封死在函数里，而闭包应让外部也使用

3. 内置函数

   # lambda函数有自己的作用域
   def makeAction():
       acts=[]
       for i in range(5):
           # i=0,1,2,3,4
           acts.append((lambda x,j=i:j**x))
       return acts
   fs=makeAction()
   res01=fs[0](3)
   print(res01)
   

   查看系统内置函数：print(dir(builtins))

   • map：把数组里的数一个个给函数
   • reduce：可用于累加

   from functools import reduce
   arr=[2,4,6]
   res01=reduce(lambda x,y:str(x)+str(y),arr)
   print(res01)  #246
   

   • filter：过滤

   arr=('张晓明','张三丰','王重阳','李娟')
   res=filter(lambda s:s[0]=='张' and len(s)==2,arr)
   print(list(res))
   

   • sorted:排序(更多用到的时这种)

   users=[
       {'id':'008','user_name':'admin','user_password':'888','type':0},
       {'id':'002','user_name':'joke','user_password':'777','type':1},
       {'id':'001','user_name':'nose','user_password':'777','type':1}
   ]
   res=sorted(users,key=lambda user:user['id'],reverse=True)
   print(res)
   

4. 模块

   1. 介绍

      Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

      模块让你能够有逻辑地组织你的 Python 代码段，把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

      模块能定义函数，类和变量，模块里也能包含可执行的代码。模块可以被别的程序引入，以使用该模块中的函数等功能。

   2. import

      import如何工作：一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

      1. 找到模块文件
      2. 编译成位码（需要时）
      3. 执行模块的代码来创建其所定义的对象

      module_a.py

      #!/Users/lzhan/Lzhan/python/project/unit1
      # -*- coding: UTF-8 -*-
      def add(a,b):
        return a+b
      version='1.0'
      print('add is end')
      # print __name__=="__main__" # 结果为false
      

      main.py

      # -*- coding:UTF-8 -*-
      # 第一种应用方式
      
      # import module_a
      
      # print module_a.add(10,20)
      # dir(module_a) # get list of attributes for sys module
      # 第二种调用方式
      from module_a import add,version
      print (add(10,20))
      print (version)
      
      print( __name__=='__main__')
      

      补充：

      #!/Users/lzhan/Lzhan/python/project/unit1
      # -*- coding: UTF-8 -*-
      import sys
      print 'test import and arguments'
      for i in sys.argv:
        print(i)
      
      print (__name__=="__main__")
      
      print( 'end')
      
      print (__name__) #表示当前文件的文件名字
      
      print( sys.path)
      
      print (dir())
      
      

      当导入包文件夹的情况下,多级目录使用.作为分隔符,使用模块的时候，也要全部引入

      
          import dir01.dir02.moudule
      
          #调用模块中的内容
          dir01.dir02.moudule.func()
      
          或者
          import dir01.dir02.moudule as m
      
          m.func()
      
      
      

   3. from xx import *

      from module_a import add,version
      

      搜索路径
      当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

      1. 当前目录
      2. 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。

      import sys
      print(list(sys.path))
      #手动添加目录
      sys.path.append('c:\\python\\modules')
      sys.path.append('c:/python/modules')
      

      3. 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
      4. 任何.pth文件的内容（如果存在的话）

      在python安装路径的site-packages目录下修建了PckPath.pth文件

      /Users/lzhan/AI/python/project_modules/modules
      

      模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

   4. globals() 和 locals() 函数

      根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。

      如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。

      如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。

      两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

   5. 编译

   当文件导入时，就会进行编译。因此、通常不会看到程序顶层文件的.pyc字节码文件。除非这个文件也被其他文件导入：只有被导入的文件才会留下字节码文件。顶层文件的字节码是在内部使用后就丢弃了。

   6. 执行

      和def一样，import和form是可执行语句，而不是在编译期间的声明。直到python执行到这些语句时，才会进行解析。

   7. distutils

      Distutils可以用来在Python环境中构建和安装额外的模块。新的模块可以是纯Python的，也可以是用C/C++写的扩展模块，或者可以是Python包，包中包含了由C和Python编写的模块。

   8. from

      from会把模块中的变量复制到另一个作用域，所以顶层文件中就可以直接使用该变量了。

          import modulea
          from modulea import * #等价
      

      from语句智能用在模块文件的顶部，不能放在函数中。

      所以下面代码是等价的

          from module import name1,name2
          #等价于
          import module
          name1=module.name1
          name2=module.name2
          del module
      

      from语句有破坏命名空间的潜质！！

   9. 查看模块命名空间

      import public_var as p
      print(p.__dict__)
      print(dir(p))
      

   10. reload() 函数

       当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

       因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：

       1. reload是Python的内置函数，而不是语句
       2. reload只能重载已经存在的模块对象，而不是变量
       3. relaod必须手动导入

       import public_var as p
       from importlib import reload
       
       print(p.urls['first'])
       
       p.urls['first']='baidu.com'
       
       print(p.urls['first'])
       
       reload(p)
       print(p.urls['first'])
       

   11. Python中的包:在保重隐藏数据

       import modules.public_var
       from modules.public_var import *
       

       包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

       简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py 用于标识当前文件夹是一个包。