该例子计算strings中有个别单词出现的次数,总括

2019-08-31 作者:编程   |   浏览(195)

Python数据剖判之双色球计算单个红和蓝球哪个比例高的格局,python数据剖析

本文实例陈说了Python数据深入分析之双色球总计单个红和蓝球哪个比例高的艺术。分享给大家供大家参照他事他说加以考察,具体如下:

总括单个红球和蓝球,哪个组合最多,展现前19组多少

#!/usr/bin/python
# -*- coding:UTF-8 -*-
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import operator
df = pd.read_table('newdata.txt',header=None,sep=',')
tdate = sorted(df.loc[:,0])
# print tdate
h1 = df.loc[:,1:7:6].values  #取第一列红球和蓝球
# print h1
h2 = df.loc[:,2:7:5].values  #取第二列红球和蓝球
h3 = df.loc[:,3:7:4].values
h4 = df.loc[:,4:7:3].values
h5 = df.loc[:,5:7:2].values
h6 = df.loc[:,6:7:1].values
# tblue = df.loc[:,7]
#将上方切分的所有数据组合到一起
data = np.append(h1, h2, axis = 0)
data = np.append(data, h3, axis = 0)
data = np.append(data, h4, axis = 0)
data = np.append(data, h5, axis = 0)
data = np.append(data, h6, axis = 0)
# print data
data1 = pd.DataFrame(data)
# print data1
#写入到一个文件中
data1.to_csv('hldata.csv',index=None,header=None)
#读取文件,将组合进行统计并从大到小排序
f = open("hldata.csv")
count_dict = {}
for line in f.readlines():
  line = line.strip()
  count = count_dict.setdefault(line, 0)
  count  = 1
  count_dict[line] = count
sorted_count_dict = sorted(count_dict.iteritems(), key=operator.itemgetter(1), reverse=True)
# for item in sorted_count_dict:
#   print "%s,%d" % (item[0], item[1])
# print sorted_count_dict
fenzu = pd.DataFrame(sorted_count_dict).set_index([0])
#print fenzu
#分别从第一列和第二列取前19个数据放到x y中
x = list(fenzu.index[:19])
y = list(fenzu.values[:19])
print x
print y
#将x对应数值,不然画图报错
s = pd.Series(range(1,len(x) 1), index=x)
#设置画图属性
plt.figure(figsize=(12,6),dpi=80)
plt.legend(loc='best')
# plt.plot(fenzu,color='red')
plt.bar(s,y,alpha=.5, color='r',width=0.8)
plt.title('The one red and one blue ball number')
plt.xlabel('one red and one blue number')
plt.ylabel('times')
#可以在图中放置标签字符
# for i in range(0,19):
#   plt.text(int(i 1.4),25,x[i],color='b',size=10)
# plt.text(1.4,20,x[0],color='g',ha='center')
#将['1,12', '26,9', '5,13']这样的字符放到图中
plt.xticks(s,x, rotation=10,size=10,ha='left')
plt.show()

结果如下:

图片 1

能够见见红球1和蓝球12出现过的次数最多,其次是红球26和蓝球9

参考:

import matplotlib.pyplot as plt
import numpy as np
plt.rc('font', family='SimHei', size=13)
num = np.array([13325, 9403, 9227, 8651])
ratio = np.array([0.75, 0.76, 0.72, 0.75])
men = num * ratio
women = num * (1-ratio)
x = ['聊天','支付','团购n优惠券','在线视频']
width = 0.5
idx = np.arange(len(x))
plt.bar(idx, men, width, color='red', label='男性用户')
plt.bar(idx, women, width, bottom=men, color='yellow', label='女性用户')
plt.xlabel('应用类别')
plt.ylabel('男女分布')
plt.xticks(idx width/2, x, rotation=40)
plt.legend()

图片 2

更加多关于Python相关内容感兴趣的读者可查看本站专项论题:《Python数学生运动算技术计算》、《Python字符串操作能力汇总》、《Python编码操作技艺计算》、《Python数据结构与算法教程》、《Python函数使用手艺总计》、《Python入门与进级特出教程》及《Python文件与目录操作技术汇总》

企望本文所述对大家Python程序设计具备扶助。

本文实例陈说了Python数据深入分析之双色球总括单个红和蓝球哪个比...

JS设计方式之义务链情势实例详解,js设计形式实例详解

本文实例汇报了JS设计情势之任务链形式。分享给我们供大家参考,具体如下:

权利链设计格局:

在义务链格局里,很多目的由每三个目的对其下家的引用而连接起来造成一条链。央求在那一个链上传递,直到链上的某三个目的说了算拍卖此恳请。发出这几个央浼的顾客端并不知道链上的哪多少个指标最终管理这些乞请,那使得系统可以在不影响客商端的动静下动态地再一次组织和分红责任。

权利链形式涉及到的角色如下所示:

● 抽象管理者(Handler)剧中人物:定义出三个拍卖诉求的接口。假诺须求,接口能够定义 出一个方式以设定和再次回到对下家的援用。这么些剧中人物一般由一个Java抽象类可能Java接口实现。上海教室中Handler类的集聚关系交给了现实子类对下家的引用,抽象方法handleRequest()标准了子类管理央求的操作。

● 具体管理者(ConcreteHandler)角色:具体管理者接到乞请后,能够挑选将呼吁管理掉,可能将必要传给下家。由于具体处理者持有对下家的引用,因而,假使急需,具体管理者能够访谈下家。

图片 3

在JS(ES6以前)中严峻意义上是一向不extends承继概念,所以以下代码未有模拟抽象类,代码中只兑现了切实管理类.

使用处境:在八个购物超级市场,在五一做了四个活动,所以图书类商品依据购销的金额依次做出以下折扣方案,

1、购买满199元,打9折
2、购买满399元,打8折
3、购买满599元以上,打7折;

职分链链的帮助和益处:

恳请发送者只须要掌握链中的首先个节点,进而减弱了发送者和一组接收者之间的强联系。要是不选拔义务链链情势、依照当前价位客商端要精通每顶级降价消息,最终知晓具体是那一层上优惠才是适合当下价位的折扣。

function BookHandler() {
 this.calcPrice = function( price ) {
  if ( 199 > price ) {
   console.log("原价是:"  price);
  } else {
   this.successor.calcPrice( price );
  }
 }
 this.setSuccessor = function( _successor ) {
  this.successor = _successor;
 }
}
function BookCalc9Handler( _successor ) {
 this.calcPrice = function( price ) {
  if ( 199 <= price && price < 399 ) {
   console.log("原价是:"  price  ";打9折后:"   (price * 0.9));
  } else {
   this.successor.calcPrice( price );
  }
 }
 this.setSuccessor = function( _successor ) {
  this.successor = _successor;
 }
}
function BookCalc8Handler() {
 this.calcPrice = function( price ) {
  if ( 399 <= price && price < 599 ) {
   console.log("原价是:"  price  ";打8折后:"   (price * 0.8));
  } else {
   this.successor.calcPrice( price )
  }
 }
 this.setSuccessor = function( _successor ) {
  this.successor = _successor;
 }
}
function BookCalc7Handler() {
 this.calcPrice = function( price ) {
  if ( price >= 599 ) {
   console.log("原价是:"  price  ";打7折后:"   (price * 0.7));
  } else {
   this.successor.calcPrice( price )
  }
 }
 this.setSuccessor = function( _successor ) {
  this.successor = _successor;
 }
}

客户端 :

var price = 400;
var bookHandler = new BookHandler();
var bookCalc9Handler = new BookCalc9Handler();
var bookCalc8Handler = new BookCalc8Handler();
var bookCalc7Handler = new BookCalc7Handler();
bookHandler.setSuccessor(bookCalc9Handler);
bookCalc9Handler.setSuccessor(bookCalc8Handler);
bookCalc8Handler.setSuccessor(bookCalc7Handler);
bookHandler.calcPrice(price);

Console.log打印出来的效果:

图片 4

越来越多关于JavaScript相关内容可查看本站专题:《javascript面向对象入门教程》、《JavaScript切换特效与技巧总括》、《JavaScript查找算法技能总括》、《JavaScript错误与调整技术总括》、《JavaScript数据结构与算法技能总括》、《JavaScript遍历算法与本领计算》及《JavaScript数学生运动算用法总括》

仰望本文所述对大家JavaScript程序设计具备援救。

本文实例叙述了JS设计方式之权利链格局。分享给大家供我们参考,具体如下: 责...

Python完毕的客户登入系统成效示例,python系统机能

正文实例陈述了Python达成的客商登入系统机能。分享给我们供我们参谋,具体如下:

有N,E,Q多个选项,若选取Q大概暂停,则系统退出。若别的选项,则一再让客户挑选。

#!/usr/bin/env python
db = {}
def newuser():
  prompt = 'login desired: '
  while 1:
    name = raw_input(prompt)
    if db.has_key(name):
      prompt = 'name taken, try another: '
      continue
    else:
      break
  pwd = raw_input('passwd: ')
  db[name] = pwd
def olduser():
  name = raw_input('login: ')
  pwd = raw_input('passwd: ')
  passwd = db.get(name)
  if passwd == pwd:
    pass
  else:
    print 'login incorrect'
    return
  print 'welcome back', name
def showmenu():##主函数名
  prompt = """
(N)ew User Login
(E)xisting User Login
(Q)uit
Enter choice: """
  done = 0 ##控制循环的控制器
  while not done:
    chosen = 0 ##控制循环的控制器
    while not chosen:
      try:
        choice = raw_input(prompt)[0]
      except (EOFError, KeyboardInterrupt):
        choice = 'q'
      print 'nYou picked: [%s]' % choice
      if choice not in 'neq':##非neq继续小循环
        print 'invalid menu option, try again'
      else:
        chosen = 1 ##跳出小循环
    if choice == 'q': done = 1 ##跳出大循环
    if choice == 'n': newuser()
    if choice == 'e': olduser()
if __name__ == '__main__':
  showmenu()

运营结果:

图片 5

越来越多关于Python相关内容感兴趣的读者可查看本站专项论题:《Python数学生运动算手艺总计》、《Python字符串操作本领汇总》、《Python编码操作技巧总括》、《Python数据结构与算法教程》、《Python函数使用才具总计》、《Python入门与进级精湛教程》及《Python文件与目录操作手艺汇总》

瞩望本文所述对我们Python程序设计有所扶助。

本文实例陈述了Python达成的客商登陆连串机能。分享给大家供大家参谋,具体如下: 有...

Python中的defaultdict与__missing__()使用介绍,

前言

前几日我们的支柱是 defaultdict ,同有的时候候也会介绍一下模拟方法 __missing__() ,本文重要缘于网络亲密的朋友博客,分享给有亟待的人。上边话非常少说了,来八只看看详细的介绍吧。

私下认可值能够很有利

确定,在Python中假使访谈字典中一纸空文的键,会掀起KeyError万分。可是不常,字典中的每一种键都存在默许值是十一分便于的。举个例子上面包车型客车例子:

strings = ('puppy', 'kitten', 'puppy', 'puppy',
   'weasel', 'puppy', 'kitten', 'puppy')
counts = {}
for kw in strings:
 counts[kw]  = 1

该例子总结strings中有个别单词出现的次数,并在counts字典中作记录。单词每出现一遍,在counts相对应的键所存的值数字加1。可是实际,运维这段代码会抛出KeyError万分,出现的机遇是每种单词第贰回总计的时候,因为Python的dict中空头支票暗中认可值的布道,能够在Python命令行中验证:

>>> counts = dict()
>>> counts
{}
>>> counts['puppy']  = 1
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'puppy'

使用剖断语句检查

既然如此,首先只怕想到的章程是在单词第一次总括的时候,在counts中相应的键存下暗中同意值1。那必要在拍卖的时候加多叁个论断语句:

strings = ('puppy', 'kitten', 'puppy', 'puppy',
   'weasel', 'puppy', 'kitten', 'puppy')
counts = {}
for kw in strings:
 if kw not in counts:
  counts[kw] = 1
 else:
  counts[kw]  = 1
# counts:
# {'puppy': 5, 'weasel': 1, 'kitten': 2}

使用 dict.setdefault() 方法

也足以透过 dict.setdefault() 方法来安装暗许值:

strings = ('puppy', 'kitten', 'puppy', 'puppy',
   'weasel', 'puppy', 'kitten', 'puppy')
counts = {}
for kw in strings:
 counts.setdefault(kw, 0)
 counts[kw]  = 1

dict.setdefault() 方法接收多个参数,第贰个参数是健的名目,第一个参数是暗中同意值。假设字典中一纸空文给定的键,则赶回参数中提供的私下认可值;反之,则赶回字典中保存的值。利用 dict.setdefault()办法的重返值能够重写for循环中的代码,使其更为从简:

strings = ('puppy', 'kitten', 'puppy', 'puppy',
   'weasel', 'puppy', 'kitten', 'puppy')
counts = {}
for kw in strings:
 counts[kw] = counts.setdefault(kw, 0)   1

使用 collections.defaultdict 类

以上的章程即使在自然水准上消除了dict中空头支票私下认可值的难题,可是此时大家会想,有未有一种字典它自个儿提供了默许值的法力吗?答案是一定的,那就是 collections.defaultdict

defaultdict类就类似是二个dict,不过它是使用二个类型来开始化的:

>>> from collections import defaultdict
>>> dd = defaultdict(list)
>>> dd
defaultdict(<type 'list'>, {})

defaultdict类的早先化函数接受三个档案的次序作为参数,当所拜访的键不真实的时候,能够实例化三个值作为暗中同意值:

>>> dd['foo']
[]
>>> dd
defaultdict(<type 'list'>, {'foo': []})
>>> dd['bar'].append('quux')
>>> dd
defaultdict(<type 'list'>, {'foo': [], 'bar': ['quux']})

内需注意的是,这种样式的暗中同意值唯有在经过 dict[key]或者 dict.__getitem__(key) 访谈的时候才使得,这么些中的因由在下文子禽介绍。

>>> from collections import defaultdict
>>> dd = defaultdict(list)
>>> 'something' in dd
False
>>> dd.pop('something')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'pop(): dictionary is empty'
>>> dd.get('something')
>>> dd['something']
[]

defaultdict类除了收受类型名称作为开端化函数的参数之外,还可以动用另外不带参数的可调用函数,到时该函数的回到结果作为默许值,那样使得默许值的取值越来越灵敏。上面用叁个例子来证实,怎么样用自定义的不带参数的函数 zero()用作defaultdict类的初阶化函数的参数:

>>> from collections import defaultdict
>>> def zero():
...  return 0
...
>>> dd = defaultdict(zero)
>>> dd
defaultdict(<function zero at 0xb7ed2684>, {})
>>> dd['foo']
0
>>> dd
defaultdict(<function zero at 0xb7ed2684>, {'foo': 0})

利用 collections.defaultdict来减轻早先时代的单词计算难点,代码如下:

from collections import defaultdict
strings = ('puppy', 'kitten', 'puppy', 'puppy',
   'weasel', 'puppy', 'kitten', 'puppy')
counts = defaultdict(lambda: 0) # 使用lambda来定义简单的函数
for s in strings:
 counts[s]  = 1

defaultdict类是什么贯彻的

透过上边的内容,想必我们早已了然了defaultdict类的用法,那么在defaultdict类中又是怎么来落到实处暗中同意值的效果吗?那之中的首借使运用了看 __missing__()那几个主意:

>>> from collections import defaultdict
>>> print defaultdict.__missing__.__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

透过查看 __missing__()方法的 docstring ,能够看到当使用 __getitem__()措施访谈七个不设有的键时 dict[key] 这种格局实际上是 __getitem__()办法的简化情势),会调用 __missing__() 方法获取暗中认可值,并将该键加多到字典中去。

关于 __missing__() 方法的有血有肉介绍能够参照他事他说加以考察Python官方文书档案中的" Mapping Types — dict "一节。

文书档案中介绍,从2.5版本最初,借使派生自dict的子类定义了 __missing__() 方法,当访谈一纸空文的键时,dict[key]会调用 __missing__()方法取得暗中认可值。

从中能够见到,纵然dict协理 __missing__()方法,不过在dict本人是一纸空文那些格局的,而是须求在派生的子类中自动完结那么些方法。可以差非常的少的证实这或多或少:

>>> print dict.__missing__.__doc__
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AttributeError: type object 'dict' has no attribute '__missing__'

与此同临时候,大家能够越来越压实验,定义八个子类Missing并贯彻 __missing__()方法:

>>> class Missing(dict):
...  def __missing__(self, key):
...   return 'missing'
...
>>> d = Missing()
>>> d
{}
>>> d['foo']
'missing'
>>> d
{}

回到结果反映了 __missing__()方法确实发挥了遵循。在此基础上,大家多少修改 __missing__()艺术,使得该子类同defautldict类一样为不设有的键设置三个暗中同意值:

>>> class Defaulting(dict):
...  def __missing__(self, key):
...   self[key] = 'default'
...   return 'default'
...
>>> d = Defaulting()
>>> d
{}
>>> d['foo']
'default'
>>> d
{'foo': 'default'}

在旧版本的Python中落实类defaultdict的效能

defaultdict类是从2.5版本之后才增进的,在某些旧版本中并不协理它,由此为旧版本完毕叁个匹配的defaultdict类是不可缺少的。那实际上很轻易,固然质量大概不一定如2.5版本中自带的defautldict类好,但在效益上是均等的。

首先, __getitem__()措施须求在访谈键失利时,调用 __missing__() 方法:

class defaultdict(dict):
 def __getitem__(self, key):
  try:
   return dict.__getitem__(self, key)
  except KeyError:
   return self.__missing__(key)

协理,必要贯彻 __missing__()办法用来设置暗中认可值:

class defaultdict(dict):
 def __getitem__(self, key):
  try:
   return dict.__getitem__(self, key)
  except KeyError:
   return self.__missing__(key)
 def __missing__(self, key):
  self[key] = value = self.default_factory()
  return value

下一场,defaultdict类的开头化函数__init__() 须求经受类型或许可调用函数参数:

class defaultdict(dict):
 def __init__(self, default_factory=None, *a, **kw):
  dict.__init__(self, *a, **kw)
  self.default_factory = default_factory
 def __getitem__(self, key):
  try:
   return dict.__getitem__(self, key)
  except KeyError:
   return self.__missing__(key)
 def __missing__(self, key):
  self[key] = value = self.default_factory()
  return value

末尾,综合上述内容,通过以下方法完结包容新旧Python版本的代码:

try:
 from collections import defaultdict
except ImportError:
 class defaultdict(dict):
  def __init__(self, default_factory=None, *a, **kw):
   dict.__init__(self, *a, **kw)
   self.default_factory = default_factory
  def __getitem__(self, key):
   try:
    return dict.__getitem__(self, key)
   except KeyError:
    return self.__missing__(key)
  def __missing__(self, key):
   self[key] = value = self.default_factory()
   return value

参照文书档案

总结

如上便是那篇文章的全体内容了,希望本文的原委对大家的就学也许干活具备自然的参阅学习价值,假诺有疑问我们能够留言交换,多谢我们对帮客之家的支撑。

前言 明天大家的主演是 defaultdict ,相同的时间也会介绍一下模仿方法 __missing__() ,本文主要源于网上基友...

本文由小鱼儿玄机30码发布于编程,转载请注明出处:该例子计算strings中有个别单词出现的次数,总括

关键词: 小鱼儿玄机30码