用Python快速开发CAM程序(实战版)

来源：互联网发布：上海师范大学网络续费编辑：程序博客网时间：2024/05/26 14:09

这一节将介绍函数，模块的调用，类，面向对象,并结合前面的知识写一个CAM程序

一：函数
函数用def来声明，可以分为有参与无参函数,直接说个实例就明白了：

#-*- encoding: utf-8 -*-

'''

Created on 2014年5月23日

@author: Administrator

'''

def method():

print '这一个无参的函数'

def method_x(x):

print '这一个有参的函数 ,传入的形参 = ',x

def method_y(x):

x = 5* x

return x

method()

method_x(22)

print '返回的变量是:',method_y(20)

结果如下:

这一个无参的函数

这一个有参的函数 ,传入的形参 = 22

返回的变量是: 100
二：模块的调用
Python中的程序文件以.py来命名后缀,每个程序都可以称为模块，我们来写两个模块
第一个模块:

#!/usr/bin/python

#-*- encoding: utf-8 -*-

hm = 8

def whe(x):

print '你调用了ky这个模块中的方法了'

x = 5 * x

return x

第二个模块:

#!/usr/bin/python

#-*- encoding: utf-8 -*-
'调用一个模块用import'

import ky

x = ky.whe(5)

print '调用了ky的模块后，返回的变量为',x

y = ky.hm * 20

print '调用了ky的模块中的变量相乘后,y =',y

结果如下：

你调用了ky这个模块中的方法了

调用了ky的模块后，返回的变量为 25

调用了ky的模块中的变量相乘后,y = 160

就调用模块而言，这比Java,Perl要好用的多，只要引入就行了，然后就直接用，多好。

二：类与面向对象
类还是用class来声明， Python中的self等价于C++中的self指针和Java、C#中的this.

在一个函数中最少要有一个形参self,如def Havex(self),以下介绍类的成员变量，私有变量，成员方法，私有方法，

类方法，静态方法,与内部类

#-*- encoding: utf-8 -*-

'''

Created on 2014年5月23日

@author: Administrator

'''

'创建一个类'

class Myclass:

'成员变量'

xu = 12

name='dlh'

__namekk = '类的私有属性shuxing'

#构造函数

def __init__(self,n=20000):

self.xu=n

#自动执行,析构函数，主要用来关掉一些连接，如数据库连接，文件的打开

def __del__(self):

#p.close()

print '释放资源,close'

def Havex(self):

print self.__namekk

return 'fff'

def fun1(self):

#方法中的局部变量

self.tow = 'iiiiiiiii'

print self.name

print '我是公有方法'

self.__fun2() #调用私有方法

'定义静态方法要加以下这句@staticmethod'

@staticmethod

def staticxx():

'静态方法不用加self'

print Myclass.name

print '我是静态方法static'

'私有的，要定义两个下划线_ _'

def __fun2(self):

print self.name

print '我是私有方法'

'定义类方法要加以下这句@classmethod'

@classmethod

def classfun3(self):

print self.name

print '我是类方法class'

def xik(self):

self.fun1()

print self.fun1(),'我开始了+++++++++'

class Leibu_class():

var1 = '我是内部类,ok,ok'

def main():

'创建一个对象,并传入一参数'

kj = Myclass(50000000)

print kj.xu

print kj.Havex()

kj.fun1()

Myclass.classfun3()

Myclass.staticxx()

'创建内部类的对象'

lei = kj.Leibu_class

lei2 = Myclass.Leibu_class()

print lei.var1

print lei2.var1,'222'

#print kj.__namekk

#print kj.fun1()

print kj.tow

kj.xik()

if __name__ == '__main__':

main()

结果如下:

50000000

类的私有属性shuxing

fff

dlh

我是公有方法

dlh

我是私有方法

dlh

我是类方法class

dlh

我是静态方法static

我是内部类,ok,ok

我是内部类,ok,ok 222

iiiiiiiii

dlh

我是公有方法

dlh

我是私有方法

dlh

我是公有方法

dlh

我是私有方法

None 我开始了+++++++++

释放资源,close

介绍了这么多，已经足够用来编写CAM程序了：

取出这个料号是多少层，并取出层相关的属性，然后，要gts增加一个PAD

#!/usr/bin/python

#Import Standard Modules

import os, string, sys, re, time

#Import Genesis specific resources

sys.path.append('/genesis/e92/all/python')

import genClasses

class Copy():

def __init__(self,layer,job,info):

self.layer = layer

self.job = job

self.info = info

print 'kkkkkkk'

self.copy_other_layer()

self.addLayers()

#self.config()

def copy_other_layer(self):

print 'kkkkkkk ',self.layer,self.job

self.job.PAUSE('scripts copy '+self.layer+' layer')

self.job.COM("units,type=mm");

self.job.COM("display_layer,name="+self.layer+",display=yes,number=1");

self.job.COM("work_layer,name="+self.layer);

self.job.COM("add_pad,attributes=no,x=80.8383775,y=57.2963275,symbol=r900,"+

"polarity=positive,angle=0,mirror=no,nx=1,ny=1,dx=0,dy=0,xscale=1,"+

"yscale=1");

self.job.COM("display_layer,name="+self.layer+",display=no,number=1");

def addLayers(self):

self.layers = []

self.context_x = []

self.polarity_x = []

self.layer_type_x = []

self.side_x = []

for x in xrange(len(self.info['gROWname'])):

if not len(self.info['gROWname'][x]): break

name = self.info['gROWname'][x]

context = self.info['gROWcontext'][x]

polarity = self.info['gROWpolarity'][x]

layer_type = self.info['gROWlayer_type'][x]

drl_start = self.info['gROWdrl_start'][x]

drl_end = self.info['gROWdrl_end'][x]

side = self.info['gROWside'][x]

self.layers.append(name)

self.context_x.append(context)

self.polarity_x.append(polarity)

self.layer_type_x.append(layer_type)

self.side_x.append(side)

#print self.layers[x]

return self.layers

def Total_Info():

Have_Layerx = []

Have_Layer = Tmpx.addLayers()

print '- - - - - - - - - - - - - -'

print jobName+' Have ',len(Have_Layer),' layer,List:'

for tmp in xrange(len(Have_Layer)):

Have_Layerx.append(Have_Layer[tmp])

print Have_Layer[tmp]

print Have_Layer

print '++++++- - - - - - - - - - - - - -',len(Have_Layerx)

for tmp in xrange(len(Have_Layerx)):

print Have_Layerx[tmp]

print Have_Layerx

print len(Have_Layerx)

print 'End bye'

def Other_info(Copy):

Have_Layer = Tmpx.addLayers()

print Have_Layer

Have_Layer_Type_= Copy.layer_type_x

print Have_Layer_Type_

Layer_context = Tmpx.context_x

print Layer_context

Layer_Side = Tmpx.side_x

print Layer_Side

Have_polarity = Copy.polarity_x

print Have_polarity

if __name__ == '__main__':

import genClasses

if os.environ.has_key('JOB'):

jobName = os.environ['JOB']

step = os.environ['STEP']

else:

print 'Open a job first...'

sys.exit(1)

print 'JOB =',jobName,'Step = ',step

# Call layer selector

job = genClasses.Job(jobName)

Tmpx = Copy('gts',job,job.matrix.info)

Total_Info()

Other_info(Tmpx)

0 0