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

ฟังก์ชั่นใน 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

องค์ประกอบข้อความใน HTML

การเพิ่มองค์ประกอบข้อความใน HTML

บทเรียนนี้เป็นส่วนหนึ่งของชุด  วิชาการเขียนโปรแกรมคอมพิวเตอร์ คุณสามารถไปที่  Intro to Programming  หากคุณต้องการเริ่มต้นตั้งแต่ต้น

องค์ประกอบ HTML ทั่วไปบางส่วนที่ประกอบกันเป็นหน้าเว็บคือองค์ประกอบข้อความ ข้อความทั้งหมดที่คุณอ่านบนเว็บไซต์นี้ เช่น ไม่ว่าจะเป็นหัวเรื่องที่อยู่ด้านบนของหน้า ส่วนหัวของส่วน หรือข้อความนี้ล้วนสร้างจากองค์ประกอบข้อความ HTML

องค์ประกอบย่อหน้า

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

<p>นี่คือย่อหน้า</p>

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

องค์ประกอบหัวเรื่อง

เช่นเดียวกับองค์ประกอบย่อหน้า องค์ประกอบส่วนหัวยังใช้เพื่อแสดงข้อความบนหน้าจอ โดยทั่วไปจะใช้เพื่อสร้างส่วนหัวของส่วน 

<h1>นี่คือองค์ประกอบส่วนหัว</h1>

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

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

พวกเขายังมาพร้อมกับสไตล์เบราว์เซอร์เริ่มต้นซึ่งช่วยเสริมลำดับความสำคัญ: <h1>องค์ประกอบใหญ่ที่สุด องค์ประกอบ<h2>เล็กกว่า และอื่นๆ

<h1>นี่คืออันที่ใหญ่ที่สุด</h1>
<h2>อันนี้เล็กกว่านิดหน่อย</h2>
<h3>อันนี้เล็กกว่าอีก</h3>
<h4>พวกมันเล็กลงเรื่อยๆ</h4>
<h5>อันนี้ไม่ใหญ่ขนาดนั้น</h5>
<h6>ตอนนี้ค่อนข้างเล็กจริงๆ</h6>

องค์ประกอบการจัดรูปแบบข้อความ

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

• B เก่า : <b> องค์ประกอบทำให้เนื้อหาเป็นตัวหนา
• ตัวเอียง : <i>องค์ประกอบทำให้เนื้อหาเป็นตัวเอียง 
• ขีดเส้นใต้ : <u>องค์ประกอบขีดเส้นใต้เนื้อหา

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

<p>คำเหล่านี้ไม่ใช่ตัวหนา แต่ <b>สองคำนี้</b>คือ</p>

HTML นั้นจะแสดงดังนี้:

ลองสิ่งนี้!

ลองทดลองกับแต่ละองค์ประกอบที่กล่าวถึงในบทเรียนนี้ในอินพุตด้านล่าง คุณสามารถป้อนสิ่งที่คุณต้องการ แต่ถ้าคุณต้องการแนวคิดบางอย่างเกี่ยวกับสิ่งที่จะป้อน ให้ลองใช้องค์ประกอบด้านล่างเป็นตัวอย่าง

<h1>ราตรีสวัสดิ์อันยาวนาน</h1>
<h3><u>บทที่ 1: เมืองและความเงียบ</u></h3>
<p>นักสืบฮาร์ดคาสเซิลตัวสั่นเมื่อได้ยินเสียงเคาะประตู เที่ยงคืนของวันเสาร์ และมีใครกำลังมองหารองเท้ายางอยู่หรือเปล่า? มันมีกลิ่นเหมือนปัญหา เพราะถ้าเขาได้เรียนรู้สิ่งหนึ่งในช่วงเวลาที่เขาเป็นตาส่วนตัว นั่นคือผีทั้งหมดของเมืองจะออกมาในเวลากลางคืน</p>
<p><i>ฉันหวังว่าคุณจะไม่หาเรื่องทะเลาะ</i> เขาคิดกับตัวเอง <i>เพราะถ้าคุณเจอ คุณก็เจอมัน</i></p>

ป้อนองค์ประกอบ HTML ของคุณในการป้อนข้อมูลที่นี่:

 

เพิ่ม CSS ของเรา 

 

ทำด้วยตัวคุณเอง!

เปิด   ไฟล์  index.html ของโครงการบทช่วย สอนการเขียนโปรแกรม GCF  ในโปรแกรมแก้ไขข้อความ แล้วเพิ่ม  องค์ประกอบข้อความ เพื่อความเข้าใจที่ดีที่สุด อย่าลืมพิมพ์โค้ดนี้จริงๆ แทนที่จะคัดลอกและวาง 

1. เมื่อคุณสร้างไฟล์นี้เป็นครั้งแรก คุณมีองค์ประกอบเนื้อหาจริงหนึ่งรายการในหน้านี้แล้ว ก่อนอื่นให้ค้นหาองค์ประกอบนั้น:

   <p>สวัสดีชาวโลก!</p>

2. ไปข้างหน้าและ  ลบองค์ประกอบนั้น 
3. เรามาเริ่มสร้างบางสิ่งที่เหมือนหน้าเว็บจริงที่คุณอาจเห็นในชีวิตประจำแทน: หน้าเว็บบทวิจารณ์ภาพยนตร์ เริ่มต้นด้วย  หัวข้อและตรวจสอบให้แน่ใจว่าได้ใส่ไว้ใน  <body> องค์ประกอบ โดยที่ <p>องค์ประกอบของคุณเคยอยู่มาก่อน: 

   <h1>บทวิจารณ์ภาพยนตร์คลาสสิกของ Cinema</h1>

4. ด้านล่างให้เพิ่ม  หัวข้อย่อย แม้ว่าหัวเรื่องแรกจะเป็นหัวเรื่องหลักของหน้าเว็บทั้งหมดของคุณ แต่หัวเรื่องนี้จะเป็นเพียงหัวเรื่องสำหรับบทวิจารณ์ภาพยนตร์ฟอร์มยักษ์ที่แต่งขึ้น: 

   <h2>รีวิว: Basketball Dog (2018)</h2>

5. ตอน นี้ขอเพิ่ม  ข้อความ นี่คือเนื้อแท้ของบทวิจารณ์ของคุณ ดังนั้นจึงมีคำอื่นๆ อีกมาก แต่โปรดสังเกตว่าคำเหล่านั้นยังคงถูกห่อด้วย  <p> แท็กง่ายๆ หนึ่งคำสำหรับแต่ละย่อหน้า เพิ่มสิ่งนี้ใต้  <h1> องค์ประกอบที่คุณเพิ่งเพิ่ม:

   <p>4 จาก 5 ดาว</p>
   <p>จากผู้กำกับวิคกี เฟลมมิง สู่เรื่องราวอันอบอุ่นของเด็กชายชื่อพีท (เทรนต์ ดักสัน) และโรเวอร์ สุนัขของเขา (ให้เสียงโดยบรินสัน ลัมเบิลบรันต์) คุณอาจคิดว่าเด็กผู้ชายกับสุนัขของเขาเรียนรู้คุณค่าที่แท้จริงของมิตรภาพฟังดูคุ้นเคย แต่การหักมุมครั้งใหญ่ทำให้ภาพยนตร์เรื่องนี้แตกต่างออกไป นั่นคือ Rover เล่นบาสเก็ตบอล และเขาก็เล่นเก่งไม่แพ้กัน</p>
   <p>แม้ว่าอาจไม่จำเป็นต้องรวมเกมการแข่งขันชิงแชมป์ของ Rover ทั้ง 150 นาทีแบบเรียลไทม์ แต่ Basketball Dog จะทำให้คุณสนใจตลอดรันไทม์ 4 ชั่วโมง และตอนจบจะทำให้คนรักสุนัขต้องเสียน้ำตา หากคุณรักกีฬาบาสเก็ตบอลหรือสัตว์เลี้ยง นี่คือภาพยนตร์สำหรับคุณ</p>
   <p>ค้นหารายชื่อนักพากย์ทั้งหมดได้ที่เว็บไซต์ Basketball Dog</p>
   

6. เนื่องจากเธอเป็นผู้กำกับภาพยนตร์ ดูเหมือนว่า "วิคกี เฟลมมิง" อาจเป็นชื่อที่สำคัญที่สุดในย่อหน้าเหล่านั้น ดังนั้นมาทำให้เป็น  ตัวหนา เพื่อดึงดูดความสนใจให้มากขึ้น ห่อชื่อนั้นด้วย  <b> และ  </b> แท็ก เช่น: 

   <b>วิกกี้ เฟลมมิ่ง</b>

7. นอกจากนี้ อาจเป็นความคิดที่ดีที่จะกำหนดระดับดาวนอกเหนือจากข้อความที่เหลือด้วย ลองตัวเอียงที่จะแยกมัน ตัดเฉพาะคำเหล่านั้นด้วย แท็ <i>ก</i>เช่น:

   <p><i>4 จาก 5 ดาว</i></p>

เมื่อคุณทำทั้งหมดนี้แล้ว โค้ดที่สมบูรณ์ของคุณควรมีลักษณะดังนี้:

<html>
  <เนื้อหา>
    <h1>บทวิจารณ์ภาพยนตร์คลาสสิกของ Cinema</h1>
    <h2>รีวิว: Basketball Dog (2018)</h2>
    <p><i>4 จาก 5 ดาว</i></p>
    <p>จากผู้กำกับ <b>วิคกี เฟลมมิง</b> สู่เรื่องราวอันอบอุ่นของเด็กชายชื่อพีท (เทรนต์ ดักสัน) และโรเวอร์ สุนัขของเขา (ให้เสียงโดยบรินสัน ลัมเบิลบรันต์) คุณอาจคิดว่าเด็กผู้ชายกับสุนัขของเขาเรียนรู้คุณค่าที่แท้จริงของมิตรภาพฟังดูคุ้นเคย แต่การหักมุมครั้งใหญ่ทำให้ภาพยนตร์เรื่องนี้แตกต่างออกไป นั่นคือ Rover เล่นบาสเก็ตบอล และเขาก็เล่นเก่งไม่แพ้กัน</p>
    <p>แม้ว่าอาจไม่จำเป็นต้องรวมเกมการแข่งขันชิงแชมป์ของ Rover ทั้ง 150 นาทีแบบเรียลไทม์ แต่ Basketball Dog จะทำให้คุณสนใจตลอดรันไทม์ 4 ชั่วโมง และตอนจบจะทำให้คนรักสุนัขต้องเสียน้ำตา หากคุณรักกีฬาบาสเก็ตบอลหรือสัตว์เลี้ยง นี่คือภาพยนตร์สำหรับคุณ</p>
    <p>ค้นหารายชื่อนักพากย์ทั้งหมดได้ที่เว็บไซต์ Basketball Dog</p>
  </body>
</html>

ดับเบิลคลิก  ไฟล์ index.html ของคุณ  เพื่อโหลดในเบราว์เซอร์ และคุณจะเห็นสิ่งนี้ หน้าเว็บของคุณเริ่มดูเหมือนหน้าเว็บจริงมากขึ้น!

Read More

การเพิ่มรายการใน HTML

การเพิ่มรายการใน HTML

 

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

รายการที่ไม่เรียงลำดับ

องค์ประกอบรายการ ที่ไม่มีลำดับมีลักษณะดังนี้:

<ul></ul>

อย่างไรก็ตาม แท็กเหล่านี้ไม่ได้ทำอะไรเลย ซึ่งไม่เหมือนกับที่คุณเคยเห็นมาก่อน หากต้องการแสดงเนื้อหาเป็นรายการ คุณต้องมีองค์ประกอบ HTML สองรายการที่ทำงานร่วมกันได้แก่ ตัวรายการเอง เช่น<ul>องค์ประกอบด้านบน และ องค์ประกอบ รายการซึ่งอยู่ภายใน:

<ul>
  <li>นี่คือรายการ</li>
  <li>นี่คือรายการที่สอง</li>
  <li>สามรายการตรงนี้</li>
</ul>

ในรายการที่ไม่เรียงลำดับเช่นนี้ เบราว์เซอร์ของคุณจะไม่แสดงอะไรเลยสำหรับ ตัวแท็ก <ul>และ</ul>ตัวแท็กเอง แต่จะถือว่าเป็นคำแนะนำในการแสดง<li>องค์ประกอบภายในแทน รายการที่ไม่เรียงลำดับจะบอกเบราว์เซอร์ให้แสดงแต่ละรายการด้วยสัญลักษณ์แสดงหัวข้อย่อยตามค่าเริ่มต้น หากคุณจะโหลดตัวอย่างนั้นในเบราว์เซอร์ มันจะมีลักษณะดังนี้:

รายการที่สั่งซื้อ

องค์ประกอบ รายการสั่งซื้อมีลักษณะดังนี้:

<ol></ol>

โครงสร้างขององค์ประกอบรายการที่เรียงลำดับนั้นโดยพื้นฐานแล้วจะเหมือนกับของรายการที่ไม่เรียงลำดับ: <ol>องค์ประกอบคือราก และองค์ประกอบจำนวนเท่าใดก็ได้<li>ที่อยู่ภายใน:

<ol>
  <li>นี่คือรายการ</li>
  <li>นี่คือรายการที่สอง</li>
  <li>สามรายการตรงนี้</li>
</ol>

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

Read More

ลิงค์และรูปภาพใน HTML

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

แอตทริบิวต์ HTML 

 

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

ชื่อ = "ค่า"

ตัวอย่างเช่น นี่คือองค์ประกอบที่มีแอตทริบิวต์ HTML ซึ่งชื่อคือ "id" และค่าคือ "myParagraph":

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

ลิงค์ 

 

องค์ประกอบ HTML สำหรับลิงก์เรียกว่าองค์ประกอบจุดยึด องค์ประกอบสมอที่ไม่มีแอตทริบิวต์ HTML อาจมีลักษณะดังนี้:

<a>คลิกฉัน</a>

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

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

<a href="https://edu.gcfglobal.org/">คลิกฉัน</a>

เพิ่มสองชิ้นที่นี่:

• ชื่อแอตทริบิวต์ : ในกรณีนี้ ชื่อคือ  hrefและจะเหมือนกันสำหรับองค์ประกอบจุดยึดใดๆ ไม่ว่าคุณต้องการให้ไปที่ใด ย่อมาจาก Hypertext Reference แต่สิ่งที่คุณต้องจำก็คือhref เช่นเดียวกับแอตทริบิวต์ส่วนใหญ่ จะมีเครื่องหมายเท่ากับนำหน้าค่าตามหลัง
• ค่าแอตทริบิวต์ : ขึ้นอยู่กับตำแหน่งที่คุณต้องการให้ลิงก์ไป ค่าใดๆ ที่คุณป้อนในที่นี้ควรอยู่ในเครื่องหมายคำพูด และสำหรับตัวอย่างนี้คือหน้าแรกของไซต์นี้: "https://edu.gcfglobal.org/"

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

Read More

องค์ประกอบเชิงโต้ตอบใน HTML

การเพิ่มองค์ประกอบแบบโต้ตอบใน HTML

บทเรียนนี้เป็นส่วนหนึ่งของชุด  วิชาการเขียนโปรแกรมคอมพิวเตอร์ คุณสามารถไปที่  Intro to Programming  หากคุณต้องการเริ่มต้นตั้งแต่ต้น

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

ปุ่ม

 

องค์ประกอบ HTML สำหรับปุ่มคือสิ่งที่คุณคาดเดาได้:

<ปุ่ม>กดฉัน</ปุ่ม>

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

   

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

<ปุ่ม>
  <img src="https://media.gcflearnfree.org/global/coding/hamburger-button.png">
</ปุ่ม>

ในเบราว์เซอร์จะแสดงดังนี้:

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

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

อินพุต

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

แต่ละตัวเลือกเหล่านี้เป็นอินพุต HTML ประเภท หนึ่ง ตัวอย่างเช่น สิ่งเหล่านี้เป็นองค์ประกอบสำหรับการป้อนข้อความ (เช่น สิ่งที่คุณพิมพ์ชื่อผู้ใช้หรือรหัสผ่านลงไป) และการป้อนข้อมูลในช่องทำเครื่องหมาย :

<ประเภทการป้อนข้อมูล="ข้อความ">
<ประเภทอินพุต = "ช่องทำเครื่องหมาย">

ขอให้สังเกตว่าพวกเขาใช้องค์ประกอบ HTML เดียวกัน โดย มี ค่าแอตทริบิวต์ HTML<input>ต่างกัน ค่าเหล่านี้ให้ข้อมูลเพียงพอแก่เบราว์เซอร์เพื่อแสดงสองสิ่งที่แตกต่างกันโดยสิ้นเชิงเมื่อโหลด:

การป้อนข้อความ 

 

ช่องทำเครื่องหมาย 

ในทางกลับกัน การป้อนข้อมูลแบบเลื่อนลงจะทำโดยใช้องค์ประกอบที่เลือกซึ่งมีองค์ประกอบตัวเลือก จำนวน หนึ่ง HTML จะมีลักษณะดังนี้:

<เลือก>
  <option>ตัวเลือกแรก</option>
  <option>อีกอันหนึ่ง</option>
  <option>กลุ่มตัวเลือกที่นี่</option>
</เลือก>

องค์ประกอบนี้มีโครงสร้างคล้ายกับ องค์ประกอบ <ol>and <ul>ที่คุณใช้สร้างรายการ นั่นเป็นเพราะ<select>องค์ประกอบนั้นไม่แสดง แต่จะทำหน้าที่เป็นคำแนะนำเพื่อบอกเบราว์เซอร์ถึงวิธีแสดง<option>องค์ประกอบที่ซ้อนอยู่ภายใน หากคุณต้องการแสดง HTML ข้างต้นในเบราว์เซอร์ คุณจะเห็นสิ่งนี้: 

      ตัวเลือกแรก        อีกอันหนึ่ง        ตัวเลือกมากมายที่นี่

Read More

Python TUPLE – แพ็ค, แกะ, เปรียบเทียบ, สไลซ์, ลบ, คีย์

Tuple Matching ใน Python คืออะไร?

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

ไวยากรณ์ทูเปิล

Tup = ('ม.ค.', 'ก.พ.', 'มีนาคม')

ในการเขียนทูเพิลว่าง คุณต้องเขียนเป็นวงเล็บสองอันที่ไม่มีอะไร-

blunt1 = ();

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

ทื่อ1 = (50,);

ดัชนีทูเพิลเริ่มต้นที่ 0 และสามารถนำมาต่อกัน หั่นเป็นแว่น และอื่นๆ ได้

ในบทช่วยสอนนี้ เราจะเรียนรู้-

 

• การบรรจุและการเปิดออก
• การเปรียบเทียบสิ่งอันดับ
• การใช้ทูเพิลเป็นกุญแจในพจนานุกรม
• กำลังลบ Tuples
• หั่นทูเปิล
• ฟังก์ชันในตัวด้วย Tuple
• ข้อดีของทูเพิลโอเวอร์ลิสต์

การมอบหมายทูเพิล

Python มีคุณสมบัติการกำหนด tuple ซึ่งช่วยให้คุณสามารถกำหนดตัวแปรได้มากกว่าหนึ่งตัวในแต่ละครั้ง ในที่นี้ เราได้กำหนด tuple 1 ด้วยข้อมูลบุคคล เช่น ชื่อ นามสกุล ปีเกิด ฯลฯ และอีก tuple 2 ที่มีค่าในนั้นเช่น ตัวเลข (1,2,3,….,7)

ตัวอย่างเช่น,

(ชื่อ, นามสกุล, ปีเกิด, หนังที่ชอบและปี, อาชีพ, บ้านเกิด) = Robert

 

นี่คือรหัส

 

tup1 = ('โรเบิร์ต' 'คาร์ลอส' '1965' 'เทอร์มิเนเตอร์ 1995' 'นักแสดง' 'ฟลอริดา');
tup2 = (1,2,3,4,5,6,7);
พิมพ์(tup1[0])
พิมพ์(tup2[1:4])

• Tuple 1 รวมรายการข้อมูลของ Robert
• Tuple 2 มีรายการตัวเลขอยู่ในนั้น
• เราเรียกค่าของ [0] ใน tuple และสำหรับ tuple 2 เราเรียกค่าระหว่าง 1 ถึง 4
• เรียกใช้รหัส - ตั้งชื่อ Robert สำหรับ tuple แรกในขณะที่ tuple ที่สองจะให้ตัวเลข (2,3 และ 4)

การบรรจุและการเปิดออก

ในการบรรจุ เราใส่ค่าลงใน tuple ใหม่ ในขณะที่แตกไฟล์ เราจะแยกค่าเหล่านั้นกลับเข้าไปในตัวแปร

 

x = ("Guru99", 20, "Education") # ทูเพิลบรรจุ
(บริษัท, emp, โปรไฟล์) = x # tuple unpacking
พิมพ์ (บริษัท)
พิมพ์ (ชั่วคราว)
พิมพ์ (โปรไฟล์)

การเปรียบเทียบสิ่งอันดับ

ตัวดำเนินการเปรียบเทียบใน Python สามารถทำงานกับสิ่งอันดับ

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

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

ลองศึกษาสิ่งนี้ด้วยตัวอย่าง -

#เคส1

เป็น=(5,6)
ข=(1,4)
ถ้า (a>b):print("a ใหญ่กว่า")
อย่างอื่น: print("b ใหญ่กว่า")

#เคส2

เป็น=(5,6)
ข=(5,4)
ถ้า (a>b):print("a ใหญ่กว่า")
อื่นๆ: พิมพ์ ("b ใหญ่กว่า")

#เคส3

เป็น=(5,6)
ข=(6,4)
ถ้า (a>b):print("a ใหญ่กว่า")
อย่างอื่น: print("b ใหญ่กว่า")

กรณีที่ 1:การเปรียบเทียบเริ่มต้นด้วยองค์ประกอบแรกของทูเพิลแต่ละตัว ในกรณีนี้ 5>1 ดังนั้นเอาต์พุต a จึงใหญ่กว่า

กรณีที่ 2:การเปรียบเทียบเริ่มต้นด้วยองค์ประกอบแรกของทูเพิลแต่ละตัว ในกรณีนี้ 5>5 ซึ่งไม่สามารถสรุปได้ ดังนั้นมันจึงไปยังองค์ประกอบถัดไป 6>4 ดังนั้นเอาต์พุต a จึงใหญ่กว่า

กรณีที่ 3:การเปรียบเทียบเริ่มต้นด้วยองค์ประกอบแรกของทูเพิลแต่ละตัว ในกรณีนี้ 5>6 ซึ่งเป็นเท็จ ดังนั้นมันจึงเข้าไปในบล็อกอื่นและพิมพ์ว่า "b ใหญ่กว่า"

การใช้ทูเพิลเป็นกุญแจในพจนานุกรม

เนื่องจาก tuples สามารถแฮชได้ และ list ไม่ได้ เราจึงต้องใช้ tuple เป็นคีย์ หากเราจำเป็นต้องสร้างคีย์ผสมเพื่อใช้ในพจนานุกรม

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

ไดเร็กทอรี[last,first] = number

ภายในวงเล็บ นิพจน์เป็นทูเพิล เราสามารถใช้การมอบหมายทูเพิลในลูปเพื่อนำทางพจนานุกรมนี้

สุดท้าย อันดับแรกในไดเร็กทอรี:

พิมพ์ก่อน, ล่าสุด, ไดเรกทอรี[สุดท้าย, แรก]

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

Tuples และพจนานุกรม

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

a = {'x':100, 'y':200}
b = รายการ (a.items())
พิมพ์ (ข)

กำลังลบ Tuples

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

ของ

หั่นทูเปิล

ในการดึงชุดองค์ประกอบย่อยเฉพาะจากทูเพิลหรือรายการ เราใช้ฟังก์ชันพิเศษที่เรียกว่าการแบ่งส่วน Slicing ไม่เพียงใช้ได้กับ tuple เท่านั้น แต่ยังรวมถึงอาร์เรย์และรายการด้วย

x = ("a", "b","c", "d", "e")
พิมพ์(x[2:4])

ผลลัพธ์ของรหัสนี้จะเป็น ('c', 'd')

นี่คือโค้ด Python 2 สำหรับตัวอย่างด้านบนทั้งหมด

tup1 = ('โรเบิร์ต' 'คาร์ลอส' '1965' 'เทอร์มิเนเตอร์ 1995' 'นักแสดง' 'ฟลอริดา');
tup2 = (1,2,3,4,5,6,7);
พิมพ์ tup1[0]
พิมพ์ tup2[1:4]

#การบรรจุและแกะ
x = ("Guru99", 20, "Education") # ทูเพิลบรรจุ
(บริษัท, emp, โปรไฟล์) = x # tuple unpacking
บริษัทพิมพ์
พิมพ์ emp
พิมพ์โปรไฟล์

#การเปรียบเทียบสิ่งอันดับ
#เคส1
เป็น=(5,6)
ข=(1,4)
ถ้า (a>b): พิมพ์ "a ใหญ่กว่า"
อย่างอื่น: พิมพ์ "b ใหญ่กว่า"

#เคส2
เป็น=(5,6)
ข=(5,4)
ถ้า (a>b): พิมพ์ "a ใหญ่กว่า"
อย่างอื่น: พิมพ์ "b ใหญ่กว่า"

#เคส3
เป็น=(5,6)
ข=(6,4)
ถ้า (a>b): พิมพ์ "a ใหญ่กว่า"
อย่างอื่น: พิมพ์ "b ใหญ่กว่า"

#ทูเปิลส์และพจนานุกรม
a = {'x':100, 'y':200}
b = a.items()
พิมพ์ข

#หั่นทูเปิล
x = ("a", "b","c", "d", "e")
พิมพ์ x[2:4]

ฟังก์ชันในตัวด้วย Tuple

ในการทำงานที่แตกต่างกัน tuple อนุญาตให้คุณใช้ฟังก์ชันในตัวมากมาย เช่น all(), any(), enumerate(), max(), min(), sorted(), len(), tuple() เป็นต้น

ข้อดีของทูเพิลโอเวอร์ลิสต์

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

สรุป

Python มีคุณสมบัติการกำหนด tuple ซึ่งช่วยให้คุณสามารถกำหนดตัวแปรได้มากกว่าหนึ่งตัวในแต่ละครั้ง

• การบรรจุและการแกะทูเปิลส์
• ในการบรรจุ เราใส่ค่าลงใน tuple ใหม่ ในขณะที่แตกไฟล์ เราจะแยกค่าเหล่านั้นกลับเข้าไปในตัวแปร
• ตัวดำเนินการเปรียบเทียบใน Python สามารถทำงานกับสิ่งอันดับ
• การใช้ทูเพิลเป็นกุญแจในพจนานุกรม
• Tuples สามารถแฮชได้และรายการไม่ได้
• เราต้องใช้ทูเพิลเป็นคีย์หากเราจำเป็นต้องสร้างคีย์ผสมเพื่อใช้ในพจนานุกรม
• พจนานุกรมสามารถส่งคืนรายการของทูเพิลได้โดยการเรียกรายการ โดยที่ทูเพิลแต่ละตัวเป็นคู่ของค่าคีย์
• Tuples จะไม่เปลี่ยนรูปและไม่สามารถลบได้ คุณไม่สามารถลบหรือลบรายการออกจากทูเพิล แต่การลบ tuple ทั้งหมดทำได้โดยใช้คำหลัก "del"
• ในการดึงชุดองค์ประกอบย่อยเฉพาะจากทูเพิลหรือรายการ เราใช้ฟังก์ชันพิเศษที่เรียกว่า slicing

Read More