പൈത്തൺ ഡാറ്റ തരങ്ങളെക്കുറിച്ചും ടൈപ്പ് പരിവർത്തനങ്ങൾ എങ്ങനെ നടത്താമെന്നതിനെക്കുറിച്ചും ഒരു ആമുഖം.
പൈത്തണിൽ ഞങ്ങൾ വേരിയബിളുകൾ സൃഷ്ടിക്കുകയോ പ്രഖ്യാപിക്കുകയോ ചെയ്യുമ്പോൾ, വേരിയബിളുകൾക്ക് വ്യത്യസ്ത ഡാറ്റ തരങ്ങൾ നിലനിർത്താൻ കഴിയും.
പൈത്തണിന് ഇനിപ്പറയുന്ന അന്തർനിർമ്മിത ഡാറ്റ തരങ്ങളുണ്ട്:
ദി str
a എന്ന് പ്രഖ്യാപിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഡാറ്റ തരം ഉപയോഗിക്കുന്നു സ്ട്രിംഗ് വേരിയബിൾ.
ഉദാഹരണം:
x = 'some string' y = str('another string')
സംഖ്യാ വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ 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
ബൂലിയൻ ഡാറ്റ തരം ഉപയോഗിച്ച് വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ കീവേഡ് ഉപയോഗിക്കുന്നു.
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')
ഒരു ഡാറ്റ തരം മറ്റൊന്നിലേക്ക് നേരിട്ട് പരിവർത്തനം ചെയ്യുന്നതിന് പൈത്തൺ തരം പരിവർത്തന പ്രവർത്തനങ്ങൾ നിർവചിക്കുന്നു, ഇത് തികച്ചും ഉപയോഗപ്രദമാണ്.
ചില ഉദാഹരണങ്ങൾ ചുവടെ:
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'}