แนะนำ Python

เกริ่นนำ

ยินดีต้อนรับสู่บทแนะนำออนไลน์ 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)

Python พิมพ์ 2 บรรทัดหลังจากที่คุณพิมพ์ 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() จะบอกคุณได้ว่าสตริงมีความยาวเท่าใด จำนวนองค์ประกอบในรายการและ tuples (โครงสร้างข้อมูลที่มีลักษณะเหมือนอาร์เรย์อีกแบบ) และจำนวนคู่คีย์-ค่าในพจนานุกรม

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

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

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

นี่คือโค้ดที่เรียกใช้ฟังก์ชัน sample() ด้านบน พิมพ์สิ่งที่จะแสดงผล:

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

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

การเยื้อง

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

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

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

ตรวจสอบโค้ดขณะรันไทม์

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

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

คำสั่ง if-statement มีข้อผิดพลาดที่ชัดเจนซึ่งพิมพ์ฟังก์ชันRepeat() เป็น repeeeet() โดยไม่ตั้งใจ เรื่องตลกใน Python ก็คือ โค้ดนี้จะคอมไพล์และทำงานได้ดีตราบใดที่ชื่อในรันไทม์ไม่ใช่ 'Guido' เฉพาะเมื่อการเรียกใช้พยายามเรียกใช้ repeeeet() จริงๆ จะพบว่าไม่มีฟังก์ชันดังกล่าวและเกิดข้อผิดพลาดขึ้น นอกจากนี้ยังมีข้อผิดพลาดที่สองในข้อมูลโค้ดนี้ ไม่ได้กำหนดค่า 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 จำนวนมากเกิดจากการลืมว่าแต่ละตัวแปรมีค่าเป็นประเภทใด ดังนั้นให้ใช้ชื่อตัวแปร (จริงๆ เท่านั้น) เพื่อช่วยให้สิ่งต่างๆ ตรงไปตรงมาเสมอ

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

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

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

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

ตัวอย่างเช่น เรามีโมดูล "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 — เข้าถึง exit(), argv, stdin, stdout, ...
• re — นิพจน์ทั่วไป
• os — อินเทอร์เฟซของระบบปฏิบัติการ ระบบไฟล์

คุณสามารถดูเอกสารของโมดูลและแพ็กเกจไลบรารีมาตรฐานได้ที่ 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 รายการ