Python之路_Day6

Python之路_Day6_课堂笔记

前期回顾：

无

本期内容：

一、atm作业讲解

二、递归的例子，阶乘

三、反射

四、模块

五、冒泡算法

六、本周作业

一、ATM作业讲解

二、递归的例子，阶乘

使用递归实现“1*2*3*4*5*6*7”

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # 递归阶乘
    6. 

  6. def func(num):
    7. 

  7.     if num == 1:
    8. 

  8.         return 1
    9. 

  9.     return num * func(num-1)
    10. 

    11. 

  11. x = func(7)
    12. 

  12. print(x)
    13.
三、反射

利用字符串的形式去对象（模块）中操作（寻找）成员，反射

实例：伪造WEB框架的路由系统

反射：基于字符串的形式去对象（模块）中操作成员

    

  1. # 反射的四个方法
    2. 

  2. getattr(commons,input)    # 获取
    3. 

  3. hasattr(commons,input)    # 检查
    4. 

  4. setattr(commons,input)    # 设置
    5. 

  5. delattr(commons,input)    # 删除
    6. 



    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # index 反射主程序
    6. 

    7. 

  7. import commons
    8. 

    9. 

  9. def run():
    10. 

  10.     inp = input(‘请输入要打开页面的URL: ‘)
    11. 

  11.     if hasattr(commons,inp):
    12. 

  12.         func = getattr(commons,inp)
    13. 

  13.         func()
    14. 

  14.     else:
    15. 

  15.         print(‘404‘)
    16. 

    17. 

  17. if __name__ == __name__:
    18. 

  18.     run()
    19. 



    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # commons index 调用的模块
    6. 

    7. 

  7. def login():
    8. 

  8.     print(‘登录页面‘)
    9. 

    10. 

  10. def logout():
    11. 

  11.     print(‘退出页面‘)
    12. 

    13. 

  13. def home():
    14. 

  14.     print(‘主页面‘)
    15. 



    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # 反射
    6. 

  6. # index.py
    7. 

    8. 

  8. def run():
    9. 

  9.     inp = input(‘请输入要打开页面的URL: ‘)
    10. 

  10.     m,f = inp.split(‘/‘)
    11. 

  11.     obj = __import__(m) # 以字符串格式导入模块
    12. 

  12.     if hasattr(obj,f):
    13. 

  13.         func = getattr(obj,f)
    14. 

  14.         func()
    15. 

  15.     else:
    16. 

  16.         print(‘404‘)
    17. 

    18. 

  18. if __name__ == __name__:
    19. 

  19.     run()
    20. 



    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # commons.py
    6. 

    7. 

  7. def login():
    8. 

  8.     print(‘登录页面‘)
    9. 

    10. 

  10. def logout():
    11. 

  11.     print(‘退出页面‘)
    12. 

    13. 

  13. def home():
    14. 

  14.     print(‘主页面‘)
    15. 



    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

    6. 

  6. # manager.py
    7. 

    8. 

    9. 

  9. def manager():
    10. 

  10.     print(‘管理页面‘)
    11. 



    

  1. obj = __import__("lib."+m , formlist=True)
    2.

扩展：导入模块

import xxx

form xxx import ooo

obj = __import__("xxx")

obj = __import__("xxx.ooo.xxx",formlist=True)

四、模块

logging

time/datetime

json/pickle

requests

os

用于提供系统级别的操作：

    

  1. os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
    2. 

  2. os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
    3. 

  3. os.curdir                   返回当前目录: (‘.‘)
    4. 

  4. os.pardir                   获取当前目录的父目录字符串名：(‘..‘)
    5. 

  5. os.makedirs(‘dir1/dir2‘)    可生成多层递归目录
    6. 

  6. os.removedirs(‘dirname1‘)   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
    7. 

  7. os.mkdir(‘dirname‘)         生成单级目录；相当于shell中mkdir dirname
    8. 

  8. os.rmdir(‘dirname‘)         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
    9. 

  9. os.listdir(‘dirname‘)       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
    10. 

  10. os.remove()                 删除一个文件
    11. 

  11. os.rename("oldname","new")  重命名文件/目录
    12. 

  12. os.stat(‘path/filename‘)    获取文件/目录信息
    13. 

  13. os.sep                      操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
    14. 

  14. os.linesep                  当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
    15. 

  15. os.pathsep                  用于分割文件路径的字符串
    16. 

  16. os.name                     字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
    17. 

  17. os.system("bash command")   运行shell命令，直接显示
    18. 

  18. os.environ                  获取系统环境变量
    19. 

  19. os.path.abspath(path)       返回path规范化的绝对路径
    20. 

  20. os.path.split(path)         将path分割成目录和文件名二元组返回
    21. 

  21. os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
    22. 

  22. os.path.basename(path)      返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
    23. 

  23. os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False
    24. 

  24. os.path.isabs(path)         如果path是绝对路径，返回True
    25. 

  25. os.path.isfile(path)        如果path是一个存在的文件，返回True。否则返回False
    26. 

  26. os.path.isdir(path)         如果path是一个存在的目录，则返回True。否则返回False
    27. 

  27. os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
    28. 

  28. os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
    29. 

  29. os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间
    30.

sys

用于提供对Python解释器相关的操作：

    

  1. sys.argv           命令行参数List，第一个元素是程序本身路径
    2. 

  2. sys.exit(n)        退出程序，正常退出时exit(0)
    3. 

  3. sys.version        获取Python解释程序的版本信息
    4. 

  4. sys.maxint         最大的Int值
    5. 

  5. sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
    6. 

  6. sys.platform       返回操作系统平台名称
    7. 

  7. sys.stdin          输入相关
    8. 

  8. sys.stdout         输出相关
    9. 

  9. sys.stderror       错误相关
    10. 



    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # 模块
    6. 

    7. 

  7. import os
    8. 

  8. import sys
    9. 

    10. 

  10. ss = os.path.abspath(__file__)   # 获取文件的绝对路径
    11. 

  11. dd = os.path.dirname(__file__)   # 获取文件的所在目录
    12. 

  12. sys.path.append(os.path.dirname(os.path.abspath(__file__))) # 将文件的目录添加到系统默认路径
    13.

hashlib

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

    

  1. import hashlib
    2. 

  2.  
    3. 

  3. # ######## md5 ########
    4. 

  4. hash = hashlib.md5()
    5. 

  5. # help(hash.update)
    6. 

  6. hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
    7. 

  7. print(hash.hexdigest())
    8. 

  8. print(hash.digest())
    9. 

  9.  
    10. 

  10.  
    11. 

  11. ######## sha1 ########
    12. 

  12.  
    13. 

  13. hash = hashlib.sha1()
    14. 

  14. hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
    15. 

  15. print(hash.hexdigest())
    16. 

  16.  
    17. 

  17. # ######## sha256 ########
    18. 

  18.  
    19. 

  19. hash = hashlib.sha256()
    20. 

  20. hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
    21. 

  21. print(hash.hexdigest())
    22. 

  22.  
    23. 

  23.  
    24. 

  24. # ######## sha384 ########
    25. 

  25.  
    26. 

  26. hash = hashlib.sha384()
    27. 

  27. hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
    28. 

  28. print(hash.hexdigest())
    29. 

  29.  
    30. 

  30. # ######## sha512 ########
    31. 

  31.  
    32. 

  32. hash = hashlib.sha512()
    33. 

  33. hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
    34. 

  34. print(hash.hexdigest())
    35.

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

    

  1. import hashlib
    2. 

  2.  
    3. 

  3. # ######## md5 ########
    4. 

  4.  
    5. 

  5. hash = hashlib.md5(bytes(‘898oaFs09f‘,encoding="utf-8"))
    6. 

  6. hash.update(bytes(‘admin‘,encoding="utf-8"))
    7. 

  7. print(hash.hexdigest())
    8.

python内置还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密

    

  1. import hmac
    2. 

  2.  
    3. 

  3. h = hmac.new(bytes(‘898oaFs09f‘,encoding="utf-8"))
    4. 

  4. h.update(bytes(‘admin‘,encoding="utf-8"))
    5. 

  5. print(h.hexdigest())
    6.

MD5

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # MD5 加密
    6. 

  6. import hashlib
    7. 

    8. 

  8. obj = hashlib.md5()
    9. 

  9. obj.update(bytes(‘123‘,encoding=‘utf-8‘))
    10. 

  10. result = obj.hexdigest()
    11. 

  11. print(result)
    12.

正则表达式

re模块

普通字符：a-z/A-Z/0-9

元字符： .    ^    $    *    +    ?    {}    []    |    ()    \

    

  1. 字符：
    2. 

  2. . 匹配除换行符以外的任意字符
    3. 

  3. \w	匹配字母或数字或下划线或汉字
    4. 

  4. \s	匹配任意的空白符
    5. 

  5. \d	匹配数字
    6. 

  6. \b	匹配单词的开始或结束
    7. 

  7. ^	匹配字符串的开始
    8. 

  8. $	匹配字符串的结束
    9. 

  9. 次数：
    10. 

  10. * 重复零次或更多次
    11. 

  11. +	重复一次或更多次
    12. 

  12. ?	重复零次或一次
    13. 

  13. {n}	重复n次
    14. 

  14. {n,}	重复n次或更多次
    15. 

  15. {n,m}	重复n到m次
    16.

re.findall()    # 匹配所有结果

    

  1. # findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；
    2. 

  2. # 空的匹配也会包含在结果中
    3. 

  3. #findall(pattern, string, flags=0)
    4. 



    

  1.         # 无分组
    2. 

  2.         r = re.findall("a\w+",origin)
    3. 

  3.         print(r)
    4. 

    5. 

  5.         # 有分组
    6. 

  6.         origin = "hello alex bcd abcd lge acd 19"
    7. 

  7.         r = re.findall("a((\w*)c)(d)", origin)
    8. 

  8.         print(r)
    9.

re.match()    # 从起始位置开始匹配

    

  1. # match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
    2. 

  2.  
    3. 

  3.  
    4. 

  4.  match(pattern, string, flags=0)
    5. 

  5.  # pattern： 正则模型
    6. 

  6.  # string ： 要匹配的字符串
    7. 

  7.  # falgs  ： 匹配模式
    8. 

  8.      X  VERBOSE     Ignore whitespace and comments for nicer looking RE‘s.
    9. 

  9.      I  IGNORECASE  Perform case-insensitive matching.
    10. 

  10.      M  MULTILINE   "^" matches the beginning of lines (after a newline)
    11. 

  11.                     as well as the string.
    12. 

  12.                     "$" matches the end of lines (before a newline) as well
    13. 

  13.                     as the end of the string.
    14. 

  14.      S  DOTALL      "." matches any character at all, including the newline.
    15. 

  15.  
    16. 

  16.      A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D
    17. 

  17.                     match the corresponding ASCII character categories
    18. 

  18.                     (rather than the whole Unicode categories, which is the
    19. 

  19.                     default).
    20. 

  20.                     For bytes patterns, this flag is the only available
    21. 

  21.                     behaviour and needn‘t be specified.
    22. 

  22.       
    23. 

  23.      L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.
    24. 

  24.      U  UNICODE     For compatibility only. Ignored for string patterns (it
    25. 

  25.                     is the default), and forbidden for bytes patterns.
    26. 



    

  1.         # 无分组
    2. 

  2.         r = re.match("h\w+", origin)
    3. 

  3.         print(r.group())     # 获取匹配到的所有结果
    4. 

  4.         print(r.groups())    # 获取模型中匹配到的分组结果
    5. 

  5.         print(r.groupdict()) # 获取模型中匹配到的分组结果
    6. 

    7. 

  7.         # 有分组
    8. 

    9. 

  9.         # 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
    10. 

    11. 

  11.         r = re.match("h(\w+).*(?P<name>\d)$", origin)
    12. 

  12.         print(r.group())     # 获取匹配到的所有结果
    13. 

  13.         print(r.groups())    # 获取模型中匹配到的分组结果
    14. 

  14.         print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组
    15.

re.search()    # 匹配一个结果

    

  1. # search,浏览整个字符串去匹配第一个，未匹配成功返回None
    2. 

  2. # search(pattern, string, flags=0)
    3. 



    

  1.         # 无分组
    2. 

    3. 

  3.         r = re.search("a\w+", origin)
    4. 

  4.         print(r.group())     # 获取匹配到的所有结果
    5. 

  5.         print(r.groups())    # 获取模型中匹配到的分组结果
    6. 

  6.         print(r.groupdict()) # 获取模型中匹配到的分组结果
    7. 

    8. 

  8.         # 有分组
    9. 

    10. 

  10.         r = re.search("a(\w+).*(?P<name>\d)$", origin)
    11. 

  11.         print(r.group())     # 获取匹配到的所有结果
    12. 

  12.         print(r.groups())    # 获取模型中匹配到的分组结果
    13. 

  13.         print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组
    14.

re.sub()    # 匹配替换

    

  1. # sub，替换匹配成功的指定位置字符串
    2. 

  2.  
    3. 

  3. sub(pattern, repl, string, count=0, flags=0)
    4. 

  4. # pattern： 正则模型
    5. 

  5. # repl   ： 要替换的字符串或可执行对象
    6. 

  6. # string ： 要匹配的字符串
    7. 

  7. # count  ： 指定匹配个数
    8. 

  8. # flags  ： 匹配模式
    9. 



    

  1.         # 与分组无关
    2. 

    3. 

  3.         origin = "hello alex bcd alex lge alex acd 19"
    4. 

  4.         r = re.sub("a\w+", "999", origin, 2)
    5. 

  5.         print(r)
    6.

re.split()    # 分割

    

  1. # split，根据正则匹配分割字符串
    2. 

  2.  
    3. 

  3. split(pattern, string, maxsplit=0, flags=0)
    4. 

  4. # pattern： 正则模型
    5. 

  5. # string ： 要匹配的字符串
    6. 

  6. # maxsplit：指定分割个数
    7. 

  7. # flags  ： 匹配模式
    8. 



    

  1.         # 无分组
    2. 

  2.         origin = "hello alex bcd alex lge alex acd 19"
    3. 

  3.         r = re.split("alex", origin, 1)
    4. 

  4.         print(r)
    5. 

    6. 

  6.         # 有分组
    7. 

  7.         
    8. 

  8.         origin = "hello alex bcd alex lge alex acd 19"
    9. 

  9.         r1 = re.split("(alex)", origin, 1)
    10. 

  10.         print(r1)
    11. 

  11.         r2 = re.split("(al(ex))", origin, 1)
    12. 

  12.         print(r2)
    13.

进度条小练习

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # 进度条小程序
    6. 

  6. import sys
    7. 

  7. import time
    8. 

    9. 

  9. def view_bar(num, total):
    10. 

  10.     rate = float(num) / float(total)
    11. 

  11.     rate_num = int(rate * 100)
    12. 

  12.     r = ‘\r%s%d%%‘ % ("="*num , rate_num)
    13. 

  13.     sys.stdout.write(r)
    14. 

  14.     sys.stdout.flush()
    15. 

    16. 

  16. if __name__ == ‘__main__‘:
    17. 

  17.     for i in range(0, 101):
    18. 

  18.         time.sleep(0.1)
    19. 

  19.         view_bar(i, 100)
    20.
五、冒泡算法

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding: utf-8 -.-
    3. 

  3. # By sandler
    4. 

    5. 

  5. # 冒泡排序
    6. 

  6. li = [1,5,2,7,11,44,66,33,22]
    7. 

  7. print(li)
    8. 

  8. for i in range(len(li))[::-1]:
    9. 

  9.     for j in range(i):
    10. 

  10.         if li[j] > li[j+1]:
    11. 

  11.             li[j],li[j+1] = li[j+1], li[j]
    12. 

  12. print(li)
    13. 

    14. 

  14. # 执行结果
    15. 

  15. [1, 5, 2, 7, 11, 44, 66, 33, 22]
    16. 

  16. [1, 2, 5, 7, 11, 22, 33, 44, 66]
    17.

六、本周作业：

计算器，只处理加减乘除

8*12+(6-(5*6-2)/77+2)*(3-7)+8

# 1、从前到后找，找到第一个 (开始 )结尾，中间不含有括号

# 2、\(中间不包含括号\)

def 处理加减乘除(表达式):

# 8*12+1*4+8

return 1

def 处理括号(表达式):

while True:

#8*12+(6-(5*6-2)/77+2)*(3-7)+8

re.split("\((中间不包含括号)\)", 表达式, 1)

8*12+(6-   5*6-2  /77+2)*(3-7)+8

ret = 处理加减乘除(5*6-2 )

8*12+(6- ret /77+2)*(3-7)+8

来自为知笔记(Wiz)

时间： 2024-08-09 17:18:29

Python之路_Day6的相关文章

Python之路【第十七篇】：Django【进阶篇 】

Python之路[第十七篇]:Django[进阶篇 ] Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行数据库操作 import MySQLdb def GetList(sql): db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')

Python之路【第九篇】：Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

Python之路[第九篇]:Python操作 RabbitMQ.Redis.Memcache.SQLAlchemy Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度.Memcached基于一个存储键/值对的hashmap.其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信. Memc

七日Python之路--第十二天（Django Web 开发指南）

<Django Web 开发指南>.貌似使用Django1.0版本,基本内容差不多,细读无妨.地址:http://www.jb51.net/books/76079.html (一)第一部分 入门 (1)内置数字工厂函数 int(12.34)会创建一个新的值为12的整数对象,而float(12)则会返回12.0. (2)其他序列操作符 连接(+),复制(*),以及检查是否是成员(in, not in) '**'.join('**')   或  '***%s***%d' % (str, int)

七日Python之路--第九天

众所周知,代码这东西不是看出来的.程序这东西只哟一个标准. 下面找点开源的东西看看,学习一下大婶们的犀利编码...... 推荐一下: 虽然有点老了:http://www.iteye.com/topic/405150,还有就是GitHub上面搜索一下Django就能出来很多,当然还有OSChina.只是有个问题,就是Django版本不同,具体的内容可能会有些不同,但大概还是相同的.领略即可,然后书写自己的代码. 首要的还是官方文档. 看着还是有些难度的.偶然发现一个不错的Blog:http://w

Python之路【第三篇】：Python基础（二）

Python之路[第三篇]:Python基础(二) 内置函数 一 详细见python文档,猛击这里 文件操作 操作文件时,一般需要经历如下步骤: 打开文件 操作文件 一.打开文件 1 文件句柄 = file('文件路径', '模式') 注:python中打开文件有两种方式,即:open(...) 和  file(...) ,本质上前者在内部会调用后者来进行文件操作,推荐使用 open. 打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作.

Python之路【第二篇】：Python基础（一）

Python之路[第二篇]:Python基础(一) 入门知识拾遗 一.作用域 对于变量的作用域,执行声明并在内存中存在,该变量就可以在下面的代码中使用. 1 2 3 if 1==1:     name = 'wupeiqi' print  name 下面的结论对吗? 外层变量,可以被内层变量使用 内层变量,无法被外层变量使用 二.三元运算 1 result = 值1 if 条件 else 值2 如果条件为真:result = 值1如果条件为假:result = 值2 三.进制 二进制,01 八进

Python之路【第十九篇】：爬虫

Python之路[第十九篇]:爬虫 网络爬虫(又被称为网页蜘蛛,网络机器人,在FOAF社区中间,更经常的称为网页追逐者),是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本.另外一些不常使用的名字还有蚂蚁.自动索引.模拟程序或者蠕虫. Requests Python标准库中提供了:urllib.urllib2.httplib等模块以供Http请求,但是,它的 API 太渣了.它是为另一个时代.另一个互联网所创建的.它需要巨量的工作,甚至包括各种方法覆盖,来完成最简单的任务. import

Python之路【第七篇】：线程、进程和协程

Python之路[第七篇]:线程.进程和协程 Python线程 Threading用于提供线程相关的操作,线程是应用程序中工作的最小单元. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 #!/usr/bin/env python # -*- coding:utf-8 -*- import threading import time   def show(arg):     time.sleep(1)     print 'thread'+str(arg)   for i in

Python之路【第八篇】：堡垒机实例以及数据库操作

Python之路[第八篇]:堡垒机实例以及数据库操作 堡垒机前戏 开发堡垒机之前,先来学习Python的paramiko模块,该模块机遇SSH用于连接远程服务器并执行相关操作 SSHClient 用于连接远程服务器并执行基本命令 基于用户名密码连接: + import paramiko transport = paramiko.Transport(('hostname', 22)) transport.connect(username='wupeiqi', password='123') ssh