入门-常用内部功能
一、每一个整数都具备如下功能:
1)def __divmod__(self, y): """ 相除,得到商和余数组成的元组 """ """ x.__divmod__(y) <==> divmod(x, y) """ pass
#求商和余数 e=115 f=10 g=e.__divmod__(f) print(g) print(divmod(e,f))
2)def __abs__(self):
""" 返回绝对值 """ """ x.__abs__() <==> abs(x) """ pass
#取绝对值 a=-18 b=19 print(abs(a)) c=a.__abs__() print(c)
3)def __add__(self, y):
""" 相加 """
""" x.__add__(y) <==> x+y """
pass
#相加 d=a.__add__(b) print(d) print(a+b)
二、每个字符串都具备如下功能:
1)def __contains__(self, y):
"""x是否包含y"""
""" x.__contains__(y) <==> y in x """
pass
g='hellowworld' #g.__contains__() 字符串g是否包含子字符串 print(g.__contains__('hellow'))
2)def capitalize(self):
""" 首字母变大写 """ """S.capitalize() -> string"""
g='hellowworld' print(g.capitalize())
3)def center(self, width, fillchar=None):
""" 内容居中,width:总长度;fillchar:空白处填充内容,默认无 """ """S.center(width[, fillchar]) -> string"""
g='hellowworld' print(g.center(30,"*"))
4) def count(self, sub, start=None, end=None):
""" 子序列个数 """ """ S.count(sub[, start[, end]]) -> int"""
g='hellowworld'
print(g.count('e',0,5))
5) def endswith(self, suffix, start=None, end=None):
""" 是否以 xxx 结束,从哪到哪""" """ S.endswith(suffix[, start[, end]]) -> bool"""
g='hellowworld' print(g.endswith('o',1,5))
6)def find(self, sub, start=None, end=None):
""" 寻找子序列位置,如果没找到,返回 -1 """ """S.find(sub [,start [,end]]) -> int"""
g='hellowworld'
print(g.find('d',5,15))
7)def format(*args, **kwargs):
""" 字符串格式化,动态参数,将函数式编程时细说 """ """S.format(*args, **kwargs) -> string"""
i="hellow {0} ! {1} {2}" print(i.format('world','Welcome','lucy'))#连接的作用等同于%s + j="hellow {someone} ! {do} {who}" print(j.format(someone='world',do="Welcome",who='lucy'))#另一种连接方式,一种字符串替换
8)def join(self, iterable):
""" 连接 """ """S.join(iterable) -> string"""
k=['h','e','l','l','o','w'] print('~'.join(k))#把一个序列连接起来,可指定用什么分隔符连接
9)def partition(self, sep):
""" 分割,前,中,后三部分 """ """S.partition(sep) -> (head, sep, tail)"""
l='iamlucky' print(l.partition('am'))#输出结果:('i', 'am', 'lucky')
10)def replace(self, old, new, count=None):
""" 替换 """ """S.replace(old, new[, count]) -> string"""
g='hellowworld' print(g.replace('l','g',1))
11)def splitlines(self, keepends=False):
""" 根据换行分割 """ """S.splitlines(keepends=False) -> list of strings"""
m=''' a b c''' print(m.splitlines( ))
12)def split(self, sep=None, maxsplit=None):
""" 分割, maxsplit最多分割几次 """ """ S.split([sep [,maxsplit]]) -> list of strings
>>> u = "www.doiido.com.cn" #使用默认分隔符 >>> print u.split() ['www.doiido.com.cn'] #以"."为分隔符 >>> print u.split('.') ['www', 'doiido', 'com', 'cn'] #分割0次 >>> print u.split('.',0) ['www.doiido.com.cn'] #分割一次 >>> print u.split('.',1) ['www', 'doiido.com.cn'] #分割两次 >>> print u.split('.',2) ['www', 'doiido', 'com.cn'] #分割两次,并取序列为1的项 >>> print u.split('.',2)[1] doiido #分割最多次(实际与不加num参数相同) >>> print u.split('.',-1) ['www', 'doiido', 'com', 'cn'] #分割两次,并把分割后的三个部分保存到三个文件 >>> u1,u2,u3 = u.split('.',2) >>> print u1 www >>> print u2 doiido >>> print u3 com.cn
str="hello boy<[www.doiido.com]>byebye" print(str.split("[")[1]) print(str.split("[")[1].split("]")[0]) print(str.split("[")[1].split("]")[0].split('.'))
13)def strip(self, chars=None):
""" 用于移除字符串头尾指定的字符(默认为空格) """ """S.strip([chars]) -> string or unicode"""
hh="00000lucy00000" print(hh.strip('0'))
三、每个列表都具备如下功能:
1)append() 方法用于在列表末尾添加新的对象
list.append(obj)
aList = [123, 'xyz', 'zara', 'abc']
aList.append(2009)
print("Updated List : ", aList)
2)extend() 函数用于在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.extend(seq)#seq 元素列表或元组
aList = [123, 'xyz', 'zara', 'abc'] bList=[2009,"lol"] aList.extend(bList) print(aList)
3)insert() 函数用于将指定对象插入列表的指定位置
list.insert(index, obj)#index -- 对象 obj 需要插入的索引位置;obj -- 要插入列表中的对象
bList=[2009, 'lol', 2008, 'haha'] bList.insert(3,'xixi') print(bList)
4)pop() 函数用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.pop(obj=list[-1])#obj -- 可选参数,要移除列表元素的对象
bList=[2009, 'lol', 2008, 'xixi', 'haha'] print(bList.pop(1))#结果:lol;bList=[2009,2008, 'xixi', 'haha']
5)remove() 函数用于移除列表中某个值的第一个匹配项
list.remove(obj)
dlist=['a','a','h','h','haha'] dlist.remove('h') print(dlist) #结果:['a','a','h','haha']
6)reverse() 函数用于反向列表中元素
list.reverse()
dlist=['a', 'a', 'h', 'haha'] dlist.reverse() print(dlist)#结果:['haha', 'h', 'a', 'a']
7)sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数
list.sort([func])#func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序
dlist=['haha', 'h', 'a', 'a'] dlist.sort() print(dlist)#结果:['a', 'a', 'h', 'haha']
四、每个元组都具备如下功能:
1)Python 元组 tuple() 函数将列表转换为元组
cmp(tuple1, tuple2)
tuple(seq)#seq -- 要转换为元组的序列
aList =[123, 'xyz', 'zara', 'abc'] aTuple = tuple(aList) print(aTuple)#结果:(123, 'xyz', 'zara', 'abc')
五、每个字典都具备如下功能:
1)def get(self, k, d=None):
""" 根据key获取值,d是默认值 """ """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ pass
dic={'k1':'v1','k2':'v2'} print(dic.get('k1'))#结果:v1 print(dic.get('k2'))#结果:v2 print(dic.get('k3','v3'))#结果:v3
2)items keys values:
dic={'k1':'v1','k2':'v2'} print(dic.keys()) #结果:输出dic的所有键dict_keys(['k2', 'k1']) print(dic.values())#结果:输出dic的所有指定键的值dict_values(['v2', 'v1']) print(dic.items())#结果:输出dic的所有键值对dict_items([('k2', 'v2'), ('k1', 'v1')])
3)def pop(self, k, d=None): # real signature unknown; restored from __doc__
""" 获取并在字典中移除 """ """D.pop(k[,d]) -> v, remove specified key and return the corresponding value"""
dic={'k1':'v1','k2':'v2'} print(dic.pop('k1'))#v1 print(dic)#{'k2': 'v2'}
4)update() 函数把字典dict2的键/值对更新到dict里
dict.update(dict2)
dic1={'k1':'v1','k2':'v2'} dic2={'k3':'v3'} dic.update(dic2) print(dic)#{'k2': 'v2', 'k1': 'v1', 'k3': 'v3'}
练习题:
dic={} all_list=[11,22,33,44,55,66,77,88,99,90,100,101] for i in all_list: if i>60: if 'k1' in dic.keys(): dic['k1'].append(i) else: dic['k1']=[i,] else: if 'k2' in dic.keys(): dic['k2'].append(i) else: dic['k2']=[i,] print(dic)
六、set:
1)要创建一个set,需要提供一个list作为输入集合:
s=set([1,2,3,4,5,6,7])#创建set对象,无序,重复元素被过滤掉,无重复元素 print(s)
2)def add(self, *args, **kwargs): # real signature unknown
""" 添加 """
s=set([1,2,3,4,5,6,7])#创建set对象 print(s) s.add(8) print(s)#{1,2,3,4,5,6,7,8}
3)def difference(self, *args, **kwargs): # real signature unknown
"""Return the difference of two or more sets as a new set 前者-两者的交集"""
pass
s=set([1,2,3,4,5,6,7,8]) s1=set([2,3,5,8]) print(s.difference(s1))#结果为:{1,4,6,7},但s依然为{1,2,3,4,5,6,7,8}
4)def difference_update(self, *args, **kwargs): # real signature unknown
""" 删除当前set中的所有包含在 new set 里的元素 """ """ Remove all elements of another set from this set. """ pass
s=set([1,2,3,4,5,6,7,8]) s1=set([2,3,5,8]) s.difference_update(s1) print(s)#结果s为:{1,4,6,7},但print(s.difference_update(s1))输出结果为None
5)def symmetric_difference(self, *args, **kwargs):
""" 对称差集,创建新对象,两者的并集-两者的交集"""
s=set([1,3,5,7,9]) s1=set([2,4,6,7,9]) print(s.symmetric_difference(s1))
6)def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
"""对称差集,改变原来 """
s=set([1,3,5,7,9]) s1=set([2,4,6,7,9]) s.symmetric_difference_update(s1) print(s)
7)def intersection(self, *args, **kwargs):
""" 取交集,新创建一个set """
s=set([1,2,3,4,5,6,7,8]) s1=set([2,3,5,8]) ss=s.intersection(s1) print(ss)#结果为:{2,3,5,8}取交集,但s依然为{1,2,3,4,5,6,7,8}
8)def intersection_update(self, *args, **kwargs):
""" 取交集,修改原来set """
s=set([1,2,3,4,5,6,7,8]) s1=set([2,3,5,8])
print(s.intersection_update(s1))#结果为None
s.intersection_update(s1)
print(s)#结果s为交集:{2,3,5,8}
9)discard、pop、remove:
s=set([2,3,5,8]) s.discard(5)
print(s)
s.remove(2)
print(s)
print(s.pop())
练习:
#练习:利用set寻找差异 # 数据库中原有 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} } # cmdb 新汇报的数据 new_dict = { "#1":{'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80}, "#3":{'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80}, "#4":{'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80} } old_set=set(old_dict.keys()) new_set=set(new_dict.keys()) update_set=old_set.intersection(new_set) delete_set=old_set.symmetric_difference(update_set) add_set=new_set.symmetric_difference(update_set) print(update_set) print(delete_set) print(add_set)
七、collection系列:
1.计数器(counter):Counter是对字典类型的补充,用于追踪值的出现次数
import collections#导入类 obj=collections.Counter('adsgeewsssadsfwewewsadaadggggg') print(obj)#Counter({'s': 6, 'g': 6, 'a': 5, 'w': 4, 'd': 4, 'e': 4, 'f': 1})
def most_common(self, n=None): """ 返回一个TopN列表。如果n没有被指定,则返回所有元素。当多个元素计数值相同时,按照字母序排列。 """
import collections obj=collections.Counter('adsgeewsssadsfwewewsadaadggggg') print(obj) obj1=obj.most_common(3) print(obj1)#[('s', 6), ('g', 6), ('a', 5)]
def elements(self): """ 返回一个迭代器。元素被重复了多少次,在该迭代器中就包含多少个该元素。所有元素按照字母序排序,个数小于1的元素不被包含。"""
obj2=list(obj.elements()) print(obj2)
#['a', 'a', 'a', 'a', 'a', 'd', 'd', 'd', 'd', 'g', 'g', 'g', 'g', 'g', 'g', 'w', 'w', 'w', 'w', 'f', 'e', 'e', 'e', 'e', 's', 's', 's', 's', 's', 's']
for k,v in obj.items():#dict的items()、keys()、values()方法,counter同样适用 print(k,v) for k in obj.keys(): print(k) for v in obj.values(): print(v)
计数器的更新包括增加和减少两种。其中,增加使用update()方法:
import collections obj=collections.Counter('adsgeewsssadsfwewewsadaadggggg') print(obj)#Counter({'g': 6, 's': 6, 'a': 5, 'w': 4, 'd': 4, 'e': 4, 'f': 1})
obj.update('fjwfwoewowew')# 使用另一个iterable对象更新,iterable我先通俗理解为数组、字符串、列表
print(obj) #Counter({'w': 9, 'g': 6, 's': 6, 'e': 6, 'a': 5, 'd': 4, 'f': 3, 'o': 2, 'j': 1})
import collections obj=collections.Counter('adsgeewsssadsfwewewsadaadggggg') print(obj)#Counter({'g': 6, 's': 6, 'a': 5, 'w': 4, 'd': 4, 'e': 4, 'f': 1})
obj3=collections.Counter('fjwfwoewowew')
obj.update(obj3)#使用另一个Counter对象来更新键值
print(obj)#Counter({'w': 9, 'e': 6, 's': 6, 'g': 6, 'a': 5, 'd': 4, 'f': 3, 'o': 2, 'j': 1})
减少则使用subtract()方法:
obj.subtract('fjwfwoewowew')# 使用另一个iterable对象更新 print(obj)
obj.subtract(obj3)#使用另一个Counter对象更新 print(obj)
2.有序字典(orderedDict )
orderdDict是对字典类型的补充,他记住了字典元素添加的顺序
import collections dic=collections.OrderedDict() dic['k1']='v1' dic['k2']='v2' dic['k3']='k3' print(dic)
move_to_end:把指定key移到末尾
import collections dic=collections.OrderedDict() dic['k1']='v1' dic['k2']='v2' dic['k3']='k3' print(dic) dic.move_to_end('k2') print(dic)
3.defaultdict是对字典的类型的补充,他默认给字典的值设置了一个类型
import collections dic=collections.defaultdict(list)#append()list的方法,默认为list类型 all_list=[11,22,33,44,55,66,77,88,99,90,100,101] for i in all_list: if i>60: dic['k1'].append(i) else: dic['k2'].append(i) print(dic)
4.可命名元组(namedtuple)
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
import collections mytuple=collections.namedtuple('mytuple',['lucy','lily','jake','jason'])#创建类mytuple,为元组里的元素名字获取元素 obj=mytuple('x','y','xx','yy')#创建元组对象 print(obj.jake)#不用通过索引即可获得元组元素 print(obj.lily) print(obj.lucy) print(obj.jason)
5.队列:
import collections d=collections.deque()#双向队列 d.append('lucy') d.appendleft('lily') d.appendleft('lina') print(d) d.extend(['HAHA','XIXI','HEIHEI']) print(d) d.extendleft(['XIUXIU']) print(d) print(d.count('lucy')) print(d.pop())
import queue#单向队列所在的类 q=queue.Queue()#创建一个单项队列对象, q.put('lina')#写入 q.put('linda') q.put('lucy') print(q.qsize())#统计写入个数 print(q.get())#先进先出 FIFO,输出结果为lina
6.深浅copy:
1. copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象。
2. copy.deepcopy 深拷贝 拷贝对象及其子对象
数字、字符串深浅copy作用相同
import copy a={'k1':'v1','k2':'v2','k3':['haha','lily',123]} print(id(a))#35513800 a1=copy.copy(a) print(id(a1))#35932296 a2=copy.deepcopy(a) print(id(a2))#35514184 print(a1)#{'k3': ['haha', 'lily', 123], 'k2': 'v2', 'k1': 'v1'} print(a2)#{'k3': ['haha', 'lily', 123], 'k2': 'v2', 'k1': 'v1'} a['k3'][0]='hehe' print(a)#{'k3': ['hehe', 'lily', 123], 'k2': 'v2', 'k1': 'v1'} print(a1)#{'k3': ['hehe', 'lily', 123], 'k2': 'v2', 'k1': 'v1'} print(a2)#不做修改{'k3': ['haha', 'lily', 123], 'k2': 'v2', 'k1': 'v1'}