maya
दृश्य वस्तुओं का पता लगाना

नाम से वस्तुओं का पता लगाएं

नाम से ऑब्जेक्ट्स खोजने के लिए ls() कमांड्स का उपयोग करें:

freds = cmds.ls("fred") 
#finds all objects in the scene named exactly 'fred', ie [u'fred', u'|group1|fred']

एक वाइल्डकार्ड के रूप में * प्रयोग करें:

freds = cmds.ls("fred*")
# finds all objects whose name starts with 'fred'
# [u'fred', u'frederick', u'fred2']

has_fred = cmds.ls("*fred*")
# [u'fred', u'alfred', u'fredericka']

ls () कई फ़िल्टर स्ट्रिंग तर्क लेता है:

cmds.ls("fred", "barney") 
# [u'fred', u'|group1|barney']

यह एक तर्क-वितर्क स्वीकार कर सकता है:

look_for = ['fred', 'barney']
# cmds.ls(look_for)
# [u'fred', u'|group1|barney']

एलएस () परिणामों से निपटना

फ़िल्टर के रूप में ls () का उपयोग करना कभी-कभी विषम परिणाम प्रदान कर सकता है। यदि आप गलती से कोई तर्क के साथ फ़िल्टर तर्क और कॉल ls() पास करना भूल जाते हैं, तो आपको माया दृश्य में प्रत्येक नोड की एक सूची मिलेगी:

 cmds.ls()
 # [u'time1', u'sequenceManager1', u'hardwareRenderingGlobals', u'renderPartition'...] etc

इसका एक सामान्य कारण ls() अंदर * args का उपयोग करना है ls() :

cmds.ls(["fred", "barney"]) # OK, returns ['fred', 'barney']
cmds.ls([]) # OK, returns [] 
cmds.ls(*[]) # not ok: returns all nodes!

माया 2015 और पहले

माया 2015 और उससे पहले की, ls() क्वेरी जो कुछ भी नहीं पाती है वह खाली सूची के बजाय None लौटाएगा। परिणाम का उपयोग करने के मामले में, यह एक अपवाद के परिणामस्वरूप हो सकता है:

 for item in cmds.ls("don't_exist"):
     print item
 # Error: TypeError: file <maya console> line 1: 'NoneType' object is not iterable 

इस के आसपास काम करने के लिए सबसे साफ मुहावरे हमेशा एक वैकल्पिक आउटपुट जोड़ रहे हैं जब कोई भी ls() ऑपरेशन के बाद जोड़कर or [] वापस नहीं किया जाता है। यह सुनिश्चित करेगा कि वापसी None बल्कि एक खाली सूची है:

 for item in cmds.ls("don't_exist") or []:
     print item
 # prints nothing since there's no result -- but no exception

प्रकार से वस्तुओं का पता लगाना

ls() में एक type ध्वज शामिल है, जो आपको एक विशेष प्रकार के दृश्य नोड्स खोजने देता है। उदाहरण के लिए:

 cameras = cmds.ls(type='camera')
 // [u'topShape', u'sideShape', u'perspShape', u'frontShape']

आप एक ही कॉल में कई प्रकार खोज सकते हैं:

 geometry = cmds.ls(type=('mesh', 'nurbsCurve', 'nurbsSurface'))

आप 'अमूर्त' प्रकार भी खोज सकते हैं, जो माया के आंतरिक वर्ग पदानुक्रम के अनुरूप है। ये क्या नोड प्रकार एक विशेष वस्तु का प्रतिनिधित्व करता है पता लगाने के लिए, का उपयोग nodeType आदेश:

cmds.nodeType('pCubeShape1', i=True)  # 'i' includes the inherited object types
// Result: [u'containerBase',
 u'entity',
 u'dagNode',
 u'shape',
 u'geometryShape',
 u'deformableShape',
 u'controlPoint',
 u'surfaceShape',
 u'mesh'] //
 # in this example, ls with any of the above types will return `pCubeShape1`

किसी वस्तु के मौजूद होने को देखने के लिए ls () का उपयोग करना

चूंकि ls() नामों से वस्तुओं को ढूंढता है, यह पता लगाने का एक आसान तरीका है कि क्या कोई वस्तु दृश्य में मौजूद है। ls() ऑब्जेक्ट्स की एक सूची के साथ केवल वही लौटाएगा जो दृश्य में हैं।

 available_characters = cmds.ls('fred', 'barney', 'wilma', 'dino')
 # available_characters will contain only the named characters that are present

घटक चयन के साथ काम करना

घटकों के साथ काम करते समय, जैसे कि कोने या यूवी बिंदु, माया व्यक्तिगत वस्तुओं के बजाय एक बृहदान्त्र-पृथक सीमा को वापस करने के लिए चूकता है:

 print cmds.ls('pCube1.vtx[*]')  # get all the vertices in the cube
 # [u'pCube1.vtx[0:7]']

आप माया को व्यक्तिगत घटक प्रविष्टियों में सीमा संकेतन का विस्तार करने के लिए मजबूर करने के लिए flatten विकल्प के साथ ls उपयोग कर सकते हैं:

expanded = cmds.ls('pCube1.vtx[*]', flatten=True)
print expanded
# [u'pCube1.vtx[0]', u'pCube1.vtx[1]', u'pCube1.vtx[2]', u'pCube1.vtx[3]', u'pCube1.vtx[4]', u'pCube1.vtx[5]', u'pCube1.vtx[6]', u'pCube1.vtx[7]']

लूपिंग करते समय यह फॉर्म आमतौर पर बेहतर होता है, क्योंकि आपके पास किसी भी कोड को लिखने के लिए pCube1.vtx[0:7] जैसे कई इंडिविजुअल एंट्री में लिखने की जरूरत नहीं होती है।

आप filterExpand परिणाम कमांड का उपयोग करके भी वही परिणाम प्राप्त कर सकते हैं।

सुरक्षित रूप से ls से एक ही वस्तु प्राप्त करना

कई ls() क्वेरीज़ का उद्देश्य किसी एक ऑब्जेक्ट को ढूंढना है, लेकिन ls हमेशा एक सूची (या, पुराने मेयस, एक एकल None ) देता है। यह एक साधारण प्रश्न के लिए जटिल त्रुटि जाँच बनाता है।

किसी भी परिस्थिति में एक ls से एकल मूल्य प्राप्त करने का सबसे आसान तरीका है

result = (cmds.ls('your query here') or [None])[0]

or गारंटी देता है कि कम से कम आपको एक सूची मिलेगी जिसमें कोई भी None ताकि आप इसे हमेशा अनुक्रमित कर सकें।

ध्यान दें कि यह शैली आपको यह नहीं बताएगी कि क्या आपने एक से अधिक परिणाम प्राप्त किए हैं - यह सिर्फ एक परिणाम को मानने के लिए सुरक्षित बनाता है।