python自动化运维之路~DAY4
一.模块导入方式详解.
关于Python有几种导入模块的方式！
1.内置函数或者第三方库的导入方法。
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianleycheng
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
'''
import导入内置函数用法展示：
'''
import sys,os #导入内置函数
print(os.path.abspath(__file__)) #打印当前脚本的绝对路径
print(os.path.dirname(os.path.abspath(__file__))) #打印当前脚本所在目录的绝对路径
print("*"*50,"我是分割线","*"*50)
'''
import导入第三方模块(paramiko连接服务器)的用法展示
'''
import paramiko #通过用户名密码的方式登陆服务器并执行指令操作如下：
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('172.30.1.87', 22, 'rianley', '1')
stdin, stdout, stderr = ssh.exec_command('df -h')
print(stdout.read())
ssh.close()
#以上代码测试结果如下：
D:\python\daima\DAY5\ATM\bin\mange.py
D:\python\daima\DAY5\ATM\bin
************************************************** 我是分割线 **************************************************
b'\xe6\x96\x87\xe4\xbb\xb6\xe7\xb3\xbb\xe7\xbb\x9f
\xe5\xae\xb9\xe9\x87\x8f \xe5\xb7\xb2\xe7\x94\xa8
\xe5\x8f\xaf\xe7\x94\xa8 \xe5\xb7\xb2\xe7\x94\xa8% \xe6\x8c\x82\xe8\xbd\xbd\xe7\x82\xb9\nudev
973M 0 973M 0% /dev\ntmpfs
199M 22M 178M 11% /run\n/dev/sda1
18G 5.1G 12G 31% /\ntmpfs
992M 220K 992M 1% /dev/shm\ntmpfs
5.0M 4.0K 5.0M 1% /run/lock\ntmpfs
992M 0 992M 0% /sys/fs/cgroup\ntmpfs
199M 72K 199M 1% /run/user/1000\n/dev/sr0
1.4G 1.4G 0 100% /media/rianley/Ubuntu 16.04 LTS amd64\n'
2.Python Package包的导入方法：
如果区分你看到的目录是一个Python Package包呢？其实很简单，你只要看这个名录下是否有__init__.py这个文件就好了，如果有那么就是Python Package包，如果没有，就说嘛你看到的就是个普通的目录，如下图，你就可以看出来ATM就是一个Python Package包，而shopping_mall就是一个目录，而判断的依据就是是否包含_init__.py文件。
那么，在python package包中导入模块呢？又是如何实现的呢？我们一起来看一下：
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
'''
前景提要：
在包ATM.bin目录下有一个atm模块，这个模块的内容如下：
def test_name():
name_str = input("Please enter your name:>>>")
print("My name is [\033[31;1m%s \033[0m]"% name_str)
print("这里是ATM的执行程序")
'''
import sys,os
BASE = os.path.normcase(os.path.join(os.path.dirname(os.path.abspath(__file__)), #
os.path.pardir,
os.path.pardir)
)
sys.path.append(BASE) #这个步骤是将路径加进来，并执行里面的代码
from ATM.bin import atm
atm.test_name()
'''
关于“BASE“字符串说明如下：
1>.os.path.normcase（path）作用：本地化的路径的字符串。在Unix和Mac OS X，这个返回的路径不变;不区分大小写的文件系统，它的路径转换为小写。在Windows上，它也
转换成斜线，反斜线。
2>.path说明如下：
os.path.join(os.path.dirname(os.path.abspath(__file__)), #join是把路径拼接起来，dirname是取该文件的目录
os.path.pardir, #pardir是取上级目录
os.path.pardir) #pardir是取上级目录
'''
#以上代码测试结果如下：
这里是ATM的包名
这里是ATM的执行程序
Please enter your name:>>>程小航
My name is [程小航 ]
二.装饰器：（"器"所指的就是函数）
定义：本质是函数，（装饰其他函数）就是为其他函数添加附加功能。
原则：装饰器对它被装饰的函数是完全透明的,大致分为两个特色：
1.不能修改被装饰的函数的源代码；
2.不能修改被装饰的函数的调用方式。
实现装饰器知识储备：1.函数即"变量"；
2.高阶函数；
3.嵌套函数。
1.函数即"变量"
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
'''
函数即"变量":
和变量的存储方式是一样的，我们定义个函数得给他起一个名称，便于我们来调用。
函数分两种：1.用关键字定义的函数“def”
2.匿名函数
'''
#无参数函数
def test_1():#其中我们可以将test_1这个函数名称[存储内存地址，在后面加一个（）就可以调用该函数，将其下面的所有的代码叫做函数体
print("my name is rianley,I love python!") #从这一行开始缩进相同的代码就是函数体
return "goodboy!"
#有参数函数
def test_2(name):
print("my name is \033[32;1m%s:\033[0m"%name)
pass
test_1() #这个过程就是调用上面已经定义好的函数！
test_2("rianley")
print("*"*50,"我是分割线","*"*50)
'''
什么是匿名函数:
不需要起名称而且不需要被多次调用！基本上允许一次之后就被回收了，不过我们可以给他赋值给一个变量。（python解释器会定时查看当前内存的变量是否被调用，如果
没有被调用的话就会被解释器收回内存地址，如果已经被调用的话就不会收回其的内存地址直到程序运行结束之后释放掉所有的内存，注意，如果你的某个变
量被多个地方调用的话你手动del掉的变量还是不会被系统收回，你删除的只是这个变量的某一次的调度次数而已～）
'''
print(lambda y:y+100) #由于没有赋值给你一个变量，python解释器无法调用它（如果使用print函数打印它的话，只能打印它在内存中的地址编号而已）！
我们需要按照下面的方法进行调用的哟～
calc = lambda x:x*100
print(calc(3))
#以上代码执行结果如下：
my name is rianleycheng,I love python!
my name is rianleycheng:
************************************************** 我是分割线 **************************************************
<function <lambda> at 0x00E16DB0>
300
2.高阶函数
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
import time
#a.把一个函数名当作实参传给另外一个函数(在不修改被装饰函数源代码的情况下为其添加附加功能);
def test1(function):
start_time = time.time()
function()
stop_time = time.time()
print("the function run time is %s" % (stop_time - start_time))
def bar():
print("in the bar")
time.sleep(3)
test1(bar)
print("*"*50,"我是分割线","*"*50)
# b.返回值中包含函数名(不修改函数的调用方式)。
def bar():
time.sleep(2)
print("in the bar")
def test2(function):
print(function)
return function
print(test2(bar))
t=test2(bar)
t()
#以上代码执行结果如下：
in the bar
the function run time is 3.0001704692840576
************************************************** 我是分割线 **************************************************
<function bar at 0x01366D68>
<function bar at 0x01366D68>
<function bar at 0x01366D68>
in the bar
3.嵌套函数
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
'''
嵌套函数:
简单的理解就是函数里面套函数，就是一个def中可以定义多个def，而且支持在函数中调用子函数，下面我们来举例子看一下就明白了 。
'''
#例如1：
def foo():
print("in the foo")
def bar():
print("in the bar")
bar() #只属于局部变量的函数，只能在局部变量的缩进来调用，不能在全局调用哟～
def test1():
foo()
test1()
print("*"*50,"我是分割线","*"*50)
foo()
print("*"*50,"我是分割线","*"*50)
# 例如2：
x=0
def grandpa():
x=1
def dad():
x=2
def son():
x=3
print(x) #最终生效的作用域不是全局变量，而是当前函数的定义的变量x=3，这就是在嵌套函数中的作用域的功能！
son()
dad()
grandpa()
#以上代码执行结果如下：
in the foo
in the bar
************************************************** 我是分割线 **************************************************
in the foo
in the bar
************************************************** 我是分割线 **************************************************
4.定义一个无参数装饰器，（装饰器又叫语法糖，在其他语言中也有类似的功能哟～）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
import time
#定义一个装饰器，实现统计每个函数的运行时间
def timmer(func): #定义一个装饰器名称（也可以理解定义一个变量），并定义一个需要装饰的参数，当调用的时候必须将被装饰的参数替换，Python默认做了这个操作
def warpper(*args,**kwargs): #这个就是装饰器，里面会存着传给func的参数
start_time = time.time()
res = func(*args,**kwargs) #运行被装饰的函数
stop_time = time.time()
print('the func tun time is %s' % (stop_time - start_time))
return res
return warpper
# 定义一个函数,并且使用@符号调用装饰器即可！
@timmer #相当于test1 = timer(test1) 这个时候会去调用timmer这个装饰器。
def test1():#这个功能只是打印字符串的功能
time.sleep(3)
print("in the test1")
@timmer #相当于test2 = timer(test2)
def test2(name,age):#这个功能只是打印字符串的功能，并且还有返回值
time.sleep(3)
print("My name is \033[32;1m%s:\033[0m" % name)
print("My age is \033[32;1m%s:\033[0m" % age)
return 100
# 调用对应的函数
result_1= test1()
result_2 = test2("rianley",25)
print(result_1)
print(result_2)
#以上代码执行效果如下：
in the test1
the func tun time is 3.000213146209717
My name is rianley:
My age is 25:
the func tun time is 3.0001907348632812
None
100
5.定义一个有参装饰器
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
#定义一个有参装饰器,在调用的时候需要传递一个参数进去
import time
user,passwd = "rianley","123"
def auth(auth_type): #定义一个模拟登陆网页认证的装饰器
def outer_wrapper(func):
def wrapper(*args, **kwargs):
username = input("Please enter your username:>>>").strip()
password = input("Please enter your password:>>>").strip()
if user == username and passwd == password:
print("欢迎你,:\033[0m%s\033[0m" % username)
res = func(*args, **kwargs)
return res
else:
exit("\033[31;1m用户名或者密码错误！\033[0m")
return wrapper
return outer_wrapper
def index():
print("welcome to index page!")
@auth(auth_type="local")
def home():
print("welcome to home page!")
return "这是家目录"
@auth(auth_type = "ldap")
def bbs():
print("welcome to bbs page!")
index()
print(home())
bbs()
#以上代码执行结果如下：
welcome to index page!
Please enter your username:>>>rianley
Please enter your password:>>>123
欢迎你,:rianley
welcome to home page!
这是家目录
Please enter your username:>>>rianley
Please enter your password:>>>123
欢迎你,:rianley
welcome to bbs page!
6.定义有参装饰器
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
#装饰器实战模版，模拟控制网络的登录方式。
# （实现了第一次登录成功后，第二次访问其他的网页就不需要重新输入密码，和上面的那个有点差别）
import time
def timmer(func):
def warpper(*args,**kwargs):
start_time = time.time()
func(*args,**kwargs)
stop_time = time.time()
print('the func tun time is %s' % (stop_time - start_time))
return warpper
#定义一个函数,并且使用@符号调用装饰器即可！
accunts = {} #用于验证用户是否成功登录的容器
corrent_logon_user = None
def auth(auth_type):
def auth_deco(func):
def wrapper(*args,**kwargs):
if corrent_logon_user not in accunts:
user = input("please input your username:>>>")
passwd = input("please input your passward:>>>")
if auth_type == "file":
if user == "rianleycheng" and passwd == "123":
accunts[user] = True
print(accunts)
global corrent_logon_user #可能会生成SyntaxWarning提醒，可忽略，可以用异常处理来过滤掉
corrent_logon_user = user
return func(*args,**kwargs)
else:
print("")
elif auth_type == "ldap":
print("===>ldap")
return func(*args,kwargs)
else:
return func(*args,**kwargs)
return wrapper
return auth_deco
@auth('file')
def index(msg):
print("in the index:",msg)
@auth('ldap')
def home():
print("in the home")
return "66666"
index("test")
print(home())
please input your username:>>> rianley
please input your passward:>>>123
{'rianley': True}
in the index: test
in the home
66666
三.生成器
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的，而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面的几个元素，那后面绝大多数元素占用的空间就白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是可以在循环中的过程中不断的推算出后续的元素呢？这样就不必创建完整的list，从而节省了大量的空间。在python中，这种一边循环一边计算的机制，称为生成器：generator.
生成器特点：
1.只有在调用的时候才会生成相应的数据，这是节省内存的核心因素；
2.只记录当前位置；
3.只有一个__next___()方法。 在python2.7中使用next方法则用：next().
1.开始写一个简单的生成器
#！/usr/bin/env python #_*_coding:utf-8_*_ #@author :rianley #blog:http://www.cnblogs.com/rianley #EMAIL:rianley@qq.com fist = (i*2 for i in range(10)) #列表生成式，可以使你的代码更加便捷！可以很下面的代码进行比较哟~ # for i in fist: #查看这个生成器的所有元素 # print(i) print(fist.__next__()) #打印第生成器的第一个数据 print(fist.__next__()) #打印生成器的第二个数据，并且会自动从内存中删除上一个数据所占的内存 print(fist.__next__()) #打印生成器的第三个数据，并且会自动从内存中删除之前所占的内存变量，也就是只保存当前的数据，不过__next__方法我们用的很少，一般都是用for循
环实现，以减少代码的重复,不然的话1000w的数据我们得调用1000次就麻烦了，哈哈 print("*"*50,"我是分割线","*"*50) #我们可以看下定义的列表，其实定义的一个列表就是把数据强行写到内存去了，直接就占用内存，下面有2种方法定义一个列表，效率差不多，但是第一种方法明显节省代码的容
量啊~ list_0 = [ i*2 for i in range(20)] #这种方法是列表生成生成式，和下面(list_1)的3行代码的效率是一样的，但是代码更加简洁。 list_1 = [] for i in range(20): list_1.append(i*2) print(list_0) print(list_1) # 如果上面要循环1万次，会对内存占用很大的空间，而且还会浪费时间！python解释器有一个神器出现了，就是生成器，它生成的是一个内存地址，并没有真正的开辟内存空间！
只有通过__next__方法（一般用循环）取值的时候才会去得到相应的数字。 list_3 = (i*2 for i in range(10000000)) #这就是定义一个生成器，如果用列表定义的话可能要等待3s左右，但是生成器则是你定义完毕就OK了，随时可以调用 print(list_3) #仅仅是生成了一个生成器的内存地址 #以上代码测试结果如下： 0 2 4 ************************************************** 我是分割线 ************************************************** [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38] <generator object <genexpr> at 0x01882B10>
2.用生成器写斐波那契数列
#！/usr/bin/env python #_*_coding:utf-8_*_ #@author :rianley #blog:http://www.cnblogs.com/rianley #EMAIL:rianley@qq.com #通过学习上面的生成器，只是一个开门见山，因为generator非常强大，如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现哟，比如著名的“斐
波那契数列[Fibonacci]” #"斐波那契数列"用列表生成式写不出来，但是，用函数就能把他打印出来却很容易哟： def fib(max): n,a,b, = 0,0,1 while n < max: #print(b) yield b #如果一个函数中有yield的存在就不能叫只叫它函数了，而是一个生成器 a,b = b,a+b #相当于：t = (b,a + b) ; a =t[0] ;b =t[1] n = n + 1 return "done" f = fib(100) #print(f) for i in range(10): #打印前10个"斐波那契数列"，通过__next__的方法来取得想要的结果。 print(f.__next__()) ''' 如果用__next__方法读取文件的话读到最后一行再往下读的话是会报错的，这个时候我们就可以用捕捉异常来出来，下面就简单的举个例子 ''' #当使用循环迭代的时候会报错，我们可以通过捕捉异常的方法将数据进行抓取 g = fib(6) while True: try: #抓取这段代码进行操作 x = next(g) print("g:",x) except StopIteration as e: #如果报错是：StopIteration就执行以下的代码。 print("Generator return value:",e.value) break #以上代码执行结果如下： 1 1 2 3 5 8 13 21 34 55 g: 1 g: 1 g: 2 g: 3 g: 5 g: 8 Generator return value: done
3.生成器的send方法
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :rianley
#blog:http://www.cnblogs.com/rianley
#EMAIL:rianley@qq.com
import time
def consumer(name):
print("%s 准备吃饺子啦！"% name)
while True:
dumplings = yield
print("饺子[%s]来了，被[%s]吃了！"% (dumplings,name))
test_1 = consumer("rianleycheng")
test_1.__next__() #__next__方法是调用"yield"但是不能传值
test_1.__next__()
filling = "猪肉大葱"
test_1.send(filling) #不仅仅可以调用“yield”还可以给它传一个值哟
def producer(name):
c = consumer("A")
c2 = consumer("B")
c.__next__()
c2.__next__()
print("俺要开始准备吃饺子了！")
for i in range(10):
time.sleep(1)
print("做了2个饺子")
c.send(i)
c2.send(i)
producer("程小航")
#以上代码执行结果如下：
rianleycheng 准备吃饺子啦！
饺子[None]来了，被[rianleycheng]吃了！
饺子[猪肉大葱]来了，被[rianleycheng]吃了！
A 准备吃饺子啦！
B 准备吃饺子啦！
俺要开始准备吃饺子了！
做了2个饺子
饺子[0]来了，被[A]吃了！
饺子[0]来了，被[B]吃了！
做了2个饺子
饺子[1]来了，被[A]吃了！
饺子[1]来了，被[B]吃了！
做了2个饺子
饺子[2]来了，被[A]吃了！
饺子[2]来了，被[B]吃了！
做了2个饺子
饺子[3]来了，被[A]吃了！
饺子[3]来了，被[B]吃了！
做了2个饺子
饺子[4]来了，被[A]吃了！
饺子[4]来了，被[B]吃了！
做了2个饺子
饺子[5]来了，被[A]吃了！
饺子[5]来了，被[B]吃了！
做了2个饺子
饺子[6]来了，被[A]吃了！
饺子[6]来了，被[B]吃了！
做了2个饺子
饺子[7]来了，被[A]吃了！
饺子[7]来了，被[B]吃了！
做了2个饺子
饺子[8]来了，被[A]吃了！
饺子[8]来了，被[B]吃了！
做了2个饺子
饺子[9]来了，被[A]吃了！
饺子[9]来了，被[B]吃了！
