7-python-bas_pybas

作者：2023面试高手 | 2024-05-20 07:37:03

踩

pybas

Python 基础

python弊端：没有声明语句

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
1
2
3
4
5
6
7

改为：

def func_out():
    c=a
    c=c+1
    print(c)
1
2
3
4

闭包——函数内嵌

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

如果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()()
1
2
3
4
5
6
7
8
```
用完a让a=None或者直接用拷贝的值，一定要return，不然会把闭包封死在函数里，而闭包应让外部也使用

内置函数

# 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)
1
2
3
4
5
6
7
8
9
10

查看系统内置函数：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
1
2
3
4

filter：过滤

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

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)
1
2
3
4
5
6
7

模块
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
1
2
3
4
5
6
7
```
  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__')
1
2
3
4
5
6
7
8
9
10
11
12
13
```
  补充：
```
#!/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())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
```
  当导入包文件夹的情况下,多级目录使用.作为分隔符,使用模块的时候，也要全部引入
```
    import dir01.dir02.moudule

    #调用模块中的内容
    dir01.dir02.moudule.func()

    或者
    import dir01.dir02.moudule as m

    m.func()


1
2
3
4
5
6
7
8
9
10
11
12
```
3. from xx import *
```
from module_a import add,version
1
```
  搜索路径
  当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
  1. 当前目录
  2. 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
```
import sys
print(list(sys.path))
#手动添加目录
sys.path.append('c:\\python\\modules')
sys.path.append('c:/python/modules')
1
2
3
4
5
```
  1. 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
  2. 任何.pth文件的内容（如果存在的话）
  在python安装路径的site-packages目录下修建了PckPath.pth文件
```
/Users/lzhan/AI/python/project_modules/modules
1
```
  模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
4. globals() 和 locals() 函数
  
  根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
  
  如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
  
  如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
  
  两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
5. 编译
当文件导入时，就会进行编译。因此、通常不会看到程序顶层文件的.pyc字节码文件。除非这个文件也被其他文件导入：只有被导入的文件才会留下字节码文件。顶层文件的字节码是在内部使用后就丢弃了。
1. 执行
  
  和def一样，import和form是可执行语句，而不是在编译期间的声明。直到python执行到这些语句时，才会进行解析。
2. distutils
  
  Distutils可以用来在Python环境中构建和安装额外的模块。新的模块可以是纯Python的，也可以是用C/C++写的扩展模块，或者可以是Python包，包中包含了由C和Python编写的模块。
3. from
  
  from会把模块中的变量复制到另一个作用域，所以顶层文件中就可以直接使用该变量了。
```
    import modulea
    from modulea import * #等价
1
2
```
  from语句智能用在模块文件的顶部，不能放在函数中。
  
  所以下面代码是等价的
```
    from module import name1,name2
    #等价于
    import module
    name1=module.name1
    name2=module.name2
    del module
1
2
3
4
5
6
```
  from语句有破坏命名空间的潜质！！
4. 查看模块命名空间
```
import public_var as p
print(p.__dict__)
print(dir(p))
1
2
3
```
5. 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'])
1
2
3
4
5
6
7
8
9
10
11
```
6. Python中的包:在保重隐藏数据
```
import modules.public_var
from modules.public_var import *
1
2
```
  包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
  
  简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py 用于标识当前文件夹是一个包。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/596738