Polymorphism ใน Python ด้วย EXAMPLES

Polymorphism คืออะไร?

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

ในบทช่วยสอน Python Polymorphism คุณจะได้เรียนรู้:

• Polymorphism คืออะไร?
• ความหลากหลายในตัวดำเนินการ
• ความหลากหลายในวิธีการที่ผู้ใช้กำหนด
• ความหลากหลายในฟังก์ชัน
• ความหลากหลายและการสืบทอด
• ความแตกต่างกับวิธีการเรียน
• ความแตกต่างระหว่างวิธีการโอเวอร์โหลดและ Polymorphism เวลาคอมไพล์

ความหลากหลายในตัวดำเนินการ

ตัวดำเนินการใน Python ช่วยดำเนินการทางคณิตศาสตร์และงานเขียนโปรแกรมอื่นๆ อีกหลายอย่าง ตัวอย่างเช่น ตัวดำเนินการ '+' ช่วยในการเพิ่มระหว่างประเภทจำนวนเต็มสองประเภทใน Python และในทำนองเดียวกัน โอเปอเรเตอร์เดียวกันจะช่วยในการเชื่อมสตริงในการเขียนโปรแกรม Python

ให้เรายกตัวอย่างของตัวดำเนินการ + (บวก) ใน Python เพื่อแสดงแอปพลิเคชันของ Polymorphism ใน Python ดังที่แสดงด้านล่าง:

รหัสหลาม:

p = 55
q = 77
r = 9.5
g1 = "ปราชญ์"
g2 = "99!"
พิมพ์ ("ผลรวมของตัวเลขสองตัว", p + q)
print("ชนิดข้อมูลของผลลัพธ์คือ",type(p + q))
print("ผลรวมของตัวเลขสองตัว",q + r)
พิมพ์ ("ประเภทข้อมูลของผลลัพธ์คือ" ประเภท (q + r))
พิมพ์ ("สตริงที่ต่อกันคือ", g1 + g2)
print("ประเภทข้อมูลของสองสตริง",type(g1 + g2))

เอาท์พุท:

ผลรวมของสองตัวเลข 132
ชนิดข้อมูลของผลลัพธ์คือ <class 'int'>

ผลรวมของทั้งสองตัวเลข 86.5
ชนิดข้อมูลของผลลัพธ์คือ <class 'float'>

สตริงที่ต่อกันคือ Guru99!
ชนิดข้อมูลของสองสตริง <class 'str'>

ตัวอย่างข้างต้นถือได้ว่าเป็นตัวอย่างของการโอเวอร์โหลดโอเปอเรเตอร์

 

ความหลากหลายในวิธีการที่ผู้ใช้กำหนด

วิธีการกำหนดโดยผู้ใช้ในภาษาการเขียนโปรแกรม Python เป็นวิธีที่ผู้ใช้สร้างขึ้นและประกาศโดยใช้คำหลัก def พร้อมชื่อฟังก์ชัน

ความแตกต่างในภาษาการเขียนโปรแกรม Python ทำได้โดยวิธีการโอเวอร์โหลดและการแทนที่ Python กำหนดวิธีการด้วยคำหลัก def และมีชื่อเดียวกันทั้งในคลาสลูกและพาเรนต์

ให้เรายกตัวอย่างดังต่อไปนี้ที่แสดงด้านล่าง: –

รหัสหลาม:

จากคณิตศาสตร์
นำเข้าpi
คลาสสแควร์:
    def __init__ (ตัวเอง, ความยาว):
    self.l = ความยาว
def ปริมณฑล (ตัวเอง):
    ส่งคืน 4 * (self.l)
พื้นที่ def (ตัวเอง):
    กลับ self.l * self.l
วงคลาส:
    def __init__ (ตัวเอง, รัศมี):
    self.r = รัศมี
def ปริมณฑล (ตัวเอง):
    ส่งคืน 2 * pi * self.r
พื้นที่ def (ตัวเอง):
    ส่งคืน pi * self.r * * 2
#เริ่มต้นคลาส
sqr = สี่เหลี่ยม (10)
c1 = วงกลม(4)
print("ปริมณฑลคำนวณสำหรับสี่เหลี่ยม: ", sqr.perimeter())
print("พื้นที่คำนวณสำหรับสี่เหลี่ยม: ", sqr.area())
print("ปริมณฑลคำนวณสำหรับ Circle: ", c1.perimeter())
print("พื้นที่คำนวณสำหรับ Circle: ", c1.area())

เอาท์พุท:

ปริมณฑลคำนวณสำหรับสี่เหลี่ยมจัตุรัส: 40
พื้นที่คำนวณสำหรับตาราง: 100
เส้นรอบวงคำนวณสำหรับวงกลม: 25.132741228718345
พื้นที่คำนวณสำหรับ Circle: 50.26548245743669

ในโค้ดด้านบนนี้ มีวิธีที่ผู้ใช้กำหนดสองวิธี คือ ปริมณฑลและพื้นที่ ซึ่งกำหนดไว้ในคลาสวงกลมและสี่เหลี่ยม

ดังที่แสดงไว้ข้างต้น ทั้งคลาสแบบวงกลมและคลาสสแควร์เรียกชื่อเมธอดเดียวกันเพื่อแสดงคุณสมบัติของโพลิมอร์ฟิซึมเพื่อส่งมอบเอาต์พุตที่ต้องการ

ความหลากหลายในฟังก์ชัน

ฟังก์ชันในตัวใน Python ได้รับการออกแบบและรองรับการรันข้อมูลหลายประเภท ใน Python Len()เป็นหนึ่งในฟังก์ชั่นที่สำคัญในตัว

ใช้งานได้กับข้อมูลหลายประเภท: รายการ ทูเพิล สตริง และพจนานุกรม ฟังก์ชัน Len () ส่งคืนข้อมูลที่แน่นอนซึ่งสอดคล้องกับข้อมูลหลายประเภทเหล่านี้

รูปต่อไปนี้แสดงวิธีการใช้ Polymorphism ใน Python ที่สัมพันธ์กับฟังก์ชันที่สร้างขึ้น: –

โปรแกรมต่อไปนี้ช่วยในการอธิบายการประยุกต์ใช้ Polymorphism ใน Python: –

รหัสหลาม:

พิมพ์ ("ความยาวของสตริง Guru99 คือ ",len("Guru99"))
print("ความยาวของรายการคือ ,len(["Guru99","Example","Reader"]))
print("ความยาวของพจนานุกรมคือ ",len({"ชื่อเว็บไซต์":"Guru99","Type":"Education"}))

เอาท์พุท:

ความยาวของสาย Guru99 คือ 6
ความยาวของรายการคือ3
ความยาวของพจนานุกรมคือ2

ในตัวอย่างข้างต้น ฟังก์ชัน Len () ของ Python ดำเนินการ Polymorphism สำหรับประเภทข้อมูลสตริง รายการ และพจนานุกรม ตามลำดับ

ความหลากหลายและการสืบทอด

การสืบทอดใน Python สามารถกำหนดเป็นแนวคิดการเขียนโปรแกรมที่คลาสย่อยกำหนดคุณสมบัติสืบทอดจากคลาสฐานอื่นที่มีอยู่ใน Python

มีสองแนวคิดหลักของ Python ที่เรียกว่า method overriding และ method overloading

• ในการโอเวอร์โหลดเมธอด Python มีคุณสมบัติในการสร้างเมธอดที่มีชื่อเดียวกันเพื่อดำเนินการหรือรันฟังก์ชันต่างๆ ในส่วนโค้ดที่กำหนด อนุญาตให้ใช้วิธีการโอเวอร์โหลดและใช้เพื่อทำงานต่าง ๆ ในแง่ที่ง่ายกว่า
• ในการแทนที่เมธอด Python จะแทนที่ค่าที่ใช้ชื่อที่คล้ายกันในคลาสพาเรนต์และคลาสย่อย

ให้เรายกตัวอย่างต่อไปนี้ของ Polymorphism and inheritance ดังที่แสดงด้านล่าง: –

รหัสหลาม:

คลาสเบสคลาส:
    def __init__ (ตัวเอง, ชื่อ):
    self.name = ชื่อ
def area1(ตัวเอง):
    ผ่าน
def __str__(ตัวเอง):
    กลับชื่อตัวเอง
คลาสสี่เหลี่ยมผืนผ้า (เบสคลาส):
    def __init__(ตัวเอง ความยาว ความกว้าง):
    super().__init__("สี่เหลี่ยมผืนผ้า")
self.length = ความยาว
self.breadth = ความกว้าง
def area1(ตัวเอง):
    กลับความยาวตัวเอง * self.breadth
คลาสสามเหลี่ยม(เบสคลาส):
    def __init__(ตัวเอง ความสูง ฐาน):
    super().__init__("สามเหลี่ยม")
self.height = ความสูง
self.base = ฐาน
def area1(ตัวเอง):
    ผลตอบแทน (self.base * self.height) / 2
a = สี่เหลี่ยมผืนผ้า (90, 80)
b = สามเหลี่ยม(77, 64)
print("รูปร่างคือ: ", b)
print("พื้นที่ของรูปทรงคือ", b.area1())
พิมพ์ ("รูปร่างคือ:", ก)
print("พื้นที่ของรูปทรงคือ", a.area1())

เอาท์พุท:

รูปร่างคือ: สามเหลี่ยม
พื้นที่ของรูปทรงคือ 2464.0

รูปร่างคือ: สี่เหลี่ยมผืนผ้า
พื้นที่ของรูปทรงคือ 7200

ในโค้ดข้างต้น เมธอดมีชื่อเดียวกับเมธอด init และเมธอด area1 วัตถุของคลาสสแควร์และสี่เหลี่ยมจะใช้เพื่อเรียกใช้ทั้งสองวิธีเพื่อทำงานที่แตกต่างกันและให้ผลลัพธ์ของพื้นที่ของสี่เหลี่ยมและสี่เหลี่ยม

ความแตกต่างกับวิธีการเรียน

การเขียนโปรแกรม Python ช่วยให้โปรแกรมเมอร์บรรลุ Polymorphism และการโอเวอร์โหลดเมธอดด้วยเมธอดของคลาส คลาสต่างๆ ใน ​​Python สามารถมีเมธอดที่ประกาศในชื่อเดียวกันในโค้ด Python

ใน Python สามารถกำหนดคลาสที่แตกต่างกันได้สองคลาส คลาสแรกจะเป็นคลาสลูก และมาจากแอททริบิวจากคลาสอื่นที่กำหนดไว้ซึ่งเรียกว่าคลาสพาเรนต์

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงแนวคิดของ Polymorphism ด้วยวิธีการเรียน: –

รหัสหลาม:

คลาสอเมซอน:
    def __init__(ตัวเอง, ชื่อ, ราคา):
    self.name = ชื่อ
self.price = ราคา
ข้อมูล def (ตัวเอง):
    print("นี่คือผลิตภัณฑ์และคลาส am ถูกเรียกใช้ ชื่อคือ {self.name} ค่าใช้จ่ายนี้ {self.price} รูปี")
ฟลิปคาร์ทคลาส:
    def __init__(ตัวเอง, ชื่อ, ราคา):
    self.name = ชื่อ
self.price = ราคา
ข้อมูล def (ตัวเอง):
    พิมพ์ (f "นี่คือผลิตภัณฑ์และคลาส fli ถูกเรียกใช้ ชื่อคือ {self.name} ค่าใช้จ่ายนี้ {self.price} รูปี")
FLP = flipkart ("iPhone", 2.5)
AMZ = อเมซอน ("ไอโฟน", 4)
สำหรับ product1 ใน (FLP, AMZ):
    product1.info()

เอาท์พุท:

นี่คือผลิตภัณฑ์ และคลาส fli ถูกเรียกใช้ ชื่อคือ iPhone และมีราคา 2.5 รูปี
นี่คือผลิตภัณฑ์ และคลาส am ถูกเรียกใช้ ชื่อคือ iPhone และมีราคา 4 รูปี

ในโค้ดด้านบน คลาสที่แตกต่างกันสองคลาสที่ตั้งชื่อเป็น flipkart และ amazon ใช้ชื่อเมธอดเดียวกัน info และ init เพื่อเสนอราคาผลิตภัณฑ์ตามลำดับ และแสดงแนวคิดของ Polymorphism เพิ่มเติมใน Python

ความแตกต่างระหว่างวิธีการโอเวอร์โหลดและ Polymorphism เวลาคอมไพล์

ในเวลาคอมไพล์ Polymorphism คอมไพเลอร์ของโปรแกรม Python จะแก้ไขการโทร Compile-time Polymorphism ทำได้โดยใช้วิธีการโอเวอร์โหลด

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

สรุป:

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

Read More

วัตถุที่เปลี่ยนแปลงได้และไม่เปลี่ยนแปลงใน Python

ตถุกลายพันธุ์คืออะไร?

Mutable ใน Python สามารถกำหนดเป็นวัตถุที่สามารถเปลี่ยนแปลงหรือถือได้ว่าเป็นสิ่งที่เปลี่ยนแปลงได้ในธรรมชาติ เปลี่ยนแปลงได้ หมายถึงความสามารถในการแก้ไขหรือแก้ไขค่า

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

ในบทช่วยสอน Python นี้ คุณจะได้เรียนรู้:

• วัตถุกลายพันธุ์คืออะไร?
• วัตถุที่ไม่เปลี่ยนรูปคืออะไร?
• ใน Python ทุกอย่างคืออ็อบเจกต์
• วัตถุที่ไม่แน่นอนใน Python
• วัตถุที่ไม่เปลี่ยนรูปใน Python
• ความหมายสำหรับคีย์พจนานุกรมใน Python
• ข้อยกเว้นในการไม่เปลี่ยนรูป
• วัตถุที่เปลี่ยนแปลงได้กับวัตถุที่ไม่เปลี่ยนรูป
• Python ชนิดข้อมูลที่ไม่เปลี่ยนรูป

วัตถุที่ไม่เปลี่ยนรูปคืออะไร?

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

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

ใน Python ทุกอย่างคืออ็อบเจกต์

ในภาษาโปรแกรม Python ทุกสิ่งถือได้ว่าเป็นวัตถุที่ประกอบด้วยรายการ จำนวนเต็ม และฟังก์ชัน คุณลักษณะนี้สามารถเปรียบเทียบได้กับภาษาโปรแกรมอื่น ๆ ที่สนับสนุนอ็อบเจ็กต์

คุณลักษณะนี้สามารถตรวจสอบได้โดยใช้ล่าม Python ดังที่แสดงด้านล่าง: –

 

 

 

รหัสหลาม:

print("อินสแตนซ์ต่อไปนี้เป็นวัตถุ:",isinstance(3,object))
พิมพ์ ("อินสแตนซ์อื่นสำหรับวัตถุ", isinstance (จริง, วัตถุ))
def my_func():
    ส่งคืน "guru99"
print("นี่คือตัวอย่างฟังก์ชันและถือเป็นวัตถุใน Python:", isinstance(my_func, object))

เอาท์พุท:

อินสแตนซ์ต่อไปนี้เป็นวัตถุ: True
อีกตัวอย่างหนึ่งสำหรับวัตถุ True
นี่คือตัวอย่างฟังก์ชันและถือเป็นวัตถุใน Python: True

นอกจากนี้ Python ยังมีฟังก์ชันในตัวที่ชื่อว่า id ซึ่งส่งคืนที่อยู่ของอ็อบเจ็กต์ตามที่ปรากฏในหน่วยความจำของภาษาการเขียนโปรแกรม Python

รหัสหลาม:

z = 200
รหัส(z)
print("id ของวัตถุคือ",z)

เอาท์พุท:

รหัสของวัตถุคือ 9795360

ในโค้ดข้างต้น ฟังก์ชัน id ที่มีไวยากรณ์เป็น id(obj) จะให้ที่อยู่ของ obj ในหน่วยความจำ Python มีวัตถุชื่อ z และมีการกำหนดค่า 200 จากนั้นวัตถุ z จะถูกส่งไปยังฟังก์ชัน id เป็น id(z) และ Python จะส่งที่อยู่ของวัตถุเป็น 9795360

วัตถุที่ไม่แน่นอนใน Python

ในอ็อบเจ็กต์ที่เปลี่ยนแปลงได้ ค่าของอ็อบเจ็กต์จะเปลี่ยนแปลงในช่วงเวลาหนึ่ง

ในตัวอย่างนี้ เราได้อธิบายอ็อบเจกต์ที่เปลี่ยนแปลงได้ใน Python และสิ่งนี้ใช้รายการเป็นแอปพลิเคชั่นของอ็อบเจกต์ที่เปลี่ยนแปลงได้ดังแสดงด้านล่าง: –

รหัสหลาม:

mut_list = [1, 2, 3]
  print("รายการใน Python",mut_list)
mut_list[0] = 'Gurru99'
mut_list
  print("รายการใน Python หลังจากเปลี่ยนค่า",mut_list)

เอาท์พุท:

รายการใน Python [1, 2, 3]
รายการใน Python หลังจากเปลี่ยนค่า ['Gurru99', 2, 3]

ดังที่เราเห็นในตัวอย่างข้างต้น รายการที่ไม่แน่นอนใน Python มีค่าเท่ากับ 1,2,3 องค์ประกอบแรกของรายการที่เปลี่ยนแปลงได้จะเปลี่ยนจาก 1 เป็น Guru99 และจะไม่สร้างวัตถุใหม่เมื่อมีการเริ่มต้นค่าใหม่

ที่นี่เราสามารถใช้วิธี id เพื่อใช้งานได้ ต่อไปนี้แสดงให้เห็นถึงการใช้วิธีการ id สำหรับวัตถุที่เปลี่ยนแปลงได้ดังแสดงด้านล่าง: –

รหัสหลาม:

mut_list = [1, 2, 3]
print("รายการใน Python",mut_list)
print("id ของรายการคือ ,id(mut_list))
mut_list[0] = 'Gurru99'
mut_list
print("รายการ mut ใน Python หลังจากเปลี่ยนค่า",mut_list)
print("id ของรายการคือการเปลี่ยนแปลงค่าภายหลัง",id(mut_list))

เอาท์พุต

รายการใน Python [1, 2, 3]
รหัสของรายการคือ 139931568729600
รายการใน Python หลังจากเปลี่ยนค่า ['Gurru99', 2, 3]
id ของรายการคือโพสต์การเปลี่ยนแปลงค่า 139931568729600

รูปต่อไปนี้แสดงอ็อบเจกต์ที่เปลี่ยนแปลงได้ใน Python ดังแสดงด้านล่าง: –

วัตถุที่ไม่เปลี่ยนรูปใน Python

ออบเจ็กต์ที่ไม่เปลี่ยนรูปใน Python คืออ็อบเจ็กต์ที่อินสแตนซ์ไม่เปลี่ยนแปลงตลอดช่วงเวลา อินสแตนซ์ที่ไม่เปลี่ยนรูปของประเภทเฉพาะ เมื่อสร้างแล้ว จะไม่เปลี่ยนแปลง และสามารถตรวจสอบได้โดยใช้วิธี id ของ Python

ให้เรายกตัวอย่างวัตถุประเภทจำนวนเต็มใน Python ที่แสดงแนวคิดของวัตถุที่ไม่เปลี่ยนรูปใน Python ดังแสดงด้านล่าง: –

รหัสหลาม:

ก=244
print("จำนวนก่อนเปลี่ยนคือ",a)
print("id ของตัวเลขก่อนการเปลี่ยนแปลงคือ",id(a))
a=344
print("ตัวเลขหลังการเปลี่ยนแปลงคือ",a)
print("id ของตัวเลขหลังการเปลี่ยนแปลงคือ",id(a))

เอาท์พุต

ตัวเลขก่อนการเปลี่ยนแปลงคือ 244
id ของตัวเลขก่อนการเปลี่ยนแปลงคือ 9796768
ตัวเลขก่อนเปลี่ยนคือ 344
id ของตัวเลขก่อนการเปลี่ยนแปลงคือ 140032307887024

จะเห็นได้ว่ามีการเปลี่ยนแปลงใน "a" มาศึกษาว่ากลไกทำงานอย่างไร:

• ไม่มีการเปลี่ยนแปลงในค่าของวัตถุเมื่อเริ่มต้น "a" ด้วย 344
• แต่จะมีการสร้างวัตถุใหม่และล้อมรอบด้วย "a"
• วัตถุอื่นที่กำหนดเป็น 244 จะไม่สามารถเข้าถึงได้อีกต่อไป
• ตัวอย่างข้างต้นใช้วัตถุจำนวนเต็ม

ที่ a=244 วัตถุใหม่จะถูกสร้างขึ้นและอ้างอิงถึง “a” ดังที่แสดงด้านล่าง: –

โพสต์โดยใช้ a=344 มีอ็อบเจ็กต์ใหม่ที่อ้างอิงด้วย “a” ไดอะแกรมต่อไปนี้แสดงถึงสิ่งเดียวกัน: –

ดังนั้นเมื่อใดก็ตามที่มีการกำหนดค่าใหม่ให้กับชื่อของประเภท int จะมีการเปลี่ยนแปลงในการผูกชื่อกับวัตถุอื่น หลักการเดียวกันนี้สอดคล้องกับ tuples, strings, float และ Boolean จึงเรียกว่าไม่เปลี่ยนรูป

ความหมายสำหรับคีย์พจนานุกรมใน Python

พจนานุกรมสามารถกำหนดเป็นคอลเลกชันที่เรียงลำดับซึ่งเก็บข้อมูลในรูปแบบคีย์และไม่อนุญาตให้ทำซ้ำ พจนานุกรมมีหนึ่งคีย์ซึ่งมีคู่ค่าที่สอดคล้องกันซึ่งจัดตำแหน่งไว้ พวกมันเปลี่ยนแปลงได้ในประเภท และเนื้อหาสามารถเปลี่ยนแปลงได้แม้หลังจากเริ่มต้นและการสร้าง

ในช่วงเวลาใด ๆ ประเด็นสำคัญจะชี้ไปที่องค์ประกอบเฉพาะอย่างใดอย่างหนึ่งในแต่ละครั้ง กุญแจของพจนานุกรมไม่เปลี่ยนรูป

 

ให้เราใช้สถานการณ์สมมติที่แสดงด้านล่าง: –

ก = [4, 6]
ข = [5, 6, 7]
my_dict = {a: 'x', b: 'y'}
พิมพ์ (my_dict)

ผลลัพธ์: – โค้ด Python ด้านบนไม่ได้ให้ผลลัพธ์ใดๆ และจะสร้างข้อผิดพลาดประเภทประเภทที่ไม่สามารถแฮชได้แทน นี่เป็นสถานการณ์สมมติและไม่ได้ใช้ในคอมไพเลอร์ Python

ในที่นี้aถูกกำหนดเป็น [4,6] และในพจนานุกรมถูกกำหนดเป็น x ในที่นี้bถูกกำหนดเป็น [5,6,7] และในพจนานุกรมถูกกำหนดเป็น y

• คีย์ 'a' มีค่า [4,6] และกำหนดค่าเริ่มต้นเพิ่มเติมเป็น x
• คีย์ 'b' มีค่าเป็น [5,6,7] ซึ่งกำหนดค่าเริ่มต้นเพิ่มเติมเป็น 'y' ในพจนานุกรม
• สมมติว่าค่าของ ' aต่อท้ายด้วย 5 และ 7 ซึ่งเป็นกุญแจสำคัญสำหรับพจนานุกรม
• จากนั้นพจนานุกรมก็กลายพันธุ์และจะให้ทั้ง'x'และ'y'เป็นค่าสำหรับพจนานุกรมด้านบน

พิจารณาสถานการณ์สมมติต่อไปนี้ตามภาพประกอบด้านบน: –

ก = [5, 6,7]
ข = [5, 6, 7]
my_dict = {a: 'x', b: 'y'}
พิมพ์ (my_dict)

ดังนั้น ในฐานะภาษาโปรแกรม Python ทำให้คีย์ของพจนานุกรมไม่เปลี่ยนรูป และพจนานุกรมเป็นประเภทข้อมูลที่ไม่เปลี่ยนรูป

ข้อยกเว้นในการไม่เปลี่ยนรูป

อย่างไรก็ตาม Python ให้ข้อยกเว้นสำหรับความไม่เปลี่ยนรูป ข้อยกเว้นดังกล่าวสามารถสังเกตได้สำหรับประเภทวัตถุทูเปิล ทูเพิลสามารถเป็นการรวมกันของประเภทอ็อบเจ็กต์ที่ไม่แน่นอนและไม่เปลี่ยนรูป ให้เรายกตัวอย่างเพื่ออธิบายข้อยกเว้นในการไม่เปลี่ยนรูปดังที่แสดงด้านล่าง: –

รหัสหลาม:

tupexample=([1,1],'guru99')
print("ทูเพิลก่อนการเปลี่ยนแปลง",ทูเพิล)
print("id ของ tuple ก่อนเปลี่ยน",id(tupexample))
tupexample=([2,2],'guru99')
print("ทูเพิลหลังการเปลี่ยนแปลง",ทูเพิล)
print("id ของ tuple หลังจากเปลี่ยน",id(tupexample))

เอาท์พุท:

ทูเพิลก่อนการเปลี่ยนแปลง ([1, 1], 'guru99')
id ของ tuple ก่อนการเปลี่ยนแปลง 140649480694656
ทูเพิลหลังการเปลี่ยนแปลง ([2, 2], 'guru99')
id ของ tuple หลังจากเปลี่ยน 140649480694592

คุณสามารถเห็นได้ในโค้ดด้านบนว่าองค์ประกอบแรกซึ่งเป็นรายการนั้นไม่สามารถเปลี่ยนแปลงได้ ในขณะที่ tuple นั้นไม่สามารถเปลี่ยนแปลงได้ ค่าของ tuple ไม่สามารถเปลี่ยนแปลงได้ แต่เนื้อหาของรายการที่อยู่ใน tuple สามารถเปลี่ยนค่าได้

ดังนั้น สิ่งนี้ทำให้เกิดข้อยกเว้นว่าอ็อบเจ็กต์ที่ไม่เปลี่ยนรูปไม่ได้เปลี่ยนค่าของพวกมัน แต่ค่าขององค์ประกอบจะเปลี่ยนค่าของพวกมัน

วัตถุที่เปลี่ยนแปลงได้กับวัตถุที่ไม่เปลี่ยนรูป

ต่อไปนี้เป็นข้อแตกต่างที่สำคัญระหว่าง Mutable และ Immutable Objects:

วัตถุที่ไม่แน่นอน	วัตถุที่ไม่เปลี่ยนรูป
สถานะวัตถุสามารถเปลี่ยนแปลงได้เมื่อสร้างแล้ว	เมื่อสร้างแล้วจะไม่สามารถเปลี่ยนสถานะวัตถุได้
ออบเจ็กต์ที่เปลี่ยนแปลงได้ไม่ถือว่าปลอดภัยสำหรับเธรด	วัตถุที่ไม่เปลี่ยนรูปจะถือเป็นเธรดที่ปลอดภัยในธรรมชาติ
อ็อบเจ็กต์ที่เปลี่ยนแปลงได้ไม่ได้ถูกสร้างให้เสร็จสิ้น และด้วยเหตุนี้โปรแกรมเมอร์จึงสามารถเปลี่ยนแปลงอ็อบเจ็กต์ที่เปลี่ยนแปลงได้และใช้อ็อบเจ็กต์เดียวกัน	มันเป็นสิ่งสำคัญที่จะทำให้คลาสสุดท้ายเมื่อมีการสร้างอ็อบเจกต์ที่ไม่เปลี่ยนรูป

Python ชนิดข้อมูลที่ไม่เปลี่ยนรูป:

ระดับ	คำอธิบาย	ไม่เปลี่ยนรูปหรือไม่
บูล	ค่าบูลีน	ไม่เปลี่ยนรูป
Int	ค่าจำนวนเต็ม (ขนาดสามารถกำหนดเองได้)	ไม่เปลี่ยนรูป
ลอย	เลขทศนิยม	ไม่เปลี่ยนรูป
รายการ	ลำดับของวัตถุที่มีลักษณะไม่แน่นอน	เปลี่ยนแปลงได้
ทูเปิล	ลำดับของวัตถุธรรมชาติที่ไม่เปลี่ยนรูป	ไม่เปลี่ยนรูป
สตรัท	ตัวละคร /สตริง	ไม่เปลี่ยนรูป
ชุด	ชุดของวัตถุแตกต่างที่มีลักษณะไม่เป็นระเบียบ	เปลี่ยนแปลงได้
Frozenset	กำหนดระดับของธรรมชาติที่ไม่เปลี่ยนรูป	ไม่เปลี่ยนรูป
Dict	การทำแผนที่พจนานุกรมหรือการเชื่อมโยง	เปลี่ยนแปลงได้

Read More

ตัวอย่างฟังก์ชันหลักและเมธอดของ Python

ฟังก์ชั่นหลักของ Python คืออะไร?

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

ฟังก์ชั่น def main () ใน Python คืออะไร? เพื่อให้เข้าใจสิ่งนี้ ให้พิจารณาโค้ดตัวอย่างต่อไปนี้

def main() ตัวอย่าง 1

def หลัก ():
     พิมพ์ ("สวัสดีชาวโลก!")
พิมพ์ ("Guru99")

ในที่นี้ เราได้งานพิมพ์สองชิ้น โดยชุดแรกถูกกำหนดไว้ในฟังก์ชันหลักคือ "Hello World!" และอีกอันหนึ่งเป็นอิสระซึ่งก็คือ “Guru99” เมื่อคุณเรียกใช้ฟังก์ชัน def main ():

• พิมพ์ “Guru99” เท่านั้น
• และไม่ใช่รหัส “Hello World!”

เป็นเพราะเราไม่ได้ประกาศฟังก์ชันการเรียก “if__name__== “__main__”

เป็นสิ่งสำคัญที่หลังจากกำหนดฟังก์ชันหลักแล้ว คุณต้องเรียกใช้โค้ดโดย if__name__== “__main__” จากนั้นรันโค้ด จากนั้นคุณจะได้รับผลลัพธ์ “hello world!” ในคอนโซลการเขียนโปรแกรม พิจารณารหัสต่อไปนี้

def main() ตัวอย่าง 2

def หลัก ():
    พิมพ์ ("สวัสดีชาวโลก!")

ถ้า __name__ == "__main__":
    หลัก()

พิมพ์("Guru99")

 

 

 

EXPLORE MORELearn Java Programming with Beginners Tutorial08:32Linux Tutorial for Beginners: Introduction to Linux Operating...01:35What is Integration Testing Software Testing Tutorial03:04What is JVM (Java Virtual Machine) with Architecture JAVA...02:24How to write a TEST CASE Software Testing Tutorial01:08Seven Testing Principles Software Testing05:01Linux File Permissions Commands with Examples13:29How to use Text tool in Photoshop CC Tutorial08:32What is NoSQL Database Tutorial02:00Important Linux Commands for Beginners Linux Tutorial15:03

Guru99 ถูกพิมพ์ในกรณีนี้

 

นี่คือคำอธิบาย

• เมื่อล่าม Python อ่านไฟล์ต้นฉบับ มันจะรันโค้ดทั้งหมดที่พบในไฟล์นั้น
• เมื่อ Python รัน “source file” เป็นโปรแกรมหลัก มันจะตั้งค่าตัวแปรพิเศษ (__name__) ให้มีค่า (“__main__”)
• เมื่อคุณรันฟังก์ชันหลักใน python มันจะอ่านคำสั่ง "if" และตรวจสอบว่า __name__ เท่ากับ __main__ หรือไม่
• ใน Python “if__name__== “__main__”อนุญาตให้คุณเรียกใช้ไฟล์ Python ในรูปแบบโมดูลที่ใช้ซ้ำได้หรือโปรแกรมแบบสแตนด์อโลน

ตัวแปร __name__ และ Python Module

เพื่อให้เข้าใจถึงความสำคัญของตัวแปร __name__ ในวิธีฟังก์ชันหลักของ Python ให้พิจารณาโค้ดต่อไปนี้:

def หลัก ():
    พิมพ์ ("สวัสดีชาวโลก!")

ถ้า __name__ == "__main__":
    หลัก()

พิมพ์("Guru99")

พิมพ์ ("ค่าในชื่อตัวแปรที่สร้างขึ้นคือ: ",__name__)

ตอนนี้ให้พิจารณาว่าโค้ดถูกนำเข้าเป็นโมดูล

นำเข้า MainFunction

พิมพ์ ("เสร็จสิ้น")

นี่คือคำอธิบายรหัส:

 

เช่นเดียวกับ C Python ใช้ == เพื่อเปรียบเทียบในขณะที่ = สำหรับการมอบหมาย ตัวแปล Python ใช้ฟังก์ชันหลักในสองวิธี

 

วิ่งตรง:

• __name__=__main__
• if statement == True และสคริปต์ใน _main_ จะถูกดำเนินการ

นำเข้าเป็นโมดูล

• __name__= ชื่อไฟล์ของโมดูล
• if statement == false และสคริปต์ใน __main__ จะไม่ถูกดำเนินการ

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

ตัวอย่างด้านบนคือโค้ด Python 3 หากคุณต้องการใช้ Python 2 โปรดพิจารณาโค้ดต่อไปนี้

def หลัก ():
  พิมพ์ "สวัสดีชาวโลก!"
  
ถ้า __name__== "__main__":
  หลัก()

พิมพ์ "คุรุ99"

ใน Python 3 คุณไม่จำเป็นต้องใช้ if__name รหัสต่อไปนี้ยังใช้งานได้

def หลัก ():
  พิมพ์ ("สวัสดีชาวโลก!")
  
หลัก()
พิมพ์("Guru99")

หมายเหตุ:ตรวจสอบให้แน่ใจว่าหลังจากกำหนดฟังก์ชั่นหลักแล้ว คุณเว้นการเยื้องไว้บางส่วนและไม่ได้ประกาศโค้ดด้านล่างฟังก์ชัน def main(): ไม่เช่นนั้นจะทำให้เกิดข้อผิดพลาดในการเยื้อง

Read More

การเรียก การเยื้อง อาร์กิวเมนต์ & ค่าส่งคืน

ฟังก์ชั่นใน Python คืออะไร?

ฟังก์ชันในไพธอนคือส่วนของโค้ดที่ทำงานเมื่อมีการอ้างอิง มันถูกใช้เพื่อใช้ประโยชน์จากรหัสมากกว่าหนึ่งแห่งในโปรแกรม เรียกอีกอย่างว่าวิธีการหรือขั้นตอน Python มีฟังก์ชัน inbuilt มากมาย เช่น print(), input(), compile(), exec() เป็นต้น แต่ยังให้อิสระในการสร้างฟังก์ชันของคุณเอง

 

 

วิธีกำหนดและเรียกใช้ฟังก์ชันใน Python

ฟังก์ชั่นใน Python ถูกกำหนดโดย คำสั่ง “def ”ตามด้วยชื่อฟังก์ชันและวงเล็บ ( () )

ตัวอย่าง:

ให้เรากำหนดฟังก์ชันโดยใช้คำสั่ง ” def func1():” และเรียกใช้ฟังก์ชัน ผลลัพธ์ของฟังก์ชันจะเป็น"ฉันกำลังเรียนรู้ฟังก์ชัน Python"

 

ฟังก์ชันprint func1()เรียก def func1(): และพิมพ์คำสั่ง ” ฉันกำลังเรียนรู้ฟังก์ชัน Python None“

มีชุดของกฎใน Python เพื่อกำหนดฟังก์ชัน

• อาร์กิวเมนต์หรือพารามิเตอร์อินพุตควรอยู่ในวงเล็บเหล่านี้
• คำสั่งแรกของฟังก์ชันอาจเป็นคำสั่งทางเลือกก็ได้- docstring หรือสตริงเอกสารประกอบของฟังก์ชัน
• รหัสภายในทุกฟังก์ชันเริ่มต้นด้วยเครื่องหมายทวิภาค (:) และควรเยื้อง (เว้นวรรค)
• คำสั่ง return (นิพจน์) ออกจากฟังก์ชัน โดยเลือกส่งกลับค่าไปยังผู้โทร คำสั่ง return ที่ไม่มี args เหมือนกับ return ไม่มี

ความสำคัญของการเยื้อง (ช่องว่าง) ใน Python

ก่อนที่เราจะทำความคุ้นเคยกับฟังก์ชัน Python สิ่งสำคัญคือเราต้องเข้าใจกฎการเยื้องเพื่อประกาศฟังก์ชัน Python และกฎเหล่านี้ใช้ได้กับองค์ประกอบอื่นๆ ของ Python เช่นเดียวกับการประกาศเงื่อนไข ลูป หรือตัวแปร

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

 

ตอนนี้ เมื่อคุณเพิ่มการเยื้อง (เว้นวรรค) หน้าฟังก์ชัน "print" ควรพิมพ์ตามที่คาดไว้

 

อย่างน้อย การเยื้องเพียงครั้งเดียวก็เพียงพอแล้วที่จะทำให้โค้ดของคุณทำงานสำเร็จ แต่ตามแนวทางปฏิบัติที่ดีที่สุด แนะนำให้เว้นวรรค 3-4 เพื่อเรียกใช้ฟังก์ชันของคุณคุณ

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

ตอนนี้เมื่อเราใช้การเยื้องเดียวกันสำหรับทั้งสองคำสั่งและจัดแนวในบรรทัดเดียวกัน จะให้ผลลัพธ์ที่คาดไว้

ฟังก์ชันคืนค่าอย่างไร

คำสั่ง return ใน Python ระบุค่าที่จะคืนให้กับผู้เรียกใช้ฟังก์ชัน มาทำความเข้าใจกับตัวอย่างต่อไปนี้กัน

ขั้นตอนที่ 1) ฟังก์ชั่นไม่ส่งคืนสิ่งใด

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

ขั้นตอนที่ 2) แทนที่คำสั่งพิมพ์ด้วยคำสั่งการมอบหมาย

เพื่อให้ชัดเจนยิ่งขึ้น เราแทนที่คำสั่งพิมพ์ด้วยคำสั่งการมอบหมาย มาตรวจสอบผลลัพธ์กัน

เมื่อคุณเรียกใช้คำสั่ง “print square (4)” มันจะคืนค่าของอ็อบเจกต์จริง ๆ เนื่องจากเราไม่มีฟังก์ชันเฉพาะใด ๆ ที่จะเรียกใช้ที่นี่ มันจะส่งคืน “ไม่มี”

ขั้นตอนที่ 3) ใช้ฟังก์ชัน 'return' และรันโค้ด

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

ขั้นตอนที่ 4) เรียกใช้คำสั่ง 'print square'

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

อาร์กิวเมนต์ในฟังก์ชัน

อาร์กิวเมนต์คือค่าที่ส่งผ่านไปยังฟังก์ชันเมื่อมีการเรียก

กล่าวอีกนัยหนึ่งในด้านการโทร มันคืออาร์กิวเมนต์ และด้านฟังก์ชัน มันคือพารามิเตอร์

มาดูกันว่า Python Args ทำงานอย่างไร –

ขั้นตอนที่ 1)อาร์กิวเมนต์ถูกประกาศในนิยามฟังก์ชัน ขณะเรียกใช้ฟังก์ชัน คุณสามารถส่งผ่านค่าสำหรับ args นั้นดังที่แสดงด้านล่าง

ขั้นตอนที่ 2)ในการประกาศค่าเริ่มต้นของอาร์กิวเมนต์ กำหนดค่าที่นิยามฟังก์ชัน

ตัวอย่าง: x ไม่มีค่าเริ่มต้น ค่าเริ่มต้นของ y=0 เมื่อเราใส่อาร์กิวเมนต์เพียงตัวเดียวในขณะที่เรียกใช้ฟังก์ชันการคูณ Python จะกำหนดค่าที่ให้มาให้กับ x โดยที่ยังคงค่าของ y=0 ไว้ ดังนั้นการคูณของ x*y=0

ขั้นตอนที่ 3)คราวนี้เราจะเปลี่ยนค่าเป็น y=2 แทนที่จะเป็นค่าเริ่มต้น y=0 และจะคืนค่าเอาต์พุตเป็น (4×2)=8

ขั้นตอนที่ 4)คุณยังสามารถเปลี่ยนลำดับในการส่งผ่านอาร์กิวเมนต์ใน Python ที่นี่เราได้กลับลำดับของค่า x และ y เป็น x=4 และ y=2

ขั้นตอนที่ 5)หลายอาร์กิวเมนต์สามารถส่งผ่านเป็นอาร์เรย์ได้ ในตัวอย่างนี้ เราเรียก args หลายตัว (1,2,3,4,5) โดยการเรียกใช้ฟังก์ชัน (*args)

ตัวอย่าง:เราประกาศ args หลายตัวเป็นตัวเลข (1,2,3,4,5) เมื่อเราเรียกใช้ฟังก์ชัน (*args) มันพิมพ์ออกมาเป็น (1,2,3,4,5)

เคล็ดลับ :

• ในไพทอน 2.7 ไม่รองรับ ฟังก์ชั่นโอเวอร์โหลดใน Python Function Overloading คือความสามารถในการสร้างเมธอดหลายเมธอดที่มีชื่อเดียวกันพร้อมการใช้งานที่แตกต่างกัน รองรับฟังก์ชั่นโอเวอร์โหลดใน Python 3 . อย่างสมบูรณ์
• มีความสับสนระหว่างวิธีการและการทำงานค่อนข้างมาก เมธอดใน Python เชื่อมโยงกับอินสแตนซ์ของอ็อบเจ็กต์ในขณะที่ฟังก์ชันไม่ได้ใช้งาน เมื่อ Python เรียกใช้เมธอด มันจะผูกพารามิเตอร์แรกของการเรียกนั้นกับการอ้างอิงอ็อบเจ็กต์ที่เหมาะสม กล่าวง่ายๆ ฟังก์ชันสแตนด์อโลนใน Python คือ "ฟังก์ชัน" ในขณะที่ฟังก์ชันที่เป็นแอตทริบิวต์ของคลาสหรืออินสแตนซ์คือ "เมธอด"

นี่คือรหัส Python 3 ที่สมบูรณ์

#กำหนดฟังก์ชั่น
def func1():
   พิมพ์ ("ฉันกำลังเรียนรู้ฟังก์ชัน Python")
   พิมพ์ ("ยังอยู่ใน func1")
   
func1()

def สแควร์ (x):
  	กลับ x*x
พิมพ์(สี่เหลี่ยม(4))

def คูณ (x,y=0):
	พิมพ์ ("ค่าของ x=",x)
	พิมพ์ ("ค่าของ y=",y)
    
	ส่งคืน x*y
  
พิมพ์(คูณ(y=2,x=4))

นี่คือรหัส Python 2 ที่สมบูรณ์

#กำหนดฟังก์ชั่น
def func1():
   พิมพ์ "ฉันกำลังเรียนรู้ฟังก์ชัน Python"
   พิมพ์ "ยังอยู่ใน func1"
   
func1()

def สแควร์ (x):
  	กลับ x*x
พิมพ์สี่เหลี่ยม(4)

def คูณ (x,y=0):
	พิมพ์"ค่าของ x=",x
	พิมพ์"ค่าของ y=",y
    
	ส่งคืน x*y
  
พิมพ์คูณ(y=2,x=4)

สรุป:

ฟังก์ชันใน Python เป็นโค้ดที่ใช้ซ้ำได้ซึ่งใช้ในการดำเนินการเดี่ยวที่เกี่ยวข้อง ในบทความนี้เราจะเห็น

• ฟังก์ชันที่กำหนดโดยคำสั่งdef
• บล็อกโค้ดภายในทุกฟังก์ชันเริ่มต้นด้วยโคลอน (:) และควรเยื้อง (เว้นวรรค)
• อาร์กิวเมนต์หรือพารามิเตอร์อินพุตควรอยู่ในวงเล็บเหล่านี้ ฯลฯ
• ควรเว้นการเยื้องอย่างน้อยหนึ่งรายการก่อนโค้ดหลังจากประกาศฟังก์ชัน
• รูปแบบการเยื้องเดียวกันควรคงไว้ตลอดทั้งโค้ดภายในฟังก์ชัน def
• สำหรับแนวทางปฏิบัติที่ดีที่สุด สามหรือสี่เยื้องถือว่าดีที่สุดก่อนคำสั่ง
• คุณสามารถใช้คำสั่ง "return" เพื่อคืนค่าการเรียกใช้ฟังก์ชัน
• Python จะพิมพ์ค่าสุ่มเช่น (0x021B2D30) เมื่ออาร์กิวเมนต์ไม่ถูกส่งไปยังฟังก์ชันการเรียก ตัวอย่าง “ฟังก์ชั่นการพิมพ์”
• ด้านการโทร มันคืออาร์กิวเมนต์ และด้านฟังก์ชัน มันคือพารามิเตอร์
• ค่าเริ่มต้นในอาร์กิวเมนต์ – เมื่อเราระบุอาร์กิวเมนต์เพียงตัวเดียวขณะเรียกใช้ฟังก์ชันการคูณหรือฟังก์ชันอื่นๆ Python จะกำหนดอาร์กิวเมนต์อื่นตามค่าเริ่มต้น
• Python ช่วยให้คุณสามารถย้อนกลับลำดับของอาร์กิวเมนต์ได้เช่นกัน

Read More