博客园_进行时

在linux中通过进程名获得进程id

2012-02-21T01:09:00Z

当需要kil一个进程时，需要提供一个pid(使用kill命令)或提供一个进程名(使用pkill命令)。
pkill是如何通过进程名得到进程id的？
在linux中进程是通过文件来表示的，信息都存储在/proc/pid目录中。
在/proc/pid/status文件的第一行，保存有进程名，和用户输入的进行比对，如果一致，就添加到动态数组中，最后返回。

附代码：

long* find_pid_by_name( char* pidName)
{
	DIR *dir;
	struct dirent *next;
	long* pidList=NULL;
	int i=0;

        ///proc中包括当前的进程信息,读取该目录
	dir = opendir("/proc");
	if (!dir)
		perror_msg_and_die("Cannot open /proc");
	
        //遍历
	while ((next = readdir(dir)) != NULL) {
		FILE *status;
		char filename[READ_BUF_SIZE];
		char buffer[READ_BUF_SIZE];
		char name[READ_BUF_SIZE];

		/* Must skip ".." since that is outside /proc */
		if (strcmp(next->d_name, "..") == 0)
			continue;

		/* If it isn't a number, we don't want it */
		if (!isdigit(*next->d_name))
			continue;
                //设置进程
		sprintf(filename, "/proc/%s/status", next->d_name);
		if (! (status = fopen(filename, "r")) ) {
			continue;
		}
		if (fgets(buffer, READ_BUF_SIZE-1, status) == NULL) {
			fclose(status);
			continue;
		}
		fclose(status);

                //得到进程id
		/* Buffer should contain a string like "Name:   binary_name" */
		sscanf(buffer, "%*s %s", name);
		if (strcmp(name, pidName) == 0) {
			pidList=realloc( pidList, sizeof(long) * (i+2));
			pidList[i++]=strtol(next->d_name, NULL, 0);
		}
	}

	if (pidList) {
		pidList[i]=0;
	}
	return NULL;
}

注：该代码在busybox0.6.3/libbb/find_pid_by_name.c

本文链接

busybox0.60.3源码学习开始

2012-02-21T00:56:00Z

busybox是一套unix-like系统下常用命令的精简实现合集，多用于嵌入式或其他
对内存敏感的应用。代码短小，基本功能实现完整，涉及面广，是学习unix-like下
编程的好资料。busybox0.60.3源码是官网能下载到的最早版本，其中的代码大部分
编写在1995年以前，里面附带的源码还没像今天这样复杂和完善，一般只实现了基本功能。

这样可以绕过很多不必要的旁枝末节，直接对实现原理进行学习。

未来，我会陆续把自己学习这套库时摘录出的代码和自己模仿编写的一些DEMO加上注释贴出来。

希望这份粗糙的代码合集能对您学习linux编程起到帮助。

本文链接

pygame做的贪吃蛇

2011-12-19T15:50:00Z

某天无聊，在阅览室一上午做的。
唉，对做2d小游戏还是挺有兴趣的，可惜数学实在不好，只能偶尔做做简单的小玩意～
一口气写的，没写注释…
你控制的蛇是s，周围都是b，撞上就lost了

看代码～贴到文件里就可以用。

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
'''
Created on 2011-11-25
author: shiweifu
  mail: shiweifu@126.com
'''
import struct
import sys
import os
import pygame
from random import randint


import pygame.sprite as Sprite
from pygame.locals import *

debug = True

FONT_NAME = "Arial"
FONT_SIZE = 25

SCREENRECT = Rect(0, 0, 640, 480)
RECT_LEN = 15

class Box:
    def __init__(self, x, y, f):
        self.x = x
        self.y = y
        self.flag = f
        if self.flag:
            self.surface = get_font_surface("b")
        else:
            self.surface = pygame.Surface((15,15))

    def __str__(self):
        return "x:%s y:%s" % (str(self.x),str(self.y))


class Link(object):
    
    def __init__(self, x, y, surface):
        self.x = x
        self.y = y
        self.surface = surface
    
    def __str__(self):
        return "x:%s y:%s" % (str(self.x),str(self.y))
        
class Player:
    def __init__(self,x,y):
        self.snake_body = []
        self.append(x,y)

    def append(self,x,y):
        l = Link(x,y,get_font_surface("s",(255,0,0)))        
        self.snake_body.append(l)

    def abc(self):
        print("test")
    
    def move_left(self):
        i = len(self.snake_body) - 1

        while i >= 1:
#            debug_output("i:"+str(i))
            self.snake_body[i].x = self.snake_body[i-1].x
            self.snake_body[i].y = self.snake_body[i-1].y
            i -= 1
        self.snake_body[0].x -= 1        


    def move_right(self):
        i = len(self.snake_body) - 1

        while i >= 1:
#            debug_output("i:"+str(i))
            self.snake_body[i].x = self.snake_body[i-1].x
            self.snake_body[i].y = self.snake_body[i-1].y
            i -= 1
        self.snake_body[0].x += 1

    def move_up(self):
        i = len(self.snake_body) - 1

        while i >= 1:
            self.snake_body[i].x = self.snake_body[i-1].x
            self.snake_body[i].y = self.snake_body[i-1].y
            i -= 1
        self.snake_body[0].y -= 1
    
    def move_down(self):
        i = len(self.snake_body) - 1

        while i >= 1:
            self.snake_body[i].x = self.snake_body[i-1].x
            self.snake_body[i].y = self.snake_body[i-1].y
            i -= 1
        self.snake_body[0].y += 1

    def move(self,target):
        if target == "up":
            self.move_up()
        if target == "down":
            self.move_down()
        if target == "left":
            self.move_left()
        if target == "right":
            self.move_right() 
                
def get_font_surface(s,color = (0,255,0),font_size=25):
    font = pygame.font.SysFont(FONT_NAME,font_size)
    #color = (0,255,0)
    backcolor = (0,0,0)
    r = font.render(s,True,color,backcolor)
    return r

def create_map(width,height,rect_len):
    y = 0
    map_pos = []
    snake_map = []
    flag =True
    while y < height:
        x = 0        
        flag = False
        while x < width:        
            if x < rect_len or x+rect_len >= width:
                flag = True
            elif y < rect_len or y+rect_len >= height:
                flag = True
            else:
                flag = False

            snake_map.append(Box(x/rect_len,y/rect_len,flag))
            x += 15
        y += 15

    return snake_map

def debug_output(s, f=sys.stdout):
    if debug == True:
        f.write("debug info: " + s + "\n")
        f.flush()

class Game:
    
    WIDTH = 640
    HEIGHT = 480
    BOX_SIZE = 15
    
    def __init__(self, caption="CooooolSnake"):
    
        pygame.init()
        pygame.display.set_caption(caption)
        self.screen = pygame.display.set_mode(SCREENRECT.size, 0, 32)    
        pygame.mouse.set_visible(0)
        self.background = pygame.Surface(SCREENRECT.size)
        
        self.map_size = (Game.WIDTH/15-1,Game.HEIGHT/15-1)
        
        self.snake_map = create_map(Game.WIDTH,Game.HEIGHT,self.BOX_SIZE)
        
        self.stages = []
        
        self.__crate_player__()

    def get_new_pos(self):
        done = False
        pos = None
        while not done:
            x = randint(2,self.map_size[0]-1)
            y = randint(2,self.map_size[1]-2)

            for link in self.player.snake_body:
                if x == link.x and y == link.y:
                    continue
            pos = (x,y)
            done = True

        return pos
               

    def __crate_player__(self):
        x = randint(2,self.map_size[0]-1)
        y = randint(2,self.map_size[1]-2)
        self.player = Player(x,y)

    def is_over(self):
        head = self.player.snake_body[0]
        i = 0
        
        for link in self.player.snake_body[1:]:
            if head.x == link.x and head.y == link.y:
                return True 
        
        for box in self.snake_map:
            if box.flag:
                if head.x == box.x and head.y == box.y:
                    return True
        return False
        
    def update_snake(self):
        
        for link in self.player.snake_body:
            self.background.blit(link.surface,(link.x*Game.BOX_SIZE,link.y*Game.BOX_SIZE))
            
    def update_map(self):
        for box in self.snake_map:
            self.background.blit(box.surface,(box.x*Game.BOX_SIZE,box.y*Game.BOX_SIZE))

    def add_stage(self):
        x,y = self.get_new_pos()
        s = get_font_surface("s",(255,0,0))
        l = Link(x,y,s)
        self.stages.append(l)
    
    def update_stage(self):
        head = self.player.snake_body[0]
        for stage in self.stages:
            if stage.x == head.x and stage.y == head.y:
                self.player.append(stage.x,stage.y)
                self.stages.remove(stage)
                
        for stage in self.stages:
            self.background.blit(stage.surface,(stage.x*Game.BOX_SIZE,stage.y*Game.BOX_SIZE))

    def refresh_background(self):
        self.background.fill((0,0,0))
        self.update_map()
        self.update_snake()
        
        self.update_stage()
        
        self.screen.blit(self.background, (0, 0))
        
    def over(self):        
        logo = get_font_surface("YOU ARE LOST!",(0,0,255),60)
        self.background.blit(logo,(100,200))

        clock = pygame.time.Clock()
        done = False

        count = 0

        while not done:
            clock.tick(10)
            count += 1
            if count == 5:
                done = True         
            self.screen.blit(self.background, (0, 0))
            pygame.display.flip()
    
    def loop(self):
        pygame.display.update()
        clock = pygame.time.Clock()
        target = ["up","down","left","right"][randint(0,3)]
        
        count = 0
        stage_time = randint(0,50)

        
        done = False
        while not done:
            for e in pygame.event.get():
                if e.type == pygame.KEYDOWN:
                    keystate = pygame.key.get_pressed()
                    if keystate[K_UP]:
                        if target != "down":                        
                            target = "up"

                    elif keystate[K_DOWN]:
                        if target != "up":                        
                            target = "down"

                    elif keystate[K_LEFT]:
                        if target != "right":                        
                            target = "left"

                    elif keystate[K_RIGHT]:
                        if target != "left":                        
                            target = "right"
                            
                if e.type == QUIT:
                    done = True
            self.player.move(target)
            if count == stage_time:
                self.add_stage()
                stage_time = randint(0,50)
                count = 0
 
            if self.is_over():
                done = True
                
            clock.tick(10)
            
            count += 1
            
            self.refresh_background()
            
            if done:
                self.over()
            
            pygame.display.flip()

if __name__ == '__main__':
    game = Game()
    game.loop()
    pass

本文链接

python中使用struct模块处理二进制数据

2011-07-31T09:01:00Z

假设这样个场景：

你有个文件，里面全是二进制方式存储的整型，你需要读取出来。于是你随手写出了这样的代码：

1 f = open("file","rb")
2 #读取个整型
3 data = f.read(4)
4 #读取完毕，关了文件
5 f.close()
6 #转换
7 num = int(data)

然后就会报错：

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: null byte in argument for int()

你查看下data：

data = '8\x00:\x00'

神马！！竟然是十六进制！！这货怎么转换？

你翻开《CookBook》里面扯了一堆不着边用不到的东西，就是没有这个问题。绝望之时，你在文档里看到了struct模块，文档里这么说：

This module performs conversions between Python values and C structs represented as Python strings. It uses format strings (explained below) as compact descriptions of the lay-out of the C structs and the intended conversion to/from Python values. This can be used in handling binary data stored in files or from network connections, among other sources.

没错，找的就是这货！

大概看了下，主要用到的是pack 函数和unpack函数。

pack:

struct.pack(fmt, v1, v2, ...)
Return a string containing the values v1, v2, ... packed according to the given format. The arguments must match the values required by the format exactly.

unpack:

struct.unpack(fmt, string)
Unpack the string (presumably packed by pack(fmt, ...)) according to the given format. The result is a tuple even if it contains exactly one item. The string must contain exactly the amount of data required by the format (len(string) must equal calcsize(fmt)).

下面还有个对应C语言中数据类型的表格：

Format	C Type	Python	Notes
`x`	pad byte	no value
`c`	`char`	string of length 1
`b`	`signed char`	integer
`B`	`unsigned char`	integer
`?`	`_Bool`	bool	(1)
`h`	`short`	integer
`H`	`unsigned short`	integer
`i`	`int`	integer
`I`	`unsigned int`	integer or long
`l`	`long`	integer
`L`	`unsigned long`	long
`q`	`long long`	long	(2)
`Q`	`unsigned long long`	long	(2)
`f`	`float`	float
`d`	`double`	float
`s`	`char[]`	string
`p`	`char[]`	string
`P`	`void *`	long

怎么样？大概看明白了吧？

你把代码改成了：

f = open("file","rb")
data = f.read(4)
#转换格式
num = struct.unpack("i",data)
f.close()
print(num)

这样就正常输出了吧？

嘿嘿，可以早点下班了。

如果还不明白，就接着看文档去，还有可以参考下这篇文章：

http://www.cnblogs.com/tonychopper/archive/2010/07/23/1783501.html

再次赞颂简洁万能的Python。

本文链接

使用PYGAME开发的坦克游戏[代码][思路]

2011-05-09T03:54:00Z

下载地址：

http://ishare.iask.sina.com.cn/f/15170274.html

带图的链接：

http://topic.csdn.net/u/20110506/11/00F9E224-3354-4908-BC96-8670769D93B7.html

坦克游戏设计思路

近期通过pygame设计了个坦克游戏，熟悉了下2D游戏的开发，总结一下吧，否则又忘记了。

游戏类似小时候红白机上的坦克大战，有几种坦克类型，主要区别在于：
攻击力
移动速度
四个方向的贴图（png）
发炮的声音
移动的声音
血量

因为比较喜欢玩手机，所以里面坦克的名字都是以用过的手机名命名的：
E71
N95
HD2
i780
touch
8900
.....

:-) 有点雷人

地图的设计：
666666666666666666666666666
600000000000000000000000006
600000000000000000000000006
600000300001000000000000006
600000300001000001345000006
600000322221000001000100006
600000311111000001222100006
600000300001000001000100006
600000300001000001111000006
644444444444444444444444006
600000000000000000000000006
600000111110000011111000006
600000100000000000200000006
600000111110000000200000006
600000000010000000200000006
600000000010000000200000006
600000111110000011211000006
600000000000000000000000006
600000000000000000000000006
666666666666666666666666666
这就是一张地图，看明白没？
0-6代表7种不一样的元素：
土
铁
树
水
冰
空白
城墙
每种都有不一样的贴图，读取地图文件时算好坐标对着贴就是了

而每关不一样的坦克信息，玩家控制的坦克，敌方控制的坦克，都是写在地图的配置文件里的：
{

"background" : null,

"backcolor" : [0,0,0],

"tank_info" :

{

"normal":1,

"hard":1

},

"player" : "e90",

"slash" : ["6.jpg","7.jpg"],

"sound" : "Mozart_Piano_Sonata_Amin3.ogg",

"mapfile":"map",

"size":[815,700]

}
配置文件是json格式，python 加载json格式非常简单，而且定义清晰明了

然后每关都压缩成个zip文件，加载时进行读取。

坦克的移动和碰撞检测直接用pygame中的sprite对象来做就可以了，都封装在里面了，看看文档就会用，我就不细说了。

开头动画就是简单的图片切换，加上渐变效果。

整个坦克游戏开发从三月中旬一直到四月中旬，从接触pygame到写完这个游戏，也都是在这个时间段，弄明白2D游戏大概是如何开发的了。坦克重做了三回，终于成形了，也不打算改了，再改估计又想重新做了。

猜猜用了多少行。。

在linux下用wc统计，抛去注释的代码，1600多行
python 强大有木有
pygame 给力有木有

先贴几张截图，再传下代码

总体来说，写的比较灵活，可配置性比较强，地图坦克什么的都可以自己改

windows下请放在英文路径下运行，没处理中文路径的问题，这个有空再改吧（估计。。。。改不了了）哪位朋友有空改好也可以发我份哦～

本文链接

一篇很好的讲/etc/inittab的文章[转]

2011-05-09T02:58:00Z

转自：http://www.chinaunix.net/jh/7/588122.html

/etc/inittab文件中每个登记项的结构都是一样的，共分为以冒号“：”分隔的4个字段。具体如下：
identifier : run_level : action : process
其中，各字段以及与其相关的说明如下：
identifier　　登记项标识符，最多为4个字符。用于惟一地标识/etc/inittab文件中的每一个登记项

run_level　　系统运行级，即执行登记项的init级别。用于指定相应的登记项适用于哪一个运行级，即在哪一个运行级中被处理。如果该字段为空，那么相应的登记项将适用于所有的运行级。在该字段中，可以同时指定一个或多个运行级，其中各运行级分别以数字0.1.2.3.4.5.6或字母 a、b、c表示，且无需对其进行分隔。

action　　　　动作关键字。用于指定init(M)命令或进程对相应进程（在“process”字段定义）所实施的动作。具体动作包括：
　　1、boot：只有在引导过程中，才执行该进程，但不等待该进程的结束；当该进程死亡时，也不重新启动该进程。
　　2、bootwait：只有在引导过程中，才执行该进程，并等待进程的结束：当该进程死亡时，也不重新启动该进程。实际上，只有在系统被引导后，并从单用户方式进入多用户方式时，这些登记项才被处理；如果系统的默认运行级设置为2（即多用户方式），那么这些登记项在系统引导后将马上被处理。
　　3、initdefault：指定系统的默认运行级。系统启动时，init将首先查找该登记项。如果存在init将据此决定系统最初要进入的运行级。具体来说，init将指定登记项“run_level"字段中的最大数字（即最高运行级）为当前系统的默认运行级；如果该字段为空，那么将其解释为“0123456”，并以“6”作为默认运行级。如果不存在该登记项，那么init将要求用户在系统启动时指定一个最初的运行级。
　　4、off：如果相应的进程正在运行，那么就发出一个警告信号，等待20秒后，再通过杀死信号强行终止该进程。如果相应的进程并不存在那么就忽略该登记项。
　　5、once：启动相应的进程，但不等待该进程结束便继续处理/etc/inittab文件中的下一个登记项；当该进程死亡时，init也不重新启动该进程。注意：在从一个运行级进入另一个运行级时，如果相应的进程仍然在运行，那么init就不重新启动该进程。
　　6、ondemand：与“respawn”的功能完全相同，但只用于运行级为a、b或c的登记项。
　　7、powerfail：只在init接收到电源失败信号时执行相应的进程，但不等待该进程结束。
　　8、powerwait：只在init接收到电源失败信号时执行相应的进程，并在继续对/etc/inittab文件进行任何处理前等待该进程结束。
　　9、respawn：如果相应的进程还不存在，那么init就启动该进程，同时不等待该进程的结束就继续扫描/etc/inittab文件；当该进程死亡时，init将重新启动该进程。如果相应的进程已经存在，那么init将忽略该登记项并继续扫描/etc/inittab文件。
　　10、sysinit：只有在启动或重新启动系统并首先进入单用户时，init才执行这些登记项。而在系统从运行级1－6进入单用户方式时，init并不执行这些登记项。"action”字段为“sysinit”的登记项在“run_level”字段不指定任何运行级。
　　11、wait：启动进程并等待其结束，然后再处理/etc/inittab文件中的下一个登记项。

本文链接

哲学家吃空心粉问题

2011-04-29T13:22:00Z

//      pe.c
//      哲学家吃空心粉的问题
//      Copyright 2011 shiweifu <shiweifu@126.com>
//

#define _REENTRANT
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include <semaphore.h>
#include <pthread.h>

#define STR_MAX 256

typedef struct philosophy {
    char name[STR_MAX];
    sem_t *left;
    sem_t *right;
    char is_stop;
} philosophy;

void *thread_function(void *arg);

int main(int argc, char **argv) {

    int i = 0;
    //五只悲剧的筷子
    sem_t sems[5];
    //五个NC哲学家
    philosophy philers[5];

    pthread_t threads[5];

    int res = 0;

    char tmp[255] = {0};

    for(; i < 5; i++) {
        philers[i].left = &sems[i];
        philers[i].right = &sems[i];

        if (i == 4) {
            philers[i].left = &sems[0];
        }
        philers[i].is_stop = 0;
        sprintf(tmp,"NC %d",i);
        strncpy(philers[i].name,tmp,255);
    }


    for(i = 0; i < 5; i++) {
        sem_init(&sems[i], 0, 10);

        res = pthread_create(&threads[i],NULL,thread_function,&philers[i]);
        if (res != 0) {
            perror("创建线程出错啦...");
        }
    }

    //给这群吃货吃20秒
    sleep(20);

    for(i = 0; i < 5; i++) {
        philers[i].is_stop = 1;
        pthread_join(threads[i],NULL);

    }
    for(i = 0; i < 5; i++) {
        sem_destroy(&sems[i]);
    }

    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    philosophy *p = arg;

    while (1) {
        if (sem_trywait(p->left) == 0) {
            if (sem_trywait(p->right) == 0) {
                printf("红烧翅膀真好吃,我是%s\n",p->name);
                sem_post(p->left);
                sem_post(p->right);
                sleep(1);

            } else {
                sem_post(p->left);
            }
        }
        if (p->is_stop == 1) {
            break;
        }
    }
    pthread_exit(NULL);
}

本文链接

《代码整洁之道》笔记之函数

2011-04-16T06:15:00Z

作者给出了几个评判函数好坏的标准：

短小
作者给的函数合理长度是小于15行，目标是每个函数都一目了然，每个函数都会把你依次带到下一个函数中去。
if、else、while语句等其中的代码快应该只有一行。该行大抵应该是一个函数的调用语句。这样不但能保持函数短小，而且因为块内调用的函数拥有较具说明行的名称，从而增加了文档上的价值函数的缩进曾不该多余两层，这样函数更容易理解。
只做一件事
从我接触编程开始，这条规则反反复复听了很多遍：函数应该做一件事，做好这件事，只做这一件事。问题是那件事是什么，函数到底做了一件事还是做了几件事。比如一个名为write_text_to_file(char *filename)的函数，它在其中会打开一个文件，写入文本到这个文件，然后关闭文件流。这算几件事？
作者如是说：如果函数只是做了该函数名下同一抽象层上的步骤，则函数还是只做了一件事。
这样就好分辨的多。
我的理解是：write_text_to_file函数里面调用的几个函数，fopen、fwrite、fclose都是同一抽象层的，这算是只做了一件事，如果调用了更上层的delete_file函数，这样就算两件事了。不知道这样理解有没错。
switch语句的正确使用
学习过《windows程序设计》的人肯定都写过这样的代码：
switch(uMsg)
{
case WM_DESTORY:
//xxxxxxx
break;
case WM_CREATE:
//xxxxxxx
break;
}
在其中对WINDOWS窗口的消息进行判断，然后处理。没什么封装的话，就是直接写在case和break之间，一大坨。有了点封装，会把要执行的代码写到独立的函数里，在收到消息时进行调用。还可以弄个消息表，这样只需要在for循环中就完成了对应消息的处理，除非是写框架时才会这么做，一般都没这么多消息要处理。有了面向对象还可以利用继承和多态机制来简化代码，参看：http://www.cnblogs.com/shiweifu/archive/2011/04/12/2014136.html
作者这么说switch：对于switch语句，我的规矩是如果只出现一次，用于创建多态对象，而且隐藏在某个继承关系中，在系统其他部分看不到，就能容忍
对于switch他也没说绝对，后来又补充说：要就事论事
函数的名称
函数名别怕长，命名方式要在模块中进行统一。做到让看代码的人自己可以通过函数名就能大概弄明白函数是干嘛的，这样就到位了，也就是他最后说的“深合己意”
函数的参数
书中说最理想的函数参数是没有参数，其次是一个，再次是两个，如果有了三个以上的参数，就说明这个函数需要传递对象作为参数了。我觉得这个更多适合的是面向对象编程，像面向过程编程，有些时候没参数活儿没法干，难道哪个文件都弄一大堆静态函数，再弄静态变量放在文件中？我不怎么习惯这样。等我看完lua的源码再谈这个吧

然后是一些建议：

使用异常替代返回错误码
相对与返回错误码，这是更好的做法。有异常就用异常吧
如何正确编写异常处理
对异常没有太多经验，只停留在会用的层面，就不多说了
避免重复
一般第一遍编写代码，会有不少冗余重复的代码。再写一遍就是了。
如何编写出优秀的代码
以前代码写的又烂又难看，设计的又丑陋（现在设计也很糟糕），我向一位有经验的程序员请教，他说你重新再写一遍就好了，多写几次，总能写好的。后来我就按照他的话重新写了遍当时的代码，果然好看多了。后来每当遇到不满意的代码，都会重新写一下，慢慢的就有了进步。现在有时重写一次就能写出满意的代码，有时得写三次。这与对所使用的技术是否了解有关系。对所运用的技术越熟悉，一次性写好的几率就越高。书中对写出好的代码的建议也是重复编写，当然，加上这些规则对自己的代码进行审查，会写的更好。

本文链接

使用面向对象概念优化条件判断语句的一个小应用

2011-04-12T13:45:00Z

以前就知道可以通过面向对象来优化条件语句，甚至看到过说面向对象概念可以完全替代条件语句，新想那得弄多少类啊，觉得太累了就没细研究，而且那时是在用C语言，没有面向对象的语法支持。

今天写代码时候，写出了这样的代码：

   if isinstance(b,Iron):#铁
                    if self._size == Bullet.BIG:
                        b.health -= 1
                    elif self._size == Bullet.LARGE:
                        b.health -= 3
                    elif self._size == Bullet.HUGE:
                        b.health -= 5

                if isinstance(b,Soil):#土
                    if self._size == Bullet.SMALL:
                        b.health -= 1
                    elif self._size == Bullet.BIG:
                        b.health -= 5

又臭又长又丑，看了下，也没什么好办法改，条件总是要判断的呀，铁和转块受到攻击时效果不一样，受到不同大小子弹的攻击，效果不一样。
突然灵光一闪，想起了还有继承这么回事。三下五除二，写下了这样的代码：

class Floor(pygame.sprite.Sprite):

"""

Stage的组成部分。Stage向Game对象传递进来的pygame.sprite.Group对象引用进行填充。

这是个基类，不同种类的格子通过这个来继承。

"""

image = None

def _on_small_bullet(self):

"""收到小子弹攻击"""

raise TypeError,"not implement"

def _on_big_bullet(self):

"""收到大子弹攻击"""

raise TypeError,"not implement"

def _on_large_bullet(self):

"""收到巨大子弹攻击"""

raise TypeError,"not implement"

def _on_huge_bullet(self):

"""收到炮弹攻击"""

raise TypeError,"not implement"

class Soil(Floor):

"""土"""

def __init__(self,pos):

Floor.__init__(self)

self.pos = pos

self.health = 5

self.image = Soil.image

self.rect = self.image.get_rect(topleft = pos)

# self.rect = Rect(self.rect)

pass

def _on_small_bullet(self):

"""收到小子弹攻击"""

self.health -= 1

def _on_big_bullet(self):

"""收到大子弹攻击"""

self.health -= 2

def _on_large_bullet(self):

"""收到巨大子弹攻击"""

self.health -= 3

def _on_huge_bullet(self):

"""收到炮弹攻击"""

self.health -= 5

啊哈，搞定了，而且代码好看很多。
所有砖块元素都继承自Floor，这样就不需要判断类型了。

if self._size == Bullet.SMALL:

b._on_small_bullet()

elif self._size == Bullet.BIG:

b._on_big_bullet()

elif self._size == Bullet.LARGE:

b._on_large_bullet()

elif self._size == Bullet.HUGE:

b._on_huge_bullet()

代码好看了很多。
还是得多写代码啊。。

本文链接

python生成文件树的代码

2011-04-06T02:21:00Z

#!/usr/bin/python

from os.path import basename, isdir
from os import listdir

def traverse(path, depth=0):
    prefix = depth* '| ' + '|_'
    if(isdir(path)):
        print prefix, basename(path)
        for item in listdir(path):
            traverse(path+'/'+item, depth+1)
    else:
        print prefix, basename(path)

if __name__ == '__main__':
    traverse('./')

本文链接