[పైథాన్] IRC కోసం ఒక బోట్ ప్రోగ్రామ్

ఈ రోజు నేను మీకు ఎలా ప్రోగ్రామ్ చేయాలో నేర్పించబోతున్నాను బాట్ కోసం IRC. అన్నింటిలో మొదటిది, తెలియని వారికి, బోట్ అనేది ఒక IRC ఛానెల్‌కు కనెక్ట్ అయ్యే మరియు దానితో సంభాషించే ఒక ప్రోగ్రామ్, ఇది మాకు, ఉదాహరణకు, లేకుండా ఛానెల్‌ను మోడరేట్ చేయడానికి అనుమతిస్తుంది మేము కనెక్ట్ అయ్యాము అందువల్ల స్పామ్‌ను నివారించండి లేదా ఇది ఆర్డర్‌ల శ్రేణిని గుర్తించి సంబంధిత కోడ్‌ను అమలు చేస్తుంది.
ఇప్పటికే బాట్లు సిద్ధంగా ఉన్నప్పటికీ, నేర్చుకోవడానికి వారి స్వంత ప్రోగ్రామ్‌లను తయారు చేసుకోవాలనుకునే వారిలో నేను నిజాయితీగా ఉన్నాను మరియు అది పనిచేస్తుందని చూసిన తర్వాత అది మనకు ఇచ్చే గొప్ప సంతృప్తి ^^

అని చెప్పడంతో, ట్యుటోరియల్‌కు వెళ్దాం.

బోట్ ప్రోగ్రామ్ చేయడానికి మాకు అవసరం సాదా టెక్స్ట్ ఎడిటర్ cualquiera (నానో, గెడిట్, ధ్యానం, మొదలైనవి) మరియు పైథాన్ వ్యాఖ్యాత (2.6 లేదా 2.7 అవసరం, పైథాన్ 3.x తో పనిచేయదు).

మొదట మేము దిగుమతి చేస్తాము అవసరమైన గుణకాలు, ఈ సందర్భంలో మనకు రెండు మాత్రమే అవసరం:

[కోడ్] #! / usr / bin / env పైథాన్
# - * - కోడింగ్: utf-8 - * -

దిగుమతి సాకెట్
దిగుమతి స్ట్రింగ్
[/ కోడ్]

ఇప్పుడు మేము ముందుకు వెళ్తాము ఏర్పాటు బోట్:

[కోడ్] HOST = »irc.fromlinux.net»
PORT = 6667
నిక్ = »కాలికోబోట్»
IDENT = »కాలికోబాట్»
REALNAME = »కాలికోబాట్»
CHAN = »# హోమ్»
readbuffer = »»
[/ కోడ్]

నేను ప్రతి వేరియబుల్ వివరిస్తాను:

  • HOST: మేము కనెక్ట్ చేసే సర్వర్ యొక్క 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 = 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 పంపబడింది.

దీనితో మనకు ఇప్పటికే బోట్ యొక్క ఆధారం ఉంది. IRC నుండి లేదా వినియోగదారుల నుండి మనం కొన్ని ఆదేశాలకు కావలసిన విధంగా బోట్ ఎలా స్పందించాలో ఇప్పుడు నేను వివరిస్తాను.

IRC ఆదేశాలకు ప్రతిస్పందించడం:

పింగ్ మరియు పిఆర్‌విఎంఎస్‌జి ఐఆర్‌సి ఆదేశాలకు ఉదాహరణలు. చాలా ఆదేశాలు ఉన్నాయి, కానీ నేను ముందు చెప్పినట్లుగా, ఇది నేను వివరంగా చెప్పలేను.
ఉదాహరణకు, కనెక్ట్ చేసే వినియోగదారులకు బోట్ హలో చెప్పేలా చేయవచ్చు:

[కోడ్] ఉంటే లైన్ [0] .ఫైండ్ ('చేరండి')! = -1:
name = line [0] .split ('!') [0] .split (':') [1] పేరు ఉంటే! = NICK మరియు name.find (HOST) == -1:
s.send ("PRIVMSG% s: స్వాగతం @% s ^^ \ n"% (CHAN, పేరు))
[/ కోడ్]

మొదట సర్వర్ ఆదేశాన్ని పంపుతుందో లేదో తనిఖీ చేస్తాము JOIN ఎవరైనా సర్వర్‌కు కనెక్ట్ అయ్యారని ఇది సూచిస్తుంది. అప్పుడు మేము నిక్ను సంగ్రహిస్తాము, నిక్ IRC url కాదని మేము తనిఖీ చేస్తాము (మేము బోట్ నడుపుతున్న వెంటనే అది url ని పలకరిస్తుంది) చివరకు మేము గ్రీటింగ్ సందేశాన్ని పంపుతాము.

బోట్ ఆదేశాలు:

ఇప్పుడు నేను నా బోట్ ఎలా తయారు చేయగలను నా స్వంత ఆదేశాలకు ప్రతిస్పందించండి? ఒక ఉదాహరణను బాగా చూద్దాం:

[కోడ్] ఉంటే లైన్ [1] == '$ వెర్షన్':
s.send («PRIVMSG% s: కాలికోబాట్ 0.1.2 (సి) 2012 సన్ లింక్ \ n»% CHAN)
[/ కోడ్]

ఈ ఉదాహరణలో ఎవరైనా వ్రాస్తే $ వెర్షన్ బోట్ దాని పేరు, సంస్కరణ మరియు రచయితను సూచించే సందేశాన్ని చూపుతుంది. ఉదాహరణ యొక్క పూర్తి కోడ్ ఇది:

[కోడ్] దిగుమతి సాకెట్
దిగుమతి స్ట్రింగ్

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 = 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] .split ('!') [0] .split (':') [1] పేరు ఉంటే! = NICK మరియు name.find (HOST) == -1:
s.send ("PRIVMSG% s: స్వాగతం @% s ^^ \ n"% (CHAN, పేరు))

లెన్ (లైన్) <1:
ఉంటే లైన్ [1] == '$ వెర్షన్':
s.send («PRIVMSG% s: కాలికోబాట్ 0.1.2 (సి) 2012 సన్ లింక్ \ n»% CHAN)
[/ కోడ్]

మీరు ఈ ట్యుటోరియల్‌ను ఇష్టపడ్డారని నేను నమ్ముతున్నాను, అయితే, నా బోట్ యొక్క కోడ్‌కు లింక్‌ను మీకు వదిలివేస్తున్నాను, తద్వారా మీరు దాని కోడ్‌ను పూర్తిగా చూడగలరు మరియు ఇది ఎలా పనిచేస్తుందో మీరు బాగా చూడగలరు (నేను వ్యక్తిగత ఉపయోగం కోసం కొన్ని ఆదేశాలను తీసివేసినప్పటికీ).

కాలికోబాట్


వ్యాసం యొక్క కంటెంట్ మా సూత్రాలకు కట్టుబడి ఉంటుంది సంపాదకీయ నీతి. లోపం నివేదించడానికి క్లిక్ చేయండి ఇక్కడ.

12 వ్యాఖ్యలు, మీదే వదిలేయండి

మీ వ్యాఖ్యను ఇవ్వండి

మీ ఇమెయిల్ చిరునామా ప్రచురితమైన కాదు. లు గుర్తించబడతాయి గుర్తించబడతాయి *

*

*

  1. డేటాకు బాధ్యత: మిగ్యుల్ ఏంజెల్ గాటన్
  2. డేటా యొక్క ఉద్దేశ్యం: కంట్రోల్ స్పామ్, వ్యాఖ్య నిర్వహణ.
  3. చట్టబద్ధత: మీ సమ్మతి
  4. డేటా యొక్క కమ్యూనికేషన్: డేటా చట్టపరమైన బాధ్యత ద్వారా తప్ప మూడవ పార్టీలకు తెలియజేయబడదు.
  5. డేటా నిల్వ: ఆక్సెంటస్ నెట్‌వర్క్స్ (EU) హోస్ట్ చేసిన డేటాబేస్
  6. హక్కులు: ఎప్పుడైనా మీరు మీ సమాచారాన్ని పరిమితం చేయవచ్చు, తిరిగి పొందవచ్చు మరియు తొలగించవచ్చు.

  1.   AurosZx అతను చెప్పాడు

    హే, IRC on చాలా ఆసక్తికరమైన కథనంలో మీరు ప్రయాణించే బుల్షిట్ యొక్క బాట్ను నేను కోల్పోలేను.

  2.   ప్రాధేయపడింది అతను చెప్పాడు

    చాలా సులభమైన మరియు స్పష్టమైన వివరణ.
    ఒకవేళ, పైథాన్ కోడ్ అన్ని ఇండెంటేషన్ లేదు.

  3.   రాఫా అతను చెప్పాడు

    అద్భుతమైన కథనం మరియు బోట్‌ను ప్రోగ్రామ్ చేయడానికి IRC కి కనెక్ట్ అవ్వడం ఎంత సులభం :)…

    ప్రోగ్రామర్లు MSN లేదా MSN సమూహాలలో చాట్లలో mIRC కోసం స్క్రిప్ట్‌లను వ్రాస్తున్నట్లు మాకు అనిపించిన సందర్భాలను ఇది నాకు గుర్తు చేస్తుంది.

  4.   truko22 అతను చెప్పాడు

    ఆసక్తికరంగా నేను ఉంచాను

  5.   జెనెసిస్ వర్గాస్ జె. (Prelprincipiodeto) అతను చెప్పాడు

    అద్భుతమైన !!

  6.   ఎలింక్స్ అతను చెప్పాడు

    చాలా ఉపయోగకరంగా ఉంది, ధన్యవాదాలు Son_Link!

    ధన్యవాదాలు!

  7.   dbillyx అతను చెప్పాడు

    చీర్స్…

    మీ పంక్తులను అనుసరించడం మరియు పని చేసే ఏకైకదాన్ని పరీక్షించడం
    దిగుమతి సాకెట్
    దిగుమతి స్ట్రింగ్

    HOST = »లోకల్ హోస్ట్»
    PORT = 6667
    నిక్ = »కాలికోబోట్»
    IDENT = »కాలికోబాట్»
    REALNAME = »కాలికోబాట్»
    CHAN = »# హోమ్»
    readbuffer = »»
    s = socket.socket ()
    s.connect ((HOST, PORT))
    s.send ("NICK% srn"% NICK)
    s.send ("USER% s% s bla:% srn"% (IDENT, HOST, REALNAME))
    s.send ("చేరండి:% srn"% CHAN)

    ఇప్పుడు ఛానెల్ మరియు మారుపేరును మార్చడం క్రింద నాకు లోపం వాక్యనిర్మాణం విసురుతుంది

    నేను ఇతర పరిచయస్తులను అడిగాను మరియు అది పైథాన్ లాగా లేదని వారు నాకు చెప్తారు

    నేను ఏమి తప్పు చేస్తున్నానో నాకు తెలియదు లేదా నేను ఎందుకు ప్రతిదీ కాపీ చేసి పైథాన్‌లో పేస్ట్ చేసి ఎంటర్ ఇస్తాను మరియు అది ఛానెల్‌కు అనుసంధానిస్తుంది కాని 250 సెకన్ల తర్వాత ఛానెల్ దాన్ని తొలగిస్తుంది ఎందుకంటే పాంగ్ నుండి స్పందన లేదు ...

  8.   పిన్‌ఫ్రై అతను చెప్పాడు

    పూర్తి కోడ్ నాకు పని చేయదు, చివరి పేరా విఫలమైంది మరియు నేను లోపం కనుగొనలేకపోయాను. నేను ఆ భాగాన్ని తొలగిస్తే, అది కనెక్ట్ అవుతుంది మరియు ఖచ్చితంగా పనిచేస్తుంది. విండోస్ 2.7.3 లో పైథాన్ 7 తో పరీక్షించబడింది.

    PS: నా విషయంలో నేను పాస్‌వర్డ్‌తో సర్వర్‌కు కనెక్ట్ అయ్యాను మరియు ఈ పంక్తులను జోడించాను:
    PASS = »పాస్‌డెల్బోట్»
    s.send ("PASS% s \ r \ n"% PASS)

  9.   డాల్ఫిన్ అతను చెప్పాడు

    హాయ్ సన్ లింక్, వ్యాసానికి చాలా ధన్యవాదాలు, ఇది చాలా ఆసక్తికరంగా ఉంది, పంపిన ఆదేశాలకు నేను స్పందించలేను. ప్రోగ్రామ్ చివరిదానికి వెళ్ళదు మరియు నేను ఎందుకు గుర్తించలేను: "ఉంటే లెన్ (లైన్)> 1:"
    నేను మీ జవాబు కోసం ఎదురు చూస్తుంటాను.
    Gracias