python管理cisco设备：
http://www.linuxeye.com/program/1680.html
学习：
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000
https://study.163.com/course/courseMain.htm?courseId=1004987028
慕课网
入门 https://www.imooc.com/learn/177
进阶 https://www.imooc.com/learn/317
python函数
https://docs.python.org/2/library/functions.html
python第三方库
https://pypi.org/
Python3版本print 需要加括号（）
一个等号是赋值
a = 3
两个等号是判断是否相等，返回True或False
3 == 3
1.打印字符串
print ("His name is %s"%("Aviad"))
效果：His name is Aviad
2.打印整数
print ("He is %d years old"%(25))
效果：He is 25 years old
3.打印浮点数（指定保留小数点位数）
print ("His height is %.2f m"%(1.8300))
效果：His height is 1.83
%s表示与字符串替换，%d表示用整数替换，%f表示用浮点数替换，
如果输出的字符串中本身就需要%（比如输出比率），则需要用连续的两个%%来输出%。
*args: 任意数量参数，传递的是一个list
**kw: 任意数量key-value值，传递的是一个dict
PS：其实只是`*`和`**`起作用，`*args`和`**kw`是习惯名而已
能够直接处理的数据类型
1.整数；2.浮点数；3.字符串；4.布尔值；5.空值
print " " 不加引号，单引号，双引号的运行区别
print'hello,python'
print'hello','python'此句代码中的逗号会变为空格输出
单行注释用#
多行注释用'''
在Python程序中，变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头；
在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量；（动态语言 更灵活）
静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。（如Java，C）
字符串本身包含' 比如I'm OK 可以用" "括起来表示
符串包含" 我们就可以用' '括起来表示
既有""也有''的情况下，在' 和" 的前面都要加
表示换行
表示一个制表符
\ 表示 字符本身
r'...' 和 r'''...''' 直接将符号当做字符串输出
r'...'不适用于多行字符串以及同时包含' 和" 的字符串
中文字符串
u'中文' 单行
u'''中文''' 多行
在第一行添加注释 # -*- coding: utf-8 -*-
加了注释后就不用在字符串前加u；加了u就不用在第一行加注释
数运算结果仍然是整数，浮点数运算结果仍然是浮点数
Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True
1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
数据类型是列表：list
list是一种有序的集合，可以随时添加和删除其中的元素
直接用 [ ] 把list的所有元素都括起来，就是一个list对象 ['Michael', 'Bob', 'Tracy']
通常把list赋值给一个变量，可以通过变量来引用list class = ['Michael', 'Bob', 'Tracy']
Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据
L = ['Michael', 100, True]
索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推
L = ['Adam', 'Lisa', 'Bart']
print L[0]
倒序索引，索引倒数第一用[-1]，倒数第二用[-2]，以此类推
添加新元素
L.append('Paul')
append()总是把新的元素添加到 list 的尾部
L.insert(0, 'Paul')
第一个参数是索引号，第二个参数是待添加的新元素：
删除元素
L.pop()
总是删掉list的最后一个元素，并且它还返回这个元素
L.pop(2)
删掉排名第3的元素
替换元素
L[2] = 'Paul'
第三个元素替换成Paul
tuple是另一种有序的列表，中文翻译为“ 元组 ”
tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改
t = ('Adam', 'Lisa', 'Bart')
创建tuple和创建list唯一不同之处是用( )替代了[ ]
可以使用 t[0]，t[-1]等索引方式访问元素
创建单元素tuple
因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义
t = ('Adam',)
t = (1,)
可变的tuple
t = ('a', 'b', ['A', 'B'])
t 有 3 个元素：'a'，'b'和一个list：['A', 'B']
如果要改变tuple，可用list嵌套进去。tuple无法改变，list可以改变
Python代码的缩进规则，具有相同缩进的代码被视为代码块
4个空格，不要使用Tab，更不要混合Tab和空格
if 语句后接表达式，然后用:表示代码块开始
条件判断是“非此即彼”的，要么符合条件1，要么符合条件2，
因此，完全可以用一个 if ... else ... 语句把它们统一起来
else 后面有个“:”
用 if ... 多个elif ... else ... 的结构，一次写完所有的规则：
elif 意思就是 else if。这样一来，我们就写出了结构非常清晰的一系列条件判断。
特别注意: 这一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print name
name 这个变量是在 for循环中定义的，依次取出list中的每一个元素，并把元素赋值给name，然后执行for循环体（就是缩进的代码块）
while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束
循环体内直接退出循环，可以使用 break 语句。
dict就是通过 key 来查找 value。
dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略
由于dict也是集合，len() 函数可以计算任意集合的大小
使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key
key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError
dict本身提供的一个 get 方法，在Key不存在的时候，返回None
>>> print d.get('Paul')
None
存储的key-value序对是没有顺序的
dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key
更新dict
dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。
要把新同学'Paul'的成绩 72 加进去，用赋值语句：
>>> d['Paul'] = 72
如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value.
连接符+和 ，的区别:
1.拼接字符串时逗号会显示一个空格，加号不会。
2.拼接数字时逗号会显示一个空格，加号会变成加法
3.加号无法拼接不同类型变量
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素
创建
>>> s = set(['A', 'B', 'C'])
查看 set 的内容：
>>> print s
set(['A', 'C', 'B'])
由于set存储的是无序集合，所以我们没法通过索引来访问
set中的某个元素实际上就是判断一个元素是否在set中
可以用 in 操作符判断
Bart是该班的同学吗？
>>> 'Bart' in s
True
set的内部结构和dict很像，唯一区别是不存储value
set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。最后，set存储的元素也是没有顺序的
set : 变量名 = set（[list]）
特点是里面元素不重复，无序
list : 变量名 = [a,b,b,x,....... ]
特点是元素可重复，有序
dict : 变量名 = {key：value，key：value，…… }
特点是键与值一一对应，且键名不能重复，无序
由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。
注意: for 循环在遍历set时，元素的顺序和list的顺序很可能是不同的，而且不同的机器上运行的结果也可能不同
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
print x[0] + ':', x[1]
print表输出
x表示上面set集合s中的一个tuple元素，例如：('Adam', 95)
tuple是一个元组，('Adam', 95)中有两个元素，所以在tuple中的第一个元素的索引是0，第二个是1。所以x[0]表示第一个元素，例如：Adam，x[1]表示第二个元素，例如：95
+的作用是：连接字符或字符串，‘：’就是一个字符
，起到隔开作用
set的添加和删除
s.add()
s.remove()需判断
for,if ,else句尾均要加冒号
注意缩格
集合是指包含一组元素的数据结构，我们已经介绍的包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict
str.upper()把字符串 str 任意字符变成大写
str.lower()把字符串str任意字符变成小写
str.capitalize()返回一个首字符大写其他字符小写的str的副本
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值
filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
sorted()函数可对list进行排序，接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0
返回函数，
def f():
# 定义函数g:
def g():
>>> x = f() # 调用f()
>>> print x() # x指向函数，因此可以调用
运行一个函数里面定义函数，返回的是里面包含的函数
返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
匿名函数 lambda x: x * x ,关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数,后边的x*x表示函数的表达式
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果
在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator），它接收一个函数作为参数，然后，返回一个新函数。
@log 相当于运行定义的log函数
*args: 任意数量参数，传递的是一个list
**kw: 任意数量key-value值，传递的是一个dict
PS：其实只是`*`和`**`起作用，`*args`和`**kw`是习惯名而已
包：文件夹，可以有多级，包的每一层下面必须有一个_init_.py文件
模块：xxx.py文件
函数
import os 调用os包
import os.path 调用os包的path模块
from os import path 从os包调用 path模块
from os.path import isdir, isfile 从os.path调用isdir和isfile函数
from math import log 从math模块调用log函数
from logging import log as logger 从logging模块调用log函数设置别名logger
from<模块名>import<函数名>as<别名>； ——用于函数名重复，但需要在同一个代码中调用时
from<模块名>import <函数名>； ——用于函数名有重复的时候
import<函数名>；——用于函数名唯一的时候
try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
先尝试从cStringIO导入，如果失败了（比如cStringIO没有被安装），再尝试从StringIO导入。
要“试用”某一新的特性，就可以通过导入__future__模块的某些功能来实现
导入__future__的division
from __future__ import division
要注意前后分别有两个下划线
面向对象最重要的概念就是类（Class）和实例（Instance），
必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同
定义类是通过class关键字：
class Student(object):
pass
class后面紧接着是类名，即Student，类名通常是大写开头的单词，
紧接着是(object），表示该类是从哪个类继承下来的，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
pass表示空语句，不执行任何操作。一般作占位语句，当你程序思路不清时，可写pass占位，后面再返回来补充；在此处的pass只是为了补充程序的完整型
创建实例属性
xiaoming = Person()
xiaoming.name = 'Xiao Ming'
xiaoming.gender = 'Male'
通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去
“__init__”前后分别有两个下划线
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
self，表示创建的实例本身
self.name name就是属性
__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：
>>> xiaoming = Student('Xiao Ming', 59)
print xiaoming.name
如果一个属性由双下划线开头(__)，该属性就无法被外部访问
如果一个属性以"__xxx__"的形式定义，可以被外部访问了，以"__xxx__"定义的属性在Python的类中被称为特殊属性
以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问
实例属性每个实例各自拥有，互相独立，而类属性有且只有一份
定义类属性可以直接在 class 中定义：
class Person(object):
address = 'Earth'
def __init__(self, name):
self.name = name
因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：
print Person.address
# => Earth
类属性也是可以动态添加和修改的
Person.address = 'China'
当实例属性和类属性重名时，实例属性优先级高
不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。
删除 p1 的 address 实例属性
del p1.address
私有属性无法从外部访问，但是，从类的内部是可以访问的。通过实例方法访问
get_name(self) 就是一个实例方法，它的第一个参数是self
和属性类似，方法也分实例方法和类方法
类方法需要添加 @classmethod
继承一个类：
总是从某个类继承，没有类可继承就继承object
继承关系 is
组合关系 has
super(Student, self).__init__(name, gender) 去初始化父类
self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）
判断类型：
函数isinstance()可以判断一个变量的类型
可以用在Python内置的数据类型如str、list、dict，也可以用在我们自定义的类
>>> isinstance(s, Person)
True # s是Person类型
>>> isinstance(s, Student)
True # s是Student类型
在一条继承链上，一个实例可以看成它本身的类型，也可以看成它父类的类型
一个父类的实例不能是子类类型，因为子类比父类多了一些属性和方法。
判断 object类首字母不是大写
多态：
whoAmI() 方法
动态语言和静态语言（例如Java）最大的差别之一。动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。
%s 打印字符串
print ("His name is %s"%("Aviad"))
效果：His name is Aviad
多重继承：
除了从一个父类继承外，Python允许从多个父类继承，称为多重继承
经典类，新式类举例：http://blog.sina.com.cn/s/blog_90bc5fc60101eojt.html
经典类的搜索方式是按照“从左至右，深度优先”的方式去查找属性。d先查找自身是否有foo方法，没有则查找最近的父类C1里是否有该方法，如果没有则继续向上查找，直到在P1中找到该方法，查找结束。
新式类的搜索方式是采用“广度优先”的方式去查找属性
获取对象信息
type() 函数获取变量的类型
dir() 函数获取变量的所有属性
获取，需要用 getattr() 和 设置对象的属性，用setattr( )函数
特殊方法：
类里面并没有定义特殊方法，因为继承，object类都有这些方法，所有的类都继承于object，所以所有类都有这些特殊方法
特殊方法__str__() ，将实例转化为字符串，用于print的__str__方法
__str__()用于显示给用户，而__repr__()用于显示给开发人员。
__cmp__
int、str 等内置数据类型排序时，Python的 sorted() 按照默认的比较函数 cmp 排序
对一组 Student 类的实例排序时，就必须提供我们自己的特殊方法 __cmp__()
sorted(L)在进行比较时是一种迭代的比较，第一个元素与第二个元素进行比较时若返回值为1，则第二个元素放在前面，反之第一个元素放在前面，以此递推。左为负，右为正，分数由高到低，应大的返回-1；字母按a-z排，越靠后越大，返回1
要获取有多少个元素，就得用 len() 函数。
__len__()方法，就可以用len()函数返回Students实例的“长度”：
在指定的序列中找到值返回 True
if 1 in lista:
判断两个标识符是不是引用自一个对象
if a is b:
sys.exit()的退出比较优雅，调用后会引发SystemExit异常，可以捕获此异常做清理工作。
os._exit()直接将python解释器退出，余下的语句不会执行
exit(0)：无错误退出
exit(1)：有错误退出
1.init 通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性，做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。
2.new 通常用于控制生成一个新实例的过程。它是类级别的方法。
new方法的调用是发生在init之前的
new方法主要是当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径。
urlparse模块主要是把url拆分为6部分，并返回元组。并且可以把拆分后的部分再组成一个url。主要有函数有urljoin、urlsplit、urlunsplit、urlparse、parse_qs等。
socket.gethostbyname 返回的是 主机名 的IPv4 的地址格式
socket.inet_aton(addr) // 依赖于inet_aton的C实现
转换IPV4地址字符串（192.168.10.8）成为32位打包的二进制格式（长度为4个字节的二进制字符串），它不支持IPV6。inet_pton()支持IPV4/IPV6地址格式。
soup=BeautifulSoup(response.body)
对网页进行析取时，并未规定解析器，此时使用的是python内部默认的解析器“html.parser”。
解析器是什么呢？ BeautifulSoup做的工作就是对html标签进行解释和分类，不同的解析器对相同html标签会做出不同解释。
strip() split()函数
format
In [1]: '{0},{1}'.format('kzc',18)
Out[1]: 'kzc,18'
In [2]: '{},{}'.format('kzc',18)
Out[2]: 'kzc,18'
In [3]: '{1},{0},{1}'.format('kzc',18)
Out[3]: '18,kzc,18'
通过{}和:来代替%
字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次
replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
str.replace(old, new, max)
使用方法：
#!/usr/bin/python
str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);
以上实例输出结果如下：
thwas was string example....wow!!! thwas was really string
thwas was string example....wow!!! thwas is really string
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写。
hasattr(object, name)
判断object对象中是否存在name属性，当然对于python的对象而言，属性包含变量和方法.有则返回True，没有则返回False
getattr(object, name, [default])
获取object对象的属性的值，如果存在则返回属性值，如果不存在分为两种情况，一种是没有default参数时，会直接报错；给定了default参数，若对象本身没有name属性，则会返回给定的default值；如果给定的属性name是对象的方法，则返回的是函数对象，需要调用函数对象来获得函数的返回值；调用的话就是函数对象后面加括号，如func之于func();
setattr(object, name, value)
给object对象的name属性赋值value，如果对象原本存在给定的属性name，则setattr会更改属性的值为给定的value；如果对象原本不存在属性name，setattr会在对象中创建属性，并赋值为给定的value；
def sale_car(price, color='red', brand='carmy', is_second_hand=True):
设置为默认参数，那么该参数在函数调用过程中可以不需要明确给出,当然也可以函数调用过程中传入特定的参数用来修改默认参数。
默认参数的地方用 = 号给定即可, 但是要注意所有的默认参数都不能出现在非默认参数的前面
self代表类的实例，而非类。
实例来说明
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
执行结果如下
<__main__.Test object at 0x000000000284E080>
<class '__main__.Test'>
从上面的例子中可以很明显的看出，self代表的是类的实例。而self.class则指向类。
class Foo(object):
pass
>>> print Foo # 返回的是类，不是类的实例
<class '__main__'.Foo>
>>> print Foo() # 返回的是实例
<__main__.Foo object at 0x89c6d4c>
startswith()
作用：判断字符串是否以指定字符或子字符串开头
语法：string.startswith(str, beg=0,end=len(string))
或string[beg:end].startswith(str)
参数说明：
string： 被检测的字符串
str： 指定的字符或者子字符串。（可以使用元组，会逐一匹配）
beg： 设置字符串检测的起始位置（可选）
end： 设置字符串检测的结束位置（可选）
if __name__ == '__main__'的意思是：
当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；
当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行
sys.argv[ ] 其实就是一个列表，里边的项为用户输入的参数
sys.argy[0] 相当于切片，列表里的第一个
with open(file, "r") as (f):
参数 "r"；该参数决定了打开文件的模式：只读，写入，追加等。这个参数是非强制的，默认文件访问模式为只读(r)。