Python Arrays

பைத்தான் அணிகளை கற்றுக்கொள்ளுங்கள்

⚠️ முக்கிய குறிப்பு:

Python க்கு அணிகளுக்கான உள்ளமைக்கப்பட்ட ஆதரவு இல்லை, ஆனால் Python பட்டியல்கள் அணிகளாகப் பயன்படுத்தப்படலாம்.

💡 குறிப்பு:

இந்தப் பக்கம் அணிகளாக பட்டியல்களை எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டுகிறது, இருப்பினும் Python இல் அணிகளுடன் வேலை செய்ய, நீங்கள் NumPy நூலகம் போன்ற ஒரு நூலகத்தை இறக்குமதி செய்ய வேண்டும்.

Python - அணிகள்

அணிகள் பல மதிப்புகளை ஒரு மாறியில் சேமிக்கப் பயன்படுகின்றன:

எடுத்துக்காட்டு

கார் பெயர்களைக் கொண்ட ஒரு அணியை உருவாக்கவும்:

cars = ["Ford", "Volvo", "BMW"]
print(cars)  # Output: ['Ford', 'Volvo', 'BMW']

அணி என்றால் என்ன?

ஒரு அணி என்பது ஒரு சிறப்பு மாறியாகும், இது ஒரே நேரத்தில் ஒன்றுக்கு மேற்பட்ட மதிப்புகளை வைத்திருக்க முடியும்.

தனி மாறிகள் (சிக்கலானது)

car1 = "Ford"
car2 = "Volvo"
car3 = "BMW"
car4 = "Toyota"
car5 = "Honda"
# ... மேலும் 295 கார்கள்

பிரச்சனைகள்:

  • 300 மாறிகள் நிர்வகிக்க வேண்டும்
  • லூப் செய்வது கடினம்
  • சிறப்பு காரைக் கண்டுபிடிப்பது கடினம்

அணி (எளிதானது)

cars = ["Ford", "Volvo", "BMW", 
        "Toyota", "Honda", ...]
# அனைத்து 300 கார்களும் ஒரு மாறியில்

நன்மைகள்:

  • ஒரே ஒரு மாறி
  • லூப் செய்வது எளிது
  • தேடுவது எளிது
  • வரிசைப்படுத்துவது எளிது

🏁 தீர்வு:

ஒரு அணி பல மதிப்புகளை ஒரு பெயரில் வைத்திருக்க முடியும், மேலும் நீங்கள் ஒரு அடைவெண் எண்ணைக் குறிப்பிடுவதன் மூலம் மதிப்புகளை அணுகலாம்.

அணி உருப்படிகளை அணுகுதல்

அடைவெண் எண்ணைக் குறிப்பிடுவதன் மூலம் நீங்கள் ஒரு அணி உருப்படியைக் குறிக்கிறீர்கள்.

எடுத்துக்காட்டு 1: மதிப்பைப் பெறுதல்

cars = ["Ford", "Volvo", "BMW"]

# முதல் அணி உருப்படியின் மதிப்பைப் பெறவும்
x = cars[0]
print(x)  # Output: Ford

# இரண்டாவது உருப்படி
y = cars[1]
print(y)  # Output: Volvo

எடுத்துக்காட்டு 2: மதிப்பை மாற்றுதல்

cars = ["Ford", "Volvo", "BMW"]

# முதல் அணி உருப்படியின் மதிப்பை மாற்றவும்
cars[0] = "Toyota"
print(cars)  # Output: ['Toyota', 'Volvo', 'BMW']

# கடைசி உருப்படியை மாற்றவும்
cars[-1] = "Audi"
print(cars)  # Output: ['Toyota', 'Volvo', 'Audi']

அடைவெண் எண்கள்:

பைத்தான் பூஜ்ஜிய-அடிப்படையிலானது: முதல் உருப்படி அடைவெண் 0

எடுத்துக்காட்டு: cars = ["Ford", "Volvo", "BMW"]

அடைவெண் 0: "Ford"

அடைவெண் 1: "Volvo"

அடைவெண் 2: "BMW"

எதிர்மறை அடைவெண்: cars[-1] → "BMW" (கடைசி உருப்படி)

அணியின் நீளம்

அணியின் நீளத்தை (அணியில் உள்ள உருப்படிகளின் எண்ணிக்கை) திரும்ப len() முறையைப் பயன்படுத்தவும்.

cars = ["Ford", "Volvo", "BMW", "Toyota"]

# cars அணியில் உள்ள உருப்படிகளின் எண்ணிக்கையைத் திரும்பப் பெறவும்
x = len(cars)
print(x)  # Output: 4

📝 கவனிக்க:

ஒரு அணியின் நீளம் எப்போதும் மிக உயர்ந்த அணி அடைவெண்ணை விட ஒன்று அதிகமாக இருக்கும்.

அடைவெண் vs நீளம்:

அணி: cars = ["Ford", "Volvo", "BMW", "Toyota"]

மிக உயர்ந்த அடைவெண்: 3 (கடைசி உருப்படி "Toyota")

அணி நீளம்: len(cars) = 4

சூத்திரம்: நீளம் = மிக உயர்ந்த அடைவெண் + 1

காரணம்: அடைவெண்கள் 0 இலிருந்து தொடங்குகின்றன

அணி உருப்படிகளை மீண்டும் இயக்குதல்

அணியின் அனைத்து உருப்படிகளையும் மீண்டும் இயக்க for in லூப்பைப் பயன்படுத்தலாம்.

எடுத்துக்காட்டு

cars அணியில் உள்ள ஒவ்வொரு உருப்படியையும் அச்சிடவும்:

cars = ["Ford", "Volvo", "BMW"]

for x in cars:
    print(x)

# Output:
# Ford
# Volvo
# BMW

அடைவெண்களுடன் லூப் செய்தல்

cars = ["Ford", "Volvo", "BMW"]

for i in range(len(cars)):
    print(f"Index {i}: {cars[i]}")

# Output:
# Index 0: Ford
# Index 1: Volvo  
# Index 2: BMW

enumerate() பயன்படுத்துதல்

cars = ["Ford", "Volvo", "BMW"]

for index, car in enumerate(cars):
    print(f"Car {index + 1}: {car}")

# Output:
# Car 1: Ford
# Car 2: Volvo
# Car 3: BMW

அணி உருப்படிகளைச் சேர்த்தல்

ஒரு அணியில் ஒரு உருப்படியைச் சேர்க்க append() முறையைப் பயன்படுத்தலாம்.

எடுத்துக்காட்டு

cars அணியில் மேலும் ஒரு உருப்படியைச் சேர்க்கவும்:

cars = ["Ford", "Volvo", "BMW"]
print("Before:", cars)  # ['Ford', 'Volvo', 'BMW']

cars.append("Honda")
print("After:", cars)   # ['Ford', 'Volvo', 'BMW', 'Honda']

insert() முறை

குறிப்பிட்ட இடத்தில் உருப்படியைச் செருகுகிறது:

cars = ["Ford", "BMW"]
cars.insert(1, "Volvo")  # அடைவெண் 1 இல் செருகுகிறது
print(cars)  # ['Ford', 'Volvo', 'BMW']

extend() முறை

மற்றொரு பட்டியலின் உருப்படிகளைச் சேர்க்கிறது:

cars = ["Ford", "Volvo"]
more_cars = ["BMW", "Toyota"]
cars.extend(more_cars)
print(cars)  # ['Ford', 'Volvo', 'BMW', 'Toyota']

அணி உருப்படிகளை நீக்குதல்

pop() முறை

அணியிலிருந்து ஒரு உருப்படியை நீக்க pop() முறையைப் பயன்படுத்தலாம்:

cars = ["Ford", "Volvo", "BMW", "Toyota"]

# cars அணியின் இரண்டாவது உருப்படியை நீக்கவும்
cars.pop(1)
print(cars)  # ['Ford', 'BMW', 'Toyota']

# கடைசி உருப்படியை நீக்கவும்
cars.pop()
print(cars)  # ['Ford', 'BMW']

remove() முறை

அணியிலிருந்து ஒரு உருப்படியை நீக்க remove() முறையையும் பயன்படுத்தலாம்:

cars = ["Ford", "Volvo", "BMW"]

# "Volvo" மதிப்பைக் கொண்ட உருப்படியை நீக்கவும்
cars.remove("Volvo")
print(cars)  # ['Ford', 'BMW']

⚠️ கவனிக்க:

பட்டியலின் remove() முறை குறிப்பிடப்பட்ட மதிப்பின் முதல் நிகழ்வை மட்டுமே நீக்குகிறது.

numbers = [1, 2, 3, 2, 4, 2]
numbers.remove(2)
print(numbers)  # [1, 3, 2, 4, 2] - முதல் 2 மட்டும் நீக்கப்பட்டது

அணி முறைகள்

Python பட்டியல்கள்/அணிகளில் பயன்படுத்தக்கூடிய உள்ளமைக்கப்பட்ட முறைகளின் தொகுப்பைக் கொண்டுள்ளது.

முறை விளக்கம் எடுத்துக்காட்டு
append() பட்டியலின் முடிவில் ஒரு உருப்படியைச் சேர்க்கிறது list.append(x)
clear() பட்டியலிலிருந்து அனைத்து உருப்படிகளையும் நீக்குகிறது list.clear()
copy() பட்டியலின் நகலைத் தருகிறது new_list = list.copy()
count() குறிப்பிட்ட மதிப்பைக் கொண்ட உருப்படிகளின் எண்ணிக்கையைத் தருகிறது list.count(x)
extend() தற்போதைய பட்டியலின் முடிவில் மற்றொரு பட்டியலின் உருப்படிகளைச் சேர்க்கிறது list.extend(iterable)
index() குறிப்பிட்ட மதிப்பைக் கொண்ட முதல் உருப்படியின் அடைவெண்ணைத் தருகிறது list.index(x)
insert() குறிப்பிட்ட இடத்தில் ஒரு உருப்படியைச் செருகுகிறது list.insert(i, x)
pop() குறிப்பிட்ட இடத்தில் உள்ள உருப்படியை நீக்குகிறது list.pop(i)
remove() குறிப்பிட்ட மதிப்பைக் கொண்ட முதல் உருப்படியை நீக்குகிறது list.remove(x)
reverse() பட்டியலின் வரிசையை தலைகீழாக மாற்றுகிறது list.reverse()
sort() பட்டியலை வரிசைப்படுத்துகிறது list.sort()

NumPy அணிகள்

🔬 மேம்பட்ட பயன்பாடு:

உண்மையான எண் அணிகளுக்கு (ஒரே தரவு வகை), NumPy நூலகத்தைப் பயன்படுத்தவும்:

Python பட்டியல்கள்

# பல்வேறு தரவு வகைகள்
mixed_list = [1, "hello", 3.14, True]
print(mixed_list)
# [1, 'hello', 3.14, True]

தரவு வகை: கலப்பு

நினைவகம்: குறைவான திறமையானது

கணித செயல்பாடுகள்: குறைவான செயல்திறன்

NumPy அணிகள்

import numpy as np

# ஒரே தரவு வகை
numpy_array = np.array([1, 2, 3, 4, 5])
print(numpy_array)
# [1 2 3 4 5]
print(type(numpy_array))
# <class 'numpy.ndarray'>

தரவு வகை: ஒரே மாதிரியான

நினைவகம்: அதிக திறமையானது

கணித செயல்பாடுகள்: அதிக செயல்திறன்

பயிற்சி

Python பட்டியல்களை அணிகளாகப் பயன்படுத்தலாம்.

பின்வரும் குறியீட்டின் விளைவு என்ன:

fruits = ['apple', 'banana', 'cherry']
print(fruits[0])

❓ பயிற்சி கேள்வி:

apple
✓ சரி! Python இல், அணிகள் பூஜ்ஜிய-அடிப்படையிலானவை. fruits[0] பட்டியலின் முதல் உருப்படியை அணுகுகிறது, இது "apple" ஆகும்.
banana
✗ தவறு! fruits[0] முதல் உருப்படியை அணுகுகிறது. Python பூஜ்ஜிய-அடிப்படையிலானது, எனவே முதல் உருப்படி அடைவெண் 0 ஆகும்.
cherry
✗ தவறு! fruits[0] முதல் உருப்படியை அணுகுகிறது. கடைசி உருப்படி அடைவெண் 2 ஆக இருக்கும் (fruits[2]).

சிறந்த நடைமுறைகள்

தரவு விருப்பங்களுக்கு பட்டியல்களைப் பயன்படுத்தவும்: கலப்பு தரவு வகைகள் மற்றும் எளிய கட்டமைப்புகள்
எண் கணிதத்திற்கு NumPy பயன்படுத்தவும்: வேகமான கணித செயல்பாடுகள் மற்றும் அதிக திறமை
அடைவெண் பிழைகளைத் தவிர்க்கவும்: எப்போதும் அணி எல்லைகளுக்குள் இருப்பதை உறுதி செய்யவும்
பெரிய தரவுகளுக்கு பட்டியல்களைத் தவிர்க்கவும்: நினைவக பயன்பாடு அதிகமாக இருக்கும்
தொகுதி செயல்பாடுகளுக்கு பட்டியல் காம்ப்ரிஹென்ஷன்களைப் பயன்படுத்தவும்: [x*2 for x in numbers]