पायथन का उपयोग करके एक बंद कनेक्शन की गणना करना

शुरुआत में, अपने बारे में कुछ शब्द: मैं एक इंजीनियर के रूप में काम करता हूं, इसलिए मेरा काम विभिन्न तंत्रों के डिजाइन से संबंधित है। उनमें से कई में एक महत्वपूर्ण कनेक्शन के रूप में ऐसी चीज है। और इस तथ्य के बावजूद कि वह पतन के लिए गणना करने के लिए एक बहुत ही सरल सूत्र का उपयोग करता है, मैं हर बार पेन लेने के लिए जल्दी से थक गया था और इस प्रक्रिया को स्वचालित करने के लिए एक मजबूत-इच्छाशक्ति वाला निर्णय लिया गया था।



प्रारंभ में, स्वचालन में एक तुच्छ एक्सेल फ़ाइल शामिल थी जिसमें संबंधित सूत्र "बंद" थे। लेकिन फिर एक छोटा कार्यक्रम लिखने का फैसला किया गया। इसके अलावा, इसने दो लक्ष्यों को एक साथ आगे बढ़ाया - एक अधिक सुविधाजनक "उत्पाद" प्राप्त करने के लिए और अंत में पायथन में वास्तव में उपयोगी कुछ लिखना, जिसे मैंने लंबे समय से पसंद किया है। सच है, इस क्षेत्र में मेरा ज्ञान बहुत, बहुत मामूली है, लेकिन अधिक दिलचस्प काम है।



निष्कर्ष में, एक छोटा सा सिद्धांत। कुंजी कनेक्शन की गणना करने के लिए, चित्र में दिखाए गए सूत्र का उपयोग करें। इसमें निम्नलिखित मात्राओं का उपयोग किया गया है:

• T शाफ्ट पर अभिनय करने वाला क्षण है (N * m)
• डी - शाफ्ट व्यास (मिमी)
• [सिग्मा] - अनुमेय पेराई तनाव (N / mm.kv)
• एलपी - काम की लंबाई (मिमी)
• एच - डॉवेल ऊँचाई (मिमी)
• टी - शाफ्ट पर गहराई गहराई (मिमी)

दरअसल, परिचय समाप्त हो गया है, सीधे कार्यक्रम पर जाएं। गणना एल्गोरिथ्म वास्तव में सरल है:
1. उपयोगकर्ता शाफ्ट के व्यास में प्रवेश करता है।
2. प्राप्त व्यास मूल्य के आधार पर, प्रमुख पैरामीटर निर्धारित किए जाते हैं।
3. उपयोगकर्ता हब सामग्री का चयन करता है जिस पर स्वीकार्य कतरनी तनाव निर्भर करता है।
4. उपयोगकर्ता शाफ्ट पर टोक़ अभिनय के मूल्य में प्रवेश करता है।
5. उपयोगकर्ता कुंजी लंबाई मान में प्रवेश करता है।
6. परिणाम की गणना और निष्कर्ष।
वास्तव में इस एल्गोरिथ्म में कुछ और बिंदु शामिल होने चाहिए जो मैंने निर्दिष्ट नहीं किए। यह जाँचने के बारे में है कि उपयोगकर्ता ने वास्तव में क्या दर्ज किया है (एक स्ट्रिंग या एक संख्या)।
तो, चलो आरंभिक मापदंडों को दर्ज करके शुरू करते हैं। निम्नलिखित निर्माण का उपयोग कीबोर्ड से मान दर्ज करने के लिए किया जाता है:

d = int(raw_input("   , : ")) 

इसके साथ, हम कीबोर्ड से वर्ण प्राप्त करते हैं और उन्हें स्ट्रिंग से संख्या में परिवर्तित करते हैं। ऐसा लगता है कि सब कुछ सरल है। हालांकि, विचारशील प्रतिबिंब के बाद, मैंने इस कोड को थोड़ा जटिल करने का फैसला किया:

 while 1: try: d = int(raw_input("   , : ")) break except ValueError: print ("  !") 

नतीजतन, प्रोग्राम खुद को नियंत्रित करता है कि उपयोगकर्ता क्या दर्ज करता है - एक संख्या या एक स्ट्रिंग। और दूसरे मामले में, यह एक उपयुक्त चेतावनी देता है। एक अनंत लूप का उपयोग उपयोगकर्ता द्वारा आवश्यक डेटा को जल्दी या बाद में प्राप्त करने के लिए किया जाता है। इसी तरह की तकनीक का उपयोग करते हुए, प्रोग्राम को बाकी की ज़रूरतों को भी प्राप्त होता है, तुरंत उन्हें शुद्धता के लिए जाँचना।
हम कुंजी के मापदंडों को निर्धारित करने के लिए आगे बढ़ते हैं। यहाँ, दुर्भाग्यवश, मैं अपेक्षाकृत अधिक लंबी सूची का उपयोग करने की तुलना में होशियार नहीं हुआ, अगर - एलीफ - और:

 if 6 <= d < 8: shponka = {"b": 2, "h": 2, "t1": 1.2, "t2": 1.0} elif 8 <= d < 10: shponka = {"b": 3, "h": 3, "t1": 1.8, "t2": 1.4} elif 10 <= d < 12: shponka = {"b": 4, "h": 4, "t1": 2.5, "t2": 1.8} elif 12 <= d < 17: shponka = {"b": 5, "h": 5, "t1": 3.0, "t2": 2.3} elif 17 <= d < 22: shponka = {"b": 6, "h": 6, "t1": 3.5, "t2": 2.8} elif 22 <= d < 30: shponka = {"b": 8, "h": 7, "t1": 4.0, "t2": 3.3} elif 30 <= d < 38: shponka = {"b": 10, "h": 8, "t1": 5.0, "t2": 3.3} elif 38 <= d < 44: shponka = {"b": 12, "h": 8, "t1": 5.0, "t2": 3.3} elif 44 <= d < 50: shponka = {"b": 14, "h": 9, "t1": 5.5, "t2": 3.8} elif 50 <= d < 58: shponka = {"b": 16, "h": 10, "t1": 6.0, "t2": 4.3} elif 58 <= d < 65: shponka = {"b": 18, "h": 11, "t1": 7.0, "t2": 4.4} elif 65 <= d < 75: shponka = {"b": 20, "h": 12, "t1": 7.5, "t2": 4.9} elif 75 <= d < 85: shponka = {"b": 22, "h": 14, "t1": 9.0, "t2": 5.4} elif 85 <= d < 95: shponka = {"b": 25, "h": 14, "t1": 9.0, "t2": 5.4} elif 95 <= d < 110: shponka = {"b": 28, "h": 16, "t1": 10.0, "t2": 6.4} elif 110 <= d < 130: shponka = {"b": 32, "h": 18, "t1": 11.0, "t2": 7.4} else: print("         ") raw_input("    ") exit() print ("  = " + str(shponka["b"]) + " ,   = " + str(shponka["h"]) + " ,     = " + str(shponka["t1"]) + " ,     = " + str(shponka["t2"]) + " ") 

प्रमुख मापदंडों को शब्दकोश में लिखा गया है - मुझे यह प्रतीत हुआ कि इस तरह से उनके साथ काम करना आसान होगा। अब हम कुंजी की कार्य अवधि निर्धारित करते हैं:

 l_work = l - shponka["b"] 

और फिर वास्तविक कुचल तनाव:

 napr = (2 * 1000 * moment) / (d * l_work * (shponka["h"] - shponka["t1"])) 

कतरनी तनाव का प्राप्त मूल्य अनुमेय मूल्य के साथ तुलना की जाती है। दो विकल्प यहां संभव हैं:
1. अनुमेय वोल्टेज मान से अधिक नहीं है, जिसका अर्थ है कि चयनित कुंजी हमें संतुष्ट करती है।
2. अनुमेय वोल्टेज मान पार हो गया है। यह जानना अच्छा होगा कि इसे कैसे ठीक किया जाए। ज्यादातर मामलों में, ऐसा करने का सबसे आसान तरीका कुंजी की लंबाई को बदलना है। इसलिए, कार्यक्रम इस तथ्य के आधार पर कुंजी की लंबाई को फिर से बताता है कि कतरनी तनाव अनुमेय की तुलना में 20 यूनिट कम है (आमतौर पर यह पर्याप्त है)।
पायथन में, यह इस तरह दिखेगा:

 if napr <= dopysk_napr: print("     " + str(napr) + " /^2.    " + str(dopysk_napr) + " /^2.") raw_input("    ") exit() else: print("      !       !") #     l_work_rek = (2 * 1000 * moment) / ((dopysk_napr - 20) * d * (shponka["h"] - shponka["t1"])) #       l_rek = l_work_rek + shponka["b"] #      napr_rek = (2 * 1000 * moment) / (d * l_work_rek * (shponka["h"] - shponka["t1"])) print("    " + str(l_rek) + " .      " + str(napr_rek) + " /^2.") raw_input("    ") exit() 

और अंत में, पूरा कार्यक्रम कोड:

 # -*- coding: cp866 -*- #       (  ) while 1: try: d = int(raw_input("   , : ")) break except ValueError: print ("  !") #,        if 6 <= d < 8: shponka = {"b": 2, "h": 2, "t1": 1.2, "t2": 1.0} elif 8 <= d < 10: shponka = {"b": 3, "h": 3, "t1": 1.8, "t2": 1.4} elif 10 <= d < 12: shponka = {"b": 4, "h": 4, "t1": 2.5, "t2": 1.8} elif 12 <= d < 17: shponka = {"b": 5, "h": 5, "t1": 3.0, "t2": 2.3} elif 17 <= d < 22: shponka = {"b": 6, "h": 6, "t1": 3.5, "t2": 2.8} elif 22 <= d < 30: shponka = {"b": 8, "h": 7, "t1": 4.0, "t2": 3.3} elif 30 <= d < 38: shponka = {"b": 10, "h": 8, "t1": 5.0, "t2": 3.3} elif 38 <= d < 44: shponka = {"b": 12, "h": 8, "t1": 5.0, "t2": 3.3} elif 44 <= d < 50: shponka = {"b": 14, "h": 9, "t1": 5.5, "t2": 3.8} elif 50 <= d < 58: shponka = {"b": 16, "h": 10, "t1": 6.0, "t2": 4.3} elif 58 <= d < 65: shponka = {"b": 18, "h": 11, "t1": 7.0, "t2": 4.4} elif 65 <= d < 75: shponka = {"b": 20, "h": 12, "t1": 7.5, "t2": 4.9} elif 75 <= d < 85: shponka = {"b": 22, "h": 14, "t1": 9.0, "t2": 5.4} elif 85 <= d < 95: shponka = {"b": 25, "h": 14, "t1": 9.0, "t2": 5.4} elif 95 <= d < 110: shponka = {"b": 28, "h": 16, "t1": 10.0, "t2": 6.4} elif 110 <= d < 130: shponka = {"b": 32, "h": 18, "t1": 11.0, "t2": 7.4} else: print("         ") raw_input("    ") exit() print ("  = " + str(shponka["b"]) + " ,   = " + str(shponka["h"]) + " ,     = " + str(shponka["t1"]) + " ,     = " + str(shponka["t2"]) + " ") #       while 1: try: material = raw_input("   :  (1)   (2). ") break except ValueError: print ("     ,   .") if material == "1": dopysk_napr = 130 #  /^2 elif material == "2": dopysk_napr = 80 #  /^2 else: print("   !") raw_input("    ") exit() #          while 1: try: moment = int(raw_input("       : ")) break except ValueError: print ("       !") #        while 1: try: l = int(raw_input("     : ")) break except ValueError: print ("  !") #    (,     ) l_work = l - shponka["b"] #           napr = (2 * 1000 * moment) / (d * l_work * (shponka["h"] - shponka["t1"])) if napr <= dopysk_napr: print("     " + str(napr) + " /^2.    " + str(dopysk_napr) + " /^2.") raw_input("    ") exit() else: print("      !       !") #     l_work_rek = (2 * 1000 * moment) / ((dopysk_napr - 20) * d * (shponka["h"] - shponka["t1"])) #       l_rek = l_work_rek + shponka["b"] #      napr_rek = (2 * 1000 * moment) / (d * l_work_rek * (shponka["h"] - shponka["t1"])) print("    " + str(l_rek) + " .      " + str(napr_rek) + " /^2.") raw_input("    ") exit() 

इस पर, इस कार्यक्रम पर मेरा काम सबसे अधिक संभावना नहीं है, क्योंकि मुझे वास्तव में पायथन पसंद है और मेरे काम में इसका आवेदन वास्तव में संभव है (कम से कम समान कंपास स्क्रिप्ट के लिए)। भविष्य में मेरे पास कई अतिरिक्त गणना मोड जोड़ने की योजना है, जो इस बात पर निर्भर करता है कि क्या निर्धारित किया जाना है। ठीक है, बहुत दूर के भविष्य में, एक उपयोगकर्ता इंटरफ़ेस दिखाई दे सकता है।
मैं यह भी समझता हूं कि इस मामूली काम के साथ, मैं झूठ बोल रहा हूं कि क्या मैं आदरणीय जनता को आश्चर्यचकित करूंगा लेकिन मुझे समझ है और (संभवतः) सुधार के लिए सिफारिशें।