#!/bin/bash
 
mkdir friends
for i in {1..11}
do
    wget -k -e robots=off --load-cookies cookies.txt -P friends/ \
        http://fanfou.com/friends/upsuper/p.$i
    sed -i -e "s/http:\/\/fanfou\.com\/friends\/upsuper\///g" \
        "friends/p.$i"
    sed -i -e "s/http:\/\/fanfou\.com\/friends/p.1/g" \
        "friends/p.$i"
    sed -i -e "s/http:\/\/fanfou\.com\/followers/..\/followers\/p.1/g" \
        "friends/p.$i"
done
 
mkdir followers
for i in {1..8}
do
    wget -k -e robots=off --load-cookies cookies.txt -P followers/ \
        http://fanfou.com/followers/upsuper/p.$i
    sed -i -e "s/http:\/\/fanfou\.com\/followers\/upsuper\///g" \
        "followers/p.$i"
    sed -i -e "s/http:\/\/fanfou\.com\/friends/..\/friends\/p.1/g" \
        "followers/p.$i"
    sed -i -e "s/http:\/\/fanfou\.com\/followers/p.1/g" \
        "followers/p.$i"
done
 
for f in friends/* followers/*
do
    sed -i -e "s/http:\/\/fanfou\.com\/friends/..\/friends/g" \
        "followers/p.$i"
    sed -i -e "s/http:\/\/fanfou\.com\/followers/..\/followers/g" \
        "friends/p.$i"
done

#!/usr/bin/env python
# - * - coding: utf8 - * -
 
import sys
import json
 
from socket import timeout
from urllib import urlencode
from base64 import b64encode
from getpass import getpass
from httplib2 import Http
 
username = raw_input('Username: ')
password = getpass('Password: ')
auth = 'Basic ' + b64encode('%s:%s' % (username, password))
headers = { 'Authorization': auth }
 
h = Http(timeout=1)
sys.stdout = sys.stderr
 
# Delete friends
print 'Delete friends:'
resp, content = h.request('http://api.fanfou.com/friends/ids.json', headers=headers)
friends = json.loads(content)
for friend in friends:
    query_str = urlencode({ 'id': friend.encode('utf8') })
    print friend.encode('utf8'),
    try:
        resp, content = h.request('http://api.fanfou.com/friendships/destroy.json?' + query_str, 'POST', headers=headers)
    except timeout:
        print 'timeout'
    else:
        print resp.status
 
# Delete followers
print 'Delete followers:'
resp, content = h.request('http://api.fanfou.com/followers/ids.json', headers=headers)
followers = json.loads(content)
for follower in followers:
    query_str = urlencode({ 'id': follower.encode('utf8') })
    print follower.encode('utf8'),
    try:
        resp, content = h.request('http://api.fanfou.com/blocks/create.xml?' + query_str, 'POST', headers=headers)
    except timeout:
        print 'timeout',
    else:
        print resp.status,
    try:
        resp, content = h.request('http://api.fanfou.com/blocks/destroy.xml?' + query_str, 'POST', headers=headers)
    except timeout:
        print 'timeout'
    else:
        print resp.status

line_count = 0
 
def read_split(f):
    global line_count
    line_count += 1
    line = f.readline()
    if not line:
        return False
    return line[:-1].split()
 
with open('simsun-12.bdf', 'r') as f:
    chars = {}
    line = ['']
    try:
        # 获得字符总数
        while line[0] != 'CHARS':
            line = read_split(f)
        # 读取所有字符
        for i in range(int(line[1])):
            assert read_split(f)[0] == 'STARTCHAR'
            line = read_split(f)
            # 编码
            assert line[0] == 'ENCODING'
            char = unichr(int(line[1]))
            line = read_split(f)
            # 绘制参数
            assert line[0] == 'BBX'
            width, height, x1, y1 = [int(x) for x in line[1:]]
            x0, y0 = (1 + x1, 12 - y1 - height)
            # 准备绘制文字
            base_image = [[0 for x in range(14)] for y in range(14)]
            # 读取并绘制文字
            line = read_split(f)
            assert line[0] == 'BITMAP'
            for y in range(y0, y0 + height):
                line = read_split(f)[0]
                bits = int(line, 16)
                bits >>= len(line) * 4 - width
                for x in range(x0 + width - 1, x0 - 1, -1):
                    base_image[y][x] = bits & 1
                    bits >>= 1
            chars[char] = base_image
            # 结束这个文字
            line = read_split(f)
            assert line[0] == 'ENDCHAR'
        line = read_split(f)
        assert line[0] == 'ENDFONT'
    except AssertionError:
        print 'line', line_count
        raise

import marshal
marshal.dump(chars, open('base_image', 'wb'))

#!/usr/bin/python
# - * - coding: utf8 - * -
 
import marshal
import copy
 
base_chars = marshal.load(open('base_image', 'rb'))
chars = {}
for char, image in base_chars.iteritems():
    new_image = []
    for y in range(14):
        new_row = []
        for x in range(14):
            if image[y][x]:
                value = 81
            else:
                value = 0
            if y > 0 and image[y-1][x]:
                value += 4
            if y < 13 and image[y+1][x]:
                value += 4
            if x > 0 and image[y][x-1]:
                value += 4
            if x < 13 and image[y][x+1]:
                value += 4
            new_image.append(value)
    chars[char] = new_image
 
marshal.dump(chars, open('advanced_data', 'wb'))

#!/usr/bin/python
# - * - coding: utf8 - * -
 
import marshal
 
chars = marshal.load(open('advanced_data', 'rb'))
 
def image_diff(image1, image2):
    ret = 0
    for v1, v2 in zip(image1, image2):
        ret += (v1 - v2) ** 2
    return ret
 
remember_number = 5
try:
    searched = marshal.load(open('searched_chars', 'rb'))
except IOError:
    searched = {}
while True:
    input_string = unicode(raw_input('ID: '), 'utf8')
    if not input_string:
        break
    for char in input_string:
        if char not in chars:
            continue
        if char not in searched:
            diff_data = []
            image = chars[char]
            for c, v in chars.iteritems():
                if c == char:
                    continue
                diff_data.append((image_diff(v, image), c))
            diff_data.sort()
            searched[char] = diff_data[:remember_number]
        print char,
        for item in searched[char]:
            print u'({0}, {1})'.format(*item),
        print
    print
 
marshal.dump(searched, open('searched_chars', 'wb'))

import Image, ImageDraw, ImageFont
image = Image.new('L', [14, 14], 255)
draw = ImageDraw.Draw(image)
font = ImageFont.truetype('simsun.ttc', 12)
draw.text((1, 1), u'好', font=font)
image.save('hw.png')

import Image, ImageDraw, ImageFont
image = Image.new('L', [28, 28], 255)
draw = ImageDraw.Draw(image)
font = ImageFont.truetype('simsun.ttc', 24)
draw.text((2, 2), u'好', font=font)
# 抗锯齿方式缩放
image = image.resize((14, 14), Image.ANTIALIAS)
image.save('hw.png')

for i in range(0xB0, 0xF8):
    chr_i = chr(i)
    for j in range(0xA1, 0xFF):
        if i == 0xD7 and j >= 0xFA and j <= 0xFE:
            continue
        char = unicode(chr_i + chr(j), 'gb18030')
        print char,

#!/usr/bin/python
# - * - coding: UTF-8 - * -
 
import Image, ImageDraw, ImageFont, ImageFilter
 
font = ImageFont.truetype('simsun.ttc', 24)
 
def get_char_data(char):
    image = Image.new('L', [28, 28], 255)
    draw = ImageDraw.Draw(image)
    draw.text((2, 2), char, font=font)
    image = image.resize((14, 14), Image.ANTIALIAS)
    return list(image.getdata())
 
def diff_of_data(data1, data2):
    ret = 0
    for i in zip(data1, data2):
        ret += abs(i[0] - i[1])
    return ret
 
chars = {}
for i in range(0xB0, 0xF8):
    chr_i = chr(i)
    for j in range(0xA1, 0xFF):
        if i == 0xD7 and j >= 0xFA and j <= 0xFE:
            continue
        char = unicode(chr_i + chr(j), 'gb18030')
        chars[char] = get_char_data(char)
 
remember_number = 5
input_string = unicode(raw_input('ID: '), 'utf8')
for input_char in input_string:
    if input_char not in chars:
        print input_char
        continue
    input_data = chars[input_char]
    diff_list = []
    for char, data in chars.iteritems():
        if char == input_char:
            continue
        diff_list.append((diff_of_data(data, input_data), char))
    diff_list.sort()
    print input_char,
    for diff, char in diff_list[:5]:
        print u'({0}, {1})'.format(diff, char).encode('utf8').ljust(11),
    print

#!/usr/bin/python
# - * - coding: UTF-8 - * -
 
import Image, ImageDraw, ImageFont, ImageFilter
 
font = ImageFont.truetype('simsun.ttc', 24)
 
def get_char_data(char):
    image = Image.new('L', [28, 28], 255)
    draw = ImageDraw.Draw(image)
    draw.text((2, 2), char, font=font)
    image = image.resize((14, 14), Image.ANTIALIAS)
    # XXX 期待更好的处理方式
    image = image.filter(ImageFilter.SHARPEN).filter(ImageFilter.SMOOTH)
    return list(image.getdata())
 
def diff_of_data(data1, data2):
    ret = 0
    for i in zip(data1, data2):
        ret += abs(i[0] - i[1])
    return ret
 
chars = {}
for i in range(0xB0, 0xF8):
    chr_i = chr(i)
    for j in range(0xA1, 0xFF):
        if i == 0xD7 and j >= 0xFA and j <= 0xFE:
            continue
        char = unicode(chr_i + chr(j), 'gb18030')
        chars[char] = get_char_data(char)
 
remember_number = 5
while True:
    input_string = unicode(raw_input('ID: '), 'utf8')
    if not input_string:
        break
    for input_char in input_string:
        if input_char not in chars:
            print input_char
            continue
        input_data = chars[input_char]
        diff_list = []
        for char, data in chars.iteritems():
            if char == input_char:
                continue
            diff_list.append((diff_of_data(data, input_data), char))
        diff_list.sort()
        print input_char,
        for diff, char in diff_list[:5]:
            print u'({0}, {1})'.format(diff, char).encode('utf8').ljust(11),
        print
    print

#!/usr/bin/env python
# - * - coding: UTF-8 - * -
 
import csv
import struct
import sys
 
fin = open('ip_group_city.csv', 'r')
c = csv.reader(fin, delimiter=';', quotechar='"')
fout = open('ipdata.dat', 'wb')
c.next()
a = 0
s = []
for r in c:
  a += 1
  s.append(struct.pack('>Iff2sh',
      int(r[0]),
      float(r[7]), float(r[8]),
      r[1], int(float(r[10] or '0') * 2)))
  if a % 10000 == 0:
    fout.write(''.join(s))
    s = []
    print >> sys.stderr, a,
fout.write(''.join(s))
print >> sys.stderr, a
fin.close()
fout.close()

#!/usr/bin/env python
# - * - coding: UTF-8 - * -
 
# Copyright (C) 2010 Upsuper <quanxunzhen@gmail.com>
# License: AGPLv3
 
from threading import Thread, Lock
from httplib import HTTPConnection
import urllib
import cgi, json
import sys, re
 
# 常数设置
THREADS_NUM = 5             # 最大线程数
RENREN_USER = ''            # 人人网用户名
RENREN_PWD  = ''            # 人人网密码
USER_AGENT  = 'urenren 0.1' # 提交给人人网的 User-Agent
 
# JSON 输出函数
json_dump = lambda v: json.dump(v, sys.stdout)
# 编译匹配用正则表达式
parse_re = re.compile(r'<td><p><a href="[^\?]+\?id=(\d+)[^"]*">'
                      r'<img src="([^"]+)" border="0" /></a></p>'
                      r'<a href="[^"]+">([^<]+)</a></td>')
 
class RequestThread(Thread):
  def __init__(self, id, sid, friends):
    Thread.__init__(self)
    self.__page = '/getfriends.do?curpage=%%d&id=%d&sid=%s' % (id, sid)
    self.__friends = friends
    self.__conn = HTTPConnection('3g.renren.com')
 
  def run(self):
    global curpage, stop_sign
 
    while not stop_sign:
      # 获取当前页面
      curpage_lock.acquire()
      page = curpage
      curpage += 1
      curpage_lock.release()
 
      # 连接获取数据
      conn = self.__conn
      conn.request('GET', self.__page % (page, ), None, {
        'User-Agent': USER_AGENT
      })
      data = conn.getresponse().read()
 
      # 处理获取的数据
      friend_iter = parse_re.finditer(data)
      t_stop_sign = True
      for f in friend_iter:
        t_stop_sign = False
        id = int(f.group(1))
        self.__friends[id] = (f.group(3), f.group(2))
      stop_sign = t_stop_sign
 
def readFriends(id):
  # 初始化多线程
  global curpage, curpage_lock, stop_sign
  curpage = 0
  curpage_lock = Lock()
  stop_sign = False
  threads = []
  friends = {}
 
  # 创建线程
  for i in xrange(THREADS_NUM):
    threads.append(RequestThread(id, sid, friends))
  # 开始执行线程
  for t in threads:
    t.start()
  # 等待线程结束
  for t in threads:
    t.join()
 
  return friends
 
def main():
  # 初始化CGI输出
  print 'Content-Type: text/plain'
  print
 
  # 获取ID信息
  form = cgi.FieldStorage()
  id1, id2 = 0, 0
  if form.has_key('id1'): id1 = int(form['id1'].value)
  if form.has_key('id2'): id2 = int(form['id2'].value)
  if not (id1 and id2):
    json_dump({'error': True})
    return
 
  # 登入人人网
  conn = HTTPConnection('3g.renren.com')
  conn.request('POST', '/login.do',
      urllib.urlencode({'email': RENREN_USER, 'password': RENREN_PWD}),
      {
        'Content-Type': 'application/x-www-form-urlencoded',
        'User-Agent': USER_AGENT,
      })
  response = conn.getresponse()
  data = response.read()
  conn.close()
  match = re.search(r'sid=([0-9a-f]+)', data, re.I)
  global sid
  sid = match.group(1)
 
  # 读取好友
  friends1 = readFriends(id1)
  friends2 = readFriends(id2)
  if len(friends1) > len(friends2):
    friends1, friends2 = friends2, friends1
 
  # 判断交集
  intersection = []
  for i in friends1.iterkeys():
    if i in friends2:
      intersection.append((i, friends2[i][0], friends2[i][1]))
  json_dump({'error': False, 'count': len(intersection), 'data': intersection})
 
if __name__ == '__main__':
  try:
    main()
  except:
    json_dump({'error': True})

import dbus
bus = dbus.SessionBus()
player = bus.get_object('org.mpris.audacious', '/Player')

window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.fullscreen()
window.show()
gtk.main()

window.connect('key-press-event', key_press)
window.connect('destroy', lambda widget, data = None: gtk.main_quit())

def key_press(widget, event, data = None):
  if gdk.keyval_name(event.keyval) == 'Escape':
    window.destroy()

def button_press(widget, event, data = None):
  print event
window.connect('button-press-event', button_press)

window.add_events(gtk.gdk.BUTTON_PRESS_MASK)

def scroll(widget, event, data = None):
  print event
window.connect('scroll-event', scroll)

#!/usr/bin/env python
 
import pygtk
pygtk.require('2.0')
import gtk
from gtk import gdk
 
import dbus
 
def button_press(widget, event, data = None):
  button = event.button
  if button == 1:
    if player.GetStatus() == 2:
      player.Play()
    else:
      player.Pause()
  elif button == 9:
    player.Prev()
  elif button == 8:
    player.Next()
 
def scroll(widget, event, data = None):
  if event.direction == gdk.SCROLL_UP:
    player.VolumeSet(player.VolumeGet() + 3)
  elif event.direction == gdk.SCROLL_DOWN:
    player.VolumeSet(player.VolumeGet() - 3)
 
def key_press(widget, event, data = None):
  if gdk.keyval_name(event.keyval) == 'Escape':
    window.destroy()
 
bus = dbus.SessionBus()
player = bus.get_object('org.mpris.audacious', '/Player')
 
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect('destroy', lambda widget, data = None: gtk.main_quit())
window.add_events(gdk.BUTTON_PRESS_MASK)
window.connect('button-press-event', button_press)
window.connect('key-press-event', key_press)
window.connect('scroll-event', scroll)
window.fullscreen()
window.show()
gtk.main()

window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DOCK)

def button_press(widget, event, data = None):
  if event.type == gdk._2BUTTON_PRESS:
    window.destroy()
    return
  elif event.type == gdk._3BUTTON_PRESS:
    return
  button = event.button
  if button == 1:
    if player.GetStatus() == 2:
      player.Play()
    else:
      player.Pause()
  elif button == 9:
    player.Prev()
  elif button == 8:
    player.Next()

#!/usr/bin/env python
 
import pygtk
pygtk.require('2.0')
import gtk
from gtk import gdk
 
import dbus
 
def button_press(widget, event, data = None):
  if event.type == gdk._2BUTTON_PRESS:
    window.destroy()
    return
  elif event.type == gdk._3BUTTON_PRESS:
    return
  button = event.button
  if button == 1:
    if player.GetStatus() == 2:
      player.Play()
    else:
      player.Pause()
  elif button == 9:
    player.Prev()
  elif button == 8:
    player.Next()
 
def scroll(widget, event, data = None):
  if event.direction == gdk.SCROLL_UP:
    player.VolumeSet(player.VolumeGet() + 3)
  elif event.direction == gdk.SCROLL_DOWN:
    player.VolumeSet(player.VolumeGet() - 3)
 
bus = dbus.SessionBus()
player = bus.get_object('org.mpris.audacious', '/Player')
 
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect('destroy', lambda widget, data = None: gtk.main_quit())
window.add_events(gdk.BUTTON_PRESS_MASK)
window.connect('button-press-event', button_press)
window.connect('scroll-event', scroll)
window.set_type_hint(gdk.WINDOW_TYPE_HINT_DOCK)
window.fullscreen()
window.show()
gtk.main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import math
sqrt = math.sqrt
 
def gen_imet(func):
  def retfunc(self, other):
    ret = func(self, other)
    self.ave = ret.ave
    self.u = ret.u
    self.digs = ret.digs
    return self
  return retfunc
 
def get_digs(a, b):
  if a == 0: return b
  elif b == 0: return a
  else: return min(a, b)
 
class PhyStat:
  """
  物理实验数据
 
  PhyStat(ave, u = 0.0, digs = 0)
  ave   表示平均值，如果传入一列数则自动计算平均值及其标准误差
  u     表示标准误差，如果 ave 传入数据列表则此处表示仪器精度
  digs  表示有效数字个数，0 表示不限制
  """
 
  def __init__(self, ave, u = 0.0, digs = 0):
    """
    对于 ave 为数据列表的情况，使用下面公式计算平均值：
    ave = Σx[i] / n
    根据下面公式计算标准误差：
    S = Sqrt(Σ(x[i]-ave)^2 / (n - 1))
    u = Δinst / Sqrt(3)
    U = Sqrt(S^2 + u^2)
    """
    self.digs = digs
 
    if isinstance(ave, tuple) or isinstance(ave, list):
      data = ave
      n = len(data)
      ave = math.fsum(ave) / n
      self.ave = ave
 
      s = 0.0
      for i in data:
        s += (i - ave) ** 2
      s = sqrt(s / (n - 1))
      u /= sqrt(3)
      self.u = sqrt(s ** 2 + u ** 2)
    else:
      self.ave = float(ave)
      self.u = abs(float(u))
 
  def __repr__(self):
    ave = self.ave
    exp = int(math.floor(math.log10(ave)))
    exp10 = 10 ** exp
    ave = ave / exp10
    u = self.u / exp10
    digs = self.digs
    if digs == 0:
      ret = '%f ±%f'
    else:
      ret = '%%.%df ±%%.%df' % (digs, digs)
    if exp:
      ret = '(%s) E %d' % (ret, exp)
    return ret % (ave, u)
 
  __neg__ = lambda self: PhyStat(-self.ave, self.u, self.digs)
  __pos__ = lambda self: self
  __abs__ = lambda self: PhyStat(abs(self.ave), self.u, self.digs)
 
  def __add__(self, other):
    if isinstance(other, PhyStat):
      ave = self.ave + other.ave
      u = sqrt(self.u ** 2 + other.u ** 2)
      digs = get_digs(self.digs, other.digs)
      return PhyStat(ave, u, digs)
    else:
      ave = self.ave + other
      return PhyStat(ave, self.u, self.digs)
 
  __radd__ = __add__
  __sub__ = lambda self, other: self + (-other)
  __rsub__ = lambda self, other: other + (-self)
 
  def __mul__(self, other):
    if isinstance(other, PhyStat):
      a = self.ave
      b = other.ave
      ave = a * b
      u = ave * sqrt((self.u / a) ** 2 + (other.u / b) ** 2)
      digs = get_digs(self.digs, other.digs)
      return PhyStat(ave, u, digs)
    else:
      ave = self.ave * other
      u = self.u * other
      return PhyStat(ave, u, self.digs)
 
  __rmul__ = __mul__
 
  def __div__(self, other):
    if isinstance(other, PhyStat):
      return self * other ** -1
    else:
      return (1.0 / other) * self
 
  __rdiv__ = lambda self, other: other * self ** -1
 
  def __pow__(self, other):
    a = self.ave
    ave = a ** other
    u = abs(other * self.u / a * ave)
    return PhyStat(ave, u, self.digs)
 
  __iadd__ = gen_imet(lambda self, other: self + other)
  __isub__ = gen_imet(lambda self, other: self - other)
  __imul__ = gen_imet(lambda self, other: self * other)
  __idiv__ = gen_imet(lambda self, other: self / other)
  __ipow__ = gen_imet(lambda self, other: self ** other)
 
  __int__ = lambda self: int(self.ave)
  __long__ = lambda self: long(self.ave)
  __float__ = lambda self: self.ave

def func1(a): a += 1
def func2(a): a[0] = 0
t1 = 0
func1(t1)
print t1
t2 = [1, 2, 3]
func2(t2)
print t2

0
[0, 2, 3]

a = 1
print id(a)
a += 1
print id(a)

a = [[1, 2, 3], [4, 5, 6]]
b = a[0]
b[0] = 0
print a

[[0, 2, 3], [4, 5, 6]]

a = [[1, 2, 3], [4, 5, 6]]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
a.append(15)
a[1][2] = 10
print a
print b
print c
print d

[[1, 2, 3], [4, 5, 10], 15]
[[1, 2, 3], [4, 5, 10], 15]
[[1, 2, 3], [4, 5, 10]]
[[1, 2, 3], [4, 5, 6]]