一 : 随手记电脑版如何记转账以及如何记支出和收入

随手记电脑版如何记转账？

点击标准按钮栏上“记一笔”，出现记一笔页面，点击“转账”，选择转账账户，录入转账金额等，确定，即完成一笔转账记录。

也可以，点击“收支流水账”，选择“账户转账”，出现账户转账信息页面。选择转账账户，录入金额等，点击“确定”，即完成一笔转账记录。

如何记支出和收入？

点击“收支流水账”，开始记账。

在记账界面中，选择刚才建立的招商银行卡账户进行记账

这样，在招商银行卡的流水中就能看到刚刚记录的这笔帐了

二 : linux下write操作原理、错误原因及处理方法

linux下write操作原理、错误原因及处理方法

1. write函数介绍

（1）文件I/O与标准I/O之争：

根据《UNIX环境高级编程》中介绍，文件I/O与准备I/O之间的差别主要有以下几点：其一，文件I/O是在系统的内核中实现的，而标准I/O函数则提供了文件I/O函数的一个完整的带缓冲的替代品。因此说，文件I/O是一种较低级的I/O操作函数，而标准I/O则是一种相对较高的I/O。标准I/O函数将打开的文件模型抽象成“文件流”。常见的文件I/O有：open, write, create, close, read等；标准I/O有：fopen,freopen, fdopen, getc等。第二，标准I/O一般是磁盘和终端设备I/O的首选，而当试图用于网络I/O，即对网络socket进行操作时，应该应用文件I/O。

（2）文件I/O的阻塞与非阻塞（以write函数为例）： www.2cto.com

前面已经说过，文件I/O是一种带有缓冲区的操作函数，而在实际的操作过程中，势必会出现阻塞与非阻塞相关的问题。下面以write操作来介绍阻塞与非阻塞这两种情况：

write函数首先将进程需要发送的数据先放在进程缓冲区中，然后向socket的发送缓冲区进行拷贝，在此，可能出现这样情况，即当进程缓冲区中的数据量大于此时发送缓冲区中所能接受的数据量时，若此时处于阻塞模式，应用进程将会被挂起，直到进程缓冲区中的数据全部拷贝到发送缓冲区中，注意此时内核也不会返回write函数，因此，在阻塞模式下，若write函数正常返回，这也并不代表数据已经完成被对方进程接收，至多只能说明数据已经被发送缓冲区完全接受；若是处于非阻塞模式，此时write操作将会失败，内核会立即返回EAGAIN错误，在此需要声明的是，有时候在某些地方说会返回EWOULDBLOCK错误，其实二者本质一样，只是分别用于不同的系统罢了，前者主要是出现于GNU系统，，而后者主要出现在类BSD系统。 www.2cto.com

【引申1】阻塞与非阻塞的转换：切换socket fd的阻塞标志。

int fcntl(int fd , int cmd)

int fcntl(int fd,int cmd,long arg)

其中cmd代表要操作的命令，常见有：

F_GETFL：取得fd的当前状态标志

F_SETFL：设置fd的当前状态标志

[cpp]

flags = (long) fcntl(pc->fd, F_GETFL);

bflags = flags & ~O_NONBLOCK; /* clear non-block flag, i.e. block */

fcntl(pc->fd, F_SETFL, bflags);

【引申2】Linux中发送缓存大小的查看：

sysctl -a | grep net.ipv4.tcp_wmem

net.ipv4.tcp_wmem = 4096 16384 81920 （这三个值分别代表发送缓冲区的最少字节数，默认字节数以及最多字节数） www.2cto.com

2. write常见错误以及原因分析：

前面已经说过EAGAIN错误出现的原因，下面主要讲解EPIPE错误是在何种情景下产生的。

我们知道TCP连接需要三次握手，而退出需要四个过程，而EPIPE则是产生于进程socket的退出过程中，对应上面的原理图，若B端的进程已经主动关闭（发送FIN），但是A端因为各种原因（主要是未同步），未能知晓并仍然向对方发送数据，此时A端内核会返回EPIPE错误，它会发送SIGPIPE信号给进程A，默认情况下，进程将会自动退出。

最近在做项目过程中，因为Apache server端的keep-alive配置时间过短，导致过早发出FIN，而使得client端的socket出现EPIPE错误，最后将keep-alive时间配置稍长点，一切问题OK！

作者 陈立龙

三 : Json概述以及python对json的相关操作

什么是json：

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。(www.61k.com）易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。

JSON建构于两种结构：

“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。
值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。
这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。

jso官方说明参见：

对简单数据类型的encoding 和 decoding：

使用简单的json.dumps方法对简单数据类型进行编码，例如：

import json obj = [[1,2,3],123,123.123,'abc',{'key1':(1,2,3),'key2':(4,5,6)}] encodedjson = json.dumps(obj) print repr(obj) print encodedjson

输出：

[[1, 2, 3], 123, 123.123, 'abc', {'key2': (4, 5, 6), 'key1': (1, 2, 3)}]
[[1, 2, 3], 123, 123.123, "abc", {"key2": [4, 5, 6], "key1": [1, 2, 3]}]

通过输出的结果可以看出，简单类型通过encode之后跟其原始的repr()输出结果非常相似，但是有些数据类型进行了改变，例如上例中的元组则转换为了列表。在json的编码过程中，会存在从python原始类型向json类型的转化过程，具体的转化对照如下：

json.dumps()方法返回了一个str对象encodedjson，我们接下来在对encodedjson进行decode，得到原始数据，需要使用的json.loads()函数：

decodejson = json.loads(encodedjson) print type(decodejson) print decodejson[4]['key1'] print decodejson

输出：

<type 'list'>
[1, 2, 3]

[[1, 2, 3], 123, 123.123, u'abc', {u'key2': [4, 5, 6], u'key1': [1, 2, 3]}]

loads方法返回了原始的对象，但是仍然发生了一些数据类型的转化。比如，上例中‘abc’转化为了unicode类型。从json到python的类型转化对照如下：

json.dumps方法提供了很多好用的参数可供选择，比较常用的有sort_keys（对dict对象进行排序，我们知道默认dict是无序存放的），separators，indent等参数。

排序功能使得存储的数据更加有利于观察，也使得对json输出的对象进行比较，例如：

data1 = {'b':789,'c':456,'a':123} data2 = {'a':123,'b':789,'c':456} d1 = json.dumps(data1,sort_keys=True) d2 = json.dumps(data2) d3 = json.dumps(data2,sort_keys=True) print d1 print d2 print d3 print d1==d2 print d1==d3

输出：

{"a": 123, "b": 789, "c": 456}
{"a": 123, "c": 456, "b": 789}
{"a": 123, "b": 789, "c": 456}
False
True

上例中，本来data1和data2数据应该是一样的，但是由于dict存储的无序特性，造成两者无法比较。因此两者可以通过排序后的结果进行存储就避免了数据比较不一致的情况发生，但是排序后再进行存储，系统必定要多做一些事情，也一定会因此造成一定的性能消耗，所以适当排序是很重要的。

indent参数是缩进的意思，它可以使得数据存储的格式变得更加优雅。

data1 = {'b':789,'c':456,'a':123} d1 = json.dumps(data1,sort_keys=True,indent=4) print d1

输出：

{
   "a": 123,
   "b": 789,
   "c": 456
}

输出的数据被格式化之后，变得可读性更强，但是却是通过增加一些冗余的空白格来进行填充的。json主要是作为一种数据通信的格式存在的，而网络通信是很在乎数据的大小的，无用的空格会占据很多通信带宽，所以适当时候也要对数据进行压缩。separator参数可以起到这样的作用，该参数传递是一个元组，包含分割对象的字符串。

print 'DATA:', repr(data) print 'repr(data) :', len(repr(data)) print 'dumps(data) :', len(json.dumps(data)) print 'dumps(data, indent=2) :', len(json.dumps(data, indent=4)) print 'dumps(data, separators):', len(json.dumps(data, separators=(',',':')))

输出：

DATA: {'a': 123, 'c': 456, 'b': 789}
repr(data)            : 30
dumps(data)           : 30
dumps(data, indent=2) : 46
dumps(data, separators): 25

通过移除多余的空白符，达到了压缩数据的目的，而且效果还是比较明显的。

另一个比较有用的dumps参数是skipkeys，默认为False。 dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True的话，则会比较优雅的过度。

data = {'b':789,'c':456,(1,2):123} print json.dumps(data,skipkeys=True)
扩展：python json 操作 / python操作json文件 / python 多层json操作

输出：

{"c": 456, "b": 789}

处理自己的数据类型

json模块不仅可以处理普通的python内置类型，也可以处理我们自定义的数据类型，而往往处理自定义的对象是很常用的。

首先，我们定义一个类Person。

class Person(object):  def __init__(self,name,age):  self.name = name  self.age = age  def __repr__(self):  return 'Person Object name : %s , age : %d' % (self.name,self.age) if __name__ == '__main__':  p = Person('Peter',22)  print p

如果直接通过json.dumps方法对Person的实例进行处理的话，会报错，因为json无法支持这样的自动转化。通过上面所提到的json和python的类型转化对照表，可以发现，object类型是和dict相关联的，所以我们需要把我们自定义的类型转化为dict，然后再进行处理。这里，有两种方法可以使用。

方法一：自己写转化函数

''' Created on 2011-12-14 @author: Peter ''' import Person import json p = Person.Person('Peter',22) def object2dict(obj):  #convert object to a dict  d = {}  d['__class__'] = obj.__class__.__name__  d['__module__'] = obj.__module__  d.update(obj.__dict__)  return d def dict2object(d):  #convert dict to object  if'__class__' in d:  class_name = d.pop('__class__')  module_name = d.pop('__module__')  module = __import__(module_name)  class_ = getattr(module,class_name)  args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args  inst = class_(**args) #create new instance  else:  inst = d  return inst d = object2dict(p) print d #{'age': 22, '__module__': 'Person', '__class__': 'Person', 'name': 'Peter'} o = dict2object(d) print type(o),o #<class 'Person.Person'> Person Object name : Peter , age : 22 dump = json.dumps(p,default=object2dict) print dump #{"age": 22, "__module__": "Person", "__class__": "Person", "name": "Peter"} load = json.loads(dump,object_hook = dict2object) print load #Person Object name : Peter , age : 22

上面代码已经写的很清楚了，实质就是自定义object类型和dict类型进行转化。object2dict函数将对象模块名、类名以及__dict__存储在dict对象里，并返回。dict2object函数则是反解出模块名、类名、参数，创建新的对象并返回。在json.dumps 方法中增加default参数，该参数表示在转化过程中调用指定的函数，同样在decode过程中json.loads方法增加object_hook,指定转化函数。

方法二：继承JSONEncoder和JSONDecoder类，覆写相关方法

JSONEncoder类负责编码，主要是通过其default函数进行转化，我们可以override该方法。同理对于JSONDecoder。

''' Created on 2011-12-14 @author: Peter ''' import Person import json p = Person.Person('Peter',22) class MyEncoder(json.JSONEncoder):  def default(self,obj):  #convert object to a dict  d = {}  d['__class__'] = obj.__class__.__name__  d['__module__'] = obj.__module__  d.update(obj.__dict__)  return d class MyDecoder(json.JSONDecoder):  def __init__(self):  json.JSONDecoder.__init__(self,object_hook=self.dict2object)  def dict2object(self,d):  #convert dict to object  if'__class__' in d:  class_name = d.pop('__class__')  module_name = d.pop('__module__')  module = __import__(module_name)  class_ = getattr(module,class_name)  args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args  inst = class_(**args) #create new instance  else:  inst = d  return inst d = MyEncoder().encode(p) o = MyDecoder().decode(d) print d print type(o), o

对于JSONDecoder类方法，稍微有点不同，但是改写起来也不是很麻烦。看代码应该就比较清楚了。

扩展：python json 操作 / python操作json文件 / python 多层json操作

本文标题：借贷记账法原理以及如何操作？-随手记电脑版如何记转账以及如何记支出和收入
本文地址： http://www.61k.com/1071013.html