不定时更新中,
20141007最新更新

• 列出100以内被3整除的数更简单的方法:

  range(3,100,3)    
  

• 删除读取文本文件换行回车的方法:

  line.strip()
  

• 判断字符串是否是回文的简单方法:

  def isPalindrome(s):
      return s == s[::-1]
  

• 字符串的一些方法:

  • S.upper() #S中的字母大写
  • S.lower() #S中的字母小写
  • S.capitalize() #首字母大写
  • S.title() #每个单词首字母大写
  • S.istitle() #每个单词首字母是否大写的，且其它为小写，
  • S.isupper() #S中的字母是否全是大写
  • S.islower() #S中的字母是否全是小写
  • S.isalpha() #S中的字符是否只有字母组成

• 在collections模块中有一个Counter类

  Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。
  例如:统计一个字符串中重复字母的在字母表最先出现的字符

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

from collections import Counter
def checkio(text):
    count = Counter([x for x in text.lower() if x.isalpha()])
    m = max(count.values())
    return sorted([x for (x, y) in count.items() if y == m])[0]
if __name__ == "__main__":
    print(checkio("Hello World!"))
    print(checkio("How do you do?"))
    print(checkio(u"One"))
    print(checkio(u"Oops!"))

counter的方法有增加(updata)和减少(subtract)两种:
比如:

1
2
3
4
5
6

count = Counter('which')
count['h']
 #结果显示:2
count.update('witch')
count.['h'] 
 #结果显示:3

• RE

  B(括号)

  在正则表达式中有 3 种类型的括号
  方括号”[“内是需要匹配的字符,花括号”{“内是指定匹配字符的数量。 圆括号“(“ 则是用来分组的。

  C(插入符号)

  插入符号 “^” 表示正则式的开始。

  D(美元符号)

  美元符号“$” 表示正则式的结束。

注意:类似(com|net|org)的多选一,用圆括号.

年月日的匹配:
yy-mm-dd

'^(1[9][0-9][0-9]|2[0][0-1][0-9]|[0-9][0-9])[\.-]?([1-9]|0[1-9]|1[0-2])[\.-]?([1-9]|0[1-9]|1[0-9]|2[0-9]|3[0-1])$'

时间的匹配:
hh:mm:ss

'^([0-9]|0[0-9]|1[0-9]|2[0-3])[:]([0-9]|0[0-9]|[0-6][0-9])[:]([0-9]|0[0-9]|[0-5][0-9])$'

ip地址的匹配:

 '^(([01]?[0-9][0-9]?|2[0-4][0-9]|2[5][0-5])\.){3}([01]?[0-9][0-9]?|2[0-4][0-9]|2[5][0-5])$'

• 字母 字符与ASCII数字对应的函数:

  ord（）将字符转换成ascii码数字
  chr()将ascii码数字转换为字符
  unichr()将ascii码整数返回成unicode字符

• random.sample(list, n)通常用来产生不重复的n位数字

   print int(''.join(map(str, random.sample(range(10), 10))))
   #3571490628
  

• enumerate的用法

  enumerate会将数组或列表组成一个索引序列。使我们再获取索引和索引内容的时候更加方便：

1
2

for index，text in enumerate(list)): 
    print index ,text

参考 链接 和 链接

描述

Python time strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定。

语法

strftime()方法语法：

time.strftime(format[, t])

说明

python中时间日期格式化符号：

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

实例

• 获取时间的方法

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

>>>import time
>>>this_time=time.localtime()
>>> this_time
time.struct_time(tm_year=2013, tm_mon=6, tm_mday=6, tm_hour=13, tm_min=42, tm_sec=38, tm_wday=3, tm_yday=157, tm_isdst=0)
>>> type(this_time)
<type 'time.struct_time'>
>>> this_year=this_time[0]
>>> this_year
2013
>>> for time in this_time:
...     print time
...
2013
6
6
13
42
38
3
157
0
time.strftime('%Y-%m-%d %T',time.localtime(time.time())
 # 2014-09-04 23:42:34

• 取过去具体时间的方法:

1
2
3
4
5
6
7
8
9
10

import time
 #取一天前的当前具体时间
time.strftime('%Y-%m-%d %T',time.localtime(time.time()-24*60*60))
 #取20天前的当前具体时间
time.strftime('%Y-%m-%d %T',time.localtime(time.time()-20*24*60*60))
 #取20天前当前具体时间的前2小时
time.strftime('%Y-%m-%d %T',time.localtime(time.time()-20*24*60*60-2*60*60))

• 冒泡法排序

  第一个循环倒序,相邻两个元素比较大小然后交换.第一次将最大的一个逐渐排序到列表最后一个位置.

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

from __future__ import print_function, unicode_literals, division
arry = [16, 134, 15, 1, 78, 10, 9]
def bubble_sort(arry):
    for i in range(len(arry) - 1, 0, -1):
        for j in range(i):
            if arry[j] > arry[j + 1]:
                arry[j], arry[j + 1] = arry[j + 1], arry[j]
if __name__ == "__main__":
    bubble_sort(arry)
    print (arry)

[1, 9, 10, 15, 16, 78, 134]

• 选择法排序

  第一个元素和后面所有元素对比,找到最小的一个,然后交换.

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

from __future__ import print_function, unicode_literals, division
arry = [16, 134, 15, 1, 78, 10, 9]
def select_sort(arry):
    length = len(arry)
    for i in range(length - 1):
        sort_index = i
        for j in range(i, length):
            if arry[j] > arry[sort_index]:
                sort_index = j
        arry[sort_index], arry[i] = arry[i], arry[sort_index]
if __name__ == "__main__":
    select_sort(arry)
    print(arry)

[1, 9, 10, 15, 16, 78, 134]

• 插入排序

最开始以第一个元素为准,第二个元素与第一个比较,排序.第三个与前两个比较然后排序.以此类推.

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

rom __future__ import print_function, unicode_literals, division
arry = [17, 23, 20, 14, 12, 25, 1, 20, 81, 14, 11, 12]
def select_sort(arry):
    length = len(arry)
    for i in range(length - 1):
        sort_index = i
        for j in range(i, length):
            if arry[j] < arry[sort_index]:
                sort_index = j
        if sort_index != i:
            arry[sort_index], arry[i] = arry[i], arry[sort_index]
if __name__ == "__main__":
    select_sort(arry)
    print(arry)

`

[1, 11, 12, 12, 14, 14, 17, 20, 20, 23, 25, 81]

• Lambda表达式有何用处？如何使用？原文链接点我

  涛吴:

  简单来说，编程中提到的 lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。这一用法跟所谓 λ 演算（题目说明里的维基链接）的关系，有点像原子弹和质能方程的关系，差别其实还是挺大的。

不谈形式化的 λ 演算，只说有实际用途的匿名函数。先举一个普通的 Python 例子：将一个 list 里的每个元素都平方：

map( lambda x: x*x, [y for y in range(10)] )

这个写法要好过

def sq(x):
   return x * x

map(sq, [y for y in range(10)])

，因为后者多定义了一个（污染环境的）函数，尤其如果这个函数只会使用一次的话。而且第一种写法实际上更易读，因为那个映射到列表上的函数具体是要做什么，非常一目了然。如果你仔细观察自己的代码，会发现这种场景其实很常见：你在某处就真的只需要一个能做一件事情的函数而已，连它叫什么名字都无关紧要。Lambda 表达式就可以用来做这件事。

进一步讲，匿名函数本质上就是一个函数，它所抽象出来的东西是一组运算。这是什么意思呢？类比

a = [1, 2, 3]

和

f = lambda x : x + 1

，你会发现，等号右边的东西完全可以脱离等号左边的东西而存在，等号左边的名字只是右边之实体的标识符。如果你能习惯 [1, 2, 3] 单独存在，那么 lambda x : x + 1 也能单独存在其实也就不难理解了，它的意义就是给「某个数加一」这一运算本身。

现在回头来看 map() 函数，它可以将一个函数映射到一个可枚举类型上面。沿用上面给出的 a 和 f，可以写：
map(f, a)
也就是将函数 f 依次套用在 a 的每一个元素上面，获得结果 [2, 3, 4]。现在用 lambda 表达式来替换 f，就变成：

map( lambda x : x + 1, [1, 2, 3] )

会不会觉得现在很一目了然了？尤其是类比

a = [1, 2, 3]
r = []
for each in a:
   r.append(each+1)

这样的写法时，你会发现自己如果能将「遍历列表，给遇到的每个元素都做某种运算」的过程从一个循环里抽象出来成为一个函数 map，然后用 lambda 表达式将这种运算作为参数传给 map 的话，考虑事情的思维层级会高出一些来，需要顾及的细节也少了一点。Python 之中，类似能用到 lambda 表达式的「高级」函数还有 reduce、filter 等等，很多语言也都有这样的工具（不过这些特性最好不要在 Python 中用太多，[原因详见] (http://www.zhihu.com/question/19794855/answer/12987428) 的评论部分）。这种能够接受一个函数作为参数的函数叫做「高阶函数」（higher-order function），是来自函数式编程（functional programming）的思想。

和其他很多语言相比，Python 的 lambda 限制多多，最严重的当属它只能由一条表达式组成。这个限制主要是为了防止滥用，因为当人们发觉 lambda 很方便，就比较容易滥用，可是用多了会让程序看起来不那么清晰，毕竟每个人对于抽象层级的忍耐 / 理解程度都有所不同。

1.设置git的SSH公钥

• 打开终端,输入命令:

  ssh-keygen -t rsa -C "skywater@gmail.com"
  

• 继续输入命令:

1
2

cd .SSH      
subl id_rsa.pub

拷贝SSH公钥到github账户的SSH keys里面.

• 输入命令:

1
2

git config --global user.email "skywater@gmail.com"
git config --global user.name "playbear"

2. 安装hexo环境,参考官网

• 安装node.js,打开终端,输入命令:

  brew install node
  

• 安装nvm,命令:

  curl https://raw.githubusercontent.com/creationix/nvm/v0.13.1/install.sh | bash
  

• 安装完成后重启终端,然后运行:

  nvm install 0.10
  

• 安装Hexo:

  npm install -g hexo
  

• 初始化Hexo:

1
2
3
4
5

cd playbear.github.io
hexo init
npm install
hexo g
hexo d

3. 常用hexo命令

1
2

hexo g
hexo d

4. hexo版本更新

npm update -g

如果重装系统后的安装，在hexo g之后将备份的文件夹拷贝覆盖即可。