请教 无线通信设备中的radio 中文叫什么?# EE - 电子工程
e*c
1 楼
c*9
2 楼
《灯火阑珊 》之二十
“抱歉抱歉，让你久等。”浩实从里面出来。他看到肖佳悦脸色有些异样，望着他若有
所思，和刚才带着微微傲慢的审视全然不同。他有些困惑了。
“好好爱雨珊，她是这个世界上最纯净的女人。好好保护她，不要让她再受伤。”
肖佳悦丢下几句话，走了。
浩实没有完全明白肖佳悦的意思，但他是乐观的人，他觉得肖佳悦的话里带着鼓励，这
样想，他心情明朗起来。
肖佳悦在当天晚上不请自到，来到雨珊的住处。两个闺蜜一边做晚饭，一边聊起白天的
一幕，
“你不知道，然然多乖巧多懂事，她妈妈那么伶牙俐齿的女人能教育出这么知书达理的
小女孩，”雨珊今天特别开心。
“和我聊聊那个王浩实，你的大英雄，你的王教授，”肖佳悦故意拐入正题。
“哎呀，只是刚刚认识。他人很好，正直，热心，反正我们接触不多了，”雨珊有点微
微害羞。
“热心？他对你别有用心，傻子都看得出来。”
“雨珊，听我说，好的男人不多，机会稍纵即逝。你把自己 封闭太久了，如果觉得可
能，就放下顾虑，试一试相处。我觉得浩实是值得依靠的男人……”
肖佳悦这时候发现，雨珊的眼里有一层雾，她吃惊地捧起雨珊的脸，
“佳悦，你知道的，你知道我所有的一切。我12岁时候的意外，我想忘掉，我很努力忘
掉，可我还是会做恶梦。佳悦，我是病人，我不是正常的女人。我已经赶走了一个秦一
剑，我不想再伤害浩实。你说得对，浩实是好男人，浩实是值得依靠的男人，可是他不
会娶一个病人，他是男人他就不会要我。他就是娶我，他也是同情我。佳悦，不要再给
我希望了，我没有权利再爱了……”雨珊说地从断断续续，到声泪俱下。
肖佳悦开始激动，开始气愤，她用力晃动雨珊的肩膀，
“江雨珊，你20岁的时候我就和你说过，我不允许你输给一桩往事，我也不允许你败给
自己，这些你都忘了吗？王浩实不是秦一剑，他比秦一剑成熟，比秦一剑有阅历。浩实
如果爱你就会包容你，根本不会在乎你的任何缺陷，况且，你的病在你的心里。你懦弱
，你逃避，你不敢面对是你最大的病。雨珊，你还没有意识到吗?你无可救药了，你连
尝试改变自己的勇气都没有。要我说，不要谈爱情，你根本不配活着。要么你就精彩地
活着，享受爱情和美好，要么你就去死，去为你12岁的江雨珊，去为你的早逝的初恋陪
葬……”
肖佳悦说的气愤填膺，雨珊泣不成声。
“佳悦，给我勇气，不要放弃我。我会勇敢，我会坚强，为了浩实，为了我自己。我，
我爱浩实，我爱他的。”
星期天的早上，浩实一觉醒来天已经大亮。他想着今天要约雨珊，如果今天约不成就明
天，明天约不成就后天。
手机响起来，居然是雨珊的号码，他惊喜万分，
“王教授吗？我是雨珊。感谢你那日为我解围，还有介绍我做然然的家教老师，我想看
你那天有时间请你吃饭。”
这是雨珊吗，真的是吗？天呀，一切太不可思议了。浩实下意识掐一下自己证实不是在
做梦。雨珊不仅不再拒绝他，还主动接近他。雨珊信任他，这是一个美好的开始。
“当然有时间，任何时候都有时间，现在好吗？先去喝茶，再去吃午餐，我们看电影，
再去吃晚餐，还可以去吃夜宵……”浩实真的要疯了。
“这样吧，我们先去吃午餐，一会儿我把地址发给你。”
“好呀，你说什么都好，”浩实从床上一跃而起。他觉得今天是他回国以来最开心的一
天。
“抱歉抱歉，让你久等。”浩实从里面出来。他看到肖佳悦脸色有些异样，望着他若有
所思，和刚才带着微微傲慢的审视全然不同。他有些困惑了。
“好好爱雨珊，她是这个世界上最纯净的女人。好好保护她，不要让她再受伤。”
肖佳悦丢下几句话，走了。
浩实没有完全明白肖佳悦的意思，但他是乐观的人，他觉得肖佳悦的话里带着鼓励，这
样想，他心情明朗起来。
肖佳悦在当天晚上不请自到，来到雨珊的住处。两个闺蜜一边做晚饭，一边聊起白天的
一幕，
“你不知道，然然多乖巧多懂事，她妈妈那么伶牙俐齿的女人能教育出这么知书达理的
小女孩，”雨珊今天特别开心。
“和我聊聊那个王浩实，你的大英雄，你的王教授，”肖佳悦故意拐入正题。
“哎呀，只是刚刚认识。他人很好，正直，热心，反正我们接触不多了，”雨珊有点微
微害羞。
“热心？他对你别有用心，傻子都看得出来。”
“雨珊，听我说，好的男人不多，机会稍纵即逝。你把自己 封闭太久了，如果觉得可
能，就放下顾虑，试一试相处。我觉得浩实是值得依靠的男人……”
肖佳悦这时候发现，雨珊的眼里有一层雾，她吃惊地捧起雨珊的脸，
“佳悦，你知道的，你知道我所有的一切。我12岁时候的意外，我想忘掉，我很努力忘
掉，可我还是会做恶梦。佳悦，我是病人，我不是正常的女人。我已经赶走了一个秦一
剑，我不想再伤害浩实。你说得对，浩实是好男人，浩实是值得依靠的男人，可是他不
会娶一个病人，他是男人他就不会要我。他就是娶我，他也是同情我。佳悦，不要再给
我希望了，我没有权利再爱了……”雨珊说地从断断续续，到声泪俱下。
肖佳悦开始激动，开始气愤，她用力晃动雨珊的肩膀，
“江雨珊，你20岁的时候我就和你说过，我不允许你输给一桩往事，我也不允许你败给
自己，这些你都忘了吗？王浩实不是秦一剑，他比秦一剑成熟，比秦一剑有阅历。浩实
如果爱你就会包容你，根本不会在乎你的任何缺陷，况且，你的病在你的心里。你懦弱
，你逃避，你不敢面对是你最大的病。雨珊，你还没有意识到吗?你无可救药了，你连
尝试改变自己的勇气都没有。要我说，不要谈爱情，你根本不配活着。要么你就精彩地
活着，享受爱情和美好，要么你就去死，去为你12岁的江雨珊，去为你的早逝的初恋陪
葬……”
肖佳悦说的气愤填膺，雨珊泣不成声。
“佳悦，给我勇气，不要放弃我。我会勇敢，我会坚强，为了浩实，为了我自己。我，
我爱浩实，我爱他的。”
星期天的早上，浩实一觉醒来天已经大亮。他想着今天要约雨珊，如果今天约不成就明
天，明天约不成就后天。
手机响起来，居然是雨珊的号码，他惊喜万分，
“王教授吗？我是雨珊。感谢你那日为我解围，还有介绍我做然然的家教老师，我想看
你那天有时间请你吃饭。”
这是雨珊吗，真的是吗？天呀，一切太不可思议了。浩实下意识掐一下自己证实不是在
做梦。雨珊不仅不再拒绝他，还主动接近他。雨珊信任他，这是一个美好的开始。
“当然有时间，任何时候都有时间，现在好吗？先去喝茶，再去吃午餐，我们看电影，
再去吃晚餐，还可以去吃夜宵……”浩实真的要疯了。
“这样吧，我们先去吃午餐，一会儿我把地址发给你。”
“好呀，你说什么都好，”浩实从床上一跃而起。他觉得今天是他回国以来最开心的一
天。
s*e
3 楼
俺突然想起了，那句“欲练神功，挥刀子宫”的名言
p*y
4 楼
1. 防治胃肠溃疡
患胃肠道溃疡的患者常服用保泰松，往往会胃溃疡出血。如果在服用保泰松之后吃
些香蕉就可以完全保护胃不发生溃疡，因为香蕉中含有一种能预防胃溃疡的化学物质，
它能刺激胃黏膜细胞的生长繁殖，产生更多的黏膜来保护胃。
2. 治高血压
高血压和心血管疾病患者体内往往钠多钾少，而香蕉富含钾离子。钾离子有抑制钠
离子收缩血管和损坏心血管的作用。吃香蕉能维持体内钾钠平衡和酸碱平衡，使神经肌
肉保持正常，心肌收缩协调，所以每日食香蕉3-5个，对高血压及心血管病患者有益无
害。
3. 治疗忧郁症
新近发现，香蕉含有一种物质，能够帮助人脑产生5-羟色胺，使人心情变得愉快舒
畅、活泼开朗，所以，忧郁症患者平时应适量多吃香蕉，可减少引起情绪低落的激素，
使悲观失望、厌世烦躁的情绪逐渐消散。
4. 治皮肤瘙痒症
香蕉皮中含有蕉皮素，它可抑制真菌，经实验，用香蕉皮治疗由真菌或细菌所引起
的皮肤瘙痒及脚气病，效果良好。患者可精选新鲜的香蕉皮在皮肤瘙痒处反复摩擦，或
用香蕉皮捣成泥涂抹，或用香蕉皮煎水洗涤，连用数日，即可奏效。
5. 治痔疮及便血
每日空腹吃香
患胃肠道溃疡的患者常服用保泰松，往往会胃溃疡出血。如果在服用保泰松之后吃
些香蕉就可以完全保护胃不发生溃疡，因为香蕉中含有一种能预防胃溃疡的化学物质，
它能刺激胃黏膜细胞的生长繁殖，产生更多的黏膜来保护胃。
2. 治高血压
高血压和心血管疾病患者体内往往钠多钾少，而香蕉富含钾离子。钾离子有抑制钠
离子收缩血管和损坏心血管的作用。吃香蕉能维持体内钾钠平衡和酸碱平衡，使神经肌
肉保持正常，心肌收缩协调，所以每日食香蕉3-5个，对高血压及心血管病患者有益无
害。
3. 治疗忧郁症
新近发现，香蕉含有一种物质，能够帮助人脑产生5-羟色胺，使人心情变得愉快舒
畅、活泼开朗，所以，忧郁症患者平时应适量多吃香蕉，可减少引起情绪低落的激素，
使悲观失望、厌世烦躁的情绪逐渐消散。
4. 治皮肤瘙痒症
香蕉皮中含有蕉皮素，它可抑制真菌，经实验，用香蕉皮治疗由真菌或细菌所引起
的皮肤瘙痒及脚气病，效果良好。患者可精选新鲜的香蕉皮在皮肤瘙痒处反复摩擦，或
用香蕉皮捣成泥涂抹，或用香蕉皮煎水洗涤，连用数日，即可奏效。
5. 治痔疮及便血
每日空腹吃香
t*o
5 楼
用python和java做一些data pre-processing.
非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
文件稍微大一点，10MB-100MB吧。
发现python is much slower than java, 6X slower.
python performance 这么差呀。
非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
文件稍微大一点，10MB-100MB吧。
发现python is much slower than java, 6X slower.
python performance 这么差呀。
r*9
6 楼
谢谢
w*r
7 楼
不错，多活一天是一天
【在 s**********e 的大作中提到】
: 俺突然想起了，那句“欲练神功，挥刀子宫”的名言
【在 s**********e 的大作中提到】
: 俺突然想起了，那句“欲练神功，挥刀子宫”的名言
j*z
8 楼
这个。。。
food版的东东？怎么跑wisdom版来了？
food版的东东？怎么跑wisdom版来了？
a*e
9 楼
编译语言和解释语言可以这么比？
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
w*d
10 楼
无线电
g*1
11 楼
但是关版了，哈哈
【在 s**********e 的大作中提到】
: 俺突然想起了，那句“欲练神功，挥刀子宫”的名言
【在 s**********e 的大作中提到】
: 俺突然想起了，那句“欲练神功，挥刀子宫”的名言
P*a
12 楼
Wisdom版鼓励素食和健康的生活习惯．
【在 j********z 的大作中提到】
: 这个。。。
: food版的东东？怎么跑wisdom版来了？
【在 j********z 的大作中提到】
: 这个。。。
: food版的东东？怎么跑wisdom版来了？
L*r
13 楼
hehe,
use profile to see where is the bottleneck.
try to use its c module or pipe data to it.
use functional programming instead of loop.
I have used it to handle files. files are nG per file(>10G after compression
perf file). hehehe
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
use profile to see where is the bottleneck.
try to use its c module or pipe data to it.
use functional programming instead of loop.
I have used it to handle files. files are nG per file(>10G after compression
perf file). hehehe
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
c*e
14 楼
开玩笑怎的？
H*o
15 楼
他早把那个破版关了，不就没事了么？
发信人: goooo1111 (能量都凝聚在爪子里了), 信区: Thoughts
标 题: Re: 今天老邢没杀人
发信站: BBS 未名空间站 (Tue Sep 29 08:46:37 2009, 美东)
但是关版了，哈哈
【在 s**********e 的大作中提到】
: 俺突然想起了，那句“欲练神功，挥刀子宫”的名言
发信人: goooo1111 (能量都凝聚在爪子里了), 信区: Thoughts
标 题: Re: 今天老邢没杀人
发信站: BBS 未名空间站 (Tue Sep 29 08:46:37 2009, 美东)
但是关版了，哈哈
【在 s**********e 的大作中提到】
: 俺突然想起了，那句“欲练神功，挥刀子宫”的名言
M*8
16 楼
zan
【在 P******a 的大作中提到】
: Wisdom版鼓励素食和健康的生活习惯．
l*a
17 楼
分析瓶颈,用cython重写
还有贴下核心处理步骤,不应该慢这么多啊
还有贴下核心处理步骤,不应该慢这么多啊
c*c
18 楼
fangshe
【在 r****9 的大作中提到】
: 谢谢
【在 r****9 的大作中提到】
: 谢谢
s*e
19 楼
只是关了7天
A*u
20 楼
这那是合理得比较
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
L*t
21 楼
射频
【在 r****9 的大作中提到】
: 谢谢
【在 r****9 的大作中提到】
: 谢谢
w*r
22 楼
刚闻kapopo被杀了
【在 g*******1 的大作中提到】
: 但是关版了，哈哈
【在 g*******1 的大作中提到】
: 但是关版了，哈哈
g*g
23 楼
差不多，你的问题跟这个类似，5到6倍正常。
Read DNA sequences - write their reverse-complement
http://shootout.alioth.debian.org/u64q/performance.php?test=rev
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
Read DNA sequences - write their reverse-complement
http://shootout.alioth.debian.org/u64q/performance.php?test=rev
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
n*g
24 楼
收音机
e*n
25 楼
说啥呢
俺不明白
哪个板被关了7天？
俺不明白
哪个板被关了7天？
j*a
26 楼
我上次用c和python各写一个程序处理同一个二进制文件，速度没差多少
顶多1.5x
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
顶多1.5x
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
k*2
27 楼
射频
e*n
28 楼
8天!!
【在 s**********e 的大作中提到】
: 只是关了7天
【在 s**********e 的大作中提到】
: 只是关了7天
l*a
29 楼
这个靠谱,跟我的感觉一样
【在 j*a 的大作中提到】
: 我上次用c和python各写一个程序处理同一个二进制文件，速度没差多少
: 顶多1.5x
c*c
30 楼
射频是radio frequency，radio应该就是取放射的意思吧，anyway，意会就可以了
s*e
31 楼
这回彻底愤怒了，
N*m
32 楼
orange vs apple
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
g*1
33 楼
才注意到你的nick
【在 s**********e 的大作中提到】
: 这回彻底愤怒了，
【在 s**********e 的大作中提到】
: 这回彻底愤怒了，
d*q
34 楼
这种处理 更有可能是没用对
还不一定需要cython出马。
除非有大量的密集型计算。
【在 l********a 的大作中提到】
: 分析瓶颈,用cython重写
: 还有贴下核心处理步骤,不应该慢这么多啊
还不一定需要cython出马。
除非有大量的密集型计算。
【在 l********a 的大作中提到】
: 分析瓶颈,用cython重写
: 还有贴下核心处理步骤,不应该慢这么多啊
y*z
35 楼
.....
【在 g*******1 的大作中提到】
: 才注意到你的nick
【在 g*******1 的大作中提到】
: 才注意到你的nick
t*o
36 楼
谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
然后写到一个新的文件。
我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
，居然比c#还快。
pos = 10; // 11th column of the data
valueMap = {}
cnt = 0
for ln in sys.stdin:
vals = ln.split('\t')
val = vals[pos]
if val == null or len(val) == 0: continue
else:
if (not valueMap.has_key(val)):
valueMap[val] = len(valueMap) + 1
line = ""
for e in vals[:pos]:
line += e + '\t'
line += str(valueMap[val]) + '\t'
for e in vals[pos+1:]:
line += e + '\t'
sys.stdout.write(line[:len(line)-1])
cnt += 1
if cnt % 1000 == 0:
sys.stderr.write(str(cnt) + ' lines processed\n')
sys.stdin.close()
sys.stdout.close()
我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
然后写到一个新的文件。
我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
，居然比c#还快。
pos = 10; // 11th column of the data
valueMap = {}
cnt = 0
for ln in sys.stdin:
vals = ln.split('\t')
val = vals[pos]
if val == null or len(val) == 0: continue
else:
if (not valueMap.has_key(val)):
valueMap[val] = len(valueMap) + 1
line = ""
for e in vals[:pos]:
line += e + '\t'
line += str(valueMap[val]) + '\t'
for e in vals[pos+1:]:
line += e + '\t'
sys.stdout.write(line[:len(line)-1])
cnt += 1
if cnt % 1000 == 0:
sys.stderr.write(str(cnt) + ' lines processed\n')
sys.stdin.close()
sys.stdout.close()
r*n
37 楼
Ocaml很快啊, haskel跟java也差不多了.
【在 g*****g 的大作中提到】
: 差不多，你的问题跟这个类似，5到6倍正常。
: Read DNA sequences - write their reverse-complement
: http://shootout.alioth.debian.org/u64q/performance.php?test=rev
【在 g*****g 的大作中提到】
: 差不多，你的问题跟这个类似，5到6倍正常。
: Read DNA sequences - write their reverse-complement
: http://shootout.alioth.debian.org/u64q/performance.php?test=rev
r*n
38 楼
我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
def process_file(input_file, output_file):
pos = 10
valueMap = dict()
cnt = 0
output = []
with open(input_file, 'r') as f:
lines = f.readlines()
for each_line in lines:
vals = each_line.split('\t')
val = vals[pos]
if val == '' or val == 'null':
continue
else:
if val not in valueMap:
valueMap[val] = len(valueMap) + 1
part1 = '\t'.join(vals[:pos])
part2 = '\t' + str(valueMap[val]) + '\t'
part3 = '\t'.join(vals[pos+1:])
output.append(part1 + part2 + part3)
cnt += 1
if cnt % 1000 == 0:
output.append(str(cnt) + 'lines processed')
with open(out_file, 'w') as f:
f.write('\n'.join(output))
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
def process_file(input_file, output_file):
pos = 10
valueMap = dict()
cnt = 0
output = []
with open(input_file, 'r') as f:
lines = f.readlines()
for each_line in lines:
vals = each_line.split('\t')
val = vals[pos]
if val == '' or val == 'null':
continue
else:
if val not in valueMap:
valueMap[val] = len(valueMap) + 1
part1 = '\t'.join(vals[:pos])
part2 = '\t' + str(valueMap[val]) + '\t'
part3 = '\t'.join(vals[pos+1:])
output.append(part1 + part2 + part3)
cnt += 1
if cnt % 1000 == 0:
output.append(str(cnt) + 'lines processed')
with open(out_file, 'w') as f:
f.write('\n'.join(output))
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
n*w
39 楼
那个是mono的c#。很好奇微软的c#会是多少。
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
X*r
40 楼
何必把每行split再join呢，找到第pos-1和第pos个\t的位置，把中间那段的内容换一
下就好了。
而且好象也没有必要在内存维持输出文件的所有内容，边处理边写就是了。
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
下就好了。
而且好象也没有必要在内存维持输出文件的所有内容，边处理边写就是了。
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
r*n
41 楼
~~~~~~~~~~~~~同意
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
我觉得读文件一块读一块写要快些
【在 X****r 的大作中提到】
: 何必把每行split再join呢，找到第pos-1和第pos个\t的位置，把中间那段的内容换一
: 下就好了。
: 而且好象也没有必要在内存维持输出文件的所有内容，边处理边写就是了。
m*t
42 楼
大数据的操作是要优化的
c里面一次读个几G处理完再写回去，比边读边写快十倍都不止
c里面一次读个几G处理完再写回去，比边读边写快十倍都不止
j*a
43 楼
这是你的代码问题了，看上去就显得啰嗦臃肿。
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
M*P
44 楼
avoid string += anotherstring
using join instead.
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
using join instead.
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
h*n
45 楼
字符串加法用得太多了，这样很慢，尤其是这样在尾端一点一点添加的方式。你可以试
试先split，改掉第pos个单元，然后一次性join起来。
减少读写操作的次数也可能有帮助，难说每次读些需要做哪些额外的工作，放在循环里
的话也会影响速度。
试先split，改掉第pos个单元，然后一次性join起来。
减少读写操作的次数也可能有帮助，难说每次读些需要做哪些额外的工作，放在循环里
的话也会影响速度。
t*o
46 楼
谢谢大家的讨论，看来我的python code自己也有问题。
多谢。
多谢。
v*s
47 楼
我这段代码貌似快了不少。 你的用了10秒钟处理1M lines， 我这个3.9秒。 你试试看。
测试的时候都是重新定向到文件。 直接输出到屏幕那个太慢。
我把你的文件中间“xxx lines processed” 也去掉了。
import sys
pos = 10
valueMap = {}
cnt = 0
for line in sys.stdin:
vals = line.split('\t')
val = vals[pos]
if not val:
continue
else:
if not val in valueMap:
valueMap[val] = str(len(valueMap) + 1)
vals[pos] = valueMap[val]
sys.stdout.write('\t'.join(vals))
sys.stdin.close()
sys.stdout.close()
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
测试的时候都是重新定向到文件。 直接输出到屏幕那个太慢。
我把你的文件中间“xxx lines processed” 也去掉了。
import sys
pos = 10
valueMap = {}
cnt = 0
for line in sys.stdin:
vals = line.split('\t')
val = vals[pos]
if not val:
continue
else:
if not val in valueMap:
valueMap[val] = str(len(valueMap) + 1)
vals[pos] = valueMap[val]
sys.stdout.write('\t'.join(vals))
sys.stdin.close()
sys.stdout.close()
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
w*i
48 楼
use
try: do_sth(valueMap[val])
except KeyError: Init(valueMap[val])
instead of
if val not in valueMap: Init(valueMap[val])
do_sth(valueMap[val])
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
try: do_sth(valueMap[val])
except KeyError: Init(valueMap[val])
instead of
if val not in valueMap: Init(valueMap[val])
do_sth(valueMap[val])
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
r*n
49 楼
这样的好处是什么?
我一直不喜欢程序里放好多
try
except
【在 w****i 的大作中提到】
: use
: try: do_sth(valueMap[val])
: except KeyError: Init(valueMap[val])
: instead of
: if val not in valueMap: Init(valueMap[val])
: do_sth(valueMap[val])
我一直不喜欢程序里放好多
try
except
【在 w****i 的大作中提到】
: use
: try: do_sth(valueMap[val])
: except KeyError: Init(valueMap[val])
: instead of
: if val not in valueMap: Init(valueMap[val])
: do_sth(valueMap[val])
v*s
50 楼
如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
我改成exception 仅仅提高了0.1秒。
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
我改成exception 仅仅提高了0.1秒。
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
l*a
51 楼
+1,我也讨厌try
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
w*i
52 楼
估计时间都花在split()上了，如果你的data远多于10列，试试
vals = line.split('\t', 11)
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
vals = line.split('\t', 11)
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
h*n
53 楼
但是exception机制本身是比较慢的，尽量少用。
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
v*s
54 楼
我一共只有12个，不知道楼主原来的数据是什么样子。
受教了，谢谢。
【在 w****i 的大作中提到】
: 估计时间都花在split()上了，如果你的data远多于10列，试试
: vals = line.split('\t', 11)
受教了，谢谢。
【在 w****i 的大作中提到】
: 估计时间都花在split()上了，如果你的data远多于10列，试试
: vals = line.split('\t', 11)
t*o
55 楼
thanks vvs' improved code.
I tried with the new code and indeeded it improved a lot on running speed.
Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
This seems also aligned with data points some folks here have - cool~
My data is wide - (tens) of thousands of columns.
As i said, i probably just go with java directly - 2.5x still matters a lot
to me :)
Thanks for all discussions!
I tried with the new code and indeeded it improved a lot on running speed.
Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
This seems also aligned with data points some folks here have - cool~
My data is wide - (tens) of thousands of columns.
As i said, i probably just go with java directly - 2.5x still matters a lot
to me :)
Thanks for all discussions!
g*g
56 楼
You have to compare apple to apple, your java code may not
be optimized either.
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
be optimized either.
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
v*s
57 楼
你把java code也贴出来，好虫大侠说不定看着不爽了帮你调一把，呵呵。
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
v*s
58 楼
你有那么多column，那么使用split('\t',11) 要快的多了。
测试文件是3000行， 每行1万列。 size 84M
$ wc p0.txt
3000 30000000 87597247 p0.txt
$ ls -lh p0.txt
-rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
$ time python a2.py < p0.txt > p2out.txt
real 0m4.213s
user 0m2.759s
sys 0m1.440s
$ time python a3.py < p0.txt > p3out.txt
real 0m1.653s
user 0m0.214s
sys 0m1.432s
$ diff a2.py a3.py
6c6
< vals = line.split('\t')
---
> vals = line.split('\t',11)
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
测试文件是3000行， 每行1万列。 size 84M
$ wc p0.txt
3000 30000000 87597247 p0.txt
$ ls -lh p0.txt
-rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
$ time python a2.py < p0.txt > p2out.txt
real 0m4.213s
user 0m2.759s
sys 0m1.440s
$ time python a3.py < p0.txt > p3out.txt
real 0m1.653s
user 0m0.214s
sys 0m1.432s
$ diff a2.py a3.py
6c6
< vals = line.split('\t')
---
> vals = line.split('\t',11)
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
t*o
59 楼
用python和java做一些data pre-processing.
非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
文件稍微大一点，10MB-100MB吧。
发现python is much slower than java, 6X slower.
python performance 这么差呀。
非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
文件稍微大一点，10MB-100MB吧。
发现python is much slower than java, 6X slower.
python performance 这么差呀。
a*e
60 楼
编译语言和解释语言可以这么比？
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
L*r
61 楼
hehe,
use profile to see where is the bottleneck.
try to use its c module or pipe data to it.
use functional programming instead of loop.
I have used it to handle files. files are nG per file(>10G after compression
perf file). hehehe
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
use profile to see where is the bottleneck.
try to use its c module or pipe data to it.
use functional programming instead of loop.
I have used it to handle files. files are nG per file(>10G after compression
perf file). hehehe
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
l*a
62 楼
分析瓶颈,用cython重写
还有贴下核心处理步骤,不应该慢这么多啊
还有贴下核心处理步骤,不应该慢这么多啊
A*u
63 楼
这那是合理得比较
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
g*g
64 楼
差不多，你的问题跟这个类似，5到6倍正常。
Read DNA sequences - write their reverse-complement
http://shootout.alioth.debian.org/u64q/performance.php?test=rev
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
Read DNA sequences - write their reverse-complement
http://shootout.alioth.debian.org/u64q/performance.php?test=rev
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
j*a
65 楼
我上次用c和python各写一个程序处理同一个二进制文件，速度没差多少
顶多1.5x
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
顶多1.5x
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
l*a
66 楼
这个靠谱,跟我的感觉一样
【在 j*a 的大作中提到】
: 我上次用c和python各写一个程序处理同一个二进制文件，速度没差多少
: 顶多1.5x
N*m
67 楼
orange vs apple
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
d*q
68 楼
这种处理 更有可能是没用对
还不一定需要cython出马。
除非有大量的密集型计算。
【在 l********a 的大作中提到】
: 分析瓶颈,用cython重写
: 还有贴下核心处理步骤,不应该慢这么多啊
还不一定需要cython出马。
除非有大量的密集型计算。
【在 l********a 的大作中提到】
: 分析瓶颈,用cython重写
: 还有贴下核心处理步骤,不应该慢这么多啊
t*o
69 楼
谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
然后写到一个新的文件。
我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
，居然比c#还快。
pos = 10; // 11th column of the data
valueMap = {}
cnt = 0
for ln in sys.stdin:
vals = ln.split('\t')
val = vals[pos]
if val == null or len(val) == 0: continue
else:
if (not valueMap.has_key(val)):
valueMap[val] = len(valueMap) + 1
line = ""
for e in vals[:pos]:
line += e + '\t'
line += str(valueMap[val]) + '\t'
for e in vals[pos+1:]:
line += e + '\t'
sys.stdout.write(line[:len(line)-1])
cnt += 1
if cnt % 1000 == 0:
sys.stderr.write(str(cnt) + ' lines processed\n')
sys.stdin.close()
sys.stdout.close()
我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
然后写到一个新的文件。
我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
，居然比c#还快。
pos = 10; // 11th column of the data
valueMap = {}
cnt = 0
for ln in sys.stdin:
vals = ln.split('\t')
val = vals[pos]
if val == null or len(val) == 0: continue
else:
if (not valueMap.has_key(val)):
valueMap[val] = len(valueMap) + 1
line = ""
for e in vals[:pos]:
line += e + '\t'
line += str(valueMap[val]) + '\t'
for e in vals[pos+1:]:
line += e + '\t'
sys.stdout.write(line[:len(line)-1])
cnt += 1
if cnt % 1000 == 0:
sys.stderr.write(str(cnt) + ' lines processed\n')
sys.stdin.close()
sys.stdout.close()
r*n
70 楼
Ocaml很快啊, haskel跟java也差不多了.
【在 g*****g 的大作中提到】
: 差不多，你的问题跟这个类似，5到6倍正常。
: Read DNA sequences - write their reverse-complement
: http://shootout.alioth.debian.org/u64q/performance.php?test=rev
【在 g*****g 的大作中提到】
: 差不多，你的问题跟这个类似，5到6倍正常。
: Read DNA sequences - write their reverse-complement
: http://shootout.alioth.debian.org/u64q/performance.php?test=rev
r*n
71 楼
我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
def process_file(input_file, output_file):
pos = 10
valueMap = dict()
cnt = 0
output = []
with open(input_file, 'r') as f:
lines = f.readlines()
for each_line in lines:
vals = each_line.split('\t')
val = vals[pos]
if val == '' or val == 'null':
continue
else:
if val not in valueMap:
valueMap[val] = len(valueMap) + 1
part1 = '\t'.join(vals[:pos])
part2 = '\t' + str(valueMap[val]) + '\t'
part3 = '\t'.join(vals[pos+1:])
output.append(part1 + part2 + part3)
cnt += 1
if cnt % 1000 == 0:
output.append(str(cnt) + 'lines processed')
with open(out_file, 'w') as f:
f.write('\n'.join(output))
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
def process_file(input_file, output_file):
pos = 10
valueMap = dict()
cnt = 0
output = []
with open(input_file, 'r') as f:
lines = f.readlines()
for each_line in lines:
vals = each_line.split('\t')
val = vals[pos]
if val == '' or val == 'null':
continue
else:
if val not in valueMap:
valueMap[val] = len(valueMap) + 1
part1 = '\t'.join(vals[:pos])
part2 = '\t' + str(valueMap[val]) + '\t'
part3 = '\t'.join(vals[pos+1:])
output.append(part1 + part2 + part3)
cnt += 1
if cnt % 1000 == 0:
output.append(str(cnt) + 'lines processed')
with open(out_file, 'w') as f:
f.write('\n'.join(output))
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
n*w
72 楼
那个是mono的c#。很好奇微软的c#会是多少。
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
X*r
73 楼
何必把每行split再join呢，找到第pos-1和第pos个\t的位置，把中间那段的内容换一
下就好了。
而且好象也没有必要在内存维持输出文件的所有内容，边处理边写就是了。
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
下就好了。
而且好象也没有必要在内存维持输出文件的所有内容，边处理边写就是了。
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
r*n
74 楼
~~~~~~~~~~~~~同意
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
我觉得读文件一块读一块写要快些
【在 X****r 的大作中提到】
: 何必把每行split再join呢，找到第pos-1和第pos个\t的位置，把中间那段的内容换一
: 下就好了。
: 而且好象也没有必要在内存维持输出文件的所有内容，边处理边写就是了。
m*t
75 楼
大数据的操作是要优化的
c里面一次读个几G处理完再写回去，比边读边写快十倍都不止
c里面一次读个几G处理完再写回去，比边读边写快十倍都不止
j*a
76 楼
这是你的代码问题了，看上去就显得啰嗦臃肿。
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
M*P
77 楼
avoid string += anotherstring
using join instead.
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
using join instead.
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
h*n
78 楼
字符串加法用得太多了，这样很慢，尤其是这样在尾端一点一点添加的方式。你可以试
试先split，改掉第pos个单元，然后一次性join起来。
减少读写操作的次数也可能有帮助，难说每次读些需要做哪些额外的工作，放在循环里
的话也会影响速度。
试先split，改掉第pos个单元，然后一次性join起来。
减少读写操作的次数也可能有帮助，难说每次读些需要做哪些额外的工作，放在循环里
的话也会影响速度。
t*o
79 楼
谢谢大家的讨论，看来我的python code自己也有问题。
多谢。
多谢。
v*s
80 楼
我这段代码貌似快了不少。 你的用了10秒钟处理1M lines， 我这个3.9秒。 你试试看。
测试的时候都是重新定向到文件。 直接输出到屏幕那个太慢。
我把你的文件中间“xxx lines processed” 也去掉了。
import sys
pos = 10
valueMap = {}
cnt = 0
for line in sys.stdin:
vals = line.split('\t')
val = vals[pos]
if not val:
continue
else:
if not val in valueMap:
valueMap[val] = str(len(valueMap) + 1)
vals[pos] = valueMap[val]
sys.stdout.write('\t'.join(vals))
sys.stdin.close()
sys.stdout.close()
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
测试的时候都是重新定向到文件。 直接输出到屏幕那个太慢。
我把你的文件中间“xxx lines processed” 也去掉了。
import sys
pos = 10
valueMap = {}
cnt = 0
for line in sys.stdin:
vals = line.split('\t')
val = vals[pos]
if not val:
continue
else:
if not val in valueMap:
valueMap[val] = str(len(valueMap) + 1)
vals[pos] = valueMap[val]
sys.stdout.write('\t'.join(vals))
sys.stdin.close()
sys.stdout.close()
【在 t*********o 的大作中提到】
: 谢谢大家讨论。楼上贴的benchmark results非常有用，跟我的数据很吻合，很好 :)
: 我的python核心代码如下。很简单，一行一行的读，把某一列的数据重新label一下，
: 然后写到一个新的文件。
: 我已经决定就用java了。从benchmark比较结果来看，java速度已经位列最快的一波了
: ，居然比c#还快。
: pos = 10; // 11th column of the data
: valueMap = {}
: cnt = 0
: for ln in sys.stdin:
: vals = ln.split('\t')
w*i
81 楼
use
try: do_sth(valueMap[val])
except KeyError: Init(valueMap[val])
instead of
if val not in valueMap: Init(valueMap[val])
do_sth(valueMap[val])
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
try: do_sth(valueMap[val])
except KeyError: Init(valueMap[val])
instead of
if val not in valueMap: Init(valueMap[val])
do_sth(valueMap[val])
【在 r*******n 的大作中提到】
: 我按你的思路改了一下,看效果有没有改善, 然后再用pypy试试.
: def process_file(input_file, output_file):
: pos = 10
: valueMap = dict()
: cnt = 0
: output = []
: with open(input_file, 'r') as f:
: lines = f.readlines()
: for each_line in lines:
: vals = each_line.split('\t')
r*n
82 楼
这样的好处是什么?
我一直不喜欢程序里放好多
try
except
【在 w****i 的大作中提到】
: use
: try: do_sth(valueMap[val])
: except KeyError: Init(valueMap[val])
: instead of
: if val not in valueMap: Init(valueMap[val])
: do_sth(valueMap[val])
我一直不喜欢程序里放好多
try
except
【在 w****i 的大作中提到】
: use
: try: do_sth(valueMap[val])
: except KeyError: Init(valueMap[val])
: instead of
: if val not in valueMap: Init(valueMap[val])
: do_sth(valueMap[val])
v*s
83 楼
如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
我改成exception 仅仅提高了0.1秒。
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
我改成exception 仅仅提高了0.1秒。
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
l*a
84 楼
+1,我也讨厌try
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
w*i
85 楼
估计时间都花在split()上了，如果你的data远多于10列，试试
vals = line.split('\t', 11)
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
vals = line.split('\t', 11)
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
h*n
86 楼
但是exception机制本身是比较慢的，尽量少用。
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
【在 v*s 的大作中提到】
: 如果重复的很多，那么大部分的检查都是白做的，所以用exception， 会比较快。
: 不过可能提高的也不是很多。我的数据中， 1M line， 随机数分布在1－100之间
: 我改成exception 仅仅提高了0.1秒。
v*s
87 楼
我一共只有12个，不知道楼主原来的数据是什么样子。
受教了，谢谢。
【在 w****i 的大作中提到】
: 估计时间都花在split()上了，如果你的data远多于10列，试试
: vals = line.split('\t', 11)
受教了，谢谢。
【在 w****i 的大作中提到】
: 估计时间都花在split()上了，如果你的data远多于10列，试试
: vals = line.split('\t', 11)
t*o
88 楼
thanks vvs' improved code.
I tried with the new code and indeeded it improved a lot on running speed.
Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
This seems also aligned with data points some folks here have - cool~
My data is wide - (tens) of thousands of columns.
As i said, i probably just go with java directly - 2.5x still matters a lot
to me :)
Thanks for all discussions!
I tried with the new code and indeeded it improved a lot on running speed.
Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
This seems also aligned with data points some folks here have - cool~
My data is wide - (tens) of thousands of columns.
As i said, i probably just go with java directly - 2.5x still matters a lot
to me :)
Thanks for all discussions!
g*g
89 楼
You have to compare apple to apple, your java code may not
be optimized either.
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
be optimized either.
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
v*s
90 楼
你把java code也贴出来，好虫大侠说不定看着不爽了帮你调一把，呵呵。
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
v*s
91 楼
你有那么多column，那么使用split('\t',11) 要快的多了。
测试文件是3000行， 每行1万列。 size 84M
$ wc p0.txt
3000 30000000 87597247 p0.txt
$ ls -lh p0.txt
-rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
$ time python a2.py < p0.txt > p2out.txt
real 0m4.213s
user 0m2.759s
sys 0m1.440s
$ time python a3.py < p0.txt > p3out.txt
real 0m1.653s
user 0m0.214s
sys 0m1.432s
$ diff a2.py a3.py
6c6
< vals = line.split('\t')
---
> vals = line.split('\t',11)
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
测试文件是3000行， 每行1万列。 size 84M
$ wc p0.txt
3000 30000000 87597247 p0.txt
$ ls -lh p0.txt
-rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
$ time python a2.py < p0.txt > p2out.txt
real 0m4.213s
user 0m2.759s
sys 0m1.440s
$ time python a3.py < p0.txt > p3out.txt
real 0m1.653s
user 0m0.214s
sys 0m1.432s
$ diff a2.py a3.py
6c6
< vals = line.split('\t')
---
> vals = line.split('\t',11)
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
d*q
92 楼
throwing exception in py is pretty lightweight...
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
r*t
93 楼
他只用到前面 11 列么？
【在 v*s 的大作中提到】
: 你有那么多column，那么使用split('\t',11) 要快的多了。
: 测试文件是3000行， 每行1万列。 size 84M
: $ wc p0.txt
: 3000 30000000 87597247 p0.txt
: $ ls -lh p0.txt
: -rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
: $ time python a2.py < p0.txt > p2out.txt
: real 0m4.213s
: user 0m2.759s
: sys 0m1.440s
【在 v*s 的大作中提到】
: 你有那么多column，那么使用split('\t',11) 要快的多了。
: 测试文件是3000行， 每行1万列。 size 84M
: $ wc p0.txt
: 3000 30000000 87597247 p0.txt
: $ ls -lh p0.txt
: -rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
: $ time python a2.py < p0.txt > p2out.txt
: real 0m4.213s
: user 0m2.759s
: sys 0m1.440s
Q*n
94 楼
学习了
S*A
95 楼
你这个 Python Code 太弱了。
Python 就是要把循环部分放到 C 里面实现。
Python 的强项是有很多 library 要好好利用。
就是 几百 M 的文件一次读进来处理更快。
尽可能避免用 Python code 来做 Loop.
试试这个会不会好些。至少代码量会短很多吧。
这个假设输入文件每行都有至少 10 个 column。
import sys
import re
data = sys.stdin.read()
lines = re.findall(r'(?m)^((?:[^\t]*\t){9,9})([^\t]*)(.*)', data)
valmap = {}
output = [ head + valmap.setdefault(mid, str(len(valmap)+1)) + tail + '\n'
for head,mid,tail in lines]
sys.stdout.write(''.join(output))
Python 就是要把循环部分放到 C 里面实现。
Python 的强项是有很多 library 要好好利用。
就是 几百 M 的文件一次读进来处理更快。
尽可能避免用 Python code 来做 Loop.
试试这个会不会好些。至少代码量会短很多吧。
这个假设输入文件每行都有至少 10 个 column。
import sys
import re
data = sys.stdin.read()
lines = re.findall(r'(?m)^((?:[^\t]*\t){9,9})([^\t]*)(.*)', data)
valmap = {}
output = [ head + valmap.setdefault(mid, str(len(valmap)+1)) + tail + '\n'
for head,mid,tail in lines]
sys.stdout.write(''.join(output))
d*q
96 楼
throwing exception in py is pretty lightweight...
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
【在 r*******n 的大作中提到】
: 这样的好处是什么?
: 我一直不喜欢程序里放好多
: try
: except
r*t
97 楼
他只用到前面 11 列么？
【在 v*s 的大作中提到】
: 你有那么多column，那么使用split('\t',11) 要快的多了。
: 测试文件是3000行， 每行1万列。 size 84M
: $ wc p0.txt
: 3000 30000000 87597247 p0.txt
: $ ls -lh p0.txt
: -rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
: $ time python a2.py < p0.txt > p2out.txt
: real 0m4.213s
: user 0m2.759s
: sys 0m1.440s
【在 v*s 的大作中提到】
: 你有那么多column，那么使用split('\t',11) 要快的多了。
: 测试文件是3000行， 每行1万列。 size 84M
: $ wc p0.txt
: 3000 30000000 87597247 p0.txt
: $ ls -lh p0.txt
: -rw-r--r-- 1 vvs 5000 84M Nov 1 23:07 p0.txt
: $ time python a2.py < p0.txt > p2out.txt
: real 0m4.213s
: user 0m2.759s
: sys 0m1.440s
Q*n
98 楼
学习了
S*A
99 楼
你这个 Python Code 太弱了。
Python 就是要把循环部分放到 C 里面实现。
Python 的强项是有很多 library 要好好利用。
就是 几百 M 的文件一次读进来处理更快。
尽可能避免用 Python code 来做 Loop.
试试这个会不会好些。至少代码量会短很多吧。
这个假设输入文件每行都有至少 10 个 column。
import sys
import re
data = sys.stdin.read()
lines = re.findall(r'(?m)^((?:[^\t]*\t){9,9})([^\t]*)(.*)', data)
valmap = {}
output = [ head + valmap.setdefault(mid, str(len(valmap)+1)) + tail + '\n'
for head,mid,tail in lines]
sys.stdout.write(''.join(output))
Python 就是要把循环部分放到 C 里面实现。
Python 的强项是有很多 library 要好好利用。
就是 几百 M 的文件一次读进来处理更快。
尽可能避免用 Python code 来做 Loop.
试试这个会不会好些。至少代码量会短很多吧。
这个假设输入文件每行都有至少 10 个 column。
import sys
import re
data = sys.stdin.read()
lines = re.findall(r'(?m)^((?:[^\t]*\t){9,9})([^\t]*)(.*)', data)
valmap = {}
output = [ head + valmap.setdefault(mid, str(len(valmap)+1)) + tail + '\n'
for head,mid,tail in lines]
sys.stdout.write(''.join(output))
w*u
100 楼
毫无意义
硬件如此便宜的现在，这种语言的速度根本不值得讨论。scalability才是硬道理。我
把这东西扔到几个服务器上并行，用最烂的语言，一样泡影那个最好的desktop every
single time. 你用assembly for-loop 个百万次依然很浪费时间，so what's the
point.
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
硬件如此便宜的现在，这种语言的速度根本不值得讨论。scalability才是硬道理。我
把这东西扔到几个服务器上并行，用最烂的语言，一样泡影那个最好的desktop every
single time. 你用assembly for-loop 个百万次依然很浪费时间，so what's the
point.
【在 t*********o 的大作中提到】
: 用python和java做一些data pre-processing.
: 非常简单，就是一个文件一行行多出来，处理一下写到另外一个文件。
: 文件稍微大一点，10MB-100MB吧。
: 发现python is much slower than java, 6X slower.
: python performance 这么差呀。
r*t
101 楼
这个浪费内存了，用 iterator 代替 list comprehension, pipeline 风格快很多。
【在 S*A 的大作中提到】
: 你这个 Python Code 太弱了。
: Python 就是要把循环部分放到 C 里面实现。
: Python 的强项是有很多 library 要好好利用。
: 就是 几百 M 的文件一次读进来处理更快。
: 尽可能避免用 Python code 来做 Loop.
: 试试这个会不会好些。至少代码量会短很多吧。
: 这个假设输入文件每行都有至少 10 个 column。
: import sys
: import re
: data = sys.stdin.read()
【在 S*A 的大作中提到】
: 你这个 Python Code 太弱了。
: Python 就是要把循环部分放到 C 里面实现。
: Python 的强项是有很多 library 要好好利用。
: 就是 几百 M 的文件一次读进来处理更快。
: 尽可能避免用 Python code 来做 Loop.
: 试试这个会不会好些。至少代码量会短很多吧。
: 这个假设输入文件每行都有至少 10 个 column。
: import sys
: import re
: data = sys.stdin.read()
r*t
102 楼
你那个是按 c 写出来的，不如直接上 c 了。
【在 t*********o 的大作中提到】
: 谢谢大家的讨论，看来我的python code自己也有问题。
: 多谢。
【在 t*********o 的大作中提到】
: 谢谢大家的讨论，看来我的python code自己也有问题。
: 多谢。
T*U
103 楼
硬件还没便宜到这种地步, 几个并行服务器还是很贵的
现在大型应用,数据库都还是需要优化再优化, 大公司也都是拼优化
every
【在 w*********u 的大作中提到】
: 毫无意义
: 硬件如此便宜的现在，这种语言的速度根本不值得讨论。scalability才是硬道理。我
: 把这东西扔到几个服务器上并行，用最烂的语言，一样泡影那个最好的desktop every
: single time. 你用assembly for-loop 个百万次依然很浪费时间，so what's the
: point.
现在大型应用,数据库都还是需要优化再优化, 大公司也都是拼优化
every
【在 w*********u 的大作中提到】
: 毫无意义
: 硬件如此便宜的现在，这种语言的速度根本不值得讨论。scalability才是硬道理。我
: 把这东西扔到几个服务器上并行，用最烂的语言，一样泡影那个最好的desktop every
: single time. 你用assembly for-loop 个百万次依然很浪费时间，so what's the
: point.
l*s
104 楼
you should go C++, java is slow, and the amount of coding is about the same.
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
lot
【在 t*********o 的大作中提到】
: thanks vvs' improved code.
: I tried with the new code and indeeded it improved a lot on running speed.
: Now i can make python vs java to 2.5: 1, instead of 6:1 originally.
: This seems also aligned with data points some folks here have - cool~
: My data is wide - (tens) of thousands of columns.
: As i said, i probably just go with java directly - 2.5x still matters a lot
: to me :)
: Thanks for all discussions!
n*t
105 楼
你这一看就是没写过什么程序的主。
every
【在 w*********u 的大作中提到】
: 毫无意义
: 硬件如此便宜的现在，这种语言的速度根本不值得讨论。scalability才是硬道理。我
: 把这东西扔到几个服务器上并行，用最烂的语言，一样泡影那个最好的desktop every
: single time. 你用assembly for-loop 个百万次依然很浪费时间，so what's the
: point.
every
【在 w*********u 的大作中提到】
: 毫无意义
: 硬件如此便宜的现在，这种语言的速度根本不值得讨论。scalability才是硬道理。我
: 把这东西扔到几个服务器上并行，用最烂的语言，一样泡影那个最好的desktop every
: single time. 你用assembly for-loop 个百万次依然很浪费时间，so what's the
: point.
相关阅读
电子科技大学在北美华人电子圈里面知名度怎么样Re: 问Matlab求三重积分的方法物理转专业的烦恼，请教了！烂校早些毕业好呢，还是转到好学校好呢？招生委员会的教授与套磁问一个micro fabrication 的问题！bow！！借问Word如何生成List of Table, Figure? (转载)Matlab如何实现xy有曲线，z只是等间距的三维图？去哪下载 AMI 0.5um CMOS Technology 的model？我那华为的妹妹，你和别人上床只是为出国吗？ (转载)谁帮忙系统介绍下FACCH/H+TCH/H? thanksUCSB的Electronics&Photonics怎么样？大家帮忙参考一下，找工作还是继续读phd呢？white noise请问毕业论文中可不可以用网上下载的普通图片？ (转载)请推荐语音处理的经典书请问EE各位,关于SOLAR的PROGRAM一般怎么计算电磁场的能量呢？请问有在BOSTON或者Rhode Island的半导体公司的老大么?请教一个power MOSFET/IGBT的问题