[ಪೈಥಾನ್] ಐಆರ್ಸಿಗಾಗಿ ಬೋಟ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಂ ಮಾಡಿ

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

ಎಂದು ಹೇಳುವ ಮೂಲಕ, ಟ್ಯುಟೋರಿಯಲ್ ಗೆ ಹೋಗೋಣ.

ಬೋಟ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ನಮಗೆ ಒಂದು ಅಗತ್ಯವಿದೆ ಸರಳ ಪಠ್ಯ ಸಂಪಾದಕ cualquiera (ನ್ಯಾನೊ, ಗೆಡಿಟ್, ಧ್ಯಾನ, ಇತ್ಯಾದಿ) ಮತ್ತು ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ (2.6 ಅಥವಾ 2.7 ಅಗತ್ಯವಾಗಿರುತ್ತದೆ, ಪೈಥಾನ್ 3.x ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ).

ಮೊದಲು ನಾವು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಅಗತ್ಯವಿರುವ ಮಾಡ್ಯೂಲ್‌ಗಳು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಮಗೆ ಕೇವಲ ಎರಡು ಅಗತ್ಯವಿರುತ್ತದೆ:

[ಕೋಡ್] #! / usr / bin / env ಪೈಥಾನ್
# - * - ಕೋಡಿಂಗ್: utf-8 - * -

ಆಮದು ಸಾಕೆಟ್
ಆಮದು ಸ್ಟ್ರಿಂಗ್
[/ ಕೋಡ್]

ಈಗ ನಾವು ಮುಂದುವರಿಯುತ್ತೇವೆ ಹೊಂದಿಸಿ ಬೋಟ್:

[code] HOST=»irc.desdelinux.net»
PORT = 6667
ನಿಕ್ = »ಕ್ಯಾಲಿಕೊಬಾಟ್»
IDENT = »ಕ್ಯಾಲಿಕೊಬಾಟ್»
REALNAME = »ಕ್ಯಾಲಿಕೊಬಾಟ್»
CHAN = »# ಮನೆ»
readbuffer = »»
[/ ಕೋಡ್]

ನಾನು ಪ್ರತಿ ವೇರಿಯಬಲ್ ಅನ್ನು ವಿವರಿಸುತ್ತೇನೆ:

• ಹೋಸ್ಟ್: ನಾವು ಸಂಪರ್ಕಿಸುವ ಸರ್ವರ್‌ನ URL
• ಪೋರ್ಟ್: ಸರ್ವರ್ ಪೋರ್ಟ್. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಇದು 6667 ಆಗಿದೆ.
• ನಿಕ್, ಐಡೆಂಟ್ ಮತ್ತು ರಿಯಲ್ನೇಮ್: ಅವು ಬೋಟ್‌ನ ಅಡ್ಡಹೆಸರು, ಅದರ ಗುರುತಿಸುವಿಕೆ ಮತ್ತು ನಿಜವಾದ ಹೆಸರಿಗೆ ಅನುರೂಪವಾಗಿದೆ.
• ಚಾನ್: ಬೋಟ್ ಪ್ರವೇಶಿಸುವ ಚಾನಲ್
• ರೀಡ್‌ಬಫರ್: ಈ ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಸರ್ವರ್ ಕಳುಹಿಸಿದ ಡೇಟಾವನ್ನು ಉಳಿಸಲಾಗುತ್ತದೆ.

ನಮ್ಮ ಬೋಟ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ನಂತರ ನಾವು ಮುಂದುವರಿಯುತ್ತೇವೆ ಸಂಪರ್ಕ

[ಕೋಡ್] s = socket.socket ()
s.connect ((HOST, PORT))
s.send ("NICK% s \ r \ n"% NICK)
s.send ("USER% s% s bla:% s \ r \ n"% (IDENT, HOST, REALNAME))
s.send ("ಸೇರಿ:% s \ r \ n"% CHAN)
[/ ಕೋಡ್]

ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಹೆಚ್ಚು ರಹಸ್ಯವಿಲ್ಲ, ಎರಡನೆಯದು ಸೃಷ್ಟಿಸುತ್ತದೆ ಸರ್ವರ್ ಸಂಪರ್ಕ ಮತ್ತು ಕೊನೆಯ ಮೂರು ಲಾಗಿನ್‌ನೊಂದಿಗೆ ಮುಂದುವರಿಯಲು ಬೋಟ್‌ನ ಡೇಟಾವನ್ನು ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ.

ಸಂಪರ್ಕಗೊಂಡ ನಂತರ ನಾವು a ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಅನಂತ ಲೂಪ್ ಇದರಲ್ಲಿ ನಾವು ಹೋಗುತ್ತೇವೆ / ನಿಂದ ಸರ್ವರ್‌ಗೆ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುವುದು ಮತ್ತು ಕಳುಹಿಸುವುದು:

[ಕೋಡ್] ಆದರೆ 1:
readbuffer = ರೀಡ್‌ಬಫರ್ + s.recv (1024)
temp = string.split (ರೀಡ್‌ಬಫರ್, "\ n")
readbuffer = temp.pop ()
ತಾತ್ಕಾಲಿಕ ಸಾಲಿಗೆ:
line = string.rstrip (ಸಾಲು)
line = line.split (CHAN + ':')

ಒಂದು ವೇಳೆ ಸಾಲು [0] .ಫೈಂಡ್ ("ಪಿಂಗ್")! = -1:
pingid = line [0] .split () [1] s.send ("PONG% s \ r \ n"% pingid)
[/ ಕೋಡ್]

ಮೇಲೆ ಬರೆದ ಎಲ್ಲಾ ಸಾಲುಗಳಲ್ಲಿ, ನಾನು ಪ್ರಮುಖವಾದವುಗಳ ಬಗ್ಗೆ ಮಾತ್ರ ಕಾಮೆಂಟ್ ಮಾಡುತ್ತೇನೆ.
ಕಾನ್ line = line.split (CHAN + ':') ನಾವು ಏನು ಮಾಡುತ್ತೇವೆ ಸರ್ವರ್ ಯಾವಾಗ ನಮಗೆ ಕಳುಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಭಾಗಿಸಿ ಚಾನಲ್‌ನಿಂದ ಏನನ್ನಾದರೂ ಪಡೆಯೋಣ.
ಉದಾಹರಣೆಗೆ ಈ ಕೆಳಗಿನ ಸಾಲು ಯಾರಾದರೂ ಚಾನಲ್‌ನಲ್ಲಿ ಏನನ್ನಾದರೂ ಬರೆದಿದ್ದಾರೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ:

:son_link!sonlink@127.0.0.1 PRIVMSG #Home :Hola ^^

ಮೊದಲನೆಯದು ಬಳಕೆದಾರರ ಅಡ್ಡಹೆಸರು ಮತ್ತು ಸಂಪರ್ಕ ಡೇಟಾ (ಇದನ್ನು ಬೇರ್ಪಡಿಸಲಾಗಿದೆ!), ಆಜ್ಞೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅವನು ಬರೆದಿದ್ದಾನೆಂದು ಸೂಚಿಸುತ್ತದೆ), ಚಾನಲ್ ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಕೊಲೊನ್ ನಂತರ, ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ. ಈ ಟ್ಯುಟೋರಿಯಲ್ ವ್ಯಾಪ್ತಿಗೆ ಬರದ ಕಾರಣ ನಾನು ಇನ್ನೂ ಅನೇಕ ಆಜ್ಞೆಗಳನ್ನು ವಿವರಿಸುವುದಿಲ್ಲ.

ಇತರ ಪ್ರಮುಖ ಸಾಲುಗಳು ನಂತರ. ಬಳಕೆದಾರರು ಇನ್ನೂ ಸಂಪರ್ಕ ಹೊಂದಿದ್ದಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಸರ್ವರ್ ಆಗಾಗ್ಗೆ ಪಿಂಗ್ ಆಜ್ಞೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಬೋಟ್ PONG ಆಜ್ಞೆಯನ್ನು ID ಯೊಂದಿಗೆ ಕಳುಹಿಸುತ್ತದೆ, ಅದು ಇನ್ನೂ ಸಂಪರ್ಕಗೊಂಡಿದೆ ಎಂದು ಸರ್ವರ್‌ಗೆ ಸೂಚಿಸಲು PING ಕಳುಹಿಸಲಾಗಿದೆ.

ಇದರೊಂದಿಗೆ ನಾವು ಈಗಾಗಲೇ ಬೋಟ್‌ನ ಮೂಲವನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಕೆಲವು ಆಜ್ಞೆಗಳಿಗೆ ನಾವು ಏನು ಬಯಸುತ್ತೇವೆ ಎಂಬುದರ ಪ್ರಕಾರ ಬೋಟ್ ಹೇಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸಲು ಈಗ ನಾನು ಮುಂದುವರಿಯುತ್ತೇನೆ, ಅವು ಐಆರ್ಸಿಯಿಂದ ಅಥವಾ ಬಳಕೆದಾರರಿಂದ.

ಐಆರ್ಸಿ ಆಜ್ಞೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವುದು:

ಪಿಂಗ್ ಮತ್ತು ಪಿಆರ್ಐವಿಎಂಎಸ್ಜಿ ಐಆರ್ಸಿ ಆಜ್ಞೆಗಳ ಉದಾಹರಣೆಗಳಾಗಿವೆ. ಅನೇಕ ಆಜ್ಞೆಗಳಿವೆ, ಆದರೆ ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ, ನಾನು ಅದರ ಬಗ್ಗೆ ವಿವರವಾಗಿ ಹೋಗುವುದಿಲ್ಲ.
ಉದಾಹರಣೆಗೆ, ಸಂಪರ್ಕಿಸುವ ಬಳಕೆದಾರರಿಗೆ ನಾವು ಬೋಟ್ ನಮಸ್ಕಾರ ಹೇಳಬಹುದು:

[ಕೋಡ್] ಸಾಲು ಇದ್ದರೆ [0] .ಫೈಂಡ್ ('ಸೇರಿ')! = -1:
name = line [0] .ಸ್ಪ್ಲಿಟ್ ('!') [0] .ಸ್ಪ್ಲಿಟ್ (':') [1] ಹೆಸರಿದ್ದರೆ! = NICK ಮತ್ತು name.find (HOST) == -1:
s.send ("PRIVMSG% s: ಸ್ವಾಗತ @% s ^^ \ n"% (CHAN, ಹೆಸರು))
[/ ಕೋಡ್]

ಸರ್ವರ್ ಆಜ್ಞೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆಯೇ ಎಂದು ಮೊದಲು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಸೇರಿರಿ ಯಾರಾದರೂ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕ ಹೊಂದಿದ್ದಾರೆಂದು ಇದು ಸೂಚಿಸುತ್ತದೆ. ನಂತರ ನಾವು ನಿಕ್ ಅನ್ನು ಹೊರತೆಗೆಯುತ್ತೇವೆ, ನಿಕ್ ಐಆರ್ಸಿ url ಅಲ್ಲ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ (ನಾವು ಬೋಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದ ತಕ್ಷಣ ಅದು url ಅನ್ನು ಸ್ವಾಗತಿಸುತ್ತದೆ) ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಾವು ಶುಭಾಶಯ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ.

ಬಾಟ್ ಆಜ್ಞೆಗಳು:

ಈಗ ನಾನು ನನ್ನ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ಮಾಡುವುದು ನನ್ನ ಸ್ವಂತ ಆಜ್ಞೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಿ? ಉದಾಹರಣೆಯನ್ನು ಉತ್ತಮವಾಗಿ ನೋಡೋಣ:

[ಕೋಡ್] ವೇಳೆ [1] == '$ ಆವೃತ್ತಿ':
s.send («PRIVMSG% s: ಕ್ಯಾಲಿಕೊಬಾಟ್ 0.1.2 (ಸಿ) 2012 ಮಗ ಲಿಂಕ್ \ n»% ಚಾನ್)
[/ ಕೋಡ್]

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಯಾರಾದರೂ ಬರೆದರೆ $ ಆವೃತ್ತಿ ಬೋಟ್ ಅದರ ಹೆಸರು, ಆವೃತ್ತಿ ಮತ್ತು ಲೇಖಕರನ್ನು ಸೂಚಿಸುವ ಸಂದೇಶವನ್ನು ತೋರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಯ ಸಂಪೂರ್ಣ ಕೋಡ್ ಇದು:

[ಕೋಡ್] ಆಮದು ಸಾಕೆಟ್
ಆಮದು ಸ್ಟ್ರಿಂಗ್

HOST = »ಲೋಕಲ್ ಹೋಸ್ಟ್»
PORT = 6667
ನಿಕ್ = »ಕ್ಯಾಲಿಕೊಬಾಟ್»
IDENT = »ಕ್ಯಾಲಿಕೊಬಾಟ್»
REALNAME = »ಕ್ಯಾಲಿಕೊಬಾಟ್»
CHAN = »# ಮನೆ»
readbuffer = »»
s = socket.socket ()
s.connect ((HOST, PORT))
s.send ("NICK% s \ r \ n"% NICK)
s.send ("USER% s% s bla:% s \ r \ n"% (IDENT, HOST, REALNAME))
s.send ("ಸೇರಿ:% s \ r \ n"% CHAN)

1:

readbuffer = ರೀಡ್‌ಬಫರ್ + s.recv (1024)
temp = string.split (ರೀಡ್‌ಬಫರ್, "\ n")
readbuffer = temp.pop ()
ತಾತ್ಕಾಲಿಕ ಸಾಲಿಗೆ:
ಮುದ್ರಣ ಸಾಲು
line = string.rstrip (ಸಾಲು)
line = line.split (CHAN + ':')

ಒಂದು ವೇಳೆ ಸಾಲು [0] .ಫೈಂಡ್ ("ಪಿಂಗ್")! = -1:
pingid = line [0] .split () [1] s.send ("PONG% s \ r \ n"% pingid)

ಒಂದು ವೇಳೆ ಸಾಲು [0] .ಫೈಂಡ್ ('ಸೇರಿ')! = -1:
name = line [0] .ಸ್ಪ್ಲಿಟ್ ('!') [0] .ಸ್ಪ್ಲಿಟ್ (':') [1] ಹೆಸರಿದ್ದರೆ! = NICK ಮತ್ತು name.find (HOST) == -1:
s.send ("PRIVMSG% s: ಸ್ವಾಗತ @% s ^^ \ n"% (CHAN, ಹೆಸರು))

ಲೆನ್ (ಸಾಲು) <1:
ಒಂದು ವೇಳೆ ಸಾಲು [1] == '$ ಆವೃತ್ತಿ':
s.send («PRIVMSG% s: ಕ್ಯಾಲಿಕೊಬಾಟ್ 0.1.2 (ಸಿ) 2012 ಮಗ ಲಿಂಕ್ \ n»% ಚಾನ್)
[/ ಕೋಡ್]

ನೀವು ಈ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಇಷ್ಟಪಟ್ಟಿದ್ದೀರಿ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ನನ್ನ ಬೋಟ್‌ನ ಕೋಡ್‌ಗೆ ಲಿಂಕ್ ಅನ್ನು ನಾನು ನಿಮಗೆ ಬಿಡುತ್ತೇನೆ ಇದರಿಂದ ನೀವು ಅದರ ಕೋಡ್ ಅನ್ನು ಪೂರ್ಣವಾಗಿ ನೋಡಬಹುದು ಮತ್ತು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ಚೆನ್ನಾಗಿ ನೋಡಬಹುದು (ವೈಯಕ್ತಿಕ ಬಳಕೆಗಾಗಿ ನಾನು ಕೆಲವು ಆಜ್ಞೆಗಳನ್ನು ತೆಗೆದುಹಾಕಿದ್ದರೂ).

ಕ್ಯಾಲಿಕೊಬಾಟ್