你知道你的电脑1秒钟能做多少事情吗？(代码片段)

关键词：

让我们来看看你有多么了解电脑！所有这些程序的数值都是可变的。你的任务是：在程序花费1秒运行之前猜测它的大概值。

你并不需要猜出一个精确值：选择范围在1和10亿之间。你只要能猜出正确的数量级，就算正确！下面是一些注意事项：

• 如果答案是38,000，那么你选择10,000或100,000，我们就认为都是正确答案。误差只要在10倍范围内就ok:)
• 我们知道不同的计算机有不同的磁盘、网络和CPU速度！我们会告诉运行10次/秒和10万次/秒的代码之间的差别。更新的电脑不会让你的代码运行速度快1000倍:)
• 也就是说，所有这一切都是运行在一台新的拥有一个快速的SSD和一个凑合的网络连接的笔记本电脑上的。 C代码用gcc -O2编译。

祝你好运！

?

欢迎来到第一个程序！这一个只是让你练练手的：1秒能完成多少循环？ （结果可能比你想象得更多！）

猜猜下面的程序每秒执行多少次循环：

加群923414804免费获取数十套PDF资料

#include <stdlib.h>

// Number to guess: How many iterations of
// this loop can we go through in a second?

int main(int argc, char **argv) 
    int NUMBER, i, s;
    NUMBER = atoi(argv[1]);

    for (s = i = 0; i < NUMBER; ++i) 
        s += 1;
    

    return 0;

准确答案：550,000,000

猜猜下面的程序每秒执行多少次循环：

#!/usr/bin/env python

# Number to guess: How many iterations of an
# empty loop can we go through in a second?

def f(NUMBER):
    for _ in xrange(NUMBER):
        pass

import sys
f(int(sys.argv[1]))

准确答案：68,000,000

当我看着代码的时候，我想的是1毫秒完成多少次——我以为是微不足道的，但事实是，即使是Python，你也可以在1毫秒的时间内执行68,000次空循环迭代。

下面让我们来探讨一个更接近现实的用例。在Python中字典几乎是无处不在的，那么在1秒时间内我们可以用Python添加多少元素呢？
然后再来看一个更复杂的操作——使用Python的内置HTTP请求解析器来解析请求。

猜猜下面的程序每秒执行多少次循环：

#!/usr/bin/env python

# Number to guess: How many entries can
# we add to a dictionary in a second?

# Note: we take `i % 1000` to control
# the size of the dictionary

def f(NUMBER):
    d = 
    for i in xrange(NUMBER):
        d[i % 1000] = i

import sys
f(int(sys.argv[1]))

准确答案：11,000,000

猜猜下面的程序每秒处理多少次HTTP请求：

#!/usr/bin/env python

# Number to guess: How many HTTP requests
# can we parse in a second?

from BaseHTTPServer import BaseHTTPRequestHandler
from StringIO import StringIO

class HTTPRequest(BaseHTTPRequestHandler):
    def __init__(self, request_text):
        self.rfile = StringIO(request_text)
        self.raw_requestline = self.rfile.readline()
        self.error_code = self.error_message = None
        self.parse_request()

    def send_error(self, code, message):
        self.error_code = code
        self.error_message = message

request_text = """GET / HTTP/1.1
Host: localhost:8001
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.85 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-GB,en-US;q=0.8,en;q=0.6
"""

def f(NUMBER):
    for _ in range(NUMBER):
        HTTPRequest(request_text)

import sys
f(int(sys.argv[1]))

准确答案：25,000

我们每秒可以解析25,000个小的HTTP请求！有一件事我要在这里指出的是，这里请求解析的代码是用纯Python编写的，而不是C。

接下来，我们要试试下载网页与运行Python脚本！提示：少于1亿:)

猜猜下面的程序每秒可以完成多少次HTTP请求：

#!/usr/bin/env python

# Number to guess: How many times can we
# download google.com in a second?

from urllib2 import urlopen

def f(NUMBER):
    for _ in xrange(NUMBER):
        r = urlopen("http://google.com")
        r.read()

import sys
f(int(sys.argv[1]))

准确答案：4

猜猜下面的程序每秒可以执行多少次循环：

#!/bin/bash

# Number to guess: How many times can we start
# the Python interpreter in a second?

NUMBER=$1

for i in $(seq $NUMBER); do
    python -c ‘‘;
done

准确答案：77

启动程序实际上昂贵在其本身，而不是启动Python。如果我们只是运行/bin/true，那么1秒能做500次，所以看起来运行任何程序只需要大约1毫秒时间。当然，下载网页的快慢很大程度上取决于网页大小，网络连接速度，以及服务器间的距离，不过今天我们不谈网络性能。我的一个朋友说，高性能的网络完成网络往返甚至可能只要250纳秒（！！！），但这是在计算机位置更相邻，硬件更好的情况下。

1秒时间能够在磁盘中写入多少字节？我们都知道写到内存中时速度会更快，但是究竟会快多少呢？对了，下面的代码运行在带有SSD的计算机上。

猜猜下面的程序每秒可以写入多少字节数据：

#!/usr/bin/env python

# Number to guess: How many bytes can we write
# to an output file in a second?
# Note: we make sure everything is sync‘d to disk
# before exiting
import tempfile
import os

CHUNK_SIZE = 1000000
s = "a" * CHUNK_SIZE

def cleanup(f, name):
    f.flush()
    os.fsync(f.fileno())
    f.close()
    try:
        os.remove(name)
    except:
        pass

def f(NUMBER):
    name = ‘./out‘
    f = open(name, ‘w‘)
    bytes_written = 0
    while bytes_written < NUMBER:
        f.write(s)
        bytes_written += CHUNK_SIZE
    cleanup(f, name)

import sys
f(int(sys.argv[1]))

准确答案：342,000,000

猜猜下面的程序每秒可以写入多少字节数据：

#!/usr/bin/env python

# Number to guess: How many bytes can we write
# to a string in memory in a second?

import cStringIO

CHUNK_SIZE = 1000000
s = "a" * CHUNK_SIZE

def f(NUMBER):
    output = cStringIO.StringIO()
    bytes_written = 0
    while bytes_written < NUMBER:
        output.write(s)
        bytes_written += CHUNK_SIZE

import sys
f(int(sys.argv[1]))

准确答案：2,000,000,000

下面轮到文件了！有时候，运行一个大型的grep之后，它可以永恒跑下去。在1秒时间内，grep可以搜索多少字节？
请注意，在这么做的时候，grep正在读取的字节已经在内存中。
文件列表同样需要时间！1秒能列出多少文件？

猜猜下面的程序每秒可以搜索多少字节的数据：

#!/bin/bash 

# Number to guess: How many bytes can `grep`
# search, unsuccessfully, in a second?
# Note: the bytes are in memory

NUMBER=$1

cat /dev/zero | head -c $NUMBER | grep blah
exit 0

准确答案：2,000,000,000

猜猜下面的程序每秒可以列出多少文件：

#!/bin/bash

# Number to guess: How many files can `find` list in a second?
# Note: the files will be in the filesystem cache.

find / -name ‘*‘ 2> /dev/null | head -n $1 > /dev/null

准确答案：325,000

序列化是一个普遍要花费大量时间的地方，让人很蛋疼，特别是如果你反复结束序列化/反序列化相同数据的时候。这里有几个基准：转换64K大小的JSON格式数据，与同样大小的msgpack格式数据。

猜猜下面的程序每秒可以执行多少次循环：

#!/usr/bin/env python

# Number to guess: How many times can we parse
# 64K of JSON in a second?

import json

with open(‘./setup/protobuf/message.json‘) as f:
    message = f.read()

def f(NUMBER):
    for _ in xrange(NUMBER):
        json.loads(message)

import sys
f(int(sys.argv[1]))

准确答案：449

猜猜下面的程序每秒可以执行多少次循环：

#!/usr/bin/env python

# Number to guess: How many times can we parse
# 46K of msgpack data in a second?

import msgpack

with open(‘./setup/protobuf/message.msgpack‘) as f:
    message = f.read()

def f(NUMBER):
    for _ in xrange(NUMBER):
        msgpack.unpackb(message)

import sys
f(int(sys.argv[1]))

准确答案：4,000

数据库。没有任何类似于PostgreSQL花里胡哨的东西，我们做了2份有1000万行数据的SQLite表，一个是有索引的，另一个是未建索引的。

猜猜下面的程序每秒可以执行多少次查询：

#!/usr/bin/env python

# Number to guess: How many times can we
# select a row from an **indexed** table with 
# 10,000,000 rows?

import sqlite3

conn = sqlite3.connect(‘./indexed_db.sqlite‘)
c = conn.cursor()
def f(NUMBER):
    query = "select * from my_table where key = %d" % 5
    for i in xrange(NUMBER):
        c.execute(query)
        c.fetchall()

import sys
f(int(sys.argv[1]))

准确答案：53,000

猜猜下面的程序每秒执行多少次查询：

#!/usr/bin/env python

# Number to guess: How many times can we
# select a row from an **unindexed** table with 
# 10,000,000 rows?

import sqlite3

conn = sqlite3.connect(‘./unindexed_db.sqlite‘)
c = conn.cursor()
def f(NUMBER):
    query = "select * from my_table where key = %d" % 5
    for i in xrange(NUMBER):
        c.execute(query)
        c.fetchall()

import sys
f(int(sys.argv[1]))

准确答案：2

下面要说Hash算法！在这里，我们将比较MD5和bcrypt。用MD5你在1秒时间内可以哈希到相当多的东西，而用bcrypt则不能。

猜猜下面的程序每秒可以哈希多少字节的数据：

#!/usr/bin/env python

# Number to guess: How many bytes can we md5sum in a second?

import hashlib

CHUNK_SIZE = 10000
s = ‘a‘ * CHUNK_SIZE

def f(NUMBER):
    bytes_hashed = 0
    h = hashlib.md5()
    while bytes_hashed < NUMBER:
        h.update(s)
        bytes_hashed += CHUNK_SIZE
    h.digest()
import sys
f(int(sys.argv[1]))

准确答案：455,000,000

猜猜下面的程序每秒可以哈希多少字节的密码：

#!/usr/bin/env python

# Number to guess: How many passwords
# can we bcrypt in a second?

import bcrypt

password = ‘a‘ * 100

def f(NUMBER):
    for _ in xrange(NUMBER):
        bcrypt.hashpw(password, bcrypt.gensalt())

import sys
f(int(sys.argv[1]))

准确答案：3

接下来，我们要说一说内存访问。 现在的CPU有L1和L2缓存，这比主内存访问速度更快。这意味着，循序访问内存通常比不按顺序访问内存能提供更快的代码。

猜猜下面的程序每秒可以向内存写入多少字节数据：

#include <stdlib.h>
#include <stdio.h>

// Number to guess: How big of an array (in bytes)
// can we allocate and fill in a second?

// this is intentionally more complicated than it needs to be
// so that it matches the out-of-order version

int main(int argc, char **argv) 
    int NUMBER, i;
    NUMBER = atoi(argv[1]);

    char* array = malloc(NUMBER);
    int j = 1;
    for (i = 0; i < NUMBER; ++i) 
        j = j * 2;
        if (j > NUMBER) 
            j = j - NUMBER;
        
        array[i] = j;
    

    printf("%d", array[NUMBER / 7]);
    // so that -O2 doesn‘t optimize out the loop

    return 0;

准确答案：376,000,000

猜猜下面的程序每秒可以向内存写入多少字节数据：

#include <stdlib.h>
#include <stdio.h>

// Number to guess: How big of an array (in bytes)
// can we allocate and fill with 5s in a second?
// The catch: We do it out of order instead of in order.
int main(int argc, char **argv) 
    int NUMBER, i;
    NUMBER = atoi(argv[1]);

    char* array = malloc(NUMBER);
    int j = 1;
    for (i = 0; i < NUMBER; ++i) 
        j = j * 2;
        if (j > NUMBER) 
            j = j - NUMBER;
        
        array[j] = j;
    

    printf("%d", array[NUMBER / 7]);
    // so that -O2 doesn‘t optimize out the loop

    return 0;

准确答案：68,000,000

欢迎大家去试一试，给我们留下宝贵的意见。

javascript执行：你知道现在有多少种函数吗？(代码片段)

...文章中，我们大致了解了执行上下文是什么，也知道了任何语句的执行都会依赖特定的上下文。一旦上下文被切换，整个语句的效果可能都会发生改变。那么，切换上下文的时机就显得非常重要了。在JavaScript࿰... 查看详情

调查问卷(代码片段)

...如何编程操作这两种文件？A:不明白。Q:2.4 学了C语言，你知道什么叫面向过程吗？它解决问题的方法是什么？A:面向过程的编程语言解决问题方面比较依靠人为设计，基本上还是一步一步的写。Q:2.5 在C语言里面，什么是模块？你... 查看详情

开源利器分享：bitbar坐看今天你的项目涨了多少star(代码片段)

...我的周遭总是充斥者着各种让人能产生焦虑的信息，我不知道有没有小伙伴和我一样，看到各种神通广大、游戏人生的大侠，低头看看自己当前的处境和生活，默默的叹了口气。我很长一段时间都处于被信息轰炸的焦虑中，感觉... 查看详情

spingioc和di你应该知道事情1(代码片段)

springIOC和springDI作为springcore的核心思想,有必要学习下才能更好的使用spring===================================================================================AbstractXmlApplicationContextabstractXmlApplicationContext=new 查看详情

你知道easyx吗(代码片段)

关于C++控制台上的图形界面，你知道一个东西叫做EasyX吗？作为一个退役的OI选手（WTF?(3^2-3^1)年级退役？），在退役之后总想找点事情做。开发个游戏？（我只会控制台）学下人工智能？（脑子不够用）学一下Py？（爱我C++）好... 查看详情

基础篇css你知道多少？(代码片段)

前言css就像女人的化妆品一样，化妆前后对于web前端来说，书写好css是不容易的一件事情。下面就让我把工作中遇到问题分享给大家。css优先级先看下图优先级选择器的优先权解释说明内联样式表的权值最高1000。ID选择器的权值... 查看详情

mysql有多少文件你知道吗?(代码片段)

MySQL里面的文件多且杂,与我们业务开发相关的也不多,但是对MySQL的整体理解还是需要懂这些知识点,当遇到问题或需要对MySQL做调优时间可以找到对应的切入点.本文对各种常见的MySQL文件做知识点总结,方便以后可以及时查阅复盘... 查看详情

mysql有多少文件你知道吗?(代码片段)

MySQL里面的文件多且杂,与我们业务开发相关的也不多,但是对MySQL的整体理解还是需要懂这些知识点,当遇到问题或需要对MySQL做调优时间可以找到对应的切入点.本文对各种常见的MySQL文件做知识点总结,方便以后可以及时查阅复盘... 查看详情

程序猿每天该做的事

...能提高?一天仅仅提高1%，365天你的效率就能提高多少倍你知道吗？?(1+0.01)^365?=?37?倍?5、看一个实用的新闻站点或读一张实用的报纸，了解业界动态?闭门造车是不行的，了解一下别人都在做什么，对自己能带来非常多启发?6、记住... 查看详情

枚举还有这样的用法你知道吗(代码片段)

　　有时我们会用玫举定义协议，使用枚举的好处是让代码更加清晰，因为它可以描述特定的值，当然对程序员是如此，稍微看下就明白了，如果要你对非技术做运维，甚至连运维都不是的人，如果你单单告诉他某某设备此时返... 查看详情

实现你的第一个链表——手把手教你创建单向链表(代码片段)

...次坐好即可，这就是数组的使用。但是，如果我们预先不知道有多少小朋友，那事情就不好办了， 查看详情

爬虫(代码片段)

...器，可以接受请求将其转发。#匿名度：#高匿名：啥也不知道#匿名：知道你使用了代理，但是不知道你的真实IP#透明：知道你使用了代理并且知道你的真实IP#类 查看详情

除了trycatch，你究竟还知道多少避免空指针异常的骚操作？(代码片段)

        你究竟还知道多少避免空指针异常的那些骚操作？        一个有趣的bug总能找到一个有趣的java8特性！当我们遇到空指针异常时，你还在使用try...catch吗？那就太out啦！这里教你一招使用java8特... 查看详情

flutterdart中的mixins混入你知道是什么吗？(代码片段)

1.写在前面在上篇文章中介绍了Dart中的抽象类和implements，那么现在就继续来学习Dart中的Mixins的混入。【Flutter】苹果Mac电脑配置flutter开发环境【Flutter】AndroidStudio安装第三方模拟器—网易MuMu【Flutter】项目运行报错FailedtofindBu... 查看详情

自动化测试面试题总结

...口测试个人理解，具体还得补全）5、分布式自动化测试知道怎么做的吗？6、你的项目总共有多少自动化用例，跑每个用例多少时间，跑完这个项目的所有用例共花了多少时间？7、需要维护你的用例脚本吗？维护时间是多少？8... 查看详情

如果你的加了一个点击事情的＜a＞标签没有获取到你的数据(代码片段)

看起来没有进行点击操作好像你的点击没用，根据就没有进入点击的函数中在你的a标签的href="#"这个#要加上试试看 查看详情

python的坑--你知道吗？(代码片段)

python的坑--你知道吗？1.列表的坑坑的地方是：因为列表用pop之后,后面的索引都会自动减一#列表的坑之一list1=[‘python‘,‘java‘,‘php‘,‘c‘,‘c++‘,‘c#‘,‘ruby‘]#将索引为奇数的元素删除[‘java‘,‘c‘,‘c#‘]list2=[]foriteminlis... 查看详情

数据科学项目1：构建你的第一个数据科学项目(代码片段)

...。例如：我想开始一个数据科学项目，但我却不知道如何着手进行。我们大多数人都是通过一些在线课程了解了这个领域。我们对课程中布置的作业和项 查看详情