แนะนำ Python

Prelude

ยินดีต้อนรับสู่บทแนะนำ Python ออนไลน์ของ Google โดยอิงตามหลักสูตร Python เบื้องต้นที่เปิดสอนภายใน ดังที่ได้กล่าวไว้ในหน้าการตั้งค่า เนื้อหานี้ครอบคลุม Python 3

หากกำลังมองหาหลักสูตร MOOC ที่เกี่ยวข้อง ให้ลองดูหลักสูตรจาก Udacity และ Coursera (intro to programming [ผู้เริ่มต้น] หรือ intro to Python) สุดท้ายนี้ หากคุณกำลังมองหาการเรียนรู้ออนไลน์แบบศึกษาด้วยตนเองโดยไม่ต้องดูวิดีโอ ให้ลองดูหลักสูตรที่ระบุไว้ในช่วงท้ายของโพสต์นี้ ซึ่งแต่ละหลักสูตรจะมีเนื้อหาการเรียนรู้และอินเทอร์พรีเตอร์แบบอินเทอร์แอกทีฟของ Python ที่คุณสามารถใช้ฝึกฝนได้ "ล่าม" ที่เราพูดถึงคืออะไร คุณจะทราบได้ในส่วนถัดไป

ข้อมูลเบื้องต้นเกี่ยวกับภาษา

Python เป็นภาษาแบบไดนามิกที่แปลโดยอินเทอร์พรีเตอร์ (คอมไพล์เป็นไบต์โค้ด) ไม่มีการประกาศประเภทของตัวแปร พารามิเตอร์ ฟังก์ชัน หรือเมธอดในซอร์สโค้ด ซึ่งจะทำให้โค้ดสั้นและยืดหยุ่น แต่คุณจะเสียการตรวจสอบประเภทของซอร์สโค้ดในเวลาคอมไพล์ Python จะติดตามประเภทของค่าทั้งหมดในขณะรันไทม์ และแจ้งว่าโค้ดที่ไม่มีความหมายเมื่อมีการเรียกใช้

วิธีที่ยอดเยี่ยมในการดูว่าโค้ด Python ทำงานอย่างไรคือการเรียกใช้ตัวแปล Python และพิมพ์โค้ดลงในตัวแปลนั้นโดยตรง หากคุณมีคำถามเช่น "จะเกิดอะไรขึ้นหากฉันเพิ่ม int ใน list" การพิมพ์คำถามลงในตัวแปล Python เป็นวิธีที่รวดเร็วและอาจเป็นวิธีที่ดีที่สุดในการดูว่าเกิดอะไรขึ้น (ดูด้านล่างเพื่อดูสิ่งที่เกิดขึ้นจริง)

$ python3        ## Run the Python interpreter
Python 3.X.X (XXX, XXX XX XXXX, XX:XX:XX) [XXX] on XXX
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 6       ## set a variable in this interpreter session
>>> a           ## entering an expression prints its value
6
>>> a + 2
8
>>> a = 'hi'    ## 'a' can hold a string just as well
>>> a
'hi'
>>> len(a)      ## call the len() function on a string
2
>>> a + len(a)  ## try something that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
>>> a + str(len(a))  ## probably what you really wanted
'hi2'
>>> foo         ## try something else that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'foo' is not defined
>>> ^D          ## type CTRL-d to exit (CTRL-z in Windows/DOS terminal)

บรรทัด 2 บรรทัดที่ Python พิมพ์หลังจากที่คุณพิมพ์ python และก่อนพรอมต์ >>> จะบอกข้อมูลเกี่ยวกับ เวอร์ชันของ Python ที่คุณใช้และตำแหน่งที่สร้าง ตัวอย่างเหล่านี้ควรใช้ได้ตราบใดที่สิ่งแรกที่พิมพ์คือ "Python 3."

ดังที่เห็นด้านบน การทดสอบตัวแปรและตัวดำเนินการนั้นทำได้ง่าย นอกจากนี้ ตัวแปลยังส่งข้อผิดพลาดรันไทม์ (หรือที่เรียกว่า "ยก" ในภาษา Python) หากโค้ดพยายามอ่านตัวแปรที่ยังไม่ได้กำหนดค่า Python เป็นภาษาที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เช่นเดียวกับ C++ และ Java ดังนั้น "a" และ "A" จึงเป็นตัวแปรที่แตกต่างกัน การสิ้นสุดบรรทัดจะหมายถึงการสิ้นสุดของคำสั่ง ดังนั้น Python จึงไม่จำเป็นต้องมีเซมิโคลอนที่ท้ายคำสั่งแต่ละคำสั่ง ซึ่งแตกต่างจาก C++ และ Java ความคิดเห็นจะเริ่มต้นด้วย '#' และสิ้นสุดที่ท้ายบรรทัด

ซอร์สโค้ด Python

ไฟล์ต้นฉบับของ Python จะใช้นามสกุล ".py" และเรียกว่า "โมดูล" เมื่อใช้โมดูล Python hello.py วิธีที่ง่ายที่สุดในการรันคือใช้คำสั่งเชลล์ "python hello.py Alice" ซึ่งจะเรียกใช้ตัวแปล Python เพื่อดำเนินการโค้ดใน hello.py โดยส่งอาร์กิวเมนต์บรรทัดคำสั่ง "Alice" ไปให้ ดูหน้าเอกสารอย่างเป็นทางการเกี่ยวกับตัวเลือกต่างๆ ที่คุณมีเมื่อเรียกใช้ Python จากบรรทัดคำสั่ง

ต่อไปนี้คือโปรแกรม hello.py ที่เรียบง่ายมาก (โปรดสังเกตว่าบล็อกของโค้ดจะคั่นอย่างเคร่งครัดโดยใช้การเยื้องแทนที่จะใช้เครื่องหมายปีกกา ซึ่งเราจะพูดถึงเรื่องนี้ในภายหลัง)

#!/usr/bin/python3

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
    print('Hello there', sys.argv[1])
    # Command line args are in sys.argv[1], sys.argv[2] ...
    # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
    main()

การเรียกใช้โปรแกรมนี้จากบรรทัดคำสั่งจะมีลักษณะดังนี้

$ python3 hello.py Guido
Hello there Guido
$ ./hello.py Alice  ## without needing 'python3' first (Unix)
Hello there Alice

การนำเข้า อาร์กิวเมนต์บรรทัดคำสั่ง และ len()

คำสั่งที่อยู่นอกสุดในไฟล์ Python หรือ "โมดูล" จะทำการตั้งค่าแบบครั้งเดียว โดยคำสั่งเหล่านั้นจะทำงานจากบนลงล่างในครั้งแรกที่มีการนำเข้าโมดูลที่ใดที่หนึ่ง ซึ่งจะตั้งค่าตัวแปรและฟังก์ชัน คุณสามารถรันโมดูล Python ได้โดยตรง ดังที่แสดงไว้ข้างต้น python3 hello.py Bob หรือจะนำเข้าและใช้โมดูลนั้นกับโมดูลอื่นๆ ก็ได้ เมื่อเรียกใช้ไฟล์ Python โดยตรง ระบบจะตั้งค่าตัวแปรพิเศษ "__name__" เป็น "__main__" ดังนั้นจึงเป็นเรื่องปกติที่จะมีข้อความมาตรฐาน if __name__ ==... ที่แสดงด้านบนเพื่อเรียกใช้ฟังก์ชัน main() เมื่อโมดูลทำงานโดยตรง แต่จะไม่เรียกใช้เมื่อโมดูลถูกนำเข้าโดยโมดูลอื่น

ในโปรแกรม Python มาตรฐาน ลิสต์ sys.argv จะมีอาร์กิวเมนต์บรรทัดคำสั่งในลักษณะมาตรฐาน โดย sys.argv[0] จะเป็นโปรแกรมเอง, sys.argv[1] จะเป็นอาร์กิวเมนต์แรก และอื่นๆ หากทราบเกี่ยวกับ argv หรือจำนวนอาร์กิวเมนต์ คุณก็ขอค่านี้จาก Python ได้ง่ายๆ ด้วย len(sys.argv) เช่นเดียวกับที่เราทำในโค้ดอินเทอร์พรีเตอร์แบบอินเทอร์แอกทีฟด้านบนเมื่อขอความยาวของสตริง โดยทั่วไป len() จะบอกความยาวของสตริง จำนวนองค์ประกอบในลิสต์และทูเพิล (โครงสร้างข้อมูลอีกแบบที่คล้ายอาร์เรย์) และจำนวนคู่คีย์-ค่าในพจนานุกรม

ฟังก์ชันที่ผู้ใช้กำหนด

ฟังก์ชันใน Python มีการกำหนดดังนี้

# Defines a "repeat" function that takes 2 arguments.
def repeat(s, exclaim):
    """
    Returns the string 's' repeated 3 times.
    If exclaim is true, add exclamation marks.
    """

    result = s + s + s # can also use "s * 3" which is faster (Why?)
    if exclaim:
        result = result + '!!!'
    return result

นอกจากนี้ ให้สังเกตว่าบรรทัดที่ประกอบกันเป็นฟังก์ชันหรือคำสั่ง if จะจัดกลุ่มโดยมีระดับการเยื้องเดียวกัน นอกจากนี้ เรายังนำเสนอ 2 วิธีที่แตกต่างกันในการทำซ้ำสตริง โดยใช้ตัวดำเนินการ + ซึ่งเป็นมิตรกับผู้ใช้มากกว่า แต่ * ก็ใช้ได้เช่นกันเนื่องจากเป็นตัวดำเนินการ "ทำซ้ำ" ของ Python ซึ่งหมายความว่า '-' * 10 จะให้ผลลัพธ์เป็น '----------' ซึ่งเป็นวิธีที่ยอดเยี่ยมในการสร้าง "บรรทัด" บนหน้าจอ ในความคิดเห็นของโค้ด เราได้บอกใบ้ว่า * ทำงานได้เร็วกว่า + เนื่องจาก * จะคำนวณขนาดของออบเจ็กต์ผลลัพธ์เพียงครั้งเดียว ในขณะที่ + จะคำนวณทุกครั้งที่มีการเรียกใช้ + ทั้ง + และ * เรียกว่าตัวดำเนินการ "โอเวอร์โหลด" เนื่องจากมีความหมายต่างกันสำหรับตัวเลขและสตริง (รวมถึงประเภทข้อมูลอื่นๆ)

คีย์เวิร์ด def จะกำหนดฟังก์ชันที่มีพารามิเตอร์ภายในวงเล็บและโค้ดที่เยื้อง บรรทัดแรกของฟังก์ชันอาจเป็นสตริงเอกสาร ("docstring") ที่อธิบายสิ่งที่ฟังก์ชันทำ Docstring อาจเป็นคำอธิบายแบบบรรทัดเดียวหรือหลายบรรทัดก็ได้ ดังตัวอย่างด้านบน (ใช่แล้ว นั่นคือ "เครื่องหมายคำพูด 3 ตัว" ซึ่งเป็นฟีเจอร์เฉพาะของ Python) ตัวแปรที่กำหนดในฟังก์ชันจะเป็นตัวแปรเฉพาะของฟังก์ชันนั้น ดังนั้น "result" ในฟังก์ชันข้างต้นจึงแยกจากตัวแปร "result" ในฟังก์ชันอื่น คำสั่ง return สามารถรับอาร์กิวเมนต์ได้ ในกรณีนี้ค่าที่ส่งคืนไปยังผู้เรียกคืออาร์กิวเมนต์นั้น

ต่อไปนี้คือโค้ดที่เรียกใช้ฟังก์ชัน repeat() ข้างต้นและพิมพ์ค่าที่ฟังก์ชันแสดงผล

def main():
    print(repeat('Yay', False))      ## YayYayYay
    print(repeat('Woo Hoo', True))   ## Woo HooWoo HooWoo Hoo!!!

ในเวลารันไทม์ ฟังก์ชันต้องกำหนดโดยการดำเนินการของ "def" ก่อนที่จะเรียกใช้ โดยปกติแล้วจะกำหนดฟังก์ชัน main() ไว้ที่ด้านล่างของไฟล์พร้อมกับฟังก์ชันที่เรียกใช้ไว้ด้านบน

การเยื้อง

ฟีเจอร์ Python ที่ไม่เหมือนใครอย่างหนึ่งคือการเยื้องด้วยการเว้นวรรคของโค้ดมีผลต่อความหมายของโค้ด บล็อกตรรกะของคำสั่ง เช่น บล็อกที่ประกอบกันเป็นฟังก์ชัน ควรมีการเยื้องเหมือนกันทั้งหมด โดยตั้งค่าจากการเยื้องของฟังก์ชันหลักหรือ "if" หรืออะไรก็ตาม หากบรรทัดใดบรรทัดหนึ่งในกลุ่มมีการเยื้องที่แตกต่างกัน ระบบจะแจ้งว่ามีข้อผิดพลาดทางไวยากรณ์

การใช้ช่องว่างของ Python อาจดูแปลกๆ ในตอนแรก แต่ก็สมเหตุสมผลและเราก็คุ้นเคยกับมันได้อย่างรวดเร็ว หลีกเลี่ยงการใช้ TAB เนื่องจากจะทำให้รูปแบบการเยื้องซับซ้อนขึ้นมาก (และ TAB อาจมีความหมายต่างกันในแพลตฟอร์มต่างๆ) ตั้งค่าโปรแกรมแก้ไขให้แทรกช่องว่างแทน TAB สำหรับโค้ด Python

คำถามที่ผู้เริ่มต้นมักถามคือ "ฉันควรเยื้องกี่ช่องว่าง" ตามคู่มือการเขียนโค้ด Python อย่างเป็นทางการ (PEP 8) คุณควรเยื้องด้วยช่องว่าง 4 ช่อง (ข้อเท็จจริงที่น่าสนใจ: หลักเกณฑ์ด้านสไตล์ภายในของ Google กำหนดให้เยื้องโดยใช้ 2 ช่องว่าง)

ตรวจสอบโค้ดที่รันไทม์

Python จะตรวจสอบเพียงเล็กน้อยในเวลาคอมไพล์ โดยจะเลื่อนการตรวจสอบประเภท ชื่อ ฯลฯ เกือบทั้งหมดในแต่ละบรรทัดจนกว่าบรรทัดนั้นจะทำงาน สมมติว่าฟังก์ชัน main() ข้างต้นเรียกใช้ฟังก์ชัน repeat() ดังนี้

def main():
    if name == 'Guido':
        print(repeeeet(name) + '!!!')
    else:
        print(repeat(name))

คำสั่ง if มีข้อผิดพลาดที่ชัดเจน ซึ่งฟังก์ชัน repeat() พิมพ์ผิดเป็น repeeeet() สิ่งที่น่าขำใน Python คือโค้ดนี้จะคอมไพล์และทำงานได้ดีตราบใดที่ชื่อในรันไทม์ไม่ใช่ "Guido" เฉพาะเมื่อการเรียกใช้พยายามเรียกใช้ repeeeet() จริงๆ เท่านั้น ระบบจึงจะสังเกตได้ว่าไม่มีฟังก์ชันดังกล่าวและแสดงข้อผิดพลาด นอกจากนี้ ยังมีข้อผิดพลาดที่ 2 ในข้อมูลโค้ดนี้ด้วย นั่นคือไม่ได้กำหนดค่าให้กับ name ก่อนที่จะนำไปเปรียบเทียบกับ "Guido" Python จะแสดงข้อผิดพลาด "NameError" หากคุณพยายามประเมินตัวแปรที่ไม่ได้กำหนด ตัวอย่างเหล่านี้แสดงให้เห็นว่าเมื่อคุณเรียกใช้โปรแกรม Python เป็นครั้งแรก ข้อผิดพลาดแรกๆ ที่คุณเห็นจะเป็นการพิมพ์ผิดง่ายๆ หรือตัวแปรที่ไม่ได้เริ่มต้น เช่น ตัวแปรเหล่านี้ นี่เป็นส่วนหนึ่งที่ภาษาที่มีระบบประเภทที่ละเอียดกว่า เช่น Java มีข้อได้เปรียบ เนื่องจากสามารถตรวจหาข้อผิดพลาดดังกล่าวได้ในเวลาคอมไพล์ (แต่แน่นอนว่าคุณต้องดูแลข้อมูลประเภททั้งหมดนั้น ซึ่งเป็นข้อแลกเปลี่ยน)

Python 3 เปิดตัวคำแนะนำประเภท คำแนะนำประเภทช่วยให้คุณระบุประเภทของอาร์กิวเมนต์แต่ละรายการในฟังก์ชัน รวมถึง ประเภทของออบเจ็กต์ที่ฟังก์ชันส่งคืน ตัวอย่างเช่น ในฟังก์ชันที่มีคำอธิบายประกอบ def is_positive(n: int) -> bool: อาร์กิวเมนต์ n คือ int และค่าที่ส่งคืนคือ bool เราจะพูดถึงความหมายของประเภทเหล่านี้ในภายหลัง แต่คุณจะใช้คำแนะนำประเภทหรือไม่ก็ได้ คุณจะเห็นโค้ดจำนวนมากขึ้นเรื่อยๆ ที่ใช้คำแนะนำประเภท เนื่องจากหากคุณใช้คำแนะนำประเภท เอดิเตอร์บางตัว เช่น cider-v และ VS.code จะสามารถเรียกใช้การตรวจสอบเพื่อยืนยันว่าฟังก์ชันของคุณถูกเรียกใช้ด้วย ประเภทอาร์กิวเมนต์ที่ถูกต้อง รวมถึงยังแนะนำและตรวจสอบอาร์กิวเมนต์ขณะที่คุณแก้ไขโค้ดได้ด้วย บทแนะนำนี้จะไม่ครอบคลุมคำแนะนำประเภท แต่เราต้องการให้คุณทราบถึงคำแนะนำประเภทหากได้ยินหรือเห็นคำแนะนำประเภทในที่ต่างๆ

ชื่อตัวแปร

เนื่องจากตัวแปร Python ไม่มีประเภทที่ระบุไว้ในซอร์สโค้ด การตั้งชื่อตัวแปรให้มีความหมายจึงเป็นประโยชน์อย่างยิ่งในการช่วยเตือนให้คุณทราบว่าเกิดอะไรขึ้น ดังนั้นให้ใช้ "name" หากเป็นชื่อเดียว และใช้ "names" หากเป็นรายการชื่อ และใช้ "tuples" หากเป็นรายการของทูเพิล ข้อผิดพลาดพื้นฐานหลายอย่างใน Python เกิดจากการลืมว่าตัวแปรแต่ละตัวมีค่าประเภทใด ดังนั้นให้ใช้ชื่อตัวแปร (สิ่งที่คุณมีจริงๆ) เพื่อช่วยให้ทุกอย่างเป็นไปอย่างราบรื่น

สำหรับการตั้งชื่อจริง ภาษาบางภาษาชอบใช้ underscored_parts สำหรับชื่อตัวแปรที่ประกอบด้วย "คำมากกว่า 1 คำ" แต่ภาษาอื่นๆ ชอบใช้ camelCasing โดยทั่วไปแล้ว Python ชอบใช้วิธีขีดล่าง แต่แนะนำให้นักพัฒนาแอปใช้ CamelCase หากผสานรวมกับโค้ด Python ที่มีอยู่ซึ่งใช้รูปแบบนั้นอยู่แล้ว ความอ่านง่ายมีความสำคัญ อ่านเพิ่มเติมได้ในส่วนเกี่ยวกับแบบแผนการตั้งชื่อใน PEP 8

คุณคงเดาได้ว่าคีย์เวิร์ดอย่าง "if" และ "while" ไม่สามารถใช้เป็นชื่อตัวแปรได้ หากใช้ คุณจะได้รับข้อผิดพลาดด้านไวยากรณ์ อย่างไรก็ตาม โปรดระมัดระวังอย่าใช้ฟังก์ชันในตัวเป็นชื่อตัวแปร ตัวอย่างเช่น แม้ว่า 'str', 'list' และ 'print' อาจดูเหมือนเป็นชื่อที่ดี แต่คุณจะเขียนทับตัวแปรระบบเหล่านั้น ฟังก์ชันในตัวไม่ใช่คีย์เวิร์ด ดังนั้นนักพัฒนา Python มือใหม่จึงอาจใช้ฟังก์ชันเหล่านี้โดยไม่ตั้งใจ

ข้อมูลเพิ่มเติมเกี่ยวกับโมดูลและเนมสเปซของโมดูล

สมมติว่าคุณมีโมดูล "binky.py" ซึ่งมี "def foo()" ชื่อที่สมบูรณ์ของฟังก์ชัน foo นั้นคือ "binky.foo" ด้วยวิธีนี้ โมดูล Python ต่างๆ จะตั้งชื่อฟังก์ชันและตัวแปรได้ตามต้องการ และชื่อตัวแปรจะไม่ขัดแย้งกัน กล่าวคือ module1.foo จะแตกต่างจาก module2.foo ในคำศัพท์ของ Python เราจะบอกว่า binky, module1 และ module2 แต่ละรายการมี "เนมสเปซ" ของตัวเอง ซึ่งคุณอาจเดาได้ว่าเป็นการเชื่อมโยงชื่อตัวแปรกับออบเจ็กต์

ตัวอย่างเช่น เรามีโมดูล "sys" มาตรฐานซึ่งมีฟีเจอร์ระบบมาตรฐานบางอย่าง เช่น รายการ argv และฟังก์ชัน exit() เมื่อใช้คำสั่ง "import sys" คุณจะเข้าถึงคำจำกัดความในโมดูล sys และทำให้คำจำกัดความเหล่านั้นพร้อมใช้งานได้โดยใช้ชื่อที่สมบูรณ์ เช่น sys.exit() (ใช่ "sys" ก็มีเนมสเปซด้วย)

  import sys

  # Now can refer to sys.xxx facilities
  sys.exit(0)

มีแบบฟอร์มการนำเข้าอีกแบบหนึ่งซึ่งมีลักษณะดังนี้ "from sys import argv, exit" ซึ่งจะทำให้ argv และ exit() พร้อมใช้งานโดยใช้ชื่อย่อ อย่างไรก็ตาม เราขอแนะนำให้ใช้รูปแบบเดิมที่มีชื่อแบบเต็ม เนื่องจากจะช่วยให้ระบุได้ง่ายขึ้นมากว่าฟังก์ชันหรือแอตทริบิวต์มาจากที่ใด

มีโมดูลและแพ็กเกจจำนวนมากที่มาพร้อมกับการติดตั้งโปรแกรมแปลภาษา Python มาตรฐาน คุณจึงไม่ต้องดำเนินการใดๆ เพิ่มเติมเพื่อใช้งาน ซึ่งเรียกรวมกันว่า "ไลบรารีมาตรฐานของ Python" โมดูล/แพ็กเกจที่ใช้กันโดยทั่วไป ได้แก่

• sys — access to exit(), argv, stdin, stdout, ...
• re - นิพจน์ทั่วไป
• os - อินเทอร์เฟซระบบปฏิบัติการ ระบบไฟล์

ดูเอกสารประกอบของโมดูลและแพ็กเกจทั้งหมดใน Standard Library ได้ที่ http://docs.python.org/library

ความช่วยเหลือออนไลน์ help() และ dir()

คุณขอรับความช่วยเหลือเกี่ยวกับ Python ได้หลายวิธี

• ค้นหาใน Google โดยเริ่มจากคำว่า "python" เช่น "python list" หรือ "python string lowercase" โดยปกติแล้วผลการค้นหาแรกมักจะเป็นคำตอบ เทคนิคนี้ดูเหมือนจะใช้ได้ดีกับ Python มากกว่าภาษาอื่นๆ ด้วยเหตุผลบางประการ
• เว็บไซต์เอกสารอย่างเป็นทางการของ Python — docs.python.org — มีเอกสารคุณภาพสูง อย่างไรก็ตาม เรามักพบว่าการค้นหาใน Google ด้วยคำ 2-3 คำนั้นรวดเร็วกว่า
• นอกจากนี้ยังมีรายชื่ออีเมลอย่างเป็นทางการของ Tutor ที่ออกแบบมาโดยเฉพาะสำหรับผู้ที่เพิ่งเริ่มต้นใช้งาน Python และ/หรือการเขียนโปรแกรม
• คุณสามารถดูคำถาม (และคำตอบ) จำนวนมากได้ที่ StackOverflow และ Quora
• ใช้ฟังก์ชัน help() และ dir() (ดูด้านล่าง)

ภายในตัวแปล Python ฟังก์ชัน help() จะดึงสตริงเอกสารประกอบสำหรับโมดูล ฟังก์ชัน และเมธอดต่างๆ Docstring เหล่านี้คล้ายกับ Javadoc ของ Java ฟังก์ชัน dir() จะบอกคุณว่าแอตทริบิวต์ของออบเจ็กต์คืออะไร ด้านล่างนี้คือวิธีเรียกใช้ help() และ dir() จากอินเทอร์พรีเตอร์

• help(len) — สตริงความช่วยเหลือสำหรับฟังก์ชัน len() ในตัว โปรดทราบว่าคือ "len" ไม่ใช่ "len()" ซึ่งเป็นการเรียกฟังก์ชัน ซึ่งเราไม่ต้องการ
• help(sys) - สตริงความช่วยเหลือสำหรับโมดูล sys (ต้องทำ import sys ก่อน)
• dir(sys) — dir() คล้ายกับ help() แต่จะแสดงรายการสัญลักษณ์ที่กำหนดไว้หรือ "แอตทริบิวต์" อย่างรวดเร็ว
• help(sys.exit) - สตริงความช่วยเหลือสำหรับฟังก์ชัน exit() ในโมดูล sys
• help('xyz'.split) — สตริงความช่วยเหลือสำหรับเมธอด split() สำหรับออบเจ็กต์สตริง คุณเรียกใช้ help() ด้วยออบเจ็กต์นั้นเองหรือตัวอย่างของออบเจ็กต์นั้น รวมถึงแอตทริบิวต์ของออบเจ็กต์ เช่น การโทรหา help('xyz'.split) จะเหมือนกับการโทรหา help(str.split)
• help(list) - สตริงความช่วยเหลือสำหรับออบเจ็กต์ list
• dir(list) — แสดงแอตทริบิวต์ของออบเจ็กต์ list รวมถึงเมธอดของออบเจ็กต์
• help(list.append) - สตริงความช่วยเหลือสำหรับเมธอด append() สำหรับออบเจ็กต์ list