आंतरिक क्रियाएं

पायथन भाषा में अनेक आंतरिक क्रियाएं उपलब्ध है. उनमें से हिंदी आवृत्ति में भी कुछ क्रियाएं उपलब्ध है. उनकी सूची इस प्रकार है.

अंक()

कोश()

नकशा()

रचना()

अक्षर()

क्रमण()

न्यूनतम()

लंबाई()

अक्षरमूल्य()

खोले()

पता()

वस्तु()

अगला()

घात()

पुर्जे()

षोडश()

अधिकतम()

चल()

फैलाव()

संमिश्र()

अष्टम()

छानना()

बाईट()

समुच्चय()

आगत()

छापे()

बाईटविन्यास()

सरकबंद()

उल्टा()

टुकड़ा()

बिन()

सूची()

एकयंत्र()

तैरताबिंदु()

माला()

स्थूलांकन()

केवल()

द्वैत()

योग()


अंक(क, *आधार)

दिए हुए आगत ‘क’ का पूर्णांक में परिवर्तन करना. ‘क’ कोई शब्दमाला हो सकती है या कोई तैरता बिंदु अंक हो सकता है. आधार यह आगत आवश्यक नही है. इसके ना होते इसका मूल्य 10 माना जाता है.

>>> अंक(2.5)
2
>>> अंक('123')
123
>>> अंक('10111001', 2)
185
>>> अंक('FF', 16)
255

^

अक्षर(क)

दिए हुए अंक का यूनिकोड पद्धतिसे अक्षर में परिवर्तन करे और लौटाए.

>>> अक्षर(2309)
'अ'
>>> अक्षर(97)
'a'
>>> अक्षर(66)
'B'

^

अक्षरमूल्य(क)

दिए हुए अक्षर का यूनिकोड पद्धतिसे अंक में परिवर्तन करे और लौटाए.

>>> अक्षरमूल्य('क')
2325
>>> अक्षरमूल्य('A')
65
>>> अक्षरमूल्य('?')
63

^

अगला(एकयंत्र, अंत)

इस क्रिया का उपयोग करके एकयंत्र का अगला मूल्य लौटाया जाता है. यंत्र खाली होने पर ‘अंत’ यह मूल्य लौटाया जाता है.

>>> क = [1,2,3]
>>> ख = एकयंत्र(क)
>>> अगला(ख, -1)
1
>>> अगला(ख, -1)
2
>>> अगला(ख, -1)
3
>>> अगला(ख, -1)
-1

^

अधिकतम(सूची)

अधिकतम(क, ख)

अधिकतम इस क्रिया का दो तरह से उपयोग किया जा सकता है. यदि आगत एक सूची है तो इस सूची का सबसे बड़ा मूल्य लौटाया जाता है. यदि आगत केवल दो मूल्य है तो दोनों में से सबसे बड़ा मूल्य लौटाया जाता है.

>>> अधिकतम([1,9,4,2,8,5])
9
>>> अधिकतम(['त', 'प', 'ड', 'स', 'म'])
'स'
>>> अधिकतम(23, 11.7)
23
>>> अधिकतम(['कि', 'कै', 'को' ])
'को'

^

अष्टम(क)

दिए हुए अंक का अष्टम यानी संख्या 8 के आधार वाले अंक में परिवर्तन करे. अष्टम अंकों की शुरुआत ‘0o’ (शून्य और अंग्रेजी अक्षर ‘o’) से की जाती है.

>>> अष्टम(22)
'0o26'
>>> अष्टम(40)
'0o50'

^

आगत(आवेदन)

आगत क्रिया के लिए ‘आवेदन’ आवश्यक नहीं है. आगत क्रिया अगली पंक्ति पर आवेदन प्रस्तुत करती है तथा मिला हुआ उत्तर शब्दमाला के रूप में जमा करती है.

>>> क = आगत('क के लिये मूल्य दे : ')
क के लिये मूल्य दे : 25
>>> क
'25'
>>> प = आगत('प के लिये मूल्य दे : ')
प के लिये मूल्य दे : नमस्ते
>>> प
'नमस्ते'

^

उल्टा(क्रम)

दिए हुए क्रम आधारित वस्तु का क्रम उल्टाया जाता है तथा एक नया निर्माता लौटाया जाता है

>>> क = [1,2,3]
>>> ख = उल्टा(क)
>>> सूची(ख)
[3, 2, 1]

यहां ‘क’ एक सूची है. ‘ख’ एक निर्माता है. ‘ख’ पर सूची यह क्रिया करके एक नई सूची तैयार की जाती है, इस सूची का क्रम ‘क’ के क्रम का उल्टा है

^

एकयंत्र(क्रम)

दिए हुए क्रम आधारित वस्तु का एकयंत्र तैयार करे. एकयंत्र का फायदा यह है कि इसके घटकों पर एक-एक करके क्रिया की जा सकती है.

>>> क = [1,2,3]
>>> ख = एकयंत्र(क)
>>> अगला(ख, -1)
1
>>> अगला(ख, -1)
2

^

केवल(क)

दी हुई संख्या का केवल मूल्य लौटाए. ‘क’ एक अंक अथवा तैरता बिंदु हो सकता है. यदि ‘क’ एक संमिश्र संख्या है तो उसका मापक लौटाया जाता है.

>>> केवल(16)
16
>>> केवल(-7)
7
>>> केवल(3+4j)
5.0

^

कोश()

इस क्रिया का उपयोग करके एक नया कोश तैयार किया जाता है.

^

क्रमण(सूची, *घटन)

क्रमण इस क्रिया से दी हुई सूची के घटक बढ़ते क्रम में लगाए जाते हैं. इस क्रिया का दूसरा आगत है घटन. घटन यह आगत आवश्यक नहीं है. यदि गठन का मूल्य 0 है तो घटकों का क्रम बढ़ता है, यदि घटन का मूल्य एक या उससे ज्यादा है तो घटकों का क्रम कम होने वाला है.

>>> क = [1,9,4,2,8,5]
>>> क्रमण(क)
[1, 2, 4, 5, 8, 9]
>>> क्रमण(क, 0)
[1, 2, 4, 5, 8, 9]
>>> क्रमण(क, 1)
[9, 8, 5, 4, 2, 1]

^

खोले(फाइलनाम, पद्धति, कोडपद्धति)

“फाइलनाम” नाम की फाइल दी गई पद्धति से खोले. पद्धति फैसला करती है की फाइल सिर्फ पढ़ने के लिए खोले या फाइल में बदलाव भी करे.

पद्धति को दिए हुए अक्षरों से स्पष्ट किया जाता है.

अक्षर

अर्थ

‘प’

पढ़े

‘न’

नई

‘ल’

लिखे

‘ज’

जोड़े

‘ब’

बायनरी

‘+’

बदलाव

पद्धति यह आगत ना हो तो फाइल सिर्फ पढ़ने के लिए खोली जाती है.

‘ल’ पद्धति से खोली हुई फ़ाइल शुरुआत में खाली होती है. यह फाइल पढ़ने पर कुछ लौटाया नहीं जाता. ‘न’ से एक नई फाइल तैयार की जाती है. यदि इस नाम की फाइल पहले से ही मौजूद हो तो ‘फाईलहाजिरदोष’ लौटाया जाता है. ‘ज’ का उपयोग करके मौजूद फाइल के अंत में लिखा जा सकता है. ‘ब’ का उपयोग करके फाइल में सीधे बाईट लिखे जा सकते हैं. ‘+’ का उपयोग ‘प’ के साथ करके फाइल पढ़ी तथा लिखी जा सकती है.

>>> फ = खोले('प्रयोग.ट', 'न')
>>> फ.लिखे('नमस्कार आप का स्वागत है')
23
>>> फ.बंद()
>>> फ = खोले('प्रयोग.ट', 'न')
सावधान : फाईलहाजिरदोष
>>> फ = खोले('प्रयोग.ट', 'प')
>>> फ.पढ़े()
'नमस्कार आप का स्वागत है'

^

घात(आधार, घातमूल्य, मॉड)

इस क्रिया का उपयोग करके दिए हुए आधार अंक का घातांक गिना जाता है.

>>> घात(4, 2)
16
>>> घात(25, 0.5)
5.0

यहां एक तीसरा आगत है जो आवश्यक नहीं है. यदि तीसरा आगत हाजिर है तो जवाब में घातांक को मॉड से भाग कर बचा हुआ भाग लौटाया जाता है.

>>> घात(4, 2, 5)
1

^

चल()

इस्तेमाल होने वाले हिंदी भाषा के सर्व चलों का कोश लौटाए.

>>> क = 1
>>> ख = 2
>>> ग = क + ख
>>> चल()
{'क': 1, 'ख': 2, 'ग': 3}

^

छानना(क्रिया, सूची)

इस क्रिया का उपयोग करके दी हुई सूची के घटक दी हुई क्रिया के अनुसार छाने जा सकते हैं. यह क्रिया एक निर्माता लौटाती है. इस निर्माता का उपयोग करके एक नई सूची तैयार की जा सकती है.

>>> घोषित अधिक4(क):
+++     अगर क > 4:
+++             लौटाए सत्य
+++     लौटाए असत्य
+++
>>>
>>> संख्या = [1,2,3,4,5,6,7,8,9]
>>>
>>> ख = छानना(अधिक4, संख्या)
>>> सूची(ख)
[5, 6, 7, 8, 9]

इस उदाहरण में हमने प्रथम एक क्रिया घोषित की है. फिर इस क्रिया का उपयोग करके दी हुई सूची के अंक छाने गए है.

^

छापे(*वस्तु)

इस क्रिया का उपयोग करके दी हुई वस्तु को छापा जाता है.

>>> क = [1,2,3,4]
>>> ख = 'नमस्ते'
>>> प = चल()
>>> छापे(क, ख, प)
[1, 2, 3, 4] नमस्ते {'क': [1, 2, 3, 4], 'ख': 'नमस्ते', 'ग': 3}

^

टुकड़ा(शुरुआत, अंत, *अंतर)

इस क्रिया से किसी सूची या शब्दमाला का टुकड़ा अलग किया जा सकता है. यहां हम टुकड़े की शुरुआत, अंत और बीच का अंतर दे सकते हैं. अंतर आवश्यक आगत नहीं है. अंतर न होने पर 1 माना जाता है.

>>> क = [0,1,2,3,4,5,6,7,8,9]
>>> ख = टुकड़ा(3,6)
>>> क[ख]
[3, 4, 5]
>>> ख = टुकड़ा(3,8,2)
>>> क[ख]
[3, 5, 7]

^

तैरताबिंदु(क)

दी हुई शब्दमाला का तैरताबिंदु अंक में परिवर्तन करे. ऐसे अंको का त्वरित इस्तेमाल हो सकता है जैसा हम उदाहरण में देखते है.

>>> तैरताबिंदु('1e-3')
0.001
>>> तैरताबिंदु('+1.25')
1.25
>>> तैरताबिंदु('+1.25') * 8
10.0

^

बिन(क)

द्वैत(क)

इस क्रिया का उपयोग करके दी हुई संख्या का बाइनरी अथवा द्वैत संख्या में परिवर्तन किया जाता है ह. द्वैत संख्या लिखने के लिए 0 और 1 इन दो आंकड़ों का उपयोग किया जाता है. इस संख्या की शुरुआत में ‘0’ तथा अंग्रेजी अक्षर ‘b’ लिखे जाते है.

>>> द्वैत(7)
'0b111'
>>> बिन(7)
'0b111'

^

नकशा(आगतक्रिया, क, *ख)

इस क्रिया के पहले दो आगत आवश्यक है. पहला आगत है एक क्रिया और दूसरा आगत है एक सूची अथवा शब्दमाला. यहां आगतक्रिया को आगे की वस्तु के सभी घटकों पर एक-एक करके इस्तेमाल किया जाता है. यह क्रिया एक नया निर्माता लौटाती है.

>>> घोषित अधिक(क , ख):
+++     लौटाए क + ख
+++
>>> त = [2,3,4,5,6,7]
>>> थ = [9,8,7,6,5,4]
>>> प = नकशा(अधिक, त, थ)
>>> सूची(प)
[11, 11, 11, 11, 11, 11]

^

न्यूनतम(सूची)

न्यूनतम(क, ख)

न्यूनतम इस क्रिया का दो तरह से उपयोग किया जा सकता है. यदि आगत एक सूची है तो इस सूची का सबसे छोटा मूल्य लौटाया जाता है. यदि आगत केवल दो मूल्य है तो दोनों में से सबसे छोटा मूल्य लौटाया जाता है.

>>> न्यूनतम([1,9,4,2,8,5])
1
>>> न्यूनतम(['त', 'प', 'ड', 'स', 'म'])
'ड'
>>> न्यूनतम(23, 11.7)
11.7
>>> न्यूनतम(['कि', 'कै', 'को' ])
'कि'

^

पता(क)

दिए गए वस्तु का पता बताएं. पता याने मेमरी में वह जगह जहां यह वस्तु लिखी गई है.

>>> त = [2,3,4,5,6,7]
>>> पता(त)
2581959456384

^

पुर्जे(क)

दी गई वस्तु के गुणधर्मों की सूची लौटाए.

>>> आयात गणित उर्फ ग
>>> पुर्जे(ग)
['अंश', 'आकॉस', 'आकॉसह', 'आटॅन', 'आटॅन2', 'आटॅनह', 'आसाईन', 'आसाईनह', 'ई', 'कॉस', 'कॉसह', 'कोज', 'क्रमगुणित', 'गॅमा', 'घनमूल', 'घातांक', 'घातांक2', 'छत', 'जमीन', 'ज्या', 'टाऊ', 'टॅनह', 'पाय', 'मस', 'मूल', 'रेडियन', 'लगॅमा', 'लस', 'लॉग', 'लॉग10', 'लॉग2', 'समूल', 'साईन', 'साईनह', 'स्पर']

^

फैलाव(अंत)

फैलाव(शुरुआत, अंत, अंतर)

इस क्रिया का उपयोग करके एक नया निर्माता तैयार किया जाता है. यह निर्माता शुरुआत और अंत इन दो संख्याओं के बीच में सभी संख्याओं की एक सूची तैयार करता है. यदि चाहे तो संख्याओं का अंतर एक से अलग भी रखा जा सकता है.

>>> क = फैलाव(5)
>>> सूची(क)
[0, 1, 2, 3, 4]
>>> क = फैलाव(2,5)
>>> सूची(क)
[2, 3, 4]
>>> क = फैलाव(0,14,3)
>>> सूची(क)
[0, 3, 6, 9, 12]
>>> क = फैलाव(10, 1)
>>> सूची(क)
[]

^

बाईट(शब्दमाला, कोडपद्धति)

इस क्रिया का उपयोग करके शब्दमाला को बाईट में परिवर्तन किया जाता है. यहां कोडपद्धति आवश्यक है. बाईट इस वास्तुप्रकार में बदलाव नहीं किया जा सकता. यदि ऐसा करना है तो बाईटविन्यास का उपयोग करे.

>>> क = बाईट('कखग', 'utf-8')
>>> क
b'\xe0\xa4\x95\xe0\xa4\x96\xe0\xa4\x97'
>>> क[0]
224
>>> क[0] = 223
सावधान : वस्तुप्रकारदोष

^

बाईटविन्यास(शब्दमाला, कोडपद्धति)

इस क्रिया का उपयोग करके शब्दमाला को बाईटविन्यास में परिवर्तन किया जाता है. यहां कोडपद्धति आवश्यक है. बाईटविन्यास इस वास्तुप्रकार में बदलाव किया जा सकता है.

>>> क = बाईटविन्यास('कखग', 'utf-8')
>>> क
bytearray(b'\xe0\xa4\x95\xe0\xa4\x96\xe0\xa4\x97')
>>> क[0]
224
>>> क[0] = 223
>>> क
bytearray(b'\xdf\xa4\x95\xe0\xa4\x96\xe0\xa4\x97')

^

माला(क, कोडपद्धति)

इस क्रिया का उपयोग करके बाईट अथवा बाईटविन्यास वस्तुओं का शब्दमाला में परिवर्तन किया जा सकता है. यहां एक कोड पद्धति आवश्यक है.

>>> क = बाईटविन्यास('कखग', 'utf-8')
>>> माला(क, 'utf-8')
'कखग'

^

योग(क)

इस क्रिया से दी हुई सूची के सभी घटकों का योग निकाला जाता है.

>>> क = [3,4,5,6,7]
>>> योग(क)
25

^

रचना(मूल्य, पद्धति)

इस क्रिया का उपयोग करके दिए हुए अंक या तैरतेबिंदु को दी हुई पद्धति का उपयोग करके शब्दमाला मे परिवर्तन किया जाता है. पद्धति को भी एक शब्दमाला के रूप में प्रस्तुत किया जाता है. पद्धति यह नीचे दिए हुए तीन घटको के उपयोग से तैयार की जाती है.

.(अंक)

अअंक यह मूल्य दशांश के बाद की लंबाई देता है.

e

‘e’ - इस अक्षर का उपयोग करके आंक को वैज्ञानिक पद्धति से दिखाया जाता है.

f

‘f’ - इस अक्षर का उपयोग करके अंक का तैरतेबिंदु में परिवर्तन किया जाता है.

ऊपर दिए हुए तीन घटकों मे से दो का उपयोग करके विविध प्रकार की शब्दमालाए तैयार की जा सकती है.


^

लंबाई(क)

दी हुई वस्तु में घटकों की संख्या लौटाए. इस वस्तु की लंबाई कहते है.

>>> क = [3,4,5,6,7]
>>> लंबाई(क)
5

^

वस्तु()

इस क्रिया से एक नई खाली वस्तु तैयार की जा सकती है. इस वस्तु के कोई विशेष गुणधर्म नहीं होते.

>>> क = वस्तु()

^

षोडश(क)

दिए हुए अंक को षोडश मतलब 16 के आधार वाले अंक में परिवर्तन करे. षोडश अंक शुरुआत में ‘0x’ (शून्य और अंग्रेजी अक्षर ‘x’) से लिखे जाते है.

>>> षोडश(50)
'0x32'

^

संमिश्र(क)

इस क्रिया का उपयोग करके शब्दमाला को समिश्रा संख्याओं में परिवर्तन किया जाता है.

>>> क = संमिश्र('1+1j')
>>> ख = संमिश्र('-1+2j')
>>> क
(1+1j)
>>> ख
(-1+2j)
>>> क + ख
3j
>>> क * ख
(-3+1j)

^

समुच्चय(क)

दी हुई वस्तु का सच में परिवर्तन करे. इससे समुच्चय की क्रियाओं का उपयोग किया जा सकता है.

>>> क = समुच्चय([1,2,3,4,5])
>>> क
{1, 2, 3, 4, 5}
>>> ख = समुच्चय([3,4,5,6,7])
>>> ख
{3, 4, 5, 6, 7}
>>> क._सर्वनिष्ठ(ख)
{3, 4, 5}

^

सरकबंद(*क)

इस क्रिया का उपयोग करके दी हुई सूचियों के पहले, दूसरे इत्यादि संख्याओं के टुपलों की सूची बनाई जाती है. यह क्रिया एक निर्माता लौटाती है.

>>> क = [1,2,3]
>>> ख = ['प', 'फ', 'ब']
>>> त = सरकबंद(क, ख)
>>> सूची(त)
[(1, 'प'), (2, 'फ'), (3, 'ब')]

^

सूची(क)

दिए हुए निर्माता का सूची में परिवर्तन करे.

>>> क = फैलाव(5)
>>> सूची(क)
[0, 1, 2, 3, 4]

^

स्थूलांकन(क, लांबी)

दी हुई संख्या का दी हुई लंबाई तक स्थूलांकन करे. यदि लंबाई ना हो तो संख्या का नजदीकी अंक लौटाया जाता है.

>>> आयात गणित उर्फ ग
>>> ग.पाय
3.141592653589793
>>> स्थूलांकन(ग.पाय, 4)
3.1416
>>> स्थूलांकन(ग.पाय)
3
>>>

^