下载文档原格式
当然不可以在前处理里面写*node之类的话。
但是你可以在前处理命令行里用python语言建立节点，等价于一个GUI操作，实际上每个GUI操作都是在执行一个对应的PYTHON语句，记录在*.py文件里（与ANSYS的*.log文件类似）。
APDL与input文件是完全不通的两个概念。
老的有限元程序都是只有一个输入数据文件，复杂模型写此文件十分麻烦，因此有了图形前处理。
前处理的用处就是帮助你生成这个input 文件而已。
ANSYS比较另类，发明了一个APDL前处理语言。
用它编程，完成GUI操作，对于熟练用户来说比在GUI上点鼠标选菜单又快了很多（此思路已经被许多软件所模范，比如midas的MP什么语言，只是功能差劲多了，起劲还没有模仿的与ANSYS一样好的）。
ANSYS的另类之处在于，它的输入文件哪里去了呢？没了？？ABAQUS则走上了另一条道路，它保留了输入文件，input file。
它有前处理编程语言吗？有的，不过它没有如ANSYS那样开发一种新语言APDL，而是直接采用了PYTHON这种面向对象的解释性语言。
它的前处理可以理解为是pyhon语言的解释器。
python是解释性语言，正如APDL也是解释性语言一样。
（不需要编译，在相关环境下直接解释执行的）。
它与ANSYS的APDL的区别：APDL可以理解为fortran77式的旧式计算机语言，PYTHON 是面向对象的OOP语言。
python是开放的，ABAQUS用它做了一堆类库，你只有调入这些类库才可以使用这些类的函数。
想想C++语言吧，你要建立一个节点，你得先建立一个节点对象object，再使用此对象的method。
你要对你的体作操作，你要知道你在操作哪个对象才行。
下面是一个PY例子：from abaqus import * 调入相应类库，from sketch import *from part import *myModel = mdb.Model(name='Model A') 建立一个model对象mySketch = myModel.Sketch(name='Sketch A', sheetSize=200.0)xyCoordsInner = ((-5 , 20), (5, 20), (15, 0),(-15, 0), (-5, 20))xyCoordsOuter = ((-10, 30), (10, 30), (40, -30),(30, -30), (20, -10), (-20, -10),(-30, -30), (-40, -30), (-10, 30))for i in range(len(xyCoordsInner)-1): 建立线（sketch对象的一种method）mySketch.Line(point1=xyCoordsInner,point2=xyCoordsInner[i+1])for i in range(len(xyCoordsOuter)-1):mySketch.Line(point1=xyCoordsOuter,point2=xyCoordsOuter[i+1])myPart = myModel.Part(name='Part A', dimensionality=THREE_D, type=DEFORMABLE_BODY)myPart.BaseSolidExtrude(sketch=mySketch, depth=20.0)。
Abaqus里应用Python的一些技巧例如：cell4 = mdb.models['block'].parts['crankcase'].cells[4]，要把part模块中编号为4的体赋值给cell4，就需通过路径mdb→models→part→cells（4号体属性），其中'block'、'crankcase'、分别是model和part的名字。
在草图Sketch中画线：s = mdb.models[' block '].ConstrainedSketch(name='grid',sheetSize=3.0)s.Line(point1=(-1.275, 0.0), point2=(-1.125, 0.0))s.Line(point1=(1.125, 0.0), point2=(1.275, 0.0))执行任何一条命令都必须按照结构树的格式进行操作。
我们所看到的python脚本繁杂的语句就是这样形成的。
这样大量的命令不能在短时间内掌握，我们只需要根据自己的需要边建立模型边学习就可以了。
a = mdb.models['Model-1'].rootAssemblys = a.instances['Mount-1'].edgesside1Edges = s.findAt(((0.0475, 0.0, 0.0), ))以上三行与下面的句子是等同的，即把findat找到的edges赋值给side1Edges。
分开来写简单明了，大大缩短了语句的长度。
side1Edges = mdb.models['Model-1'].rootAssembly. instances['Mount-1'].edges. findAt(((0.0475, 0.0, 0.0), ))a.Surface(side1Edges=side1Edges, name='Bottom')，这行语句设置side1Edges所对应的edge为名称'Bottom'的surface的set。
Abaqus是一款强大的工程仿真软件，而Python则是一种高效、易学的编程语言。
通过Python 对Abaqus进行二次开发，可以大大提高仿真效率。
以下是Abaqus Python二次开发入门案例的步骤：
安装Abaqus和Python
首先需要安装Abaqus和Python。
Abaqus可以从官网下载安装包，而Python则可以从官网下载安装。
了解Abaqus Python API
在Abaqus中，Python API是用来编写脚本和插件的工具。
通过Python API，可以实现对Abaqus 的二次开发。
需要了解Abaqus Python API的基本知识，包括模块、工具、数据对象等等。
编写Python脚本
根据需求，编写Python脚本来实现特定的功能。
例如，可以编写一个脚本，用来自动生成模型、执行仿真、结果后处理等等。
在编写脚本的过程中，需要使用Abaqus Python API提供的函数和方法。
运行Python脚本
将编写的Python脚本保存，并在Abaqus中运行。
在运行脚本之前，需要确保Abaqus已经启动，并且已经连接到了Python解释器。
调试和优化
在运行脚本的过程中，可能会遇到各种问题，需要进行调试和优化。
需要对Python脚本进行逐步调试，找到问题所在，并且优化代码，提高仿真效率。
以上是Abaqus Python二次开发入门案例的基本步骤。
在开发过程中，需要不断学习和积累经验，才能够更好地利用Python API实现对Abaqus的二次开发。
abaqus python 曲线函数Abaqus Python 曲线函数1. 简介Abaqus 是一款强大的有限元分析软件，Python 是一种广泛使用的编程语言。
在Abaqus 中，可以使用Python 编写脚本来完成各种任务。
其中，曲线函数是一种常用的功能，可以用于定义材料特性、加载条件等。
2. 曲线函数的基本概念曲线函数是一种描述变量与时间（或其他自变量）之间关系的数学函数。
在 Abaqus 中，曲线函数通常用于描述材料特性、加载条件等。
曲线函数由若干个数据点组成，每个数据点包括自变量和因变量两个值。
通过这些数据点可以确定一个连续的曲线，从而实现对变量与时间之间关系的描述。
3. 创建曲线函数在 Abaqus 中创建曲线函数需要使用 Python 脚本。
下面是一个简单的例子：```pythonfrom abaqus import *from abaqusConstants import *# 创建一个空白曲线函数对象myCurve = Curve()# 添加数据点myCurve.addDataPoint(0, 0)myCurve.addDataPoint(1, 1)myCurve.addDataPoint(2, 4)myCurve.addDataPoint(3, 9)# 打印所有数据点for i in range(myCurve.numDataPoints):print(myCurve.getDataPoint(i))```这段代码创建了一个空白的曲线函数对象，并添加了四个数据点。
最后通过循环打印了所有数据点的值。
4. 曲线函数的属性曲线函数有许多属性可以设置，包括名称、单位、描述等。
下面是一个例子：```pythonfrom abaqus import *from abaqusConstants import *# 创建一个空白曲线函数对象myCurve = Curve()# 设置名称、单位和描述myCurve.setName('MyCurve')myCurve.setUnits('mm', 'MPa')myCurve.setDescription('Stress-strain curve')# 添加数据点myCurve.addDataPoint(0, 0)myCurve.addDataPoint(1, 1)myCurve.addDataPoint(2, 4)myCurve.addDataPoint(3, 9)# 打印所有数据点和属性值print('Name:', )print('Units:', myCurve.xUnits, myCurve.yUnits) print('Description:', myCurve.description)for i in range(myCurve.numDataPoints):print(myCurve.getDataPoint(i))```这段代码创建了一个空白的曲线函数对象，并设置了名称、单位和描述。
abaqus python 集合布尔运算Abaqus是一种常用的有限元分析软件，在该软件中，用户可以使用Python进行脚本编写，以便实现更高效、更灵活的模拟分析。
在Python脚本中，我们可以利用集合布尔运算操作实现更多的功能，本文将对这一方面进行详细介绍。
1. 集合概述在Python语言中，集合是一种无序、可变的数据类型，其中每个元素唯一且不可重复。
集合可以通过花括号{}或set()函数来创建。
在Abaqus中，集合通常是由节点和单元构成的，集合中的节点或单元也可以通过节点或单元编号、坐标或其它属性来确定。
2. 集合布尔运算集合布尔运算有并集（union）、交集（intersection）、差集（difference）和对称差集（symmetric difference）四种，这些运算都可以用于集合之间的操作。
并集（union）：将两个集合中的所有元素合并在一起形成一个新集合。
交集（intersection）：找到两个集合中共有的元素，形成一个新集合。
差集（difference）：找到第一个集合中不在第二个集合中的元素，形成一个新集合。
对称差集（symmetric difference）：找到两个集合中不共有的元素，形成一个新集合。
其中，集合之间的交集运算非常常见，尤其是在Abaqus中。
3. Abaqus中的集合布尔运算在Abaqus中，集合布尔运算可以直接应用于节点集和单元集，以实现更高级的分析预处理，如：3.1. 创建节点集通过以下Python脚本创建节点集nodeset1和nodeset2：nodeset1 = mdb.models["Model-1"].parts["Part-1"].nodes.getByBoundingBox(x1=0.0, y1=0.0, z1=0.0, x2=100.0, y2=100.0, z2=100.0) nodeset2 =mdb.models["Model-1"].parts["Part-1"].nodes.getByBoundingBox(x1=50.0, y1=50.0,z1=50.0, x2=150.0, y2=150.0, z2=150.0)其中nodeset1和nodeset2根据节点坐标的范围来定义。
Python语言在ABAQUS中的应用采用python脚本语言二次开发ABAQUS，通过开发python脚本程序处理ABAQUS重复工作，提高了工作效率。
标签Python；ABAQUS；交换输入；函数引言ABAQUS是大型通用的有限元分析软件，可以模拟绝大部分工程材料的线性和非线性行为，获得了广大用户的认可，在建筑结构分析领域应用广泛。
Python是一种面向对象的脚本语言，，该语言已经诞生20余年，它的简洁性和易用性使程序的开发过程变得简单，特别适用于快速应用开发。
在此介绍一下编写脚本快速建模。
编写Python脚本快速建立模型是ABAQUS高级用户经常使用的功能之一。
例如，在Abaqus/CAE中建模时需要反复输入各种参数和设置多个对话框，编写脚本只需要几条语句就可以实现。
如果经常建立相同或类似模型，还可以编写独立的模块，还可以编写脚本创建材料库，运行Python脚本后Material Manager 将自动出现定义的材料。
在此介绍3种最常用的快速建立模型的方法，包括交互式输入、创建材料库。
1.交互式输入交互式输入直接指定模型参数，而无需在Abaqus/CAE下选择多个菜单、多个按钮，可以节省许多建模时间。
Abaqus脚本接口提供3种交互式输入函数，分别是：getInput（）函数、getInputs（）函数和getWarningReply （）函数，详细介绍参见Abaqus 6.10帮助手册《Abaqus Scripting User’s Manual》第6.7节“Prompting the user for input”和<《Abaqus Scripting Reference Manual》第49.5节“User input commands”。
GetInput（）函数脚本getInput.py将调用getInput（）函数自定义输入参数，开平方根运算后输出计算结果。
程序测试代码如下：from abaqus import *from math import sqrtinput=getInput（’please enter a number ‘，’9’）number=float（input）print sqrt（number）GetInputs（）函数脚本getInputs.py将调用getInputs（）函数自定义输入并输出数据信息，代码如下：from abaqus import *x=getInputs（（（’please enter the first number ‘，’2’），（’please enter the second number’，’5’），（’please enter the third number’，’8’）））print xGetWarningReply （）函数脚本getWarningReply.py将调用get Warning Reply （）函数来创建警告对话框。
Abaqus的Python脚本命令基本概念Abaqus的Python脚本命令基本概念1.访问对象(access)对象Abaqus通过Abaqus/CAE启动时，会⾃动导⼊所有的模块，⽆需使⽤import语句，注意，有唯⼀⼀个符号常数模块没有导⼊，应该使⽤下列语句：from abaqusConstants import*下列语句将访问Material对象：Import materialmdb.models[name].materials[name] !访问材料mdb.models[name].materials[name].elastic.type !访问材料类型下列语句访问HistoryRegion对象：Import odbAccessSession.odbs[name].steps[name].historyRegions[name] !访问Region对象Session.odbs[name].steps[name].frames[i].fieldOutputs[name] !访问结果2路径(PATH)创建对象的⽅法称为构造函数(Constructor)，例如：Mdb.models[‘Model-1’].Part(name=’Part-1’,dimensionality=THREE_D,type=DEFORMABLE_BODY)上⾯这句长语句⽤构造函数Part创建⼀个三维实体对象Part-1，构造函数Part的路径即为：mdb.models[‘Model-1’l.parts[‘Part-1’]构造函数的⾸字母为⼤写。
3参数(arguments)构造函数⼀般都需要提供参数，包括必选参数和可选参数。
例如：session.Viewport(‘myViewport’,(10,10),100,50)后⾯括号⾥⾯的内容是需要定义的参数4返回值(return value)所有的命令都有返回值，不同的命令有不同的返回值，构造函数的返回值是构造的对象，可以将返回值赋值给新的变量。
在abaqus中使用python实现的功能（一、二）By lxm9977(lxm200501@)功能一：实行提交多个job的功能。
对象：Job object使用：在源文件开始写上import job，源程序用mdb.jobs[name] 使用名字为name的job对象。
建立一个job对象的方法：●利用已有的inp文件中建立job：mdb.JobFromInputFile（）●利用已有的cae中建立job： Job(...)建议用第一种方法。
设定参数的方法：✓利用第一种方法建立job的时候，可以设定很多的参数，比如type，queue，userSubroutine等。
格式：mdb.JobFromInputFile（name＝，inputFile＝，type＝，queue ＝，userSubroutine＝，…….）。
✓也可以先建立一个job，然后利用job对象的setValues来设定参数，格式：job.setValues(type＝，queue＝，userSubroutine＝，…….)。
一个简单的例子：文件：job.pyfrom abaqusConstants import *import jobmdb.JobFromInputFile(name='job-1-1',inputFileName='Job-1.inp')＃基于inp文件Job-1.inp建立名称为job-1-1的jobmdb.jobs['job-1-1'].setValues(waitMinutes=1)＃设定参数mdb.jobs['job-1-1'].submit()＃提交任务mdb.jobs['job-1-1'].waitForCompletion()运行：在cmd下面运行：Abaqus cae nogui=job.py如果是多个job，同样道理了，不多说了。
文章标题：探索Abaqus中的刚体反作用力提取方法在有限元分析中，Abaqus是一款广泛应用的工程仿真软件，可以进行结构、热力、流体等多领域的仿真分析。
在实际工程中，我们经常需要了解结构中各部件的受力情况，其中刚体反作用力是一个重要的参数。
本文将以Python语言作为工具，来探讨如何在Abaqus中提取刚体反作用力，并对提取方法进行全面深入的分析和讨论。
一、了解刚体反作用力的概念在进行结构分析时，刚体反作用力是指在结构中各个刚体之间相互作用的力，它是产生位移、变形和应力的根源。
刚体反作用力的提取可以帮助工程师分析结构的受力情况，为优化设计和改进结构提供重要依据。
二、Abaqus中刚体反作用力的提取方法在Abaqus中，我们可以通过Python脚本来实现刚体反作用力的提取。
我们需要使用Abaqus提供的Python接口来与软件进行交互，接着通过编写特定的Python脚本来实现刚体反作用力的提取。
在Python脚本中，我们可以使用Abaqus提供的API函数来获取所需的数据，进而实现刚体反作用力的提取。
三、Python脚本实现刚体反作用力的提取在编写Python脚本时，首先需要导入Abaqus提供的Python接口模块，并初始化与Abaqus软件的连接。
我们需要指定所要提取的刚体，并设置相应的参数。
通过调用Abaqus提供的API函数，我们可以获取刚体反作用力的数据，并将其保存或输出到指定的文件中。
我们可以通过对数据进行分析和处理，来获取所需的刚体反作用力信息。
四、讨论刚体反作用力的提取精度和有效性在实际工程中，刚体反作用力的提取精度对分析结果的准确性和可靠性有着重要影响。
在编写Python脚本时，我们需要考虑如何提高提取精度和有效性。
可以采用增加采样点、优化计算算法等方法来提高提取的准确性，同时也需要考虑计算效率和稳定性的问题。
五、个人观点与总结通过对Abaqus中刚体反作用力提取方法的探讨，我认为Python脚本在实现刚体反作用力的提取方面具有很大的优势。
Abaqus Python 曲线函数一、引言在工程领域，使用数值模拟软件进行仿真分析是非常常见的工作。
Abaqus是一款广泛应用于有限元分析的软件，它提供了Python编程接口，使得用户可以使用Python自定义各种功能。
本文将介绍Abaqus Python中的曲线函数相关内容，包括曲线的创建和操作等。
二、Abaqus Python基础在使用Abaqus Python编程之前，首先需要了解一些基础知识。
Abaqus Python是一种脚本语言，它可以通过Abaqus命令窗口或者Python脚本文件进行运行。
在Abaqus Python中，可以使用import语句导入相关的模块，例如导入曲线模块可以使用以下语句：from abaqus import *from abaqusConstants import *导入模块后，可以使用该模块提供的函数和类进行编程。
三、曲线函数的创建在Abaqus Python中，可以使用Curve函数创建曲线对象。
Curve函数的基本语法如下：curveObject = Abaqus.Curve(expression=expression, range=[start, end], method=' LINEAR', ncps=number_of_control_points)其中，expression表示曲线的表达式，可以是一个数学公式或者用户自定义的函数。
range表示曲线的范围，即起始点和终止点的坐标值。
method表示曲线的拟合方法，常见的方法包括线性拟合和样条拟合等。
ncps表示曲线的控制点数目。
四、曲线函数的操作1. 曲线点的获取使用Abaqus Python可以轻松获取曲线上的任意点的坐标值。
可以使用函数interpolate在曲线上插值计算某个点的坐标值，效果如下：coordinate = curveObject.interpolate(u=u)其中，u表示曲线上的参数值，coordinate表示该参数值对应的坐标值。
abaqus的python手册全文共四篇示例，供读者参考第一篇示例：一、Abaqus中Python的应用1. 调用Abaqus APIAbaqus提供了一个丰富的API，通过Python可以轻松地调用这些API来完成各种任务。
比如创建模型、定义边界条件、设置分析参数等。
用户可以通过编写Python脚本来实现自定义的分析过程。
2. 扩展Abaqus功能通过编写Python脚本，用户可以扩展Abaqus的功能，实现一些Abaqus原生功能不支持的功能。
比如可以编写一个脚本来实现特定的后处理功能，或者实现一些自定义的材料模型等。
3. 批量处理任务在实际工程中，通常需要进行大量的有限元分析任务。
通过编写Python脚本，可以实现批量处理任务，提高工作效率。
比如可以编写一个循环来处理多个模型，或者实现并行计算等。
4. 与其他软件集成Python是一种通用的编程语言，可以方便地与其他软件集成。
比如可以通过Python脚本实现Abaqus和CAD软件（比如SolidWorks）的数据交互，或者实现Abaqus和MATLAB的联合分析等。
1. 环境搭建首先需要在电脑上安装Abaqus和Python环境。
Abaqus支持Python2.7和Python3.6及以上版本。
安装完Abaqus后，需要在Abaqus命令窗口中输入“abaqus cae nogui=python”命令进入Python环境。
2. Python基础知识在使用Abaqus的Python API之前，需要掌握一些基本的Python知识。
比如变量、循环、条件语句等。
可以通过在线教程或书籍学习Python的基础知识。
下面我们来看一个简单的Python脚本示例，实现一个简单的有限元分析任务：```pythonfrom abaqus import *from abaqusConstants import *# 创建一个模型myModel = mdb.Model(name='ExampleModel')myAssembly = myModel.rootAssemblymyPart = myModel.Part(name='Part-1',dimensionality=THREE_D, type=DEFORMABLE_BODY)# 创建一个立方体myPart.Cube(center=(0, 0, 0), size=10.0)# 后处理odb = session.odbs['ExampleJob.odb']session.viewports['Viewport:1'].setValues(displayedObject=odb)```以上示例演示了如何使用Python脚本创建一个简单的有限元模型，并进行力学分析。
使用python进行ABAQUS的二次开发的简要说明（byYoung2017.06.27）（所有用词以英文为准，翻译仅供参考）一、abaqus二次开发总述：首先最重要的知识点需要明确，abaqus在求解核心（Solver/ Kernel）和图形用户界面（GUI）之间使用的交互语言天然就是python，因此使用python进行abaqus二次开发是十分自然的选择（当然你也可以用C++，但是鉴于python所拥有的各类开源库函数的优势，python应当是二次开发的首选）。
abaqus已经使用python 写好了很多用于计算、建模、GUI等操作的模块，因此二次开发的重点在于灵活调用这些模块，完成自己的设计计算需求。
所以原则上，所有能通过abaqus/CAE交互完成的操作，使用脚本都可以实现。
并且由于Python提供的丰富的函数资源库，会使得很多复杂的建模的过程更加参数化，更加可控，有时候甚至更加简单。
其次二次开发的学习要点在于勤查手册，其中Abaqus Scripting User's Manual和Abaqus Scripting User's Reference Manual是查阅的重点，其中后者是abaqus中各个object内置方法，路径，输入参数等的详细说明。
最后关于调用脚本的几种用法说明：(1)直接在命令行调用调用脚本并打开cae界面： abaqus cae script=myscript.py调用用于可视化操作脚本，打开显示界面（注意：此时只有visualization模块被激活）： abaqus cae viewer=myscript.py 调用脚本在命令行执行，同时不打开GUI界面，但会进入python 交互界面：abaqus cae noGUI=myscript.py(2)在abaqus的GUI界面调用按照Main Menu: File->Run Script，选择需要调用的脚本文件，abaqus会进行执行(3)在abaqus的命令行交互界面调用（command line interface，在abaqus的GUI界面打开之后，窗口的最下方会有命令输入的位置，在这里也可以调用python脚本，执行方法是键入命令：execfile('myscript.py')abaqus的python脚本其实和其他应用场景下的python脚本没有太多区别，只不过有很多abaqus已经开发好的对象库可供使用，其学习过程和学习任何其他python库都是一致的。
基于Python的Abaqus二次开发实例讲解（asian58 2013.6.26）基于Python的Abaqus的二次开发便捷之处在于：1、所有的代码均可以先在Abaqus\CAE中操作一遍后再通过rp文件读取，然后再在此基础上进行相应的修改；2、Python是一种解释性语言，读起来非常清晰，因此在修改程序的过程中，不存在程序难以理解的问题；3、Python是一种通用性的、功能非常强大的面向对象编程语言，有许多成熟的类似于Matlab函数的程序在网络上流传，为后期进一步的数据处理提供了方便。
为了更加方便地完成Abaqus的二次开发，需进行一些相关约定：1、所有参数化直接通过点的坐标值进行，直接对几何尺寸的参数化反而更加繁琐；2、程序参数化已不允许在模型中添加太多的Tie，因此不同零部件的绑定直接通过共节点来进行，这就要求建模方法与常规的建模方法有所区别。
思路如下：将一个整机拆成几个大的Part来建立，一个Part中包含许多零件，这样在划分网格式时就可以自动实现共节点的绑定。
不同的零件可通过建立不同的Set来进行区分，不同Part 的绑定可以通过Tie来实现。
将一个复杂的结构拆成几个恰当的Part来建立，一方面可以将复杂的模型简单化，使建立复杂模型成为可能；另一方面，不同的Part可单独调用，从而又可实现程序的模块化，增加程序的适应范围，延长程序的使用寿命，也方便后期程序的维护和修改。
3、通过py文件建立起的模型要进行参数优化，已不适合采用Isight中Abaqus模块，需要用到Isight的Simcode模块。
下面详细解释一个臂架的py文件。
#此程序用来绘制臂架前段#导入相关模块# -*- coding: mbcs -*-from abaqus import *from abaqusConstants import *#定义整个臂架的长、宽、高L0=14300W0=1650H0=800#创建零件P01_12 L1=H0+200 W1=200 T1=12s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=2000.0)g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraints s.setPrimaryObject(option=STANDALONE)s.rectangle(point1=(W0/2, L1/2), point2=(W0/2+W1, -L1/2))s.rectangle(point1=(-W0/2, L1/2), point2=(-W0/2-W1, -L1/2))p = mdb.models['Model-1'].Part(name='Part-1', dimensionality=THREE_D, type=DEFORMABLE_BODY)p = mdb.models['Model-1'].parts['Part-1'] p.BaseShell(sketch=s)session.viewports['Viewport: 1'].setValues(displayedObject=p) del mdb.models['Model-1'].sketches['__profile__']#定义零件的厚度p = mdb.models['Model-1'].parts['Part-1'] f = p.faces pickedFaces01 = f.findAt (((W0/2, L1/2, 0),),((-W0/2, L1/2, 0),), ) p.assignThickness(faces=pickedFaces01, thickness=T1) p.Set(faces=pickedFaces01, name='P01_12')#创建辅助平面和辅助坐标系p = mdb.models['Model-1'].parts['Part-1']p.DatumCsysByThreePoints(name='Datum csys-1', coordSysType=CARTESIAN, origin=( 0.0, 0.0, 0.0), line1=(1.0, 0.0, 0.0), line2=(0.0, 1.0, 0.0))p = mdb.models['Model-1'].parts['Part-1']p.DatumPlaneByPrincipalPlane(principalPlane=XYPLANE, offset=L0)#创建零件P02_12 L2=L1 W2=W1 T2=12p = mdb.models['Model-1'].parts['Part-1'] d = p.datums#将草图原点参数化t = p.MakeSketchTransform(sketchPlane=d[5], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0, L0)) s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=29006.85, gridSpacing=725.17, transform=t) g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraints s.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']s.rectangle(point1=(W0/2, L2/2), point2=(W0/2+W2, -L2/2))s.rectangle(point1=(-W0/2, L2/2), point2=(-W0/2-W2, -L2/2))p = mdb.models['Model-1'].parts['Part-1']d2 = p.datumsp.Shell(sketchPlane=d2[5], sketchUpEdge=d2[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件的厚度p = mdb.models['Model-1'].parts['Part-1'] Array f = p.facespickedFaces02 = f.findAt(((W0/2, L1/2, L0),),((-W0/2, L1/2, L0),), )p.assignThickness(faces=pickedFaces02, thickness=T2)p.Set(faces=pickedFaces02, name='P02_12')#创建零件P03_12和零件P04_08T3=12T4=8p = mdb.models['Model-1'].parts['Part-1']d = p.datumst = p.MakeSketchTransform(sketchPlane=d[5], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0, L0)) s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=29006.85, gridSpacing=725.17, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)#创建草图p = mdb.models['Model-1'].parts['Part-1']s.Line(point1=(-W0/2-W1, H0/2), point2=(-W0/2, H0/2))s.Line(point1=(W0/2, H0/2), point2=(W0/2+W1, H0/2))s.Line(point1=(-W0/2-W1, -H0/2), point2=(-W0/2, -H0/2))s.Line(point1=(W0/2, -H0/2), point2=(W0/2+W1, -H0/2))p = mdb.models['Model-1'].parts['Part-1']d2 = p.datumsp.ShellExtrude(sketchPlane=d2[5], sketchUpEdge=d2[4].axis2,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L0, flipExtrudeDirection=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P03_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facespickedFaces03 = f.findAt(((-W0/2, H0/2, L0/2),),((W0/2, H0/2, L0/2),),)p.assignThickness(faces=pickedFaces03, thickness=T3)p.Set(faces=pickedFaces03, name='P03_12')#定义零件P04_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facespickedFaces04 = f.findAt(((-W0/2, -H0/2, L0/2),),((W0/2, -H0/2, L0/2),),)p.assignThickness(faces=pickedFaces04, thickness=T4)p.Set(faces=pickedFaces04, name='P04_12')#创建零件P05_08T5=8p = mdb.models['Model-1'].parts['Part-1']d = p.datumst = p.MakeSketchTransform(sketchPlane=d[5], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0, L0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=29006.85, gridSpacing=725.17, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']s.Line(point1=(-W0/2-W1/2, H0/2), point2=(-W0/2-W1/2, -H0/2))s.Line(point1=(W0/2+W1/2, H0/2), point2=(W0/2+W1/2, -H0/2))p = mdb.models['Model-1'].parts['Part-1']d2 = p.datumsp.ShellExtrude(sketchPlane=d2[5], sketchUpEdge=d2[4].axis2,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L0,flipExtrudeDirection=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P05_8的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facespickedFaces05 = f.findAt(((-W0/2-W1/2, 0, L0/2),),((W0/2+W1/2, 0, L0/2),),)p.assignThickness(faces=pickedFaces05, thickness=T5)p.Set(faces=pickedFaces05, name='P05_08')#创建零件P06_08L6=W0+W1n=L0//2520+1T6=8p = mdb.models['Model-1'].parts['Part-1']f, d = p.faces, p.datumst = p.MakeSketchTransform(sketchPlane=f[0], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(W0/2+W1/2, -H0/2,0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=28684, gridSpacing=717, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']#循环命令绘制平行隔板for i in range(0,n): Array s.Line(point1=(-500-(i*2520), H0), point2=(-500-(i*2520), 0.0))p = mdb.models['Model-1'].parts['Part-1']f1, d2 = p.faces, p.datumsp.ShellExtrude(sketchPlane=f1[0], sketchUpEdge=d2[4].axis2,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L6,flipExtrudeDirection=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P06_08的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facesfor i in range(0,n): Array pickedFaces = f.findAt(((0, H0/4, 500+i*2520),))p.assignThickness(faces=pickedFaces, thickness=T6)p.Set(faces=pickedFaces, name='P06_08_'+str(1+i))#创建零件P07_12,P08_12W7=200L7=W0+W1T7=12T8=12p = mdb.models['Model-1'].parts['Part-1']f, e = p.faces, p.edgest = p.MakeSketchTransform(sketchPlane=f.findAt(coordinates=(W0/2+W1/2, 0.0, 100.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 0.0)),sketchOrientation=RIGHT,sketchPlaneSide=SIDE1,origin=(W0/2+W1/2, -H0/2, 0.0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=53678, gridSpacing=1341, transform=t)g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']#循环命令绘制平行隔板for i in range(0,n):s.Line(point1=(400+i*2520, -H0), point2=(600+i*2520, -H0))s.Line(point1=(400+i*2520, 0), point2=(600+i*2520, 0))p = mdb.models['Model-1'].parts['Part-1']f1, e1 = p.faces, p.edgesp.ShellExtrude(sketchPlane=f.findAt(coordinates=(W0/2+W1/2, 0.0, 100.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 0.0)),sketchPlaneSide=SIDE1,sketchOrientation=RIGHT, sketch=s, depth=W0+W1, flipExtrudeDirection=ON, keepInternalBoundaries=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P07_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facesfor i in range(0,n):pickedFaces07 = f.findAt(((0, H0/2, 400+i*2520),),((0, H0/2, 600+i*2520),),) p.assignThickness(faces=pickedFaces07, thickness=T7)p.Set(faces=pickedFaces07, name='P07_12_'+str(1+i))fp=[]for i in range(0,2):fp.append(f.findAt(((0, H0/2, 400+i*2520),),((0, H0/2, 600+i*2520),),))p.Set(faces=fp, name='P07_fp')#定义零件P08_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facesfor i in range(0,n):pickedFaces08 = f.findAt(((0, -H0/2, 400+i*2520),),((0, -H0/2, 600+i*2520),),) p.assignThickness(faces=pickedFaces08, thickness=T7)p.Set(faces=pickedFaces08, name='P08_12_'+str(1+i))#为中间隔板创建空腔#定义相关参数边界距离、圆角d0=100r0=100p = mdb.models['Model-1'].parts['Part-1']f1, e1 = p.faces, p.edgest = p.MakeSketchTransform(f.findAt(coordinates=(0, 0.0, 500.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 500.0)),sketchPlaneSide=SIDE1, sketchOrientation=RIGHT,origin=(0.0, 0.0, 500.0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=5910.0, gridSpacing=147.0, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)#创建矩形s.rectangle(point1=(-W0/2-W1/2+d0, H0/2-d0), point2=(W0/2+W1/2-d0, -H0/2+d0)) #创建圆角s.FilletByRadius(radius=r0,curve1=g[29], nearPoint1=(-W0/2-W1/2+d0, H0/2-d0), curve2=g[26], nearPoint2=(-W0/2-W1/2+d0, H0/2-d0))s.FilletByRadius(radius=r0, curve1=g[26], nearPoint1=(-W0/2-W1/2+d0, -H0/2+d0), curve2=g[27], nearPoint2=(-W0/2-W1/2+d0, -H0/2+d0)) s.FilletByRadius(radius=r0, curve1=g[27], nearPoint1=(W0/2+W1/2-d0, -H0/2+d0), curve2=g[28], nearPoint2=(W0/2+W1/2-d0, -H0/2+d0)) s.FilletByRadius(radius=r0, curve1=g[28], nearPoint1=(W0/2+W1/2-d0, H0/2-d0), curve2=g[29], nearPoint2=(W0/2+W1/2-d0, H0/2-d0))p = mdb.models['Model-1'].parts['Part-1']f1, d2 = p.faces, p.datumsp.CutExtrude(f.findAt(coordinates=(0, 0.0, 500.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 500.0)),sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L0, flipExtrudeDirection=OFF)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#开始建立梁Beam_1p = mdb.models['Model-1'].parts['Part-1']f, d = p.faces, p.datums#绘制参考面p.DatumPlaneByOffset(plane=f.findAt(coordinates=(W0/2, -H0/2, 100.0)),flip=SIDE2, offset=8.0)dp1 = d.keys()[-1]p = mdb.models['Model-1'].parts['Part-1']d = p.datumst = p.MakeSketchTransform(sketchPlane=d[dp1], sketchUpEdge=d[4].axis1,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0,0.0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=31857.0, gridSpacing=796.0, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']#计算中间加强梁的数量if n%2==1:n1=n//2 n2=n//2 else:n1=n//2 n2=n//2-1 for i in range(0,n1):s.Line(point1=(-500-i*2520*2, W0/2+W1/2), point2=(-500-2520-i*2520*2,-W0/2-W1/2 )) for i in range(0,n2):s.Line(point1=(-500-2520-i*2520*2,-W0/2-W1/2), point2=(-500-2*2520-i*2520*2,W0/2+W1/2 ))#在基准平面dp1上面绘制梁p = mdb.models['Model-1'].parts['Part-1'] d2 = p.datums e = p.edgesp.Wire(sketchPlane=d2[dp1], sketchUpEdge=d2[4].axis1, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s) s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__'] edges1=[] for i in range(0,n-1): edges1.append (e.findAt(((0, -H0/2-8, 500+2520/2+i*2520),),)) p.Set(edges=edges1, name='Beam_1') ############################开始定义有限元分析的相关参数 #定义材料mdb.models['Model-1'].Material(name='steel')mdb.models['Model-1'].materials['steel'].Elastic(table=((210000.0, 0.3), )) mdb.models['Model-1'].materials['steel'].Density(table=((7.8e-06, ), ))#定义壳单元属性mdb.models['Model-1'].HomogeneousShellSection(name='shell', preIntegrate=OFF, material='steel', thicknessType=UNIFORM, thickness=10.0, thicknessField='', idealization=NO_IDEALIZATION, poissonDefinition=DEFAULT,thicknessModulus=None, temperature=GRADIENT, useDensity=OFF, integrationRule=SIMPSON, numIntPts=5) #赋所有壳单元属性p = mdb.models['Model-1'].parts['Part-1']for i in range(1,5):region1 = p.sets['P0'+str(i)+'_12']p.SectionAssignment(region=region1, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY , offsetField='',thicknessAssignment=FROM_GEOMETRY )region2 = p.sets['P05_08']p.SectionAssignment(region=region2, sectionName='shell', offset=0.0, offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)for i in range(1,n+1): Array region3 = p.sets['P06_08_'+str(i)]p.SectionAssignment(region=region3, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)for i in range(1,n+1):region4 = p.sets['P07_12_'+str(i)]p.SectionAssignment(region=region4, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)for i in range(1,n+1):region5 = p.sets['P08_12_'+str(i)]p.SectionAssignment(region=region5, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)#定义梁单元属性mdb.models['Model-1'].LProfile(name='L_65', a=65.0, b=65.0, t1=7.0, t2=7.0)mdb.models['Model-1'].BeamSection(name='B_65', integration=DURING_ANALYSIS,poissonRatio=0.0, profile='L_65', material='steel', temperatureVar=LINEAR,consistentMassMatrix=False)#赋所有梁单元属性p = mdb.models['Model-1'].parts['Part-1']region = p.sets['Beam_1']p.SectionAssignment(region=region, sectionName='B_65', offset=0.0,offsetType=MIDDLE_SURFACE, offsetField='',thicknessAssignment=FROM_SECTION)p.assignBeamSectionOrientation(region=region, method=N1_COSINES, n1=(0.0, 0.0,-1.0))#定义装配体import assemblya = mdb.models['Model-1'].rootAssemblya.DatumCsysByDefault(CARTESIAN)p = mdb.models['Model-1'].parts['Part-1']a.Instance(name='Part-1-1', part=p, dependent=ON)#定义分析步import stepmdb.models['Model-1'].StaticStep(name='Step-1', previous='Initial')#定义底面与梁的tiedimport interactiona = mdb.models['Model-1'].rootAssemblyregion1=a.instances['Part-1-1'].sets['P04_12']region2=a.instances['Part-1-1'].sets['Beam_1']mdb.models['Model-1'].Tie(name='Constraint-1', master=region1, slave=region2, positionToleranceMethod=COMPUTED, adjust=OFF, tieRotations=ON, thickness=ON)#开始定义耦合#导入相关模块import regionToolseta = mdb.models['Model-1'].rootAssemblyd, r = a.datums, a.referencePoints#定义参考点a.ReferencePoint(point=(0.0, H0/2, 500+2520/2))rp1 = r.keys()[-1]refPoints1=(r1[rp1], )region1=regionToolset.Region(referencePoints=refPoints1)s1 = a.instances['Part-1-1'].facesregion2 = a.instances['Part-1-1'].sets['P07_fp']mdb.models['Model-1'].Coupling(name='Constraint-2', controlPoint=region1, surface=region2, influenceRadius=WHOLE_SURFACE, couplingType=DISTRIBUTING, localCsys=None, u1=ON, u2=ON, u3=ON, ur1=ON, ur2=ON, ur3=ON)#########################定义边界条件import loada = mdb.models['Model-1'].rootAssemblyd, r = a.datums, a.referencePointsregion = a.instances['Part-1-1'].sets['P02_12']mdb.models['Model-1'].DisplacementBC(name='SPC', createStepName='Initial', region=region, u1=SET, u2=SET, u3=SET, ur1=SET, ur2=SET, ur3=SET,amplitude=UNSET, distributionType=UNIFORM, fieldName='', localCsys=None)a = mdb.models['Model-1'].rootAssemblyregion = a.instances['Part-1-1'].sets['P08_12_'+str(n-1)]mdb.models['Model-1'].DisplacementBC(name='SPC2', createStepName='Initial', region=region, u1=SET, u2=SET, u3=SET, ur1=SET, ur2=SET, ur3=SET,amplitude=UNSET, distributionType=UNIFORM, fieldName='', localCsys=None)r1 = a.referencePointsrefPoints1=(r1[rp1], )region = regionToolset.Region(referencePoints=refPoints1)mdb.models['Model-1'].ConcentratedForce(name='force', createStepName='Step-1',region=region, cf2=-10000.0, distributionType=UNIFORM, field='',localCsys=None)mdb.models['Model-1'].Gravity(name='G', createStepName='Step-1', comp2=-9.8, distributionType=UNIFORM, field='')#################划分网格import meshp = mdb.models['Model-1'].parts['Part-1']p.seedPart(size=20.0, deviationFactor=0.1, minSizeFactor=0.1)p.generateMesh()a = mdb.models['Model-1'].rootAssembly###############创建作业并提交分析import jobmdb.Job(name='006', model='Model-1', description='', type=ANALYSIS, atTime=None, waitMinutes=0, waitHours=0, queue=None, memory=90,memoryUnits=PERCENTAGE, getMemoryFromAnalysis=True,explicitPrecision=SINGLE, nodalOutputPrecision=SINGLE, echoPrint=OFF,modelPrint=OFF, contactPrint=OFF, historyPrint=OFF, userSubroutine='',scratch='', multiprocessingMode=DEFAULT, numCpus=4, numDomains=4) mdb.jobs['006'].submit(consistencyChecking=ON)mdb.jobs['006'].waitForCompletion()###############进入后处理模块import visualizationo3 = session.openOdb(name='F:/ABAQUS/006.odb')session.viewports['Viewport: 1'].setValues(displayedObject=o3)session.viewports['Viewport: 1'].odbDisplay.display.setValues(plotState=( CONTOURS_ON_DEF, ))session.viewports['Viewport: 1'].view.setValues(session.views['Iso'])mdb.saveAs(pathName='F:/ABAQUS/006.cae')第11 页共11 页。
Abaqus的Python对象模型小结何其昀2016-04-22目录一、引言 (1)二、会话（Session）对象 (1)2.1 session (1)2.2 viewport (2)2.3 view (3)三、模型数据库（Mdb）对象 (4)四、输出数据库（Odb）对象 (6)参考资料 (7)一、引言Abaqus内建三种基本对象为：Session，Mdb，Odb。
分别为模型数据无关会话、模型数据库、输出数据库。
其中，session和mdb对象为单例，odb对象存于session.odbs容器中。
它们各自包含或关联了大量的子对象，如图1所示。
图1 Abaqus的三个基本对象二、会话（Session）对象2.1 sessionsession对象包含一些不存储于Abaqus/CAE会话中的对象，如定义视口、远程队列、用户视图等对象，参见图2。
它有一系列功能函数和一系列成员对象或对象容器（如viewports、views、queues等）。
其中viewports容器与views容器中的对象一一关联，分别用于指定视口中的显示对象和对视图进行操作。
图2 Session对象模型2.2 viewportviewpot是程序产生图片的容器，它保存了关于对象如何显示的各种设置。
viewport用于指定视口中的不同显示对象，包括：部件/part、装配件/assembly、草图/sketch、计算结果、X-Y图和空对象等，参见图3。
例如，下述命令为设置viewport的显示对象：p = mdb.models['Model-1'].parts['lxj_fix_scale_proecf-7']session.viewports['Viewport: 1'].setValues(displayedObject=p)图3 Viewport对象模型对显示对象的设置是通过其partDisplay、assemblyDisplay和odbDisplay子对象进行的。
1学习笔记学习资料：《Python语言在Abaqus中的应用》20世纪60年代，Ray W. Clough教授在发表的论文《The Finite Element in Plane Stress Analysis》中首次提出有限单元法，此后，有限单元法的理论得到迅速发展，并广泛应用于各种力学问题和非线性问题，成为分析大型复杂工程结构的强有力手段。
Abaqus提供两种接口：1）用户子程序接口（User Subroutine）。
该接口使用Fortran语言进行开发，主要用于自定义本构关系、自定义单元等。
常用的用户子程序包括(V)UMAT、(V)UEL、(V)FRIC、(V)DLOD等。
2）Abaqus脚本接口（Abaqus Scripting Interface）。
该接口是在Python语言的基础上进行的定制开发，它扩充了Python的对象模型和数据类型，使Abaqus脚本接口的功能更加强大。
一般情况下，Abaqus的脚本接口主要用于前处理（例如，快速建模）、后处理（例如，创建和访问输出数据库）、自定义模块（例如，自动后处理模块等）。
Python语言是公认的功能强大的面向对象的编程语言，Abaqus脚本接口在它的基础上又添加了许多数据类型和核心模块，因此功能更加强大。
即便如此，Abaqus脚本接口仍然允许读者编写自己的模块或函数，以扩展其功能。
保留字Python的保留字：Python语言的代码简洁，易于阅读，保留字相对较少；Python语言中不包含分号（;）、begin、end等标记，而是通过使用空格或制表键缩进的方式进行代码分隔。
编写程序时，尽量不要选择保留字作为变量名、函数名等开发工具&运行环境：1）Python Win：【开始】→【程序】→【ActiveState ActivePython 2.6(32-bit)】→【PythonWin Editor】；运行按F5或【File】→【Debug】→【Go】2）Abaqus运行环境：启动Abaqus/CAE，【File】→【Abaqus PDE】※在Abaqus中编写Python源代码，可以与Abaqus/CAE进行实时互动，而且代码修改后的效果能够立即在Abaqus/CAE中得到体现，便于调试和修改。
Abaqus中的PDE也提供了多种编辑、调试程序的功能，包括代码着色、自动缩进、断点设置与管理、堆栈（stack）、观察列表（watch list）等功能。
3）EditPlus编辑器：模板代码：#!/user/bin/python 使Python程序可以在UNIX操作系统下运行# -* - coding:UTF-8 -*- 设置编码集为UTF-8，使得编写Python代码过程中可以输入中文字符编写规则1）合理使用注释：注释语句放在# 后；中文注释必须先添加# -* - coding:UTF-8 -*- 2）合理使用空行：空行的作用在于分隔两段不同功能或不同含义的代码，便于以后代码的维护或重构。
一般情况下，变形程序代码时应该在函数与函数之间、类的方法之间、类和函数入口之间设置空行，用来表示一段新代码的开始。
一般情况下，最好设置两个空行。
※空行是源代码的一部分，但不是语法的部分，不会报错。
在Abaqus脚本结构中使用空行是一定要十分谨慎。
如果存在嵌套循环时使用空行，一定注意空行的缩进格式。
在EditPlus编辑器下可以很清楚地看到缩进层次。
如果不便于查看空行缩进，则可以将空行作为注释行进行处理，即以#开始。
3）语句的分隔：Python中可以用分号分隔语句，物理行间的分号也可以省略，但如果一个物理行中包含多个逻辑行，则需要以分号分隔。
※习惯上一个物理行只写一个逻辑行，如果逻辑行太长需要多个物理行编写，则用反斜杠“\”作为换行符，这种做法叫做“行连接”，如果逻辑行中使用了圆括号( )、方括号[ ]、大括号{ }等暗示行连接，则无需使用反斜线。
4）模块的导入方式：模块（module）指的是某些类或函数的集合，用于实现特定功能。
importfrom … import …5）命名规则：便于大型程序的协作开发变量名：首字母一般是字母或下划线，其他字符可由字母、下划线或数字组成。
定义时不得使用保留字；避免使用i、j、k等单个字母；变量名尽可能地表达该变量的含义、定义变量时尽量避免使用缩写，方便模块名：一般首字符是小写英文字母。
扩展名为.py的文件本身就是一个模块，因此，模块名也是文件名。
类名：通常类名首字母必须大写，其他字母小写；访问类的属性和方法的表示方式为：在对象名后面跟操作符“.”。
对象名：使用小写字母。
函数名：首字母小写，并通过下划线或单词首字母大写的方式增加函数名的可读性。
对于导入模块快中的函数名，则使用模块名作为其前缀。
6）代码缩进：每行代码前输入空格或制表符来表示代码之间的层次（空格数量没有明确要求，1个即可，但习惯上每层间4空格）关系，对于Python而言，代码缩进是一种语法，如果缩进错误会抛出IdentationError异常；Python采用代码缩进和冒号“:”来区分代码块之间的层次关系。
※使用IDE开发工具或EditPlus等文本编辑软件编写代码时，编辑软件能够不起冒号并实现自动缩进，可以大大提高代码的编写效率。
数据类型1）数字类型：整型int：可以使用二进制、八进制、十六进制；Python能根据数值的大小自动将整型数转换为长整型，定义时更加方便。
长整形long：浮点型float：只有双精度浮点型数据复数类型complex：c=1+2j布尔型数据bool：2）字符串类型：使用单引号（’）、双引号（”）、三引号（’’’）来表示字符串类型的数据，其中单引号和双引号的作用相同，使用它们定义字符串时，字符串中所有的空格和制表符都被保留；三引号是Python特有的语法，用来定义多行字符串，三引号内还可以任意使用单、双引号或换行符※三引号是三个单引号※若单引号表示的字符串中还有单引号，如’what’s your name’，系统将无法判断字符串起始点而报错，这时可以用转义字符（\）实现，如’what\’s your name’；也可以使用双引号”what’s your name”。
※常用转义字符及含义※如果字符串末尾处有一个单独的反斜线\，则表示下一行是续行，如：3）元组（tuple）：由一系列元素组成，且每个元素可以存储不同类型的数据。
4）列表（list）：5）字典（dictionary）：变量和常量Python语言中的变量无需声明，赋值操作包含了变量声明的定义。
需要注意的是：Python语言每一次新的赋值操作都将创建一个新的变量，即使创建的变量名相同，但是变量的标识却不相同。
变量在使用之前必须赋值，因为只有为变量赋值后该变量才被创建。
可以在一条语句中同时为多个变量赋值，如a, b, c = 1, 2, 3全局变量：全局变量指的是能够被不同的函数、类或文件所共享的变量。
全局变量可以被文件内部的任何函数访问，也可以被外部文件访问。
一般情况下，在函数块之外定义的变量都可以认为是全局变量。
为使代码更加易读，最好在文件的开始位置定义全局变量。
全局变量用global语句声明。
※很多情况下，两个变量名相同的变量并非表示同一个变量，变量名只是变量的标识符。
相同的变量名出现在代码的不同位置，含义往往是不相同的。
为变量命名时，好的习惯：1）为避免混淆全局变量和局部变量，可以将全局变量放到单独的文件中，便于管理和修改。
2）尽量不要使用全局变量。
全局变量对于不同的模块都可以自由访问，可能导致全局变量的不可预知性，造成错误，且这种错误非常隐蔽，难以发现和改正。
局部变量：局部变量指的是只能在函数或代码块范围内使用的变量。
函数或代码块一旦结束，局部变量的生命周期也将结束。
常量：初始化之后就不能改变的固定值。
例如字符串、数字等。
编写程序时，可以根据需要将所有的常量定义在一个块中，使用时通过导入模块来实现。
运算符和表达式赋值运算符=算数运算符：加+ 减- 乘* 除/幂** x**y将返回x的y次幂取模% 返回除法的余数取整数// 返回商的整数部分※Python不支持自增、自减运算关系运算符：小于< 大于> 小于等于<= 大于等于>= 等于== 不等于!= <> ※关系运算符返回值True 或False逻辑运算符：与and 或or 非not※逻辑运算符返回值True 或False【重】运算符优先级（序号越大表示优先级越高）文件类型1）源代码文件：.py（源代码文件，由python.exe执行）.pyw（专门用于开发图形用户界面，由pythonw.exe执行）2）字节代码文件：.pyc（源代码文件经编译后生成，不能在文本编辑器中打开或编辑）3）优化代码文件：.pyo（经过优化的源文件生成，需要使用指令行工具生成）元组（tuple）：由一系列元素组成，且每个元素可以存储不同类型的数据。
创建：tuple_name=(元素0 元素1, …)※元组创建时可以为空；只有一个元素时，也应该加逗号，否则系统无法识别是元组还是表达式。
例：zoo=(‘wolf’, ‘elephant’, ‘penguin’)emptytuple=()newzoo=(‘wolf’,)※元组索引从0开始计数，如zoo[0]表示其中第一个元素※print语句后面可以跟具备定制功能的带符号%的元组。
定制功能可以输出特定格式，元组中各元素的顺序必须与定制的顺序一一对应，例：age = 33name='John'print '%s is %d years old' % (name,age)print 'Why is %s playing with that snake?' % name这里如果不加%的话无法输出※如果要在字符串中输出%，则应该是%%访问元组有两种方式：1）索引，从0开始计数，tuple_name[0]2）切片，如tuple_name[1:3]（冒号前后的数字可有可无，但是冒号必须存在），表示元组中第2个元素开始，到第4个元素结束（不包含第4个元素）※元组也可以成为新元组的元素：zoo = ('wolf', 'elephant', 'penguin')print 'Number of animals in the zoo is', len(zoo)new_zoo = ('monkey', 'dolphin', zoo)print 'Number of animals in the new zoo is', len(new_zoo)print 'All animals in new zoo are', new_zooprint 'Animals brought from old zoo are', new_zoo[2]print 'Last animal brought from old zoo is', new_zoo[2][2] 输出：Python语言中创建元组的过程称为“打包”；将元组中各个元素分别赋值给多个变量的过程称为“解包”：zoo = ('wolf', 'elephant', 'penguin')a,b,c=zoo列表创建列表：list_name=[元素1, 元素2, …]列表中各个元素包含在方括号中。
