Forem: Phondanai

Advent of Code 2022 - Day 1 ด้วย Clojure

Phondanai — Wed, 21 Dec 2022 04:05:25 +0000

มาอีกครั้งแล้วสำหรับ Advent of Code 2022, มาครั้งนี้ก็คงเหมือนเดิม จะมาลองทำ Day 1 เหมือนกับของ ปีที่แล้ว

Part 1

โจทย์ให้คำนวณหาจำนวน Calories ของ Elf ที่มี Calories รวมมากสุด เช่นในตัวอย่าง คำตอบคือ 24000 เพราะ Elf ตัวที่ 4 ขน Calories มามากสุด และผลรวมคือ 7000+8000+9000 = 24000

จาก input ตัวอย่าง สามารถใช้ partition-by ในการแบ่งส่วนของข้อมูลที่เป็นกลุ่มกันโดยอาศัยบรรทัดที่ไม่มีข้อมูล และ filter เพื่อเอาส่วนนี้ออก

(def input "1000
2000
3000

4000

5000
6000

7000
8000
9000

10000")

(def not-blank? (complement clojure.string/blank?))

(def input-groups 
  (->> input
       (clojure.string/split-lines)       ; 1
       (partition-by #(= % ""))           ; 2
       (filter #(not-blank? (first %))))) ; 3

อธิบายได้ดังนี้
1 แบ่งข้อมูล input เป็นทีละบรรทัด
2 จัดกลุ่มข้อมูลด้วยบรรทัดที่ไม่มีข้อมูล
3 เอาข้อมูลที่เป็นค่าว่างออก เนื่องจากใน 2 จะติดข้อมูล ("") มาด้วย

ข้อมูลใน input-groups จะได้ลักษณะดังนี้

user=> input-groups
(("1000" "2000" "3000") ("4000") ("5000" "6000") ("7000" "8000" "9000") ("10000"))

จากนั้นนำไปคำนวณต่อ

(def summing 
  (for [i input-groups]
    (reduce + (map #(Integer/parseInt %) i))))

user=> summing
(6000 4000 11000 24000 10000)

หาค่า max (คำตอบใน part 1)

user=> (apply max summing)
24000

Part 2

ในส่วนที่ 2 โจทย์ต้องการหา top 3 ที่มากที่สุด แล้วนำมารวมกัน
จากตรงนี้สามารถนำ summing มาคำนวณต่อด้วยการจัดเรียงด้วย sort แล้วค่อยนำมารวมกันเฉพาะ top 3

=> (->> summing
     (sort >)
     (take 3)
     (reduce +))
45000

การใช้ itertools.groupby ใน Python

Phondanai — Wed, 16 Nov 2022 08:28:36 +0000

สมมติว่าเรามีข้อมูลชุดหนึ่งที่อยากจัดกลุ่มตามตัวเลขตัวแรกของสมาชิก

data = [
  (10, "ten"),
  (1, "one"),
  (2, "two"),
  (5, "five"),
  (20, "twenty"),
  (3, "three"),
  (1, "one-one"),
  (7, "seven"),
  (2, "two-two"),
  (3, "three-three"),
  (1, "one-one-one"),
  (5, "five-five"),
]

และผลลัพธ์ที่เราต้องการคือ

{1: ['one', 'one-one', 'one-one-one']}
{2: ['two', 'two-two']}
{3: ['three', 'three-three']}
{5: ['five', 'five-five']}
{7: ['seven']}
{10: ['ten']}
{20: ['twenty']}

หากใช้ itertools.groupby ตรงๆ จะได้ผลลัพธ์ดังนี้

from itertools import groupby
from operator import itemgetter
for k, g in groupby(data, key=itemgetter(0)):
  {k: list(map(itemgetter(1), g))}

{10: ['ten']}
{1: ['one']}
{2: ['two']}
{5: ['five']}
{20: ['twenty']}
{3: ['three']}
{1: ['one-one']}
{7: ['seven']}
{2: ['two-two']}
{3: ['three-three']}
{1: ['one-one-one']}
{5: ['five-five']}

จากผลลัพธ์จะพบว่า จะไม่ได้ตรงตามกับที่เราต้องการ วิธีการแก้ไข้คือ เราต้อง sort ข้อมูลก่อนที่จะทำการ groupby

for k, g in groupby(sorted(data), key=itemgetter(0)):
  {k: list(map(itemgetter(1), g))}

{1: ['one', 'one-one', 'one-one-one']}
{2: ['two', 'two-two']}
{3: ['three', 'three-three']}
{5: ['five', 'five-five']}
{7: ['seven']}
{10: ['ten']}
{20: ['twenty']}

ก็จะได้ผลลัพธ์ตามที่เราต้องการแล้ว

REF: https://stackoverflow.com/questions/3440549/how-to-use-itertools-groupby-when-the-key-value-is-in-the-elements-of-the-iterab

Day 1 - Advent of Code 2021 ด้วย Clojure

Phondanai — Sun, 27 Feb 2022 15:50:52 +0000

ในโพสต์นี้จะลองใช้ Clojure แก้โจทย์ของ Advent of Code ปี 2021 Day 1

โจทย์ (part 1)

โจทย์ต้องการทราบว่าจำนวนครั้งที่ค่าเพิ่มขึ้น มีกี่ครั้ง โดยจะมี input มาให้ (ตั้งชื่อไว้ว่า input.txt) จากตัวอย่างในรูปคือ เพิ่มขึ้น 7 ครั้ง

อันดับแรก อ่าน input และแปลงให้เป็นตัวเลข, เพราะอ่านมาจาก text ไฟล์

(def input-part-1
  (map #(Integer/parseInt %) 
    (clojure.string/split-lines 
      (slurp "input.txt"))))

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

(partition 2 1 (range 10))
; ((0 1) (1 2) (2 3) (3 4) (4 5) (5 6) (6 7) (7 8) (8 9))

เพราะฉะนั้น โค้ดในส่วนนี้คือ

(partition 2 1 input-part-1)

ทำการเปรียบเทียบค่า โดยใช้ < เพื่อเทียบว่าค่าของตัวแรกน้อยกว่าตัวที่สองในคู่หรือไม่ โดยใช้ร่วมกับ map และ apply

(map #(apply < %)
  (partition 2 1 input-part-1))
; ผลลัพธ์จะได้ (true false true false ....)

จากนั้น นับจำนวนของค่า true ก็จะได้คำตอบของ part 1

(count
  (filter identity (map #(apply < %)
    (partition 2 1 input-part-1))))

เสร็จแล้วสำหรับ part 1

โจทย์ (part 2)

โจทย์ต้องการทราบจำนวนครั้งที่ค่าเพิ่มขึ้นเหมือนเดิม แต่ที่ต่างออกไปคือมี sliding window, โจทย์กำหนดมาคือ sliding window เท่ากับ 3 แปลว่า ต้องคำนวนค่าตัวเลขสามตัว แล้วนำมารวมกัน ทำแบบนี้ไปจนครบ แล้วจึงนำมาเปรียบเทียบกัน ดังในตัวอย่าง

ค่าของ A ได้มาจากค่าที่ 1-3, B ได้มาจาก 2-4 ,C ... ไปจนครบ input

เราสามารถใช้ partition ได้เช่นเดิม ต่างกันที่จำนวนในแต่ละกลุ่ม (กลุ่มละ 3 ค่า) เช่น

(partition 3 1 [199 200 208 210 200 207 240 269 260 263])
; ((199 200 208) (200 208 210) (208 210 200) (210 200 207) (200 207 240) (207 240 269) (240 269 260) (269 260 263))

เมื่อได้กลุ่มของค่ามาแล้ว ในแต่ละกลุ่มก็เอาค่าเหล่านั้นมาบวกกัน

(map #(reduce + %)
  (partition 3 1 [199 200 208 210 200 207 240 269 260 263]))
; (607 618 618 617 647 716 769 792)

จากตรงนี้เราก็สามารถใช้วิธีของ part 1 ในการหาคำตอบได้แล้ว

(count
  (filter identity (map #(apply < %)
    (partition 2 1 
      (map #(reduce + %)
        (partition 3 1 [199 200 208 210 200 207 240 269 260 263]))))))
; 5

ไม่รู้ว่าจะมี Day 2 รึเปล่านะ เพราะตอนนี้ทำได้แค่ Day 1 น่ะ :P

Clojure Ring เบื้องต้น

Phondanai — Tue, 29 Jun 2021 09:16:43 +0000

ได้เขียนไว้ที่นี่อีกที่นึง

วันนี้จะมาลองอธิบายการสร้างเว็บด้วย Clojure โดยใช้ library ที่ชื่อว่า ring กัน
โดยตัวอย่างที่ยกมา เอามาจากหน้า wiki ของ ring ใน github

เกี่ยวกับ Ring

ring คือ

Library ที่ใช้กันแพร่หลาย สำหรับพัฒนาเว็บโดยใช้ภาษา Clojure
สามารถสร้างเว็บและคอมไพล์ให้เป็น Java servlet ได้
สร้าง package Java war เพื่อเอาไป deploy ต่อได้ง่าย

สิ่งที่ต้องมี

hello ring

ต่อไปเราจะเริ่มสร้างเว็บแบบง่ายๆ กัน

สร้าง project ใหม่ด้วย Leiningen:

$ lein new hello-world
$ cd hello-world

เพิ่ม ring-core และ ring-jetty-adapter ลงใน dependencies ในไฟล์ project.clj

(defproject hello-world "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0"
            :url "https://www.eclipse.org/legal/epl-2.0/"}
  :dependencies [[org.clojure/clojure "1.10.0"]
                 [ring/ring-core "1.8.2"]
                 [ring/ring-jetty-adapter "1.8.2"]]
  :repl-options {:init-ns hello-world.core})

ดาวน์โหลด dependencies:

$ lein deps

ในไฟล์ src/hello-world/core.clj ให้สร้าง handler อย่างง่ายขึ้นมา (handler ก็คือฟังก์ชัน)

(ns hello-world.core)

(defn handler [request]
  {:status 200
   :headers {"Content-Type" "text/html"}
   :body "Hello World"})

จากนั้นให้ start REPL ขึ้นมาโดยใช้ Leiningen

$ lein repl

หลังจาก REPL รันขึ้นมาแล้ว, รัน Jetty ขึ้นมาเพื่อใช้ handler ที่เราสร้างขึ้น (Jetty คือ web server ตัวนึง)

=> (use 'ring.adapter.jetty)
=> (use 'hello-world.core)
=> (run-jetty handler {:port 3000
                       :join? false)

web server จะถูกรันขึ้นมา โดยตอนนี้สามารถเปิดเว็บเบราว์เซอร์ขึ้นมาแล้วเปิดหน้าเว็บ http://localhost:3000/ เพื่อดูผลลัพธ์

เอาล่ะ ตอนนี้เราก็ได้เว็บง่ายๆ โง่ๆ มาอันนึงที่ response กลับมาทุกครั้งว่า Hello World
เรามาดู concept ที่ใช้ใน ring กัน ว่ามีไรบ้าง

Ring concepts

ใน ring จะมี concepts หลักๆ อยู่ 4 อย่าง

Handler
Request
Response
Middleware

Handlers

Handlers ก็คือฟังก์ชันนี่แหละ ที่คอยรับ HTTP request --> process request --> ส่ง response กลับมา
, โดย request กับ response ใน handler เนี่ย จะอยู่ในรูปแบบ Clojure map และ ring จะจัดการที่เหลือให้ (เช่น แปลงเป็น HTTP reponse string)

ตัวอย่าง handler ที่โชว์ ip address ของ client ที่ส่ง request เข้ามา

(defn what-is-my-ip [request]
  {:status 200
   :headers {"Content-Type" "text/plain"}
   :body (:remote-addr request)})

จะเห็นได้ว่า ตัวอย่างนั้นใช้การดึงค่าออกมาจาก request map โดยใช้คีย์ :remote-addr

Requests

HTTP request จะอยู่ในรูปแบบ Clojure map ซึ่งก็จะมี keys มาตรฐานติดมา และก็ยังสามารถมี key ที่ custom เพิ่มเองได้
เช่น สร้างมาจาก middleware

key มาตรฐาน

:server-port - พอร์ตของ server ที่ request เรียกเข้ามา
:server-name - ชื่อของ server ที่ request เรียกเข้ามา
:remote-addr - Ip address ของ client request ที่เรียกเข้ามา <-- ที่ใช้ในตัวอย่างข้างบน
:uri - URI หรือ path ที่ request เรียกเข้ามา
:query-string - ตรงตัวเลยคือ query-string
:scheme protocol - ที่ใช้ request เช่น :http หรือ :https
:request-method - request method ที่เรียกมา เช่น :get, :head, :options, :put, :post หรือ :delete
:headers - Clojure map ของชื่อ header ต่างๆ
:body - InputStream จาก request body

Responses

Response map นั้น จะถูกสร้างขึ้นมาโดย handler ซึ่งมีทั้งหมด 3 key หลัก:

:status HTTP status code เช่น 200, 302, 404
:headers Clojure map ของ ชื่อ HTTP header
:body ตรงนี้จะเป็น response ที่จะตอบกลับไปยัง request, body ใน ring จะรองรับข้อมูลอยู่ 4 ประเภท คือ
- string ส่ง string ตรงๆ ไปยัง client
- ISeq แต่ละสมาชิกใน seq จะถูกส่งไปเป็น string
- File เนื้อหาในไฟล์จะถูกส่งไปยัง client
- InputStream เนื้อหาใน stream จะถูกส่งไปยัง client จนกว่า stream จะปิด

Middleware

middleware คือส่วนที่ทำให้เพิ่มความสามารถหรือทำอะไรบางอย่างเพิ่มเติมกับ handler ได้ (ในเอกสารเรียกว่าเป็น higher-level function)
middleware นั้น รับ handler เป็น input และ output ก็เป็น handler เช่นกัน
แต่ข้างในจะมีการเพิ่มเติมข้อมูลลงไป เช่น เปลี่ยน header หรืออะไรก็แล้วแต่

ตัวอย่าง middleware

(defn wrap-content-type [handler content-type]
  (fn [request]
    (let [response (handler request)]
      (assoc-in response [:headers "Content-Type"] content-type))))

จะเห็นว่า middleware นั้น return ออกมาเป็นฟังก์ชัน หรือ handler นี่แหละ
ข้างในจะมีการเปลี่ยน header "Content-Type" ให้เป็นตามตัวแปร content-type

ตัวอย่างการใช้ middleware

(def app
  (wrap-content-type handler "text/html"))

จากตัวอย่างแปลว่า มีการเปลี่ยน header "Content-Type" ให้กลายเป็นประเภท "text/html"

โดยปกติแล้ว เราสามารถซ้อน middleware ต่อกันไปได้เรื่อยๆ (เค้าเรียกว่า chain อ่ะนะ) กี่ชั้นก็ว่าไป
Clojure ก็จะมี threading macro (->) syntax เพื่อช่วยในการ chain middleware ต่างๆ เช่น

(def app
  (-> handler
      (wrap-content-type "text/html")
      (wrap-keyword-params)
      (wrap-params)))

middleware นั้นถูกใช้เป็นเรื่องปกติใน Ring, ไม่ว่าจะช่วยในเรื่องการจัดการ parameters, sessions หรือ อัพโหลดไฟล์
ทั้งหมดทั้งมวลนี้ถูกจัดการโดยใช้ middleware ของ Ring

เอาล่ะคงเท่านี้ก่อน เพราะน่าจะยาวแล้ว

ทดลองเขียน Clojure

Phondanai — Tue, 02 Mar 2021 05:42:07 +0000

Clojure เป็นภาษาสไตล์ภาษา LISP และรันอยู่บน Java Virtual Machine.

ก่อนจะเริ่มต้นใช้เราจำเป็นต้องติดตั้งซอฟต์แวร์ในเครื่องเราก่อน ของที่ต้องใช้เลยคือ Java (เค้าแนะนำเวอร์ชัน LTS ตอนนี้คือ 8 และ 11) และ Clojure
วิธีติดตั้งดูจากหน้านี้ได้เลย https://clojure.org/guides/getting_started

จากนั้น ใช้คำสั่ง clojure หรือ clj เพื่อเข้าโปรแกรม REPL (คล้ายๆ Python interpreter หรือ JavaScript console)
จะได้หน้าตาประมาณนี้

user=> _

ตัวอย่างโค้ด

user=> (println "Hello, world!")
"Hello, world!"
nil
user=> 1
1
user=> (+ 1 1)
2
user=> (+ 1 2 3 4 5 6)
21
user=> (* (+ 1 2) (- 9 8))
6

เริ่มจากการเรียกฟังก์ชันก่อนเลย โดยใน Clojure จะมี form ในการเรียกฟังก์ชันคือ เริ่มต้นด้วยวงเล็บเปิด ( แล้วตามด้วยฟังก์ชันที่ต้องการรัน
ในตัวอย่างคือ + * และprintln ทุกฟังก์ชันจะมีการ return ข้อมูลกลับมาเสมอแม้กระทั่ง println แต่สังเกตให้ดีว่าค่าที่คืนกลับมานั้นคือ nil ไม่ใช่ string "Hello, world!" ที่เห็นมานั้นเป็น side effect ที่เกิดจากการเรียกฟังก์ชัน println

Data structure

Clojure เองก็มี data structure เตรียมมาให้เราได้ใช้ เช่น vector, list, map, set

vector เป็น data structure ที่เก็บข้อมูลแบบเรียงลำดับก่อนหลัง
list เหมือน vector แต่กระบวนการจัดเก็บภายในแตกต่างกัน (เป็นแบบ linked list)
map เก็บข้อมูลแบบ key-value หรือ hash
set เก็บข้อมูลแบบไม่เรียงลำดับ และ ข้อมูลข้างในไม่ซ้ำกัน

user=> [1 2 3]
[1 2 3]
user=> (first [1 2 3])
1
user=> '(1 2 3) ; หรือ (list 1 2 3)
(1 2 3)
user=> {:one 1 :two 2}
{:one 1 :two 2}
user=> (get {:one 1 :two 2} :one)
1
user=> #{1 2 3}
#{1 3 2}

ฟังก์ชัน

แน่นอนว่า เราสามารถเขียนฟังก์ชันขึ้นมาใช้เองได้ นอกเหนือจากที่ Clojure มีมาให้ โครงสร้างของฟังก์ชันมีดังนี้

(defn function-name [param1 param2]
  body)

ตัวอย่างฟังก์ชันอย่างง่าย

user=> (defn my-plus [param1 param2]
         (+ param1 param2)) ; ค่าที่ return กลับไปคือบรรทัดสุดท้ายของส่วน body
#'user/my-plus
user=> (my-plus 10 20)
30

Bite-Size Python: Tuples and namedtuple

Phondanai — Wed, 20 May 2020 13:26:02 +0000

Tuple is one of the sequence data type like List in Python. The key main difference is tuple is immutable which mean once you create tuple you can not change it's value (but we can create new tuple from existing one after processing or something).

This post will demonstrate basic tuple operations and enhance it usage using namedtuple

Let's start

Creating tuple

# empty tuple can create using ()
>>> a_tuple = ()
# we can check that it is really a tuple
>>> type(a_tuple)
# <class 'tuple'>

# create tuple with data
>>> a_tuple = (1,) # one element tuple must include comma
>>> a_tuple
(1,)

# create tuple using `tuple` function with sequence data type like `list` 
>>> a_list = [1, 2, 3, 4, 5]
>>> a_tuple = tuple(a_list)
>>> a_tuple

Accessing data in tuple

# same manner of list by using zero-based indexing number
>>> a_tuple[0]
1

# slicing works as expect
>>> a_tuple[:3]
(1, 2, 3)

You can't modify tuple once it created

>>> a_tuple[0] = "others"
# will raise --> TypeError: 'tuple' object does not support item assignment

# but we can work around by create new one using existing values
>>> a_tuple = ("others",) + a_tuple[1:] # using `+` sign to join tuples
>>> a_tuple
('others', 2, 3, 4, 5)

You can't remove item from tuple using del too

>>> del a_tuple[-1]
# TypeError: 'tuple' object doesn't support item deletion

# `del` can only remove entire of the tuple
>>> del a_tuple

namedtuple is like an enhance version of tuple.
Key difference between these two guys is, innamedtuple you can naming something to tuples and you can accessing the value in namedtuple using name make it clearer and easy to read (but you can still use index number if you like.

# import first before using namedtuple
>>> from collections import namedtuple
# create namedtuple name `Point` consists of `x` and `y` 
# representing x, y coordinate system
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(20, -20) # x = 20, y = -20
>>> p.x
20
>>> p.y
-20

Useful functions in namedtuple

# return as a dictionary
>>> p._asdict()
{'x': 20, 'y': -20}

# replacing value
# this will return new namedtuple not in-place replacing
>>> p._replace(x=0, y=0)
Point(x=0, y=0)

Thanks for reading! :)

Bite-Size Python: Dictionaries basic

Phondanai — Fri, 15 May 2020 16:10:23 +0000

As the name imply, dictionary consists of keys and values mapping so that we can lookup for the value using the key the same way we lookup for the meaning of the word.

This post will show some basic operation on dictionaries like dictionary creation, modification and so on.

Let's start!

Dictionary creation

# create empty list
>>> a_dict = {}
# or
>>> a_dict = dict()

# create with some value
# key's in the dictionary can be mix with some other types
>>> a_dict = {"key1": "value1", 2: "two", "three": 3} 
>>> a_dict
{'key1': 'value1', 2: 'two', 'three': 3}

# or using dict() with sequence of key-value pairs
# like list of a pair of tuple
>>> a_dict = dict([("key1", "value1"), (2, "two"), ("three", 3)])
>>> a_dict
{'key1': 'value1', 2: 'two', 'three': 3}

Accessing dictionary value

# using the same manner of accessing list element 
# but use the key instead of index number
>>> a_dict["key1"]
'value1'
# or using get()
>>> a_dict.get(2)
'two'
# the main difference between these two is 
# get() will return None if the key is not found 
# in the dictionary but the other will raise the KeyError exception
# so, your program will break if the error's raise, so be careful
>>> a_dict.get("python")
>>> # noting happen

>>> a_dict["python"]
KeyError: 'python'

# you can check whether the key is available 
# in the dictionary or not using `in` syntax
>>> "key1" in a_dict
True
>>> "python" in a_dict
False

Dictionary modification

# modify the existing value
>>> a_dict["key1"] = "one"
>>> a_dict
{'key1': 'one', 2: 'two', 'three': 3}

# adding new key-value pair
>>> a_dict["python"] = "snake"
>>> a_dict
{'key1': 'one', 2: 'two', 'three': 3, 'python': 'snake'}

# delete using `del`
>>> del a_dict[2]
>>> a_dict
{'key1': 'one', 'three': 3, 'python': 'snake'}

Iterating over dictionary

# we can iterate over dictionary using looping statement like `for-loop` with items() to get both key and value pair for each member
>>> for k, v in a_dict.items():
        print(k,":",v)
key1 : one
three : 3
python : snake

# getting keys only using keys()
>>> a_dict.keys() 
dict_keys(['key1', 2, 'three'])

# as you expect, we can get only values too!
>>> a_dict.values()
dict_values(['one', 3, 'snake'])

I hope this can help you to getting start using dictionary in Python.

Thanks for reading! :)

Bite-Size Python: Basic List Operation

Phondanai — Wed, 13 May 2020 15:01:00 +0000

List is one of the most important built-in data structure uses in Python.

This post will cover some important and frequently use functions&methods to do basic operation/manipulation with list.

Let's start!

List creation

# create empty list
>>> a_list = []
# or
>>> a_list = list()

# we can use list() to create list from some sequence
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# or create from other data structure
# be careful, this only retrieve dictionary keys
>>> list({"key1": "value1", "key2": "value2"})   
['key1', 'key2']

# use items() to retrieve key-value pair
>>> list({"key1": "value1", "key2": "value2"}.items()) 
[('key1', 'value1'), ('key2', 'value2')]

List accessing

# list sequence is 0-based indexing, means index of list start from zero
>>> a_list = list(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a_list[0]
0
# list in Python support negative indexing too
>>> a_list[-1]
9
# we can obtain some part of the list by using slice
# obtains sub-list from index 1 to index 5
>>> a_list[1:5] 
[1, 2, 3, 4]
# and of course slicing support negative indexing
>>> a_list[-5:8]
[5, 6, 7]

List modification

# modify list is simple, for example use indexing and assignment
>>> a_list[0] = "hello" # yes, we can store other data type inside list
>>> a_list
['hello', 1, 2, 3, 4, 5, 6, 7, 8, 9]

# multiple value is possible
>>> a_list[-5:8] = [50, 60, 70]
>>> a_list
['hello', 1, 2, 3, 4, 50, 60, 70, 8, 9]

# delete element of the list using `del`
>>> del a_list[0] # delete first element of the list
a_list
[1, 2, 3, 4, 50, 60, 70, 8, 9]

# append new element in the list
# use append() to add new element next to the last 
>>> a_list.append(90)index
>>> a_list
[1, 2, 3, 4, 50, 60, 70, 8, 9, 90]

Wrangling

# sorting, Python provides sorted() and sort(), both sort ascending by default
# sorted() return `new` list
>>> sorted(a_list)
[1, 2, 3, 4, 8, 9, 50, 60, 70, 90]

# sort() sort input's list `inplace`, so be careful with this
# return None, use `reverse=True` to sort descending
>>> a_list(sort, reverse=True)
>>> a_list
[90, 70, 60, 50, 9, 8, 4, 3, 2, 1]

# list comprehension
>>> double_a_list = [i*2 for i in a_list]
>>> double_a_list
[180, 140, 120, 100, 18, 16, 8, 6, 4, 2]

# using reverse() to reverse element.
>>> double_a_list.reverse() # reverse also `inplace` modification, be careful with this too
>>> double_a_list
[2, 4, 6, 8, 16, 18, 100, 120, 140, 180]

There are more! But I hope this will enough for now.
You can consult this document for more functions and usages.

Thanks for reading! :)

Bite-Size Python: String

Phondanai — Sun, 10 May 2020 16:21:54 +0000

Python have many, useful functions to work with string. This post I will demonstrate some functions I frequently use.

Let's start!

split : Splitting a string using space as delimiter by default and return a list

>>> paragraph = "Python is an interpreted, high-level, general-purpose programming language. Created by Guido van Rossum and first released in 1991."
>>> word_list = paragraph.split()
>>> word_list
['Python',
 'is',
 'an',
 'interpreted,',
 'high-level,',
 'general-purpose',
 'programming',
 'language.',
 'Created',
 'by',
 'Guido',
 'van',
 'Rossum',
 'and',
 'first',
 'released',
 'in',
 '1991.']
# You can change delimiter too 
>>> word_list_split_by_comma = paragraph.split(',')
>>> word_list_split_by_comma
['Python is an interpreted',
 ' high-level',
 ' general-purpose programming language. Created by Guido van Rossum and first released in 1991.']

join : Combine list of string to single string with custom delimeter

>>> word_list
['Python',
 'is',
 'an',
 'interpreted,',
 'high-level,',
 'general-purpose',
 'programming',
 'language.',
 'Created',
 'by',
 'Guido',
 'van',
 'Rossum',
 'and',
 'first',
 'released',
 'in',
 '1991.']
>>> "|".join(word_list)
'Python|is|an|interpreted,|high-level,|general-purpose|programming|language.|Created|by|Guido|van|Rossum|and|first|released|in|1991.'
# OR
>>> "|".join(paragraph.split())
'Python|is|an|interpreted,|high-level,|general-purpose|programming|language.|Created|by|Guido|van|Rossum|and|first|released|in|1991.'

Slicing : You can slice string as same as list.

>>> first_25_chars = paragraph[:25]
first_25_chars
'Python is an interpreted,'
>>> last_25_chars = paragraph[-25:]
>>> last_25_chars
'd first released in 1991.'
>>> reverse_paragraph = paragraph[::-1]
>>> reverse_paragraph
'.1991 ni desaeler tsrif dna mussoR nav odiuG yb detaerC .egaugnal gnimmargorp esoprup-lareneg ,level-hgih ,deterpretni na si nohtyP'

len & count: string length & counting occurrence sub string

>>> len(paragraph) # This can tell how many index we can use when slicing
131
>>> paragraph.count("ed")
6

For fun

Use center to centering your text, with amount of supply width spaces and custom character replacement rather than space.

>>> "TADA!".center(30, "🌈")
'🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈TADA!🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈'

Thank you for reading :)

References

Bite-Size Python: List comprehensions

Phondanai — Sun, 10 May 2020 07:03:54 +0000

This mini-tutorial is demonstrate how I use list comprehensions in Python.

Let's start!

List creation

# normally
>>> a_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# then
>>> a_list = [i for i in range(11)] # but actually you just use list(range(11)) :P

Conditional filtering using if

>>> a_list_even = [i*i for i in range(11) if i % 2 == 0]
>>> a_list_even_doubled
[0, 4, 16, 36, 64, 100]

You can work with other data type rather than list too

>>> a_dict = {
    "mango": 20,
    "grape": 30,
    "durian": 100,
    "latte": 40,
    "cappuccino": 30
}
>>> fruits = ["mango", "grape", "durian"]
>>> fruit_prices = [(k, v) for k, v in a_dict.items() if k in fruits]
>>> fruit_prices
[('mango', 20), ('grape', 30), ('durian', 100)]

That's all.
Thank you for reading =)