%: ಊಹೆಯ ಆಟದಲ್ಲಿ 'ಗಣಿತ'

Mia Chevalier

ಬುಧವಾರ, ಅಕ್ಟೋಬರ್ 23, 2024 06:51:01 ಅಪರಾಹ್ನ

ಇಂಟರಾಕ್ಟಿವ್ ಗೆಸ್ಸಿಂಗ್ ಗೇಮ್ ಅನ್ನು ನಿರ್ಮಿಸುವಾಗ ಸಾಮಾನ್ಯ ಪೈಥಾನ್ ದೋಷ

ಪೈಥಾನ್ ಅನ್ನು ಕಲಿಯುವಾಗ, ಅತ್ಯಂತ ರೋಮಾಂಚಕಾರಿ ಯೋಜನೆಗಳಲ್ಲಿ ಒಂದಾದ ಸಂವಾದಾತ್ಮಕ ಆಟಗಳನ್ನು ನಿರ್ಮಿಸುವುದು ಸಂಖ್ಯೆ ಊಹೆಯ ಆಟ. ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಪೈಥಾನ್ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂನ ನಡವಳಿಕೆಯನ್ನು ಮಾರ್ಗದರ್ಶನ ಮಾಡಲು ನಿಯಂತ್ರಣ ಹರಿವನ್ನು ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇಂತಹ ಯೋಜನೆಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪೈಥಾನ್ 1 ಮತ್ತು 100 ರ ನಡುವಿನ ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಲು ಬಳಕೆದಾರರನ್ನು ಪ್ರೇರೇಪಿಸುತ್ತದೆ, ಹೆಚ್ಚಿನ ಅಥವಾ ಕಡಿಮೆ ಊಹಿಸಲು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಸರಿಯಾದ ಊಹೆಯನ್ನು ಮಾಡಿದಾಗ ದೃಢೀಕರಿಸುವುದು.

ಆದಾಗ್ಯೂ, ಅನೇಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ವ್ಯಾಯಾಮಗಳಂತೆ, ತಕ್ಷಣವೇ ಸ್ಪಷ್ಟವಾಗಿಲ್ಲದ ದೋಷಗಳು ಉಂಟಾಗಬಹುದು. ನೀವು ಕೆಲಸ ಮಾಡುತ್ತಿರುವಂತಹ ಪೈಥಾನ್ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಅನುಸರಿಸುವಾಗ ನೀವು ಎದುರಿಸಬಹುದಾದ ಒಂದು ದೋಷವೆಂದರೆ % ಗಾಗಿ ಬೆಂಬಲಿಸದ ಒಪೆರಾಂಡ್ ಪ್ರಕಾರ(ಗಳು): 'ಮ್ಯಾಥ್' ಮತ್ತು 'ಟುಪಲ್'. ಇದು ನಿರಾಶಾದಾಯಕವಾಗಿರಬಹುದು, ವಿಶೇಷವಾಗಿ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮೊದಲ ನೋಟದಲ್ಲಿ ಸರಿಯಾಗಿ ಕಂಡುಬಂದಾಗ.

ಈ ಊಹೆಯ ಆಟದಲ್ಲಿ, ನೀವು ಬಳಸುವಾಗ ತಪ್ಪಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಾಗ ನೀವು ಎದುರಿಸುತ್ತಿರುವ ದೋಷವು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ ಗಣಿತ ನಲ್ಲಿ ಕಾರ್ಯ IPython.display ಗ್ರಂಥಾಲಯ. ಇದು ಸಾಮಾನ್ಯ ತಪ್ಪು, ಆದರೆ ಒಮ್ಮೆ ಗುರುತಿಸಿದ ನಂತರ ಪರಿಹಾರವು ನೇರವಾಗಿರುತ್ತದೆ.

ದೋಷದ ಅರ್ಥವೇನು, ಅದು ಏಕೆ ಸಂಭವಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಸರಿಪಡಿಸಲು ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ನೀವು ಹೇಗೆ ಮಾರ್ಪಡಿಸಬಹುದು ಎಂಬುದರ ಮೂಲಕ ಈ ಮಾರ್ಗದರ್ಶಿ ನಿಮಗೆ ತಿಳಿಸುತ್ತದೆ. ಕೊನೆಯಲ್ಲಿ, ನೀವು ಗೊಂದಲಮಯ ದೋಷ ಸಂದೇಶವಿಲ್ಲದೆ ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಊಹೆಯ ಆಟವನ್ನು ಹೊಂದಿರುತ್ತೀರಿ!

ಆಜ್ಞೆ	ಬಳಕೆಯ ಉದಾಹರಣೆ
random.randint()	ನಿಂದ ಈ ಕಾರ್ಯ ಯಾದೃಚ್ಛಿಕ ಲೈಬ್ರರಿಯು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಪೂರ್ಣಾಂಕವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಊಹಿಸುವ ಆಟದಲ್ಲಿ, ಬಳಕೆದಾರರಿಗೆ ಊಹಿಸಲು 1 ಮತ್ತು 100 ರ ನಡುವೆ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯನ್ನು ಉತ್ಪಾದಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ: random.randint(1, 100).
IPython.display.Math()	ನಿಂದ ಈ ಆಜ್ಞೆ IPython.display ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ರೀತಿಯಲ್ಲಿ ಗಣಿತದ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಪರಿಹಾರದಲ್ಲಿ, ಸರಿಯಾದ ಸಂಖ್ಯೆ ಮತ್ತು ಬಳಕೆದಾರರ ಊಹೆಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ಔಟ್‌ಪುಟ್ ಅನ್ನು ಫಾರ್ಮಾಟ್ ಮಾಡಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆ: ಗಣಿತ(f'ಅಭಿನಂದನೆಗಳು! ಸರಿಯಾದ ಸಂಖ್ಯೆಯು {a}' ಆಗಿತ್ತು).
unittest.mock.patch()	ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ಅಣಕು ಆವೃತ್ತಿಯೊಂದಿಗೆ ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿನ ಕಾರ್ಯ ಅಥವಾ ವಸ್ತುವನ್ನು ಬದಲಾಯಿಸಲು ಈ ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಹಸ್ತಚಾಲಿತ ಸಂವಹನವಿಲ್ಲದೆ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಅನುಕರಿಸಲು ಘಟಕ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆ: @patch('builtins.input', side_effect=[50, 75, 85, 95, 100]).
unittest.TestCase	ನಲ್ಲಿ ಒಂದು ಮೂಲ ವರ್ಗ ಏಕಪರೀಕ್ಷೆ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ರಚಿಸಲು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ನಿರೀಕ್ಷೆಯಂತೆ ವರ್ತಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವೈಯಕ್ತಿಕ ಕಾರ್ಯಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಇದು ಚೌಕಟ್ಟನ್ನು ಒದಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ವರ್ಗ TestGuessingGame(unittest.TestCase).
continue	ಈ ನಿಯಂತ್ರಣ ಹರಿವಿನ ಆಜ್ಞೆಯನ್ನು ಪ್ರಸ್ತುತ ಪುನರಾವರ್ತನೆಯನ್ನು ಬಿಟ್ಟು ಮುಂದಿನದಕ್ಕೆ ಹೋಗಲು ಲೂಪ್‌ಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಅಮಾನ್ಯವಾದ ಇನ್‌ಪುಟ್‌ನಿಂದ ಮೌಲ್ಯದೋಷವನ್ನು ಹಿಡಿದ ನಂತರ ಪ್ರೋಗ್ರಾಂ ಮುಂದುವರಿಯುತ್ತದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ಮುಂದುವರಿಸಿ.
try-except	ದೋಷ ನಿರ್ವಹಣೆಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಈ ರಚನೆಯು ಒಂದು ವಿನಾಯಿತಿಯನ್ನು ಹೆಚ್ಚಿಸಿದಾಗಲೂ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಾಲನೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಊಹಿಸುವ ಆಟದಲ್ಲಿ, ಪೂರ್ಣಾಂಕಗಳನ್ನು ನಮೂದಿಸದ ಬಳಕೆದಾರರಿಂದ ಅಮಾನ್ಯವಾದ ಇನ್ಪುಟ್ ಅನ್ನು ಇದು ನಿರ್ವಹಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ಪ್ರಯತ್ನಿಸಿ: ... ಮೌಲ್ಯ ದೋಷ ಹೊರತುಪಡಿಸಿ:.
input()	ಈ ಕಾರ್ಯವು ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನಂತೆ ಸೆರೆಹಿಡಿಯುತ್ತದೆ. ಊಹಿಸುವ ಆಟದಲ್ಲಿ, ಬಳಕೆದಾರರನ್ನು ತಮ್ಮ ಊಹೆಯನ್ನು ನಮೂದಿಸಲು ಪ್ರೇರೇಪಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇನ್ಪುಟ್ ಅನ್ನು ನಂತರ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ: user_guess = int(ಇನ್‌ಪುಟ್ ('1 ಮತ್ತು 100 ನಡುವಿನ ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಿ:')).
f-string	ಪೈಥಾನ್ 3.6 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾಗಿದೆ, ಎಫ್-ಸ್ಟ್ರಿಂಗ್ಸ್ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಎಂಬೆಡ್ ಮಾಡುವ ಮೂಲಕ ಸುಲಭವಾದ ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಅನುಮತಿಸಿ. ಪರಿಹಾರದಲ್ಲಿ, ಅಂತಿಮ ಸಂದೇಶಕ್ಕಾಗಿ ಔಟ್ಪುಟ್ ಅನ್ನು ಫಾರ್ಮಾಟ್ ಮಾಡಲು ಅವುಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ: ಅಭಿನಂದನೆಗಳು! ಸರಿಯಾದ ಸಂಖ್ಯೆಯು {a}' ಆಗಿತ್ತು.
unittest.main()	ಈ ಆಜ್ಞೆಯು ಪೈಥಾನ್‌ನಲ್ಲಿ ಪರೀಕ್ಷಾ ಸೂಟ್ ಅನ್ನು ನಡೆಸುತ್ತದೆ ಏಕಪರೀಕ್ಷೆ ಚೌಕಟ್ಟು. ಪ್ರೋಗ್ರಾಂಗಾಗಿ ಬರೆದ ಪರೀಕ್ಷೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಚಲಾಯಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ: __ಹೆಸರು__ == '__ಮುಖ್ಯ__' ವೇಳೆ: unittest.main().

ಪೈಥಾನ್‌ನ ಗೆಸ್ಸಿಂಗ್ ಗೇಮ್ ಕೋಡ್‌ನ ಹಿಂದಿನ ಮೆಕ್ಯಾನಿಕ್ಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಪೈಥಾನ್ ಊಹಿಸುವ ಆಟದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಕೆದಾರರಿಗೆ 1 ಮತ್ತು 100 ರ ನಡುವೆ ಯಾದೃಚ್ಛಿಕವಾಗಿ ರಚಿಸಲಾದ ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಲು ಅನುಮತಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಈ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿನ ಮೊದಲ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಇದರ ಬಳಕೆ random.randint() ಕಾರ್ಯ, ಇದು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಶ್ರೇಣಿಯೊಳಗೆ ಯಾದೃಚ್ಛಿಕ ಪೂರ್ಣಾಂಕವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ (1 ರಿಂದ 100). ಇದು ಆಟದ ಹಿಂದಿನ ಪ್ರಮುಖ ತರ್ಕವನ್ನು ರೂಪಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಬಳಕೆದಾರನು ಊಹಿಸಬೇಕಾದ ರಹಸ್ಯ ಸಂಖ್ಯೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂ ನಂತರ ಬಳಕೆದಾರರಿಗೆ ತಮ್ಮ ಊಹೆಯನ್ನು ನಮೂದಿಸಲು ಅಪೇಕ್ಷಿಸುತ್ತದೆ ಇನ್ಪುಟ್ () ಫಂಕ್ಷನ್, ಇದು ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನಂತೆ ಸೆರೆಹಿಡಿಯುತ್ತದೆ ಮತ್ತು ನಂತರ ಹೋಲಿಕೆ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಪೂರ್ಣಾಂಕವಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ.

ಆಟದ ಹರಿವನ್ನು ನಿಯಂತ್ರಿಸುವಲ್ಲಿ ಲೂಪ್ ರಚನೆಯು ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ. ಎ ಸಮಯದಲ್ಲಿ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಉತ್ಪತ್ತಿಯಾಗುವ ಸಂಖ್ಯೆಯ ವಿರುದ್ಧ ಬಳಕೆದಾರರ ಊಹೆಗಳನ್ನು ನಿರಂತರವಾಗಿ ಪರಿಶೀಲಿಸಲು ಲೂಪ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಬಳಕೆದಾರರ ಊಹೆಯು ತಪ್ಪಾಗಿರುವವರೆಗೆ, ಲೂಪ್ ಆಟಗಾರನನ್ನು "ಹೆಚ್ಚಿನ ಊಹೆ" ಅಥವಾ "ಕಡಿಮೆ ಊಹಿಸಿ" ಎಂದು ಪ್ರೇರೇಪಿಸುತ್ತದೆ. ಲೂಪ್‌ನ ಒಳಗಿನ ಸ್ಥಿತಿಯು ಬಳಕೆದಾರರ ಊಹೆಯನ್ನು ರಹಸ್ಯ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಹೋಲಿಸುತ್ತದೆ, ಆಟವು ಅಕಾಲಿಕವಾಗಿ ಅಂತ್ಯಗೊಳ್ಳದೆ ಸೂಕ್ತವಾದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸುವ ಮೂಲಕ, ಆಟವು ಸಂವಾದಾತ್ಮಕವಾಗುತ್ತದೆ, ಸರಿಯಾದ ಉತ್ತರದ ಕಡೆಗೆ ಆಟಗಾರನಿಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ.

ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತಿದೆ IPython.display, ನಾವು ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಔಟ್‌ಪುಟ್ ಸ್ವರೂಪವನ್ನು ಪರಿಚಯಿಸುತ್ತೇವೆ ಗಣಿತ(), ಗಣಿತದ ಸಂಕೇತಗಳಲ್ಲಿ ಸಂದೇಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಬಳಸಲಾಗುವ ಕಾರ್ಯ. ಆದಾಗ್ಯೂ, ಬಹು ವೇರಿಯೇಬಲ್‌ಗಳೊಂದಿಗೆ ಸಂದೇಶವನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಶೇಕಡಾವಾರು ಚಿಹ್ನೆಯ (%) ಆರಂಭಿಕ ಬಳಕೆಯು ದೋಷವನ್ನು ಉಂಟುಮಾಡಿದೆ: % ಗಾಗಿ ಬೆಂಬಲಿಸದ ಒಪೆರಾಂಡ್ ಪ್ರಕಾರ(ಗಳು): 'ಮ್ಯಾಥ್' ಮತ್ತು 'ಟುಪಲ್'. ಏಕೆಂದರೆ ಈ ದೋಷ ಉಂಟಾಗುತ್ತದೆ ಗಣಿತ ಈ ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್ ಇಂಟರ್ಪೋಲೇಶನ್ ಅನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಪೈಥಾನ್‌ನ ಆಧುನಿಕ ಎಫ್-ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಬಳಸುವುದು, ಇದು ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತವಾಗಿದೆ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರು ಸರಿಯಾಗಿ ಊಹಿಸಿದಾಗ ಆಟದ ಕೊನೆಯಲ್ಲಿ ಸರಿಯಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಮೂರನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಸೆಟ್ ಅನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ ಘಟಕ ಪರೀಕ್ಷೆಗಳು ಪೈಥಾನ್ ಬಳಸಿ ಬರೆಯಲಾಗಿದೆ ಏಕಪರೀಕ್ಷೆ ಚೌಕಟ್ಟು. ಈ ಪರೀಕ್ಷೆಗಳ ಉದ್ದೇಶವು ಆಟದ ಕಾರ್ಯನಿರ್ವಹಣೆಯ ಮೌಲ್ಯೀಕರಣವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು, ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಆಟವು ನಿರೀಕ್ಷಿತವಾಗಿ ವರ್ತಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು. ಅಪಹಾಸ್ಯ ಮಾಡುವ ಮೂಲಕ ಇನ್ಪುಟ್ () ಬಳಸಿಕೊಂಡು ಕಾರ್ಯ unittest.mock.patch, ಹಸ್ತಚಾಲಿತ ಇನ್‌ಪುಟ್ ಅಗತ್ಯವಿಲ್ಲದೇ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ನಾವು ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಅನುಕರಿಸುತ್ತೇವೆ. ಈ ವಿಧಾನವು ಕೋಡ್‌ನ ದೃಢತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ವಿವಿಧ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಆಟದ ತರ್ಕವನ್ನು ಪರಿಶೀಲಿಸಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳು ಸಂಭಾವ್ಯ ದೋಷಗಳನ್ನು ಮೊದಲೇ ಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಪ್ರೋಗ್ರಾಂಗೆ ಯಾವುದೇ ಬದಲಾವಣೆಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಾರ್ಯವನ್ನು ಮುರಿಯುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಪೈಥಾನ್ ಗೆಸ್ಸಿಂಗ್ ಗೇಮ್‌ನಲ್ಲಿ ಬೆಂಬಲವಿಲ್ಲದ ಆಪರೇಂಡ್ ದೋಷವನ್ನು ಸರಿಪಡಿಸುವುದು

ಪರಿಹಾರ 1: ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳ ಪೈಥಾನ್ ಊಹಿಸುವ ಆಟ

# Importing required libraries
import random
# Function for the guessing game
def guessing_game():
    # Generate a random number between 1 and 100
    number_to_guess = random.randint(1, 100)
    user_guess = None
    # Loop until the user guesses the correct number
    while user_guess != number_to_guess:
        try:
            # Get input from the user
            user_guess = int(input('Guess a number between 1 and 100: '))
        except ValueError:
            print('Please enter a valid number.')
            continue
        # Provide hints for guessing higher or lower
        if user_guess < number_to_guess:
            print('Guess higher!')
        elif user_guess > number_to_guess:
            print('Guess lower!')
    # Congratulate the user when they guess correctly
    print(f'Congratulations! The correct number was {number_to_guess}.')
# Call the function
guessing_game()

IPython.display ಜೊತೆಗೆ ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸುವುದು ಮತ್ತು ಪೈಥಾನ್‌ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಸರಿಪಡಿಸುವುದು

ಪರಿಹಾರ 2: ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಔಟ್‌ಪುಟ್‌ಗಾಗಿ IPython.display ಅನ್ನು ಬಳಸುವುದು ಮತ್ತು tuple ದೋಷವನ್ನು ಸರಿಪಡಿಸುವುದು

# Importing required libraries from IPython
from IPython.display import display, Math
import random
# Function for the guessing game with IPython display
def guessing_game_ipython():
    number_to_guess = random.randint(1, 100)
    user_guess = None
    while user_guess != number_to_guess:
        try:
            user_guess = int(input('Guess a number between 1 and 100: '))
        except ValueError:
            print('Please enter a valid number.')
            continue
        if user_guess < number_to_guess:
            print('Guess higher!')
        elif user_guess > number_to_guess:
            print('Guess lower!')
    # Correctly formatting using the f-string instead of % formatting
    display(Math(f'Congratulations! The correct number was {number_to_guess} and you typed {user_guess}'))
# Call the function
guessing_game_ipython()

ಪರಿಸರದಾದ್ಯಂತ ನಿಖರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಸೇರಿಸುವುದು

ಪರಿಹಾರ 3: ಆಟದ ತರ್ಕವನ್ನು ಪರಿಶೀಲಿಸಲು ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಅಳವಡಿಸುವುದು

import unittest
from unittest.mock import patch
import random
# Function for the guessing game to be tested
def guessing_game_tested():
    number_to_guess = random.randint(1, 100)
    user_guess = None
    while user_guess != number_to_guess:
        user_guess = int(input('Guess a number between 1 and 100: '))
    return number_to_guess, user_guess
# Test class for the guessing game
class TestGuessingGame(unittest.TestCase):
    @patch('builtins.input', side_effect=[50, 75, 85, 95, 100])
    def test_guessing_game(self, mock_input):
        result = guessing_game_tested()
        self.assertEqual(result, (100, 100))
# Run the tests
if __name__ == '__main__':
    unittest.main()

ಇಂಟರ್ಯಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಂಗಳಲ್ಲಿ ಪ್ರದರ್ಶನಕ್ಕಾಗಿ ಪೈಥಾನ್ ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸುವ ಆಟವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಒಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಪ್ರೋಗ್ರಾಂ ಬಳಕೆದಾರರೊಂದಿಗೆ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, "ಹೆಚ್ಚಿನದನ್ನು ಊಹಿಸಿ" ಅಥವಾ "ಕಡಿಮೆ ಊಹಿಸಿ" ನಂತಹ ಸಂದೇಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವಾಗ, ಸ್ಪಷ್ಟ ಮತ್ತು ನಿಖರವಾದ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುವಾಗ ಸಾಮಾನ್ಯ ಸವಾಲು IPython.display ಔಟ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಸರಿಯಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುತ್ತಿದೆ. ಸ್ಟ್ರಿಂಗ್ ಇಂಟರ್‌ಪೋಲೇಷನ್‌ಗಾಗಿ ಶೇಕಡಾವಾರು ಚಿಹ್ನೆ (%) ಅನ್ನು ಬಳಸುವುದು ಸಾಂಪ್ರದಾಯಿಕವಾಗಿದ್ದರೂ, ಇದು % ಗಾಗಿ ಬೆಂಬಲಿಸದ ಒಪೆರಾಂಡ್ ಪ್ರಕಾರ(ಗಳು) ನಂತಹ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು: 'ಮ್ಯಾಥ್' ಮತ್ತು 'ಟುಪಲ್'. ಈ ಸಮಸ್ಯೆಯು ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಕೆಲವು ಗ್ರಂಥಾಲಯಗಳು, ಉದಾಹರಣೆಗೆ ಗಣಿತ(), f-ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ನಂತಹ ಪರ್ಯಾಯ ವಿಧಾನಗಳ ಅಗತ್ಯವಿದೆ.

ಆಧುನಿಕ ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್‌ಗಳಲ್ಲಿ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಸೇರಿಸಲು f-ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಓದಬಲ್ಲ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, "ಅಭಿನಂದನೆಗಳು! ಸರಿಯಾದ ಸಂಖ್ಯೆ %g" ಎಂದು ಬರೆಯುವ ಬದಲು, ನೀವು f-ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬಳಸಬಹುದು f'Congratulations! The correct number was {number}'. ಎಫ್-ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ನೇರವಾಗಿ ಎಂಬೆಡ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಸಾಂಪ್ರದಾಯಿಕ ಸ್ಟ್ರಿಂಗ್ ಇಂಟರ್‌ಪೋಲೇಷನ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಅಪಾಯಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ. ಇದು ಓದುವಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸುವುದಲ್ಲದೆ ಸಾಮಾನ್ಯ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.

ಎಫ್-ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಜೊತೆಗೆ, ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಪರಿಗಣನೆಯು ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಮೌಲ್ಯೀಕರಣವಾಗಿದೆ. ಬಳಕೆದಾರರಿಂದ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸುವಾಗ, ವಿಶೇಷವಾಗಿ ಊಹೆಗಳನ್ನು ಪದೇ ಪದೇ ನಮೂದಿಸುವ ಆಟದಲ್ಲಿ, ಪೂರ್ಣಾಂಕವಲ್ಲದ ಇನ್‌ಪುಟ್‌ಗಳಂತಹ ಸಂಭಾವ್ಯ ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಅನುಷ್ಠಾನಗೊಳಿಸುತ್ತಿದೆ try-except ಬ್ಲಾಕ್‌ಗಳು ಅಮಾನ್ಯವಾದ ಇನ್‌ಪುಟ್‌ನಿಂದಾಗಿ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಆಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಬದಲಾಗಿ, ಇದು ಮಾನ್ಯವಾದ ಡೇಟಾವನ್ನು ನಮೂದಿಸಲು ಬಳಕೆದಾರರನ್ನು ಆಕರ್ಷಕವಾಗಿ ಪ್ರೇರೇಪಿಸುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಒಟ್ಟಾರೆ ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಆಪ್ಟಿಮೈಸ್ಡ್ ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಮತ್ತು ಇನ್‌ಪುಟ್ ಮೌಲ್ಯೀಕರಣದ ಈ ಸಂಯೋಜನೆಯು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಬಳಕೆದಾರ-ಸ್ನೇಹಿ ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಪೈಥಾನ್ ಗೆಸ್ಸಿಂಗ್ ಗೇಮ್ ಮತ್ತು ದೋಷಗಳ ಬಗ್ಗೆ ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

"% ಗೆ ಬೆಂಬಲವಿಲ್ಲದ ಒಪೆರಾಂಡ್ ಪ್ರಕಾರ(ಗಳು): 'ಮ್ಯಾಥ್' ಮತ್ತು 'ಟುಪಲ್'" ದೋಷದ ಅರ್ಥವೇನು?
ಯಾವಾಗ ಈ ದೋಷ ಸಂಭವಿಸುತ್ತದೆ Math() ತಪ್ಪಾದ ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ನೊಂದಿಗೆ ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಶೇಕಡಾವಾರು ಚಿಹ್ನೆಯನ್ನು (%) ಎಫ್-ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದರಿಂದ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.
ಪೈಥಾನ್‌ನಲ್ಲಿ ಶೇಕಡಾವಾರು (%) ವಿಧಾನದ ಮೇಲೆ ಎಫ್-ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಏಕೆ ಬಳಸಬೇಕು?
ಸಾಂಪ್ರದಾಯಿಕಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಎಫ್-ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ಸಮರ್ಥ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ನೀಡುತ್ತವೆ % ವಿಧಾನ. ಸಂಕೀರ್ಣ ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ನಲ್ಲಿನ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಅವರು ಕಡಿಮೆ ಮಾಡುತ್ತಾರೆ.
ಊಹೆಯ ಆಟದಲ್ಲಿ ಅಮಾನ್ಯ ಬಳಕೆದಾರ ಇನ್‌ಪುಟ್ ಅನ್ನು ನಾನು ಹೇಗೆ ನಿರ್ವಹಿಸಬಹುದು?
ನೀವು ಬಳಸಬಹುದು a try-except ಬಳಕೆದಾರರು ಪೂರ್ಣಾಂಕವಲ್ಲದ ಡೇಟಾವನ್ನು ನಮೂದಿಸಿದಾಗ ValueError ನಂತಹ ದೋಷಗಳನ್ನು ಹಿಡಿಯಲು ನಿರ್ಬಂಧಿಸಿ, ಆಟವು ಸುಗಮವಾಗಿ ಮುಂದುವರಿಯುವುದನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ.
ಪಾತ್ರ ಏನು random.randint() ಈ ಆಟದಲ್ಲಿ?
random.randint() ಬಳಕೆದಾರನು ಆಟದಲ್ಲಿ ಊಹಿಸಲು ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯೊಳಗೆ (1 ರಿಂದ 100) ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.
ಹೇಗೆ ಮಾಡುತ್ತದೆ while ಊಹಿಸುವ ಆಟದಲ್ಲಿ ಲೂಪ್ ಸಹಾಯ?
ದಿ while ಬಳಕೆದಾರರು ಯಾದೃಚ್ಛಿಕವಾಗಿ ರಚಿಸಿದ ಸಂಖ್ಯೆಯನ್ನು ಸರಿಯಾಗಿ ಊಹಿಸುವವರೆಗೆ ಆಟವು ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂದು ಲೂಪ್ ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಪೈಥಾನ್ ಗೆಸ್ಸಿಂಗ್ ಆಟಗಳಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ದೋಷಗಳನ್ನು ಸರಿಪಡಿಸುವುದು

ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿದ ನಂತರ ಪೈಥಾನ್‌ನಲ್ಲಿ ಊಹಿಸುವ ಆಟವು ಸರಾಗವಾಗಿ ಚಲಿಸಬಹುದು. ಎಫ್-ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ದೋಷಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ ಗಣಿತ() ಮತ್ತು ಟುಪಲ್ ಅನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತದೆ, ಇದು ಸುಗಮ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ. ಈ ಆಧುನಿಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ವಿಧಾನವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸುಲಭವಾಗಿದೆ ಮತ್ತು ಸಾಮಾನ್ಯ ಅಪಾಯಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಇದರೊಂದಿಗೆ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಪ್ರಯತ್ನಿಸಿ-ಹೊರತುಪಡಿಸಿ ಅಮಾನ್ಯವಾದ ಇನ್‌ಪುಟ್‌ನಿಂದಾಗಿ ಆಟವು ಕ್ರ್ಯಾಶ್ ಆಗುವುದಿಲ್ಲ ಎಂದು ಬ್ಲಾಕ್‌ಗಳು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಹೊಂದಾಣಿಕೆಗಳು ಆಟವನ್ನು ಹೆಚ್ಚು ದೃಢವಾಗಿ ಮತ್ತು ಬಳಕೆದಾರ ಸ್ನೇಹಿಯಾಗಿ ಮಾಡುತ್ತವೆ, ನಿರಾಶಾದಾಯಕ ದೋಷಗಳನ್ನು ಎದುರಿಸದೆಯೇ ಸಂವಾದಾತ್ಮಕ ಅನುಭವವನ್ನು ಆನಂದಿಸಲು ಆಟಗಾರರಿಗೆ ಅಗತ್ಯವಾದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಪೈಥಾನ್ ಗೆಸ್ಸಿಂಗ್ ಗೇಮ್‌ಗಾಗಿ ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳು

ಬಳಕೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ IPython.display ಮತ್ತು ಗಣಿತ() ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಔಟ್‌ಪುಟ್‌ಗಾಗಿ ಕಾರ್ಯಗಳು. ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ, ಭೇಟಿ ನೀಡಿ IPython ದಾಖಲೆ .
ಎಂಬ ಬಗ್ಗೆ ಮಾಹಿತಿ ನೀಡುತ್ತದೆ f-ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಕ್ಲೀನರ್ ಸ್ಟ್ರಿಂಗ್ ಇಂಟರ್‌ಪೋಲೇಶನ್‌ಗಾಗಿ ಪೈಥಾನ್‌ನಲ್ಲಿ. ಹೆಚ್ಚಿನ ಓದುವಿಕೆಗಾಗಿ, ನೋಡಿ ಪೈಥಾನ್ ಅಧಿಕೃತ ದಾಖಲೆ .
ಪೈಥಾನ್ ಬಳಕೆಯಲ್ಲಿ ದೋಷಗಳು ಮತ್ತು ವಿನಾಯಿತಿಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ಈ ಮೂಲವು ವಿವರಿಸುತ್ತದೆ ಪ್ರಯತ್ನಿಸಿ-ಹೊರತುಪಡಿಸಿ ಬ್ಲಾಕ್ಗಳನ್ನು. ನೋಡಿ ನಿಜವಾದ ಪೈಥಾನ್: ಪೈಥಾನ್ ವಿನಾಯಿತಿಗಳು .
ಪೈಥಾನ್‌ನ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಯಾದೃಚ್ಛಿಕ ಮಾಡ್ಯೂಲ್ ಮತ್ತು ಊಹಿಸುವ ಆಟಗಳನ್ನು ರಚಿಸುವಲ್ಲಿ ಅದರ ಅಪ್ಲಿಕೇಶನ್. ಪೂರ್ಣ ಉಲ್ಲೇಖ ಲಭ್ಯವಿದೆ ಪೈಥಾನ್ ರಾಂಡಮ್ ಮಾಡ್ಯೂಲ್ .

%: ಊಹೆಯ ಆಟದಲ್ಲಿ 'ಗಣಿತ' ಮತ್ತು 'ಟುಪಲ್': ಬೆಂಬಲಿತವಲ್ಲದ ಒಪೆರಾಂಡ್ ಪ್ರಕಾರ(ಗಳು): ಇದನ್ನು ಹೇಗೆ ಸರಿಪಡಿಸುವುದು