如何使用Groovy操作文件

1. 读文件

读文件内容

在groovy中输出文件的内容:

println new File("tmp.csv").text

上面代码非常简单,没有流的出现,没有资源关闭的出现,也没有异常控制的出现,所有的这些groovy已经搞定了。

读取每一行内容:

  1. File file = new File(‘tmp.csv’)
  2. assert file.name == ‘tmp.csv’
  3. assert ! file.isAbsolute()
  4. assert file.path == ‘tmp.csv’
  5. assert file.parent == null
  6. //使用系统默认的编码处理文件流
  7. file.eachLine {println it }
  8. //指定处理流的编码
  9. file.eachLine(“UTF-8”) { println it }
  10. file.eachLine(“UTF-8”,10) {str,no->
  11. println str
  12. println no }

对文件中每一行的内容做处理:

  1. file.splitEachLine(“\t”) { println it }
  2. //以大写行式输出文件内容
  3. lineList = file.readLines();
  4. liineList.each {
  5. println it.toUpperCase();
  6. }
  7. file.filterLine {String str->
  8. if (str.contains(‘code’))
  9. println str
  10. }.writeTo(new PrintWriter(System.out))

解析 xml 文件

  1. <?xml version=”1.0″ encoding=”UTF-8″?>
  2. <customers>
  3. <corporate>
  4. <customer name=“bill gates” company=“microsoft”></customer>
  5. <customer name=“steve jobs” company=“apple”></customer>
  6. <customer name=“bill dyh” company=“sun”></customer>
  7. </corporate>
  8. <consumer>
  9. <customer name=“jone Doe”></customer>
  10. <customer name=“jane Doe”></customer>
  11. </consumer>
  12. </customers>

 

  1. def customers = new XmlSlurper().parse(new File(“customers.xml”))
  2. /*对文件进行解析*/
  3. for(customer in customers.corporate.customer){
  4. println “${customer.@name} works for${customer.@company}”;
  5. }

解析 propeties 文件

参考 groovy: How to access to properties file?,代码如下:

  1. def props = new Properties()
  2. new File(“message.properties”).withInputStream {
  3. stream -> props.load(stream)
  4. }
  5. // accessing the property from Properties object using Groovy’s map notation
  6. println “capacity.created=” + props[“capacity.created”]
  7. def config = new ConfigSlurper().parse(props)
  8. // accessing the property from ConfigSlurper object using GPath expression
  9. println “capacity.created=” + config.capacity.created

另外一种方式:

  1. def config = new ConfigSlurper().parse(new File(“message.groovy”).text)
  2. message.groovy 内容如下:
  3. capacity {
  4. created=“x”
  5. modified=“y”
  6. }

 

2. 操作目录

列出目录所有文件(包含子文件夹,子文件夹内文件) :

  1. def dir = new File(dirName)
  2. if (dir.isDirectory()) {
  3. dir.eachFileRecurse { file ->
  4. println file
  5. }
  6. }
  7. dir.eachFileMatch(~/.*\.txt/) {File it-> println it.name } //使正则表达式匹配文件名
  8. dir.eachFileMatch(FILES, ~/.*\.txt/) { File it-> println it.name }

 

3. 写文件

  1. import java.io.File
  2. def writeFile(fileName) {
  3. def file = new File(fileName)
  4. if (file.exists())
  5. file.delete()
  6. def printWriter = file.newPrintWriter() //
  7. printWriter.write(‘The first content of file’)
  8. printWriter.write(‘\n’)
  9. printWriter.write(‘The first content of file’)
  10. printWriter.flush()
  11. printWriter.close()

除了  file.newPrintWriter()  可以得到一个 PrintWriter,类似方法还有  file.newInputStream() 、 file.newObjectInputStream() 等。

更简洁写法:

  1. new File(fileName).withPrintWriter { printWriter ->
  2. printWriter.println(‘The first content of file’)
  3. }

 

云计算有哪些特点?

美国国家标准与技术研究院(NIST)定义:云计算是一种按使用量付费的模式,这种模式提供可用的、便捷的、按需的网络访问,进入可配置的计算资源共享池(资源包括网络,服务器,存储,应用软件,服务),这些资源能够被快速提供,只需投入很少的管理工作,或与服务供应商进行很少的交互。

从云计算的定义可以看出,云计算后端具有非常庞大、可靠的云计算中心,对于云计算使用者来说,在付出少量成本的前提下,即可获得较高的用户体验!功能强大的云计算还具有以下特点:

1. 超大规模

一般云计算都具有超大规模,Google云计算拥有100多万台服务器,Amazon、IBM、微软、Yahoo等的云计算均拥有几十万台服务器,企业私有云一般也拥有数百上千台服务器,并且云计算中心能通过整合和管理这些数目庞大的计算机集群来赋予用户前所未有的计算和存储能力。

2. 抽象化

云计算具有很好的终端支持,用户在任意位置、使用各种终端均可获取云计算提供的应用服务,仅需通过网络即可实现我们所需操作,甚至包括超级计算任务。

3. 高可靠性

云计算对于可靠性要求很高,在软硬件层面采用了诸如数据多副本容错、心跳检测和计算节点同构可互换等措施来保障服务的高可靠性,还在设施层面上的能源、制冷和网络连接等方面采用了冗余设计来进一步确保服务的可靠性。

4. 通用性

云计算不针对特定的应用,在“云”的支撑下可以构造出千变万化的应用,同一个“云”可以同时支撑不同的应用运行。

5. 高可扩展性

云计算具有高扩展性,其规模可以根据其应用的需要进行调整和动态伸缩,可以满足用户应用和大规模增长的需要。

6. 按需服务

云计算采用按需服务模式,用户可以根据需求自行购买,降低用户投入费用,并获得更好的服务支持!

7. 廉价

云计算的自动化集中式管理使大量企业无需负担日益高昂的数据中心管理成本,即可享受超额的云计算资源与服务,经常只要花费几百美元就能完成以前需要数万美元才能完成的任务。

8. 自动化

云计算不论是应用、服务和资源的部署,还是软硬件的管理,都主要通过自动化的方式来执行和管理,从而*大地降低整个云计算中心庞大的人力成本。

9. 节能环保

云计算技术能将许许多多分散在低利用率服务器上的工作负载整合到云中,来提升资源的使用效率,而且云由专业管理团队运维,所以其PUE(Power Usage Effectiveness,电源使用效率值)值和普通企业的数据中心相比出色很多,比如,Google数据中心的PUE值在1.2左右,也就是说,每一块钱的电力花在计算资源上,只需再花两角钱电力在制冷等设备,而常见的PUE在2和3之间,并且还能将云建设在水电厂等洁净资源旁边,这样既能进一步节省能源方面开支,又能保护了环境。

10. 完善的运维机制

在“云”的另一端,有全世界*专业的团队来帮用户管理信息,有全世界*先进的数据中心来帮用户保存数据。同时,严格的权限管理策略可以保证这些数据的安全。这样,用户无需花费重金就可以享受到*专业的服务。

以上是 云计算所具有的特点,这些特点的存在,使得 云计算能为用户提供更方便的体验和更低廉的成本,同时,这些特点的存在,也是 云计算能够脱颖而出,并且被大多数业界人士所推崇的重要原因之一。
————————————————

原文链接:https://blog.csdn.net/lmseo5hy/article/details/79625716

谷歌云计算的使用方法_6种云计算的常用用法

谷歌云计算的使用方法

Cloud computing has become very popular for businesses. As of 2018, over three-quarters of enterprises were already using it and more are adopting it every day. If you haven’t considered it yet, that’s possibly because you’re not sure what you can use it for. To give you an idea, here we’ll show you the six main ways it is being put to good use.

云计算在企业中已变得非常流行。 截至2018年,超过四分之三的企业已经在使用它,而且每天都有越来越多的企业采用它。 如果您还没有考虑过,那可能是因为您不确定您可以将其用作什么。 为了给您一个想法,在这里我们将向您展示如何充分利用它的六种主要方法。

1. 大数据分析 (1. Big Data analytics)

Today’s businesses collect vast amounts of data on all manner of things: customers, operational processes, logistics, machinery health, product condition and much more. The value of that data comes from making sense of it, using it to come up with solutions to problems or discovering new opportunities. To do this, however, you’ll need to conduct Big Data analytics and this requires the use of substantial computing resources, often over short periods.

当今的企业收集有关各种事物的大量数据:客户,操作流程,物流,机械运行状况,产品状态等等。 数据的价值来自对数据的理解,使用它来提出问题的解决方案或发现新的机会。 但是,要做到这一点,您将需要进行大数据分析,并且这通常需要在短时间内使用大量的计算资源。

Those resources would be incredibly expensive if you had to purchase them and for much of the time would stand unused. Convincing the finance director this was the wisest use of the company’s money would be a difficult challenge. The advantage of cloud is that its pay-as-you-go pricing means you can access all those resources for the times you do need them but not pay for them when you don’t. This way you can carry out Big Data analytics whenever you need but do so affordably.

如果您必须购买这些资源,那么它们将是难以置信的昂贵,并且在许多时间里它们将处于闲置状态。 要说服财务总监这是*明智地使用公司资金的方法,将是一项艰巨的挑战。 云的优势在于其按需付费的定价方式意味着您可以在需要时访问所有这些资源,而在不需要时则无需付费。 这样,您可以在需要时进行大数据分析,但价格合理。

2. 文件存储 (2. File storage)

While it’s true that you can store your files in many places, what makes the cloud so appealing is that files can be accessed, edited and shared anywhere with an internet connection and this opens up a variety of opportunities for mobile working, collaboration and even improved security.

虽然可以将文件存储在许多地方,但使云如此吸引人的是,可以通过Internet连接在任何地方访问,编辑和共享文件,这为移动工作,协作甚至改进提供了各种机会。安全。

What’s more, the cloud provides high-speed, high-availability access as well as offering scalability to increase or decrease storage as demand requires – again paid for on a per-use basis.

而且,云提供了高速,高可用性的访问权限,并提供了可扩展性以根据需要增加或减少存储-再次按使用付费。

3. 测试与开发 (3. Testing and development)

Developing a new application or platform in-house can be an expensive and long-winded process. It involves significant spending, time and staff involvement and requires the procurement, installation and configuration of hardware. This means it takes longer to complete a project and can put your company at a disadvantage with competitors.

在内部开发新的应用程序或平台可能是一个昂贵且漫长的过程。 它涉及大量的支出,时间和人员参与,并且需要硬件的采购,安装和配置。 这意味着完成项目需要更长的时间,并且可能使您的公司在竞争对手中处于劣势。

Cloud computing can make testing and development quicker, less expensive and less complicated. This is because there are various pre-existing and perfectly suitable cloud environments already built and ready to use out of the box.

云计算可以使测试和开发更快,更便宜,更复杂。 这是因为已经建立了各种预先存在且非常合适的云环境,可以立即使用。

4. 灾难恢复 (4. Disaster recovery)

Lots of companies use the cloud as the solution for their disaster recovery needs. Continuous backups of your servers in the cloud mean that you’ll no longer need to pay for a separate, redundant DR site of your own. Not only is recovery much cheaper, it’s also far quicker, ensuring your business is back online in no time at all.

许多公司将云用作满足其灾难恢复需求的解决方案。 在云中对服务器进行连续备份意味着您不再需要为自己的冗余冗余DR站点付费。 恢复不仅便宜得多,而且速度也快得多,可确保您的业务立即恢复在线。

5. 数据备份 (5. Data backups)

Traditional methods of backing up data have tended to be complicated and time-consuming, often requiring portable drives or even tapes being shipped to remote sites for storage. This is also a technique that can back-fire if the drives are too small for the data or are discovered to be defective.

备份数据的传统方法趋于复杂且耗时,通常需要将便携式驱动器甚至磁带运送到远程站点进行存储。 如果驱动器对于数据而言太小或被发现有缺陷,这也是一种可能会适得其反的技术。

Cloud-based backup is far easier to carry out and more secure. You can schedule backups to meet your needs; store them remotely on virtual servers, knowing that if the physical hardware hits a problem the data is still available; they can be encrypted for increased security and checked to make sure the data is not corrupt. And as with all cloud storage, you can have as much space as you need without fear of running out.

基于云的备份更容易执行且更安全。 您可以安排备份以满足您的需求; 将它们远程存储在虚拟服务器上,知道如果物理硬件遇到问题,数据仍然可用; 可以对它们进行加密以提高安全性,并检查以确保数据没有损坏。 与所有云存储一样,您可以拥有所需的空间,而不必担心耗尽。

6. 物联网 (6. The Internet of Things )

The internet of Things is beginning to transform the way we live our lives and increasing numbers of enterprises are making use of it. An IoT system works by collecting data from large numbers of connected sensors and uses this to make intelligent decisions – often using artificial intelligence and machine learning.

物联网正在开始改变我们的生活方式,越来越多的企业正在使用它。 物联网系统通过从大量连接的传感器中收集数据来工作,并经常使用人工智能和机器学习来进行智能决策。

To take advantage of the IoT, the cloud is needed to analyse that data and make insights from it. A smart traffic system, for example, can monitor traffic conditions across an entire area, discovering where issues arise and using AI to quickly reroute or slow down vehicles in order to prevent a hold up. This kind of intervention would be almost impossible to gather without the capabilities of cloud.

为了利用物联网,需要云来分析数据并从中获得见解。 例如,一个智能交通系统可以监控整个区域的交通状况,发现问题出处,并使用AI快速改道或放慢车辆速度,以防止阻塞。 没有云的功能,几乎不可能收集到这种干预。

Cloud’s scalability is also important for IoT. As a company grows, so might the number of IoT devices it sends and receives information from. More devices mean it will need larger computing resources and this can be achieved quickly and easily in the cloud without the need for significant capital investment.

云的可扩展性对于物联网也很重要。 随着公司的发展,它发送和接收信息的IoT设备的数量也可能会增加。 更多的设备意味着它将需要更大的计算资源,并且可以在云中快速轻松地实现这一目标,而无需大量的资本投资。

结论 (Conclusion)

Cloud enables businesses to do many things that, without it, they would find more expensive, overly time-consuming or beyond their in-house IT capabilities. From basic solutions, like storing files and backing up data, to highly sophisticated processes, such as Big Data analytics and IoT data processing, the potential of the cloud is enormous. Indeed, what we have discussed here barely scratches the surface and there are even more developments yet to come.

云使企业能够完成许多事情,而没有它,它们会发现更昂贵,更耗时或超出其内部IT功能。 从存储文件和备份数据的基本解决方案到大数据分析和IoT数据处理等高度复杂的流程,云的潜力是巨大的。 确实,我们在这里讨论的内容几乎没有触及表面,并且还有更多的发展。

 

配置Groovy开发运行环境

      虽然一直在做C和C++,但只要涉及到能用Java或者.net开发的部分,还是很愿意用这两者进行开发的。虽然相比于C/C++,Java或.net的灵活性小了一些,但后者开发的效率真的是相当高,而且写起来也不会像C/C++那样让人郁闷。

      这两年C#的发展可谓是精彩,Microsoft真不愧是*牛X的拿来主义公司,C#结合了多种语言的优点,写代码相当流畅,特别是C#描述中间件和API时可选的表现方法更多,对于类库使用者的要求更低,真的很不错。

      当然,相比Phyton、Ruby或者Javascript这类脚本,任何强类型语言都显得不那么灵活,就好比PHP能提供比C语言更多的语言特性,包括闭包这样强大的功能。C#能以一种强类型语言做到相当多的动态语言特性,真是很了不起。对应Java,这两年发展的真的很慢,*新版本的JDK 7,也不过是增加了.net framework 2.0中几个常用功能,和.net framework 4相比依然相差很远。Java上有Spring等如此强大的API,语言本身却简单的近乎粗陋,真是不好说。

      有人说Java就应该是这样的,就应该用getter/setter而不用=运算符,就应该不停的throws,就应该用一大票的interface,就应该不能自定义值类型……但我总觉得,开发人员喜欢什么样的设计模式都不能成为语言本身不提供该功能的理由。

      否则,Groovy为什么会出现呢?

      不吐槽了,既然Java上诞生了Groovy,这门语法甜的发腻的语言就肯定会让很多人喜欢它!虽然Groovy目前还存在效率方面的问题,它甚至比Javascript更慢,但Groovy毕竟是依赖于Java的,毕竟是和Java无缝挂接的,毕竟具备Java, Javascript, Phython, Ruby等等语言的优点,所以我估计谁也不能阻止Groovy的前进了!

 1、配置Groovy开发环境

      由于Groovy是基于JDK的,所以安装Groovy之前肯定要安装JDK了,从http://www.oracle.com/technetwork/java/javase/downloads/index.html可以下载到*新的JDK,写这篇文章时,JDK已经更新到JDK 7u2了,下载安装包安装即可。

      Groovy的安装挺简单的,基本上和JDK的安装差不多,从http://groovy.codehaus.org/Download下载Groovy的GDK环境的安装包Windows-Installer(应该是1.8版本了),直接安装就可以了;如果下载的是zip版本,则按照如下步骤设置即可:

将zip包解压到随便那个目录中,如d:\devtools\groovy1.8.4
设置环境变量GROOVY_HOME,值为放置解压文件的目录,如d:\devtools\groovy1.8.4
增加环境变量path,指向%GROOVY_HOME%\bin
接下来就可以在Groovy控制台中编写脚本了,在Windows控制台(cmd)下输入groovyconsole命令进入groovy控制台,在里面输入代码 println “HelloWorld”回车,按组合键CTRL+R就可以看到运行结果了。
当然,这是Groovy自带的*基本的开发工具,很不实用,对于Groovy,NetBeans,IntelliJ IDEA等开发环境都提供了完善的支持,eclipse也提供了对应的插件。这里主要说一下eclipse中安装插件的办法。

到http://www.eclipse.org/downloads/上下载*新版本的eclipse,目前是3.7.1版本,下载后解压到任意目录即可运行;
打开eclipse,选择菜单项“Help->Install New Software”,再打开的对话框中按下Add按钮,在其中输入网址 http://dist.springsource.org/release/GRECLIPSE/e3.7/后确定;

%title插图%num
图1

%title插图%num
图2

                    等上一会儿,直到eclipse从网上找到找到要安装的包,此时把要安装的包前面的复选框选中(全选即可),点击Finish按钮即可开始安装

%title插图%num
图3

            其实我试了几次在线安装,都是安装到一半的时候由于神奇的未知网络原因,安装中断,所以*终我使用的是离线安装的办法:
从http://dist.springsource.org/release/GRECLIPSE/e3.7/archive-2.6.0.xx-20111212-0900-e37-RELEASE.zip下载离线安装包,注意,直接下载速度不会超过1kbps,请各位同学自行寻找访问伟大祖国以外神奇网站的具体方法,我使用GoAgent,可以在10Mbps的带宽上达到200多bps的下载;
注意下载的这个安装包不能使用eclipse传统的插件安装方式(内含Groovy编译器),无论覆盖方式、Link文件方式还是dropins目录方式都玩不转,还得使用eclipse的”Help->nstall New Software“方式安装;
当打开上述图2的对话框后,不要填写网址,按下Achieve按钮,在出现的对话框中填写下载文件的路径和文件名

%title插图%num

图4

            点击OK,继续安装即可
插件安装后重启eclipse,在新建项目中应该包含了Groovy Project和Groovy Class,这就表示Groovy插件安装成功,可以利用eclipse开发Groovy应用程序了!

Android关于Groovy脚本执行ADB命令

项目使用场景:
项目中存在经常需要往设备中拷贝文件和数据库文件的操作,为便于提高开发效率,使用Groovy脚本编写一段脚本提高开发效率,省去那些繁琐的复制粘贴工作。

方法封装:

几个常用的方法封装:

/**   将AllProject项目目录下的 Data 数据库文件Push到设备中   **/
def A_PushDBToPDA(projectName) {

def rootProjectPath = rootProject.projectDir.path + File.separator + ‘AllProject’ + File.separator + projectName + File.separator
def PDASDCardPath = ‘ /sdcard/目录名称/’

//push前先移除对应的文件夹
task deleteDBDir {
doLast {
//定义adb命令并执行
def deleteDBDirCommand = ‘adb shell cd /sdcard && rm -r ‘ + PDASDCardPath + ‘Data’
Process deleteDBDirCommandProcess = deleteDBDirCommand.execute()
println “Success execute Command: ${deleteDBDirCommand.toString().readLines()}”
deleteDBDirCommandProcess.in.eachLine { processing ->
println processing
}
}
}

//执行该任务前先执行deleteDBDir目录
task A_PushDBToPDA(dependsOn: deleteDBDir) {
doLast {
def fromPath = rootProjectPath + ‘Data’
def adbCommand = ‘adb push ‘ + fromPath + PDASDCardPath
Process process = adbCommand.execute()
println “Success execute Command: ${adbCommand.toString().readLines()}”
process.in.eachLine { processing ->
println processing
}
}
}
}

使用ADB命令
删除sdcard下指定文件名或目录
adb shell cd /sdcard && rm -r 文件名称/目录

Push文件或目录到sdcard(注意空格)
adb push <从何处> <到哪里>

/**   将AllProject下的项目打包zip到 asserts 目录下,方便打包   **/
def A_AllProjectZipToAssets(projectName) {

//Gradle Zip文档  https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Zip.html

def resProjectPath = rootProject.projectDir.path + File.separator + ‘AllProject’ + File.separator + projectName
def targetPath = project.projectDir.path + File.separator + ‘src’ + File.separator + ‘main’ + File.separator + ‘assets’
//println ‘from:’ + resProjectPath
//println ‘target:’ + targetPath

//打包前需先删除zip文件
task deleteExistedZip(type: Delete) {
delete targetPath + File.separator + projectName + ‘.zip’
}
//注:exclude可以忽略掉不需要打包的文件或目录
task A_AllProjectZipToAssets(type: Zip, dependsOn: deleteExistedZip) {
from resProjectPath
exclude(‘CNG.xml’, ‘Data’)//忽略CNG.xml文件和Data目录
destinationDir file(targetPath)
baseName projectName
appendix ” //The appendix part of the archive name, if any.
version ” //The version part of the archive name, if any. eg:FeiHe-1.0.0.zip
//extension ‘zip’ //The extension part of the archive name. Default is zip
classifier ”   //The classifier part of the archive name, if any.
}
//tasks.A_AllProjectZipToAssets.dependsOn(deleteExistedZip)
}

具体使用:
这里就是Gradle文件的引用问题了,可以将gradle文件单独存放在项目的某个目录下,然后进行引用,例如

在项目根目录下创建目录:GradleConfig,将gradle文件放入,在app module下的build.gradle中引入即可:

apply from: rootProject.projectDir.path + ‘/GradleConfig/SyncOrPushFile.gradle’
构建为完成后,会在侧边的Gradle栏目中执行自定义的Task任务,如图:

%title插图%num

蓝桥杯 安慰奶牛Python版

蓝桥杯 安慰奶牛Python版

 

nodenum,edgenum = map(int,input().split())
vexlist = []
for i in range(nodenum):
c = eval(input())
vexlist.append(c)
edgelist = []
for j in range(edgenum):
s,e,l = map(int,input().split())
s = s-1 #注意此处,会影响后面的group取值
e = e-1
l = l * 2 + vexlist[s]+ vexlist[e]
edgelist.append([s,e,l])
res = []
edgelist.sort(key=lambda a:a[2])
group = [[i] for i in range(nodenum)]
for edge in edgelist:
for i in range(len(group)):
if edge[0] in group[i]:
m = i
if edge[1] in group[i]:
n = i
if m != n:
res.append(edge)
group[m] += group[n]
group[n] = []
minsum = min(vexlist)
for edge in res:
minsum += edge[2]
print(minsum)

Python爬虫 爬取CSDN首页的各窗口内容

Python爬虫 爬取CSDN首页的各窗口内容

Python爬虫
爬取CSDN首页的各窗口内容
还是一些信息的爬取,但处理的方法不同,分享一下,方便大家。
建议使用Internet Explorer浏览器打开,其他浏览器打开会运行网站附带的脚本,会跳转到CSDN首页。

#导入模块
import urllib.request
import urllib.error
import re
#csdn的首页网址
url=”https://www.csdn.net/”
#下面注释部分为模拟浏览器请求,但CSDN可直接访问,可不用
#headers={“User-Agent”,”Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.87 Safari/537.36 SE 2.X MetaSr 1.0″}
#opener=urllib.request.build_opener()
#opener.addheaders=[headers]
#date=opener.open(url).read().decode(“utf-8″,”ignore”)
#爬取首页所有信息
#urllib.request.urlopen()函数会报错,所以要进行爬虫异常处理
try:
date=urllib.request.urlopen(url).read().decode(“utf-8″,”ignore”)
print(len(date))
#HTTPError有两个属性,异常原因和异常状态码
except urllib.error.HTTPError as e:
#打印异常状态码
if hasattr(e,”code”):
print(e.code)
#打印异常原因
if hasattr(e,”reason”):
print(e.reason)
#写正则提取网址(提取到的信息,包括”\\”或者”\”都为普通字符)
pat=”’,”url”:”(.*?)”,”’
#将提取到网址放入列表
thisurl=re.compile(pat).findall(date)
#清除缓存
urllib.request.urlcleanup()
#打印列表,可不用
#print(thisurl)
#通过循环将这些网址直接放入本地
for i in range(len(thisurl)):
#去除多余信息
url1=thisurl[i].replace(“u002F”,””)
#打印去除后的网址,可不用
#print(type(url1))
#将网址里面里面的’\’字符换为’/’字符(因为使用urlib.request.urlretrieve()这个函数,
#直接把网址存入本地,而这个网址里面的地址连接符必须是’//’或者’/’,否则会报错,
#这个错报了之后很难发现怎么去改)
url2=url1.replace(“\\”,”/”)
#进行异常处理,因为使用urlib.request.urlretrieve()函数会报错,所以使用爬虫异常处理,
#得到异常状态码和异常原因
try:
urllib.request.urlretrieve(url2,”D:/write1/date1/”+str(i)+”.html”)
print(url2)
except urllib.error.HTTPError as e:
#打印异常状态码
if hasattr(e,”code”):
print(e.code)
#打印异常原因
if hasattr(e,”reason”):
print(e.reason)

用python统计水浒传中的高频词汇

用python统计水浒传中的高频词汇

用python统计水浒传中的高频词汇
#词频统计.py
import jieba
excludes = {“两个”,”一个”,”只见”,”如何”,”那里”,”哥哥”,”说道”,”军马”,”头领”,”众人”,”这里”,”兄弟”,”梁山泊”,”出来”,”小人”,”今日”,”这个”,”先锋”,”三个”,”因此”,”人马”,”问道”,”起来”,”便是”,”妇人”,”好汉”,”不是”,”不知”,”不曾”,”只是”,”如此”,”次日”,”我们”,”不得”,”如今”,”看时”,”不敢”,”来到”,”且说”,”一面”,”只得”,”山寨”,”原来”,”将军”,”却是”}
txt = open(“水浒传.txt”,”r”,encoding=’gb18030′, errors=’ignore’).read()
words = jieba.lcut(txt)
counts = {}
for word in words:
if len(word) == 1:
continue
elif word == “宋江道”or word == “宋江”:
rword = “宋江”
else:
rword = word

counts[rword] = counts.get(rword,0) + 1
for word in excludes:
del(counts[word])
items = list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
print(“小说《水浒传》中有意义的前十高频词汇为:”)
for i in range(10):
word,count = items[i]
print(“{0:<10}{1:>5}”.format(word,count))

%title插图%num

云平台是什么?

云平台是什么?

各大厂商解释不一,云计算的书里写的更是云里雾里,但是如果你实际用过现在各大云平台提供商所提供的云计算平台以后,你就可以明白的得出结论,云平台就是高级版本的虚拟主机。

云平台可比虚拟主机高级多了,怎么会是虚拟主机呢?

这是所有人在看到上面结论后的*个反应。是的,这个反应很正确,但我也没说云平台就是普通的虚拟主机啊,我说的是云平台是高级版本的虚拟主机,当然是比普通的虚拟主机高级多了。

下面我们来看看云平台和虚拟主机有哪些本质的相同点:

都是提供一个虚拟计算环境的。不同的是普通虚拟主机是一台实体主机上提供多个站点的虚拟环境,云平台是不计其数的实体主机提供不计其数的站点的虚拟环境。
都会提供一种或几种语言的支持。普通虚拟主机有的只支持一种语言,有的则支持多种语言。而云计算平台也是如此。
都会为了安全对支持的语言都做某种程度的限制。普通虚拟主机通常会限制本地文件操作的各种API,而云计算平台则会有更多的限制。
都提供特殊的API服务。既然有些API被限制不能使用,那被限制的API就会有一些安全的替代品来代替。另外,为了将用户绑定于自己的平台,提供一些特别的API服务,也会让用户的站点无法轻易转移。
都会提供数据存储服务。不同的是普通虚拟主机通常提供的是SQL数据存储,而云计算平台则提供更利于分布式计算的NOSQL数据存储。
都会提供特殊的管理平台。虚拟主机通常会提供一些Web管理接口,或者FTP等管理方式来管理。而云计算平台通常会提供特殊的数据上传同步工具。
都是通过计时和计量来收费的。不同的是,云计算平台的计费和计量更加细化,会精确到多少个CPU时间和使用了多少M的存储。
以上这些相同相似点足以说明云平台就是高级版本的虚拟主机。

这个问题回答完之后,后面的问题就简单了。

问:云计算平台有前途吗?会有人用吗?

答:只要虚拟主机有人用,云计算平台就会有人用,相同的本质更好的服务,用户没有理由不选择云计算平台。

问:那么云计算平台能干些什么呢?

答:以前虚拟主机能干的,在云平台上都能干。但是云平台提供了更多的计算资源和存储资源,只要你有钱,不用担心会像虚拟主机一样因为一时流量太大就会被封掉。

问:那怎样才能花*少的钱又充分利用起云平台来呢?

答:*好的答案就是在云平台上使用 Hprose,它可以以*小的流量提供*快的服务,在云平台上,跟使用 SOAP 或者 REST 方式来提供 Web 服务相比,使用 Hprose 来提供 Web 服务,你只需要 1% 都不到的投入。所以,Hprose 是您使用云计算平台的*好搭档。
————————————————

原文链接:https://blog.csdn.net/iteye_2945/article/details/81889334

Numpy的学习笔记

Numpy的学习笔记

#numpy
自用内容

简写np,矩阵的运算,
下面是输出矩阵:

import numpy as np
array = np.array([[1,2,3],[2,3,4]])
print(array)
#维度
print(“number of dim: “,array.ndim)
#形状 ?X ?的数组
print(“shape:”,array.shape)
#多少元素
print(“size:”,array.size)

[[1 2 3]
[2 3 4]]
number of dim: 2
shape: (2, 3)
size: 6

创建array,定义type
a = np.array([2,23,4],dtype = np.int64)
1
生成全部为0 和1的数组三行四列

zeroArray = np.zeros((3,4))
print(zeroArray)
oneArray = np.ones((3,4))
print(oneArray)

[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]

1.生成有步长的数组:
2.生成0—11的数列

arangeArray = np.arange(10,20,2)
print(arangeArray)
numArray = np.arange(12).reshape((3,4))
print(numArray)

[10 12 14 16 18]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

生成线段,生成5点4段数列

linArray = np.linspace(1,10,6).reshape((2,3))
print(linArray)

[[ 1. 2.8 4.6]
[ 6.4 8.2 10. ]]

numpy基础运算
1.加减法
2.平方
3.三角函数的运算

aArray = np.array([10,20,30,40])
bArray = np.arange(4)
c= aArray – bArray
print(c)
d = c **2
print(d)
sinA = np.sin(10)
print(sinA)

[10 19 28 37]
[ 100 361 784 1369]
-0.5440211108893698

数组的逻辑运算
1.筛选出数组中比3小的数
2.等于3的数
3.数组中逐个相乘

print(bArray<3)
print(bArray == 3)
aShape = aArray.reshape(2,2)
bShape = bArray.reshape(2,2)
print(aShape)
print(bShape)
mutArray = aShape * bShape #逐个相乘
mut_dotArray = np.dot(aShape,bShape) #矩阵相乘
#或者
mut_Array = aShape.dot(bShape)

print(mutArray)
print(mut_dotArray)

[ True True True False]
[False False False True]
[[10 20]
[30 40]]
[[0 1]
[2 3]]
[[ 0 20]
[ 60 120]]
[[ 40 70]
[ 80 150]]

随机生成一个0-1的矩阵
求和np.sum()
*小值np.min()
*大值np.max()
axis = 1 行
axis = 0 列

randomArray = np.random.random((2,4))
print(randomArray)
print(np.sum(randomArray,axis = 1))

[[0.54661074 0.27343044 0.42980382 0.04123646]
[0.10769581 0.77549246 0.28787614 0.27292254]]

#*小值的索引
print(np.argmin(randomArray))
#max index
print(np.argmax(randomArray))
#mean
print(np.mean(randomArray))
print(randomArray.mean())
#median
print(np.median(randomArray))
#累加
print(np.cumsum(randomArray))
#累差
print(np.diff(randomArray))
#排序sort,逐行排序
print(np.sort(randomArray))
#矩阵反向:行列对换,转置
print(np.transpose(randomArray))
print(randomArray.T)

3
5
0.34188355032710077
0.34188355032710077
0.2806532854593555
[0.54661074 0.82004118 1.249845 1.29108145 1.39877726 2.17426972
2.46214586 2.7350684 ]
[[-0.27318031 0.15637338 -0.38856736]
[ 0.66779665 -0.48761633 -0.01495359]]
[[0.04123646 0.27343044 0.42980382 0.54661074]
[0.10769581 0.27292254 0.28787614 0.77549246]]
[[0.54661074 0.10769581]
[0.27343044 0.77549246]
[0.42980382 0.28787614]
[0.04123646 0.27292254]]
[[0.54661074 0.10769581]
[0.27343044 0.77549246]
[0.42980382 0.28787614]
[0.04123646 0.27292254]]

clip
让小于或大于设定的某个数,都近似于设定的数字

setA = np.arange(2,14).reshape(3,4)
print(setA)
#求列中的平均值
print(np.mean(setA,axis = 0))
print(np.clip(setA,5,9))

[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[6. 7. 8. 9.]
[[5 5 5 5]
[6 7 8 9]
[9 9 9 9]]

index
print(setA)
#第3行的所有数
print(setA[2])
print(setA[2,:])
#第2行第三列
print(setA[1,2])
print(setA[2][1])
#第2列:
print(setA[:,1])
#取【7,8】,取左不取右
print(setA[1,1:3])

[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[10 11 12 13]
[10 11 12 13]

[ 3 7 11]
[7 8]

for循环输出每行,row和column都只是参数名

for row in setA:
print(row)

[2 3 4 5]
[6 7 8 9]
[10 11 12 13]

for循环输出每列

for column in setA.T:
print(column)

[ 2 6 10]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]

迭代出每一个数

for item in setA.flat:
print(item)

#第二行的每一个数

print(setA)

for itemR2 in setA[1].flat:
print(itemR2)

[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]

array的数据处理
setD = np.array([1,1,1])
setC = np.array([2,2,2])
setE = np.array([3,3])
print(np.vstack((setD,setC)))#vertical stack 变成二维上下合并
print(np.hstack((setD,setC)))#左右合并

[[1 1 1]
[2 2 2]]
[1 1 1 2 2 2]

一维数组变二维数组
#将一维数组增加了一个维度,变成二维数组(1X3)
print(setD[np.newaxis,:])
#变成(3×1)
print(setD[:,np.newaxis])

[[1 1 1]]
[[1]
[1]
[1]]

多个array的合并,任意维度
#左右合并 axis = 1
setRow = np.concatenate((setC[np.newaxis,:],setD[np.newaxis,:]),axis = 1)
print(setRow)
#上下合并 axis = 0
setColumn = np.concatenate((setC[np.newaxis,:],setD[np.newaxis,:]),axis = 0)
print(setColumn)

[[2 2 2 1 1 1]]
[[2 2 2]
[1 1 1]]

array的分割:
myArr = np.arange(12).reshape(3,4)
print(myArr)
#左右分割
print(np.split(myArr,2,axis = 1))
print(np.hsplit(myArr,2))
#左右不等量分割,分出三个不等量的矩阵
print(np.array_split(myArr,3,axis = 1))
#上下分割
print(np.vsplit(myArr,3))

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]

Numpy 的copy 和deep copy
在numpyArray中,改变了赋值的数,被赋值的数也会跟着改变

#copy,仅copy初始值,不copy后面可能会改变的
print(setC)

setCopy = setC.copy()
#1.更改数组中的某一个值,得是整数
setC[0] = 3
print(setC)
#2.同时改变几个数字:
setC[1:3] = [4,6]
print(setC)
print(setCopy)

[2 2 2]
[3 2 2]
[3 4 6]
[2 2 2]
1
2
3
4

 

友情链接: SITEMAP | 旋风加速器官网 | 旋风软件中心 | textarea | 黑洞加速器 | jiaohess | 老王加速器 | 烧饼哥加速器 | 小蓝鸟 | tiktok加速器 | 旋风加速度器 | 旋风加速 | quickq加速器 | 飞驰加速器 | 飞鸟加速器 | 狗急加速器 | hammer加速器 | trafficace | 原子加速器 | 葫芦加速器 | 麦旋风 | 油管加速器 | anycastly | INS加速器 | INS加速器免费版 | 免费vqn加速外网 | 旋风加速器 | 快橙加速器 | 啊哈加速器 | 迷雾通 | 优途加速器 | 海外播 | 坚果加速器 | 海外vqn加速 | 蘑菇加速器 | 毛豆加速器 | 接码平台 | 接码S | 西柚加速器 | 快柠檬加速器 | 黑洞加速 | falemon | 快橙加速器 | anycast加速器 | ibaidu | moneytreeblog | 坚果加速器 | 派币加速器 | 飞鸟加速器 | 毛豆APP | PIKPAK | 安卓vqn免费 | 一元机场加速器 | 一元机场 | 老王加速器 | 黑洞加速器 | 白石山 | 小牛加速器 | 黑洞加速 | 迷雾通官网 | 迷雾通 | 迷雾通加速器 | 十大免费加速神器 | 猎豹加速器 | 蚂蚁加速器 | 坚果加速器 | 黑洞加速 | 银河加速器 | 猎豹加速器 | 海鸥加速器 | 芒果加速器 | 小牛加速器 | 极光加速器 | 黑洞加速 | movabletype中文网 | 猎豹加速器官网 | 烧饼哥加速器官网 | 旋风加速器度器 | 哔咔漫画 | PicACG | 雷霆加速