Chapter 3 Python Basics¶
Python Basics
Keynote¶
3.1 Identifiers and Keywords¶
Python á Case sensitive language áá áşááŻááŤá Python identifier áááŻááŹá Variableá Functioná Classá Module áááŻáˇáááŻááş áááźáŹá¸ Object áá˝áąááᯠáá˝á˛ááźáŹá¸áááááŻááşáááŻáˇ ááąá¸ááŹá¸áá˛áˇ ááŹáááşáá áşáᯠááźá áşááŤáááşá Identifiers áá˝áą áááşááŽá¸áá˛áˇáĄá፠áááŻááşááŹááááˇáş á ááşá¸áááşá¸áá˝áąáááąáŹáˇ -
-
Alphabet (áĄáášáááŹ) áááŻáˇáááŻááş Underscore (_) áá˛áˇ á áááŤáááşá
-
áĄá˛ááŽááąáŹááşáážáŹ á áŹááŻáśá¸áá˝áąá _ á áá˛áˇ Digits (ááááşá¸) áá˝áą áááŻááşáááŻáˇáááŤáááşá
-
Keyword áá˝áąááᯠIdentifier áĄááąáá˛áˇ ááŻáśá¸áááŻáˇ ááááŤáá°á¸á
Keywords áĄáŹá¸ááŻáśá¸á Lowercase (áĄáášáááŹáĄááąá¸) áá˝áą ááźá áşááŤáááşá Python áážáŹ Keywords á áŻá áŻááąáŤááşá¸ (áá) ááŻáśá¸áážáááźáŽá¸ Table 3.1 áážáŹ ááąáŹáşááźááŹá¸ááŤáááşá
| Table 3.1 Keywords list | -/- | -/- | -/- |
|---|---|---|---|
| False | continue | from | not |
| None | def | global | or |
| True | del | if | pass |
| and | elif | import | raise |
| as | else | in | return |
| assert | except | is | try |
| break | finally | lambda | while |
| class | for | nonlocal | with |
| yield |
Python keywords á áŹáááşá¸ááᯠáĄáąáŹááşá፠Statements áá˝áąááŻáśá¸ááźáŽá¸ ááŻááşááźááˇáşáááŻáˇ áááŤáááş -
import keyword # 'keyword' module ááᯠááŻáśá¸áááŻáˇááĄáąáŹááş ááąáŤáşáááŻááşááŹ
print(keyword.kwlist) # syntax áááąáŹáˇ modulename.object/function ááŻáśá
áśááŤ
3.2 Python Types¶
Python áážáŹ Data types (á) ááťááŻá¸ (á) á áŹá¸ áážáááŤáááş -
- Basic Types:
- int, float, complex, bool, string, bytes
- Container Types:
- list, tuple, set, dict
- User-defined types:
- class
ááŽáĄáá˛áážáŹ Basic types áĄááźáąáŹááşá¸ááᯠáᎠChapter áážáŹ áĄááąá¸á áááş áážááşá¸ááźáá˝áŹá¸ááŤáááşá Container types áĄááźáąáŹááşá¸áááŻááąáŹáˇ áĄááźááşá¸ááťááşá¸áᲠááźáąáŹáá˝áŹá¸ááŤáááşá Container type áá áşááŻá áŽáĄáá˝ááş ááŽá¸áááˇáş Chapter áá˝áąáá˛áˇ áĄááąá¸á áááş áááşáážááşá¸ááźááąá¸ááŹá¸ááŤáááşá User-defined types áĄááźáąáŹááşá¸áááŻááąáŹáˇ áᎠChapter áážáŹ áááźáąáŹááąáŹáˇááŤáá°á¸á Chapter 17 ááťááž áááşáááŻáááşááŽá¸ááá˛á áááşáááŻááŻáśá¸ááá˛áááŻáᏠáá˝áąá¸áá˝áąá¸áá˝áŹá¸ááŤáááşá
3.2.1 Basic Types¶
Basic types áĄááťááŻá¸ááťááŻá¸áá˛áˇ áĽáááŹáá˝áąááᯠáĄáąáŹááşáážáŹ ááąáŹáşááźááąá¸ááŹá¸ááŤáááş -
- int ááᯠbinary, decimal, octal, hexadecimal ááŻáśá áśáá˝áąáá˛áˇ ááąáŹáşááźáááŻáˇáááŤáááşá
- binary áááŻáááş 0b/0B á octal áááŻáááş 0o/0O á hex áááŻáááş 0x/0X áá˛áˇ á ááŤáááşá (áĽááᏠ- 0b10111, 156, 0o432, 0x4A3)
- float ááᯠfractional (áááááááşá¸) áááŻáˇáááŻááş exponential form (áááşááááşá¸ááŻáśá áś) áá˛áˇ ááąáŹáşááźáááŻáˇáááŤáááşá (áĽááᏠ- 314.1528, 3.141528e2, 3.141528E2)
- complex áážáŹ real áá˛áˇ imaginary part áááŻááźáŽá¸ ááŤááŤáááşá (áĽááᏠ- 3 + 2j, 1 + 4J)
- bool á Boolean values áážá áşááŻáá˛á ááźááŻááşááŹáá áşáᯠááźá áşáááŻááşááźáŽá¸ áážá áşááŻááŻáśá¸á áĄáášáááŹáĄááźáŽá¸áá˛áˇ á ááŤáááşá (áĽááᏠ- True, False)
- string áááŻááŹ
' '," ", áááŻáˇáááŻááş""" """áá˝áąááźáŹá¸áá˛áážáŹ ááąá¸ááŹá¸áá˛áˇ Immutable collection of Unicode characters ááźá áşááŤáááşá áĽááᏠ- 'Rosanna', "Rosanna", """Rosanna"""á - bytes á Binary data ááᯠáááŻááşá áŹá¸ááźáŻááŤáááşá
b'\xa1\xe4\x56' # hex values a1a456 ááŤáá˛áˇ 3 bytes ááᯠáááŻááşá
áŹá¸ááźáŻááŤáááş
print(type(35)) # <class 'int'> áááŻááźáŽá¸ print ááŻááşááąá¸ááŤááááˇáşáááş
print(type(3.14)) # <class 'float'> áááŻááźáŽá¸ print ááŻááşááąá¸ááŤááááˇáşáááş
3.2.2 Integer and Float Ranges¶
- int áá˝áąá Arbitrary size ááźá áşáá˛áˇáĄáá˝ááş ááźááŻááşáááąáŹááş áĄáá˝ááşáĄá áŹá¸ ááŹá¸áááŻáˇáááŤáááşá (Memory áááˇáşááá˝áąáˇ ááááşá¸áĄááŻáśá¸ááą áĄáááˇáşáĄáááşááážáááŤáá°á¸)á
Floats áá˝áąáááŻááąáŹáˇ Internal áážáŹ IEEE 754 standard áĄá Binary ááŻáśá áśáá˛áˇ 64-bit double-precision values áĄááąáá˛áˇ ááááşá¸áááşá¸ááŤáááşá áᎠStandard áĄá Float áá áşááŻáá˛áˇ áĄááźáŽá¸ááŻáśá¸áááşáááŻá¸ (Maximum value) á áááˇáşáážááşá¸ááźáą 1.8 x 10^308 ááźá áşááŤáááşá ááŽáááşááźáŽá¸áá˛áˇ ááááşá¸ááááşá¸áááŻáááş inf (infinity áĄáááŻááąáŹááş) áĄááąáá˛áˇ ááąáŹáşááźááŤááááˇáşáááşá
Floats ááąáŹáşááąáŹáşááťáŹá¸ááťáŹá¸ááᯠBinary form áá˛áˇ 'ááááááťááť' (Exactly) ááąáŹáşááźáááŻáˇ áááááŻááşááŤáá°á¸á ááŤááźáąáŹááˇáş Internal representation á ááááˇáşáááşáááŻá¸áá˛áˇ Approximation (ááŽá¸á ááşááŻáśá¸áááşáááŻá¸) áᏠááźá áşááąáˇáážáááŤáááşá
ááááˇáşáááşáááŻá¸áá˛áˇ Represented value ááźáŹá¸á áá˝áŹáááťááşá áĄáááşá¸ááąá¸áááşáá˛áˇáĄáá˝ááş ááŻáśáážááşáĄáŹá¸ááźááˇáşááąáŹáˇ ááźáżááŹááźáŽá¸ááźáŽá¸ááŹá¸ááŹá¸ áááźá áşá áąááŤáá°á¸á
3.3 Variable Type and Assignment¶
Variable áá áşááŻáá˛áˇ Type ááᯠááźááŻááźáŽá¸ áááşáážááşááąá¸á áᏠ(Define) ááááŻááŤáá°á¸á Execution ááŻááşááąáá˛áˇáĄááťáááşááťááž áá°áĄááŻáśá¸ááźáŻááąáá˛áˇ Context ááąáŤáşáá°áááşááźáŽá¸ Variable type ááᯠáĄáááŻáĄááťáąáŹááş ááŻáśá¸ááźááş (Infer) áá˝áŹá¸ááŹááŤá ááŤááźáąáŹááˇáş Python ááᯠDynamically-typed language áááŻáˇ ááąáŤáşááŹááźá áşááŤáááşá
a = 25 # a áá˛áˇ type ááᯠint áááŻáˇ áá°ááááŻááşááŤáááş
a = 31.4 # a áá˛áˇ type ááᯠfloat áááŻáˇ áá°ááááŻááşááŤáááş
a = 'Hi' # a áá˛áˇ type ááᯠstr áááŻáˇ áá°ááááŻááşááŤáááş
Variable áá áşááŻáá˛áˇ Type ááᯠBuilt-in function ááźá áşáá˛áˇ type() ááᯠááŻáśá¸ááźáŽá¸ á á áşááąá¸áááŻááşááŤáááşá
a = 'Job Kaa'
print(type(a)) # type ááᯠstr áĄááąáá˛áˇ ááąáŹáşááźááąá¸ááŤááááˇáşáááş
Simple variable assignment:
Variables áĄááťáŹá¸ááźáŽá¸ááᯠáá áşááźááŻááşáááş Assignment ááŻááşááźááşá¸ -
a = 10 ; pi = 31.4 ; name = 'Rosanna' # ; ááᯠstatement separator áĄááąáá˛áˇ ááŻáśá¸ááŹá¸ááŹááŤ
a, pi, name = 10, 3.14, 'Rosanna'
a = b = c = d = 5
3.3.1 Arithmetic Operators¶
Arithmetic Operators: +, - , * , /, %, //, **
a = 4 / 2 # True division ááŻááşááąáŹááşááźáŽá¸ Float 2.0 ááᯠááážáááŤáááş
a = 7 % 2 # % á áĄááźá˝ááşá¸ (Remainder) 1 ááᯠááąá¸ááŤáááş
b = 3 ** 4 # ** á áááşááááşá¸áááşááąá¸ááŤáááş (3 raised to 4)
c = 4 // 3 # // á ááááááŻááşá¸áá˝áąááᯠáááşááŻááşááźáŽá¸ á
áŹá¸áááş (Quotient) 1 áááŻáᲠáá°ááŤáááş
In-place assignment operators áá˝áąá Arithmetic operations áá˝áąááŻááşáááŻáˇáĄáá˝ááş Shortcut ááąáŹááşá¸ááąáŹááşá¸áá
áşáᯠááźá
áşááŤáááşá áá°áááŻáˇáá˛áážáŹ +=, -=, *=, /=, %=, //=, **= áááŻáˇ ááŤáááşááŤáááşá
a **= 3 # a = a ** 3 áá˛áˇ áĄáá°áá°ááŤáá˛
b %= 10 # b = b % 10 áá˛áˇ áĄáá°áá°ááŤáá˛
3.3.2 Operation Nuances¶
Floor division (a//b) ááŻááşááąáŹááşáá˛áˇáĄá፠áááŹáááˇáş Result á Quotient (á
áŹá¸áááş) áááş áááşáá˛áˇ (áááŻáˇáááŻááş) ááŽáá˛áˇáĄáá˛á áĄááźáŽá¸ááŻáśá¸ Integer ááźá
áşááŤáááşá // ááᯠFloor division operator áááŻáˇ ááąáŤáşááŤáááşá
áááŻá¸áááŻá¸ááąá¸ áážááşáááşáááŻáááşááąáŹáˇ Number line ááąáŤáşáážáŹ áááşáááş (áááşáááŻá¸áááŻáááşáá˛áˇáááş) ááᯠáĄááźá˛áááşá¸ 'Floor' (áĄáąáŹááşááť) áááŻááşáááşáááŻáˇ áážááşáá°áááŻááşááŤáááşá ááŤááźáąáŹááˇáş -3.33 áááŻáááş -3 áááźá áşáᲠ-4 ááźá áşáá˝áŹá¸ááŹááŤá
print(10 // 3) # 3 ááᯠáááŤáááş (3.33... áááş áááşáá˛áˇ/ááŽáá˛áˇ integer)
print(-10 // 3) # -4 ááᯠáááŤáááş (-3.33... áááş áááşáá˛áˇ integer á -4 ááŤ)
print(10 // -3) # -4 ááᯠáááŤáááş
print(-10 // -3) # 3 ááᯠáááŤáááş
print(3 // 10) # 0 ááᯠáááŤáááş (0.3 áááş áááşáá˛áˇ/ááŽáá˛áˇ integer)
print(3 // -10) # -1 ááᯠáááŤáááş (-0.3 áááş áááşáá˛áˇ integer á -1 ááŤ)
print(-3 // 10) # -1 ááᯠáááŤáááş
print(-3 // -10) # 0 ááᯠáááŤáááş
-10 // 3 áážáŹ -10 ááááŻáˇ 3 áá˛áˇá áŹá¸áááŻááşáááş -3.333 áááŤáááşá áá°áˇáá˛áˇ Floor value (áĄáąáŹááşááťáááŻááşáá˛áˇ áááşáááŻá¸) á -4 ááźá áşááŤáááşá
10 // -3 áážáŹ 10 ááááŻáˇ -3 áá˛áˇá áŹá¸áááŻááşáááş -3.333 áááŤáááşá áá°áˇáá˛áˇ Floor value á -4 ááźá áşááŤáááşá
-10 // -3 áážáŹ -10 ááááŻáˇ -3 áá˛áˇá áŹá¸áááŻááşáááş 3.333 áááŤáááşá áá°áˇáá˛áˇ Floor value á 3 ááźá áşááŤáááşá
print( ) áááŻáᏠScreen ááąáŤáşáážáŹ Output ááŻááşááąá¸áááŻáˇ ááŻáśá¸áá˛áˇ Function áá áşááŻááŤá áá°áˇááᯠááŻáśá áśááťááŻá¸á áŻáśáá˛áˇ ááŻáśá¸áááŻáˇáááŤáááşá Chapter 7 ááąáŹááşáááş áĄááąá¸á áááş áá˝áąá¸áá˝áąá¸ááŤáááşá
a % b Operation ááᯠa - (b * (a // b)) áááŻáá˛áˇ ááŻáśááąáááşá¸áĄáááŻááşá¸ Evaluate ááŻááş (áá˝ááşááťááş) ááŤáááşá
ááŤááᯠáĄáąáŹááşá áĽáááŹáá˝áąááźááˇáşáááş áĄáážááşá¸ááŻáśá¸ ááŹá¸áááşááŤááááˇáşáááş -
print(10 % 3) # 1 áááŤáááş (ááŻáśáážááş áĄááźá˝ááşá¸ááŤ)
print(-10 % 3) # 2 áááŤáááş (Formula: -10 - (3 * -4) = -10 + 12 = 2)
print(10 % -3) # -2 áááŤáááş (Formula: 10 - (-3 * -4) = 10 - 12 = -2)
print(-10 % -3) # -1 áááŤáááş (Formula: -10 - (-3 * 3) = -10 + 9 = -1)
print(3 % 10) # 3 áááŤáááş
print(3 % -10) # -7 áááŤáááş (Formula: 3 - (-10 * -1) = 3 - 10 = -7)
print(-3 % 10) # 7 áááŤáááş (Formula: -3 - (10 * -1) = -3 + 10 = 7)
print(-3 % -10) # -3 áááŤáááş
a % b ááᯠa - (b * (a // b)) áááŻááźáŽá¸ Evaluate ááŻááşáá˛áˇáĄáá˝ááşááźáąáŹááˇáşá
-10 % 3 áááŻáááş -10 - (3 * (-10 // 3)) áááŻáˇ áá˝ááşááŤáááşá ááŤááźáąáŹááˇáş ááááş 2 ááᯠáááŤáááşá
10 % -3 áááŻáááş 10 - (-3 * (10 // -3)) áááŻáˇ áá˝ááşááŤáááşá ááŤááźáąáŹááˇáş รáááş -2 ááᯠáááŤáááşá
-10 % -3 áááŻáááş -10 - (-3 * (-10 // -3)) áááŻáˇ áá˝ááşááŤáááşá ááŤááźáąáŹááˇáş ááááş -1 ááᯠáááŤáááşá
Mathematical rule áĄá a / b x c áá˛áˇ a x c / b á áá°áááşáááŻááąáááˇáşá Programming áážáŹ áĄááźá˛áááşá¸ááąáŹáˇ ááážááşááŤáá°á¸á (áĄáá°á¸áááźááˇáş ááááşá¸áĄááźáŽá¸ááźáŽá¸áá˝áą áá˝ááşáá˛áˇáĄááŤááťááŻá¸áážáŹááąáŤáˇ)á
# áĄáąáŹááşá፠expressions áá˝áąá results áĄáá°áá°áᲠáá˝ááşááŤáááş
a = 300 / 100 * 250
a = 300 * 250 / 100
# ááŤááąáááˇáş ááŽááŹáá˝áąáááąáŹáˇ ááá°ááąáŹáˇááŤáá°á¸
b = 1e210 / 1e200 * 1e250
b = 1e210 * 1e250 / 1e200 # INF (Infinity) áá˝ááşáá˝áŹá¸ááŤáááş
True áááŻáᏠ1á False áááŻáᏠ0 ááźá
áşáá˛áˇáĄáá˝ááş áá°áááŻáˇááᯠááááşá¸áá˝áąáááŻáᲠááąáŤááşá¸áááŻáˇáááŤáááşá
a = True + True # 2 áááŤáááş (1 + 1)
b = True + False # 1 áááŤáááş (1 + 0)
3.4 Precedence and Associativity¶
Arithmetic expression áá áşááŻáážáŹ Operators áá˝áą áĄááťáŹá¸ááźáŽá¸ ááŤááŹáá˛áˇáĄááŤá áĄá˛áᎠOperators áá˝áąáá˛áˇ Precedence (áŚá¸á áŹá¸ááąá¸áĄáááˇáş/Priority) ááąáŤáşáá°áááşááźáŽá¸ Evaluate ááŻááş (áá˝ááşááťááş) ááŤáááşá
Priority áĄááźááˇáşááŻáśá¸áááą áĄááááˇáşááŻáśá¸áĄáááŻááş á áŽááŹá¸áá˛áˇ Operators áá˝áąáááąáŹáˇ (PEMDAS) áĄáááŻááşá¸ ááźá áşááŤáááş -
( ) # Parentheses (áá˝ááşá¸ááťáŹá¸)
** # Exponentiation (áááşááááşá¸áááşááźááşá¸)
*, /, //, % # Multiplication, Division (áĄááźážáąáŹááşá áĄá
áŹá¸ áĄáŻááşá
áŻ)
+, - # Addition, Subtraction (áĄááąáŤááşá¸á áĄááŻááş áĄáŻááşá
áŻ)
Operator áááŻááşá¸áážáŹ Left to right associativity (áááşááž ááŹáááŻáˇ) áááŻáˇáááŻááş Right to left associativity (ááŹááž áááşáááŻáˇ) áááŻáᏠáážáááźááŤáááşá
áĽááᏠ- c = a * b / c áááŻáá˛áˇ Expression áážáŹ * áá˛áˇ / á Priority áá°ááŤáááşá ááŤááąáááˇáş Arithmetic operators áá˝áąá Left to right associativity áážááá˛áˇáĄáá˝ááş * ááᯠ/ áááş áĄáááşááŻááşááŤáááşá (áááşáááşáĄááźááşá¸á ááąáŹááşááᯠáĄáááşááŻááşááŹááŤ)á
Python operators áĄáŹá¸ááŻáśá¸áá˛áˇ Priority áá˛áˇ Associativity á áŹáááşá¸áĄááźááˇáşáĄá áŻáśááᯠAppendix A áážáŹ ááźááˇáşáážáŻáááŻááşááŤáááşá
3.4.1 Conversions¶
Mixed mode operations (Type ááá°ááŹáá˝áą ááąáŹááźáŽá¸ áá˝ááşááźááşá¸):
- int áá˛áˇ float áá˝á˛ááŻááşáááş float áááŤáááşá
- int áá˛áˇ complex áá˝á˛ááŻááşáááş complex áááŤáááşá
- float áá˛áˇ complex áá˝á˛ááŻááşáááş complex áááŤáááşá
Built-in functions áá˝áąááźá áşáá˛áˇ int( ), float( ), complex( ) áá˛áˇ bool( ) áááŻáˇááᯠááŻáśá¸ááźáŽá¸ Numeric type áá áşááŻáááą ááąáŹááşáá áşááŻááᯠááźáąáŹááşá¸áᲠ(Convert) áááŻááşááŤáááşá
Type conversions:
int(float/numeric string) # float áááŻáˇáááŻááş numeric string ááᯠint ááźáąáŹááşá¸ááźááşá¸
int(numeric string, base) # numeric string ááᯠbase áá
áşááŻááŻáĄáááŻááş int ááźáąáŹááşá¸ááźááşá¸
float(int/numeric string) # int áááŻáˇáááŻááş numeric string ááᯠfloat ááźáąáŹááşá¸ááźááşá¸
float(int) # int ááᯠfloat ááźáąáŹááşá¸ááźááşá¸
complex(int/float) # complex ááźáąáŹááşá¸ááźááşá¸ (imaginary part á 0 ááźá
áşááąáááş)
complex(int/float, int/float) # complex ááźáąáŹááşá¸ááźááşá¸ (real, imag áážá
áşááŻááŻáśá¸ááŤáááş)
bool(int/float) # int/float ááᯠTrue/False (1/0) ááźáąáŹááşá¸ááźááşá¸
str(int/float/bool) # string áĄááźá
áş ááźáąáŹááşá¸ááźááşá¸
chr(int) # int áááşáááŻá¸áá˛áˇ áááşáááŻááşáá˛áˇ character (ASCII/Unicode) ááᯠááŻááşááąá¸ááźááşá¸
int( ) á Decimal portion (ááááááŻááşá¸) ááᯠááźááşááŻááşáááŻááşááŹááźá áşáá˛áˇáĄáá˝ááş áĄááźá˛áááşá¸ Zero áááşáááŻáᲠRound ááŻááşáá˝áŹá¸ááŤáááş (Rounds towards zero ááźá áşááŤáááş)á
3.4.2 Built-in Functions¶
Python áážáŹ Program áá˛áˇ áááşááąááŹáážáŹáááᯠáĄááťáááşááá˝áąá¸ ááąáŤáşááŻáśá¸áááŻáˇááá˛áˇ Built-in functions áá˝áą áĄááťáŹá¸ááźáŽá¸ ááŤááŤáááşá ááťá˝ááşááąáŹáşáááŻáˇ Output ááᯠScreen ááąáŤáşááŻááşáááŻáˇ ááŻáśá¸ááąááť print( ) function ááááşá¸ Built-in function áá áşááŻááŤáá˛á
Built-in function áá áşááŻááŻáĄááźáąáŹááşá¸ Help áááŻááťááşáááş help(function) ááᯠááŻáśá¸ááźáŽá¸ ááźááˇáşáááŻáˇáááŤáááşá
Numbers áá˝áąáá˛áˇ áá˝á˛ááŻáśá¸ááąáˇáážááá˛áˇ Built-in functions áá˝áąááᯠáĄáąáŹááşáážáŹ ááąáŹáşááźááŹá¸ááŤáááş -
abs(x) # x áá˛áˇ Absolute value (áááááááşáááŻá¸) ááᯠááźááşááąá¸ááŤáááş
pow(x, y) # x áá˛áˇ y áááşááááşá¸áááşáááŻá¸ (x raised to y) ááᯠááźááşááąá¸ááŤáááş
min(x1, x2,...) # ááąá¸ááŹá¸áá˛áˇáá˛á áĄáááşááŻáśá¸áááşáááŻá¸ (Smallest argument) ááᯠááźááşááąá¸ááŤáááş
max(x1, x2,...) # ááąá¸ááŹá¸áá˛áˇáá˛á áĄááźáŽá¸ááŻáśá¸áááşáááŻá¸ (Largest argument) ááᯠááźááşááąá¸ááŤáááş
divmod(x, y) # (x // y, x % y) áááŻááźáŽá¸ á
áŹá¸áááşáá˛áˇ áĄááźá˝ááşá¸áĄáá˝á˛ (Pair) ááᯠááźááşááąá¸ááŤáááş
round(x [,n]) # x ááᯠáááááąáᏠn ááŻáĄáá ááźááşááźáŽá¸ (Round ááŻááşááźáŽá¸) ááźááşááąá¸ááŤáááş
bin(x) # x áá˛áˇ Binary equivalent (Binary áááşáááŻá¸) ááᯠááźááşááąá¸ááŤáááş
oct(x) # x áá˛áˇ Octal equivalent (Octal áááşáááŻá¸) ááᯠááźááşááąá¸ááŤáááş
hex(x) # x áá˛áˇ Hexadecimal equivalent (Hexadecimal áááşáááŻá¸) ááᯠááźááşááąá¸ááŤáááş
áĄáąáŹááşá፠Python program áážáŹ áᎠBuilt-in functions áá˝áąáá˛á áááťááŻáˇááᯠáááşáááŻááŻáśá¸áááá˛áááŻáᏠááźááŹá¸ááŤáááş -
a = abs(-3) # a áá˛ááᯠ3 áááˇáşáááŻááşááŤáááş
print(min(10, 20, 30, 40)) # 10 ááᯠprint ááŻááşááąá¸ááŤáááş
print(hex(26)) # 1a (hex value) ááᯠprint ááŻááşááąá¸ááŤáááş
3.4.3 Built-in Modules¶
Built-in functions áá˝áąáĄááźááşá Python áážáŹ Built-in modules áá˝áąáááşá¸ áĄááťáŹá¸ááźáŽá¸ ááŤáááşááŤáááşá Module áá áşááŻá áŽáážáŹ Functions áá˝áą áĄááťáŹá¸ááźáŽá¸ ááŤáááşááŤáááşá áĄáááˇáşááźááˇáş Mathematical operations áá˝áą ááŻááşááąáŹááşáááŻáˇáĄáá˝ááş Built-in modules áá˝áąááźá áşáá˛áˇ math, cmath, random, decimal áááŻáˇáá˛á Functions áá˝áąááᯠáĄááŻáśá¸ááźáŻáááŻááşááŤáááşá
math - áĄááŻáśá¸áááşáá˛áˇ mathematics functions áá˝áą áĄááťáŹá¸ááźáŽá¸ ááŤááŤáááşá
cmath - complex numbers áá˝áąááąáŤáşáážáŹ operations ááŻááşáááŻáˇ functions áá˝áą ááŤááŤáááşá
random - random number generation (ááááşá¸áá˝áą ááťáááşá¸ááŻááşááąá¸ááŹ) áá˛áˇ áááşáááşáá˛áˇ functions áá˝áą ááŤááŤáááşá
decimal - ááááťááąááťáŹáá˛áˇ arithmetic operations áá˝áą ááŻááşáááŻáˇ functions áá˝áą ááŤááŤáááşá
math module áá˛á Mathematical functions ááťáŹá¸:
pi, e # pi áá˛áˇ e constants áá˝áąáá˛áˇ áááşáááŻá¸ááťáŹá¸
sqrt(x) # x áá˛áˇ Square root
factorial(x) # x áá˛áˇ Factorial
fabs(x) # Float x áá˛áˇ Absolute value
log(x) # x áá˛áˇ Natural log (log to the base e)
log10(x) # x áá˛áˇ Base-10 logarithm
exp(x) # e áá˛áˇ x áááşááááşá¸ (e raised to x)
trunc(x) # Integer ááźá
áşáĄáąáŹááş ááźááşááŻááşáááŻááşááźááşá¸ (Truncate)
ceil(x) # x áá˛áˇ ááŽáá˛áˇ (áááŻáˇ) x áááşááźáŽá¸áá˛áˇáĄáá˛á áĄáááşááŻáśá¸ Integer (Ceiling)
floor(x) # x áá˛áˇ ááŽáá˛áˇ (áááŻáˇ) x áááşáááşáá˛áˇáĄáá˛á áĄááźáŽá¸ááŻáśá¸ Integer (Floor)
modf(x) # x áá˛áˇ Fractional áá˛áˇ Integer parts áá˝áąááᯠáá˝á˛ááŻááşááąá¸ááźááşá¸
round( ) built-in function á Decimal places (áááááąááŹ) áĄááąáĄáá˝ááş áááşáážááşááźáŽá¸ Round ááŻááşáááŻáˇáááąáááˇáşá math module áá˛áˇ Library functions áá˝áąááźá áşáá˛áˇ trunc( )á ceil( ) áá˛áˇ floor( ) áá˝áąáááąáŹáˇ áĄááźá˛áááşá¸ Decimal places áááŤáĄáąáŹááş (Zero decimal places áĄáá) Round ááŻááşááąá¸ááŤáááşá
math module áá˛á Trigonometric functions ááťáŹá¸:
degrees(x) # Radians áááą Degrees áááŻáˇ ááźáąáŹááşá¸ááźááşá¸
radians(x) # Degrees áááą Radians áááŻáˇ ááźáąáŹááşá¸ááźááşá¸
sin(x) # x Radians áá˛áˇ Sine áááşáááŻá¸
cos(x) # x Radians áá˛áˇ Cosine áááşáááŻá¸
tan(x) # x Radians áá˛áˇ Tan áááşáááŻá¸
sinh(x) # x áá˛áˇ Hyperbolic sine
cosh(x) # x áá˛áˇ Hyperbolic cosine
tanh(x) # x áá˛áˇ Hyperbolic tan
acos(x) # x áá˛áˇ Cos inverse (Radians áá˛áˇ áááŤáááş)
asin(x) # x áá˛áˇ Sine inverse (Radians áá˛áˇ áááŤáááş)
atan(x) # x áá˛áˇ Tan inverse (Radians áá˛áˇ áááŤáááş)
hypot(x, y) # sqrt(x * x + y * y) (ááąáŹááˇáşáážááşááśáĄááŹá¸ áážáŹááźááşá¸)
random module áááą Random number generation ááŻááşááąá¸áá˛áˇ Functions ááťáŹá¸:
random( ) # 0 áá˛áˇ 1 ááźáŹá¸á random number áá
áşáᯠááŻááşááąá¸ááŤáááş
randint(start, stop) # áááşáážááşááŹá¸áá˛áˇ range áá˛á random number áá
áşáᯠááŻááşááąá¸ááŤáááş
seed( ) # random number generation logic áĄáá˝ááş current time ááᯠseed áĄááąáá˛áˇ áááşáážááşááŤáááş
seed(x) # random number generation logic áĄáá˝ááş x ááᯠseed áĄááąáá˛áˇ áááşáážááşááŤáááş
áĄáąáŹááşá፠Python program áážáŹ math module áá˛áˇ random module áá˛á Functions áááťááŻáˇááᯠáááşáááŻáĄááŻáśá¸ááźáŻáá˛áááŻáᏠááźáááŹá¸ááŤáááş -
import math
import random
print(math.factorial(5)) # 120 ááᯠprint ááŻááşááąá¸ááŤáááş
print(math.degrees(math.pi)) # 180.0 ááᯠprint ááŻááşááąá¸ááŤáááş
print(random.random( )) # 0.8960522546341796 (ááťáááşá¸ááááşá¸áá
áşááŻ) ááᯠprint ááŻááşááąá¸ááŤáááş
import math
print(dir(__builtins__)) # builtins áá˛áˇ áážáąáˇáá˛áˇááąáŹááşáážáŹ underscores 2 ááŻá
ᎠááŤááŤáááş
print(dir(math))
3.5 Container Types¶
Container types áááŻááŹá ááŻáśáážááşáĄáŹá¸ááźááˇáş Values áĄááťáŹá¸ááźáŽá¸ááᯠáá áŻáá ááşá¸áááşá¸ ááááşá¸áááşá¸ááŹá¸ááŹááᯠáááŻáááŻááŤáááşá Container types áĄááťááŻá¸ááťááŻá¸áá˛áˇ áĽáááŹáá˝áąááᯠáĄáąáŹááşáážáŹ ááąáŹáşááźááŹá¸ááŤáááş -
# list áááŻááŹá áá°ááŹáá˝áąááąáŹá ááá°ááŹáá˝áąááąáŹ ááąáŹáážáąáŹááááşá¸áááşá¸áááŻáˇááá˛áˇ indexed collection áá
áşááŻááŤ
[10, 20, 30, 20, 30, 40, 50, 10], ['She', 'sold', 10, 'shells']
# tuple áááŻááŹá ááźááşáááşáááŻáˇáááá˛áˇ immutable collection áá
áşááŻááŤ
('Rosanna', 34, 4500.55), ('Python With Joe', 350, 195.00)
# set áááŻááŹá unique values (áááşááąáᏠáááŤáá˛áˇ áááşáááŻá¸) áá˝áąááᯠá
áŻá
ááşá¸ááŹá¸ááŹááŤ
{10, 20, 30, 40}, {'Rosanna', 34, 45000}
# dict áááŻááŹá key-value pairs áá˝áąááᯠá
áŻá
ááşá¸ááŹá¸ááŹááźá
áşááźáŽá¸á unique key áá˝áąááᯠ'' ááźáŹá¸áá˛áážáŹ ááŹá¸áááŤáááş
{'ME101' : 'Strength of materials', 'EE101' : 'Electronics'}
áĄáąáŹááşá፠Program áážáŹ ááŤáá˝áąááᯠáááşáááŻááŻááşáá˛áááŻáᏠááźááŹá¸ááŤáááş -
lst = [10, 20, 30, 20, 30, 40, 50, 10]
tpl = ('Python With Joe', 350, 195.00)
s = {10, 20, 30, 40}
dct = {'ME101' : 'SOM', 'EE101' : 'Electronics'}
# List áá˛áˇ Tuple ááᯠIndex (Position) ááŻáśá¸ááźáŽá¸ Access ááŻááşááźááşá¸
print(lst[0], tpl[2]) # 10 áá˛áˇ 195.0 ááᯠprint ááŻááşááąá¸ááŤáááş
# Dictionary ááᯠKey ááŻáśá¸ááźáŽá¸ Access ááŻááşááźááşá¸
print(dct['ME101']) # SOM ááᯠprint ááŻááşááąá¸ááŤáááş
3.5.1 Python Type Jargon¶
Python Types áá˝áąáĄááźáąáŹááşá¸ ááźáąáŹáá˛áˇáĄá፠áĄáąáŹááşá፠Terms (ááąáŤááŹá) áá˝áąááᯠáááźáŹáá ááŻáśá¸ááąáˇáážáááŤáááş -
-
Collection - Container types áá˝áąááᯠááąááŻááťááąáŤáşáá˛áˇ áĄááąáŤáşáĄááąáŤáşááŤá
-
Iterable - Loop áááşááźáŽá¸ áĄáá˛á áááşáááŻá¸áá˝áąááᯠáá áşááŻááťááşá¸á Ꭰáá˝á˛ááŻááşáĄááŻáśá¸ááźáŻáááŻáˇááá˛áˇ Collection ááťááŻá¸ááᯠáááŻáááŻááŹááŤá
-
Ordered collection - Elements áá˝áąááᯠáááˇáşáááŻááşáá˛áˇ áĄá ááşáááŻááşáĄáááŻááşá¸áᲠááááşá¸áááşá¸ááąá¸ááŹá¸ááŹááŤá ááŤááźáąáŹááˇáş áá°áˇáá˛áˇ Elements áá˝áąááᯠIndex (Position) ááŻáśá¸ááźáŽá¸ áážááşá¸ááąáŤáşáááŻáˇ áááŤáááşá
-
Unordered collection - Elements áá˝áąááᯠáááˇáşáááŻááşáá˛áˇ áĄá ááşáááŻááşáĄáááŻááşá¸ ááááşá¸áááąá¸ááŤáá°á¸á ááŤááźáąáŹááˇáş Element áá áşááŻá áááşááąáᏠ(Position) áážáŹ ááąáŹááşááąááá˛áááŻáᏠááźááŻáááˇáşáážááşá¸áááŻáˇ ááááŤáá°á¸á ááŽááąáŹáˇ Position ááᯠáĄááźáąááśáá˛áˇ Index áááŻááŻáśá¸ááźáŽá¸ áážááşá¸ááąáŤáşáááŻáˇ ááááŤáá°á¸á
-
Sequence - Ordered collection áá˝áąááᯠááąááŻááťááąáŤáşáá˛áˇ áĄááąáŤáşáĄááąáŤáşááŤá
-
Immutable - ááźáąáŹááşá¸áá˛áááŻáˇáááá˛áˇ (Unchangeable) Collection ááᯠáááŻáááŻááŤáááşá
-
Mutable - ááźáąáŹááşá¸áá˛áááŻáˇááá˛áˇ (Changeable) Collection ááᯠáááŻáááŻááŤáááşá
áĄááŻááąáˇááŹáá˛áˇááźáŽá¸áá˛áˇ Types áá˝áąá ááŽáĄááťááşáá˝áąáá˛á áááşááŹáá˝áąáá˛áˇ áááŻááşááŽáá˛áááŻáᏠááźááˇáşáááŻááşááĄáąáŹááş -
-
String - Ordered collection ááźá áşáááşá Immutable ááźá áşáááşá Iterable ááźá áşáááşá
-
List - Ordered collection ááźá áşáááşá Mutable ááźá áşáááşá Iterable ááźá áşáááşá
-
Tuple - Ordered collection ááźá áşáááşá Immutable ááźá áşáááşá Iterable ááźá áşáááşá
-
Set - Unordered collection ááźá áşáááşá Mutable ááźá áşáááşá Iterable ááźá áşáááşá
-
Dictionary - Unordered collection ááźá áşáááşá Mutable ááźá áşáááşá Iterable ááźá áşáááşá
3.5.2 Comments and Indentation¶
Comments áá˝áąááᯠ# áá˛áˇ á áááşááąá¸ááŹá¸áááŤáááşá
# calculate gross salary
gs = bs + da + hra + ca
si = p * n * r / 100 # calculate simple interest
Multi-line comments áá˝áąááᯠ''' (áááŻáˇáááŻááş) """ áĄá áŻáśáááŻááş (Pair) ááźáŹá¸áá˛áážáŹ ááąá¸ááŹá¸áááˇáşááŤáááşá
''' Additional program: Calculate bonus to be paid
URL: [https://github.com/rose1996iv/PythonWithJoe](https://github.com/rose1996iv/PythonWithJoe)
Author: Joseph, Date: 7 Dec 2025 '''
Indentation á áĄáááşá¸áĄááąá¸ááźáŽá¸ááŤáááş! ááąáŤáˇááąáŤáˇáá ááŻáśá¸áááŻáˇááááŤáá°á¸á áĄáąáŹááşá Code áážáŹáááŻáááş 'Unexpected indent' áááŻáá˛áˇ Error áááşááŤááááˇáşáááşá
a = 20
b = 45 # áᏠreason ááž ááážááᲠspace áá˝áŹááŹá¸áááŻáˇ Error áááşááŤáááş
Multi-lining
ááááşáááŻáˇ Statements áá˝áąá áážááşááąáá˛áˇáááş á
áŹááźáąáŹááşá¸áĄááťáŹá¸ááźáŽá¸áá˝á˛ááźáŽá¸ (Multi-lines) ááąá¸áááŻáˇáááŤáááşá áĄá˛ááŽáááŻááąá¸áá˛áˇáĄá፠ááąáŹááşááŻáśá¸á
áŹááźáąáŹááşá¸ááá˝á˛áááş ááťááşáá˛áˇá
áŹááźáąáŹááşá¸áá˝áąáá˛áˇ áĄááŻáśá¸áážáŹ \ áááˇáşááąá¸áááŤáááşá
total = physics + chemistry + maths + \
english + myanmar + history + \
geography + civics
[ ]á { } (áááŻáˇáááŻááş) ( ) áá˝áąááźáŹá¸áá˛áážáŹááąá¸áá˛áˇ Multi-line statements áá˝áąáĄáá˝ááşááąáŹáˇ \ áááˇáşááąá¸á
áᏠááááŻááŤáá°á¸á
3.6 Classes and Objects¶
Python áážáŹ Type áááŻááşá¸á Class áá áşáᯠááźá áşááŤáááşá ááŤááźáąáŹááˇáş intá floatá complexá boolá strá listá tupleá setá dict á ááŹáá˝áą áĄááŻááşááŻáśá¸á Classes áá˝áąááťááşá¸ááŤáá˛á ááŤáá˝áąá Ready-made classes áá˝áąááŤá Python á User-defined classes áá˝áąááᯠáááŻááşáááŻááşáááşááŽá¸áá˝ááˇáş ááąá¸ááŹá¸ááŤáááş (Chapter 18 ááťáááş áá˝áąáˇáááŤáááş)á
Object áá áşááŻááᯠClass áááą áááşááŽá¸áá°ááŤáááşá Class áá áşááŻá áĄááťááşáážá áşááťááşááᯠáááşáážááşááąá¸ááŤáááş - 1. áá°áˇááŽáááą áá˝ááşááŹáááˇáş Object áá°áááˇáş ááŻáśá áś (Form) 2. áĄá˛áᎠObject ááᯠAccess ááŻááşáááŻáˇáá˛áˇ Manipulate ááŻááşáááŻáˇ ááŻáśá¸ááááˇáş Methods (Functions) ááťáŹá¸
Class áá áşááŻáááşá¸áááą Objects áĄááťáŹá¸ááźáŽá¸ áááşááŽá¸áááŻáˇ áááŤáááşá Class áá áşááŻáááą Object áá áşáᯠáááşááŽá¸áááŻááşááŹááᯠáĄá˛áᎠClass áá˛áˇ Instance áá áşáᯠáááşááŽá¸áááŻááşáááşáááŻáˇ ááźáąáŹááąáˇáážáááźááŤáááşá
Class áážáŹ ááŹáááşáážáááąáááˇáş Objects áá˝áąáážáŹ ááŹáááşááážáááŤáá°á¸á Objects áá˝áąáážáŹ ááŹáááşááážááá˛áˇáĄáá˝ááş Memory áá˛á áá°áááŻáˇáá˛áˇ Addresses áá˝áąááᯠááŻáśá¸ááźáŽá¸ áááşáá˝ážááşá¸ (Refer) ááźááŤáááşá
ááŽáĄááťááşáá˝áąááᯠáĄáąáŹááşá፠Program áá˛áˇ á ááşá¸áááşáĄáááşááźáŻáááŻááşááŤáááşá áááŻááźáŽá¸ááŹá¸áááşáá˝áŹá¸áĄáąáŹááş Observation (ááąáˇááŹáá˝áąáˇáážáááťááş) áá˝áąááᯠááźááˇáşááŤá
a = 30
b = 'Good'
print(a, b) # 3 Good áááŻááźáŽá¸ print áá˝ááşááŤáááş
print(type(a), type(b)) # <class 'int'> <class 'str'> áááŻááźáŽá¸ Class áá˝áąááᯠááźááŤáááş
print(id(a), id(b)) # 1356658640 33720000 áááŻááźáŽá¸ Memory address áá˝áą ááźááŤáááş
print(isinstance(a, int), isinstance(b, str)) # True True áááŻááźáŽá¸ ááźááŤáááş
3.7 Python Object Reference Visualization¶
Python áážáŹ Variables áá˝áąá Memory ááąáŤáşáážáŹáážááá˛áˇ Objects áá˝áąááᯠáááşááᯠRefer ááŻááşááᲠ(áááşááᯠáá˝ážááşááźááŹá¸ááá˛) áááŻáᏠááŹá¸áááşáááŻáˇ áĄáááşá¸áĄááąá¸ááźáŽá¸ááŤáááşá
Key Concept
- Python áážáŹ Variables áá˝áąáááŻáᏠááááşáááşá¸ááťááąáŹáˇ Memory áá˛áážáŹ ááááşá¸áááşá¸ááŹá¸áá˛áˇ Objects áá˝áąááᯠáá˝ážááşááźááąáá˛áˇ References (áááŻáˇáááŻááş Pointers) áá˝áąáᲠááźá áşááŤáááşá áá°áááŻáˇá Values áá˝áąááᯠáááŻááşáááŻááş ááááşá¸áááşá¸ááŹá¸áᏠáááŻááşááŤáá°á¸á Value ááááşá¸ááŹá¸áá˛áˇ Memory location ááᯠáá˝ážááşááźááąá¸ááąááŹáᏠááźá áşááŤáááşá
Memory Reference Breakdown¶
áĄáąáŹááşááŤáááŹá¸á ááŻáśáá˛áážáŹááźááŹá¸áá˛áˇ References áá˝áąááᯠáĄááąá¸á áááş áážááşá¸ááźááŹá¸ááŹá፠-
| Variable Name | Reference ID (Address) | Points To (Object Type) | Object Value | Object Memory Address |
|---|---|---|---|---|
a |
1356658640 |
int object | 30 |
1356658640 |
b |
33720000 |
str object | Good |
33720000 |
Observation (ááąáˇááŹáá˝áąáˇáážáááťááş)
- Variable
aáážáŹ Reference ID1356658640áážáááąááŤáááşá áĄá˛ááŤá Integer Object30áážáááąáá˛áˇ Address áá˛áˇ áĄáá°áá°ááŤáá˛á - Variable
báážáŹ Reference ID33720000áážáááąááŤáááşá áĄá˛ááŤá String Object'Good'áážáááąáá˛áˇ Address áá˛áˇ áĄáá°áá°ááŤáá˛á
áᎠProgram áážáŹ ááťá˝ááşááąáŹáşáááŻáˇ Objects áážá áşááŻááᯠáááşááŽá¸áá˛áˇááŤáááşá áá áşááŻá Ready-made class ááźá áşáá˛áˇ int áááąááźá áşááźáŽá¸á ááąáŹááşáá áşááŻá Ready-made class ááźá áşáá˛áˇ str áááą ááźá áşááŤáááşá
int type Object áá˛áážáŹ 30 ááŤáááşááźáŽá¸á str type Object áá˛áážáŹááąáŹáˇ 'Good' ááŤáááşááŤáááşá
Objects áážá
áşááŻááŻáśá¸á ááŹáááşááážáááŤáá°á¸ (Nameless ááźá
áşááŤáááş)á Memory áá˛á áá°áááŻáˇáá˛áˇ Addresses áá˝áąááźá
áşáá˛áˇ 1356658640 áá˛áˇ 33720000 ááᯠa áá˛áˇ b áá˛áážáŹ ááááşá¸áááşá¸ááŹá¸ááŹááŤá
áᎠAddresses áá˝áąááᯠBuilt-in function ááźá áşáá˛áˇ id( ) áááŻááŻáśá¸ááźáŽá¸ ááá°áááŻááşááŤáááşá (áážááşááťááş - áááşááťáŹá¸áááŻáˇá ááşáážáŹ áááŻááşáááŻááş Run áááşááąáŹáˇ Addresses áá˝áą ááá°áᏠáá˝ááşááŹáááŻááşááŤáááş)á
a áá˛áˇ b á Addresses áá˝áąááᯠááááşá¸ááŹá¸áá˛áˇáĄáá˝ááş áá°áááŻáˇááᯠáĄá˛áᎠAddresses áážáŹáážááá˛áˇ Objects áá˝áąááᯠRefer ááŻááşááąáááş (áááşáá˝ážááşá¸ááąáááş) áááŻáˇ ááźáąáŹááźááŤáááşá áá˝ááşáá˝ááşááźáąáŹááááş áá°áááŻáˇá Objects áá˝áąááᯠáá˝ážááşááźááąáá˛áˇ Pointers áá˝áąááŤáá˛á
a áá˛áˇ b á Refer ááŻááşááąáá˛áˇ Objects áá˝áąáá˛áˇ Type ááᯠááááťááşáááş Built-in function ááźá
áşáá˛áˇ type( ) ááᯠááŻáśá¸áááŻááşááŤáááşá
a á class int áá˛áˇ Instance ááŻááşáááŻááş á
á
áşááąá¸ááťááşáááşááąáŹáˇ Built-in function ááźá
áşáá˛áˇ isinstance( ) ááᯠááŻáśá¸áááŻááşááŤáááşá
Multiple Objects
áĄáąáŹááşá፠Program ááąá¸ááᯠáááşááźááˇáşááĄáąáŹááş -
a = 3
b = 3
print(id(a), id(b)) # 1356658640 1356658640 áááŻááźáŽá¸ áá°ááąááŹááᯠáá˝áąáˇáááŤáááş
print(a is b) # True ááźááŤáááş
a = 30 # áĄáᯠa á Object áĄáá
áşáá
áşááŻááᯠRefer ááŻááşáá˝áŹá¸ááŤááźáŽ
print(id(a)) # 1356659072 áááŻááźáŽá¸ Address ááźáąáŹááşá¸áá˝áŹá¸ááŤáááş
ááťá˝ááşááąáŹáşáááŻáˇ int objects áážá
áşáᯠáááşááŽá¸áááŻááşááŹááŹá¸? áááŻááşááŤáá°á¸á int object áá˛áážáŹ ááááşá¸ááŹá¸áá˛áˇ Value á áá°ááąáá˛áˇáĄáá˝ááş (áážá
áşááŻááŻáśá¸á 3 ááźá
áşááąáááŻáˇ)á int object áá
áşááŻáááşá¸áááŻáᲠáááşááŽá¸ááŤáááşá a ááąáŹ b ááąáŹá áĄá˛áᎠint object áá
áşááŻáááşá¸áááŻáᲠáážááşá¸ááźáŽá¸ Refer ááŻááşááąááźááŹááŤá ááŤááźáąáŹááˇáş id(a) áá˛áˇ id(b) á áá°ááŽáá˛áˇ Addresses áá˝áąááᯠááźááşááąá¸ááŹááźá
áşááŤáááşá
ááŤááᯠis operator ááŻáśá¸ááźáŽá¸áááşá¸ á
á
áşááąá¸áááŻááşááŤáááşá a áá˛áˇ b á Object áá
áşááŻáááşá¸áááŻáᲠRefer ááŻááşááąáá˛áˇáĄáá˝ááş True áááŻáˇ ááźááşááąá¸ááŤááááˇáşáááşá
ááťá˝ááşááąáŹáşáááŻáˇá a áá˛ááᯠValue áĄáá
áşáá
áşáᯠáááˇáşáááŻáˇ ááźááŻá¸á
áŹá¸áááŻááşáá˛áˇáĄá፠(áĽááᏠ- 30 áááˇáşáááŻááşáááş)á ááááşá¸ááááˇáş áááşáááŻá¸á áá˝á˛ááźáŹá¸áá˝áŹá¸ááźáŽááźá
áşáá˛áˇáĄáá˝ááş int object áĄáá
áşáá
áşááŻááᯠáááşááŽá¸áááŻááşááŤáááşá áĄááŻáĄááŤáážáŹ a á áᎠint object áĄáá
áşááᯠááźáąáŹááşá¸ááźáŽá¸ Refer ááŻááşáá˝áŹá¸ááŤááźáŽá b áááąáŹáˇ áá°á int object (Value 3 áážááá˛áˇááąáŹááş) áááŻáᲠáááşááźáŽá¸ Refer ááŻááşááąááŻááşá¸ááŤáá˛á
a á 3 ááŤáááşáá˛áˇ int object ááᯠRefer ááŻááşááąáááşáááŻáˇ ááźáąáŹáááˇáşáĄá
áŹá¸á a áááş int object ááźá
áşáááşá áááŻáˇáááŻááş 3 ááᯠa áᲠAssign ááŻááşáááŻááşáááşáááŻáˇáᲠáĄáá˝ááşááźáąáŹááąáˇáážáááźááŤáááşá
Programmers ááąáŹáşááąáŹáşááťáŹá¸ááťáŹá¸á a áá˛áˇ b ááᯠint variables áá˝áą (áááşáááŻá¸áá˝áąááᯠáááŻááşáááŻááşááááşá¸áá˛áˇ áĄáá˝ááşáá˝áą) áááŻáˇ áááşááąááźááŻááşá¸ááŤáá˛á ááááşáááşá¸á áĄá˛ááŽáááŻáááŻááşáá°á¸áááŻáᏠáĄááŻááąáŹááşááᯠááááąáŹááşááŤááźáŽá
Problem 3.1¶
Integer types áá˝áąáá˛áˇ áá°áááŻáˇáĄááąáŤáşáážáŹ ááŻáśá¸áááŻáˇááá˛áˇ Operators áá˝áąááᯠáááşáááŻáĄááŻáśá¸ááźáŻááá˛áááŻáᏠáááŻááşááźááŤá
Program (áážáááşááźáŽá¸ ááźááˇáşáááŻááşááŤáááş)
# use of integer types
print(3 / 4) # Division (áĄááźážáąáŹááş)
print(3 % 4) # Modulus (áĄááźá˝ááşá¸)
print(3 // 4) # Floor Division (á
áŹá¸áááş áĄááąáĄáá˝ááş)
print(3 ** 4) # Exponentiation (áááşááááşá¸)
a = 10 ; b = 25 ; c = 15 ; d = 30 ; e = 2 ; f = 3 ; g = 5
w = a + b - c
x = d ** e
y = f % g
print(w, x, y)
# Python handles large integers automatically
h = 99999999999999999
i = 54321
print(h * i)
Tips
- ¾ á 0 ááá˝ááşááŤáá°á¸ (Python 3 áážáŹ Float division ááźá áşáá˝áŹá¸áááŻáˇ 0.75 áá˝ááşááŤáááş)á
- áá
áşááźáąáŹááşá¸áááşá¸áážáŹ Statements áĄááťáŹá¸ááźáŽá¸ááąá¸áááşáááŻáááş
;ááśááźáŽá¸ ááźáŹá¸ááąá¸áááŤáááşá - print(w, x, y) á Values áá˝áąááᯠSpace ááźáŹá¸ááźáŽá¸ Print ááŻááşááąá¸ááŤáááşá
Problem 3.2¶
floatá complex áá˛áˇ bool types áá˝áąáá˛áˇ áá°áááŻáˇáĄááąáŤáşáážáŹ ááŻáśá¸áááŻáˇááá˛áˇ Operators áá˝áąááᯠáááşáááŻáĄááŻáśá¸ááźáŻááá˛áááŻáᏠáááŻááşááźááŤá
Program (áážáááşááźáŽá¸ ááźááˇáşáááŻááşááŤáááş)
# use of float (float ááᯠáĄááŻáśá¸ááźáŻááźááşá¸)
i = 3.5
j = 1.2
print(i % j) # Modulus áážáŹááźááşá¸
# use of complex (complex number ááᯠáĄááŻáśá¸ááźáŻááźááşá¸)
a = 1 + 2j
b = 3 * (1 + 2j)
c = a * b
print(a)
print(b)
print(c)
print(a.real) # Real part ááᯠááŻááşááźááˇáşááźááşá¸
print(a.imag) # Imaginary part ááᯠááŻááşááźááˇáşááźááşá¸
print(a.conjugate( )) # Conjugate ááŻááşááźááşá¸
print(a)
# use of bool (Boolean ááᯠáĄááŻáśá¸ááźáŻááźááşá¸)
x = True
y = 3 > 4
print(x)
print(y)
Tips
%(Modulus operator) á floats áá˝áąááąáŤáşáážáŹáááşá¸ áĄááŻááşááŻááşááŤáááşá- Complex number áá áşááŻáááą real áá˛áˇ imag part áá˝áąááᯠáá˝á˛ááŻááşáá°áááŻáˇáááŤáááşá
- Condition áá áşááŻááᯠEvaluation ááŻááşáááŻááşáááş True áááŻáˇáááŻááş False áĄááźá áş áĄá áŹá¸áááŻá¸áá˝áŹá¸ááŤáááşá
Problem 3.3¶
Number type áá áşááŻáááą ááąáŹááşáá áşááŻááᯠáááşááᯠConvert ááŻááşááá˛áááŻáᏠáááŻááşááźááŤá
Program (áážáááşááźáŽá¸ ááźááˇáşáááŻááşááŤáááş)
# convert to int (Integer ááźáąáŹááşá¸ááźááşá¸)
print(int(3.14)) # float áááą int áááŻáˇ ááźáąáŹááşá¸ááŹá፠(áááááźááşááŤáááş)
a = int('485') # numeric string áááą int áááŻáˇ
b = int('768') # numeric string áááą int áááŻáˇ
c = a + b
print(c)
# Base áá˝áąááźáąáŹááşá¸ááźáŽá¸ int ááŻááşááźááşá¸
print(int('1011', 2)) # binary string áááą decimal int áááŻáˇ
print(int('341', 8)) # octal string áááą decimal int áááŻáˇ
print(int('21', 16)) # hex string áááą decimal int áááŻáˇ
# convert to float (Float ááźáąáŹááşá¸ááźááşá¸)
print(float(35)) # int áááą float áááŻáˇ (35.0 ááźá
áşáá˝áŹá¸áááş)
i = float('4.85') # numeric string áááą float áááŻáˇ
j = float('7.68') # numeric string áááą float áááŻáˇ
k = i + j
print(k)
# convert to complex (Complex number ááźáąáŹááşá¸ááźááşá¸)
print(complex(35)) # int áááą complex áááŻáˇ (35+0j)
x = complex(4.85, 1.1) # arguments áážá
áşááŻááąá¸ááźáŽá¸ ááąáŹááşááźááşá¸
y = complex(7.68, 2.1)
z = x + y
print(z)
# convert to bool (Boolean ááźáąáŹááşá¸ááźááşá¸)
print(bool(35)) # Non-zero áááŻáˇ True áááŤáááş
print(bool(1.2)) # Non-zero áááŻáˇ True áááŤáááş
print(int(True)) # 1 áááŤáááş
print(int(False)) # 0 áááŤáááş
Tips
- Binary, Octal, Hexadecimal numeric string áá˝áąááᯠáá°áááŻáˇáá˛áˇááŽááťážáá˛áˇ Decimal integer áĄááźá áş ááźáąáŹááşá¸áááŻáˇáááŤáááşá ááŤááąáááˇáş Float áĄáá˝ááşááąáŹáˇ áĄá˛ááŽáááŻááŻááşáááŻáˇ ááááŤáá°á¸á
- Complex ááᯠConvert ááŻááşáá˛áˇáĄá፠Argument áá
áşááŻáááşá¸ááąá¸áááşáááŻáááş Imaginary part áááŻ
0áááŻáˇ áá°ááá˝áŹá¸ááŤáááşá - ááŻááááŻááşáá˛áˇ ááááşá¸ (Non-zero number - int ááźá
áşááźá
áş float ááźá
áşááźá
áş) áážááşáááťážááᯠTrue áááŻáˇ áááşáážááşááźáŽá¸á
0áááŻááąáŹáˇ False áááŻáˇ áááşáážááşááŤáááşá
Problem 3.4¶
Built-in mathematical functions áá˝áąááᯠáĄááŻáśá¸ááźáŻááŹá¸áá˛áˇ Program áá áşááŻááş ááąá¸ááŤá
Program (áážáááşááźáŽá¸ ááźááˇáşáááŻááşááŤáááş)
# built-in math functions (ááŤááźáŽá¸ááŹá¸ áááşášááťáŹ function ááťáŹá¸)
print(abs(-25)) # Absolute value áážáŹááźááşá¸ (25)
print(pow(2, 4)) # áááşááááşá¸áááşááźááşá¸ (16)
print(min(10, 20, 30, 40, 50)) # áĄáááşááŻáśá¸áážáŹááźááşá¸ (10)
print(max(10, 20, 30, 40, 50)) # áĄááźáŽá¸ááŻáśá¸áážáŹááźááşá¸ (50)
print(divmod(17, 3)) # á
áŹá¸áááşáá˛áˇ áĄááźá˝ááşá¸ áá˝á˛ááŻááşááźááşá¸ ((5, 2))
print(bin(64), oct(64), hex(64)) # Binary, Octal, Hex ááźáąáŹááşá¸ááźááşá¸
print(round(2.567), round(2.5678, 2)) # ááááşá¸ááźááˇáşááźááşááźááşá¸áážááˇáş ááá á ááąááŹááźááşááźááşá¸
Tips
- divmod(a, b) á (a // b, a % b) áááŻáá˛áˇ áĄáá˝á˛ (Pair) ááᯠááŻááşááąá¸ááŤáááşá
- bin( )á oct( )á hex( ) áá˝áąá Binaryá Octal áá˛áˇ Hexadecimal áááşáááŻá¸áá˝áąááᯠááźááşááąá¸ááŤáááşá
- round(x) ááᯠááŻáśá¸áá˛áˇáĄá፠áááááąáᏠáááŤáĄáąáŹááş (0 decimal places) ááźááşáááşáááŻáˇ áá°áááźáŽá¸ áĄááŻááşááŻááşááŤáááşá
Problem 3.5¶
math module áá˛á Functions áá˝áąááᯠáĄááŻáśá¸ááźáŻááŹá¸áá˛áˇ Program áá áşááŻááş ááąá¸ááŤá
Program (áážáááşááźáŽá¸ ááźááˇáşáááŻááşááŤáááş)
# mathematical functions from math module
import math
x = 1.5357
print(math.pi, math.e) # pi áá˛áˇ e áááşáááŻá¸ááťáŹá¸
print(math.sqrt(x)) # Square root áážáŹááźááşá¸
print(math.factorial(6)) # Factorial áážáŹááźááşá¸
print(math.fabs(x)) # Absolute float value
print(math.log(x)) # Natural log (base e)
print(math.log10(x)) # Log base 10
print(math.exp(x)) # e raised to x
print(math.trunc(x)) # áááááźááşááŻááşááźááşá¸ (Truncate)
print(math.floor(x)) # áĄáąáŹááşááťááźááşá¸ (Floor)
print(math.ceil(x)) # áĄááąáŤáşáááşááźááşá¸ (Ceiling)
# Negative values áá˝áąáá˛áˇ á
ááşá¸áááşááźááşá¸
print(math.trunc(-x))
print(math.floor(-x))
print(math.ceil(-x))
print(math.modf(x)) # Fractional part áá˛áˇ Integer part ááᯠáá˝á˛ááŻááşááźááşá¸
Output
Tips
- floor( ) á Negative infinity áááşááᯠáá˝á˛ááťááźáŽá¸ Round ááŻááşááŤáááş (áááşáááŻá¸áĄáááşá¸áááşááᯠáá°ááŤáááş)á ceil( ) á Positive infinity áááşááᯠáá˝á˛áááşááźáŽá¸ Round ááŻááşááŤáááş (áááşáááŻá¸áĄááťáŹá¸áááşááᯠáá°ááŤáááş)á trunc( ) áááąáŹáˇ 0 áááşááᯠáŚá¸áááşááźáŽá¸ Round ááŻááşááŤáááş (ááááá˝áąááᯠáááŻá¸áááŻá¸ááąá¸ ááźááşááŻááşáááŻááşááŹááŤ)á
- Positive numbers áá˝áąáĄáá˝ááşáááŻáááş trunc( ) á floor( ) áá˛áˇ áĄáá°áá°ááŤáá˛á
- Negative numbers áá˝áąáĄáá˝ááşáááŻáááş trunc( ) á ceil( ) áá˛áˇ áĄáá°áá°ááŤáá˛á
- modf( ) á
(f, i)áááŻáá˛áˇ ááááşá¸ááááşá¸áĄáá˝á˛ (Pair) ááᯠááźááşááąá¸ááŤáááş (ááŽáážáŹx = f + iááźá áşááźáŽá¸0 <= f < 1ááźá áşááŤáááş)á
Problem 3.6¶
Float áá˛áˇ Integer random numbers áá˝áąááᯠááŻááşááąá¸áááˇáş Program áá áşááŻááş ááąá¸ááŤá
Program (áážáááşááźáŽá¸ ááźááˇáşáááŻááşááŤáááş)
# random number operations using random module
import random
import datetime
# Seed áááşáážááşááźááşá¸ (áááşáážááĄááťáááşááᯠáá°áááşááźáŽá¸ Random ááŻáśá
áśááźáąáŹááşá¸áĄáąáŹááşááŻááşááŹááŤ)
# Note: ááŻáśáážááşáĄáŹá¸ááźááˇáş Python á ááŤááᯠáĄáááŻáĄááťáąáŹááş ááŻááşááąá¸ááŤáááş
random.seed(datetime.time( ))
print(random.random( )) # 0.0 áá˛áˇ 1.0 ááźáŹá¸ Random float
print(random.random( ))
print(random.randint(10, 100)) # 10 áá˛áˇ 100 ááźáŹá¸ Random integer
Tips
- random module ááᯠáááźá áşáááą import ááŻááşáááŻáˇ áááŻáĄááşááŤáááşá
- Random number generation logic ááᯠáááşáážááĄááťáááş (Current time) áá˛áˇ Seed ááŻááşááąá¸áááŻááşáááşá Program ááᯠExecute ááŻááşáááŻááşáááŻááşá¸ ááá°ááŽáá˛áˇ Random numbers áá˝áąááᯠááážáá áąááŤáááşá
- Parameter áááŤáá˛áˇ random.seed( ) ááááşá¸ Logic ááᯠáááşáážááĄááťáááşáá˛áˇáᲠSeed ááŻááşááąá¸ááŤáááşá
Problem 3.7¶
áĄáąáŹááşááąáŹáşááźá፠Data áá˝áąáá˛á áááşááŹá stringá listá tupleá set (áááŻáˇáááŻááş) dictionary ááźá áşááá˛áááŻáᏠáááşááᯠáá˝á˛ááźáŹá¸áááááŻááşááá˛?
{10, 20, 30.5}
[1, 2, 3.14, 'Nagpur']
{12 : 'Simple', 43 : 'Complicated', 13 : 'Complex'}
"Check it out!"
3 + 2j
Program
# determine type of data (Data Type áá˝áąááᯠá
á
áşááąá¸ááźááşá¸)
print(type({10, 20, 30.5})) # Curly braces {} áá˛áˇáááŻáˇ Set ááŤ
print(type([1, 2, 3.14, 'Nagpur'])) # Square brackets [] áá˛áˇáááŻáˇ List ááŤ
print(type({12 : 'Simple', 43 : 'Complicated', 13 : 'Complex'})) # Key-Value pairs ááŤáááŻáˇ Dict ááŤ
print(type("Check it out!")) # Quotes "" ááŤáááŻáˇ String ááŤ
print(type(3 + 2j)) # j ááŤáááŻáˇ Complex ááŤ
Tips
- type( ) áááŻááŹá built-in ááźá áşá áąá container ááźá áşá áąá user-defined ááźá áşá áą áááşáááˇáş Data áĄááťááŻá¸áĄá áŹá¸áááŻáááᯠáá˝á˛ááźáŹá¸á á áşááąá¸ááąá¸áááŻááşáá˛áˇ Built-in function áá áşááŻááźá áşááŤáááşá
Exercises¶
[A] Answer the following questions:¶
a. Variable a áá˛áˇ b áá˛áˇ áááşáááŻá¸áá˝áąááᯠáĄááťááşá¸ááťááşá¸áážá˛áážááş (Swap) ááąá¸áááˇáş Program áá
áşááŻááşááąá¸ááŤá áááá Variable áá
áşááŻáśá¸ááᯠáĄáá°áĄááŽáá°ááźáŽá¸ ááŻáśá¸áá˝ááˇáşááážáááŤáá°á¸á a áá˛áˇ b áĄááąáŤáşáážáŹ Arithmetic operations (áĄááąáŤááşá¸á áĄááŻááş á
áááş) ááŻááşááąáŹááşáá˝ááˇáşááážáááŤáá°á¸á
b. math module áážáŹááŤáááşáá˛áˇ Trigonometric functions áá˝áąááᯠáĄááŻáśá¸ááźáŻááŹá¸áá˛áˇ Program áá áşááŻááşááąá¸ááŤá
c. 10 áááą 50 ááźáŹá¸áá˛áážáŹáážááá˛áˇ Random numbers 5 ááŻáśá¸ááᯠááŻááşááąá¸áááˇáş Program áá áşááŻááşááąá¸ááŤá Seed value ááᯠ6 ááŹá¸ááźáŽá¸ ááŻáśá¸ááŤá Program ááᯠExecute ááŻááşáááŻááşáááŻááşá¸ áᎠSeed value ááᯠExecution time áá˛áˇ áá˝á˛ááźáŽá¸ ááźáąáŹááşá¸áá˛áá˝áŹá¸áĄáąáŹááş (Change ááźá áşáá˝áŹá¸áĄáąáŹááş) á áŽá ááşááąá¸ááŤá
d. -2.8, -0.5, 0.2, 1.5 áá˛áˇ 2.9 á áá˛áˇ ááááşá¸ááááşá¸áá˝áąáĄáá˝ááş trunc( )á floor( ) áá˛áˇ ceil( ) áááŻáˇáá˛áˇ áá˝áŹááźáŹá¸ááťááşááᯠáážááşá¸áážááşá¸áááşá¸áááşá¸ ááááĄáąáŹááş áááşáá˝áąáˇá ááşá¸áááşááŤá
e. ááźááŻáˇáá áşááźááŻáˇáá˛áˇ áĄáá°ááťáááşááᯠFahrenheit degrees áá˛áˇ áááˇáşááąáŹáşáááᯠáááşáážááşááŤá ááźáŽá¸áááş ááŽáĄáá°ááťáááşááᯠCentigrade degrees ááźáąáŹááşá¸áá˛ááźáŽá¸ áĄáá°ááťáááşáážá áşááťááŻá¸ááŻáśá¸ááᯠPrint ááŻááşááąá¸áááˇáş Program ááąá¸ááŤá
f. ááźáááśáá
áşááŻáá˛áˇ áĄááŹá¸ááťáŹá¸ááźá
áşáá˛áˇ a, b, c áááŻáˇááᯠááąá¸ááŹá¸áááşá áááşá¸ááźáááśáá˛áˇ ááąáŹááˇáş (Angles) á ááŻááᯠáážáŹáá˝áąááźáŽá¸ Next integer áĄááźá
áş Round ááŻááşáᏠááŻááşááąá¸áááˇáş Program ááᯠááąá¸ááŤá áĄáąáŹááşá፠Formulae ááťáŹá¸ááᯠáĄááŻáśá¸ááźáŻá፠-
[B] How will you perform the following operations:¶
áĄáąáŹááşá፠Operations áá˝áąááᯠáááşááᯠááŻááşááąáŹááşááᲠ-
a. 2 + 3j áá˛áˇ Imaginary part ááᯠPrint ááŻááşááŤá
b. 4 + 2j áá˛áˇ Conjugate ááᯠááá°ááŤá
c. Binary 1100001110 áá˛áˇ ááŽááťážáá˛áˇ Decimal áááşáááŻá¸ááᯠPrint ááŻááşááŤá
d. Float value 4.33 ááᯠNumeric string áĄááźá
áş ááźáąáŹááşá¸áá˛ááŤá
e. 29 ááᯠ5 áá˛áˇ á
áŹá¸áá˛áˇáĄá፠áááŹáááˇáş Integer quotient (ááááşá¸ááźááˇáşá
áŹá¸áááş) áá˛áˇ Remainder (áĄááźá˝ááşá¸) ááᯠááá°ááŤá
f. Decimal 34567 áá˛áˇ ááŽááťážáá˛áˇ Hexadecimal áááşáááŻá¸ááᯠááá°ááŤá
g. 45.6782 ááᯠááá á ááąááŹáĄáá (Second decimal place) Round-off ááŻááşááŤá
h. 3.556 áááą 4 ááĄáąáŹááş ááŻááşááŤá (Hint: ceil áááŻáˇáááŻááş round)
i. 16.7844 áááą 17 ááĄáąáŹááş ááŻááşááŤá
j. 3.45 ááᯠ1.22 áá˛áˇ á
áŹá¸áá˛áˇáĄá፠áááŹáááˇáş Remainder (áĄááźá˝ááşá¸) ááᯠááá°ááŤá
[C] Which of the following is invalid variable name and why?¶
áĄáąáŹááşááąáŹáşááźááŤáĄáááşáá˝áąáá˛á áááşááŹá Invalid variable name (áážáŹá¸áá˝ááşá¸ááąáá˛áˇ ááŹáááş) ááźá áşááá˛á ááŹááźáąáŹááˇáşáá˛?
| BASICSALARY | _basic | basic-hra | #MEAN |
|---|---|---|---|
| group. | 422 | pop in 2020 | over |
| timemindovermatter | SINGLE | hELLO | queue. |
| team'svictory | Plot#3 | 2015_DDay |
[D] Evaluate the following expressions:¶
áĄáąáŹááşá፠Expressions áá˝áąááᯠEvaluate ááŻááşá፠(áá˝ááşááťááşáĄááźáąááŻááşááŤ) - (áážááşááťááş - Operator Precedence ááąáŤáş áŚá¸á áŹá¸ááąá¸áĄáááˇáşááᯠáááááźáŻáá˝ááşááťááşááŤ)
a. 2 ** 6 // 8 % 2
b. 9 ** 2 // 5 - 3
c. 10 + 6 - 2 % 3 + 7 - 2
d. 5 % 10 + 10 -23 * 4 // 3
e. 5 + 5 // 5 - 5 * 5 ** 5 % 5
f. 7 % 7 + 7 // 7 - 7 * 7
[E] Evaluate the following expressions:¶
áĄáąáŹááşá፠Expressions áá˝áąááᯠEvaluate ááŻááşá፠-
a. min(2, 6, 8, 5)
b. bin(46)
c. round(10.544336, 2)
d. math.hypot(6, 8)
e. math.modf(3.1415)
[F] Match the following pairs:¶
áĄáąáŹááşá፠áĄáá˝á˛ááťáŹá¸ááᯠáážááşáááşáĄáąáŹááş áážááşáá˝á˛ááąá¸á፠-
| Column A | Column B |
|---|---|
| a. complex | 1. \ |
| b. Escape special character | 2. Container type |
| c. Tuple | 3. Basic type |
| d. Natural logarithm | 4. log( ) |
| e. Common logarithm | 5. log10( ) |