ክፍል ፪

Variables in Python | ተለዋዋጭ

- ቡና ለመጠጣት ሲኒ፥ ውኃ ለመጠጣት ደግሞ ብርጭቆ እንደምንጠቀም ሁሉ፥ አንድን ዳታ(Data) hold ለማድረግ/ ለመያዝ ደግሞ Variable(ተለዋዋጭ) እንጠቀማለን።

- ስለዚህ ተለዋዋጭ ማለት አንድን መረጃ ለመያዝ የሚገለግሉን ኮንቴይነር ማለት ነው።

Syntax:

variable_name = variable_data

በስተግራ በኩል የተዋዋጫችንን ስም፥ ቀስተቀኝ ቡኩ ደግም ማስቀመጥ የምንፈልገውን መረጃ/ ዳታ።

ለምሳሌ

x = 5 

x - የተለዋዋጩ ስም ስትሆን
5 - የተለዋዋጩ ዋጋ ናት።

ስለዚህ አሁን የx ዋጋ 5 ይሆናል ማለት ነው

x = 5 
print(x)

Output

5

Examples:

name = "Abebe"
age = 30
print(name)
print(age)

Output

Abebe
30

Variable Rules | የተለዋዋጭ ህጎች

- ተለዋዋጭ ስናውጅ የመንጠቀማቸው A-Z፣ a-z፣ 0-9ና _ ብቻ ናቸው።
አንድ ላይ 63 Characters።

- Case sensitive ናቸው፤ ማለትም
age ብለን ተለዋዋጭ ብንመሰርትና AGE ብለን በምንሰርት ሁለቱም የተለያዩ ናቸው።

- የተዋዋጫችን ስም በቁጥር መጀመር አይችልም።

- Spaceን በመቀም ተለዋዋጭ መመስረት አንችልም/ Space መጠቅም አንችልም።

- Keywordኦችን (በፓይተን ቀድመው የተያዙ ቃላትን) እንደ ተለዋዋጭ መጠቀም አንችልም።

❌

1one = 1
first name = "Abebe"
$x = 5

✅

```python
one1 = 1
first_name = "Abebe"
x = 5
`

Python Comment

- ኮድ ስንጽፍ፥ ኮዳችን የበለጠ ተነባቢ እንዲሆንና ሌላ ሰው በቶሎ እንዲረዳው ለማድርግ ኮሜንት(Comment) እንጠቀማለን፤ ይህም ኮሜንት በፓይተን Ignore ይደረጋል።

ሁለት አይነት ኮሜን አለ፦ Single-Line comment & Multi-Line comment(Docstring)

Single-Line comment
በ # የሚጀምርና አንድ መስመር ላይ የሚገኙ ከእሱ በኋላ ያሉት ሁሉም እንደ ኮሜንት ይወሰዳሉ

# This is this single line comment
# This line will be ignored by python interpreter

y = 10 # variable y stores the number 10

Multi-Line Comment
- ከአንድ መስመር በላይ ኮሜንት ለመጻፍ የሚረዳን ሲሆን፥ ይንንም ለማድረግ ኮሜንታችንን በሶስት " ወይም ' ውስጥ ቀማስገባት እንዘጋለን።

"""
This is multi-line comment.
Comment improves readability of code and explain the purpose of the code. So it doesn't affect our code.

Let's print out Hello, World
"""

print('Hello, World')

ለምን ኮሜንት እንጠቀማለን?

- የምንጽፈው ኮድ የበለጠ ሌሎች ሰዎች ሊረዱት እንዲችሉ ለማድረግ።

- የጻፍነውን ኮድ ከጊዜ በኋላ ልንረሳው ስለምንችል ደግመን እንድናስታውሰው ይረዳናል።

- የምንጽፈውን ኮድ አላማውን ለማስረዳት

None

ቀደም ብዬ እንደተናገርኩት None ዋጋው ይሄ ነው የማይባል ወይም ዋጋ አልባ የሆነ የዳታ አይነት ነው።

አጠቃቀሙም None Keywordን በመጠቀም አንድ ተለዋጭ ማዘጋጀት ነው።

none = None
print(none)
print(type(none))

Output

None
<class 'NoneType'>

⚠️ None የሚለው ቃል none ከሚለው ጋር ፈጽሞ አይገናኝም። None የፓይተን ቁልፍ ቃል(Keyword) ወይም ቀድሞ የተያዘ ቃል ነው።

🔅TIP

የአንድን ነገር Data type በቀላሉ ለማወቅ

type

የሚባል built in function መጠቀም ይቻላል።

print(type(2))
print(type(None))


Output

<class 'int' >
<class 'NoneType'>

Integer

Integer የሚባለው ደግሞ፥ ከDecimal  ውጪ ያሉትን ቁጥሮች፥ -ve፣ 0ና +ve ቁጥችን የያዘ የዳታ አይነት ነው።

x = 5
print(x) 
print(type(x))

Output

5
<class 'int'>

Integer የሚወከለውም int በሚባል built in function ነው፤ ለዛም ነው

print(type(x))

ብለን ስጽፍ፥ <class 'int'> ብሎ የሚወጣው።

Float

ይሄ ደግሞ የInteger ተቃራኒ ሲሆን፥ የሚይዘውም Decimal የሆኑ ቁጥሮችን ብቻ ነው።

y = 5.2
print(y)
print(type(y))

Output

5.2
<class 'float'>

የሚወከለውም float በሚባል built in function ነው።

- የትኛውም ቁጥር በውስጡ አንድ ነጥብ(.) ይዞ፥ ከነጥቡ በኋላ ያለው ቁጥር ዜሮ(0) እንኳ ቢሆን፥ ያየዳታ አይነት float ነው የሚሆነው።

ለምሳሌ፦

int_one = 1 # int
float_one = 1.0 # float

print(type(int_one))
print(type(float_one))

Output

<class 'int'>
<class 'float'>

ስለዚህ ከላይ የተጠቀሱት 1 እና 1.0 ልዩነት አላቸው ማለት ነው።

Complex

ይህ የቁጥር አይነት ደግሞ ከInteger ና Float የተለየ፥ ግን ሁለቱንም ያቀፈ ቁጥር ነው። ሂሳብ ላይ ካለው complex number ጋር አንድ ሲሆን፥ ልዩነቱ ሂሳብ ውስጥ i ን imaginary number (ምናባዊ ቁጥርን) ለመወከል እንደምንጠቀም፤ ፓይተን ውስጥ ግን j መጠቀማችን ብቻ ነው።

a = 4j
b = 5 + 3j
print(a)
print(b)
print(type(a))
print(type(b))

Output

4j
5 + 3j
<class 'complex'>
<class 'complex'>

የሚወከለውም complex በሚባል built-in function ነው።

Boolean

ይህ የዳታ አይነት በቀጥታ ቁጥር ያልሆነ፥ ነገር ግን በተዘዋዋሪ ቁጥር የሆነ የዳታ አይነት ነው።

- ይሄም ዳታ ሁለት የተላያዩ ዋጋዎች አሉት፦
True & False.

True 1 ወይም ከዜሮ ውጭ ያሉ ቁጥሮችን እንደማለት ሲሆን፥
False ደግሞ 0 ነው።

- ሁለቱ Trueና False የፓይተን Keywordኦች ናቸው።

true = True
false = False

print(true)
print(false)
print(type(true))
print(type(false))

Output

True
False
<class 'bool'>
<class 'bool'>

ሁለቱም የሚወከሉት bool በሚባል built-in function ነው።

String

ይሄ የዳታ አይነት ደግሞ ጽሑፍ(Text) ምናስቀምጥበት/ የጽሑፍ Data type ነው።

- " " ወይም ' ' እንጠቀማለን።

text = "Hello, World"
text1 = 'Hello, World'
print(text)
print(text1)
print(type(text))
print(type(text1))

Output

Hello, World
Hello, World
<class 'str'>
<class 'str'>

የሚወከለውም str በሚባል built-in function ነው።

Arithmetic Operator

ውስጡ የያዛቸው፦ +, -, *, /, **, // ና % ናቸው።

Addition +

1. ቁጥሮችን ለመደመር
2. ለ String concatenation  እንጠቀማለን

print(1+2) # Output -> 3
print(5+3) # Output -> 8

String Concatenation

print("Hello" + ", World") # Output -> Hello, World

text = "My name is "
name = "Abebe"

print(text+name) # Output -> My name is Abebe

Subtraction -

ከአንድ ቁጥር ላይ ሌላ ቁጥር ለመቀነስ

print(5-1) # Output -> 4
print(10-2) # Output -> 8

Multiplication *

1. ቁጥሮችን ለማባዛት
2. String or  List or Tuple ለማባዛት(ለመደጋገም)

print(5*2) # Output -> 10
print(2*3) # Output -> 6

print("h"*5) # Output -> hhhhh
print("hello"*2) # Output -> hellohello

Division /
ቁጥሮችን ለማካፈል

print(5/2) # Output -> 2.5
print(4/2) # Output -> 2.0

Exponent **

Exponent ለማድረግ እንጠቀምበታለን፤ x**y ማለት፦ ሂሳብ ላይ እንዳለው x the power of y እንደማለት ነው

print(2**3)  # Output -> 8
print(5**2) # Output -> 25

Floor //
ቁጥሮችን አካፍለን ነገር ግን ያገኘነውን ውጤት ያለ ነጥብ(.) ማስቀመጥ(በInteger ማስቀመጥ)

print(5//2) # Output -> 2
print(3//2) # Output -> 1

Modulus %

ቁጥሮችን አካፍለን ቀሪው ስንት እንደሆነ የሚያሰላ ነው።

ለምሳሌ፦ 5%2 ብንል፥ 2 ደራሽ ይሆንና ግን 1 ትቀራለች፤ ስለዚህ 5%2 እኩል ይሆና 1። ሁለቱ ቁጥሮች ተካፍለው ምንም ቀሪ ማይኖር ከሆነ ደግሞ መልሱ 0 ይሆናል።

print(5%2) # Output -> 1
print(3%3) # Output -> 0

❔2%5 ስንት ሚመጣ  ይመስላችኋል ?

Relational Operator

- ተመሳሳይ የሆኑ የዳታ አይነቶች(Data Types) ለማወዳደር የምንጠቀምበት ሲሆን፥ በውስጡ የያዛቸውም፦ ==, >, <, >=, <=, != ናቸው።

- እነዚህን ኦፕሬተሮች ተጠቅመን የምናገኘው ውጤት(Output) True/False ነው።

📌 Equal To(==)

🔰ኦፕሬተሩ == ሲሆን፣ ሁለትና ከዛ በላይ ተመሳሳይ የሆኑ ዳታዎች(ለምሳሌ ቁጥሮች) እኩል መሆናቸውንና አለመሆናቸውን ለማወቅ የሚረዳን ነው፤ ስንጠቀመውም ውጤቱ True/False ነው።

ለቁጥሮች ስንጠቀም ለምሳሌ፦

x = 5
y = 10
print(x==5) #  True
print(x==y) # False
print(y==10) # True

🔆 አሠራሩን ለመረዳት ያህል፥
x = 5 እንበል።
x==5 ስንልን፦

"የx ዋጋ አምስት ነውን?/ x ከ5 ጋር እኩል ነውን?" ብለን ኮምፒውተርን መጠየቅ ነው፤ ስለዚህ እኩል ከሆነ True ይለናል፥ ካልሆነ ደግሞ False ይለናል።

‼️መረሳት የሌለበት ነገር ቢኖር = እና == በጣም ልዩነት ያላቸው ሁለት የተለያዩ ኦፕሬተሮች ናቸው።

🔅 x = 5 ስንል፥ "የx ዋጋ 5 ይሁን" ብለን ለኮምፒዩተር እየነገርነው ሲሆን፥ በተቃራኒው ደግሞ x == 5 ስንል፥ "የx ዋጋ 5 ነው ወይ?" ብለን ኮምፒውተርን እየጠየቅነው ነው።

ይጥላል ....

ለString

💡 Stringኦች ስናወዳድር፣ ቁጥሮችን ስናወዳድር ካለው አሠራር ጋር ይለያያል።

ለምሳሌ 5 == 5 ብንል ያለምንም ጥያቄ እውነት ይሆናል፤
"Hi" == "Hi" ስንልስ "ምኑን ከምኑ ሚያወዳድረው? 🤔" የሚል ትልቅ ጥያቄ ያስነሳል፤ እስኪ አሠራሩን በአጭሩ ለማየት እንሞክር።

ሙከራ 1. Stringኦችን ስናወዳድር መጀመሪያ ላይ የሚወዳደረው ተወዳዳሪዎቹ የያዙት የCharchters መጠን/ብዛት ነው። ለምሳሌ
"Hi" == "Hi" ብንል፥ የሁለቱም የCharacters ብዛታቸው 2 ነው፤ ስለዚህ እውነት/True ይሆናል።

በጠቃራኒው ደግም "Hi" == "Hi!" ብንል፥ "Hi" የያዘው Characterኦች 2 ሲሆን፥ "Hi!" ደግሞ 3 ነው(H, i, !)፤ ስለዚህ እኩል አይደሉም።

ሙከራ 2. ሙከራ 1 እውነት ከሆነ፥ ቀጣይ ላይ የሚሆነው ደግሞ፦

🔰 እንደሚታወቀው ሁሉም Charecters የምንላቸው ነገሮች(ቁጥር፣ ፊደላት፣ ሥርዓተ ነጥቦች ወዘተ.) የራሳቸው የሆነ ASCII CODE አሏቸው፤ ኮምፒውተር የሚውቃቸውም በነዚህ ቁጥሮች ነው። ለምሳሌ፦
የA 65፣ የB 66፣ የC 67 ... እያለ ይጥላል።

... ስለዚህ ሁለኛው ሙከራ ሚሆነው እያንዳንዱን
String characterኦች የASCII CODE ማወዳደር ነው። እስቲ አሠራሩን እንመልከት ...

"Hi" == "Hy" ብንል፣

ሙከራ 1 ✅

ሙከራ 2
፩. ASCII CODE of H == ASCII CODE of  
H

  -> True

ይጥላል ...

፪. ASCII CODE of i == ASCII CODE of y

  -> FALSE

📝 ስለዚህ "Hi" == "Hy" ሐሰት/False ይሆናል ማለት ነው።

text1 = "Hello"
text2 = "hello"
text3 = "Hi"
text4 = "hi"

print(text1 == "Hello") # True
print(text1 == text2) # False
print(text2 == text3) # False
print(text3 == text4) # False

📌 ጥያቄ የሆነባቹ ነገር ካለ @astutechschat መጠየቅ ትችላላችሁ።

📌 ሐሳብ፣ አስታየት / መስተካከል አለበት ምትሉት ነገር ካለ 👤 @natiprado ላይ ልታደርሱን ትችላላችሁ። 😊

Greater Than (>)
🔅 እንደምናውቀው ሁለት ቁጥሮችን ለማወዳደር ነው።

🔅 ለStringኦችም ሲሆን አሠራሩ ልክ == እንዳለው ነው፤ በ == ፋንታ የሚጠቀመው >ን ነው።

‼️ 5 == "5" ማለት እንችላለን፤ ግን 5 > "5" ማለት አንችልም፤ Error ይሆናል።

print(5 > 1) # True
print(2 > -2) # True
print(1 > 3) # False

Less Than (<)
🔅 ይሄም አሠራሩ ሁሉ ከ > ተመሳሳይ ነው።

print(5 < 6) # True
print(1 < 2) # True
print(3 < 1) # False

Greater Than or Equal to (>=)
🔅 ከ > ጋር የሚለው ነገር ቢኖር እኩል የሆኑ ቁጥሮችን ስናወዳድር የምናገኘው True መሆኑ ነው።

print(5 >= 5) # True
print(5 > 5) # False 

Less Than or Equal To (<=)
🔅 ከ >= ጋር አሠራራቸው ተመሳሳይ ነው።

print(5 <= 5) # True
print( 5 < 5) # False 

🔆 ሁሉም አሠራራቸው ልክ ሒሳብ ላይ እንዳለው ጋር አንድ ነው

Not Equal ( !=)

🔅 ይሄ ደግሞ የ== ተቃራኒ ነው፤ ሚገልጸውም ሁለት ነገሮችን ስናወዳድር እኩል አለመሆናቸውን(ኢ-እኩሌታ) ነው።

print(5 != 5) # False
print(6 != 2) # True
print(2 != 1) # True

Assignment Operators

🔅 በውስጡ የያዛቸው፦ =, +=, -=, *=, **=, /=, //=  እና %= ነው።

እንደምናውቀው የ= ምልክት አንድ አዲስ ተለዋዋጭን ለማወጅ፣ ለማሻሻል የሚረዳን ነው። ሌሎቹ ግን ከዚ በፊት የነበረን ተለዋጭ ላይ አዲስ ዋጋን(Value) እንደየ አውዱ ለመጨመር፣ ለመቀነስ፣ ለማበዛት... ወዘተ. የሚረዱን ናቸው።

እስኪ በምሳሌ እንመልከት፦

age = 18

age ለሚባል ተለዋዋጭ የ18ን ዋጋ ሰጠሁ፤ እናም እንበልና ይህ አage ዋጋ ቋሚ ሳይሆን በየ ጊዜው የሚጨምር ነው፤ ስለዚህ አዲስ ተለዋዋጭ መፍጠር ሳይጠበቅብኝ፥ እንዴት የageን ዋጋ መጨመር እችላለሁ? 🤔

መልሱ ቀላል ነው፤ Assignment Operator መጠቀም 😃

age = 18
print(age) # 18
age += 2
print(age) # 20

age += 2 ይህ ማለት፦
age = age + 2 ማለት ነው

age -= 2 ➡️ age = age - 2
age *= 2 ➡️ age = age * 2
age /= 2 ➡️ age = age / 2
age //=2 ➡️ age = age // 2
age = 2 ➡️ age = age 2
age %= 2 ➡️ age = age % 2

💡ግልፅ ነው?