പൈത്തൺ ഡാറ്റ തരങ്ങളും തരം പരിവർത്തനവും

പൈത്തൺ ഡാറ്റ തരങ്ങളെക്കുറിച്ചും ടൈപ്പ് പരിവർത്തനങ്ങൾ എങ്ങനെ നടത്താമെന്നതിനെക്കുറിച്ചും ഒരു ആമുഖം.



പൈത്തൺ ഡാറ്റ തരങ്ങൾ

പൈത്തണിൽ ഞങ്ങൾ വേരിയബിളുകൾ സൃഷ്ടിക്കുകയോ പ്രഖ്യാപിക്കുകയോ ചെയ്യുമ്പോൾ, വേരിയബിളുകൾക്ക് വ്യത്യസ്ത ഡാറ്റ തരങ്ങൾ നിലനിർത്താൻ കഴിയും.

പൈത്തണിന് ഇനിപ്പറയുന്ന അന്തർനിർമ്മിത ഡാറ്റ തരങ്ങളുണ്ട്:


  • പി
  • int, ഫ്ലോട്ട്, സങ്കീർണ്ണമായ
  • ലിസ്റ്റ്, ടുപ്പിൾ
  • ഡിക്റ്റ്
  • സജ്ജമാക്കുക
  • bool
  • ബൈറ്റ്, ബൈറ്റ്അറേ

വാചക തരം: str

ദി str a എന്ന് പ്രഖ്യാപിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഡാറ്റ തരം ഉപയോഗിക്കുന്നു സ്ട്രിംഗ് വേരിയബിൾ.

ഉദാഹരണം:


x = 'some string' y = str('another string')

സംഖ്യാ തരം: int, float, complex

സംഖ്യാ വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ int, float അല്ലെങ്കിൽ complex.

ഉദാഹരണം:

//int a = 5 b = int(5) //float c = 5.5 d = float(5.5) //complex e = 1j f = complex(1j)

സീക്വൻസ് തരം: ലിസ്റ്റ്, ടുപ്പിൾ

സീക്വൻസ് തരം വേരിയബിളുകൾ സൃഷ്ടിക്കുന്നതിന് ഞങ്ങൾ list അല്ലെങ്കിൽ tuple.

  • ഒരു list ഓർഡർ ചെയ്തതും മാറ്റാവുന്നതുമായ ഒരു ശേഖരമാണ്. തനിപ്പകർപ്പ് അംഗങ്ങളെ അനുവദിക്കുന്നു.
  • ഒരു tuple ഓർ‌ഡർ‌ ചെയ്‌തതും മാറ്റാൻ‌ കഴിയാത്തതുമായ ഒരു ശേഖരം. തനിപ്പകർപ്പ് അംഗങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം:


//list colors = ['red', 'green', 'blue'] colors_list = list(('red', 'green', 'blue')) //tuple fruits = ('apple', 'orange', 'banana') fruits_tuple = list(('apple', 'orange', 'banana'))

മാപ്പിംഗ് തരം: ഡിക്റ്റ്

ഒരു മാപ്പ് അല്ലെങ്കിൽ നിഘണ്ടു സൃഷ്‌ടിക്കുന്നതിന് ഞങ്ങൾ dict.

TO നിഘണ്ടു ക്രമീകരിക്കാത്തതും മാറ്റാവുന്നതും സൂചികയിലാക്കിയതുമായ ഒരു ശേഖരമാണ്. പ്രധാന മൂല്യ ജോഡികളാണ് ഡാറ്റ.

ഉദാഹരണം:

people = {'name': 'John', 'age': '45'} people_dict = dict(name='John', age=45)

തരം സജ്ജമാക്കുക: സജ്ജമാക്കുക

ഒരു set ക്രമീകരിക്കാത്തതും സൂചികയിലാക്കാത്തതുമായ ഒരു ശേഖരമാണ്.


ഒരു സെറ്റ് സൃഷ്ടിക്കാൻ, ഞങ്ങൾ set ഉപയോഗിക്കുന്നു.

ഉദാഹരണം:

status_codes = {'200', '300', '400', '500'} status_codes = set(('200', '300', '400', '500'))

ബൂളിയൻ തരം: bool

ദി bool ബൂലിയൻ ഡാറ്റ തരം ഉപയോഗിച്ച് വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ കീവേഡ് ഉപയോഗിക്കുന്നു.

is_valid = False valid = bool(is_valid)

ബൈനറി തരം: ബൈറ്റ്, ബൈറ്റ്അറേ

ബൈനറി ഡാറ്റ തരങ്ങൾ ഇനിപ്പറയുന്ന രീതിയിൽ സൃഷ്ടിക്കാൻ കഴിയും:


//bytes a = b'some_text' b = bytes(5) //bytearray c = bytearray(3)

ഒരു വേരിയബിളിന്റെ തരം എങ്ങനെ ലഭിക്കും

ഒരു വേരിയബിളിന്റെ തരം ലഭിക്കാൻ ഞങ്ങൾ type() പ്രവർത്തനം.

ഉദാഹരണത്തിന്:

colors = ['red', 'green', 'blue'] colors_list = list(('red', 'green', 'blue')) print(type(colors_list)) print(colors_list) fruits = ('apple', 'orange', 'banana') fruits_tuple = tuple(('apple', 'orange', 'banana')) print(type(fruits_tuple)) print(fruits_tuple)

Put ട്ട്‌പുട്ട്:

['red', 'green', 'blue'] ('apple', 'orange', 'banana')

പൈത്തൺ ഡാറ്റ തരം പരിവർത്തനം

ഒരു ഡാറ്റ തരം മറ്റൊന്നിലേക്ക് നേരിട്ട് പരിവർത്തനം ചെയ്യുന്നതിന് പൈത്തൺ തരം പരിവർത്തന പ്രവർത്തനങ്ങൾ നിർവചിക്കുന്നു, ഇത് തികച്ചും ഉപയോഗപ്രദമാണ്.


ചില ഉദാഹരണങ്ങൾ ചുവടെ:

Int ൽ നിന്ന് ഫ്ലോട്ടിലേക്ക് പരിവർത്തനം ചെയ്യുക

x = 5 y = float(x) print(y)

Put ട്ട്‌പുട്ട്:

5.0

ഫ്ലോട്ടിൽ നിന്ന് ഇന്റിലേക്ക് പരിവർത്തനം ചെയ്യുക

x = 5.0 y = int(x) print(y)

Put ട്ട്‌പുട്ട്:

5

സ്‌ട്രിംഗിൽ നിന്ന് ലിസ്റ്റിലേക്ക് പരിവർത്തനം ചെയ്യുക

s = 'devqa' t = list(s) print(t)

Put ട്ട്‌പുട്ട്:

['d', 'e', 'v', 'q', 'a']

സ്‌ട്രിംഗിൽ നിന്ന് ടുപ്പിളിലേക്ക് പരിവർത്തനം ചെയ്യുക

s = 'devqa' t = tuple(s) print(t)

Put ട്ട്‌പുട്ട്:

('d', 'e', 'v', 'q', 'a')

സ്‌ട്രിംഗിൽ നിന്ന് സെറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുക

s = 'devqa' t = set(s) print(t)

Put ട്ട്‌പുട്ട്:

{'d', 'e', 'a', 'v', 'q'}

രസകരമായ ലേഖനങ്ങൾ