Go语言的行列和货仓完结方式,Python规范库之collections包的应用教程

By admin in 4858.com on 2019年6月29日

golang,其实本人的落实是应用container/list包达成的,其实container/list包不小个大.

正文实例陈说了Go语言的体系和储藏室完成方式。分享给我们供大家参照他事他说加以考查。具体如下:

本身是后面一个出身,写那些推断是还是不是存在恐怕是去重的点子,前端js基本上有好各种主意,然而一般都有一些麻烦。

Python标准库之collections包的应用教程,pythoncollections

前言

Python为大家提供了4种为主的数据结构:list, tuple, dict,
set,但是在拍卖数据量十分大的图景的时候,那4种数据结构就明显过于单一了,例如list作为数组在一些意况插入的频率会十分的低,一时候大家也要求爱护贰个稳步的dict。所以今年我们就要采用Python标准库为大家提供的collections包了,它提供了两个有效的集合类,纯熟明白那个集结类,不只能够让大家让写出的代码尤其Pythonic,也得以增长我们先后的周转成效。

defaultdict

defaultdict(default_factory)在一般的dict之上增多了default_factory,使得key不设临时会自动生成相应项目的value,default_factory参数能够内定成list,
set, int等种种合法类型。

大家今后有下边那样一组list,固然我们有5组数据,可是稳重察看后意识实际上我们只有3种color,可是各个color对应七个值。现在大家想要将以此list转变到一个dict,那几个dict的key对应一种color,dict的value设置为一个list存放color对应的多少个值。大家能够利用defaultdict(list)来消除这一个主题材料。

>>> from collections import defaultdict
>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...  d[k].append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

如上等价于:

>>> d = {}
>>> for k, v in s:
...  d.setdefault(k, []).append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

假定我们不期待含有重复的因素,能够设想动用defaultdict(set)
。set相比list的不相同之处在于set中不一样意存在同样的因素。

>>> from collections import defaultdict
>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(set)
>>> for k, v in s:
...  d[k].add(v)
...
>>> sorted(d.items())
[('blue', {2, 4}), ('red', {1, 3})]

OrderedDict

Python3.6此前的dict是严节的,可是在少数意况大家必要有限支撑dict的有序性,那个时候能够利用OrderedDict,它是dict的二个subclass,不过在dict的基础上保持了dict的有序型,下边大家来看一下用到情势。

>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
>>> # dictionary sorted by key
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
>>> # dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])
>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

使用popitem(last=True)措施可以让我们遵照LIFO(先进后出)的逐个删除dict中的key-value,即除去最终一个插入的键值对,要是last=False就依据FIFO(先进先出)删除dict中key-value。

>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
>>> # dictionary sorted by key
>>> d = OrderedDict(sorted(d.items(), key=lambda t: t[0]))
>>> d
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
>>> d.popitem()
('pear', 1)
>>> d.popitem(last=False)
('apple', 4)

使用move_to_end(key, last=True)来改换有序的OrderedDict对象的key-value顺序,通过这几个办法我们得以将排序好的OrderedDict对象中的任意叁个key-value插入到字典的上马只怕结尾。

>>> d = OrderedDict.fromkeys('abcde')
>>> d
OrderedDict([('a', None), ('b', None), ('c', None), ('d', None), ('e', None)])
>>> d.move_to_end('b')
>>> d
OrderedDict([('a', None), ('c', None), ('d', None), ('e', None), ('b', None)])
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

deque

list存款和储蓄数据的优势在于按索引查找成分会非常快,可是插入和删除成分就非常慢了,因为list是依据数组达成的。deque是为了赶快落实插入和删除操作的双向列表,适合用来队列和栈,而且线程安全。

4858.com,list只提供了append和pop方法来从list的尾巴插入/删除成分,deque新增添了appendleft/popleft等艺术允许我们飞快的在要素的起来来插入/删除成分。而且使用deque在队列两端append或pop元素的算法复杂度大约是O(1),不过对于list对象改变列表长度和数据地点的操作举例
pop(0)insert(0, v)操作的复杂度高达O(n)。

>>> from collections import deque
>>> dq = deque(range(10), maxlen=10)
>>> dq
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
>>> dq.rotate(3)
>>> dq
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
>>> dq.rotate(-4)
>>> dq
deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)
>>> dq.appendleft(-1)
>>> dq
deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
>>> dq.extend([11, 22, 33])
>>> dq
deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)
>>> dq.extendleft([10, 20, 30, 40])
>>> dq
deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)

Counter

Count用来计算有关因素的面世次数。

>>> from collections import Counter
>>> ct = Counter('abracadabra')
>>> ct
Counter({'a': 5, 'r': 2, 'b': 2, 'd': 1, 'c': 1})
>>> ct.update('aaaaazzz')
>>> ct
Counter({'a': 10, 'z': 3, 'r': 2, 'b': 2, 'd': 1, 'c': 1})
>>> ct.most_common(2)
[('a', 10), ('z', 3)]
>>> ct.elements()
<itertools.chain object at 0x7fbaad4b44e0>

namedtuple

使用namedtuple(typename, field_names)Go语言的行列和货仓完结方式,Python规范库之collections包的应用教程。命名tuple中的成分来使程序更具可读性。

>>> from collections import namedtuple
>>> City = namedtuple('City', 'name country population coordinates')
>>> tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))
>>> tokyo
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))
>>> tokyo.population
36.933
>>> tokyo.coordinates
(35.689722, 139.691667)
>>> tokyo[1]
'JP'

>>> City._fields
('name', 'country', 'population', 'coordinates')
>>> LatLong = namedtuple('LatLong', 'lat long')
>>> delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))
>>> delhi = City._make(delhi_data)
>>> delhi._asdict()
OrderedDict([('name', 'Delhi NCR'), ('country', 'IN'), ('population', 21.935),
   ('coordinates', LatLong(lat=28.613889, long=77.208889))])
>>> for key, value in delhi._asdict().items():
  print(key + ':', value)
name: Delhi NCR
country: IN
population: 21.935
coordinates: LatLong(lat=28.613889, long=77.208889)

ChainMap

ChainMap能够用来统一三个字典。

>>> from collections import ChainMap
>>> d = ChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})
>>> d['lion'] = 'orange'
>>> d['snake'] = 'red'
>>> d
ChainMap({'lion': 'orange', 'zebra': 'black', 'snake': 'red'},
   {'elephant': 'blue'}, {'lion': 'yellow'})

>>> del d['lion']
>>> del d['elephant']
Traceback (most recent call last):
 File "/usr/lib/python3.5/collections/__init__.py", line 929, in __delitem__
 del self.maps[0][key]
KeyError: 'elephant'
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 File "/usr/lib/python3.5/collections/__init__.py", line 931, in __delitem__
 raise KeyError('Key not found in the first mapping: {!r}'.format(key))
KeyError: "Key not found in the first mapping: 'elephant'"

从上面del['elephant']的报错消息可以看出来,对于更换键值的操作ChainMap只会在首先个字典self.maps[0][key]进展搜寻,新扩展的键值对也都会进入第一个字典,我们来改进一下ChainMap化解那么些难题:

class DeepChainMap(ChainMap):
 'Variant of ChainMap that allows direct updates to inner scopes'
 def __setitem__(self, key, value):
  for mapping in self.maps:
   if key in mapping:
    mapping[key] = value
    return
  self.maps[0][key] = value
 def __delitem__(self, key):
  for mapping in self.maps:
   if key in mapping:
    del mapping[key]
    return
  raise KeyError(key)
>>> d = DeepChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})
>>> d['lion'] = 'orange'   # update an existing key two levels down
>>> d['snake'] = 'red'   # new keys get added to the topmost dict
>>> del d['elephant']   # remove an existing key one level down
DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})

能够运用new_child来deepcopy一个ChainMap:

>>> from collections import ChainMap
>>> a = {'a': 'A', 'c': 'C'}
>>> b = {'b': 'B', 'c': 'D'}
>>> m = ChainMap({'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
>>> m
ChainMap({'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
>>> m['c']
'C'
>>> m.maps
[{'c': 'C', 'a': 'A'}, {'c': 'D', 'b': 'B'}]
>>> a['c'] = 'E'
>>> m['c']
'E'
>>> m
ChainMap({'c': 'E', 'a': 'A'}, {'c': 'D', 'b': 'B'})

>>> m2 = m.new_child()
>>> m2['c'] = 'f'
>>> m2
ChainMap({'c': 'f'}, {'c': 'E', 'a': 'A'}, {'c': 'D', 'b': 'B'})
>>> m
ChainMap({'c': 'E', 'a': 'A'}, {'c': 'D', 'b': 'B'})
>>> m2.parents
ChainMap({'c': 'E', 'a': 'A'}, {'c': 'D', 'b': 'B'})

UserDict

上边大家来革新一下字典,查询字典的时候将key调换为str的款型:

class StrKeyDict0(dict):
 def __missing__(self, key):
  if isinstance(key, str):
   raise KeyError(key)
  return self[str(key)]
 def get(self, key, default=None):
  try:
   return self[key]
  except KeyError:
   return default
 def __contains__(self, key):
  return key in self.keys() or str(key) in self.keys()

解释一下下边这段程序:

  • 在__missing__中isinstance(key,
    str)是必要求的,请思量一下怎么?
    因为若是三个key不存在的话,那会产生infinite
    recursion,self[str(key)]会再也调用__getitem__。
  • __contains__也是必须完成的,因为k in
    d的时候会实行调用,但是注意就算查找未果它也不会调用__missing__。关于__contains__再有五个细节正是:大家并从未选取k in my_dict,因为str(key) in self的情势,因为这会形成递归调用__contains__。

那边还重申一点,在Python2.x中dict.keys()会重回贰个list,那代表k in
my_list必须遍历list。在Python3.x中针对dict.keys()做了优化,品质越来越高,它会回来三个view仿佛set同样,详细情况参见官方文书档案。

下面这么些例子能够用UserDict改写,并且将富有的key都是str的情势累积,而且这种写法尤其常用简洁:

import collections
class StrKeyDict(collections.UserDict):
 def __missing__(self, key):
  if isinstance(key, str):
   raise KeyError(key)
  return self[str(key)]
 def __contains__(self, key):
  return str(key) in self.data
 def __setitem__(self, key, item):
  self.data[str(key)] = item

UserDict是MutableMapping和Mapping的子类,它继续了MutableMapping.update和Mapping.get八个首要的秘籍,所以地方我们并未重写get方法,能够在源码中看到它的达成和大家地点的兑现是基本上的。

总结

如上就是这篇著作的全体内容了,希望本文的开始和结果对大家学习只怕办事能带来一定的佑助,假如有毛病咱们能够留言交流,谢谢大家对帮客之家的支撑。

前言 Python为大家提供了4种基本的数据结构:list, tuple, dict,
set,可是在拍卖数据量不小…

package main

import (
    "fmt"
    "container/list"
)

func main() {
    // 生成队列
    l := list.New()

    // 入队, 压栈
    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)
    l.PushBack(4)

    // 出队
    i1 := l.Front()
    l.Remove(i1)
    fmt.Printf("%d\n", i1.Value)

    // 出栈
    i4 := l.Back()
    l.Remove(i4)
    fmt.Printf("%d\n", i1.Value)
}

golang,其实笔者的兑现是选用container/list包实现的,其实container/list包很庞大.

js与Java其实也大差不差,只要思路正确,只是实现的代码区别而已。

复制代码 代码如下:

开场小编想的是透过双层for循环,但一般依然某个费力,查工具书开采,Java中的数组有个办法可以用来剖断是不是存在。

package main
import (
    “fmt”
    “container/list”
)
func main() {
    // 生成队列
    l := list.New()
    // 入队, 压栈
    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)
    l.PushBack(4)
    // 出队
    i1 := l.Front()
    l.Remove(i1)
    fmt.Printf(“%d\n”, i1.Value)
    // 出栈
    i4 := l.Back()
    l.Remove(i4)
    fmt.Printf(“%d\n”, i1.Value)
}

将数组调换到 list集合,然后采纳 contains 方法。

  • 先是记住导入相应的包:

// 导入Arrays类的Java语句:
import java.util.Arrays;
  • 行使示举例下:

boolean isContains = Arrays.asList(数组).contains(包含项);
// 再次回到值是true/false

写个简单的板栗把:

// 记得在最上面导入Arrays包
import java.util.Arrays;


String[] fruits = {"apple", "banana", "xxx"};
String iLikeEat = "apple";
boolean isContains = Arrays.asList(fruits).contains(iLikeEat);
if(isContains){
      // 这里有你要吃的水果
}else{
     // 你到别出在看看把
}

String[] tenantDir = new String[resultList.size()];
                        for(int i = 0; i < resultList.size(); i++){
                            String moreCustomerId = resultList.get(i).getCustomerId();
                            sqlQueryUser = " " + "a.ENTERPRIZE_CODE" + "="  + moreCustomerId;
                            detail_url ="http://10.70.50.35:8080/ecmp-portal-core/console/views/notice2.html?nid="+ noticeId +"%26customerId="+moreCustomerId;

                            Map queryTenantDirector = new HashMap();
                            queryTenantDirector.put("customerId", moreCustomerId);
                            List<SINT01> allTenantDirectorList = dao.query("SINT01.queryTenantDirector", queryTenantDirector);

                            // 单独租户id下的用户
                            Map queryUserMap = new HashMap();
                            queryUserMap.put("sqlQueryUser", sqlQueryUser);
                            List<SINT01> allCustomerList = dao.query("SINT01.queryAllUser", queryUserMap);


                            if(allTenantDirectorList.size() > 0){
                                boolean isContains = Arrays.asList(tenantDir).contains(allTenantDirectorList.get(0).getTenantDirector());   
                                tenantDir[i] = allTenantDirectorList.get(0).getTenantDirector();
                                if(isContains){
                                    int num = allCustomerList.size();
                                    String[] customerName = new String[num];    
                                    if(null!=allCustomerList && allCustomerList.size()>0){              
                                        for(int k= 0; k < allCustomerList.size(); k++){
                                            customerName[k] = allCustomerList.get(k).getCustomerId();
                                        }
                                    }
//                                  String[] userIdTest = {"178256"};
//                                  try {
//                                      WeiXinMessageManager template = new WeiXinMessageManager("bgcloud");
//                                      template.getInstance().sendTemplate(userIdTest, templateId, detail_url,
//                                              contentStr);
//                                  } catch (Exception e) {
//                                      e.printStackTrace();
//                                  }

                                }else{
                                    int num = allCustomerList.size()+1;
                                    String[] customerName = new String[num];    
                                    if(null!=allCustomerList && allCustomerList.size()>0){              
                                        for(int k= 0; k < allCustomerList.size(); k++){
                                            customerName[k] = allCustomerList.get(k).getCustomerId();
                                        }
                                    customerName[num-1] = allTenantDirectorList.get(0).getTenantDirector();
                                    }
//                                  String[] userIdTest = {"178256"};
//                                  try {
//                                      WeiXinMessageManager template = new WeiXinMessageManager("bgcloud");
//                                      template.getInstance().sendTemplate(userIdTest, templateId, detail_url,
//                                              contentStr);
//                                  } catch (Exception e) {
//                                      e.printStackTrace();
//                                  }

                                }
                            }else{
                                int num = allCustomerList.size();
                                String[] customerName = new String[num];    
                                if(null!=allCustomerList && allCustomerList.size()>0){              
                                    for(int k= 0; k < allCustomerList.size(); k++){
                                        customerName[k] = allCustomerList.get(k).getCustomerId();
                                    }
                                }
//                              String[] userIdTest = {"178256"};
//                              try {
//                                  WeiXinMessageManager template = new WeiXinMessageManager("bgcloud");
//                                  template.getInstance().sendTemplate(userIdTest, templateId, detail_url,
//                                          contentStr);
//                              } catch (Exception e) {
//                                  e.printStackTrace();
//                              }
                            }                   

                        }

愿意本文所述对我们的Go语言程序设计具备帮忙。

另一种做法:通过下标

String[] colors= {"red",  "green",  "blue", "....."};
String myPhone = "black";
int index = Arrays.binarySearch(colors, myPhone) ;
if("-1".equals(index)){
        //  不存在!
}else{
      // 有这个色的
}

你也许感兴趣的稿子:

  • Go语言用map达成货仓功效的法门
  • Python记录详细调用货仓日志的艺术
  • go
    代码的调护治疗—打字与印刷调用仓库的实例

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有