cgtd*

Maya wxWindow

2011-03-16T07:04:00.000-07:00

This a a template to create interactive wxWindows in Maya. The same UI can be ported to most applications using a python interpreter by only changing the makeCube method. However, not all software and/or versions fully support wxWidgets. The key difference you'll want to remember between a standard window and one from Maya is to omit initializing wx.app.MainLoop().

import wx
import maya.cmds as cmds

def getApp(kill = None):
 if kill:
  if MyFrame.instance:
   MyFrame.instance.Hide()
   MyFrame.instance.Destroy()
   MyFrame.instance = None
 else:
  if MyFrame.instance:
   MyFrame.instance.Show()
  else:
   MyFrame.create()
 
class MyFrame(wx.Frame):
 instance = None
 
 @classmethod
 def create( cls, *args, **kw ):
  app = wx.GetApp()

  if app is None:
   app = wx.App( redirect = False )
  
  frame = cls( None, app, *args, **kw )
  frame.Show(True)
 
 def __init__(self, parent, app):
  MyFrame.instance = self
  wx.Frame.__init__(self, parent, wx.ID_ANY, "MyFrame", wx.DefaultPosition, wx.Size(500,500), wx.DEFAULT_FRAME_STYLE )
  
  self.panel = wx.Panel(self, -1)
  self.sphereButton = wx.Button(self.panel, -1, "Sphere")
  self.cubeButton = wx.Button(self.panel, -1, "Cube")
   
  self.Bind( wx.EVT_ICONIZE, self.OnMinimize )
  self.Bind( wx.EVT_CLOSE, self.OnClose )
  self.sphereButton.Bind(wx.EVT_BUTTON, self.makeSphere)
  self.cubeButton.Bind(wx.EVT_BUTTON, self.makeCube)
  
  mainSizer = wx.BoxSizer(wx.VERTICAL)
  panelSizer = wx.BoxSizer(wx.HORIZONTAL)
  
  panelSizer.Add(self.sphereButton, 0, 0, 0)
  panelSizer.Add(self.cubeButton, 0, 0, 0)
  self.panel.SetSizer(panelSizer)
  mainSizer.Add(self.panel, 1, wx.EXPAND, 0)
  
  self.SetSizer(mainSizer)
  mainSizer.Fit(self)
  self.Layout()
 
 def makeSphere(self, evt):
  cmds.polySphere()
  
 def makeCube(self, evt):
  cmds.polyCube()
 
 def OnClose(self,event):
  self.Show(False)

 def OnMinimize(self, event):
  self.Show(0);

XSI Plugin

2011-03-16T07:02:00.000-07:00

Creating XSI plugins in python is extremely easy. This file will add a new menu and menuItem to the main toolbar. You can actually attach a menuItem to many other XSI widgets besides the main toolbar using the RegisterMenu command. Like most UI elements, they are not initialized until they are called the first time.

import win32com.client
from win32com.client import constants

def XSILoadPlugin( in_reg ):
 in_reg.Author = ""
 in_reg.Name = "myPlugin"
 in_reg.Email = ""
 in_reg.URL = ""
 in_reg.Major = 1
 in_reg.Minor = 0
 print in_reg.Name, "has been loaded."
 
 in_reg.RegisterMenu(constants.siMenuMainTopLevelID,"MenuTitle",0,0)
 in_reg.RegisterCommand("MenuItem","MenuItem") #command, scriptname
 return 1

def XSIUnloadPlugin( in_reg ):
 print in_reg.Name, "has been unloaded."
 return 1

def MenuTitle_Init( in_ctxt ):
 oMenu = in_ctxt.Source
 oMenu.AddCommandItem("MenuItem","MenuItem") #menuname, command
 return 1

def MenuItem_Init( in_ctxt ):
 oCmd = in_ctxt.Source
 oCmd.Description = ""
 oCmd.ReturnValue = 1
 return 1

def MenuItem_Execute(  ):
 print "Command to Run"
 return 1

Maya Globals

2011-01-23T13:46:00.000-08:00

Here is a quick PyMEL script to get a list of Maya's global variables which you can use to easily grab some data without having to run your own commands or needing to query around the interface. There are 750+ by default, and Mental Ray will add a handful as well. Many values are actually not set, or are empty by default.

from pymel.core import *
for index, eachEnv in enumerate(MelGlobals().keys()):
    print "%s- %-50s %s" %(index, eachEnv, melGlobals[eachEnv])

Some nice ones to keep in mind are:

$gMainPane
$gMainWindow
$panelName

There are also some humorous ones:

$foobar
$WantProtein

Passing Values Between Python and MEL

2011-01-07T23:41:00.000-08:00

MEL to Python

MEL:

$foo="Hi"

Python:

import maya.mel as mel
foo=mel.eval("$temp=$foo")

Python to MEL

Python:

bar="Hi"

MEL:

$bar=python("bar")

Python to/from MEL

Plugin:

import maya.OpenMaya as om
import maya.OpenMayaMPx as omMPx

nodeId = om.MTypeId(0x101118)

#node data
class user(omMPx.MPxNode):
 INPUT = om.MObject()

 def __init__(self):
  omMPx.MPxNode.__init__(self)
def userCreator():
 return omMPx.asMPxPtr( user() )
def userIniter():
 numAttr = om.MFnNumericAttribute()
 user.x = numAttr.create("x","x",om.MFnNumericData.kFloat,0.0)
 numAttr.setStorable(1)
 numAttr.setWritable(1)
 user.addAttribute(user.x)

#plugin requires
def initializePlugin(mobject):
 mplugin = omMPx.MFnPlugin(mobject)
 try:
  mplugin.registerNode("user", nodeId, userCreator, userIniter)
 except:
  print "Error loading"
  raise
def uninitializePlugin(mobject):
 mplugin = omMPx.MFnPlugin(mobject)
 try:
  mplugin.deregisterNode( nodeId )
 except:
  print "Error removing"
  raise

MEL:

if(!size(`ls "userData"`)){
    createNode "user" -name "userData";
}
setAttr "userData.x" 5;
getAttr "userData.x";

Python:

import maya.cmds as cmds
if not cmds.ls("userData"):
    myUser=cmds.createNode("user", name="userData")
cmds.setAttr("userData.x", 5)
print cmds.getAttr("userData.x")

Useful Commands

2011-01-02T01:45:00.000-08:00

whatIs

whatIs script;   //mel only
whatIs statusLineUpdateInputField;   
// Result: Mel procedure found in: C:/Program Files/Autodesk/Maya2009/scripts/startup/statusLine.mel //

When you need to emulate a command from Maya and the script editor only gives feedback when Echo All Commands is checked. Maya most likely echoed a built in mel procedure that runs multiple mel commands in the background. Just open the file, find the procedure, and begin sifting through Maya's internals.

evalDeffered

cmds.evalDeferred("cmds.refresh(force=1)", lowestPriority=1) 
cmds.evalDeferred(lambda : localCommand, lowestPriority=1)

Often a command will return a result before the intended process is complete. This is often a result of commands firing idle scriptJobs. The problem is your code continues while Maya is trying to play catch up. evalDeferred will wait until Maya is completely idle (no more queued scriptJobs) before continuing.

Attributes and Values

2011-01-02T01:11:00.000-08:00

Here is a simple script to list all the attributes, attributeType, and values.

selection=cmds.ls(sl=1)[0]
selection=cmds.ls(sl=1)[0]
attributes=cmds.listAttr(selection)
attributeList=[]
print "\n"
for eachAttr in attributes:
   name=eachAttr,
   try: type=cmds.nodeType(selection+"."+eachAttr),
   except: type="Error"
   try: value=cmds.getAttr(selection+"."+eachAttr)
   except: value="Cannot Read"
   attributeList.append([name[0], type[0], value])
col1length=max([len(str(item[0])) for item in attributeList])
col2length=max([len(str(item[1])) for item in attributeList])
col3length=max([len(str(item[2])) for item in attributeList])
print ("Attribute".ljust(col1length), 
       "Type".ljust(col2length), 
       "Value".ljust(col3length))
for eachAttr in attributeList:
   print str(eachAttr[0]).ljust(col1length),
   print str(eachAttr[1]).ljust(col2length),
   print str(eachAttr[2]).ljust(col3length)

materialInfo

2011-01-02T01:05:00.000-08:00

Quite often, unintentionally, mesh will only display in wireframe. More than often it is from accidentally deleting the connection from the mesh to the shading group. However, if you are scripting a file translator or shader exporter you might have ignored the materialInfo node. Almost invisible to the user it is necessary for hardware rendering of any shader.

A: Correct Connections, B: MaterialInfo Error, C: Deleted ShadingGroup

As you can see the problem is indistinguishable in the hypershade. The only way to tell if you've got this problem is to view B's material in the Attribute Editor. If most of it's Hardware Texturing features are disabled try the following.

miNode=cmds.createNode("materialInfo")
cmds.connectAttr("phong1SG.message", "%s.shadingGroup"%miNode)
cmds.connectAttr("phong1.message", "%s.material"%miNode)

Other Extensions

2011-01-01T22:27:00.000-08:00

If you've looked into the Python install dir you've most likely seen .pyc and .pyo files. Unlike .pyw files which are simply renamed extension, .pyc and .pyo are encoded by the interpreter and are no longer human readable. Typically compiled python (.pyc) are created by the interpreter once a .py file is run. However, if the option was turned off during installation the following can create them for you. -O and -OO flags will optimize the code further.

python -m py_compile myFile.py
python -m compileall -l .

Although it would be nice to get a speed boost from optimizing and compiling our code that is not the case. You may find a minor improvement in the launch time, since the interpreter no longer needs to convert it to bytecode, but the main advantage is to have some code protection if you are distributing your program.

Hidding the Console

2011-01-01T18:30:00.000-08:00

As you have probably noticed the typical Python extension is .py. If you change this in explorer to .pyw pythonw.exe will execute the script instead of python.exe. As a result the console window will be suppressed and any GUI windows will still come up. Preventing the console looks more professional for a finished build, but during development it is still very useful for debugging.

.py appication launches a shell.

Kill Maya

2010-09-06T19:28:00.000-07:00

There are plenty of times when Maya goes rogue and takes control of your system. Here are some methods of killing the frozen process.

Linux has superior methods of handling this situation so we'll start here.

First connect to an auxiliary terminal.

Open a Virtual Console.

Press Ctrl+Alt+Fn.

Connect from a remote terminal using a secure shell. *The SSH server must be started on the client machine. service sshd start on fedora.

ssh username@ip

Connect from a remote OS using a VNC as an alternative user. *The VNC server must be started on the client machine.

Once connected to the local terminal identify and kill the process.

Use standard unix commands.

ps -u paul | grep maya

kill -signal pid

9 SIGKILL -Hardest
15 SIGTERM -Softest

If installed use top.

z: color
x: highlight column sort
<, > change sort column
q: quit
u: username
R: reverse sort
k: kill process id

Windows on the otherhand does not have virtual consoles so all these methods require a auxiliary computer on the network.

Run a basic taskkill.

taskkill /s ip /u username /p password /im maya.exe /f [/pid process id]

Connect using telnet. *The telnet server must be started on the client machine. Check Telnet Client and Telnet Server from Control Panel->Programs and Features->Turn Windows features on or off.

telnet ip
taskkill /u username /p password /im maya.exe /f

Connect from a remote OS using a VNC as an alternative user. *The VNC server, or default Microsoft Terminal Server, must be started on the client machine.

runas /user:username "taskkill /im maya.exe /f"

Hypergraph Colors

2010-09-03T21:01:00.000-07:00

I'm sure we can all agree working in the hypergraph can sometimes be quite imbroglio. Knowing what to look for in this tangled web can really help. It would be nice to have a hide connection lines on selected nodes feature like Nuke to help clean up the network. But Maya only allows us to globally merge multiple connections, which doesn't really help when we are interested in node specifics.

It is therefor pretty valuable to remember how the hypergraph defines its line colors. Here is my refined color chart from Maya's docs followed by an example of each.

General > Basics > Basics Windows and Editors > Hypergraph > Hypergraph Overview

Setting up Subversion

2010-08-25T21:00:00.000-07:00

Python Cheat Sheet

2010-08-23T00:20:00.000-07:00

This is for everyone who, for whatever reason, are putting off learning Python. Ideally, if you are coming from another language such as MEL or Perl, you should be able to skim through these demos and have no problem transitioning to Pythonic syntax. The following Python snippets are selections from the online documentation at http://docs.python.org/, which I modified whenever possible to fit into a Maya context.

Data Structures

Strings

myString="Hello"
mySecondString="World"
result=myString+mySecondString
myMultilineString="""Hello World.
What a beautiful world it is."""
myRawString=r"C:/Users"
  
firstLetter=myString[1]
lastLetter=myString[-1]
firstWord=myString[0:4]

Unicode: Since Maya is used internationally, multiple language packs are supported which require a unicode character set. Think of unicode as the big brother of the standard ASCII model. You will not see anything unusual as the result of MEL commands, however Maya will return Python commands in unicode notation. As long as your in Maya the prefix u can be ignored, however, if you are writing output to a file they will have to be converted to ASCII.

print cmds.ls(cameras=1)
>>[u'frontShape', u'perspShape', u'sideShape', u'topShape']

Lists

print cmds.ls(cameras=1)
>>[u'frontShape', u'perspShape', u'sideShape', u'topShape']

myToys=["yoyo", "cup", "ball", "crayon"] #the names of your objects
cmds.select(myToys)

firstToy=myToys[1]  #yoyo
numToys=len(myToys)  #3

List Comprehensions: These are used to create lists from any iterable object. The first time I used them was to retrieve the nth column in a matrix stored as vectors.

myMatrix=[[1,2,3,4],[1,2,3,4],[1,2,3,4]]
thirdRow=myMatrix[2] #[1,2,3]
thirdColumn=[x[2] for x in myMatrix] #[3,3,3]

Tuples: Are similar to list except they cannot be modified, also known as immutable.

myList=["Hello", 1]
myList[1]=5 #can change the value

myTuple=("Hello", 1) 
myTuple[1]=5 #ERROR

Sets: Sets are GREAT. They are just like lists but prevent duplicate elements.

keyLight= cmds.lightlink(light="keyLight", query=1) #return all objects set to receive light from keyLight
backLight= cmds.lightlink(light="backLight", query=1) #return all objects set to receive light from backLight

lightsList=keyLight+backLight #12 items, lists duplicates
lightsSet=set(keyLight+backLight) #8 items, returns only unique elements

Dictionaries: Sometimes referred to as hashes or associative arrays, are used to store data in name, value pairs.

myCameras=cmds.ls(cameras=1)
myTextures=cmds.ls(textures=1)
myScene={'cameras':myCameras, 'textures':myTextures} #myScene stores all the cameras and textures in the scene

print myScene.keys()
print myScene.values()
print myScene["cameras"]

Control Flow

While Loops: Use extreme caution when using while loops. There is no way to close Maya if you get caught in an infinite loop.

while x<10:
    print x
    x+=1 #make sure to terminate the loop!

If Statement

if (myValue==10 or myValue==20) and myValue!=30
    print myValue
elif myValue==0:
    print "Cannot be 0"
else: #all occurances
    pass #pass keeps Pythonic syntax, useful as placeholders

For Statement

for x in range(10):
    print x, someList[x]

for index, eachItem in enumerate(iterableItem):
    print index, eachItem

Exceptions

sphereAttrs=cmds.listAttr('pSphere1')
for eachAttr in sphereAttrs:
    print eachAttr+":",
    try:
        print cmds.getAttr("pSphere1."+eachAttr)
    except:
        print "Cannot Read"

Functions

def myFunction(arg=None): #defines function myFunction that accepts an argument arg that defaults to None
    print arg
    return 1
myFunction("Hello World") #calls myFunction

Classes

class newClass():
    myInt=5 #class variables
    @classmethod  #class method decorator
    def getInt(cls): #class method
        return cls.myInt
    def __init__(self, arg): #gets automatically called when an object is instantiated
        self.myString=arg  #self are instance variables, they are unique per object
    def myFunction(self, arg):
        print arg, self.myString

myClass =newClass("Hello") #creates a new object from class newClass, objects are instances of a class
myClass.myFunction("World") #Hello World
print myClass.myFunction.myString #Hello
print newClass.myInt #5
print newClass.getInt() #5

I hope this will get you all started in the right direction. The vast majority of all your scripts will come from topics discussed here, everything else beyond this cheat sheet will merit a dedicated post. If you have further questions I find it's easiest to just to Google the topic. Even though I am a member of http://www.python-forum.org/pythonforum/ I rarely, if ever have to create a new thread. On the other hand I highly recommend the Maya Programming Forum on http://forums.cgsociety.org/ since Maya specifics sometimes get hazy. Hopefully you are all already members.

Current Version

2010-08-15T03:40:00.001-07:00

It is often necessary to know the exact Python version for debugging or installing modules.

import sys
print sys.version_info

It is also sometimes important to know what Maya version is currently running, especially for backwards compatibility.

import maya.cmds as cmds
print cmds.about(version=1)

If you are using an IDE and want to make sure your code will execute as expected without having to worry about version control set its default Python interpreter to C:\Program Files\Autodesk\Maya2009\bin\mayapy.exe.

External Editor

2010-08-15T03:40:00.000-07:00

Maya 2011 new features

Although Maya 2011 added a slew of new features to the script editor, it is still best practice to program in a standalone IDE. Some of the benefits include:

Custom syntax highlighting.
Collapsible Code.
Regex Assistance.
File management, versioning, sharing is easier.
Runs on an independent process.

Fortunately, Maya automatically saves your scripts on exit. However, you WILL lose data if you solely rely on this feature. This can occur if you are coding on multiple instances of Maya simultaneously, or more likely, Maya crashes. Also, keep in mind, your scripts can easily, unintentionally trigger a crash themselves. Programming on an independent process will allow you to force quit from Maya with no data lose.

Again Python has the benefit over MEL in that it is an independent, open-source language. Therefore IDE's are readily available. Eclipse + PyDev [open-source], Komodo [commercial], PyCrust [commercial], etc. In addition every Python interpreter comes with a bare bones editor called IDLE. Install either version 2.5 or 2.6 (post Maya 2010). http://www.python.org/download/ To launch the IDE go to Start > Python > IDLE. You can also launch it through a shell using:

python C:/Python27/Lib/idlelib/idle.py

Yes, you are using a Python application to write your own Python scripts. Once the Tk Python shell opens go to File > New Window. Here you can type your code as if you were using Maya's Script Editor. You will want to save your file to ~\Users\Paul\Documents\maya\scripts [Windows] or ~/Library/Preferences/Autodesk/maya/scripts [Mac] with a .py extension.

Then in order to execute this file from Maya type:

import filename

Once the file is imported successfully and you want to make changes you will need to run:

reload(filename)

There may be times while debugging when it may be more convenient to execute portions of your external script from Maya. To interact with imported objects you must type the filename . variableName.

import HelloWorld
print HelloWorld.mySting  #call a variable defined in HelloWorld.py
HelloWorld.myFunction()   #call a function defined in HelloWorld.py

*Maya can read Python documents created after Maya has launched, but cannot read new MEL files until it has been restarted.

Alternative Importing

2010-08-15T03:39:00.000-07:00

Using Maya's scripts folder is great if your working on a personal project, but isn't as handy for a company wide script. In these cases you can assign Maya to look in a shared folder.

import sys
sys.path.append("M:\mayascripts")
import HelloWorld

Whereas the MEL source command allows for absolute paths:

source "C:/users/paul/desktop/something.mel"

Or set the environment variables MAYA_SCRIPT_PATH for MEL and the PYTHONPATH for Python to the scripts directory. Also note Maya will automatically source all your MEL files, but Python scripts must always be manually imported.

If you are going to be editing the env variables you will need to restart Maya for changes to take affect.

History Menu

2010-08-15T03:38:00.001-07:00

Script Editor > History

Batch Render Messages

MEL - Only effects messages detailing batch rendering progress.

Echo All Commands

MEL - Displays overly verbose detail for every action Maya takes. You might think this is beneficial to have on but rarely is this information valuable. This is equivalent to:

cmds.commandEcho(state=1)    #or 0

Line Numbers In Errors

MEL & Python (2011) - Displays the line the error occured. Pre 2011, or when Show Stack Trace is enabled, Python's interpreter outputs this information regardless.

Show Stack Trace

MEL & Python (2011) - Creates a separate stack output window for runtime errors. Pre 2011 Python's interpreter outputs this information regardless. This is equivalent to:

stackTrace -state 1    #or 0
print (12/0)           #try making a runtime error

*Manually setting the commandEcho, stackTrace state triggers toggling errors in the UI.

Suppress Command Results

MEL - Toggles command results. Will still display //Result in the command line.

polySphere;
>>// Result: pSphere3 polySphere3 //

Suppress Info Messages

Toggles display of info messages, only generated by Maya internals.

Suppress Warning Messages

MEL & Python - Toggles display of purple (yellow 2011) warning messages(commands). Will still display //Warning in the command line. [Added to Python library in 2011]

warning "You did something wrong.";
>>// Warning: You did something wrong. //

Suppress Error Messages

MEL & Python - Toggles display of red error messages(commands). Will still display //Error in the command line. [Added to Python library in 2011]

Suppress Stack Window

Toggling this from the menu takes no affect. However, if Show Stack Trace is on and you manually set suppressStackWindow the stack window is suppressed AND the Suppress Stack Window menu reflects the change. Querying this field defaults to off, otherwise it is the previously set state regardless of the UI display on startup.

scriptEditorInfo -suppressStackWindow 1;

*Manually setting the stackTrace state triggers toggling errors for selecting Show Stack Trace from the UI.

Basic Python in Maya

2010-08-15T03:38:00.000-07:00

Lets cover some Python fundamentals to get us started.

Since, out of the box, Python was not developed for Maya it does not understand how to interact with any of your scene's nodes. Therefore, although you can always write pure Python code with no problem, whenever Python needs to interact with your scene you will need to import a module Maya provides to append all its MEL functions.

import maya.cmds
maya.cmds.polySphere()

This will first execute the module maya.cmds from the current Python session. This will import all of Maya's Python wrappers for its MEL commands. To execute the Maya command you must write the module name followed by the command name. To reduce the need to type maya.cmds for every command it is most common to assign the module to a namespace.

import maya.cmds as cmds    #mc is also a frequently assigned namespace
cmds.polySphere()

Another method is to bring all the maya.cmds objects into the current main module:

from maya.cmds import *
polySphere()

This requires no namespaces. However, standard Python functions may be overridden. Alternatively, since everything in Python are objects you can copy the function call to an object in the current module.

import maya.cmds as cmds
polySphere=cmds.polySphere()
polySphere()

-----

Most commands return feedback after a successful call.

All commands in create mode return the name of the node created.
Query commands return the attribute(s) designated.
Edit commands will return either 0 or 1.

Again, always have the docs open while programming to check available flags.

mySphere=cmds.polySphere() #stored the created nodes in mySphere
print mySphere
>>[u'pSphere1', u'polySphere1']

These are some of the most simple, essential commands that even non programmers should know. You will return to these time and time again.

ls
select
delete
listAttr
setAttr
listConnections
listRelatives
nodeType
undo

Example:

import maya.cmds as cmds
stepTransforms=[]     #a python array
for i in xrange(50):     #loop this code block 50 times
    currentStep=cmds.polyCube(width=6, height=.2, depth=1, name="step%s" %i)
    cmds.xform(currentStep, translation=[0,float(i)/5,0], rotation=[0,i*10,0])

    stepTransform, stepMesh=currentStep     #unpack the polyCube result into transforms and meshes
    stepTransforms.append(stepTransform)
cmds.group(stepTransforms, name="stairs")

Writing Python procedures for Maya doesn't get much more complicated than that. Play around with different commands, and remember the docs have examples on nearly everything.

Getting Started

2010-08-08T01:55:00.000-07:00

Lets get started with an into to scripting in Maya.
Start off by opening the script editor: Windows > General > Script Editor

You should also always have the API open at the same time: In the Maya Docs go to Technical Documentation > CommandsPython. Now, if your new to scripting by thankful your starting off in Maya. The documentation and interpreter feedback are the best in the business. 90% of Maya's commands are echoed after execution and the API is extremely well documented. All the commands have examples, and are both searchable and categorized. Luckily, Maya Scripting IS NOT a two bit chapter in a thousand page pdf manual, more on those programs later.

You could start off in MEL. There are plenty of advantages in doing so:

No need to import commands
Automatic sourcing
Maya's feedback is all in MEL
Unicode support
Maya ASCII is all in MEL
Expressions, Render Options, and many nodes except MEL directly

However, whenever possible I will be making my scripts in Python.

Extremely expandable using modules. NumPy, Django,...
Extensive UI development. wxPython, PyQT
Compatible with many other CG applications. Nuke, Houdini, Realflow, XSI, ...
Syntax highlighting/decoration.
Object Oriented.
Easily readable. NO ; $ ` required.

In either the MEL or Python tab type:

print "Hello World" 
>>Hello World

To execute your code it is best to highlight the portion you want to run, then hit Control+Enter. Maya's interpreter will return Hello World and you have completed your first script.