old_dict = {"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },"#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
}
new_dict = {"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },"#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 },
}获取三个列表：1. 需要更新的列表 update_list2. 需要删除的列表 del_list3. 需要增加的列表 add_list代码实现：#!/usr/local/env python3'''Author:@南非波波Blog:http://www.cnblogs.com/songqingbo/E-mail:qingbo.song@gmail.com'''old_dict = {"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },"#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },}new_dict = {"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },"#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 },}#设置setold_set = set(old_dict.keys())new_set = set(new_dict.keys())#更新的setupdate_set = new_set.intersection(old_dict)delate_set = old_set.difference(update_set)add_set = new_set.difference(update_set)update_list = []del_list = []add_list = []# print(update_set)# print(delate_set)# print(add_set)for i in update_set:update_list.append({i:new_dict[i]})print('需要更新的列表:%s' % update_list)for i in delate_set:del_list.append({i:old_dict[i]})print("需要删除的列表:%s" % del_list)for i in add_set:add_list.append({i:new_dict[i]})print("需要增加的列表:%s" % add_list)

#!/usr/local/env python3
'''
Author:@南非波波
Blog:http://www.cnblogs.com/songqingbo/
E-mail:qingbo.song@gmail.com
'''
import collectionsobj = collections.Counter('sjndsjkdsdmslaladsldsldms')print("输出字符出现的次数字典:")
for k,v in obj.items():print("{%s:%s}" % (k,v))print("输出每一个字符:") #遍历获取原始字符元素
for k in obj.elements():print(k)print("输出前四个出现次数最多的字符:")
for k in obj.most_common(4):print(k)输出结果：输出字符出现的次数字典:{s:7}{l:4}{m:2}{d:6}{k:1}{n:1}{j:2}{a:2}输出每一个字符:sssssssllllmmddddddknjjaa输出前四个出现次数最多的字符:('s', 7)('d', 6)('l', 4)('m', 2)

    功能：对于不存在的元素，返回计数器为0import collectionsc = collections.Counter('adjsdkskdjksjaksklklakl')c.__missing__(5)返回结果：0

　　功能：获取出现次数的前几个字母排名import collectionsc = collections.Counter('adjsdkskdjksjaksklklakl')c.most_common(3)[('k', 7), ('s', 4), ('a', 3)]c.most_common(8)[('k', 7), ('s', 4), ('a', 3), ('j', 3), ('l', 3), ('d', 3)]

    功能：计数器中的所有元素，并且按照ascii码进行了排序返回一个迭代器。元素被重复了多少次，在该迭代器中就包含多少个该元素。所有元素按照字母序排序，个数小于1的元素不被包含。import collectionsc = collections.Counter('adjsdkskdjksjaksklklakl')sorted(c.elements())返回结果：['a', 'a', 'a', 'd', 'd', 'd', 'j', 'j', 'j', 'k', 'k', 'k', 'k', 'k', 'k', 'k','l', 'l', 'l', 's', 's', 's', 's']

    功能：默认将计数器中所有的字符认为一个键，然后统计键出现的次数，即键值。如果键不存在则返回0.import collectionsc = collections.Counter('adjsdkskdjksjaksklklakl')>>> c['a']3>>> c['b']0>>> c['l']3

    功能：都是更新计数器，update是增加，subtract是减少import collections>>> c = collections.Counter('which')>>> c['h']  #这里的h出现2次2>>> c.update('with')>>> cCounter({'h': 3, 'i': 2, 'w': 2, 't': 1, 'c': 1})>>> c['h'] #这里则完成了update操作，h出现了3次3>>> c.subtract('with') >>> cCounter({'h': 2, 'c': 1, 'i': 1, 'w': 1, 't': 0})>>> c['h'] #这里完成subtract操作之后，h出现的次数又恢复到2次2

    功能：删除键import collections>>> c = collections.Counter('which')>>> c['h']  #这里的h出现2次2>>> del c['h']>>> cCounter({'c': 1, 'i': 1, 'w': 1, 't': 0})>>> c['h']  #del操作删除了键'h'0

    功能：浅拷贝import collections>>> c = collections.Counter('which')>>> d = c.copy()>>> dCounter({'h': 2, 'c': 1, 'i': 1, 'w': 1})>>> id(c)7150792>>> id(d)6511976

　　有序字典继承字典的一切属性，只是在顺序上是有序的。d = collections.OrderedDict({'name':'swht','age':18})print(d)返回结果：OrderedDict([('name', 'swht'), ('age', 18)])print(type(d))返回结果：<class 'collections.OrderedDict'>

    功能：将指定的键值对从开头移动到末尾。d = collections.OrderedDict({'name':'swht','age':18,'address':'shandong',})d.move_to_end('name')print(d)返回结果：OrderedDict([('age', 18), ('address', 'shandong'), ('name', 'swht')])

    功能：移除字典键值，并返回删除键值的valuesd = collections.OrderedDict({'name':'swht','age':18,'address':'shandong',})d.pop('address')print(d)返回结果：OrderedDict([('age', 18), ('name', 'swht')])

    功能：清空有序字典的值d = collections.OrderedDict({'name':'swht','age':18,'address':'shandong',})d.clear()print(d)返回结果：OrderedDict()

    功能：继承字典的属性，获取字典的所有键和所有值d = collections.OrderedDict({'name':'swht','age':18,'address':'shandong',})l1 = d.keys()l2 = d.values()l3 = d.items()print(l1,l2，l3)返回结果：odict_keys(['address', 'age', 'name']) odict_values(['shandong', 18, 'swht']) odict_items([('age', 18), ('name', 'swht'), ('address', 'shandong')])

#!/usr/local/env python3
'''
Author:@南非波波
Blog:http://www.cnblogs.com/songqingbo/
E-mail:qingbo.song@gmail.com
'''
import collections
MytupleClass = collections.namedtuple("MytupleClass",['x','y','z'])
obj = MytupleClass(11,22,33)
print(obj.x,obj.y,obj.z)
返回结果：11 22 33
总结：相当于在元组的基础上增加一个key，使其成为一个类字典的样子

下面两种方法都可以创建双向列表，虽然在最初的引用的类不同，但最后创建的类型 都是collections.deque
#创建双向队列
import collections
d = collections.deque()
返回结果：<class 'collections.deque'>#but这样创建双向队列呢
import queue
p = queue.deque()
print(type(p))
#<class 'collections.deque'>

#创建单向队列
import queue
q = queue.Queue()
print(type(q))
#<class 'queue.Queue'>

#对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址import copya1 = 22255a2 = 22255print(id(a1),id(a2)) #3428240 3428240#对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。import copy#字典n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}##赋值n2 = n1print(n1,n2) #{'k1': 'wu', 'k2': 123, 'k3': ['alex', 456]} {'k1': 'wu', 'k2': 123, 'k3': ['alex', 456]}print(id(n1),id(n2))  #6674440 6674440 #内存地址一样##浅拷贝n3 = copy.copy(n1)print(n1,n3) #{'k1': 'wu', 'k2': 123, 'k3': ['alex', 456]} {'k1': 'wu', 'k2': 123, 'k3': ['alex', 456]}print(id(n1),id(n3)) #6936584 12067848  #浅拷贝第一级，内存地址相同print(id(n1['k3']),id(n3['k3'])) #18741768 18741768##深拷贝n4 = copy.deepcopy(n1)print(n1,n4) #{'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} {'k3': ['alex', 456], 'k1': 'wu', 'k2': 123}print(id(n1),id(n4)) #6805512 11736904print(id(n1['k3']),id(n4['k3'])) #7601032 7599496 #深拷贝第二级，内存地址也不相同#列表n1 = [1,2,3,4,5,[6,7],]##赋值n2 = n1print(n1,n2) #[1, 2, 3, 4, 5, [6, 7]] [1, 2, 3, 4, 5, [6, 7]]print(id(n1),id(n2)) #18609928 18609928print(id(n1[5]),id(n2[5])) #18609544 18609544##浅拷贝n3 = copy.copy(n1)print(n1,n3) #[1, 2, 3, 4, 5, [6, 7]] [1, 2, 3, 4, 5, [6, 7]]print(id(n1),id(n3)) #18609928 18232904print(id(n1[5]),id(n3[5])) #18609544 18609544##深拷贝n4 = copy.deepcopy(n1)print(n1,n4) #[1, 2, 3, 4, 5, [6, 7]] [1, 2, 3, 4, 5, [6, 7]]print(id(n1),id(n4)) #18609928 18611848print(id(n1[5]),id(n4[5])) #18609544 18611912#元组一个小插曲：import copyn1 = (1,2,3,4,5,(6,7,),)#赋值n2 = n1print('n1:',n1,'n2:',n2) #n1: (1, 2, 3, 4, 5, (6, 7)) n2: (1, 2, 3, 4, 5, (6, 7))print(id(n1),id(n2)) #10416584 10416584print(id(n1[5]),id(n2[5])) #18415304 18415304print(type(n1),type(2)) #<class 'tuple'> <class 'int'>#浅拷贝n3 = copy.copy(n1)print('n1:',n1,'n3:',n3) #n1: (1, 2, 3, 4, 5, (6, 7)) n2: (1, 2, 3, 4, 5, (6, 7))print(id(n1),id(n3)) #10416584 10416584print(id(n1[5]),id(n3[5])) #18415304 18415304print(type(n1),type(3)) #<class 'tuple'> <class 'int'>#深拷贝n4 = copy.deepcopy(n1)print('n1:',n1,'n4:',n4) #n1: (1, 2, 3, 4, 5, (6, 7)) n2: (1, 2, 3, 4, 5, (6, 7))print(id(n1),id(n4)) #10416584 10416584print(id(n1[5]),id(n4[5])) #18415304 18415304print(type(n1),type(5)) #<class 'tuple'> <class 'int'>

        import copyn1 = (1,2,3,4,5,[6,7,],)#赋值n2 = n1print('n1:',n1,'n2:',n2) #(1, 2, 3, 4, 5, [6, 7]) n2: (1, 2, 3, 4, 5, [6, 7])print(id(n1),id(n2)) #11465160 11465160print(id(n1[5]),id(n2[5])) #18480456 18480456print(type(n1),type(2)) #<class 'tuple'> <class 'int'>#浅拷贝n3 = copy.copy(n1)print('n1:',n1,'n3:',n3) #n1: (1, 2, 3, 4, 5, [6, 7]) n3: (1, 2, 3, 4, 5, [6, 7])print(id(n1),id(n3)) #11465160 11465160print(id(n1[5]),id(n3[5])) #18480456 18480456print(type(n1),type(3)) #<class 'tuple'> <class 'int'>#深拷贝n4 = copy.deepcopy(n1)print('n1:',n1,'n4:',n4) #n1: (1, 2, 3, 4, 5, [6, 7]) n4: (1, 2, 3, 4, 5, [6, 7])print(id(n1),id(n4)) #11465160 18109736print(id(n1[5]),id(n4[5])) #18480456 18478920print(type(n1),type(5)) #<class 'tuple'> <class 'int'>    

    import copydic = {"cpu":[80,],"mem":[80,],"disk":[80,],}print("old:",dic)new_dic1 = copy.copy(dic)new_dic1["cpu"][0] = 50print("old:",dic)print("浅拷贝:",new_dic1)#返回结果：#old: {'disk': [80], 'cpu': [80], 'mem': [80]}#浅拷贝: {'disk': [80], 'cpu': [50], 'mem': [80]}new_dic2 = copy.deepcopy(dic)new_dic2["cpu"][0] = 60print("old:",dic)print("深拷贝:",new_dic2)#返回结果# old: {'mem': [80], 'cpu': [50], 'disk': [80]}# 深拷贝: {'mem': [80], 'cpu': [60], 'disk': [80]}

    #!/usr/local/env python3'''Author:@南非波波Blog:http://www.cnblogs.com/songqingbo/E-mail:qingbo.song@gmail.com'''#定义函数，作用打印一个值def num_print():n = 456n += 1print(n)

形参：函数中一个变量，在函数执行前无意义，在函数调用时必须指定实际参数。
实参：实际参数用户传递给所调用的函数的一个变量，其值赋值到函数中的形式参数，然后在函数中    作为变量参与函数执行
默认参数：必须放在最后def show(a1,a2,a3 = 5):print(a1,a2,a3)show("wu","ha")#返回结果：wu ha 5指定参数：def show(a1,a2):print(a1,a2)show(a2=52,a1=8)#返回结果：8 52动态参数：*arg --序列：自动转换成一个元组def show(*arg):print(arg,type(arg))show(23,45,67)#返回结果：(23, 45, 67) <class 'tuple'>#orl = [23,45,67]show(*l)#返回结果：(23, 45, 67) <class 'tuple'>**arg --字典：自动转换成一个字典#默认字典处理def show(**arg):print(arg,type(arg))show(name1='swht',name2='shen')#返回结果：{'name1': 'swht', 'name2': 'shen'} <class 'dict'>#ord = {"name1"="swht","name2"="shen"}show(**d)#返回结果：{'name1': 'swht', 'name2': 'shen'} <class 'dict'>*arg，**kwarges --序列和字典def show(*args,**kwargs):print(args,type(args),'\n',kwargs,type(kwargs))show(23,45,67,82,name1='swht',name2='shen')#返回结果：(23, 45, 67, 82) <class 'tuple'> {'name2': 'shen', 'name1': 'swht'} <class 'dict'>     注意：使用*arg，**kwarges组合参数，必须是*arg在前，**kwarges在后，否则系统报错；另外实参在输入的时候也应该是按照上述顺序。

    def show(*args,**kwargs):print(args,type(args),'\n',kwargs,type(kwargs))l = [23,45,67,82]d = {'name1':'swht','name2':'shen'}show(l,d)#返回结果：([23, 45, 67, 82], {'name1': 'swht', 'name2': 'shen'}) <class 'tuple'> {} <class 'dict'>def show(*args,**kwargs):print(args,type(args),'\n',kwargs,type(kwargs))l = [23,45,67,82]d = {'name1':'swht','name2':'shen'}show(*l,**d)#返回结果：(23, 45, 67, 82) <class 'tuple'> {'name2': 'shen', 'name1': 'swht'} <class 'dict'>总结：函数可以传递元组、列表、字典等类型的值，由于带'*'、'**'的参数允许传入多个参数，所以在调用函数的时候默认将传入的参数识别到第一个*args。为了指定将参数传给某个args，这里需要对实参进行加'*'进行标识。#listshow = "Welcome to {0},there have too many {1}!"# reault = show.format("China","Foods")l = ["China","Foods"]reault = show.format(*l)print(reault)#返回结果：Welcome to China,there have too many Foods!#dictshow = "{name} is a {acter}!"# reault = show.format(name='swht',acter='teacher')d = {'name':'swht','acter':'teacher'}reault = show.format(**d)print(reault)#返回结果：swht is a teacher!

    功能：简单函数的表示方式func = lambda a:a+1函数名  关键字 形参：函数体创建形式参数a，函数内容为a+1,并将结果return
测试代码：f = lambda x:x + 1ret = f(4)print(ret)

    功能：取绝对值>>> abs(5)5>>> abs(-85)85

    功能：iterable所有的元素都为真,返回True，否则返回False备注：为False的元素：0、''、False或者空，其他的为True参数：iterable为可迭代对象all的功能可以使用下面的函数进行理解：def all(iterable):for element in iterable:if not element:return Falsereturn True测试代码：all('test,hh')返回值为：True>>> all(['a', 'b', 'c', 'd'])  #列表list，元素都不为空或0True>>> all(['a', 'b', '', 'd'])  #列表list，存在一个为空的元素False>>> all([0, 1，2, 3])  #列表list，存在一个为0的元素False             >>> all(('a', 'b', 'c', 'd'))  #元组tuple，元素都不为空或0True>>> all(('a', 'b', '', 'd'))  #元组tuple，存在一个为空的元素False>>> all((0, 1，2, 3))  #元组tuple，存在一个为0的元素False>>> all([]) # 空列表True>>> all(()) # 空元组True    

　　功能：iterable中元素只要有一个元素为真，则返回True,否则返回False(即iterable中所有的元素为假才会返回False)参数：iterable为可迭代对象any的功能可以使用下面的函数进行理解：def any(iterable):for element in iterable:if  element:return Falsereturn True测试代码：>>> any([0,1,2,3]) #列表中仅有一个元素0为假，返回TrueTrue>>> any([' ', '  ', '', 0])True>>> any([0]) #列表中元素只有一个元素0，返回FalseFalse>>> any([0,''])False>>> any([0,'',4])True    >>> any(('a', 'b', 'c', 'd'))  #元组tuple，元素都不为空或0True>>> any(('a', 'b', '', 'd'))  #元组tuple，存在一个为空的元素True>>> any((0, '', False))  #元组tuple，元素全为0,'',falseFalse>>> any([]) # 空列表False>>> any(()) # 空元组False

    功能：对可迭代函数'iterable'中的每一个元素应用‘function’方法，将结果作为list返回参考链接：http://segmentfault.com/a/1190000000322433测试代码：def add_100(num):return num + 100li1 = [25,26,27]ret = list(map(add_100,li1))print(ret)返回结果：[125, 126, 127]

    两个版本的对比，真是让人感到诧异，python3上执行map明明已经获取了值，但非得加个list进行展示，超乎寻常。def abc(a,b,c):return a*1000 + b*100 + c*10list1 = [11,22,33]list2 = [44,55,66]list3 = [77,88,99]ret = list(map(abc,list1,list2,list3))print(ret) #返回结果 [16170, 28380, 40590]

    功能：该函数与python2中的repr()函数一样，返回一个可打印的对象字符串。当遇到非ascii码时，就会输出\x，\u或\U等字符来表示。例如：ascii(4) = int.__repr__(4) = repr(4)等号两边的方式是对等的。测试代码：>>> ascii(54)'54'>>> ascii('o')"'o'">>> type(ascii(54))<class 'str'>   >>> print(ascii(10), ascii(9000000), ascii('b\31'), ascii('0x\1000'))10 9000000 'b\x19' '0x@0'

    功能：将整数转换为二进制字符串>>> bin(56)'0b111000'>>> bin(100)'0b1100100'注意：如果bin()函数的实际参数不是一个整数,则该该实参(由类创建的对象)返回值必须是整数型如：>>> class myType:...     def __index__(self):...             return 56...>>> myvar = myType()>>> bin(myvar)'0b111000'

    功能：获取对象的bool值bool(0) #Falsebool(5) #Truebool('') #False#为假的元素：0 none 空列表 空字典 空元组 空字符串

    功能：转成字符字典。Bytearray类型是一个可变的序列，并且序列中的元素的取值范围为 [0 ,255]。>>> a = bytearray([5,8])>>> a[0]5>>> a[1]8>>> abytearray(b'\x05\x08')

    功能：返回一个新的数组对象，这个数组不能对数组元素进行修改，每个元素的取值范围为[0 ,255]测试代码：bytes(iterable_of_ints) >>> b = bytes((5,8,6,8))>>> print(b)b'\x05\x08\x06\x08'bytes(string, encoding[, errors])   >>> bytes('sdjsd',encoding='utf-8')b'sdjsd'bytes(bytes_or_buffer)  ？bytes(int) >>> bytes(5)b'\x00\x00\x00\x00\x00'bytes()  >>> bytes()b''

    功能：判断函数或者对象是否可执行>>> callable(5)False>>> callable(0)False>>> callable('')False>>> callable(int())False>>> callable(lambda x:x+1)True

    功能：参数为一个整型数字，返回值对应ASCII码的字符>>> chr(5)'\x05'>>> chr(115)'s'>>> chr(56)'8'

    功能：返回一个字符的ASCII码值>>> ord('s')115>>> ord('5')53

    功能：classmethod是用来指定一个类的方法为类方法，没有此参数指定的类的方法为实例方法>>> class C: #定义一个类...     @classmethod  #声明为类方法，不经过实例化就可以直接调用...     def f(self): #定义一个函数（类的方法）...             print "This is a class method"...>>> C.f()  #通过类调用函数This is a class method>>> c = C()>>> c.f()This is a class method>>> class D:...     def f(self):...             print " This is not a class method "...>>> D.f()  #没有经过@classmethod 声明的类方法，必须经过实例化才能被调用Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: unbound method f() must be called with D instance as first argument (got nothing instead)>>> d = D()>>> d.f()This is not a class method

    功能：类的静态方法，只能在类内部使用。经过静态类方法声明的类，在调用的时候不需要进行实例化总结：对比classmethod()和staticmethod()静态方法：@staticmethod()class Foo(object):str = "I'm a static method."def bar():print(Foo.str)bar = staticmethod(bar)Foo.bar()返回结果：I'm a static method. 类方法：@classmethod()class Foo(object):str = "I'm a static method."def bar(cls):print(cls.str)bar = classmethod(bar)Foo.bar()返回结果：I'm a static method.
较简单的操作代码：静态方法：@staticmethod()class Foo:str = "I'm a static method."@staticmethoddef bar():print(Foo.str)Foo.bar() 返回结果：I'm a static method. 类方法：@classmethod()class Foo:str = "I'm a static method."@classmethoddef bar(cls):print(cls.str )Foo.bar()返回结果：I'm a static method.

    功能：compile语句是从type类型中将str里面的语句创建成代码对象。compile语句的目的是提供一次性的字节码编译，就不用在以后的每次调用中重新进行编译了语法：compile( str, file, type )eveal_code = compile('1+2','','eval')>>>eveal_code返回结果：<code object <module> at 0x01555D40, file "", line 1>>>>eval(eveal_code)返回结果：3single_code = compile( 'print("apicloud.com")', '', 'single' )>>> single_code返回结果：<code object <module> at 0x01555B10, file "", line 1>>>> exec(single_code)返回结果：apicloud.com

    功能：创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。参数real: int, long, float或字符串；参数imag: int, long, float>>>complex()0j#数字>>> complex(1,2)(1+2j)#当做字符串处理>>> complex('1')(1+0j)#注意：这个地方在“+”号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错>>> complex('1+2j')(1+2j)

    参考链接：http://www.cnblogs.com/zhangjing0502/archive/2012/05/16/2503702.html功能：删除object对象名为name的属性语法：delattr(object,name) 参数object：对象。参数name：属性名称字符串。>>> class Person:...     def __init__(self, name, age):...             self.name = name...             self.age = age...>>> tom = Person("Tom", 35)>>> dir(tom)['__doc__', '__init__', '__module__', 'age', 'name']>>> delattr(tom, "age")>>> dir(tom)['__doc__', '__init__', '__module__', 'name']

    功能：用于返回一个对象属性，或者方法class A:   def __init__(self):   self.name = 'zhangjing'  #self.age='24'def method(self):   print("method print")  Instance = A()   print(getattr(Instance , 'name', 'not find')) #如果Instance 对象中有属性name则打印self.name的值，否则打印'not find'print(getattr(Instance , 'age', 'not find'))  #如果Instance 对象中有属性age则打印self.age的值，否则打印'not find'print(getattr(a, 'method', 'default'))  #如果有方法method，否则打印其地址，否则打印default   print(getattr(a, 'method', 'default')()) #如果有方法method，运行函数并打印None否则打印defaultli=["swht","shen"]getattr(li,"pop")返回结果：<built-in method pop of list object at 0x01AFDA80>

    功能：参数是一个对象,一个字符串和一个任意值。字符串可能会列出一个现有的属性或一个新的属性。这个函数将值赋给属性的。该对象允许它提供。语法：setattr(object, name, value) setattr(x,“foobar”,123)相当于x.foobar = 123

    功能：用于确定一个对象是否具有某个属性语法：hasattr(object, name) -> bool判断object中是否有name属性，返回一个布尔值li=["swht","shen"]hasattr(li,'append')返回结果：True

    功能：字典定义函数，可以创建一个字典，也可以将其他类型（列表、元组、字符串）转换成字典类型定义：dict1 = dict(one = 1, two = 2, a = 3)prin（dict1){'one': 1, 'a': 3, 'two': 2}类型转换：list1 = ['name','age',]list2 = ['swht',18]dict(zip(list1,list2))返回结果：{'name': 'swht', 'age': 18}new_list= [['key1','value1'],['key2','value2'],['key3','value3']]dict(new_list)返回结果：{'key3': 'value3', 'key1': 'value1', 'key2': 'value2'}

    功能：divmod(a,b)方法返回的是a//b（除法取整）以及a对b的余数>>> divmod(2,5)(0, 2)>>> divmod(12,5)(2, 2)

    功能：获取字典的索引值并指定开始值li = ['swht','shen','test']for i,k in enumerate(li,3): #遍历列表，索引值从3开始print(i,k)#返回结果3 swht4 shen5 test

    参考链接：http://www.cnblogs.com/fangshenghui/p/3445469.html功能：filter(function, sequence)对于队列中的item依次被function处理def fun(item):if item != 4:return itemlist1 = [5,4,8]print(list(filter(fun,list1)))返回结果：[4, 8]总结：相当于一个过滤函数

    参考：http://blog.csdn.net/caimouse/article/details/42042051功能：本函数是返回一个冻结的集合l = [1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9]  print(len(l), l)  set = frozenset(l)  print(len(set), set) 返回结果：11 [1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9]9 frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9})总结：所谓冻结就是这个集合不能再添加或删除任何集合里的元素。因此与集合set的区别，就是set是可以添加或删除元素，而frozenset不行。frozenset的主要作用就是速度快，它是使用hash算法实现。参数iterable是表示可迭代的对象，比如列表、字典、元组等等

    功能：基于字典的访问局部和全局变量的方式locals 是只读的，globals 不是关于名字空间的相关说明请移步参考：http://blog.csdn.net/scelong/article/details/6977867

    功能：输出对象的hash值>>> hash(8)8>>> hash('sd')-584109415>>> hash('99')-1356598271>>> hash('asds')-1179125483

    int(x [,base ])         将x转换为一个整数    long(x [,base ])        将x转换为一个长整数    float(x )               将x转换到一个浮点数    complex(real [,imag ])  创建一个复数    str(x )                 将对象 x 转换为字符串    repr(x )                将对象 x 转换为表达式字符串    eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象    tuple(s )               将序列 s 转换为一个元组    list(s )                将序列 s 转换为一个列表    chr(x )                 将一个整数转换为一个字符    unichr(x )              将一个整数转换为Unicode字符    ord(x )                 将一个字符转换为它的整数值    hex(x )                 将一个整数转换为一个十六进制字符串    oct(x )                 将一个整数转换为一个八进制字符串

    功能：获取对象的内存地址id(object)

    功能:获取用户的输入信息input("请输入你的名字:")>>>请输入你的名字:swhtswht

    功能：判断对象类型isinstance(5,int)返回结果:True

    功能：本函数用来判断类参数class是否是类型参数classinfo的子类class Line:  pass  class RedLine(Line):  pass  class Rect:  pass  print(issubclass(RedLine, Line))  #返回True  Redline是Line的子类print(issubclass(Rect, Line))  #返回False  

    功能：创建一个迭代器for i in iter((1,2,4,5,6,7,)):print(i)返回结果：1 2 4 5 6 7 #循环遍历元组

    功能：获取字符串的长度len(str)

    功能：返回所有整数中最大的一个数max(5,6,8,7) 返回结果：8

    功能：本函数是返回对象obj的内存查看对象>>> v = memoryview(b'abc123')>>> print(v[1])98>>> print(v[0])97>>> print(v[2])import struct  buf = struct.pack("i"*12, *list(range(12)))  x = memoryview(buf)  y = x.cast('i', shape=[2,2,3])  print(y.tolist()) 返回结果：[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]总结：所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。参考链接：http://blog.csdn.net/caimouse/article/details/43083627

    功能：排序sorted([5, 2, 3, 1, 4])[1, 2, 3, 4, 5]

    功能：返回整数数字的和sum([1,5,8]) #参数是一个list返回结果：14

    功能：获取对象的类型type(object)

    功能：本函数是实现返回对象object的属性和属性值的字典对象>>> class Foo:...     a = 1...>>> print(vars(Foo)){'a': 1, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__module__': '__main__'}总结：如果默认不输入参数，就打印当前调用位置的属性和属性值，相当于locals()的功能。如果有参数输入，就只打印这个参数相应的属性和属性值。参考：http://blog.csdn.net/caimouse/article/details/46489079

    功能：zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表>>> x = [1,2,3,]>>> y = [4,5,6,]>>> z = [7,8,9,]>>> xyz = zip(x,y,z)>>> print(xyz)<zip object at 0x00FBD968>>>> print(list(xyz))[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

    功能:产生随机数import randomrandom.randint(1,99) #从1-99中产生随机数

    功能：查看模块所在的位置__import__('random') #参数为一个字符串<module 'random' from 'D:\\Program Files\\Python\\Python35\\python35.zip\\random.pyc'>

功能：指定当前指针位置files = open('test.txt','r',encoding='utf-8')
files.seek(5)
print(files.read()) #读取指为直接切割针5后面的所有字符
files.truncate() #获取指针5之前的所有字符然后写到原来的文件（或者可以理解）
files.close()

读二进制文件：input = open('data','rb')读取所有内容：f = open('test.txt','r')try:all_txt_view = f.read()finally:f.close()读取固定字节：f = open('test.txt','rb')try:while True:chunk = f.read(100)if not chunk:breakpassfinally:f.close()读每行：list_of_all_the_lines = f.readlines()如果文件是文本文件，还可以直接遍历文件对象获取每行：for line in f:print(line)写文件写文本文件output = open('data','w')写入多行：f.writeline(list_of_text_string)

作业连接：http://www.cnblogs.com/wupeiqi/articles/4950799.html
1. 用户输入一个字符串，将其转换成字典 使用json
2. 增加一条记录
3. （可选）删除一条
4. （可选）线上文件修改global       log 127.0.0.1 local2daemonmaxconn 256log 127.0.0.1 local2 info
defaultslog globalmode httptimeout connect 5000mstimeout client 50000mstimeout server 50000msoption  dontlognulllisten stats :8888stats enablestats uri       /adminstats auth      admin:1234frontend oldboy.orgbind 0.0.0.0:80option httplogoption httpcloseoption  forwardforlog globalacl www hdr_reg(host) -i www.oldboy.orguse_backend www.oldboy.org if wwwbackend test.oldboy.orgserver 100.1.7.9 100.1.7.9 weight 20 maxconn 3000#server 100.1.7.9 100.1.7.999 weight 20 maxconn 3000backend buy.oldboy.orgserver 100.1.7.90 100.1.7.90 weight 20 maxconn 3000字典：
{"backend": "test.oldboy.org","record":{"server": "100.1.7.999","weight": 20,"maxconn": 30}
}