基本数据类型补充:
set 是一个无序且不重复的元素集合
- class set(object):
- “””
- set() -> new empty set object
- set(iterable) -> new set object
- Build an unordered collection of unique elements.
- “””
- def add(self, *args, **kwargs): # real signature unknown
- “””
- Add an element to a set,添加元素
- This has no effect if the element is already present.
- “””
- pass
- def clear(self, *args, **kwargs): # real signature unknown
- “”” Remove all elements from this set. 清除内容”””
- pass
- def copy(self, *args, **kwargs): # real signature unknown
- “”” Return a shallow copy of a set. 浅拷贝 “””
- pass
- def difference(self, *args, **kwargs): # real signature unknown
- “””
- Return the difference of two or more sets as a new set. A中存在,B中不存在
- (i.e. all elements that are in this set but not the others.)
- “””
- pass
- def difference_update(self, *args, **kwargs): # real signature unknown
- “”” Remove all elements of another set from this set. 从当前集合中删除和B中相同的元素”””
- pass
- def discard(self, *args, **kwargs): # real signature unknown
- “””
- Remove an element from a set if it is a member.
- If the element is not a member, do nothing. 移除指定元素,不存在不保错
- “””
- pass
- def intersection(self, *args, **kwargs): # real signature unknown
- “””
- Return the intersection of two sets as a new set. 交集
- (i.e. all elements that are in both sets.)
- “””
- pass
- def intersection_update(self, *args, **kwargs): # real signature unknown
- “”” Update a set with the intersection of itself and another. 取交集并更更新到A中 “””
- pass
- def isdisjoint(self, *args, **kwargs): # real signature unknown
- “”” Return True if two sets have a null intersection. 如果没有交集,返回True,否则返回False”””
- pass
- def issubset(self, *args, **kwargs): # real signature unknown
- “”” Report whether another set contains this set. 是否是子序列”””
- pass
- def issuperset(self, *args, **kwargs): # real signature unknown
- “”” Report whether this set contains another set. 是否是父序列”””
- pass
- def pop(self, *args, **kwargs): # real signature unknown
- “””
- Remove and return an arbitrary set element.
- Raises KeyError if the set is empty. 移除元素
- “””
- pass
- def remove(self, *args, **kwargs): # real signature unknown
- “””
- Remove an element from a set; it must be a member.
- If the element is not a member, raise a KeyError. 移除指定元素,不存在保错
- “””
- pass
- def symmetric_difference(self, *args, **kwargs): # real signature unknown
- “””
- Return the symmetric difference of two sets as a new set. 对称差集
- (i.e. all elements that are in exactly one of the sets.)
- “””
- pass
- def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
- “”” Update a set with the symmetric difference of itself and another. 对称差集,并更新到a中 “””
- pass
- def union(self, *args, **kwargs): # real signature unknown
- “””
- Return the union of sets as a new set. 并集
- (i.e. all elements that are in either set.)
- “””
- pass
- def update(self, *args, **kwargs): # real signature unknown
- “”” Update a set with the union of itself and others. 更新 “””
- pass
1:创建
- s = set()
- s = {11,22,33,55}
2:转换
- li = [11,22,33,44]
- tu = (11,22,33,44)
- st = ”
- s = set(li)
3:intersection , intersection_update方法
- a = {11,22,33,44}
- b = {22,66,77,88}
- ret = a.intersection(b)
- print(ret)
intersection取得两个集合中的交集元素,并将这些元素以一个新的集合返回给一个变量接收
- a = {11,22,33,44}
- b = {22,66,77,88}
- a.intersection_update(b)
- print(a)
intersection_update取得两个集合的交集元素,并更新a集合
4:isdisjoint , issubset , issuperset方法
- s = {11,22,33,44}
- b = {11,22,77,55}
- ret = s.isdisjoint(b)#有交集返回False,没有交集返回True
- print(ret)
- ## False
issubset判断是否为子集
- a = {11,22,33,44}
- b = {11,44}
- ret = b.issubset(a)
- print(ret)
- ##########################################
- True
issuperset判断是否为父集
- a = {11,22,33,44}
- b = {11,44}
- ret = a.issubset(b)
- print(ret)
- ##########################################
- False
5:discard , remove , pop
- s = {11,22,33,44}
- s.remove(11)
- print(s)
- s.discard(22)
- print(s)
- s.pop()
- print(s)
三者都能达到移除元素的效果,区别在于remove移除集合中不存在的元素时会报错,discard移除不存在的元素是不会报错,pop无法精确控制移除哪个元素,按其自身的规则随机移除元素,返回被移除的元素,可以使用变量接收其返回值
6:symmetric_difference取差集
- s = {11,22,33,44}
- b = {11,22,77,55}
- r1 = s.difference(b)
- r2 = b.difference(s)
- print(r1)
- print(r2)
- ret = s.symmetric_difference(b)
- print(ret)
- ## set([33, 44])
- ## set([77, 55])
- ## set([33, 44, 77, 55])
symmetric_difference返回两个集合中不是交集的元素
上面的代码中,将symmetric_difference换成symmetric_difference_update则表示将两个集合中不是交集的部分赋值给s
7:union , update方法
- s = {11,22,33,44}
- b = {11,22,77,55}
- ret = s.union(b)
- print(ret)
- ## set([33, 11, 44, 77, 22, 55])
union方法合并两个集合
- s = {11,22,33,44}
- b = {11,22,77,55}
- s.update(b)
- print(s)
- ## set([33, 11, 44, 77, 22, 55])
update方法更新s集合,将b集合中的元素添加到s集合中!update方法也可以传递一个列表,如:update([23,45,67])
练习题:有下面两个字典
要求:
1)两个字典中有相同键的,则将new_dict中的值更新到old_dict对应键的值
2)old_dict中存在的键且new_dict中没有的键,在old_dict中删除,并把new_dict中的键值更新到old_dict中
3)最后输出old_dict
- # 数据库中原有
- 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’: 800 },
- “#3”:{ ‘hostname’:‘c1’, ‘cpu_count’: 2, ‘mem_capicity’: 80 },
- “#4”:{ ‘hostname’:‘c2’, ‘cpu_count’: 2, ‘mem_capicity’: 80 }
- }
- old_keys = set(old_dict.keys())
- new_keys = set(new_dict.keys())
- #需要更新元素的键
- update_keys = old_keys.intersection(new_keys)
- print(update_keys)
- #需要删除元素的键
- del_keys = old_keys.difference(new_keys)
- #需要添加元素的键
- add_keys = new_keys.difference(old_keys)
- print(del_keys)
- print(add_keys)
- update_keys = list(update_keys)
- for i in update_keys :
- old_dict[i] = new_dict[i]
- del_keys = list(del_keys)
- for j in del_keys :
- del old_dict[j]
- for k in list(add_keys) :
- old_dict[k] = new_dict[k]
- print(old_dict)
- ########################################
- {‘#3’: {‘hostname’: ‘c1’, ‘cpu_count’: , ‘mem_capicity’: }, ‘#1’: {‘hostname’: ‘c1’, ‘cpu_count’: , ‘mem_capicity’: }, ‘#4’: {‘hostname’: ‘c2’, ‘cpu_count’: , ‘mem_capicity’: }}
答案
collections系列
一、计数器(counter)
Counter是对字典类型的补充,用于追踪值的出现次数。
ps:具备字典的所有功能 + 自己的功能
- c = Counter(‘abcdeabcdabcaba’)
- print c
- 输出:Counter({‘a’: 5, ‘b’: 4, ‘c’: 3, ‘d’: 2, ‘e’: 1})
- ########################################################################
- ### Counter
- ########################################################################
- class Counter(dict):
- ”’Dict subclass for counting hashable items. Sometimes called a bag
- or multiset. Elements are stored as dictionary keys and their counts
- are stored as dictionary values.
- >>> c = Counter(‘abcdeabcdabcaba‘) # count elements from a string
- >>> c.most_common(3) # three most common elements
- [(‘a‘, 5), (‘b‘, 4), (‘c‘, 3)]
- >>> sorted(c) # list all unique elements
- [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]
- >>> ”.join(sorted(c.elements())) # list elements with repetitions
- ‘aaaaabbbbcccdde‘
- >>> sum(c.values()) # total of all counts
- >>> c[‘a‘] # count of letter ‘a‘
- >>> for elem in ‘shazam‘: # update counts from an iterable
- … c[elem] += 1 # by adding 1 to each element’s count
- >>> c[‘a’] # now there are seven ‘a’
- >>> del c[‘b’] # remove all ‘b’
- >>> c[‘b’] # now there are zero ‘b’
- >>> d = Counter(‘simsalabim’) # make another counter
- >>> c.update(d) # add in the second counter
- >>> c[‘a’] # now there are nine ‘a’
- >>> c.clear() # empty the counter
- >>> c
- Counter()
- Note: If a count is set to zero or reduced to zero, it will remain
- in the counter until the entry is deleted or the counter is cleared:
- >>> c = Counter(‘aaabbc’)
- >>> c[‘b’] -= 2 # reduce the count of ‘b’ by two
- >>> c.most_common() # ‘b’ is still in, but its count is zero
- [(‘a’, 3), (‘c’, 1), (‘b’, 0)]
- ”’
- # References:
- # http://en.wikipedia.org/wiki/Multiset
- # http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
- # http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
- # http://code.activestate.com/recipes/259174/
- # Knuth, TAOCP Vol. II section 4.6.3
- def __init__(self, iterable=None, **kwds):
- ”’Create a new, empty Counter object. And if given, count elements
- from an input iterable. Or, initialize the count from another mapping
- of elements to their counts.
- >>> c = Counter() # a new, empty counter
- >>> c = Counter(‘gallahad’) # a new counter from an iterable
- >>> c = Counter({‘a’: 4, ‘b’: 2}) # a new counter from a mapping
- >>> c = Counter(a=4, b=2) # a new counter from keyword args
- ”’
- super(Counter, self).__init__()
- self.update(iterable, **kwds)
- def __missing__(self, key):
- “”” 对于不存在的元素,返回计数器为0 “””
- ‘The count of elements not in the Counter is zero.‘
- # Needed so that self[missing_item] does not raise KeyError
- return 0
- def most_common(self, n=None):
- “”” 数量大于等n的所有元素和计数器 “””
- ”’List the n most common elements and their counts from the most
- common to the least. If n is None, then list all element counts.
- >>> Counter(‘abcdeabcdabcaba’).most_common(3)
- [(‘a’, 5), (‘b’, 4), (‘c’, 3)]
- ”’
- # Emulate Bag.sortedByCount from Smalltalk
- if n is None:
- return sorted(self.iteritems(), key=_itemgetter(1), reverse=True)
- return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1))
- def elements(self):
- “”” 计数器中的所有元素,注:此处非所有元素集合,而是包含所有元素集合的迭代器 “””
- ”’Iterator over elements repeating each as many times as its count.
- >>> c = Counter(‘ABCABC’)
- >>> sorted(c.elements())
- [‘A’, ‘A’, ‘B’, ‘B’, ‘C’, ‘C’]
- # Knuth’s example for prime factors of 1836: 2**2 * 3**3 * 17**1
- >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
- >>> product = 1
- >>> for factor in prime_factors.elements(): # loop over factors
- … product *= factor # and multiply them
- >>> product
- Note, if an element‘s count has been set to zero or is a negative
- number, elements() will ignore it.
- ”’
- # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
- return _chain.from_iterable(_starmap(_repeat, self.iteritems()))
- # Override dict methods where necessary
- @classmethod
- def fromkeys(cls, iterable, v=None):
- # There is no equivalent method for counters because setting v=1
- # means that no element can have a count greater than one.
- raise NotImplementedError(
- ‘Counter.fromkeys() is undefined. Use Counter(iterable) instead.’)
- def update(self, iterable=None, **kwds):
- “”” 更新计数器,其实就是增加;如果原来没有,则新建,如果有则加一 “””
- ”’Like dict.update() but add counts instead of replacing them.
- Source can be an iterable, a dictionary, or another Counter instance.
- >>> c = Counter(‘which‘)
- >>> c.update(‘witch‘) # add elements from another iterable
- >>> d = Counter(‘watch‘)
- >>> c.update(d) # add elements from another counter
- >>> c[‘h‘] # four ‘h‘ in which, witch, and watch
- ”’
- # The regular dict.update() operation makes no sense here because the
- # replace behavior results in the some of original untouched counts
- # being mixed-in with all of the other counts for a mismash that
- # doesn’t have a straight-forward interpretation in most counting
- # contexts. Instead, we implement straight-addition. Both the inputs
- # and outputs are allowed to contain zero and negative counts.
- if iterable is not None:
- if isinstance(iterable, Mapping):
- if self:
- self_get = self.get
- for elem, count in iterable.iteritems():
- self[elem] = self_get(elem, 0) + count
- else:
- super(Counter, self).update(iterable) # fast path when counter is empty
- else:
- self_get = self.get
- for elem in iterable:
- self[elem] = self_get(elem, 0) + 1
- if kwds:
- self.update(kwds)
- def subtract(self, iterable=None, **kwds):
- “”” 相减,原来的计数器中的每一个元素的数量减去后添加的元素的数量 “””
- ”’Like dict.update() but subtracts counts instead of replacing them.
- Counts can be reduced below zero. Both the inputs and outputs are
- allowed to contain zero and negative counts.
- Source can be an iterable, a dictionary, or another Counter instance.
- >>> c = Counter(‘which‘)
- >>> c.subtract(‘witch‘) # subtract elements from another iterable
- >>> c.subtract(Counter(‘watch‘)) # subtract elements from another counter
- >>> c[‘h‘] # 2 in which, minus 1 in witch, minus 1 in watch
- >>> c[‘w‘] # 1 in which, minus 1 in witch, minus 1 in watch
- -1
- ”’
- if iterable is not None:
- self_get = self.get
- if isinstance(iterable, Mapping):
- for elem, count in iterable.items():
- self[elem] = self_get(elem, 0) – count
- else:
- for elem in iterable:
- self[elem] = self_get(elem, 0) – 1
- if kwds:
- self.subtract(kwds)
- def copy(self):
- “”” 拷贝 “””
- ‘Return a shallow copy.’
- return self.__class__(self)
- def __reduce__(self):
- “”” 返回一个元组(类型,元组) “””
- return self.__class__, (dict(self),)
- def __delitem__(self, elem):
- “”” 删除元素 “””
- ‘Like dict.__delitem__() but does not raise KeyError for missing values.’
- if elem in self:
- super(Counter, self).__delitem__(elem)
- def __repr__(self):
- if not self:
- return ‘%s()’ % self.__class__.__name__
- items = ‘, ‘.join(map(‘%r: %r’.__mod__, self.most_common()))
- return ‘%s({%s})’ % (self.__class__.__name__, items)
- # Multiset-style mathematical operations discussed in:
- # Knuth TAOCP Volume II section 4.6.3 exercise 19
- # and at http://en.wikipedia.org/wiki/Multiset
- #
- # Outputs guaranteed to only include positive counts.
- #
- # To strip negative and zero counts, add-in an empty counter:
- # c += Counter()
- def __add__(self, other):
- ”’Add counts from two counters.
- >>> Counter(‘abbb‘) + Counter(‘bcc‘)
- Counter({‘b‘: 4, ‘c‘: 2, ‘a‘: 1})
- ”’
- if not isinstance(other, Counter):
- return NotImplemented
- result = Counter()
- for elem, count in self.items():
- newcount = count + other[elem]
- if newcount > 0:
- result[elem] = newcount
- for elem, count in other.items():
- if elem not in self and count > 0:
- result[elem] = count
- return result
- def __sub__(self, other):
- ”’ Subtract count, but keep only results with positive counts.
- >>> Counter(‘abbbc‘) – Counter(‘bccd‘)
- Counter({‘b‘: 2, ‘a‘: 1})
- ”’
- if not isinstance(other, Counter):
- return NotImplemented
- result = Counter()
- for elem, count in self.items():
- newcount = count – other[elem]
- if newcount > 0:
- result[elem] = newcount
- for elem, count in other.items():
- if elem not in self and count < 0:
- result[elem] = 0 – count
- return result
- def __or__(self, other):
- ”’Union is the maximum of value in either of the input counters.
- >>> Counter(‘abbb‘) | Counter(‘bcc‘)
- Counter({‘b‘: 3, ‘c‘: 2, ‘a‘: 1})
- ”’
- if not isinstance(other, Counter):
- return NotImplemented
- result = Counter()
- for elem, count in self.items():
- other_count = other[elem]
- newcount = other_count if count < other_count else count
- if newcount > 0:
- result[elem] = newcount
- for elem, count in other.items():
- if elem not in self and count > 0:
- result[elem] = count
- return result
- def __and__(self, other):
- ”’ Intersection is the minimum of corresponding counts.
- >>> Counter(‘abbb‘) & Counter(‘bcc‘)
- Counter({‘b‘: 1})
- ”’
- if not isinstance(other, Counter):
- return NotImplemented
- result = Counter()
- for elem, count in self.items():
- other_count = other[elem]
- newcount = count if count < other_count else other_count
- if newcount > 0:
- result[elem] = newcount
- return result
- Counter
Counter
二、有序字典(orderedDict )
orderdDict是对字典类型的补充,他记住了字典元素添加的顺序
- class OrderedDict(dict):
- ‘Dictionary that remembers insertion order’
- # An inherited dict maps keys to values.
- # The inherited dict provides __getitem__, __len__, __contains__, and get.
- # The remaining methods are order-aware.
- # Big-O running times for all methods are the same as regular dictionaries.
- # The internal self.__map dict maps keys to links in a doubly linked list.
- # The circular doubly linked list starts and ends with a sentinel element.
- # The sentinel element never gets deleted (this simplifies the algorithm).
- # Each link is stored as a list of length three: [PREV, NEXT, KEY].
- def __init__(self, *args, **kwds):
- ”’Initialize an ordered dictionary. The signature is the same as
- regular dictionaries, but keyword arguments are not recommended because
- their insertion order is arbitrary.
- ”’
- if len(args) > 1:
- raise TypeError(‘expected at most 1 arguments, got %d’ % len(args))
- try:
- self.__root
- except AttributeError:
- self.__root = root = [] # sentinel node
- root[:] = [root, root, None]
- self.__map = {}
- self.__update(*args, **kwds)
- def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
- ‘od.__setitem__(i, y) <==> od[i]=y’
- # Setting a new item creates a new link at the end of the linked list,
- # and the inherited dictionary is updated with the new key/value pair.
- if key not in self:
- root = self.__root
- last = root[0]
- last[1] = root[0] = self.__map[key] = [last, root, key]
- return dict_setitem(self, key, value)
- def __delitem__(self, key, dict_delitem=dict.__delitem__):
- ‘od.__delitem__(y) <==> del od[y]’
- # Deleting an existing item uses self.__map to find the link which gets
- # removed by updating the links in the predecessor and successor nodes.
- dict_delitem(self, key)
- link_prev, link_next, _ = self.__map.pop(key)
- link_prev[1] = link_next # update link_prev[NEXT]
- link_next[0] = link_prev # update link_next[PREV]
- def __iter__(self):
- ‘od.__iter__() <==> iter(od)’
- # Traverse the linked list in order.
- root = self.__root
- curr = root[1] # start at the first node
- while curr is not root:
- yield curr[2] # yield the curr[KEY]
- curr = curr[1] # move to next node
- def __reversed__(self):
- ‘od.__reversed__() <==> reversed(od)’
- # Traverse the linked list in reverse order.
- root = self.__root
- curr = root[0] # start at the last node
- while curr is not root:
- yield curr[2] # yield the curr[KEY]
- curr = curr[0] # move to previous node
- def clear(self):
- ‘od.clear() -> None. Remove all items from od.’
- root = self.__root
- root[:] = [root, root, None]
- self.__map.clear()
- dict.clear(self)
- # — the following methods do not depend on the internal structure —
- def keys(self):
- ‘od.keys() -> list of keys in od’
- return list(self)
- def values(self):
- ‘od.values() -> list of values in od’
- return [self[key] for key in self]
- def items(self):
- ‘od.items() -> list of (key, value) pairs in od’
- return [(key, self[key]) for key in self]
- def iterkeys(self):
- ‘od.iterkeys() -> an iterator over the keys in od’
- return iter(self)
- def itervalues(self):
- ‘od.itervalues -> an iterator over the values in od’
- for k in self:
- yield self[k]
- def iteritems(self):
- ‘od.iteritems -> an iterator over the (key, value) pairs in od’
- for k in self:
- yield (k, self[k])
- update = MutableMapping.update
- __update = update # let subclasses override update without breaking __init__
- __marker = object()
- def pop(self, key, default=__marker):
- ”’od.pop(k[,d]) -> v, remove specified key and return the corresponding
- value. If key is not found, d is returned if given, otherwise KeyError
- is raised.
- ”’
- if key in self:
- result = self[key]
- del self[key]
- return result
- if default is self.__marker:
- raise KeyError(key)
- return default
- def setdefault(self, key, default=None):
- ‘od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od’
- if key in self:
- return self[key]
- self[key] = default
- return default
- def popitem(self, last=True):
- ”’od.popitem() -> (k, v), return and remove a (key, value) pair.
- Pairs are returned in LIFO order if last is true or FIFO order if false.
- ”’
- if not self:
- raise KeyError(‘dictionary is empty’)
- key = next(reversed(self) if last else iter(self))
- value = self.pop(key)
- return key, value
- def __repr__(self, _repr_running={}):
- ‘od.__repr__() <==> repr(od)’
- call_key = id(self), _get_ident()
- if call_key in _repr_running:
- return ‘…’
- _repr_running[call_key] = 1
- try:
- if not self:
- return ‘%s()’ % (self.__class__.__name__,)
- return ‘%s(%r)’ % (self.__class__.__name__, self.items())
- finally:
- del _repr_running[call_key]
- def __reduce__(self):
- ‘Return state information for pickling’
- items = [[k, self[k]] for k in self]
- inst_dict = vars(self).copy()
- for k in vars(OrderedDict()):
- inst_dict.pop(k, None)
- if inst_dict:
- return (self.__class__, (items,), inst_dict)
- return self.__class__, (items,)
- def copy(self):
- ‘od.copy() -> a shallow copy of od’
- return self.__class__(self)
- @classmethod
- def fromkeys(cls, iterable, value=None):
- ”’OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
- If not specified, the value defaults to None.
- ”’
- self = cls()
- for key in iterable:
- self[key] = value
- return self
- def __eq__(self, other):
- ”’od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
- while comparison to a regular mapping is order-insensitive.
- ”’
- if isinstance(other, OrderedDict):
- return dict.__eq__(self, other) and all(_imap(_eq, self, other))
- return dict.__eq__(self, other)
- def __ne__(self, other):
- ‘od.__ne__(y) <==> od!=y’
- return not self == other
- # — the following methods support python 3.x style dictionary views —
- def viewkeys(self):
- “od.viewkeys() -> a set-like object providing a view on od’s keys”
- return KeysView(self)
- def viewvalues(self):
- “od.viewvalues() -> an object providing a view on od’s values”
- return ValuesView(self)
- def viewitems(self):
- “od.viewitems() -> a set-like object providing a view on od’s items”
- return ItemsView(self)
- OrderedDict
OrderedDict
三、默认字典(defaultdict)
defaultdict是对字典的类型的补充,他默认给字典的值设置了一个类型。
- class defaultdict(dict):
- “””
- defaultdict(default_factory[, …]) –> dict with default factory
- The default factory is called without arguments to produce
- a new value when a key is not present, in __getitem__ only.
- A defaultdict compares equal to a dict with the same items.
- All remaining arguments are treated the same as if they were
- passed to the dict constructor, including keyword arguments.
- “””
- def copy(self): # real signature unknown; restored from __doc__
- “”” D.copy() -> a shallow copy of D. “””
- pass
- def __copy__(self, *args, **kwargs): # real signature unknown
- “”” D.copy() -> a shallow copy of D. “””
- pass
- def __getattribute__(self, name): # real signature unknown; restored from __doc__
- “”” x.__getattribute__(‘name’) <==> x.name “””
- pass
- def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__
- “””
- defaultdict(default_factory[, …]) –> dict with default factory
- The default factory is called without arguments to produce
- a new value when a key is not present, in __getitem__ only.
- A defaultdict compares equal to a dict with the same items.
- All remaining arguments are treated the same as if they were
- passed to the dict constructor, including keyword arguments.
- # (copied from class doc)
- “””
- pass
- def __missing__(self, key): # real signature unknown; restored from __doc__
- “””
- __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
- if self.default_factory is None: raise KeyError((key,))
- self[key] = value = self.default_factory()
- return value
- “””
- pass
- def __reduce__(self, *args, **kwargs): # real signature unknown
- “”” Return state information for pickling. “””
- pass
- def __repr__(self): # real signature unknown; restored from __doc__
- “”” x.__repr__() <==> repr(x) “””
- pass
- default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- “””Factory for default value called by __missing__().”””
- defaultdict
defaultdict
使用方法:
- import collections
- dic = collections.defaultdict(list)
- dic[‘k1’].append(‘alext’)
- print(dic)
练习:
- 有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中。
- 即: {‘k1’: 大于66 , ‘k2’: 小于66}
- values = [11, 22, 33,44,55,66,77,88,99,90]
- my_dict = {}
- for value in values:
- if value>66:
- if my_dict.has_key(‘k1’):
- my_dict[‘k1’].append(value)
- else:
- my_dict[‘k1’] = [value]
- else:
- if my_dict.has_key(‘k2’):
- my_dict[‘k2’].append(value)
- else:
- my_dict[‘k2’] = [value]
原生字典
- from collections import defaultdict
- values = [11, 22, 33,44,55,66,77,88,99,90]
- my_dict = defaultdict(list)
- for value in values:
- if value>66:
- my_dict[‘k1’].append(value)
- else:
- my_dict[‘k2’].append(value)
- defaultdict字典解决方法
- 默认字典
默认字典
四、可命名元组(namedtuple)
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
- import collections
- MytupleClass = collections.namedtuple(‘MytupleClass’,[‘x’,‘y’,‘z’])
- obj = MytupleClass(11,33,44)
- print(obj.x)
- print(obj.y)
- print(obj.z)
- class Mytuple(__builtin__.tuple)
- | Mytuple(x, y)
- |
- | Method resolution order:
- | Mytuple
- | __builtin__.tuple
- | __builtin__.object
- |
- | Methods defined here:
- |
- | __getnewargs__(self)
- | Return self as a plain tuple. Used by copy and pickle.
- |
- | __getstate__(self)
- | Exclude the OrderedDict from pickling
- |
- | __repr__(self)
- | Return a nicely formatted representation string
- |
- | _asdict(self)
- | Return a new OrderedDict which maps field names to their values
- |
- | _replace(_self, **kwds)
- | Return a new Mytuple object replacing specified fields with new values
- |
- | ———————————————————————-
- | Class methods defined here:
- |
- | _make(cls, iterable, new=<built–in method __new__ of type object>, len=<built–in function len>) from __builtin__.type
- | Make a new Mytuple object from a sequence or iterable
- |
- | ———————————————————————-
- | Static methods defined here:
- |
- | __new__(_cls, x, y)
- | Create new instance of Mytuple(x, y)
- |
- | ———————————————————————-
- | Data descriptors defined here:
- |
- | __dict__
- | Return a new OrderedDict which maps field names to their values
- |
- | x
- | Alias for field number 0
- |
- | y
- | Alias for field number 1
- |
- | ———————————————————————-
- | Data and other attributes defined here:
- |
- | _fields = (‘x’, ‘y’)
- |
- | ———————————————————————-
- | Methods inherited from __builtin__.tuple:
- |
- | __add__(…)
- | x.__add__(y) <==> x+y
- |
- | __contains__(…)
- | x.__contains__(y) <==> y in x
- |
- | __eq__(…)
- | x.__eq__(y) <==> x==y
- |
- | __ge__(…)
- | x.__ge__(y) <==> x>=y
- |
- | __getattribute__(…)
- | x.__getattribute__(‘name’) <==> x.name
- |
- | __getitem__(…)
- | x.__getitem__(y) <==> x[y]
- |
- | __getslice__(…)
- | x.__getslice__(i, j) <==> x[i:j]
- |
- | Use of negative indices is not supported.
- |
- | __gt__(…)
- | x.__gt__(y) <==> x>y
- |
- | __hash__(…)
- | x.__hash__() <==> hash(x)
- |
- | __iter__(…)
- | x.__iter__() <==> iter(x)
- |
- | __le__(…)
- | x.__le__(y) <==> x<=y
- |
- | __len__(…)
- | x.__len__() <==> len(x)
- |
- | __lt__(…)
- | x.__lt__(y) <==> x<y
- |
- | __mul__(…)
- | x.__mul__(n) <==> x*n
- |
- | __ne__(…)
- | x.__ne__(y) <==> x!=y
- |
- | __rmul__(…)
- | x.__rmul__(n) <==> n*x
- |
- | __sizeof__(…)
- | T.__sizeof__() — size of T in memory, in bytes
- |
- | count(…)
- | T.count(value) -> integer — return number of occurrences of value
- |
- | index(…)
- | T.index(value, [start, [stop]]) -> integer — return first index of value.
- | Raises ValueError if the value is not present.
- Mytuple
Mytuple
五、双向队列(deque)
一个线程安全的双向队列
- class deque(object):
- “””
- deque([iterable[, maxlen]]) –> deque object
- Build an ordered collection with optimized access from its endpoints.
- “””
- def append(self, *args, **kwargs): # real signature unknown
- “”” Add an element to the right side of the deque. “””
- pass
- def appendleft(self, *args, **kwargs): # real signature unknown
- “”” Add an element to the left side of the deque. “””
- pass
- def clear(self, *args, **kwargs): # real signature unknown
- “”” Remove all elements from the deque. “””
- pass
- def count(self, value): # real signature unknown; restored from __doc__
- “”” D.count(value) -> integer — return number of occurrences of value “””
- return 0
- def extend(self, *args, **kwargs): # real signature unknown
- “”” Extend the right side of the deque with elements from the iterable “””
- pass
- def extendleft(self, *args, **kwargs): # real signature unknown
- “”” Extend the left side of the deque with elements from the iterable “””
- pass
- def pop(self, *args, **kwargs): # real signature unknown
- “”” Remove and return the rightmost element. “””
- pass
- def popleft(self, *args, **kwargs): # real signature unknown
- “”” Remove and return the leftmost element. “””
- pass
- def remove(self, value): # real signature unknown; restored from __doc__
- “”” D.remove(value) — remove first occurrence of value. “””
- pass
- def reverse(self): # real signature unknown; restored from __doc__
- “”” D.reverse() — reverse *IN PLACE* “””
- pass
- def rotate(self, *args, **kwargs): # real signature unknown
- “”” Rotate the deque n steps to the right (default n=1). If n is negative, rotates left. “””
- pass
- def __copy__(self, *args, **kwargs): # real signature unknown
- “”” Return a shallow copy of a deque. “””
- pass
- def __delitem__(self, y): # real signature unknown; restored from __doc__
- “”” x.__delitem__(y) <==> del x[y] “””
- pass
- def __eq__(self, y): # real signature unknown; restored from __doc__
- “”” x.__eq__(y) <==> x==y “””
- pass
- def __getattribute__(self, name): # real signature unknown; restored from __doc__
- “”” x.__getattribute__(‘name’) <==> x.name “””
- pass
- def __getitem__(self, y): # real signature unknown; restored from __doc__
- “”” x.__getitem__(y) <==> x[y] “””
- pass
- def __ge__(self, y): # real signature unknown; restored from __doc__
- “”” x.__ge__(y) <==> x>=y “””
- pass
- def __gt__(self, y): # real signature unknown; restored from __doc__
- “”” x.__gt__(y) <==> x>y “””
- pass
- def __iadd__(self, y): # real signature unknown; restored from __doc__
- “”” x.__iadd__(y) <==> x+=y “””
- pass
- def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__
- “””
- deque([iterable[, maxlen]]) –> deque object
- Build an ordered collection with optimized access from its endpoints.
- # (copied from class doc)
- “””
- pass
- def __iter__(self): # real signature unknown; restored from __doc__
- “”” x.__iter__() <==> iter(x) “””
- pass
- def __len__(self): # real signature unknown; restored from __doc__
- “”” x.__len__() <==> len(x) “””
- pass
- def __le__(self, y): # real signature unknown; restored from __doc__
- “”” x.__le__(y) <==> x<=y “””
- pass
- def __lt__(self, y): # real signature unknown; restored from __doc__
- “”” x.__lt__(y) <==> x<y “””
- pass
- @staticmethod # known case of __new__
- def __new__(S, *more): # real signature unknown; restored from __doc__
- “”” T.__new__(S, …) -> a new object with type S, a subtype of T “””
- pass
- def __ne__(self, y): # real signature unknown; restored from __doc__
- “”” x.__ne__(y) <==> x!=y “””
- pass
- def __reduce__(self, *args, **kwargs): # real signature unknown
- “”” Return state information for pickling. “””
- pass
- def __repr__(self): # real signature unknown; restored from __doc__
- “”” x.__repr__() <==> repr(x) “””
- pass
- def __reversed__(self): # real signature unknown; restored from __doc__
- “”” D.__reversed__() — return a reverse iterator over the deque “””
- pass
- def __setitem__(self, i, y): # real signature unknown; restored from __doc__
- “”” x.__setitem__(i, y) <==> x[i]=y “””
- pass
- def __sizeof__(self): # real signature unknown; restored from __doc__
- “”” D.__sizeof__() — size of D in memory, in bytes “””
- pass
- maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- “””maximum size of a deque or None if unbounded”””
- __hash__ = None
- deque
- deque
deque
注:既然有双向队列,也有单项队列(先进先出 FIFO )
- class Queue:
- “””Create a queue object with a given maximum size.
- If maxsize is <= 0, the queue size is infinite.
- “””
- def __init__(self, maxsize=0):
- self.maxsize = maxsize
- self._init(maxsize)
- # mutex must be held whenever the queue is mutating. All methods
- # that acquire mutex must release it before returning. mutex
- # is shared between the three conditions, so acquiring and
- # releasing the conditions also acquires and releases mutex.
- self.mutex = _threading.Lock()
- # Notify not_empty whenever an item is added to the queue; a
- # thread waiting to get is notified then.
- self.not_empty = _threading.Condition(self.mutex)
- # Notify not_full whenever an item is removed from the queue;
- # a thread waiting to put is notified then.
- self.not_full = _threading.Condition(self.mutex)
- # Notify all_tasks_done whenever the number of unfinished tasks
- # drops to zero; thread waiting to join() is notified to resume
- self.all_tasks_done = _threading.Condition(self.mutex)
- self.unfinished_tasks = 0
- def task_done(self):
- “””Indicate that a formerly enqueued task is complete.
- Used by Queue consumer threads. For each get() used to fetch a task,
- a subsequent call to task_done() tells the queue that the processing
- on the task is complete.
- If a join() is currently blocking, it will resume when all items
- have been processed (meaning that a task_done() call was received
- for every item that had been put() into the queue).
- Raises a ValueError if called more times than there were items
- placed in the queue.
- “””
- self.all_tasks_done.acquire()
- try:
- unfinished = self.unfinished_tasks – 1
- if unfinished <= 0:
- if unfinished < 0:
- raise ValueError(‘task_done() called too many times’)
- self.all_tasks_done.notify_all()
- self.unfinished_tasks = unfinished
- finally:
- self.all_tasks_done.release()
- def join(self):
- “””Blocks until all items in the Queue have been gotten and processed.
- The count of unfinished tasks goes up whenever an item is added to the
- queue. The count goes down whenever a consumer thread calls task_done()
- to indicate the item was retrieved and all work on it is complete.
- When the count of unfinished tasks drops to zero, join() unblocks.
- “””
- self.all_tasks_done.acquire()
- try:
- while self.unfinished_tasks:
- self.all_tasks_done.wait()
- finally:
- self.all_tasks_done.release()
- def qsize(self):
- “””Return the approximate size of the queue (not reliable!).”””
- self.mutex.acquire()
- n = self._qsize()
- self.mutex.release()
- return n
- def empty(self):
- “””Return True if the queue is empty, False otherwise (not reliable!).”””
- self.mutex.acquire()
- n = not self._qsize()
- self.mutex.release()
- return n
- def full(self):
- “””Return True if the queue is full, False otherwise (not reliable!).”””
- self.mutex.acquire()
- n = 0 < self.maxsize == self._qsize()
- self.mutex.release()
- return n
- def put(self, item, block=True, timeout=None):
- “””Put an item into the queue.
- If optional args ‘block’ is true and ‘timeout’ is None (the default),
- block if necessary until a free slot is available. If ‘timeout’ is
- a non-negative number, it blocks at most ‘timeout’ seconds and raises
- the Full exception if no free slot was available within that time.
- Otherwise (‘block’ is false), put an item on the queue if a free slot
- is immediately available, else raise the Full exception (‘timeout’
- is ignored in that case).
- “””
- self.not_full.acquire()
- try:
- if self.maxsize > 0:
- if not block:
- if self._qsize() == self.maxsize:
- raise Full
- elif timeout is None:
- while self._qsize() == self.maxsize:
- self.not_full.wait()
- elif timeout < 0:
- raise ValueError(“‘timeout’ must be a non-negative number”)
- else:
- endtime = _time() + timeout
- while self._qsize() == self.maxsize:
- remaining = endtime – _time()
- if remaining <= 0.0:
- raise Full
- self.not_full.wait(remaining)
- self._put(item)
- self.unfinished_tasks += 1
- self.not_empty.notify()
- finally:
- self.not_full.release()
- def put_nowait(self, item):
- “””Put an item into the queue without blocking.
- Only enqueue the item if a free slot is immediately available.
- Otherwise raise the Full exception.
- “””
- return self.put(item, False)
- def get(self, block=True, timeout=None):
- “””Remove and return an item from the queue.
- If optional args ‘block’ is true and ‘timeout’ is None (the default),
- block if necessary until an item is available. If ‘timeout’ is
- a non-negative number, it blocks at most ‘timeout’ seconds and raises
- the Empty exception if no item was available within that time.
- Otherwise (‘block’ is false), return an item if one is immediately
- available, else raise the Empty exception (‘timeout’ is ignored
- in that case).
- “””
- self.not_empty.acquire()
- try:
- if not block:
- if not self._qsize():
- raise Empty
- elif timeout is None:
- while not self._qsize():
- self.not_empty.wait()
- elif timeout < 0:
- raise ValueError(“‘timeout’ must be a non-negative number”)
- else:
- endtime = _time() + timeout
- while not self._qsize():
- remaining = endtime – _time()
- if remaining <= 0.0:
- raise Empty
- self.not_empty.wait(remaining)
- item = self._get()
- self.not_full.notify()
- return item
- finally:
- self.not_empty.release()
- def get_nowait(self):
- “””Remove and return an item from the queue without blocking.
- Only get an item if one is immediately available. Otherwise
- raise the Empty exception.
- “””
- return self.get(False)
- # Override these methods to implement other queue organizations
- # (e.g. stack or priority queue).
- # These will only be called with appropriate locks held
- # Initialize the queue representation
- def _init(self, maxsize):
- self.queue = deque()
- def _qsize(self, len=len):
- return len(self.queue)
- # Put a new item in the queue
- def _put(self, item):
- self.queue.append(item)
- # Get an item from the queue
- def _get(self):
- return self.queue.popleft()
- Queue.Queue
Queue.Queue
三元运算
三元运算(三目运算),是对简单的条件语句的缩写。
- # 书写格式
- result = 值1 if 条件 else 值2
- # 如果条件成立,那么将 “值1” 赋值给result变量,否则,将“值2”赋值给result变量
- a = 1
- name = ‘poe’ if a == 1 else ‘jet’
- print(name)
深浅拷贝
一、数字和字符串
对于 数字 和 字符串 而言,赋值、浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址。
- import copy
- # ######### 数字、字符串 #########
- n1 = 123
- # n1 = “i am alex age 10”
- print(id(n1))
- # ## 赋值 ##
- n2 = n1
- print(id(n2))
- # ## 浅拷贝 ##
- n2 = copy.copy(n1)
- print(id(n2))
- # ## 深拷贝 ##
- n3 = copy.deepcopy(n1)
- print(id(n3))
二、其他基本数据类型
对于字典、元祖、列表 而言,进行赋值、浅拷贝和深拷贝时,其内存地址的变化是不同的。
1、赋值
赋值,只是创建一个变量,该变量指向原来内存地址,如:
- n1 = {“k1”: “wu”, “k2”: 123, “k3”: [“alex”, 456]}
- n2 = n1
2、浅拷贝
浅拷贝,在内存中只额外创建第一层数据
- import copy
- n1 = {“k1”: “wu”, “k2”: 123, “k3”: [“alex”, 456]}
- n3 = copy.copy(n1)
3、深拷贝
深拷贝,在内存中将所有的数据重新创建一份(排除最后一层,即:python内部对字符串和数字的优化)
- import copy
- n1 = {“k1”: “wu”, “k2”: 123, “k3”: [“alex”, 456]}
- n4 = copy.deepcopy(n1)
函数
1:函数的定义
- def 函数名(参数):
- …
- 函数体
- …
- 返回值
函数的定义主要有如下要点:
def:表示函数的关键字 函数名:函数的名称,日后根据函数名调用函数 函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出 [11,22,38,888,2]中的最大数等… 参数:为函数体提供数据 返回值:当函数执行完毕后,可以给调用者返回数据。
2:返回值
函数是一个功能块,该功能到底执行成功与否,需要通过返回值来告知调用者。
以上要点中,比较重要有参数和返回值:
- def 发送短信():
- 发送短信的代码…
- if 发送成功:
- return True
- else:
- return False
- while True:
- # 每次执行发送短信函数,都会将返回值自动赋值给result
- # 之后,可以根据result来写日志,或重发等操作
- result = 发送短信()
- if result == False:
- 记录日志,短信发送失败…
3:参数
函数有三种不同的参数:
普通参数
- # ######### 定义函数 #########
- # name 叫做函数func的形式参数,简称:形参
- def func(name):
- print name
- # ######### 执行函数 #########
- # ‘wupeiqi’ 叫做函数func的实际参数,简称:实参
- func(‘poe’)
默认参数
- def func(name, age = 18):
- print “%s:%s” %(name,age)
- # 指定参数
- func(‘poe’, 19)
- # 使用默认参数
- func(‘gin’)
- 注:默认参数需要放在参数列表最后
动态参数
- def f1(*a):
- print(a,type(a))
- f1(123,456,[1,2,3],‘who’)
- ## ((123, 456, [1, 2, 3], ‘who’), <type ‘tuple’>)
- def func(**kwargs):
- print args
- # 执行方式一
- func(name=‘poe’,age=18)
- # 执行方式二
- li = {‘name’:‘poe’, age:18, ‘gender’:‘male’}
- func(**li)
- def f1(*a,**b) :#一个星的参数必须在前,两个星的参数必须在后
- print(a,type(a))
- print(b,type(b))
- f1(11,22,33,k1=1234,k2=456)
- ## ((11, 22, 33), <type ‘tuple’>)({‘k2’: 456, ‘k1’: 1234}, <type ‘dict’>)
为动态参数传入列表,元组,字典:(注:这几种数据类型在函数传参的时候只有引用传递,没有值传递)
- def f1(*args) :
- print(args,type(args))
- li = [1,2,3,4]
- f1(li)
- f1(*li)
- ## (([1, 2, 3, 4],), <type ‘tuple’>)
- ## ((1, 2, 3, 4), <type ‘tuple’>)
- def f2(**kwargs) :
- print(kwargs,type(kwargs))
- dic = {‘k1’:123,‘k2’:456}
- f2(k1 = dic)
- f2(**dic)
- ## ({‘k1’: {‘k2’: 456, ‘k1’: 123}}, <type ‘dict’>)
- ## ({‘k2’: 456, ‘k1’: 123}, <type ‘dict’>)
4:内置函数
注:查看详细猛击这里
数据类型转换函数
- chr(i) 函数返回ASCII码对应的字符串
-
- print(chr(65))
- print(chr(66))
- print(chr(65)+chr(66))
- ##########################################
- A
- B
- AB
- complex(real[,imaginary]) 函数可把字符串或数字转换为复数
-
- print(complex(“2+1j”))
- print(complex(“”))
- print(complex(2,1))
- ##########################################
- (2+1j)
- (2+0j)
- (2+1j)
- float(x) 函数把一个数字或字符串转换成浮点数
-
- print(float(12))
- print(float(12.2))
- ##########################################
- 12.0
- 12.2
- long(x[,base]) 函数把数字和字符串转换成长整数,base为可选的基数
- list(x) 函数可将序列对象转换成列表
- min(x[,y,z…]) 函数返回给定参数的最小值,参数可以为序列
- max(x[,y,z…]) 函数返回给定参数的最大值,参数可以为序列
- ord(x) 函数返回一个字符串参数的ASCII码或Unicode值
-
- print(ord(‘a’))
- print(ord(u“A”))
- ##########################################
- 97
- 65
- str(obj) 函数把对象转换成可打印字符串
- tuple(x) 函数把序列对象转换成tuple
- type(x) 可以接收任何东西作为参数――并返回它的数据类型。整型、字符串、列表、字典、元组、函数、类、模块,甚至类型对象都可以作为参数被 type 函数接受
abs()函数:取绝对值
- print(abs(-1.2))
all()函数与any函数:
all(iterable):如果iterable的任意一个元素为0、”、False,则返回False,否则返回True
- print(all([‘a’,‘b’,‘c’,‘d’]))#True
- print(all([‘a’,‘b’,”,‘d’]))#False
- #注意:空元组、空列表返回值为True,这里要特别注意
- print(any([‘a’,‘b’,‘c’,‘d’]))#True
- print(any([‘a’,0,‘ ‘,False]))#True
- print(any([0,”,False]))#False
ascii(object) 函数:
返回一个可打印的对象字符串方式表示,如果是非ascii字符就会输出\x,\u或\U等字符来表示。与python2版本里的repr()是等效的函数。
- print(ascii(1))
- print(ascii(‘a’))
- print(ascii(123))
- print(ascii(‘中文’))#非ascii字符
- ##########################################
- 1
- ‘a’
- 123
- ‘\u4e2d\u6587’
lambda表达式:
学习条件运算时,对于简单的 if else 语句,可以使用三元运算来表示,即:
- # 普通条件语句
- if 1 == 1:
- name = ‘poe’
- else:
- name = ‘bruce’
- # 三元运算
- name = ‘poe’ if 1 == 1 else ‘bruce’
对于简单的函数,也存在一种简便的表示方式,即:lambda表达式
- # ###################### 普通函数 ######################
- # 定义函数(普通方式)
- def func(arg):
- return arg + 1
- # 执行函数
- result = func(123)
- # ###################### lambda ######################
- # 定义函数(lambda表达式)
- my_lambda = lambda arg : arg + 1
- # 执行函数
- result = my_lambda(123)
生成随机数:
- import random
- chars = ”
- for i in range(4) :
- rand_num = random.randrange(0,4)
- if rand_num == 3 or rand_num == 1:
- rand_digit = random.randrange(0,10)
- chars += str(rand_digit)
- else:
- rand_case = random.randrange(65,90)
- case = chr(rand_case)
- chars += case
- print(chars)
filter函数
filter()函数是 Python 内置的另一个有用的高阶函数,filter()函数接收一个函数 f 和一个list,这个函数 f 的作用是对每个元素进行判断,返回 True或 False,filter()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list。
例1,要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数,保留奇数,首先,要编写一个判断奇数的函数:
- # filter(fn,iterable)
- def is_odd(x) :
- return x % 2 == 1
- li = [1, 4, 6, 7, 9, 12, 17]
- result = filter(is_odd,li)
- print(result)
- ##########################################
- [1, 7, 9, 17]
例2:删除 列表中的None 或者空字符串
- li = [‘test’, None, ”, ‘str’, ‘ ‘, ‘END’]
- def is_not_empty(s) :
- return s and len(s.strip()) > 0
- print(filter(is_not_empty,li))
- ##########################################
- [‘test’, ‘str’, ‘END’]
例3:请利用filter()过滤出1~100中平方根是整数的数,即结果应该是:[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
- import math
- def is_sqr(x) :
- return math.sqrt(x) % 1 == 0
- print filter(is_sqr,range(1,101))
以上三个函数都可以使用lambda表达式的写法来书写,如:
- result = filter(lambda x : x % 2 == 1,[1,4,6,9,12,7,17])
- print(result)
map()函数
map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回
例如,对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]如果希望把list的每个元素都作平方,就可以用map()函数
- li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
- print(li)
- def f(x) :
- return x*x
- r = list(map(f,[1, 2, 3, 4, 5, 6, 7, 8, 9]))
- print(r)
注:在python3里面,map()的返回值已经不再是list,而是iterators, 所以想要使用,只用将iterator 转换成list 即可, 比如 list(map()) 。
进制转换函数(以下四个函数可以实现各进制间的互相转换)
bin(x) :将整数x转换为二进制字符串,如果x不为Python中int类型,x必须包含方法__index__()并且返回值为integer
oct(x):将一个整数转换成8进制字符串。如果传入浮点数或者字符串均会报错
hex(x):将一个整数转换成16进制字符串。
int():
- 传入数值时,调用其__int__()方法,浮点数将向下取整
-
- print(int(3))#
- print(int(3.6))#
- 传入字符串时,默认以10进制进行转换
-
- print(int(”))#
- 字符串中允许包含”+”、”-“号,但是加减号与数值间不能有空格,数值后、符号前可出现空格
-
- print(int(‘+36’))#
- 传入字符串,并指定了进制,则按对应进制将字符串转换成10进制整数
-
- print(int(”,2))#
- print(int(‘0o7’,8))#
- print(int(‘0x15’,16))#
open函数,该函数用于文件处理
操作文件时,一般需要经历如下步骤:
- 打开文件
- 操作文件
一:打开文件
- 文件句柄 = open(‘文件路径’, ‘模式’)
打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作。
打开文件的模式有:
- r ,只读模式【默认】
- w,只写模式【不可读;不存在则创建;存在则清空内容;】
- x, 只写模式【不可读;不存在则创建,存在则报错】
- a, 追加模式【可读; 不存在则创建;存在则只追加内容;】
- f = open(‘test.log’,‘r’)
- data = f.read()
- f.close()
- print(data)
“+” 表示可以同时读写某个文件
- r+, 读写【可读,可写】
- w+,写读【可读,可写】
- x+ ,写读【可读,可写】
- a+, 写读【可读,可写】
- # r+ 模式
- f = open(‘test.log’,‘r+’,encoding=‘utf-8’)
- print(f.tell())#打印当前指针所在的位置,此时为0
- data = f.read()
- print(data)
- print(f.tell())#此时当前指针在文件最末尾
- f.close()
- # w+模式:先清空文件,再写入文件,写入文件后才可以读文件
- f = open(‘test.log’,‘w+’,encoding=“utf-8”)
- f.write(‘python’)#写完后,指针到了最后
- f.seek(0)#移动指针到开头
- data = f.read()
- f.close()
- print(data)
- # a+模式:打开的同时,指针已经到最后,
- # 写时,追加,指针到最后
- f = open(‘test.log’,‘a+’,encoding=“utf-8”)
- print(f.tell())#读取当前指针位置,此时指针已经到最后
- f.write(‘c++’)
- print(f.tell())
- #此时要读文件必须把指针移动到文件开头
- f.seek(0)
- data = f.read();
- print(data)
- f.close()
“b”表示以字节的方式操作
- rb 或 r+b
- wb 或 w+b
- xb 或 w+b
- ab 或 a+b
注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型
二:文件操作
- class file(object)
- def close(self): # real signature unknown; restored from __doc__
- 关闭文件
- “””
- close() -> None or (perhaps) an integer. Close the file.
- Sets data attribute .closed to True. A closed file cannot be used for
- further I/O operations. close() may be called more than once without
- error. Some kinds of file objects (for example, opened by popen())
- may return an exit status upon closing.
- “””
- def fileno(self): # real signature unknown; restored from __doc__
- 文件描述符
- “””
- fileno() -> integer “file descriptor“.
- This is needed for lower-level file interfaces, such os.read().
- “””
- return 0
- def flush(self): # real signature unknown; restored from __doc__
- 刷新文件内部缓冲区
- “”” flush() -> None. Flush the internal I/O buffer. “””
- pass
- def isatty(self): # real signature unknown; restored from __doc__
- 判断文件是否是同意tty设备
- “”” isatty() -> true or false. True if the file is connected to a tty device. “””
- return False
- def next(self): # real signature unknown; restored from __doc__
- 获取下一行数据,不存在,则报错
- “”” x.next() -> the next value, or raise StopIteration “””
- pass
- def read(self, size=None): # real signature unknown; restored from __doc__
- 读取指定字节数据
- “””
- read([size]) -> read at most size bytes, returned as a string.
- If the size argument is negative or omitted, read until EOF is reached.
- Notice that when in non-blocking mode, less data than what was requested
- may be returned, even if no size parameter was given.
- “””
- pass
- def readinto(self): # real signature unknown; restored from __doc__
- 读取到缓冲区,不要用,将被遗弃
- “”” readinto() -> Undocumented. Don’t use this; it may go away. “””
- pass
- def readline(self, size=None): # real signature unknown; restored from __doc__
- 仅读取一行数据
- “””
- readline([size]) -> next line from the file, as a string.
- Retain newline. A non-negative size argument limits the maximum
- number of bytes to return (an incomplete line may be returned then).
- Return an empty string at EOF.
- “””
- pass
- def readlines(self, size=None): # real signature unknown; restored from __doc__
- 读取所有数据,并根据换行保存值列表
- “””
- readlines([size]) -> list of strings, each a line from the file.
- Call readline() repeatedly and return a list of the lines so read.
- The optional size argument, if given, is an approximate bound on the
- total number of bytes in the lines returned.
- “””
- return []
- def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
- 指定文件中指针位置
- “””
- seek(offset[, whence]) -> None. Move to new file position.
- Argument offset is a byte count. Optional argument whence defaults to
- (offset from start of file, offset should be >= 0); other values are 1
- (move relative to current position, positive or negative), and 2 (move
- relative to end of file, usually negative, although many platforms allow
- seeking beyond the end of a file). If the file is opened in text mode,
- only offsets returned by tell() are legal. Use of other offsets causes
- undefined behavior.
- Note that not all file objects are seekable.
- “””
- pass
- def tell(self): # real signature unknown; restored from __doc__
- 获取当前指针位置
- “”” tell() -> current file position, an integer (may be a long integer). “””
- pass
- def truncate(self, size=None): # real signature unknown; restored from __doc__
- 截断数据,仅保留指定之前数据
- “””
- truncate([size]) -> None. Truncate the file to at most size bytes.
- Size defaults to the current file position, as returned by tell().
- “””
- pass
- def write(self, p_str): # real signature unknown; restored from __doc__
- 写内容
- “””
- write(str) -> None. Write string str to file.
- Note that due to buffering, flush() or close() may be needed before
- the file on disk reflects the data written.
- “””
- pass
- def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
- 将一个字符串列表写入文件
- “””
- writelines(sequence_of_strings) -> None. Write the strings to the file.
- Note that newlines are not added. The sequence can be any iterable object
- producing strings. This is equivalent to calling write() for each string.
- “””
- pass
- def xreadlines(self): # real signature unknown; restored from __doc__
- 可用于逐行读取文件,非全部
- “””
- xreadlines() -> returns self.
- For backward compatibility. File objects now include the performance
- optimizations previously implemented in the xreadlines module.
- “””
- pass
- 2.x
2.x版本
- class TextIOWrapper(_TextIOBase):
- “””
- Character and line based layer over a BufferedIOBase object, buffer.
- encoding gives the name of the encoding that the stream will be
- decoded or encoded with. It defaults to locale.getpreferredencoding(False).
- errors determines the strictness of encoding and decoding (see
- help(codecs.Codec) or the documentation for codecs.register) and
- defaults to “strict“.
- newline controls how line endings are handled. It can be None, ”,
- ‘\n’, ‘\r’, and ‘\r\n’. It works as follows:
- * On input, if newline is None, universal newlines mode is
- enabled. Lines in the input can end in ‘\n’, ‘\r’, or ‘\r\n’, and
- these are translated into ‘\n’ before being returned to the
- caller. If it is ”, universal newline mode is enabled, but line
- endings are returned to the caller untranslated. If it has any of
- the other legal values, input lines are only terminated by the given
- string, and the line ending is returned to the caller untranslated.
- * On output, if newline is None, any ‘\n’ characters written are
- translated to the system default line separator, os.linesep. If
- newline is ” or ‘\n’, no translation takes place. If newline is any
- of the other legal values, any ‘\n’ characters written are translated
- to the given string.
- If line_buffering is True, a call to flush is implied when a call to
- write contains a newline character.
- “””
- def close(self, *args, **kwargs): # real signature unknown
- 关闭文件
- pass
- def fileno(self, *args, **kwargs): # real signature unknown
- 文件描述符
- pass
- def flush(self, *args, **kwargs): # real signature unknown
- 刷新文件内部缓冲区
- pass
- def isatty(self, *args, **kwargs): # real signature unknown
- 判断文件是否是同意tty设备
- pass
- def read(self, *args, **kwargs): # real signature unknown
- 读取指定字节数据
- pass
- def readable(self, *args, **kwargs): # real signature unknown
- 是否可读
- pass
- def readline(self, *args, **kwargs): # real signature unknown
- 仅读取一行数据
- pass
- def seek(self, *args, **kwargs): # real signature unknown
- 指定文件中指针位置
- pass
- def seekable(self, *args, **kwargs): # real signature unknown
- 指针是否可操作
- pass
- def tell(self, *args, **kwargs): # real signature unknown
- 获取指针位置
- pass
- def truncate(self, *args, **kwargs): # real signature unknown
- 截断数据,仅保留指定之前数据
- pass
- def writable(self, *args, **kwargs): # real signature unknown
- 是否可写
- pass
- def write(self, *args, **kwargs): # real signature unknown
- 写内容
- pass
- def __getstate__(self, *args, **kwargs): # real signature unknown
- pass
- def __init__(self, *args, **kwargs): # real signature unknown
- pass
- @staticmethod # known case of __new__
- def __new__(*args, **kwargs): # real signature unknown
- “”” Create and return a new object. See help(type) for accurate signature. “””
- pass
- def __next__(self, *args, **kwargs): # real signature unknown
- “”” Implement next(self). “””
- pass
- def __repr__(self, *args, **kwargs): # real signature unknown
- “”” Return repr(self). “””
- pass
- buffer = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- encoding = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
- 3.x
3.x版本
三:管理上下文
为了避免打开文件后忘记关闭,可以通过管理上下文,即:
- with open(‘log’,‘r’) as f:
- …
如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。
在Python 2.7 及以后,with又支持同时对多个文件的上下文进行管理,即:
- with open(‘log1’) as obj1, open(‘log2’) as obj2:
- pass
可使用此方法对一个文件进行读操作,同时把数据又写入到另一个打开的文件中!
read()、readline() 和 readlines()
每种方法可以接受一个变量以限制每次读取的数据量,但它们通常不使用变量。 .read() 每次读取整个文件,它通常用于将文件内容放到一个字符串变量中。然而 .read() 生成文件内容最直接的字符串表示,但对于连续的面向行的处理,它却是不必要的,并且如果文件大于可用内存,则不可能实现这种处理。
.readline() 和 .readlines() 非常相似。它们都在类似于以下的结构中使用:
- fh = open(‘c:\\autoexec.bat’)
- for line in fh.readlines():
- print line
.readline() 和 .readlines() 之间的差异是后者一次读取整个文件,象 .read() 一样。.readlines() 自动将文件内容分析成一个行的列表,该列表可以由 Python 的 for … in … 结构进行处理。另一方面,.readline() 每次只读取一行,通常比 .readlines() 慢得多。仅当没有足够内存可以一次读取整个文件时,才应该使用 .readline()。
练习题:用户名与密码的验证
首先新建一个文件,这里为test.log文件,内容为两行如下:
- admin$123
- ginvip$123456
1:让用户选择1或2,1为登录,2为注册
2:如果用户选择1,用户输入用户名与密码,然后与test.log文件中的用户名与密码进行验证,验证成功输出“登录成功”,否则“登录失败”
3:如果用户选择2,让用户输入用户名与密码,并与test.log文件中的用户名验证,如果test.log中用户名已经存在,则输出“该用户名已经存在”,否则将用户输入的用户与密码以上面test.log文件中的形式写入test.log文件中
- def check_user(user) :
- with open(‘test.log’,‘r’,encoding=‘utf-8’) as f :
- for line in f :
- user_list = line.strip()
- user_list = user_list.split(‘$’)
- if user == user_list[0] :
- return True
- return False
- def register(user,pwd) :
- with open(‘test.log’,‘a’,encoding=‘utf-8’) as f :
- user_info = ‘\n’ + user + ‘$’ + pwd
- if f.write(user_info) :
- return True
- return False
- def login(user,pwd) :
- with open(‘test.log’,‘r’,encoding=‘utf-8’) as f :
- for line in f:
- user_list = line.strip()
- user_list = user_list.split(‘$’)
- if user == user_list[0] and pwd == user_list[1]:
- return True
- return False
- def main() :
- print(‘welcome to my website’)
- choice = input(‘1:login 2:register’)
- if choice == ”:
- user = input(‘input username :’)
- pwd = input(‘input password : ‘)
- if check_user(user) :
- print(‘the username is exist’)
- else:
- if register(user,pwd) :
- print(‘register success’)
- else:
- print(‘register failed’)
- elif choice == ”:
- user = input(‘input username :’)
- pwd = input(‘input password : ‘)
- if login(user,pwd) :
- print(‘login success’)
- else:
- print(‘login failed’)
- main()
冒泡排序
冒泡排序的原理:
- def Bubble_sort(args) :
- for i in range(len(args)-1) :
- for j in range(len(args) –1):
- if args[j] > args[j+1]:
- temp = args[j]
- args[j] = args[j+1]
- args[j+1] = temp
- return args
- li = [33,2,10,1,9,3,8]
- print(Bubble_sort(li))
练习题
1、简述普通参数、指定参数、默认参数、动态参数的区别
2、写函数,计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
- digit = 0
- case = 0
- space = 0
- other = 0
- def func2(s) :
- global digit,case,space,other
- if not isinstance(s,basestring) :
- print(‘the data type wrong!’)
- return False
- for i in s :
- if i.isdigit() :
- digit += 1
- elif i.isalpha() :
- case += 1
- elif i.isspace() :
- space += 1
- else:
- other += 1
- s = ‘I love python , is num 1 , o_k’
- a = [1,2,3]
- func2(s)
- print(digit)
- print(case)
- print(space)
- print(other)
- ########################################
- 1
- 18
- 8
- 3
- 问题:判断是不是字符串后直接退出函数,而不执行下面的代码?
第2题答案
3、写函数,判断用户传入的对象(字符串、列表、元组)长度是否大于5。
- def func3(v) :
- if len(v) > 5 :
- return True
- else:
- return False
- a = ‘I love python , is num 1 , o_k’
- l = [1,2,3]
- t = (5,7,9,10,45,10)
- print(func3(t))
第三题答案
4、写函数,检查用户传入的对象(字符串、列表、元组)的每一个元素是否含有空内容。
5、写函数,检查传入列表的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者。
- def func5(lis) :
- if len(lis) > 2 :
- return lis[0:2]
- else :
- return False
- li = [1,2,3]
- print(func5(li))
- ##########################################
- [1, 2]
第五题答案
6、写函数,检查获取传入列表或元组对象的所有奇数位索引对应的元素,并将其作为新列表返回给调用者。
- def func6(lis) :
- new_lis = []
- for k in range(len(lis)) :
- if k % 2 == 1 :
- new_lis.append(lis[k])
- return new_lis
- li = [1,2,3,8,10,44,77]
- tu = (‘poe’,‘andy’,‘jet’,‘bruce’,‘jacky’)
- print(func6(tu))
- ##########################################
- [‘andy’, ‘bruce’]
第六题答案
7、写函数,检查传入字典的每一个value的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者。
- dic = {“k1”: “v1v1”, “k2”: [,,,]}
- PS:字典中的value只能是字符串或列表
- def func7(d) :
- v = d.values()
- li = []
- for i in v :
- if len(i) > 2:
- li.append(i[0:2])
- return li
- print(func7(dic))
- ##########################################
- [[11, 22], ‘v1’]
第七题答案
8、写函数,利用递归获取斐波那契数列中的第 10 个数,并将该值返回给调用者
- def fabonacci(n) :
- if n == 0 :
- return 0
- elif n == 1:
- return 1
- else:
- return fabonacci(n–1) + fabonacci(n–2)
- print(fabonacci(10))
神龙|纯净稳定代理IP免费测试>>>>>>>>天启|企业级代理IP免费测试>>>>>>>>IPIPGO|全球住宅代理IP免费测试