Archive for December, 2012

作者:AngryFox 分类: Uncategorized December 31st, 2012 暂无评论
# coding: UTF-8
import time
from ctypes import *

user32 = windll.LoadLibrary('user32.dll')
user32.BlockInput(True);
time.sleep(10);
user32.BlockInput(False);
作者:AngryFox 分类: Uncategorized December 31st, 2012 暂无评论

用os.path.walk来遍历文件

import os, sys
listonly = False
skipexts = ['.gif', '.exe', '.pyc', '.o', '.a','.dll','.lib','.pdb','.mdb']        # ignore binary files

def visitfile(fname, searchKey):                       # for each non-dir file
    global fcount, vcount
      try:
        if not listonly:
            if os.path.splitext(fname)[1] in skipexts:
                pass
            elif open(fname).read().find(searchKey) != -1:
                print'%s has %s' % (fname, searchKey)
                fcount += 1
    except: pass
    vcount += 1 

def visitor(args, directoryName,filesInDirectory):     # called for each dir
    for fname in filesInDirectory:
        fpath = os.path.join(directoryName, fname)
        if not os.path.isdir(fpath):
            visitfile(fpath,args)

def searcher(startdir, searchkey):
    global fcount, vcount
    fcount = vcount = 0
    os.path.walk(startdir, visitor, searchkey)

if __name__ == '__main__':
    root=raw_input("type root directory:")
    key=raw_input("type key:")
    searcher(root,key)
    print 'Found in %d files, visited %d' % (fcount, vcount)
作者:AngryFox 分类: Uncategorized December 31st, 2012 暂无评论
# -*- coding: utf-8 -*-
#! /usr/bin/env python

import string, threading, time

def thread_main(a):
    global count, mutex
    # 获得线程名
    threadname = threading.currentThread().getName()

    for x in xrange(0, int(a)):
        # 取得锁
        mutex.acquire()
        print mutex
        count = count + 1
        # 释放锁
        mutex.release()
        #print threadname, x, count
        time.sleep(1)

def main(num):
    global count, mutex
    threads = []

    count = 1
    # 创建一个锁
    mutex = threading.Lock()

    # 先创建线程对象
    for x in xrange(0, num):
        threads.append(threading.Thread(target=thread_main, args=(10,)))
        #print threads
    # 启动所有线程
    for t in threads:
        t.start()
    # 主线程中等待所有子线程退出
    for t in threads:
        t.join()  

if __name__ == '__main__':
    num = 4
    # 创建4个线程
    main(4)
作者:AngryFox 分类: Uncategorized December 31st, 2012 暂无评论
1.生成随机数
          import random    #这个是注释,引入模块
          rnd = random.randint(1,500)#生成1-500之间的随机数

2.读文件

         f = open("c:\\1.txt","r")
         lines = f.readlines()#读取全部内容
         for line in lines
                 print line
3.写文件
        f = open("c:\\1.txt","r+")#可读可写模式
        f.write("123")#写入字符串

4.正则表达式,读取tomcat的日志并打印日期

     import re
     regx = "\d\d\d\d-\d\d-\d+"
     f = open("c:\stdout.log","r")
     i = 0
     for str in f.readlines():
        if re.search(regx,str):
             Response.write(str+"<br>")
              if i>10:break#由于是测试,只分析十行
              i=i+1
     f.close();

5.连接数据库

import pgdb

conn = pgdb.connect

(host='localhost',databse='qingfeng',user='qingfeng',password='123')

        cur = conn.cursor() 

        cur.execute("select * from dream") 

        print cur.rowcount

6.SAX处理xml:

      import string
      from xml.sax import saxlib, saxexts

      class QuotationHandler(saxlib.HandlerBase):
          """Crude sax extractor for quotations.dtd document"""

          def __init__(self):
                  self.in_quote = 0
                  self.thisquote = ''

          def startDocument(self):
              print '--- Begin Document ---'

          def startElement(self, name, attrs):
              if name == 'quotation':
                  print 'QUOTATION:'
                  self.in_quote = 1
              else:
                  self.thisquote = self.thisquote + '{'

          def endElement(self, name):
              if name == 'quotation':
                  print string.join(string.split(self.thisquote[:230]))+'...',
                  print '('+str(len(self.thisquote))+' bytes)\n'
                  self.thisquote = ''
                  self.in_quote = 0
              else:
                  self.thisquote = self.thisquote + '}'

          def characters(self, ch, start, length):
              if self.in_quote:
                  self.thisquote = self.thisquote + ch[start:start+length]

      if __name__ == '__main__':
          parser  = saxexts.XMLParserFactory.make_parser()
          handler = QuotationHandler()
          parser.setDocumentHandler(handler)
          parser.parseFile(open("sample.xml"))
          parser.close()

7.python的GUI模块标准的是Tkinter,也有QT和MFC的模块,有兴趣的大家自己搜索下

        import Tkinter

        root=Tkinter.Tk()

        my=Label(root,"Welcome to python's world")

        my.pack()

        root.mainloop()
作者:AngryFox 分类: Uncategorized December 30th, 2012 暂无评论

知识点

1.线程是“轻量级”进程,因为相较于进程的创建和管理,操作系统通常会用较少的资源来创建和管理线程。操作系统要为新建的进程分配单独的内在空间和数据;相反,程序中的线程在相同的内存空间中执行,并共享许多相同的资源。多线程程序在结内存的使用效率要优于多进程程序。

2.python提供了完整的多线程处理类,如果操作系统支持多线程,就可用python的threading模块创建多线程应用程序。程序员可以在一个应用程序中包含多个执行线程,而且每个线程都表明程序中的一部份要与其他线程并发执行。许多应用程序都可获益于多线程编程。Web浏览器下载大文件时(比如音乐或视频),用户希望立即可欣赏音乐或观看视频,这样就可以让一个线程下载,另一个线程播放已经下载的一部分。从而实现多个操作并发执行。
性能提示

1.单线程程序问题在于要在结束费时较长的操作后,才能开始其它操作。而在多线程程序中,线程可共享一个或多个处理器,使多个任务并行执行。

2.解释器开始执行程序时,“主”线程开始执行。每个线程都可创建和启动其它线程。如果程序包含多个正在运行的线程,它们将依据指定的间隔时间(称为一个quantum),依次进入和离开解释器。Python的“全局解释器锁”(Global Interpreter Lock,GIL)保证解释器在任何时刻只运行一个线程。GIL每次可用时,都会有单个线程包含它,然后,线程进入解释器,关在该线程的quantum时间段中执行它。一旦quantum到期,线程就离开解释器,同时释放GIL。

3.在任何时刻,线程都处于某种线程状态。新线程将从“born”状态开始它的生命周期。线程保持这个状态,直到程序调用线程的start方法,这会使线程进入“ready”状态,有时也称为“runnable”状态。另外,控制权会立即返回至调用线程(调用者)。之后,调用者可与已启动的线程以及程序中的其他任何线程并发执行。当“ready”线程首次获得GIL(Global Interpreter Lock,全局解释器锁),会执行它的run方法,成为一人“running”线程。run方法会一直执行,直到线程引发一个未处理的异常,或者线程离开解释器。running线程离开解释器时,线程会记住它的当前执行位置。以后线程重新进入解释器,线程会从该位置继续执行。线程惟一能获得GIL的状态就是“running”状态。

4.run方法返回或终止(如遇到一个未进行捕捉的异常),就会进入“dead”状态。解释器最终会对dead线程进行处理。如果running线程调用另一个线程的join方法,running线程会失去GIL,并等待加入的方法死亡之后才会继续。

5.大多数程序都使用外部资源(比如网络连接和磁盘文件)来执行任务。如果线程请求的资源不可用,线程就会进入“blocked”(暂停或阻塞)状态,直到资源再次可用,线程发了I/O请求后(比如从磁盘上读入文件,或将文件发送到打印机),会失去GIL,并离开解释器。其它线程就中使用解释器,从而可高效利用处理器,有助缩短程序的总体执行时间。I/O操作完成后,在“blocked”状态等候它的线程进入“ready”状态,之后,线程就会试图重新获得GIL。

6.“running”线程调用time.sleep函数后,会释放GIL并进入“sleeping”(休眠)状态。指定的休眠时间到期,“sleeping”线程会返回“ready”状态。即使解释器可用,“sleeping”线程也不能使用解释器。

7.程序中的线程通常共享数据。如果多个线程修改相同的数据,数据会出错,在这样的程序中,需要同步对共享数据的访问。这意味着访问共享数据的每个线程首先必须获得与数据对应的一个同步对象锁。一旦线程处理完数据,就应释放同步对象,使其它线程能访问数据。

8.有时因为一个程序的逻辑需求,正在运行的线程即使为共享数据获得了同步对象,也不能对其执行操作。这种情况下,线程可调用同步对象的wait方法以主动释放对象。这会导致线程释放GIL并针对那个同步对象进入“waiting”状态。另一个线程调用同步对象的notify方法时,那个同步对象的一个“waiting”线程会变成“ready”状态。在重新获得GIL后,线程就会恢复执行。“running”线程调用同步对象的notifyAll方法,处于“waiting”状态的每个线程都会变成“ready”状态。然后,解释器选择一个“ready”线程来执行。

9.threading.currentThread函数会返回对当前正在运行的线程的一个引用。

10.threading.enumerate函数返回一个列表,其中包含Thread类的当前所有活动对象(即run方法开始但未终止的任何线程)。

11.threading.activeCount函数返回上面列表的长度。

12.isAlive可测试线程是否死亡,如果返回1代表线程正在运行;setName方法设置线程名称;getName方法返回线程名称;为一个线程使用print方法会显示线程名称及其当前状态。

13.通常将访问共享数据的代码区称为“临界区”

14.访问共享数据的每个线程都禁止其他所有线程同时访问相同的数据。这称为“独占”或“线程同步”。threading模块提供了许多线程同步机制。最简单的同步机制是“锁”。锁对象用threading.RLock类创建,它定义了两个方法,即acquire(获得)和release(释放)。线程调用acquire方法,锁会进入“locked”(锁定)状态,每次只有一个线程可获得锁。如另一个线程试图对同一个锁对象调用acquire方法,操作系统会将那个线程转变为“blocked”状态,直到锁变得可用。拥有锁的线程调用release方法,锁会进入“unlocked”(解锁)状态。“blocked”的线程会收到一个通知,并可获得锁。如果多个锁处于“blocked”状态,所有线程都会先解除该状态。然后,操作系统选择一个线程来获得锁,再将其余线程变回“blocked”状态。

15.在多线程程序中,线程必须先获得一个锁,再进入临界区;退出临界区时,则要释放锁。

16.在复杂的线程中,有时只在发生某些事件时才访问一个临界区(比如在某个数据值改变时)。这是通过“条件变量”来完成的。线程用条件变量来监视一个对象的状态,或者发出事件通知。对象状态改变或事件发生时,处于blocked状态的线程会收到通知。收到通知后线程才访问临界区。

17.条件变量用threading.Condition类创建。条件变量包含基本锁,所以它们提供了acquire和release方法。条件变量的其它方法还有wait和nofify。线程成功获得一个基本锁后,调用wait方法会导致调用线程释放这个锁,并进入“blocked”状态,直到另一个线程调用同一个条件变量的notify方法,从而将其唤醒。notify方法可唤醒一个正在等待条件变量的线程;notifyAll则唤醒所有正在等待的方法。

18.下面通过一个“生产者/消费者”的关系,说明线程同步的应用情况。在这个关系中,应用程序的“生产者”部分生成数据,“消费者”部分使用数据,在多线程的生产者/消费者关系中,“生产者线程”调用一个“生产方法”来生成数据,并将数据放到名为“缓冲区”的共享内存区域。“消费者线程”则调用一个“消费方法”来读取数据。如果正在等待放入下一批数据的生产者线程发现消费者线程尚未从缓冲区中读取上一批数据,生产者线程就会调用条件变量的wait方法;否则,消费者线程将无法看到上一批数据。消费者线程读取数据时,应调用条件变量的notify方法,使正在等待的生产者线程继续。如果消费者线程发现缓冲区为空,或上一批数据已读取,就应调用条件变量的wait方法;否则,消费者线程会从缓冲区读入“垃圾”数据,或者重复处理以前的数据项–任何一种可能都会导致应用程序出现逻辑错误。生产者将下一批数据放入缓冲区时,生产者线程应调用条件变量的notify方法,让消费者线程继续。

19.为尽可能缩短共享资源并以相同相对速度工作的各线程的等待时间,可用一个“队列(Queue)”来提供额外的缓冲区,便于生产者在其中放值,也便于消费者从中获得那些值。

20.python提供一个Queue模块,该模块定义一人Queue类,即队列的一个同步实现。

21.“信号机”(Semaphore)是一个变量,控制着对公共资源或临界区的访问。信号机维护着一个计数器,指定可同时使用资源或进入临界区的线程数。每次有一个线程获得信号机时,计数器都会自减。若计数器为0,其它线程便只能暂停访问信号机,直到另一个线程释放信号机。

22.threading模块定义了可用于线程通信的Event(事件)类。Event有一个内部标记,可为true或false。一个或多个线程能调用Event对象的wait方法以暂停并等待事件发生。事件发生后,暂停的线程会按它们抵达的顺序被唤醒,并恢复执行。
常见编程错误

1.必须把所有临界区都封闭在acquire和release调用之间。

2.如果程序使用了锁,就要仔细检查,保证程序不会死锁。如果程序或线程永远处于“blocked”状态,就会发生死锁。

3.等待一个条件变量的线程必须用notify显式唤醒,否则它会永远地等待下去,导致死锁。
测试和调试提示

1.保证每个wait调用都有一个对应的notify调用,以最终结束等待,也可调用notifyAll以策万全。

性能提示

1.通过同步来确保多线程程序的正确性,可能会减慢程序的运行速度,这是由于锁造成了额外的开销,而且需在线程的不同状态间频繁切换。

作者:AngryFox 分类: Uncategorized December 30th, 2012 暂无评论

使用条件变量最大的好处是可以避免忙等。相当与多线程中的信号。

条件变量是线程中的东西就是等待某一条件的发生和信号一样

以下是说明
,条件变量使我们可以睡眠等待某种条件出现。
条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待”条件变量的条件成立”而挂起;另一个线程使”条件成立”(给出条件成立信号)。为了防止竞争,条件变量的使用总是和一个互斥锁结合在一起。
条件变量类型为pthread_cond_t

创建和注销
条件变量和互斥锁一样,都有静态动态两种创建方式,静态方式使用PTHREAD_COND_INITIALIZER常量,如下:
pthread_cond_t cond=PTHREAD_COND_INITIALIZER
动态方式调用pthread_cond_init()函数,API定义如下:
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)
尽管POSIX标准中为条件变量定义了属性,但在LinuxThreads中没有实现,因此cond_attr值通常为NULL,且被忽略。
注销一个条件变量需要调用pthread_cond_destroy(),只有在没有线程在该条件变量上等待的时候才能注销这个条件变量,否则返回EBUSY。API定义如下:
int pthread_cond_destroy(pthread_cond_t *cond)

等待和激发
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
等待条件有两种方式:无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait(),其中计时等待方式如果在给定时刻前条件没有满足,则返回ETIMEOUT,结束等待,其中abstime以与time()系统调用相同意义的绝对时间形式出现,0表示格林尼治时间1970年1月1日0时0分0秒。
使用绝对时间而非相对时间的优点是。如果函数提前返回(很可能因为捕获了一个信号,)
无论哪种等待方式,都必须和一个互斥锁配合,以防止多个线程同时请求pthread_cond_wait()(或pthread_cond_timedwait(),下同)的竞争条件(Race Condition)。mutex互斥锁必须是普通锁(PTHREAD_MUTEX_TIMED_NP)或者适应锁(PTHREAD_MUTEX_ADAPTIVE_NP),且在调用pthread_cond_wait()前必须由本线程加锁(pthread_mutex_lock()),而在更新条件等待队列以前,mutex保持锁定状态,并在线程挂起进入等待前解锁。在条件满足从而离开pthread_cond_wait()之前,mutex将被重新加锁,以与进入pthread_cond_wait()前的加锁动作对应。
激发条件有两种形式,pthread_cond_signal()激活一个等待该条件的线程,存在多个等待线程时按入队顺序激活其中一个;而pthread_cond_broadcast()则激活所有等待线程。

其他
pthread_cond_wait()和pthread_cond_timedwait()都被实现为取消点,因此,在该处等待的线程将立即重新运行,在重新锁定mutex后离开pthread_cond_wait(),然后执行取消动作。也就是说如果pthread_cond_wait()被取消,mutex是保持锁定状态的,因而需要定义退出回调函数来为其解锁。


EXAMPLE
       Consider two shared variables x and y, protected by the mutex mut,  and
       a  condition  variable  cond  that is to be signaled whenever x becomes
       greater than y.
              int x,y;
              pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
              pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
       Waiting until x is greater than y is performed as follows:
              pthread_mutex_lock(&mut);
              while (x <= y) {
                      pthread_cond_wait(&cond, &mut);
              }
              /* operate on x and y */
              pthread_mutex_unlock(&mut);
       Modifications on x and y that may cause x  to  become  greater  than  y
       should signal the condition if needed:
              pthread_mutex_lock(&mut);
              /* modify x and y */
              if (x > y) pthread_cond_broadcast(&cond);
              pthread_mutex_unlock(&mut);
       If  it  can be proved that at most one waiting thread needs to be waken
       up (for instance, if there are only two threads communicating through x
       and  y),  pthread_cond_signal  can be used as a slightly more efficient
       alternative    to    pthread_cond_broadcast.      In     doubt,     use
       pthread_cond_broadcast.
       To  wait  for  x to becomes greater than y with a timeout of 5 seconds,
       do:

              struct timeval now;
              struct timespec timeout;
              int retcode;
              pthread_mutex_lock(&mut);
              gettimeofday(&now);
              timeout.tv_sec = now.tv_sec + 5;
              timeout.tv_nsec = now.tv_usec * 1000;
              retcode = 0;
              while (x <= y && retcode != ETIMEDOUT) {
                      retcode = pthread_cond_timedwait(&cond, &mut, &timeout);
              }
              if (retcode == ETIMEDOUT) {
                      /* timeout occurred */
              } else {
                      /* operate on x and y */
              }
              pthread_mutex_unlock(&mut);
 

要想知道更详细,请看 man pthread_cond_wait

作者:AngryFox 分类: Uncategorized December 30th, 2012 暂无评论

现在到了C1000K 问题了

现在网民越来越多了,越来越多的网络服务开始面临C10K问题,就是连接数超过1万的问题。为什么连接数超过1万会有问题?因为之前的网络服务程序都没有考虑这么大的并发,会引起服务器死机或者失去响应都问题。如何解决这个问题?改变对连接提供服务的策略。

主要是想说在商用服务器软件或者开源服务器软件能够很好的解决这个问题之前,C10K将是互联网服务提供商(ISP)的一道不小的门槛。我们可以看到很多网站有不错的服务内容(IM、Game、Blog、Photo等等),但是随着用户数的增加,很快它就开始陷入了不稳定的状态,经常失去响应或者关闭了某些服务,如果这个时候出现了另外一家服务稳定的提供商,大家便会转向那里。所以,如果目标用户群足够大,做ISP之前事先考虑清楚C10K问题,保证服务推出之后能够在大并发的情况下保持稳定,是成功的重要条件。

关注EPOLL
通信服务器通常采用多进程、多线程同步阻塞I/O或者是基于SELECT、POLL的单线程事件驱动I/O(Single Process Event-Driven)等方式设计.设计了一个通信服务器,分析指出几种网络I/O方式在高并发连接下其性能已经成为首要瓶颈,提出采用一种新的单线程异步事件驱动I/O方式-EPOLL,针对传统的POLL作了相关的优化;根据通信服务器特性提出了在不同服务器负载和网络条件下,采取几种转发模式和发送模式的自适应匹配策略用以提高服务器性能.通过实验表明,基于采用EPOLL技术和自适应匹配策略的服务器比传统的基于SELECT、POLL的服务器提高了五倍的性能.

作者:AngryFox 分类: Uncategorized December 30th, 2012 暂无评论

1.os模块
os模块包装了不同操作系统的通用接口,使用户在不同操作系统下,可以使用相同的函数接口,返回相同结构的结果。
os.name:返回当前操作系统名称(’posix’, ‘nt’, ‘os2′, ‘mac’, ‘ce’ or ‘riscos’)
os中定义了一组文件、路径在不同操作系统中的表现形式参数,如
os.sep(文件夹分隔符,windows中是 \ )
os.extsep(扩展名分隔符,windows中是 . )
os.pathsep(目录分隔符,windows中是 ; )
os.linesep(换行分隔符,windows中是 \r\n )
os中有大量文件、路径操作的相关函数,如:
listdir(path):列举目录下的所有文件
makedir(path):创建文件夹,注:创建已存在的文件夹将异常
makedirs(path):递归式的创建文件夹,注:创建已存在的文件夹将异常
remove(filename):删除一个文件
rmdir(path):删除一个文件夹,注:删除非空的文件夹将异常
removedirs(path):递归的删除文件夹,直到有一级的文件夹非空,注:文件夹路径不能以’\'结束
rename(src,dst):给文件或文件夹改名(可以改路径,但是不能覆盖目标文件)
renames(src,dst):递归式的给文件或文件名改名
walk(path):列举path下的所有文件、文件夹
os中与进程相关的操作,如:
execl(path):运行一个程序来替代当前进程,会阻塞式运行
_exit(n):退出程序
startfile(filename):用与文件关联的程序运行,关联程序打开后,立即返回
system(cmd):运行一个程序或命令,会立即返回,并在cmd执行完成后,会返回cmd退出代码
os.path:在不同的操作系统中调用不同的模块,是一个可import的模块,这个模块中提供很多有用的操作:
abspath(path):返回path的绝对路径,若path已经是绝对路径了,则保持。
basename(path):返回path中的文件名。
commonprefix(list):返回list中的统一前缀,用于获得一组字符串的左起相同的内容
dirname(path):返回path中的文件夹部分,结果不包含’\’
exists(path):文件或文件夹是否存在
getatime(path):文件或文件夹的最后访问时间,从新纪元到访问时的秒数
getmtime(path):文件或文件夹的最后修改时间
getctime(path):文件或文件夹的创建时间
getsize(path):文件或文件夹的大小,若是文件夹返回0
isabs(path):返回是否是绝对路径
isfile(path):返回是否是文件路径
isdir(path):返回是否是文件夹路径
islink(path):返回是否是快捷方式
join(path1,path2,…):将path进行组合,若其中有绝对路径,则之前的path将被删除
normcase(path):转换路径中的间隔符
normpath(path):转换路径为系统可识别的路径
realpath(path):转换路径为绝对路径
split(path):将路径分解为(文件夹,文件名)
splitext(path):将路径分解为(其余部分,.扩展名),若文件名中没有扩展名,扩展名部分为空字符串
在操作与系统不支持的对象时,抛出OSError异常。

2.sys模块
系统信息和方法模块,提供了很多实用的变量和方法:
argv:命令行参数List,第一个元素是程序本身路径
builtin_module_names:Python解释器导入的模块列表
modules.keys():返回所有已经导入的模块列表
exc_info():获取当前正在处理的异常类
exc_type、exc_value、exc_traceback:当前处理的异常详细信息
executable:Python解释程序路径
exit(n):退出程序,正常退出时exit(0)
getwindowsversion():获取Windows的版本
hexversion:获取Python解释程序的版本值,16进制格式如:0x020403F0
version:获取Python解释程序的版本信息
maxint:最大的Int值
maxunicode:最大的Unicode值
modules:返回系统导入的模块字段,key是模块名,value是模块
path:返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
platform:返回操作系统平台名称

3.built-in内置模块
eval(expr[,globals[,locals]]):执行一段代码,并返回结果
exec(expr[,globals[,locals]]):执行一段代码
execfile(file[,globals[,locals]]):执行一个文件
filter(func,list):使用函数来过滤list,返回满足要求的list元素组
getattr(obj,name[,default]):获取对象的属性,若没有该属性,则返回默认值
setattr(obj,name,value):设置对象的属性,若没有该属性,则异常
hasattr(obj,name):返回对象是否有指定属性
input([prompt]):提示控制台输入,必须输入常量或变量,若想直接输入字符串,需要使用引号括起来
raw_input([prompt]):提示控制台输入,直接输入数字或字符串
open(filename,mode):打开文件,mode可以为:w,r,a,若想同时读写,则加上+,若想以二进制读写,则加上b
reload(module):再次导入已导入过的模块
type(obj):返回一个对象的类型
zip(seq1,…):将若干个元组进行合并,长度以元组中的最短的为准

4.time模块
这个模块定义的都是和时间、时钟、计时相关的内容:
clock():返回第一次调用到当前调用时的计时,是以秒为单位的浮点数
localtime([t]):返回时间的数组,有9个元素(年,月,日,时,分,秒,星期几,当年的第几天,是否夏令时),星期一为0
mktime(tlist):是localtime的反函数,将一个9元数组转成一个浮点时间值,后3个元素,系统会自己调整
sleep(n):挂起线程n秒
strftime(fstring[,t]):格式化显示时间,fstring常用关键字:
%a,%A:星期的缩写,全拼
%b,%B:月份的缩写,全屏
%c,%x,%X:本地默认表示法(日期时间,日期,时间)
%Y(%y:2位),%m,%d,%H,%M,%S:年月日时分秒
%w:星期,0为星期天
strptime(string[,format]):将字符串解析为9元素的时间数组
time():返回当前时间值,浮点数
更高级的用法可以使用datetime模块,创建其中的date,time对象,可以进行加减操作,得出timedelta对象。

5.re模块
限定符说明:
“.”: 匹配任何字符
“^”: 匹配开头
“$”: 匹配结尾
“*”: 匹配0次或更多次之前的表达式。贪婪时,匹配尽可能多次
“+”: 匹配1次或更多次之前的表达式。等价于{1,}
“?”: 匹配0次或1次之前的表达式。等价于{0,1}
“*?,+?,??”: 非贪婪匹配
“{m,n}”: 贪婪式匹配之前的表达式m到n次
“{m,n}?”: 非贪婪匹配之前的表达式m到n次
“\”: 将下一个字符转义
[ABC]: 指定一个字符集
[^ABC]: 指定一个不在范围内的字符集
“A|B”: 匹配条件A或条件B
(pattern): 匹配括号内的表达式,并作为匹配项
(?:pattern): 匹配括号内的表达式,但不作为匹配项
(?#…): 注释,忽略
(?=pattern): 预查,若之后的内容匹配表达式,则成立
(?!pattern): 预查,若之后的内容不匹配表达式,则成立
(?Ppattern): 给一个匹配项命名
(?P=name): 匹配与之前命名的匹配项内容相同的部分
如:s=’12a34a56′
re.findall(’12(?P.).*(?P=xxx)56)’, s)
(?P.)匹配到a,则(?P=xxx)的内容也必须为a时才pp
(?iLmsux): 设置I,L,M,S,U,or X标记
转义符说明:
\A: 匹配开头
\Z: 匹配结尾
\b: 匹配开头或结尾的空字符串,通常是指单词边界 ???
\B: 匹配非开头和结尾的空字符串,通常是指非单词边界???
\d: 匹配一个数字。等价于[0-9]
\D: 匹配一个非数字。等价于[^0-9]
\s: 匹配一个空白字符。等价于[ \t\n\r\f\v]
\S: 匹配一个非空白字符。等价于[^ \t\n\r\f\v]
\w: 匹配一个字母数字字符。等价于[a-zA-Z0-9_]
\W: 匹配一个非字母数字字符。等价于[^a-zA-Z0-9_]
\\: 匹配一个反斜杠
\f: 匹配一个换页符。等价于\x0C 和 \cL
\n: 匹配一个换行符。等价于\x0A 和 \cJ
\r: 匹配一个回车符。等价于\x0D 和 \cM
\t: 匹配一个制表符。等价于\x09 和 \cI
\v: 匹配一个垂直制表符。等价于\x0B 和 \cK
\xHH: 匹配 HH,其中 HH 为十六进制转义值
\uHHHH: 匹配 HHHH,其中 HHHH 是一个用四个十六进制数字表示的Unicode字符
常用匹配:
匹配中文字符的正则表达式: [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内):[^\x00-\xff]
匹配空行的正则表达式:\n[\s| ]*\r
匹配首尾空格的正则表达式:(^\s*)|(\s*$)
匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配网址URL的正则表达式:^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*\\?\\S*)?$
匹配帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$
匹配国内电话号码:(\d{3}-|\d{4}-)?(\d{8}|\d{7})?
匹配腾讯QQ号:^[1-9]*[1-9][0-9]*$
模块使用:
match:
search:
sub: 替换
subn: 替换并返回替换的次数
split: 分隔
findall: 查找所有匹配项
compile:
purge:
escape:
可选参数:
I(IGNORECASE): 忽略大小写
L(LOCALE): 使用\w,\W,\b,\B时依据本地配置???
M(MULTILINE): 多行,”^”匹配每行的开头,”$”匹配每行的末尾
S(DOTALL): 使”.”匹配包含换行符在内的任意字符
X(VERBOSE): 忽略空白处和注释内容
U(UNICODE): 使\w,\W,\b,\B依靠UNICODE编码
6.thread模块/threading模块
Python Thread类主要用来表示一个单线程的运行活动
threading是对thread做了一些包装的,可以更加方便的被使用。这里需要提一下的是python对线程的支持还不够完善,不能利用多 CPU,但是下个版本的python中已经考虑改进这点,让我们拭目以待吧。
threading模块里面主要是对一些线程的操作对象化了,创建了叫Thread的class。一般来说,使用线程有两种模式,一种是创建线程要执行的 函数,把这个函数传递进Thread对象里,让它来执行;另一种是直接从Thread继承,创建一个新的class,把线程执行的代码放到这个新的 class里。
7.urllib模块

8.urllib2模块

9.socket模块

10.file对象操作
open(文件名,模式,缓冲):模式可以置为(r,w,a,r+,w+等),这些模式本身不会去锁定文件,在同时使用读和写时,要使用seek来移动位置。
close():关闭的作用是置位closed,多次关闭不会引发异常。
flush():将内在缓冲的内容写入文件。
read(n):读入若干字节,无n时,读入全部。
readline(n):读入若干行,n表示读入的最长字节数。
seek(offset,where):where=0从起始位置移动,1从当前位置移动,2从结束位置移动。
tell():文件的当前位置。
truncate(n):截断文件为n个字符,无n表示从当前位置起截断。
write(str):在当前位置写入字符串。
writelines(lines):相当于给lines中的每个字符串调用write函数。

11.其它模块
filecmp.cmp(file1,file2):比较file1和file2的内容是否相同
dircmp:可以构造一个比较两个目录内容的对象,较强
getpass.getpass(prompt):让用户在控制台输入不显示的密码
getopt.getopt(args,options[,long_options]):用于解析运行参数
shutil.copy(file1,file2):将文件1复制到file2

作者:AngryFox 分类: Uncategorized December 30th, 2012 暂无评论
    include("ImageResize.class.php")
     //转视频
     $cmd="ffmpeg.exe -i starwar.avi -ab 56 -ar 22050 -b 500 -r 15 -s 320x240 1.flv";
     exec($cmd);
     //视频截图
     $cmd="ffmpeg.exe -i starwar.avi -f image2 -ss 10 -s 400*300 -vframes 1 1.jpg";
     exec($cmd);
     //生成缩略图
     $thumbnail = new ImageResize();
     $thumbnail->resizeimage("1.jpg", 30,30, 0, "small1.jpg");  

    class ImageResize {  

        //图片类型
        var $type;  

        //实际宽度
        var $width;  

        //实际高度
        var $height;  

        //改变后的宽度
        var $resize_width;  

        //改变后的高度
        var $resize_height;  

        //是否裁图
        var $cut;  

        //源图象
        var $srcimg;  

        //目标图象地址
        var $dstimg;  

        //临时创建的图象
        var $im;  

    function resizeimage($img, $wid, $hei,$c,$dstpath) {
            $this->srcimg = $img;
            $this->resize_width = $wid;
            $this->resize_height = $hei;
            $this->cut = $c;  

            //图片的类型
            $this->type = strtolower(substr(strrchr($this->srcimg,"."),1));  

            //初始化图象
            $this->initi_img();  

            //目标图象地址
            $this -> dst_img($dstpath);  

            //--
            $this->width = imagesx($this->im);
            $this->height = imagesy($this->im);  

            //生成图象
            $this->newimg();  

            ImageDestroy ($this->im);
        }  

    function newimg() {  

    //改变后的图象的比例
            $resize_ratio = ($this->resize_width)/($this->resize_height);  

    //实际图象的比例
            $ratio = ($this->width)/($this->height);  

    if(($this->cut)=="1") {
                //裁图 高度优先
                if($ratio>=$resize_ratio){
                    $newimg = imagecreatetruecolor($this->resize_width,$this->resize_height);
                    imagecopyresampled($newimg, $this->im, 0, 0, 0, 0, $this->resize_width,$this->resize_height, (($this->height)*$resize_ratio), $this->height);
                    ImageJpeg ($newimg,$this->dstimg);
                }  

                //裁图 宽度优先
                if($ratio<$resize_ratio) {
                    $newimg = imagecreatetruecolor($this->resize_width,$this->resize_height);
                    imagecopyresampled($newimg, $this->im, 0, 0, 0, 0, $this->resize_width, $this->resize_height, $this->width, (($this->width)/$resize_ratio));
                    ImageJpeg ($newimg,$this->dstimg);
                }
            } else {
                //不裁图
                if($ratio>=$resize_ratio) {
                    $newimg = imagecreatetruecolor($this->resize_width,($this->resize_width)/$ratio);
                    imagecopyresampled($newimg, $this->im, 0, 0, 0, 0, $this->resize_width, ($this->resize_width)/$ratio, $this->width, $this->height);
                    ImageJpeg ($newimg,$this->dstimg);
                }
                if($ratio<$resize_ratio) {
                    $newimg = imagecreatetruecolor(($this->resize_height)*$ratio,$this->resize_height);
                    imagecopyresampled($newimg, $this->im, 0, 0, 0, 0, ($this->resize_height)*$ratio, $this->resize_height, $this->width, $this->height);
                    ImageJpeg ($newimg,$this->dstimg);
                }
            }
        }  

    //初始化图象
        function initi_img() {
            if($this->type=="jpg") {
                $this->im = imagecreatefromjpeg($this->srcimg);
            }  

            if($this->type=="gif") {
                $this->im = imagecreatefromgif($this->srcimg);
            }  

            if($this->type=="png") {
                $this->im = imagecreatefrompng($this->srcimg);
            }  

            if($this->type=="bmp") {
                $this->im = $this->imagecreatefrombmp($this->srcimg);
            }
        }  

    //图象目标地址
        function dst_img($dstpath) {
            $full_length  = strlen($this->srcimg);
            $type_length  = strlen($this->type);
            $name_length  = $full_length-$type_length;
            $name = substr($this->srcimg,0,$name_length-1);
            $this->dstimg = $dstpath;
            //echo $this->dstimg;
        }  

        function ConvertBMP2GD($src, $dest = false) {
            if(!($src_f = fopen($src, "rb"))) {
                return false;
            }
            if(!($dest_f = fopen($dest, "wb"))) {
                return false;
            }
            $header = unpack("vtype/Vsize/v2reserved/Voffset", fread($src_f,14));
            $info = unpack("Vsize/Vwidth/Vheight/vplanes/vbits/Vcompression/Vimagesize/Vxres/Vyres/Vncolor/Vimportant", fread($src_f, 40));  

            extract($info);
            extract($header);  

            if($type != 0x4D42) { // signature "BM"
                return false;
            }  

            $palette_size = $offset - 54;
            $ncolor = $palette_size / 4;
            $gd_header = "";
            // true-color vs. palette
            $gd_header .= ($palette_size == 0) ? "\xFF\xFE" : "\xFF\xFF";
            $gd_header .= pack("n2", $width, $height);
            $gd_header .= ($palette_size == 0) ? "\x01" : "\x00";
            if($palette_size) {
                $gd_header .= pack("n", $ncolor);
            }
            // no transparency
            $gd_header .= "\xFF\xFF\xFF\xFF";  

    fwrite($dest_f, $gd_header);  

    if($palette_size) {
                $palette = fread($src_f, $palette_size);
                $gd_palette = "";
                $j = 0;
                while($j < $palette_size) {
                    $b = $palette{$j++};
                    $g = $palette{$j++};
                    $r = $palette{$j++};
                    $a = $palette{$j++};
                    $gd_palette .= "$r$g$b$a";
                }
                $gd_palette .= str_repeat("\x00\x00\x00\x00", 256 - $ncolor);
                fwrite($dest_f, $gd_palette);
            }  

    $scan_line_size = (($bits * $width) + 7) >> 3;
            $scan_line_align = ($scan_line_size & 0x03) ? 4 - ($scan_line_size &
            0x03) : 0;  

    for($i = 0, $l = $height - 1; $i < $height; $i++, $l--) {
                // BMP stores scan lines starting from bottom
                fseek($src_f, $offset + (($scan_line_size + $scan_line_align) * $l));
                $scan_line = fread($src_f, $scan_line_size);
                if($bits == 24) {
                    $gd_scan_line = "";
                    $j = 0;
                    while($j < $scan_line_size) {
                        $b = $scan_line{$j++};
                        $g = $scan_line{$j++};
                        $r = $scan_line{$j++};
                        $gd_scan_line .= "\x00$r$g$b";
                    }
                }
                else if($bits == 8) {
                    $gd_scan_line = $scan_line;
                }
                else if($bits == 4) {
                    $gd_scan_line = "";
                    $j = 0;
                    while($j < $scan_line_size) {
                        $byte = ord($scan_line{$j++});
                        $p1 = chr($byte >> 4);
                        $p2 = chr($byte & 0x0F);
                        $gd_scan_line .= "$p1$p2";
                    }
                    $gd_scan_line = substr($gd_scan_line, 0, $width);
                }
                else if($bits == 1) {
                    $gd_scan_line = "";
                    $j = 0;
                    while($j < $scan_line_size) {
                        $byte = ord($scan_line{$j++});
                        $p1 = chr((int) (($byte & 0x80) != 0));
                        $p2 = chr((int) (($byte & 0x40) != 0));
                        $p3 = chr((int) (($byte & 0x20) != 0));
                        $p4 = chr((int) (($byte & 0x10) != 0));
                        $p5 = chr((int) (($byte & 0x08) != 0));
                        $p6 = chr((int) (($byte & 0x04) != 0));
                        $p7 = chr((int) (($byte & 0x02) != 0));
                        $p8 = chr((int) (($byte & 0x01) != 0));
                        $gd_scan_line .= "$p1$p2$p3$p4$p5$p6$p7$p8";
                    }
                    $gd_scan_line = substr($gd_scan_line, 0, $width);
                }
                fwrite($dest_f, $gd_scan_line);
            }
            fclose($src_f);
            fclose($dest_f);
            return true;
        }  

    function imagecreatefrombmp($filename) {
            $tmp_name = tempnam("/tmp", "GD");
            if($this->ConvertBMP2GD($filename, $tmp_name)) {
                $img = imagecreatefromgd($tmp_name);
                unlink($tmp_name);
                return $img;
            }
            return false;
        }  

    }  
作者:AngryFox 分类: Uncategorized December 28th, 2012 暂无评论

刷新本地dns: ipconfig /flushdns

1,mysql备份:
mysqldump -uuser -ppassword database table > table.txt
如果不写table,默认把整个database备份下来。

2,makefile 中用tab键,不能用空格。也不要从剪贴版乱copy。
shell 中等号后面不能有空格。

find * -type f 会把路径都显示出来。查找文件比ls -R方便。
whereis locate 同样可以查找文件
例如:
[yangbin1@vHost-RH9 my]$ find * -type f | grep mysql.c
linuxc/mysql_connect
linuxc/mysql_connect.c
linuxc/mysql.c
sql/mysql.c

在当前目录以及子目录中文件中查找sendfile()函数。
grep -Ra “sendfile” *

只在当前目录中查找
grep “sendfile” *

3,主机时间每天晚上同步一次,把下面的命令加入contab中:
#for standard time
30 0 * * * /usr/sbin/ntpdate tick.ucla.edu tock.gpsclock.com ntp.nasa.gov timekeeper.isi.edu usno.pa-x.dec.com > /dev/null

4,得到昨天的时间(bsd中) date -v -1d

5,取得现在的时间unix c
#include
#include
#include
main()
{
char datetime[64];
time_t now = time(&now);
strftime(datetime,100,”%Y/%m/%d %H:%M:%S”,localtime(&now));
printf(“datetime:%s\n”,datetime);
}

计算时间差
difftime(time_t time1, time_t time0) / 86400
好象最大到2035年,不太清楚。

6,利用现存两个文件,生成一个新的文件

删除交集,不同的部分放到一个新文件中。
cat list.txt list.txt.old | sort | uniq -u > list.txt.new

取出两个文件的并集,重复的行只保留一份.
cat file1 file2 | sort | uniq > file3

取出两个文件的交集,只留下同时存在于两个文件中的文件.
cat file1 file2 | sort | uniq -d >file3
7,一个进程的多个线程中不但共享文件描述符,还共享文件指针的位置。所以被别的线程读过的文件,不要忘记lseek到文件开始处。

8,sendfile()在freebsd和linux上的区别除了参数个数不一样外,前两个参数的顺序也不一样。

#ifndef FREEBSD
//….. linux sendfile
if(-1 ==sendfile(fd,fds[i].fd,0,fds[i].size))
#else
//……freebsd sendfile
if (-1 ==sendfile(fds[i].fd,fd,0,0,NULL,NULL,0))
#endif
perror(sendfile error!);

9,如何检测另一个进程是不是死掉了。
ret=kill(pid,0);
0 means no signal sent,but error checking is still performed;
ret==0 means process running;
ret==-1 and errno=ESRCH means process doesn’t exist.
other errors check urself

另一个进程启动时候将进程号写到一个文件里。
这个程序来读。然后kill检测它是不是有效的进程。
如果ret不为零,说明进程死掉了,你可以用配合system()将它重新启动。

10, 让一个进程在终端退出后,仍然在后台运行。
nohup ./receivefile 172.16.11.145 > /dev/null &

11, 查看系统信息
最大可以打开文件的数目,cpu和内存信息
cat /proc/sys/fs/file-max
cat /proc/cpuinfo
cat /proc/meminfo
linux上查看发行版本
cat /etc/issue

查看系统相关信息
uname -a

在c中查看当前系统是什么os
int uname(struct utsname *buf)

12,修改了/etc/ld.so.conf后,ldconfig -v 使设置生效。
ldd myprogram 查看程序使用了那些函数库。

13,在mysql中创建一个mydb库。将权限给某个user,密码为user123。
create database mydb;
grant all privileges on mydb.* to user@localhost identified by ‘user123′;

14,查看某主机上的web服务。
telnet 10.210.128.189 80
GET /index.html HTTP/1.0
HOST:

15,将字符串格式化成一定的数据。
sscanf(fielName, “%[ a-z]%[0-9].%[a-z]“, user, date, suffix);