แนะนำ Python

Prelude

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

หากกำลังมองหาหลักสูตร MOOC เสริม ให้ลองดูหลักสูตรจาก Udacity และ Coursera (เบื้องต้นเกี่ยวกับการเขียนโปรแกรม [สำหรับผู้เริ่มต้น] หรือเบื้องต้นเกี่ยวกับ 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 วิธีที่ง่ายที่สุดในการเรียกใช้ก็คือใช้คำสั่ง Shell "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] คืออาร์กิวเมนต์แรก และอื่นๆ หากคุณรู้เกี่ยวกับ argc หรือจำนวนอาร์กิวเมนต์ คุณขอค่านี้จาก 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 วิธีในการทําซ้ำสตริงโดยใช้โอเปอเรเตอร์ + ซึ่งใช้งานง่ายกว่า แต่ * ก็ทํางานได้เช่นกันเนื่องจากเป็นโอเปอเรเตอร์ "repeat" ของ Python ซึ่งหมายความว่า '-' * 10 จะแสดงผลเป็น '----------' ซึ่งเป็นวิธีที่ยอดเยี่ยมในการสร้าง "บรรทัด" บนหน้าจอ ในความคิดเห็นโค้ด เราได้บอกเป็นนัยว่า * ทํางานเร็วกว่า + เนื่องจาก * จะคํานวณขนาดของออบเจ็กต์ที่ได้เพียงครั้งเดียว แต่ + จะคํานวณทุกครั้งที่มีการเรียกใช้ ทั้ง + และ * เรียกว่าโอเปอเรเตอร์ "ที่มีการทำงานหลายอย่าง" เนื่องจากมีความหมายต่างกันสำหรับตัวเลขกับสตริง (และข้อมูลประเภทอื่นๆ)

คีย์เวิร์ด def จะกำหนดฟังก์ชันที่มีพารามิเตอร์ภายในวงเล็บและโค้ดเยื้อง บรรทัดแรกของฟังก์ชันอาจเป็นสตริงเอกสารประกอบ ("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 นั้นดูแปลกๆ ไปหน่อยในตอนแรก แต่มีความเป็นเหตุผลและเราพบว่าตัวเองปรับตัวได้อย่างรวดเร็ว หลีกเลี่ยงการใช้แท็บเนื่องจากจะทำให้รูปแบบการเยื้องซับซ้อนขึ้นมาก (ไม่รวมถึงแท็บ อาจหมายถึงการใช้งานที่แตกต่างกันในแพลตฟอร์มต่างๆ) ตั้งค่าตัวแก้ไขให้แทรกการเว้นวรรคแทน TABs สำหรับโค้ด 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" หากเป็นรายการ tuples ข้อผิดพลาดพื้นฐานหลายประการของ Python เกิดจากความผิดพลาดที่ลืมไปว่าค่าแต่ละประเภทอยู่ในตัวแปรใด ดังนั้นให้ใช้ชื่อตัวแปร (ทั้งหมดที่คุณมี) เพื่อช่วยในการจัดระเบียบ

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

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

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

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

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

  import sys

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

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

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

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

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

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

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

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

ภายในโปรแกรมแปลภาษา Python ฟังก์ชัน help() จะดึงสตริงเอกสารประกอบสำหรับโมดูล ฟังก์ชัน และเมธอดต่างๆ สตริงเอกสารเหล่านี้คล้ายกับ 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