为啥DEBIAN CD这么多啊，我全下之后有20G

Posted 2023-05-16

我是想知道后面那些CD里面的东西是什么，常用的服务软件也就那几个，怎么会这么大呢？

参考技术A 没有特殊要求 下载debian-503-i386-CD-1.iso 就可以了！ 参考技术B 一般的下载debian-503-i386-CD-1.iso 就可以了！ 参考技术C 如果下载cd 独立iso文件会比较多。但是和dvd 最终下载下来的文件大小是一样的。 dvd 一般5张 20gb很正常。 安装的时候如果选择的附带安装文件不多，那么第一张dvd光盘就足够用了。 这个是debian 5.03的好处，比centos要好些。 其实如果你需要下载比较小的光盘可以考虑下载netinst 光盘 一般180mg左右大小，前提是需要有互联网。 方便后续安装其他软件包。 参考技术D 安装linux共有五种方法

1、光盘

2、硬盘

3、nfs 映像

4、ftp

5、http

其中光盘安装是最普遍的，也是最简单的我就不写了。我安装的这台机器没有光驱，也没有软驱！！！只有网卡和一个128mu盘^o^

一、硬盘安装分两种情况：

a、是从win系统上安装

b、是从别的linux启动安装

这里介绍大多数人使用的windows系统安装，第二种方法我还没有调过

1、安装系统－－－redhat 9.0，（fedra core 1和2类似，我安装fc3test3的时候发现把硬盘mbr破坏了，且用修复工具都没有办法还原。）我的pc机40g硬盘，主分区只有一个分10gfat32格式，扩展分区30g，其中20g给windows用fat32格式，10g给linuxex3格式。

我安装xp系统在c盘，把redhat9.0的3个iso下载下来，放到d盘根目录red hat linux_i1.iso,red hat linux_i2.iso,red hat linux_i3.iso.

2、用光盘取工具daemon-v3.47把第一张镜像中的dosutils目录解压到d盘根目录，看看其中有没有这几个主要文件：

loadlin.exe

autoboot\initrd.img

autoboot\vmlinuz

一般都比较完整，也不用修改autoboot.bat文件了。

3、制做一个u盘启动盘，这个工作我做了一天，我的u盘是一般的杂牌128m，不带启动。在网上down了usbboot.1.62u盘启动制作工具没有用，用朗科的u盘工具也没有。于是动手自己做，经过实验找到了一种好办法，先将u盘在格式化为fat16或fat32（建议fat32），再用fdisk /mbr清理启动分区，在同事机器上用win98的 sys命令传送系统文件到u盘，这时u盘可以启动了。

4、重新启动系统进bios，把启动设为 usb－fdd，进入dos后到d盘运行dosutils目录下的autoboot.bat

5、这样启动时选择从硬盘安装 /dev/hda5 -----我的d盘

系统自动会找到所有的文件。
怎样安装Linux系统

在Internet迅速发展、上网人数不断增加、网上信息流量越来越大的情况下，你是否为寻找不到一种支持多用户、能够充当Internet服务器、支持图形界面的高速、可靠、廉价的操作系统而苦恼呢？现在，一种可行的解决方案——Linux操作系统出现在人们的面前。是什么使得广大用户对Linux如此着迷？除了Linux永远不会崩溃的神话之外，在486机器上能够照样正常运行，以及与Microsoft产品截然不同的全新风格都可以算得上是Linux备受青睐的原因。“窗”外的世界是怎样的呢?来看看吧!

Linux是开放源代码的免费软件，具有诱人的市场前景，多家厂商都竞相推出自己的Linux产品。不同厂商的Linux产品各有千秋，区别主要在于随Linux核心操作系统一同出售的工具软件不同以及系统的安装过程存在一定的差异。目前，主要的Linux系统经销商有Red

Hat Software、Caldera、 Slackware、 S.u.S.E. 以及Debian等。本文将主要结合目前较为流行，同时也是较为成熟的Red

Hat Linux 6.0版本，对Linux系统的安装和基础应用进行详细地介绍，相信广大读者在看过本文之后再结合自己的学习和实践，一定会在较短的时间内了解Linux，从而为进一步学习和掌握它打下坚实的基础。

本文假定用户在安装Linux之前已经在使用Win 95或Win 98操作系统。对于那些希望只安装Linux系统的用户同样可以参照本文的讲解。

一、安装前的准备

Linux安装光盘支持由光驱启动安装，用户只要对BIOS进行相应设置，就可以由光盘直接启动进入Linux的安装界面。在正式安装Linux操作系统之前，用户应注意以下两个方面的问题：

1.硬盘空间

Linux需要在硬盘上建立自己的磁盘分区，如果用户不希望对现有系统下的硬盘进行重新分区，建议使用一些第三方工具软件，如Partition Magic等，对硬盘上已经存在的分区进行压缩，从而为安装Linux腾出足够空间。用户需要为Linux预留大约500兆硬盘空间，既可以位于已经存在的扩展分区，也可以是没有被划分分区的硬盘空间。Red Hat Linux 6.0可以在安装过程中自己创建分区，所以用户所要做的只是为Linux操作系统预留足够的硬盘空间即可。

2.记录用户机器硬件配置信息

虽然Linux的安装过程已经被尽可能的简化，但是Linux仍然有可能不能自动检测到用户系统中的所有硬件配置。用户在安装过程中可能要回答某些硬件的设置问题，为了保证安装的系统可用，好用，建议用户在安装之前记录下系统的硬件配置信息。一个最简单的方法是在Windows下用鼠标右击“我的电脑”，选中“属性”，在出现的对话框中点击“设备管理”。其中包含了用户需要知道的所有信息，用户尤其应当注意显示器、显卡和声卡的配置情况。

二、开始安装

注意，在启动Linux的安装过程之后，没有类似Windows系统安装中“退出安装”的功能选项。如果用户在安装过程中碰到无法解决的问题而不能继续进行安装时，可以同时按下“Ctrl＋Alt＋Delete”键退出安装过程，等到找到问题的解决方法之后从新进行安装。

Red Hat Linux的安装过程采用图形界面，由键盘进行控制。其中“Tab”键用于在不同的选项之间移动，空格键用于选定或取消对某一项的选择，“Enter”键用于按动屏幕中高亮度突出显示的按钮。在屏幕的底部显示可能会用到的键盘命令。

1.启动安装过程

安装过程一开始，首先出现欢迎对话框，用户按“Enter”键继续。Red Hat先后会询问用户使用何种语言、用户使用的键盘类型（默认选项为美式键盘”）以及安装软件的位置（选择“本地CD－ROM）。在随后的升级或安装系统的询问中选择“安装”，使用何种安装类型选择“自定义安装”。

Red Hat在用户对上述问题作出答复之后，检测用户系统中是否存在SCSI 设备。如果Linux自己没有找到任何的SCSI 设备，就会询问用户是否使用了SCSI 设备。大多数用户可以回答“否”，如果用户确实使用了SCSI 设备，就要在列出的SCSI 设备驱动中进行选择，并提供一些基本的配置参数以便使Linux系统能够正常使用该设备。

2.使用Disk Druid建立Linux文件系统

在第1个过程结束之后，Red Hat将会提示用户建立Linux文件系统。在被询问使用何种工具时，选择Disk Druid。

现在用户需要在预留的硬盘空间中创建两个分区。第一个分区作为Linux的根（root）分区，用于安装Linux文件。第二个分区作为交换分区，用于补充用户的物理内存。该分区相当于Windows 系统中的交换文件，但是Linux需要建立一个独立的交换分区。在硬盘预留空间添加分区的方法如下：

按“F1”键添加分区，输入“／”作为安装点(mount point)，选择Linux Native（Linux本地分区）作为分区类型，然后在设定完分区大小之后按“OK”完成分区添加过程。

用户可以按照同样的步骤添加一个交换分区。注意“安装点”一项空出，选择“Linux Swap”作为分区类型，交换分区的大小不能低于用户物理内存的实际大小。例如，如果用户内存为36MB，交换分区的大小至少应当为36MB。

Disk Druid将会显示出用户添加的两个分区的信息：一个较大的根分区和一个较小的交换分区。用户选择“OK”，当Red Hat询问用户是否将所做的改动保存到分区表时回答“是”。这样就完成了整个分区的添加过程。

在添加完分区之后，用户需要对新分区进行格式化。Red Hat首先格式化交换分区，然后再格式化根分区。建议用户在格式化过程中选择“检查损坏的区块”选项。

4.配置硬件支持

在软件安装完毕之后，Red Hat进入硬件安装阶段，安装程序将会搜索系统的各种硬件，添加必要的驱动程序和库文件。虽然这一阶段的过程大多数都是由安装程序自动完成，但是用户还是需要回答一些安装程序提出的问题。

首先安装程序将检测用户是否使用鼠标，如果是，Red Hat需要用户确认检测结果是否正确。注意，如果用户使用双键鼠标，则应当选择“模拟3键鼠标”的选项。

然后，安装程序询问用户是否需要进行网络配置。如果用户在自己的系统中没有安装网卡，则可以回答“否”；否则，可以选择进行网络配置，Red Hat 将会找到用户机器中的网卡并要求用户输入一些建立网络连接所必须的信息。

接着，在设定用户所在时区之后，需要选择用户使用的打印机的类型和型号。除非用户使用网络打印机，否则在打印机连接中选择“本地打印机”。

接着，设置根用户的口令，这是安装过程中的重要一步。作为一个支持多用户的操作系统，Linux使用一个用户名为“root”的账号作为系统管理员。用户应当为“root”账号选择一个安全性强、容易记忆的口令。在随后的验证设置对话框中提供了几种Red Hat采用的口令服务，用户选择默认选项即可。

在此之后，安装程序建议用户创建一张紧急启动盘以备不时之需。

到此为止，整个安装过程已经接近尾声，最后也是最关键的一步就是配置Linux Loader（即LILO）。该程序在计算机启动时运行，支持多系统启动，用户可以选择是启动到Linux系统，还是进入到以前的Windows 系统。当Red Hat 询问用户希望将LILO安装到何处时，选择主启动记录（Master Boot Record）。在随后的LILO附加选项对话框中选择“OK”之后，将会出现一个可以通过LILO启动的分区列表。如果用户不希望将Linux 作为主操作系统，可以选定被标识为“DOS”的Windows 系统作为LILO的默认启动选项。

5.第一次启动系统

现在，用户可以设置自己的计算机使用X Window系统。Xconfigurator 程序会询问用户一些有关显卡和显示器的设置问题，然后根据用户提供的信息安装相应的驱动程序，并运行测试程序检验设置是否正确。用户可能会在这一阶段碰到许多问题。如果Xconfigurator的设置不正确，安装程序将会一直重复进行设置直到找到正确的配置。用户可以选择“Cancel”略过该过程。

如果Xconfigurator 设置正确，用户可以选择在Linux启动之后立即运行X Window。如果用户选中该选项，在每次启动Linux之后，将会直接出现一个类似于NT登录界面的用户名／口令窗口；否则，将会出现命令行式的登录界面。

在安装程序完成整个安装过程之后，Red Hat将会弹出一个对话框祝贺用户安装成功。在取出安装盘之后，按回车，计算机将重新启动。

计算机重新启动之后，屏幕左上角将会显示出LILO字样，表示LILO程序正在等候用户输入将要启动的操作系统。如果用户按下回车键，将会启动默认系统，按照本文的安装情况将会启动Windows系统。用户如果希望启动linux ，可以在LILO字样后输入“linux”后回车。在显示过一连串的启动信息之后，将会出现登录界面。在用户名处输入“root”，按回车，然后在口令处输入用户在安装过程中为“root”账号设定的口令（注：用户在输入口令时屏幕上不会有任何显示），再次按回车之后，用户就将以系统管理员的身份登录到Linux系统。

“root”账号拥有对整个Linux 系统的管理权限，为了防止对系统的意外改动，建议用户建立一个新的账号。这样在日常使用过程中用户可以使用其它账号，而只有在需要对系统进行管理和设置的时候才使用“root”账号。

下面简单介绍一下如何创建用户账号。

如果用户现在正处在Red Hat默认的GNOME桌面环境下，可以点击屏幕下方任务条中用一个计算机显示器作为图标的按钮，从而启动命令行窗口。在命令行方式下，首先输入命令“useradd username”按回车，其中username代表用户将要创建的账号名。然后为创建的用户账号设定口令，输入命令“passwd username”按回车。其中username代表已经创建的用户账号名。为确保输入的口令正确无误，Linux 将会要求用户再一次输入口令以进行确认。现在用户可以在命令行方式下输入“logout”命令退出“root”账号，然后以新建立的用户账号重新登录。

三、上网浏览

使用Linux 可以做什么呢？我想大多数用户都会迫不及待希望到网上浏览一番。下面就介绍以一下Linux 操作系统下最简单的网络连接方式——KDE程序Kppp（这就是为什么本人建议读者除GNOME之外，安装KDE 的缘故）。

如果用户正处在命令行界面中，可以通过输入“startx”命令启动X Window和GNOME。在运行Kppp程序之前，用户须要对系统进行相应设置。点击任务条中显示器形状的按钮图标启动一个命令窗口，然后输入以下命令：

su

在出现提示之后输入root账号和口令，然后输入：

chmod ＋s ／usr／sbin／pppd

chmod a＋x ／usr／sbin／pppd

mv ／etc／ppp／options ／etc／ppp／options.backup

exit

exit

点击任务条中屏幕形状的按钮，在弹出的菜单中选择“KDE菜单——Internet－Kppp”。启动Kppp之后，选择“Setup”，在随后出现的对话框中选择“Account”标签，然后选择“New”，在弹出的窗口中进行连接配置。点击“Dial”标签，输入一个任意的连接名称和用户的ISP电话号码。点击“IP Setup”标签，如果用户使用固定IP连接ISP，选择“Static”选项；如果用户使用ISP分配的动态IP，则选择“Dynamic”选项。再点击“DNS”标签，输入用户使用的ISP的域名和域名服务器的地址。其他选项，如网关，登录脚本和计费信息等可以空出不填。点击“OK”，返回Kppp主“setup”界面。

现在，用户需要告诉Kppp建立连接使用的Modem的位置。在“Device”标签的下拉菜单中选择用户机器中Modem的位置。默认设置为“／dev／modem”。当用户尝试与ISP建立连接时，如果Kppp找不到Modem就会向用户发出警告。这时，用户需要选择新的位置直到Kppp能够找到Modem（注：“／dev／cua1”是最有可能的选项）。

现在万事俱备。回到Kppp对话框，输入用户名和口令之后，点击“connect”。如果一切正常，Linux将会与ISP建立起点对点的连接，用户就可以实现网上冲浪了.

参考资料：www.cctv.com

为啥 Collections.counter 这么慢？

【中文标题】为啥 Collections.counter 这么慢？

【英文标题】：Why is Collections.counter so slow?为什么 Collections.counter 这么慢？

【发布时间】：2017-05-26 11:36:42

【问题描述】：

我正在尝试解决 Rosalind 的基本问题，即计算给定序列中的核苷酸，并在列表中返回结果。对于那些不熟悉生物信息学的人来说，它只是计算字符串中 4 个不同字符（'A'、'C'、'G'、'T'）的出现次数。

我希望collections.Counter 是最快的方法（首先是因为他们声称具有高性能，其次是因为我看到很多人使用它来解决这个特定问题）。

但令我惊讶的是这种方法最慢！

我比较了三种不同的方法，使用timeit 并运行两种类型的实验：

长序列运行几次 多次运行短序列。

这是我的代码：

import timeit
from collections import Counter

# Method1: using count
def method1(seq):
    return [seq.count('A'), seq.count('C'), seq.count('G'), seq.count('T')]

# method 2: using a loop
def method2(seq):
    r = [0, 0, 0, 0]
    for i in seq:
        if i == 'A':
            r[0] += 1
        elif i == 'C':
            r[1] += 1
        elif i == 'G':
            r[2] += 1
        else:
            r[3] += 1
    return r

# method 3: using Collections.counter
def method3(seq):
    counter = Counter(seq)
    return [counter['A'], counter['C'], counter['G'], counter['T']]


if __name__ == '__main__':

    # Long dummy sequence
    long_seq = 'ACAGCATGCA' * 10000000
    # Short dummy sequence
    short_seq = 'ACAGCATGCA' * 1000

    # Test 1: Running a long sequence once
    print timeit.timeit("method1(long_seq)", setup='from __main__ import method1, long_seq', number=1)
    print timeit.timeit("method2(long_seq)", setup='from __main__ import method2, long_seq', number=1)
    print timeit.timeit("method3(long_seq)", setup='from __main__ import method3, long_seq', number=1)

    # Test2: Running a short sequence lots of times
    print timeit.timeit("method1(short_seq)", setup='from __main__ import method1, short_seq', number=10000)
    print timeit.timeit("method2(short_seq)", setup='from __main__ import method2, short_seq', number=10000)
    print timeit.timeit("method3(short_seq)", setup='from __main__ import method3, short_seq', number=10000)

结果：

Test1: 
Method1: 0.224009990692
Method2: 13.7929501534
Method3: 18.9483819008

Test2:
Method1: 0.224207878113
Method2: 13.8520510197
Method3: 18.9861831665

对于这两个实验，方法 1 比方法 2 和 3快！

所以我有一组问题：

是我做错了什么还是确实比其他两种方法慢？有人可以运行相同的代码并分享结果吗？

如果我的结果是正确的，（也许这应该是另一个问题）有没有比使用方法 1 更快的方法来解决这个问题？

如果count 更快，那么collections.Counter 是怎么回事？

【问题讨论】：

这确实很有趣。您可以稍微修改第一个方法而不计算最后一个（“T”），因为它们应该是序列的len 减去“A”、“C”和“G”。我也要运行它

测试1：方法1：0.24，方法2：19.73，方法3：4.63测试2：方法1：0.26，方法2：19.35，方法3：4.30。至少 counter 比方法 2 更快，这是没有冒犯的错误代码。

没什么好奇怪的。方法 1 使用 C 代码，甚至是非常简单的 C 代码。而你只做了四次。难怪它要快得多。

考虑到您的最后一个问题，想象有 100 个核苷酸而不是 4 个。要对方法 1 进行编码，您必须将 sequence 转换为 set 并为集合中的元素运行循环。它可能会开始变得越来越低效

【参考方案1】：

这不是因为collections.Counter 很慢，它实际上相当快，但它是一个通用工具，计算字符只是众多应用程序之一。

另一方面，str.count 只计算字符串中的字符，并且高度针对其唯一的任务进行了优化。

这意味着str.count 可以在底层 C-char 数组上工作，同时它可以避免在迭代期间创建新的（或查找现有的）length-1-python-strings（这就是 for 和Counter 做）。

---

只是为了给这个语句添加更多上下文。

字符串存储为 C 数组，包装为 python 对象。 str.count 知道字符串是一个连续的数组，因此将您想要 co 的字符转换为 C-“字符”，然后在本机 C 代码中迭代数组并检查是否相等，最后包装并返回发现事件。

另一方面，for 和 Counter 使用 python-iteration-protocol。字符串的每个字符都将被包装为 python-object，然后它（散列并）在 python 中比较它们。

所以减速是因为：

每个字符都必须转换为 Python 对象（这是性能下降的主要原因） 循环在 Python 中完成（不适用于 python 3.x 中的 Counter，因为它是用 C 重写的） 每次比较都必须在 Python 中完成（而不仅仅是比较 C 中的数字 - 字符由数字表示） 计数器需要对值进行哈希处理，并且您的循环需要为您的列表编制索引。

---

注意减速的原因类似于Why are Python's arrays slow?的问题。

---

我做了一些额外的基准测试来找出collections.Counter 比str.count 更受欢迎。为此，我创建了包含不同数量的唯一字符的随机字符串并绘制了性能：

from collections import Counter
import random
import string

characters = string.printable  # 100 different printable characters

results_counter = []
results_count = []
nchars = []

for i in range(1, 110, 10):
    chars = characters[:i]
    string = ''.join(random.choice(chars) for _ in range(10000))
    res1 = %timeit -o Counter(string)
    res2 = %timeit -o char: string.count(char) for char in chars
    nchars.append(len(chars))
    results_counter.append(res1)
    results_count.append(res2)

结果是使用matplotlib绘制的：

import matplotlib.pyplot as plt

plt.figure()

plt.plot(nchars, [i.best * 1000 for i in results_counter], label="Counter",   c='black')
plt.plot(nchars, [i.best * 1000 for i in results_count],   label="str.count", c='red')
plt.xlabel('number of different characters')
plt.ylabel('time to count the chars in a string of length 10000 [ms]')
plt.legend()

Python 3.5 的结果

Python 3.6 的结果非常相似，所以我没有明确列出。

因此，如果您想计算 80 个不同的字符，Counter 会变得更快/可比，因为它只遍历字符串一次，而不是像 str.count 那样多次遍历。这将微弱地依赖于字符串的长度（但测试显示只有非常微弱的差异 +/-2%）。

Python 2.7 的结果

在 Python-2.7 中，collections.Counter 是使用 python（而不是 C）实现的，并且速度要慢得多。 str.count 和 Counter 的盈亏平衡点只能通过外推来估计，因为即使有 100 个不同的字符，str.count 仍然快 6 倍。

【讨论】：

虽然可以理解用户制作的循环，但人们仍然想知道为什么Counter 也不使用 C 代码。看起来很傻。

Counter 确实使用了 C 代码，至少在 python 3.6 中是这样，这使得 in 的性能优于 for 循环，但仍然比 str.count 差。

请同时使用 Python 2 和 Python 3。在 Python 3 中，Counter 用 C 重写。

@dawg 好点。我忘了提到时间是用 python-3.x 完成的。我现在已经包含了它以及 python-2.x 的时间安排

【参考方案2】：

正如其他人已经指出的那样，您正在将相当具体的代码与相当普遍的代码进行比较。

考虑一下，像在你感兴趣的字符上拼出循环这样微不足道的事情已经给你带来了 2 个因素，即

def char_counter(text, chars='ACGT'):
    return [text.count(char) for char in chars]


%timeit method1(short_seq)
# 100000 loops, best of 3: 18.8 µs per loop
%timeit char_counter(short_seq)
# 10000 loops, best of 3: 40.8 µs per loop

%timeit method1(long_seq)
# 10 loops, best of 3: 172 ms per loop
%timeit char_counter(long_seq)
# 1 loop, best of 3: 374 ms per loop

---

您的method1() 是最快的，但不是最有效的，因为对于您正在检查的每个字符，输入都是完全循环的，因此没有利用这样一个事实，即您可以轻松地将循环短路字符被分配给字符类之一。

不幸的是，Python 没有提供一种快速的方法来利用您的问题的特定条件。 但是，您可以为此使用 Cython，然后您将能够超越您的 method1()：

%%cython -c-O3 -c-march=native -a
#cython: language_level=3, boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True, infer_types=True

import numpy as np


cdef void _count_acgt(
        const unsigned char[::1] text,
        unsigned long len_text,
        unsigned long[::1] counts):
    for i in range(len_text):
        if text[i] == b'A':
            counts[0] += 1
        elif text[i] == b'C':
            counts[1] += 1
        elif text[i] == b'G':
            counts[2] += 1
        else:
            counts[3] += 1


cpdef ascii_count_acgt(text):
    counts = np.zeros(4, dtype=np.uint64)
    bin_text = text.encode()
    return _count_acgt(bin_text, len(bin_text), counts)

%timeit ascii_count_acgt(short_seq)
# 100000 loops, best of 3: 12.6 µs per loop
%timeit ascii_count_acgt(long_seq)
# 10 loops, best of 3: 140 ms per loop

【参考方案3】：

这里的时差很容易解释。这一切都归结为在 Python 中运行的内容以及作为本机代码运行的内容。后者总是会更快，因为它不会带来大量的评估开销。

这就是为什么调用str.count() 四次比其他任何方法都快的原因。尽管这会迭代字符串四次，但这些循环在本机代码中运行。 str.count 是用 C 实现的，因此开销很小，因此速度非常快。真的很难打败它，尤其是当任务如此简单时（只寻找简单的字符相等）。

第二种方法，收集数组中的计数实际上是以下性能较低的版本：

def method4 (seq):
    a, c, g, t = 0, 0, 0, 0
    for i in seq:
        if i == 'A':
            a += 1
        elif i == 'C':
            c += 1
        elif i == 'G':
            g += 1
        else:
            t += 1
    return [a, c, g, t]

在这里，所有四个值都是单独的变量，因此更新它们非常快。这实际上比改变列表项要快一些。

然而，这里的整体性能“问题”是在 Python 中迭代字符串 。所以这会创建一个字符串迭代器，然后将每个字符单独生成为一个实际的字符串对象。这是一个很大的开销，也是每个通过迭代 Python 中的字符串 来工作的解决方案都会变慢的主要原因。

collection.Counter 也有同样的问题。它是implemented in Python，因此尽管它非常高效和灵活，但它也存在同样的问题，即它在速度方面永远不会接近原生。