# pydoc

**Repository Path**: develop1024/pydoc

## Basic Information

- **Project Name**: pydoc
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2019-11-18
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README



[TOC]



# 日期时间time模块,datetime模块

#### 获取当前时间戳

```python
import time
now = time.time()
print '当前时间戳为',now
```



#### 获取当前时间格式化

```python
import time
now = time.strftime("%Y-%m-%d %H:%M:%S")
print "当前时间格式化输出", now

print time.strftime("%Y-%m-%d %X")  # 第二种方式

print time.strftime("%Y%m%d%H%M%S",time.localtime(time.time())) # 第三种方式
```



#### 将时间戳格式化输出

```python
import time
now = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(1481248540.68))
print "1481248540.68 格式化输出结果为",now
```



#### 将格式化的日期转为时间戳

```python
import time
now = time.mktime(time.strptime('2016-11-18 23:59:03','%Y-%m-%d %H:%M:%S'))
print "转化后的时间戳为",now
```



#### 获取现行时间 datetime模块

```python
import datetime
now = datetime.datetime.now()
print "现在的时间是",now
```



#### 获取日期时间详细信息

```python
import datetime
now = datetime.datetime.now()
print now.date()  #获取日期
print now.time()  #获取时间
print now.year   #获取年份
print now.month  #获取月份
print now.day    #获取天数
print now.hour   #获取小时
print now.minute #获取分钟
print now.second #获取秒数
print now.weekday() #返回星期几
```



#### 将字符串转化为datetime

```python
import datetime
mytime =  datetime.datetime.strptime("2016-12-23 23:00:02","%Y-%m-%d %H:%M:%S")
print mytime
print type(mytime)
```







# Python 加密解密

#### base64加密

```python
import base64
info = '小可爱'
bm = base64.b64encode(info)
print bm
```

#### base64解密

```python
jm = base64.b64decode(bm)
print jm
```



#### 其它加密方法 hashlib模块

```python
import hashlib

#md5加密
hash = hashlib.md5()
hash.update('admin'.encode('utf-8'))
print hash.hexdigest()


#sha1加密
hash = hashlib.sha1()
hash.update('admin'.encode('utf-8'))
print hash.hexdigest()


#sha256加密
hash = hashlib.sha256()
hash.update('admin'.encode('utf-8'))
print hash.hexdigest()


#sha384加密
hash = hashlib.sha384()
hash.update('admin'.encode('utf-8'))
print hash.hexdigest()


#sha512加密
hash = hashlib.sha512()
hash.update('admin'.encode('utf-8'))
print hash.hexdigest()


#自定义key加密
hash = hashlib.md5('python'.encode('utf-8'))
hash.update('admin'.encode('utf-8'))
print hash.hexdigest()


#hmac 加密
import hmac
h = hmac.new('python'.encode('utf-8'))
h.update('helloworld'.encode('utf-8'))
print h.hexdigest()
```









# Python random模块取随机数

#### 随机取一个浮点数

```python
import random
print random.random()
```

#### 随机取一个整数

```python
import random
print random.randint(1, 10)
```

#### 随机取序列中的一个元素

```python
import random
testlist1 = ['1123', 'goubuli', 58, (1, 3, 'xiaokeai')]
print random.choice(testlist1)
```

```python
import random
testlist2 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 10)
print random.choice(testlist2)
```













# Python keyword模块,关键字

#### 打印Python关键字

```python
import keyword
print keyword.kwlist
```

#### 判读是否是Python关键字

```python
print keyword.iskeyword('and')
print keyword.iskeyword('goubuli')
```











# Python zipfile模块  压缩,解压

####添加一个压缩文件

```python
import zipfile
#添加一个压缩文件 压缩a.txt
z = zipfile.ZipFile('file.zip','w')
z.write("a.txt")
z.close()
```







#### 添加多个压缩文件

```python
#添加两个压缩文件 压缩a.txt  b.txt
z = zipfile.ZipFile('file2.zip','w')
z.write("a.txt")
z.write("b.txt")
z.close()
```





#### 解压文件

```python
# 解压
z = zipfile.ZipFile('file.zip', 'r')
z.extractall()    #可设置解压路径  如 z.extractall("c:/") 
z.close()
```











# Python os,shutil模块 文件目录操作

#### 复制一个文件的内容到另一个文件中

```python
import shutil
shutil.copyfileobj(open("a.txt","r"),open("b.txt","w"))
```



#### 复制一个文件

```python
shutil.copyfile("oldfile","newfile")    # oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile")        # oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
```





#### 递归的复制文件夹及下面的所有文件

```python
shutil.copytree("olddir","newdir")      # olddir和newdir都只能是目录，且newdir必须不存在
```







### 递归的移动文件夹及下面的所有文件

```python
shutil.move("c:/temp","c:/file/")
```





#### 递归的去删除文件

```python
shutil.rmtree('c:/temp')
```







#### 将一下文件或文件夹打包  可指写打包类型 如：“zip”, “tar”, “bztar”，“gztar”

```python
shutil.make_archive("d:/zipfile","zip",root_dir="c:/users/wanglei/desktop/Everything")
```









#### 文件目录操作

```python
os.mkdir("file")                                #创建目录

#复制文件：
shutil.copyfile("oldfile","newfile")    #oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile")        #oldfile只能是文件夹，newfile可以是文件，也可以是目标目录

#复制文件夹：
shutil.copytree("olddir","newdir")       # olddir和newdir都只能是目录，且newdir必须不存在

#重命名文件（目录）
os.rename("oldname","newname")     # 文件或目录都是使用这条命令

#移动文件（目录）
shutil.move("oldpos","newpos")

#删除文件
os.remove("file")


#删除目录
os.rmdir("dir")           # 只能删除空目录
shutil.rmtree("dir")      # 空目录、有内容的目录都可以删


#转换目录
os.chdir("path")          # 换路径


#得到当前工作目录，即当前Python脚本工作的目录路径: 
print os.getcwd()

#返回指定目录下的所有文件和目录名
print os.listdir()

#函数用来删除一个文件
os.remove()

#删除多个目录
os.removedirs(r'c:\python')

#检验给出的路径是否是一个文件
print os.path.isfile()

#检验给出的路径是否是一个目录
os.path.isdir()

#判断是否是绝对路径
os.path.isabs()

#检验给出的路径是否真地存
os.path.exists()

#返回一个路径的目录名和文件名
os.path.split() 

例:
os.path.split('/home/swaroop/byte/code/poem.txt')
结果 ('/home/swaroop/byte/code', 'poem.txt')


#分离扩展名
os.path.splitext()


#获取路径名
os.path.dirname()


#获取文件名
os.path.basename()


#运行shell命令
os.system()

#读取和设置环境变量
os.getenv()
os.putenv()

#给出当前平台使用的行终止符
os.linesep 
#Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'

#指示你正在使用的平台：os.name       
# 对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

#重命名
os.rename(old,new)

#创建多级目录
os.makedirs(r'c:\python\test')

#创建单个目录
os.mkdir('test')

#获取文件属性
os.stat(file)

#修改文件权限与时间戳
os.chmod(file)

#终止当前进程
os.exit()

#获取文件大小
os.path.getsize(filename)
```

#### os.path用法

```python
os.path.abspath(path) #返回绝对路径
os.path.basename(path) #返回文件名
os.path.commonprefix(list) #返回list(多个路径)中，所有path共有的最长的路径。
os.path.dirname(path) #返回文件路径
os.path.exists(path)  #路径存在则返回True,路径损坏返回False
os.path.lexists  #路径存在则返回True,路径损坏也返回True
os.path.expanduser(path)  #把path中包含的"~"和"~user"转换成用户目录
os.path.expandvars(path)  #根据环境变量的值替换path中包含的”$name”和”${name}”
os.path.getatime(path)  #返回最后一次进入此path的时间。
os.path.getmtime(path)  #返回在此path下最后一次修改的时间。
os.path.getctime(path)  #返回path的大小
os.path.getsize(path)  #返回文件大小，如果文件不存在就返回错误
os.path.isabs(path)  #判断是否为绝对路径
os.path.isfile(path)  #判断路径是否为文件
os.path.isdir(path)  #判断路径是否为目录
os.path.islink(path)  #判断路径是否为链接
os.path.ismount(path)  #判断路径是否为挂载点（）
os.path.join(path1[, path2[, ...]])  #把目录和文件名合成一个路径
os.path.normcase(path)  #转换path的大小写和斜杠
os.path.normpath(path)  #规范path字符串形式
os.path.realpath(path)  #返回path的真实路径
os.path.relpath(path[, start])  #从start开始计算相对路径
os.path.samefile(path1, path2)  #判断目录或文件是否相同
os.path.sameopenfile(fp1, fp2)  #判断fp1和fp2是否指向同一文件
os.path.samestat(stat1, stat2)  #判断stat tuple stat1和stat2是否指向同一个文件
os.path.split(path)  #把路径分割成dirname和basename，返回一个元组
os.path.splitdrive(path)   #一般用在windows下，返回驱动器名和路径组成的元组
os.path.splitext(path)  #分割路径，返回路径名和文件扩展名的元组
os.path.splitunc(path)  #把路径分割为加载点与文件
os.path.walk(path, visit, arg)  #遍历path，进入每个目录都调用visit函数，visit函数必须有
```

#### 常用归类

```python
os.getcwd()                # 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")        # 改变当前脚本工作目录；相当于shell下cd
os.curdir                  # 返回当前目录: ('.')
os.pardir                  # 获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2')        # 可生成多层递归目录
os.removedirs('dirname1')       # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')         # 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')         # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')         # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                # 删除一个文件
os.rename("oldname","new")      # 重命名文件/目录
os.stat('path/filename')        # 获取文件/目录信息
os.sep                          # 操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep　　　　　　　　　　　　# 当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep　　　　　　　　　　　　# 用于分割文件路径的字符串
os.name　　　　　 　　　　　　　　# 字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")       # 运行shell命令，直接显示
os.environ　　　　　　　　　　　  # 获取系统环境变量
os.path.abspath(path)           # 返回path规范化的绝对路径
os.path.split(path)             # 将path分割成目录和文件名二元组返回
os.path.dirname(path)           # 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)          # 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)           # 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)          　# 如果path是绝对路径，返回True
os.path.isfile(path)           # 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)            # 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)        # 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)        # 返回path所指向的文件或者目录的最后修改时间
```















# Python ConfigParser模块,读取配置文件

#### 读取操作

```python
import ConfigParser
cp=ConfigParser.ConfigParser()
cp.read("c:\\users\\administrator\\desktop\\config.ini")
print cp.sections() # 获取所有的节点
print cp.options("mysql")# 获取某个节点下的所有键
print cp.items("mysql") #获取某个节点下的
print cp.get("mysql","ip")# 获取节点下键的值
print cp.getint("mysql","password") #按照类型读取数据
print type(cp.getint("mysql","password"))#查看数据类型
```

#### 设置某个option的值

```python
print cp.get("mysql","ip")
print cp.set("mysql","ip","192.168.8.118")  #设置一个节点下键的值
print cp.write(open("config.ini","w")) #写入
```



#### 添加一个section

```python
cp.add_section("oracle")        
cp.set("oracle","ip","http://www.everyday520.com")
cp.set("oracle","user","administrator")
cp.set("oracle","password","111111")
cp.write(open("config.ini","w"))
```



#### 移除section或option

```python
cp.remove_option("mysql","ip")
cp.remove_section("oracle")
cp.write(open("config.ini","w"))
```







# Python异常

#### 异常列表

| 异常名称                      | 描述                                |
| ------------------------- | --------------------------------- |
| BaseException             | 所有异常的基类                           |
| SystemExit                | 解释器请求退出                           |
| KeyboardInterrupt         | 用户中断执行(通常是输入^C)                   |
| Exception                 | 常规错误的基类                           |
| StopIteration             | 迭代器没有更多的值                         |
| GeneratorExit             | 生成器(generator)发生异常来通知退出           |
| StandardError             | 所有的内建标准异常的基类                      |
| ArithmeticError           | 所有数值计算错误的基类                       |
| FloatingPointError        | 浮点计算错误                            |
| OverflowError             | 数值运算超出最大限制                        |
| ZeroDivisionError         | 除(或取模)零 (所有数据类型)                  |
| AssertionError            | 断言语句失败                            |
| AttributeError            | 对象没有这个属性                          |
| EOFError                  | 没有内建输入,到达EOF 标记                   |
| EnvironmentError          | 操作系统错误的基类                         |
| IOError                   | 输入/输出操作失败                         |
| OSError                   | 操作系统错误                            |
| WindowsError              | 系统调用失败                            |
| ImportError               | 导入模块/对象失败                         |
| LookupError               | 无效数据查询的基类                         |
| IndexError                | 序列中没有此索引(index)                   |
| KeyError                  | 映射中没有这个键                          |
| MemoryError               | 内存溢出错误(对于Python 解释器不是致命的)         |
| NameError                 | 未声明/初始化对象 (没有属性)                  |
| UnboundLocalError         | 访问未初始化的本地变量                       |
| ReferenceError            | 弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
| RuntimeError              | 一般的运行时错误                          |
| NotImplementedError       | 尚未实现的方法                           |
| SyntaxError               | Python 语法错误                       |
| IndentationError          | 缩进错误                              |
| TabError                  | Tab 和空格混用                         |
| SystemError               | 一般的解释器系统错误                        |
| TypeError                 | 对类型无效的操作                          |
| ValueError                | 传入无效的参数                           |
| UnicodeError              | Unicode 相关的错误                     |
| UnicodeDecodeError        | Unicode 解码时的错误                    |
| UnicodeEncodeError        | Unicode 编码时错误                     |
| UnicodeTranslateError     | Unicode 转换时错误                     |
| Warning                   | 警告的基类                             |
| DeprecationWarning        | 关于被弃用的特征的警告                       |
| FutureWarning             | 关于构造将来语义会有改变的警告                   |
| OverflowWarning           | 旧的关于自动提升为长整型(long)的警告             |
| PendingDeprecationWarning | 关于特性将会被废弃的警告                      |
| RuntimeWarning            | 可疑的运行时行为(runtime behavior)的警告     |
| SyntaxWarning             | 可疑的语法的警告                          |
| UserWarning               | 用户代码生成的警告                         |











#Python 字符串：

#### 字符串常见操作

> 1. `find`：返回查找字符串的下标位置。如果返回的是-1，代表的是没有查找到该字符串。`rfind`是从右边到左边。
> 2. `index`：和`find`非常类似。只不过当查找不到这个字符串的时候，不是返回-1，而是抛出一个异常。`rindex`是从右边开始查找。
> 3. `len`：获取字符串字符的长度。
> 4. `count`：用来获取子字符串在原来字符串中出现的次数。
> 5. `replace`：新创建一个字符串，把原来字符串中的某个字符串替换为你想要的字符串。
> 6. `split`：按照给定的字符串进行分割。返回的是一个列表。
> 7. `startswith`：判断一个字符串是否以某个字符串开始。
> 8. `endswith`：判断一个字符串是否以某个字符串结束。
> 9. `lower`：将字符串全部改成小写。
> 10. `upper`：将字符串全部改成大写。
> 11. `strip`：将字符串左右的空格全部去掉。
> 12. `lstrip`：删除字符串左边的空格。
> 13. `rstrip`：删除字符串右边的空格。
> 14. `partition`：从`str`出现的第一个位置起，把字符串`string`分成一个3元素的元组`(string_pre_str,str,string_post_str)`，如果 string中不包含`str`，则`string_pre_str == string`。
> 15. `isalnum`：如果`string`至少有一个字符并且所有字符都是字母或数字则返回`True`，否则返回`False`。
> 16. `isalpha`：如果`string`至少有一个字符并且所有字符都是字母则返回`True`，否则返回`False`。
> 17. `isdigit`：如果`string`只包含数字则返回`True`否则返回 `False`。
> 18. `isspace`：如果字符串中只包含空格，则返回`True`，否则返回`False`。
> 19. `format`：格式化字符串。







#### 转义字符

| 转义字符 | 描述   |
| ---- | ---- |
| \在行尾 | 续行符  |
| \n   | 换行符  |
| \'   | 单引号  |
| \"   | 双引号  |
| \t   | 制表符  |
| \     | 反斜杠  |









#### 获取ASCII值

```python

# 获取字符的ascii值
print ord('a')

# 获取值的ascii
print chr(97)
```









# Python列表操作

#### 列表的函数

```python
list1=[9,1,3,4,3]
list2=[8,3,6]
tuple1=(1,3,7,5,2,4)

max(list1)  		#取列表中的最大值
min(list1)  		#取列表中的最小值
cmp(list1,list2)    #比较两个列表的大小 从第零一元素开始比较，如果第一个元素想等则比较下一个元素，如果list1大于list2返回1，小于则返回-1 ，如果两个列表想等返回0
len(list1)  	 	#取列表中的长度
list(tuple1)  		#将元组转换成列表
```

#### 列表的方法

```python
list1.append(18)  	#向列表末尾增加一个新的元素
list.insert(3,18)	#指定一个位置增加一个新的元素
list.remove(9) 		#删除列表中匹配的元素，如有多个则删除多个
list.count(3) 		#统计3在list列表中共出现了多少次
list.pop(2) 		#指定要删除的元素位置，如果不写位置则默认删除最后一个元素，删除后会返回删除的元素
list.index(3) 		#返回3在列表中第一次出现的位置
list.extend(list2)  #将list2列表中的值从尾部增加进来
list.reverse() 		#反向列表中的元素
list.sort()			#对原列表进行排序

del list1[2]  		#删除一个元素
```





#### Python遍历字典dict

```python
#encoding:utf-8
userinfo = {
    'username':'wanglei',
    'password':'111111'
}
 

#只遍历key
for k in userinfo.keys():
    print k
 
 
for k in userinfo.iterkeys():
    print k
 
 
#只遍历value
for v in userinfo.values():
    print v
 
for k in userinfo.itervalues():
    print k
 
 
#遍历key,value
for k,v in userinfo.items():
    print k,
    print v
 
#遍历key,value
for k,v in userinfo.iteritems():
        print k,v
```















# Python 安装包或者模块pip

#### 安装指定包

```
pip install 包名
```

####安装指定版本的包

```
pip install django == 1.10.6
```

#### 卸载包

```
pip uninstall 包名
```

#### 升级包

```
pip install -U 包名
```

#### 升级pip

```
pip install -U pip
```

####查看当前pip是哪个版本

```
pip --version
```

#### 显示某个已安装的包的信息

```
pip show -f <包名>
```

#### 列出当前环境下安装了哪些包

```
pip list
```

####将当前环境安装的包全部列出来放在文件中

```
pip freeze > requirements.txt
```

#### 从某个文件中安装包

```
pip install -r requirements.txt
```

#### 临时更改安装源，以豆瓣源为例

```
pip install <包名> -i https://pypi.douban.com/simple
```

#### 永久更改安装源

```
windows操作系统：在当前用户目录下新建pip/pip.ini，然后在文件红添加以下代码：

  [global]
  index-url = https://pypi.douban.com/simple
  

Linux/Mac：在用户目录下新建.pip/pip.conf，然后在文件中添加以下代码：

  [global]
  index-url = https://pypi.douban.com/simple
```









# Python sys模块

#### sys模块用法大全

```python
sys.argv           #命令行参数List，第一个元素是程序本身路径 
sys.modules.keys() #返回所有已经导入的模块列表 
sys.exc_info()     #获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息 
sys.exit(n)        #退出程序，正常退出时exit(0) 
sys.hexversion     #获取Python解释程序的版本值，16进制格式如：0x020403F0 
sys.version        #获取Python解释程序的版本信息 
sys.maxint         #最大的Int值 
sys.maxunicode     #最大的Unicode值 
sys.modules        #返回系统导入的模块字段，key是模块名，value是模块 
sys.path           #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 
sys.platform       #返回操作系统平台名称 
sys.stdout         #标准输出
sys.stdin          #标准输入
sys.stderr         #错误输出
sys.exc_clear()    #用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix    #返回平台独立的python文件安装的位置
sys.byteorder      #本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'
sys.copyright      #记录python版权相关的东西
sys.api_version    #解释器的C的API版本
sys.version_info 
'''
>>> sys.version_info
(2, 4, 3, 'final', 0) 'final'表示最终,也有'candidate'表示候选，表示版本级别，是否有后继的发行'''

sys.displayhook(value)      '''如果value非空，这个函数会把他输出到sys.stdout，并且将他保存进__builtin__._.指在python的交互式解释器里，'_'代表上次你输入得到的结果，hook是钩子的意思，将上次的结果钩过来'''
sys.getdefaultencoding()   		 #返回当前你所用的默认的字符编码格式
sys.getfilesystemencoding() 	 #返回将Unicode文件名转换成系统文件名的编码的名字
sys.setdefaultencoding(name)	#用来设置当前默认的字符编码，如果name和任何一个可用的编码都不匹配，抛出LookupError，这个函数只会被site模块的sitecustomize使用，一旦别site模块使用了，他会从sys模块移除
sys.builtin_module_names        #Python解释器导入的模块列表 
sys.executable                  #Python解释程序路径 
sys.getwindowsversion()         #获取Windows的版本 
sys.stdin.readline()            #从标准输入读一行，sys.stdout.write("a") 屏幕输出a
```













# Python   paramiko模块远程执行linux命令

#### 简单的命令执行 paramiko 密码方式登陆

```python
# -*- coding:utf-8 -*-
import paramiko

hostip = '123.206.174.241'
port = 22
username = 'root'
password = 'Yy123156'
command = 'pwd'


# 实例化SSHClient
client = paramiko.SSHClient()
# 自动添加策略，保存服务器的主机名和密钥信息
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接SSH服务端，以用户名和密码进行认证
client.connect(hostname=hostip,port=port,username=username, password=password)
# 打开一个Channel并执行命令
stdin, stdout, stderr = client.exec_command(command)
# 打印执行结果
print stdout.readlines()
# 关闭SSHClient
client.close()
```

#### 简单的命令执行 paramiko 密钥方式登陆

```python
# -*- coding:utf-8 -*-
import paramiko


hostip = '123.206.174.241'
port = 22
username = 'root'
password = 'Yy123156'
command = 'pwd'
key_file = '/root/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(key_file)

s = paramiko.SSHClient()
s.load_system_host_keys()
s.connect(hostname=hostip, port=port, username=username, password=password,pkey=key)
stdin, stdout, stderr = s.exec_command(command)

print stdout.read()
print stderr.read()
s.close()
```















# Python 持久化 shelve模块

####写

```python
# -*- coding:utf-8 -*-
import shelve

s = shelve.open('config.db')
try:
 	s['mykey'] = {'username':'zhangsan','password':'111111'}
 	s.close()
finally:
	s.close()
```

#### 读

```python
# -*- coding:utf-8 -*-
import shelve

s = shelve.open('config.db')
print s['mykey']['username']
print s['mykey']['password']
```













# Python  内置函数

####常用内置函数

```python
help(obj) 			# 在线帮助, obj可是任何类型
callable(obj) 		# 查看一个obj是不是可以像函数一样调用
repr(obj) 			# 得到obj的表示字符串，可以利用这个字符串eval重建该对象的一个拷贝
eval_r(str) 		# 表示合法的python表达式，返回这个表达式
dir(obj) 			# 查看obj的name space中可见的name
hasattr(obj,name) 	# 查看一个obj的name space中是否有name
getattr(obj,name) 	# 得到一个obj的name space中的一个name
setattr(obj,name,value) # 为一个obj的name space中的一个name指向vale这个object
delattr(obj,name) 		# 从obj的name space中删除一个name
vars(obj) 				# 返回一个object的name space。用dictionary表示
locals()    			# 返回一个局部name space,用dictionary表示
globals() 				# 返回一个全局name space,用dictionary表示
type(obj) 				# 查看一个obj的类型
isinstance(obj,cls)     # 查看obj是不是cls的instance
issubclass(subcls,supcls) #　查看subcls是不是supcls的子类
```

####类型转换函数

```python
chr(i) 			# 把一个ASCII数值,变成字符
ord(i) 			# 把一个字符或者unicode字符,变成ASCII数值
oct(x) 			# 把整数x变成八进制表示的字符串
hex(x) 			# 把整数x变成十六进制表示的字符串
str(obj) 		# 得到obj的字符串描述
list(seq) 		# 把一个sequence转换成一个list
tuple(seq) 		# 把一个sequence转换成一个tuple
dict(),dict(list) # 转换成一个dictionary
int(x) 			# 转换成一个integer
long(x) 		# 转换成一个long interger
float(x) 		# 转换成一个浮点数
complex(x) 		# 转换成复数
max(...) 	    # 求最大值
min(...) 求最小值
```









# Python 多参数*args,**kargs

#### *args tuper类型

```python
def fun1(*args):
    print args
    print type(args)

    for i in args:
        print i

fun1(1,2,2,3,14,12,34,23,234)
```



####**args dict类型

```python
def fun2(**kwargs):
    print kwargs
    print type(kwargs)

    for k,v in kwargs.items():
        print k,v

fun2(username='wanglei',password='111111')

```







# Python apply函数用法

```python
# demo1

def demo1():
    print 'hello world'
    
apply(demo1)




# demo2
def demo2(username,password):
    print 'username->',username
    print 'password->',password

apply(demo2,('admin','111111'))


      
# demo3
def demo3(a,b):
    return a*b

sum = apply(demo3,(5,8))
print sum




# demo4
def demo4(*a):
    for i in a:
        print i

apply(demo4,((7,8,9,10)))





# demo5
def demo5(*b):
    for i in b:
        print i

apply(demo5,([1,2,3,4,5,65,22]))

```











# Python 虚拟环境 Virtualenv

#### Windows 下使用virtualenv

```powershell
1.创建一个新的环境
virtualenv testfolder


2.进入环境
testfolder/Scripts/activate


3.安装软件包
pip install package_name


4.退出环境
deactivate

```



#### Linux 下使用Virtualenv

```powershell
1.创建一个新的环境
virtualenv ENV


2.进入虚拟环境
cd ENV
source ./bin/activate



3.安装软件包
pip install package_name


4.退出虚拟环境
deactivate
```



































#Python基础-文件操作

### 打开和关闭文件

1. 打开文件：

   ```
    f = open('xxx.txt','w') #以写的方式打开一个文件

   ```

2. 关闭文件：

   ```
    f = open('xxx.txt','w')
    f.close() #关闭文件

   ```





### 文件的打开模式

| 打开模式            | 说明                                       |
| --------------- | ---------------------------------------- |
| r(read)         | 以只读的方式打开。文件的指针将会放在文件的开头。这是默认的模式          |
| w(write)        | 以只写的方式。如果该文件已经存在则将其覆盖。如果不存在，则创建一个文件用于写入。 |
| a(append)       | 以追加的方式打开文件。如果该文件存在将新的内容追加到文件末尾。如果不存在，则创建新文件用于写入。 |
| rb(read binary) | 以二进制的并且只读的方式打开一个文件。文件指针将会放在文件的开头。        |
| wb              | 以二进制和只写的方式打开一个文件。如果该文件已经存在则将其覆盖。如果该文件不存在，则创建新文件用于写入。 |
| ab              | 以二进制和追加的方式打开一个文件。如果该文件已经存在则追加到文件末。如果不存在，则创建新文件用于写入。 |
| r+              | 打开一个文件用于读写。文件指针将会放在文件的开头。写进去的内容会覆盖原来的内容。 |
| w+              | 打开一个文件用于读写。如果该文件已经存在则将其覆盖。如果文件不存在，则创建新文件。 |
| a+              | 打开一个文件用于读写，文件指针将会放在文件的结尾。如果文件存在，则会将新内容追加到文件后面。如果文件不存在，则创建新文件。 |
| rb+             | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。          |
| wb+             | 以二进制格式打开一个文件用于读写。如果该文件已经存在则将其覆盖。如果文件不存在，创建新文件。 |
| ab+             | 以二进制格式打开一个文件用于追加。如果该文件已经存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |





### 文件的读写操作

1. 读数据：使用read(count)函数可以从文件中读取数据，count表示要从文件中读取的数据的长度。如果没有传，那么表示读取文件中的所有的数据。

   ```python
    fp = open('test.txt','r')
    # 读取前面5个字节的数据
    line = fp.read(5)
    print line
    # 读取所有的数据
    line = fp.read()
    print line
   ```

2. 读一行的数据：使用readline 可以以行的形式读取文件。

   ```python
    fp = open('test.txt','r')
    line = fp.readline()
    print '第一行：%s' % line
    line = fp.readline()
    print '第二行：%s' % line
    fp.close()
   ```

3. 以行的形式把文件中所有的数据都读出来：readlines返回一个列表，列表中装的就是文件中每行的数据。

   ```python
    fp = open('test.txt','r')
    lines = fp.readlines()
    for line in lines:
        print line
    fp.close()
   ```

4. 直接迭代文件对象：文件对象也是一个迭代器。即可以通过for循环来进行迭代，并且一次性只会读取一行，从而可以读取大文件。

   ```python
    fp = open('test.txt','r')
    for line in fp:
        print line
   ```

5. write写数据到文件中：write将数据写入到文件中。

   ```python
   fp = open('test.txt','w')
   fp.write('hello')
   fp.close()
   ```

6. writelines写多个数据到文件中：writelines可以一次性写入多个数据，但是不会自动换行。

   ```python
   fp = open('test.txt','w')
   fp.writelines(['hello','world'])
   fp.close()
   ```





### 文件的定位读写

1. 获取当前文件指针的位置：在读写的过程中，如果想要知道当前文件指针所在的位置，可以通过`tell()`来获取。

   ```python
    fp = open('xxx.txt','r')
    str = fp.read(3)
    print '读取到的数据是：%s' % str

    # 查看当前位置
    position = fp.tell()
    print "当前文件位置：%d" % position

    fp.close()
   ```

2. 定位到某个位置：如果在读写文件的过程中，需要从另外一个位置进行操作，可以使用`seek()`。

`seek(offset,from)`有2个参数，意义为如下：

- offset：偏移量。

- from：相对位置。

  - 0：表示从文件开头。
  - 1：表示从当前位置。
  - 2：表示从文件末尾。

  ```python
  # demo1：把相对位置设置为从文件开头，并且向后偏移5个字节。
  fp = open("xxx.txt","r")

  position = fp.tell()
  print "当前文件指针位置是：%d" % position

  fp.seek(5,0)

  position = fp.tell()
  print '当前位置是：%d' % position

  str = fp.read()

  print '读取到的字符串：%s' % str
  ```

  ```python
  # demo2：把位置设置为：离文件末尾，3个字节处
  fp = open("xxx.txt","r")

  # 查看当前位置
  pos = fp.tell()
  print '当前文件指针位置：%d' % pos

  # 重新设置位置为离文件末尾3个字节位置
  fp.seek(-3,2)

  # 读取数据
  str = fp.read()

  # 关闭文件
  fp.close()
  ```

  在`Python3`中，如果以文本的形式打开一个文件（即：不使用b），那么`seek`函数的第二个参数只能为`0`（seek(0,2)除外）。





### 关闭文件

通常来说，一个文件对象在退出程序后会自动关闭。但是对于一些你写入了数据的文件，应该手动的进行关闭。因为Python可能会缓存写入的输入，如果程序抛出异常，那么缓存的文件将不会被写入文件。因此为了安全期间，要在使用完文件后关闭。
一般的写法是：

```python
    fp = open("xxx.txt",'r')
    try:
        # your code
    finally:
        # 为了安全起见，不管程序有没有发生异常，都要关闭文件
        fp.close()
```

实际上，有专门为这种情况设计的语句，即`with`语句：

```python
    with open('xxx.txt','r') as fp:
        # your code
```

以上的`with`语句，不管程序有没有发生异常，都会关闭文件。`with`语句是叫做上下文管理器，上下文管理器是一种支持`__enter__`和`__exit__`这两个方法的对象。后期会讲到。以后在使用文件操作的时候，应该尽量使用`with`语句。









#### 递归遍历文件

```python
# -*- coding:utf-8 -*-
import os

def getfile(filepath):
    for file in os.listdir(filepath):
        if os.path.isdir(os.path.join(filepath,file)):
            getfile(os.path.join(filepath,file))
        else:
             print os.path.join(filepath, file)

getfile("C:\\Users\\Administrator\\Desktop\\server")
```



























# Python 打包exe工具  Pyinstall,Py2exe

#### 使用pyinstall模块打包Python程序

```python
# 打包命令
python pyinstaller.py -F demo1.py



# 生成一个单独的(无依赖)exe控制台程序
python pyinstaller.py -F demo1.py



# 生成一个单独的(无依赖)窗口程序
python pyinstaller.py -F -w demo1.py



# 参数
-F, –onefile 打包成一个exe文件。
-D, –onedir 创建一个目录，包含exe文件，但会依赖很多文件（默认选项）。
-c, –console, –nowindowed 使用控制台，无界面(默认)
-w, –windowed, –noconsole 使用窗口，无控制台



# 注意会生成（均在Python27目录下）：
1.dist文件夹（包含生成好的sina_crawler.exe）
2.build文件夹（中间生成，没用，事后可以删掉）
3.sina_crawler.spec文件（中间生成，没用，事后可以删掉）
```





#### 使用py2exe打包Python程序

```python
# 1.编辑 mysetup.py 将"setup(console=["demo1.py"])" 里的demo1.py 改成你的文件名

from distutils.core import setup 
import py2exe
setup(console=["demo1.py"]) 


# 2.执行命令
python mysetup.py py2exe
```









# 装饰器

#### 装饰器

```python
# -*- coding:utf-8 -*-
from functools import wraps

def decorator(func):
    @wraps(func)
    def infunc(*args,**kwargs):
        print 'hello world'
        func(*args,**kwargs)
    return infunc

@decorator
def demo1():
    print 'demo1'


@decorator
def demo2():
    print 'demo2'


@decorator
def demo3(username,password):
    print 'demo3',username,password


# 调用无参数的函数
demo1()
demo2()

# 调用有参数的函数
demo3(username='zhangsan',password='111111')

# 打印函数的名秒称，这里函数的名称会变为infunc，因为我们用的wraps装饰器使函数保持原有的函数名
print demo3.__name__
```



#### 带参数的装饰器

```python
import time

def timer(arg):
    print('arg', arg)
    def deco(func):
        def warpper(*args, **kwargs):
            start_time = time.time()
            func(*args, **kwargs)
            stop_time = time.time()
            print('共消耗时间 ',  stop_time - start_time)
        return warpper
    return deco


@timer('a')
def test1():
    time.sleep(3)
    print('hello test1 func')


test1()
```





# 任务调度

```python
import schedule
import time

def job():
    print("I'm working...")

'''
每隔10分钟执行一次任务
每隔一小时执行一次任务
每天10:30执行一次任务
每周一的这个时候执行一次任务
每周三13:15执行一次任务
'''

schedule.every(10).minutes.do(job)
schedule.every().hour.do(job)
schedule.every().day.at("10:30").do(job)
schedule.every().monday.do(job)
schedule.every().wednesday.at("13:15").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)
```



# Python生成uuid

```python
import uuid

# uuid1 生成基于计算机主机ID和当前时间的UUID
print(uuid.uuid1())

# uuid3 基于命名空间和一个字符的MD5加密的UUID
print(uuid.NAMESPACE_DNS)
print(uuid.NAMESPACE_OID)
print(uuid.NAMESPACE_URL)
print(uuid.NAMESPACE_X500)

# uuid4 随机生成一个UUID
print(uuid.uuid4())

# uuid5 基于命名空间和一个字符的SHA-1加密的UUID
uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')

# 根据十六进制字符生成UUID
x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')
print(str(x))
print(x.bytes)
print(uuid.UUID(bytes=x.bytes))
```





## Python 常用内置函数

#### map

```python
# 将列表内的所有数据转为字符串
li = [1,5,6,4,8,96,1,6,4,61]
res = map(str, li)
res = list(res)
print(res)
```



## Python 发送邮件

```python
import smtplib
from email.mime.text import MIMEText
msg_from='31931727@qq.com'     #发送方邮箱
passwd='123456'                            #填入发送方邮箱的授权码
msg_to='31931727@qq.com'         #收件人邮箱
                            
subject="python邮件测试"            #主题     
content="这是我使用python smtplib及email模块发送的邮件"  #正文
msg = MIMEText(content)
msg['Subject'] = subject
msg['From'] = msg_from
msg['To'] = msg_to
try:
    s = smtplib.SMTP_SSL("smtp.qq.com",465) #邮件服务器及端口号
    s.login(msg_from, passwd)
    s.sendmail(msg_from, msg_to, msg.as_string())
    print("发送成功")
except s.SMTPException as e:
    print("发送失败")
finally:
    s.quit()
```