入门-常用内部功能 

一、每一个整数都具备如下功能：
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()方法：

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'}

 





 

 
 

 

 
posted @ 2016-05-20 15:32  echo_cat  阅读(279)  评论(0)    收藏  举报