异度部落格

学习是一种生活态度。

0%

Posted on In

1）LPAD 方法：

1
SELECT LPAD(sal,8,'0') FROM

2）TO_CHAR 方法

1
SELECT TO_CHAR(sal,'00000000') From

3）SUBSTR 方法

1
SELECT SUBSTR('00000000'||sal,-8) FROM

=================================================================== 补充：

LPAD 和 RPAD 用法： Lpad()函数的用法： lpad 函数将左边的字符串填充一些特定的字符其语法格式如下： lpad(string,n,[pad_string]) string：可是字符或者参数 n：字符的长度，是返回的字符串的数量，如果这个数量比原字符串的长度要短，lpad 函数将会把字符串截取成从左到右的 n 个字符; pad_string：是个可选参数，这个字符串是要粘贴到 string 的左边，如果这个参数未写，lpad 函数将会在 string 的左边粘贴空格。 例如： lpad('tech', 7); 将返回' tech' lpad('tech', 2); 将返回'te' lpad('tech', 8, '0'); 将返回'0000tech' lpad('tech on the net', 15, 'z'); 将返回 'tech on the net' lpad('tech on the net', 16, 'z'); 将返回 'ztech on the net'

Rpad()函数的用法： rpad 函数将右边的字符串填充一些特定的字符其语法格式如下： rpad(string,n,[pad_string]) string：可是字符或者参数 n：字符的长度，是返回的字符串的数量，如果这个数量比原字符串的长度要短，lpad 函数将会把字符串截取成从左到右的 n 个字符; pad_string：是个可选参数，这个字符串是要粘贴到 string 的右边，如果这个参数未写，lpad 函数将会在 string 的右边粘贴空格。 例如： rpad('tech', 7); 将返回' tech' rpad('tech', 2); 将返回'te' rpad('tech', 8, '0'); 将返回'tech0000' rpad('tech on the net', 15, 'z'); 将返回 'tech on the net' rpad('tech on the net', 16, 'z'); 将返回 'tech on the netz'

参考资料：http://hi.baidu.com/ljw460/blog/item/5788594a1b55ff2608f7efc5.html

Posted on In

一般情况下，可以如下：

1
select rownum, a from A;

但是当后面有多表关联，order by 排序的时候，

1
select rownum, a from A，B where A.a=B.b order by A.a;

rownum 就可能会乱了。

这时候，可以利用分析函数 rank()来实现：

1
select rank() over(order by t.b) rowno, t.a, t.c from test t order by t.b;

这样就既可以排序，又可以自动加上连续的序号了。

参考资料： http://yuaoi.iteye.com/blog/767889 http://www.cnblogs.com/mycoding/archive/2010/05/29/1747065.html

Posted on In

一、使用 Indexer 建立文本文件索引

这里简化为对某一目录下面的所有后缀为“.py”的文件建立索引。

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
'''
Created on 2011-11-16

@author: killua
@E-mail:[email protected]
'''
import os

from time import time
from datetime import timedelta
from lucene import \
    IndexWriter, StandardAnalyzer, Document, Field, \
    InputStreamReader, FileInputStream, Version, SimpleFSDirectory, File, \
    initVM, CLASSPATH

class Indexer(object):
    _indexDir = ""
    _dataDir = ""

    def __init__(self, indexDir, dataDir):
        self._indexDir = indexDir
        self._dataDir = dataDir

    def index(self):
        if not (os.path.exists(self._dataDir) and os.path.isdir(self._dataDir)):
            raise IOError, "%s isn't existed or is not a directory" % (self._dataDir)

        dir = SimpleFSDirectory(File(self._indexDir))
        writer = IndexWriter(dir, StandardAnalyzer(Version.LUCENE_CURRENT),
                             True, IndexWriter.MaxFieldLength.LIMITED)
        writer.setUseCompoundFile(False);
        self.indexDirectory(writer, self._dataDir)
        numIndexed = writer.numDocs();
        writer.optimize()
        writer.close()
        dir.close()

        return numIndexed

    def indexDirectory(self, writer, dir):

        for name in os.listdir(dir):
            path = os.path.join(dir, name)
            if os.path.isfile(path):
                if path.endswith('.py'):
                    self.indexFile(writer, path)
            elif os.path.isdir(path):
                self.indexDirectory(writer, path)

    def indexFile(self, writer, path):
        try:
            reader = InputStreamReader(FileInputStream(path), 'UTF-8')
        except IOError, e:
            print 'IOError while opening %s: %s' %(path, e)
        else:
            print 'Indexing', path
            doc = Document()
            doc.add(Field("contents", reader))
            doc.add(Field("path", os.path.abspath(path),
                          Field.Store.YES, Field.Index.NOT_ANALYZED))
            writer.addDocument(doc)
            reader.close()

def main():
    initVM(CLASSPATH)
    indexDir = "./index/"
    dataDir = "/home/killua/Workspace/"
    indexer = Indexer(indexDir, dataDir)

    start = time()
    numIndexed = indexer.index()
    duration = timedelta(seconds=time() - start)
    print "Indexing %s files took %s" %(numIndexed, duration)

if __name__ == "__main__":
    main()

运行结果：

Indexer.py 将在 index 目录下建立一些索引文件，用于对.py 文件建立索引

二、使用 Searcher 检索文件

下面程序中实现了对文件的检索，其中参数 q 是一个表达式，可以理解为检索使用的关键字，如果文件中包含次关键字将被检索出来

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
'''
Created on 2011-11-17

@author: killua
@E-mail:[email protected]
'''

import os

from time import time
from datetime import timedelta

from lucene import \
     Document, IndexSearcher, FSDirectory, QueryParser, StandardAnalyzer, \
     SimpleFSDirectory, File, Version, initVM, CLASSPATH

class Searcher(object):

    def search(self, indexDir, q):
        fsDir = SimpleFSDirectory(File(indexDir))
        searcher = IndexSearcher(fsDir, True)
        query = QueryParser(Version.LUCENE_CURRENT, "contents",
                            StandardAnalyzer(Version.LUCENE_CURRENT)).parse(q)
        starttime = time()
        hits = searcher.search(query, 50).scoreDocs
        duration = timedelta(seconds=time() - starttime)

        print "Found %d document(s) (in%s) that matched query '%s':" %(len(hits), duration, q)

        for hit in hits:
            doc = searcher.doc(hit.doc)
            print 'path:', doc.get("path")

def main():
    initVM(CLASSPATH)
    indexDir = "./index/"
    q = "Killua"
    searcher = Searcher()
    searcher.search(indexDir, q)

if __name__ == "__main__":
    main()

Posted on In

【试题描述】
有一名员工发现日历已经7天没有翻了，于是他连着翻了7页，7天的总和刚好是138，问这一天是几号？

【试题分析】
1）假设7天在同一个月，设第一天为X，那么应该满足等差数列之和(2X+6)7/2 = 138,得到的X不为整数，所以应该是跨两个月。
2） 假设跨到第二个月1号，那么天数之和应该为(2X+5)6 + 1 = 138,不满足条件
3） 假设跨到第二个月2号，那么天数之和应该为(2X+4)*5 + 1 + 2 = 138,满足条件，X为25
那么七张日历数字应该为：25,26,27,28,29,1,2；也就是说日历是从闰年的2月25日到3月2日。
那么翻日历的那天应该是3月3日。

Posted on In

【试题描述】

已知有个rand7()的函数，返回1到7随机自然数，让利用这个rand7()构造rand10()随机1~10。

【试题分析】

1）要保证rand10()在整数1-10的均匀分布，可以构造一个1-10n的均匀分布的随机整数区间（n为任何正整数）。假设x是这个1-10n区间上的一个随机整数，那么x%10+1就是均匀分布在1-10区间上的整数。

2）接下来利用(rand7()-1)*7+rand7()构造出均匀分布在1-49的随机数：

首先rand7()-1得到一个离散整数集合{0，1，2，3，4，5，6}，其中每个整数的出现概率都是1/7。那么(rand7()-1)7得到一个离散整数集合A={0，7，14，21，28，35，42}，其中每个整数的出现概率也都是1/7。而rand7()得到的集合B={1，2，3，4，5，6，7}中每个整数出现的概率也是1/7。显然集合A和B中任何两个元素组合可以与1-49之间的一个整数一一对应，也就是说1-49之间的任何一个数，可以唯一确定A和B中两个元素的一种组合方式，反过来也成立。由于A和B中元素可以看成是独立事件，根据独立事件的概率公式P(AB)=P(A)P(B)，得到每个组合的概率是1/71/7=1/49。因此(rand7()-1)*7+rand7()生成的整数均匀分布在1-49之间，每个数的概率都是1/49。

3）由于出现的每个数的出现都是相对独立的，所以剔除41-49后剩下1-40也应该是均匀分布。

【CodeBy C Language】

1
2
3
4
5
6
7
int rand10() {
    int x = 0;
    do {
        x = (rand7()-1)*7+rand7();
    }while(x > 40);
    return x % 10 + 1;
}

【参考资料】 http://topic.csdn.net/u/20110926/11/AD722874-BCE1-4DFE-ADE1-DC4C7C293FF2.html http://blog.csdn.net/ljsspace/article/details/6820753"http://blog.csdn.net/ljsspace/article/details/6820753>

Posted on In 
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
'''
Created on 2011-8-1

@author: Killua
@E-mail:[email protected]
@Description:
'''

#!/usr/bin/env python3

import os
import time

#使用os模块进行文本替换
def context_replace(file, search_for, replace_with, new_file = 'new_file'):
    try:
        #remove old temp
        os.remove(new_file)
    except os.error:
        pass

    #open files
    fi = open(file)
    fo = open(new_file, 'w')

    #replace context
    for line in fi.readlines():
        fo.write(line.replace(search_for, replace_with))

    #close files
    fi.close()
    fo.close()

#使用 os 列出目录下的文件
def file_list(filepath):
    for filename in os.listdir(filepath):
        print(filename)

#使用 os 模块查看当前工作目录
def current_word_dir():
    print("Currnet Directory:" + os.getcwd())

#使用 os 模块创建/删除目录
def make_dir(dir_name):
    os.mkdir(dir_name)

def delete_dir(dir_name):
    if not os.path.isdir(dir_name):
        print("It's not a directory")
        return
    else:
        if len(os.listdir(dir_name)) == 0:
            os.rmdir(dir_name)
        else:
            print("The directory you want to delete is not empty,")

#使用 os 模块获取文件属性
def get_file_info(filename):
    file_state = os.stat(filename)
    mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime = file_state
    print("size:", size, "bytes")
    print("owner:", uid, gid)
    print("created:", time.ctime(ctime))
    print("last accessed:", time.ctime(atime))
    print("last modified:", time.ctime(mtime))
    print("mode:", oct(mode))
    print("inode/dev", ino, dev)

#使用 os 执行操作系统命令
def os_command_excute(cmd):
    os_name = os.name
    if os_name == "nt":
        print("Windows Command")
    else:
        print("Unix/Linux Command")
    os.system(cmd)

#Test
def main():
    #===Just For Test===
    #context_replace("sample", 'a', 'A')
    #file_list('/')
    #current_word_dir()
    #make_dir('sample_dir')
    #delete_dir('sample_dir')
    #get_file_info("sample")
    os_command_excute("ls -l")

if __name__ == "__main__":
    main()

Posted on In 
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
'''
Created on 2011-8-3

@author: Killua
@E-mail:[email protected]
@Description:
'''
#!/usr/bin/env python3

import os

#使用 os.path 模块处理文件名
def file_path_info(filename):
    print("OS:" + os.name)
    print("split:", os.path.split(filename))
    print("splitext:", os.path.splitext(filename))
    print("dirname:", os.path.basename(filename))
    print("basename:" + os.path.basename(filename))

#使用 os.path 搜索文件系统
def list_files(directory):
    stack = [directory]
    files = []
    while stack:
        directory = stack.pop()
        for file in os.listdir(directory):
            fullname = os.path.join(directory, file)
            files.append(fullname)
            if os.path.isdir(fullname) and not os.path.islink(fullname):
                stack.append(fullname)
    #List Files
    for file in files:
        print(file)

def main():
    #Just For Test
    #file_path_info("~/Workspace/MyProject/src/os_path_demo/os_path_demo.py")
    list_files("/home/killua")

if __name__ == "__main__":
    main()

Posted on In

Private Sub 与 Function 在 VB 程序设计中的区别
function 是函数，sub 是子程序，都可以传递参数，但函数有返回值，子程序没有
function 可以用自身名字返回一个值，sub 需定义别的变量，用传址方式传回值。

Sub 过程与 Function 过程的区别：
1． Sub 过程定义时无需定义返回值类型，而 Function 过程一般需要用“As 数据类型” 定义函数返回值类型。
2． Sub 过程中没有对过程名赋值的语句，而 Function 过程中一定有对函数名赋值的语句。
3． 调用过程：调用 Sub 过程与 Function 过程不同。调用 Sub 过程的是一个独立的语句，而调用函数过程只是表达式的一部分。Sub 过程还有一点与函数不一样，它不会用名字返回一个值。但是，与 Function 过程一样，Sub 过程也可以修改传递给它们的任何变量的值。
4． 调用 Sub 过程有两种方法：
以下两个语句都调用了名为 MyProc 的 Sub 过程。
Call MyProc (FirstArgument, SecondArgument)
MyProc FirstArgument, SecondArgument
注意当使用 Call 语法时，参数必须在括号内。若省略 Call 关键字，则也必须省略参数两边的括号。

Posted on In

类可以实例化为对象，而模块则不能。由于模块的数据只有一个副本，因此当程序的一部分更改模块中的公共变量时，如果程序的其他任何部分随后读取该变量，都会获取同样的值。与之相反，每个实例化对象的对象数据则单独存在。

类可以被继承，也可以实现接口，模块则不能

在类中定义的成员其作用范围在类的特定实例内，并且只存在于对象的生存周期内。要从类的外部访问类的成员，必须使用全限名称，格式为 Object.Member