পাইথন ৩ চিটশিট

পাইথন ৩ প্রোগ্রামিং এর চিটশিট

কন্ট্রিবিউটর

শেয়ার করুন

বেইস টাইপস (Base Types)

পূর্ণ সংখ্যা

int উদাহরণ: 234, 0, -193, 0b010, 0xF3

ফ্লোটিং পয়েন্ট সংখ্যা
```
float উদাহরণ: 9.23, 0.0, -1.7e-6
```
বুলিয়ান
```
bool উদাহরণ: True, False
```
স্ট্রিং অথবা অক্ষর
```
str উদাহরণ: 'hello', "world"
```

বাইটস

bytes উদাহরণ: b'toto\xfe\775'

কনটেইনার টাইপস (Container Types)

লিস্ট

list উদাহরণ: [1, 2, 3], ['x', 22, -3, 2]

ডিকশনারি

dict উদাহরণ: {'one': 1, 'two': 2}

টুপল (ইমিউটেবল বা অপরিবর্তনযোগ্য ডেটা টাইপ)
```
tuple উদাহরণ: (1, 2, 'x',)
```
সেট
```
set উদাহরণ: {1, 2, 'y'}
```

টাইপ কনভারসন (Type Conversion)

স্ট্রিং কে int নাম্বারে পরিবর্তন
```
int('15') → 15
```
int নাম্বারের পরিবর্তনের ক্ষেত্রে বেইস এর ব্যবহার: উদাহরন ১ ও ২ এ যথাক্রমে বেইস ১৬ এবং বেইস ১০ ব্যবহার করা হয়েছে
```
উদাহরণ ১:  int('3f', 16) → 63 উদাহরণ ২: int('123', 10) → 123
```
দশমিকের পরের অংশের কর্তন
```
int(15.56) → 15
```
float নাম্বারে পরিবর্তন
```
float('-11.24e8') → -1124000000.0
```
round এর মাধ্যমে একটি দশমিক ভগ্নাশের দশমিকের পরের অংশের নম্বরের সংখ্যা কমিয়ে আনা হয়
```
round(15.56, 1) → 15.6
```

বুলিয়ানে পরিবর্তন

bool(x) → উত্তর False হবে যদি x এর মান None অথবা '' (শূন্য স্ট্রিং) হয়, True হবে x এর অন্যান্য মান এর জন্যে

স্ট্রিং এ পরিবর্তন

str(x) → '...' এখানের x এর যেকোন ভ্যালু স্ট্রিং এ রূপান্তরিত হবে

ক্যারাক্টার বা chr এ পরিবর্তন

chr(64) → '@' এখানে পূর্ণ সংখ্যাটি (64) হলো ইউনিকোডে রূপান্তরিত ক্যারাক্টারের (@) অবস্থানের ক্রম। আরেকটি উদাহরনঃ ইউনিকোডে a এর অবস্থান ৬৫ পয়েন্টে।

বাইটস বা bytes এ পরিবর্তন

bytes([72,9,64]) → b'H	@' এখানে একটি লিস্টকে বাইটসে রূপান্তরিত করা হয়েছে।

স্ট্রিং(str) কে লিস্টে(list) পরিবর্তন
```
list('abc') → ['a','b','c']
```
ডিকশনারিতে (dict) এ পরিবর্তন
```
dict([(3, 'three'),(1, 'one')]) → {1: 'one', 3: 'three'}
```
সেট (set) এ পরিবর্তন
```
set(['one',  'two']) → {'one', 'two'}
```

পাইথন লুপ (Python Loops)

একটি পরিসীমা উপর পুনরাবৃত্তি(iteration)

for var in range(begin_val,end_val,step): do_something উদাহরণ: for i in range(1,4):print(i) → 1 
2 
3

একটি মান পর্যন্ত পরিসিমা করা

while condition: do_something উদাহরণ: while i!=3 : print(i) 
 i+=1 → 1 
2 
3

পাইথন লিস্ট মেথড (Python List Methods)

লিস্টের শেষে নতুন উপাদান সংযুক্ত করা
```
_oldList.append('item1')
```
লিস্টের সকল উপাদান মুছে ফেলা
```
_oldList.clear()
```
লিস্টের প্রতিলিপি করা
```
_newList = _oldList.copy()
```
লিস্টে একটি উপাদান কতবার আছে গণনা করা
```
_oldList.count('item1')
```

লিস্টের শেষে অন্য একটি লিস্টের উপাদান সংযুক্ত করা

_AList.extend(_BList)  
উদাহরণ: 
_AList = ['itemA']   
_BList = ['itemB']   
_AList.extend(_BList)   
print(_AList) → ['itemA','itemB']

লিস্টে একটি উপাদান অবস্থান বের করা এবং উপাদানটি একাধিক বার থাকলে প্রথম অবস্থান বের করা
```
_oldList.index('item1')
```

লিস্টের নির্দিষ্ট স্থানে নতুন উপাদান সংযুক্ত করা

list.insert(position,'item')  
উদাহরণ: 
_AList = ['itemA','itemC']   
_AList.insert(1,'itemB')   
print(_AList) → ['itemA','itemB','itemC']

লিস্টের নির্দিষ্ট স্থানের উপাদান মুছে ফেলা

list.pop(position)  
উদাহরণ: 
_AList = ['itemA','itemC']   
_AList.pop(1)   
print(_AList) → ['itemA']

লিস্টের নির্দিষ্ট উপাদান মুছে ফেলা

list.remove(item)  
উদাহরণ: 
_AList = ['itemA','itemC']   
_AList.remove('itemA')   
print(_AList) → ['itemC']

লিস্টের উপাদান উল্টো দিক থেকে সাজানো

list.reverse()  
উদাহরণ: 
_AList = ['itemA','itemC']   
_AList.reverse()   
print(_AList) → ['itemC','itemA']

লিস্টের উপাদান ঊর্ধ্বক্রম এবং অধঃক্রম অনুসারে সাজানো

list.sort() 
উদাহরণ: 
_AList = ['A','C']   
_AList.sort(reverse=False)   
print(_AList) → ['A','C']   
_AList.sort(reverse=True)   
print(_AList) → ['C','A']

পাইথন ডিকশনারি মেথড (Python Dictionary Methods)

ডিকশনারি কি?

ডিকশনারি বিভিন্ন তথ্যের মধ্যে সংযোগ স্থাপন করে থাকে। ডিকশনারির মধ্যে তথ্যগুলো মূল-মান জোড়া (Key-Value pair) হিসেবে থাকে।

একটি ডিকশনারির উদাহরণ। নিচের উদাহরণে কোলন(:) এর আগের অংশটিকে key এবং কোলন(:) এর পরের অংশটিকে value বলা হয়। প্রতিটি Key-Value pair একটি অপরটি থেকে কমা(,) দিয়ে পৃথক করা থাকে।
```
student = { 'name': 'John', 'age': 20 }
```
ডিকশনারির থেকে যেকোনো ভ্যালু এক্সেস করা বা নেয়া
```
print(student['name']) -> 'John' 
print(student['age']) -> 20
```
get() দিয়ে ডিকশনারির থেকে যেকোনো ভ্যালু এক্সেস করা বা নেয়া। যদি যে key টি এক্সেস করতে চাচ্ছি, তা না থেকে থাকে, তবে get() ব্যবহার করলে কোনো error না দেখিয়ে None দেখাবে। কিন্তু উপরের পদ্ধতিটি ব্যবহার করলে key না পেলে error দেখিয়ে আপনার প্রোগ্রাম ব্রেক করতে পারে। তাই নিরাপদ হল get() ব্যবহার করে key এর মাধ্যমে value এক্সেস করা। নিচের উদাহরণে 'address' নামে আমাদের কোনো key নেই, তাই value হিসেবে None আসবে।
```
print(student['name']) -> John 
print(student.get('address')) -> None
```

ডিকশনারিতে একটি নতুন Key-Value pair যোগ করা

student['gpa'] = 4.0 
-> নতুন ডিকশনারিটি হবে, student = {'name': 'John', , 'age': 20, 'gpa': 4.0}

ডিকশনারি এর সকল key গুলো নিয়ে list বানানোর পদ্ধতি
```
list(student.keys()) 
-> ['name', 'age', 'gpa']
```
ডিকশনারি এর সকল value গুলো নিয়ে list বানানোর পদ্ধতি
```
list(student.values()) 
-> ['John', 20, 4.0]
```
ডিকশনারি এর সকল (key, value) গুলো নিয়ে list বানানোর পদ্ধতি
```
list(student.items()) 
-> [('name', 'John'), ('age', 20), ('gpa', 4.0)]
```

ডিকশনারি থেকে Key-Value pair বাদ দেয়া বা remove করা

del student['gpa'] 
-> নতুন ডিকশনারিটি হবে, student = {'name': 'John', , 'age': 20}

Dictionary Comprehension (সহজে ডিকশনারি তৈরি)
```
squares = {x:x**2 for x in range(5)} 
-> {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
```

ফাইল পরিচালনা (File Handling)

ফাইল খোলা (ফাইল উপস্থিত না থাকলে এরর দেখাবে)
```
file = open(fileLocation, 'r') 
উদাহরণ: 
file = open('D:\myfiles\myFile.txt', 'r')
```
সম্পূর্ণ ফাইল পড়া
```
file.read()
```
ফাইলের নির্দিষ্ট সংখ্যক লাইন পড়া
```
file.readline()
```
ফাইল বন্ধ করা
```
file.close()
```

নতুন ফাইল তৈরি করা

newFile = open(fileName,'x') 
উদাহরণ: 
file = open('D:\myfiles\myNewFile.txt', 'x')

পুরাতন ফাইল আপডেট করা

updateFile = open(fileName,'w') 
উদাহরণ: 
file = open('D:\myfiles\myNewFile.txt', 'w')

ফাইল অপসারণ করা

os.remove(newFile) 
উদাহরণ: 
os.remove('D:\myfiles\myNewFile.txt')

ফাইল বাইনারি বা টেক্সট মোড হিসাবে পরিচালনা করতে পারেন (b - বাইনারি, t - টেক্সট)

file = open(fileLocation, 'rb') 
উদাহরণ: 
file = open('D:\myfiles\myFile.png', 'rb')

বিঃদ্রঃ এখানে, পড়ার জন্য 'r', এবং বাইনারির জন্য 'b'

পান্ডাস ডাটাফ্রাম (Pandas Dataframe)

পান্ডাস ইম্পোর্ট করা
```
import pandas as pd
```
সিএসভি ফাইল রিড করা এবং ভেরিয়েবলে রাখা
```
df = pd.read_csv(file_path)
```
ডাটাফ্রেমের রো, কলাম সংখ্যা
```
df.shape
```
ডাটাফ্রেমের ইন্ডেক্স(রো লেবেল)
```
df.index
```
ডাটাফ্রেমের সব কলামের নাম
```
df.columns
```
ডাটাফ্রেমের প্রথম n রো
```
df.head(n)
```
ডাটাফ্রেমের শেষের n রো
```
df.tail(n)
```
র‍্যান্ডমলি ডাটাফ্রেমের ৯ টি রো সিলেক্ট করে
```
df.sample(n=9)
```
ডাটাফ্রেমের ইনফো
```
df.info()
```
পুরো ডাটাফ্রেমের সামারি পরিসংখ্যান
```
df.describe()
```
নিউমেরিক কলামগুলোর গড়
```
df.mean()
```
নিউমেরিক কলামগুলোর মিডিয়ান
```
df.median()
```
কোন একটি ফাংশন এপ্লাই করা
```
df.apply(func)
```
ভ্যালু অনুযায়ী সোর্ট করা
```
df.sort_values(by='column_name')
```
কলামের ভ্যালুগুলোর ফ্রিকুয়েন্সি
```
df['column_name'].value_counts()
```
ডাটাফ্রেমের ইন্ডেক্স সোর্ট করে
```
df.sort_index()
```
কলামের ইউনিক ভ্যালুর সংখ্যা
```
df['column_name'].nunique()
```
NA/null মান রয়েছে এমন কলাম বাদ দেয়া
```
df.dpropna()
```
NA/null ভ্যালু এর মান value-এ পরিবর্তন করা
```
df.fillna(value)
```
কলামের নাম পরিবর্তন করা
```
df.rename(columns = {'old_name': 'new_name'})
```

টাইপ যাচাই (Type Verification)

যে কোনো ভ্যারিয়েবলের টাইপ যাচাই
```
type(variable)
```

ভ্যারিয়েবল এসাইনমেন্ট (Variable Assginment)

এখানে x হলো ভ্যারিয়েবল এবং সমান চিহ্নের ডান পাশে রয়েছে কম্পিউটেড এক্সপ্রেশন অথবা ভ্যালু
```
x = 1.2 + 8 + sin(0)
```
একাধিক ভ্যারিয়েবল এসাইনমেন্টঃ ডানপাশে ভ্যারিয়েবল সমূহ এবং বাম পাশে কমা দ্বারা বিভক্ত এদের ভ্যালু সমূহ ক্রমান্বয়ে সজ্জিত
```
y, z, r = 9.2, -7.6, 'bad'
```
Increment: ইনক্রিমেন্ট
```
x += 3 (or x = x + 3)
```
Decrement: ডিক্রিমেন্ট
```
x -= 3 (or x = x + 3)
```

কন্ডিশনাল সেটেটমেন্ট (Conditional Statements)

শর্তাবলি অনুসারে প্রগরাম চালানোর জন্য

if condition_1:task_1 
elif condition_2:task_2 
else:default_task উদাহরণ: animal='cat' 
if animal=='cat': print('Meow') 
 else: print('Cat not found') → Meow

পাইথন স্ট্রিং মেথড (Python String Methods)

একটি স্ট্রিং এর প্রথম অক্ষরকে বড় হাতের অক্ষরে রূপান্তর করা
```
txt.capitalize()
```
একটি স্ট্রিং এর প্রথম অক্ষরকে ছোট হাতের অক্ষরে রূপান্তর করা
```
txt.casefold()
```
সেপারেটর দ্বারা স্ট্রিংকে সাব-স্ট্রিংয়ে বিভক্ত করা
```
string.split('separator')   
উদহারণ: 
string = 'Hello, World!'   
string.split(',') → ['Hello', ' World!']
```

স্ট্রিং এর সাথে নাম্বার সংযুক্ত করা

string.format(number)  
উদহারণ: 
string = 'I am {} years old'   
string.format(21) → 'I am 21 years old'

একটি স্ট্রিং, একটি নির্দিষ্ট সাব-স্ট্রিং দ্বারা শেষে হয়েছে কিনা বের করা
```
string.endswith(substring)  
উদহারণ: 
string ='End with'   
string.endswith('th') → True
```
স্ট্রিংটি কেবল অক্ষর দ্বারা গঠিত কিনা দেখা
```
string.isalpha()  
উদহারণ: 
string ='string'   
string.isalpha() → True
```
স্ট্রিংটি কেবল সংখ্যা দ্বারা গঠিত কিনা দেখা
```
string.isdigit()  
উদহারণ: 
string ='123'   
string.isdigit() → True
```
স্ট্রিংটি আইডেন্টিফায়ার (কেবল অক্ষর, সংখা ও আন্ডারস্কোর('_') বহন করবে) কিনা
```
string.isidentifier()  
উদহারণ: 
string ='It_123'   
string.isidentifier() → True
```
একটি স্ট্রিংকে বড় হাতের অক্ষরে রূপান্তর করা
```
txt.upper()
```
একটি স্ট্রিংকে ছোট হাতের অক্ষরে রূপান্তর করা
```
txt.lower()
```
একটি স্ট্রিংয়ের বড় হাতের অক্ষরকে ছোট হাতের অক্ষরে রূপান্তর করা এবং ছোট হাতের অক্ষরকে বড় হাতের অক্ষরে রূপান্তর করা
```
txt.swapcase()
```
একটি স্ট্রিং এর প্রথম ও শেষের স্পেস রিমুভ করা
```
txt.strip()
```
প্রতিটি শব্দের প্রথম অক্ষর কে বড় হাতের অক্ষরে রূপান্তর করা
```
txt.title()
```
একটি স্ট্রিং থেকে কোন অক্ষর খুঁজা
```
string.find(value)
```
একটি স্ট্রিং সাথে আর একটি স্ট্রিং যোগ করা
```
string.join(iterable)
```
একটি স্ট্রিংকে আর একটি স্ট্রিং দিয়ে রিপ্লেস করা
```
string.replace(oldvalue, newvalue)
```
একটি স্ট্রিং এ একটি অক্ষর কত বার আছে বের করা
```
string.count(value)
```

পাইথন টুপল মেথড (Python Tuple Methods)

টুপলে একটি উপাদান কতবার আছে গণনা করা
```
_tuple.count(value)
```
টুপলে একটি উপাদানের অবস্থান বের করা
```
_tuple.index(value)
```

পাইথন সেট মেথড (Python Set Methods)

সেটে নতুন উপাদান সংযুক্ত করা
```
_set.add('item')
```
সেটের সকল উপাদান মুছে ফেলা
```
_set.clear()
```
সেটের প্রতিলিপি করা
```
_newSet = _set.copy()
```
দুটি সেটের পার্থক্য বের করা
```
_cSet = _aSet.difference(_bSet)
```

একটি সেটের এমন উপাদান বাদ দেওয়া যা অন্য একটি সেটে আছে

_aSet.difference_update(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_aSet.difference_update(_bSet)   
print(_aSet) → {'banana'}

দুটি সেটের সাধারণ উপাদান ব্যতীত সকল উপাদান বের করা

_cSet = _aSet.symmetric_difference(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_cSet=_aSet.symmetric_difference(_bSet)   
print(_cSet) → {'cherry', 'banana'}

দুটি সেটের সাধারণ উপাদান বাদ দেওয়া এবং ঐ দুটি সেটের সাধারণ উপাদান ব্যতীত সকল উপাদান একটি সেটে সংযুক্ত করা
```
_aSet.symmetric_difference_update(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_aSet.symmetric_difference_update(_bSet)   
print(_aSet) → {'cherry', 'banana'}
```

দুটি সেটে ছেদ/সাধারণ উপাদান আছে কিনা যাচাই করা

_result = _aSet.isdisjoint(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_result = _aSet.isdisjoint(_bSet)   
print(_result) → False

দুটি সেটের ছেদ/সাধারণ উপাদান বের করা

_cSet = _aSet.intersection(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_cSet=_aSet.intersection(_bSet)   
print(_cSet) → {'apple'}

একটি সেটের এমন উপাদান বাদ দেওয়া যা অন্য একটি সেটে নেই

_aSet.intersection_update(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_aSet.intersection_update(_bSet)   
print(_aSet) → {'apple'}

দুটি সেটের ইউনিয়ন বের করা

_cSet = _aSet.union(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_cSet=_aSet.union(_bSet)   
print(_cSet) → {'apple', 'cherry', 'banana'}

একটি সেটের সব উপাদান অন্য একটি সেটে উপস্থিত কিনা যাচাই করা

_result = _aSet.issubset(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'banana','cherry', 'apple'}   
_result = _aSet.issubset(_bSet)   
print(_result) → True

একটি সেটে অন্য একটি সেটের সব উপাদান উপস্থিত কিনা যাচাই করা

_result = _aSet.issuperset(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'cherry', 'banana'} 
_bSet = {'banana', 'apple'}   
_result = _aSet.issuperset(_bSet)   
print(_result) → True

একটি সেটে অন্য একটি সেটের সব উপাদান সংযুক্ত করা

_aSet.update(_bSet)  
উদাহরণ: 
_aSet = {'apple', 'banana'} 
_bSet = {'cherry', 'apple'}   
_aSet.update(_bSet)   
print(_aSet) → {'apple', 'banana', 'cherry'}

সেটের নির্দিষ্ট উপাদান মুছে ফেলা
```
_aSet.discard(item)/_aSet.remove(item)
```

মড্যুল এবং নেইম ইমপোর্ট (Module and Name import)

as এর ব্যবহার করে সরাসরি names এর এক্সেস
```
from monmod import nom1, nom2 as fct
```
মড্যুল এক্সেস এর অন্য উপায় হতে পারে monmod.nom1
```
import monmod
```

নামপাই লাইব্রেরি (Numpy Library)

নামপাই ইনস্টল করা
```
pip install numpy
```

নামপাই ইম্পোর্ট করা

import numpy as np

বিঃদ্রঃ এখানে, np হল alias বা শর্ট নেম। ফুল numpy না লেখে np লেখলেও হবে এখন থেকে

ভার্সন চেক করা
```
np.__version__
```
অ্যারে তৈরি করা (নামপাই-এ অ্যারে অবজেক্টকে ndarray বলা হয়)
```
arr = np.array([1, 2, 3, 4, 5])
```

অ্যারে copy করা

arr = np.array([1, 2, 3, 4, 5])
newArr = arr.copy()

অ্যারের ডাইম্যানসন চেক করা
```
arr.ndim
```
অ্যারের shape চেক করা
```
arr.shape
```

অ্যারের shape চেঞ্জ করা (1D থেকে 2D)

arr = np.array([1, 2, 3, 4, 5, 6])
newArr = arr.reshape(3, 2)

বিঃদ্রঃ এখানে arr অ্যারেটা ১ম ডাইম্যানসন এর এবং newArr অ্যারেটা (৩, ২) ডাইম্যানসন এর। মানে ৩ টা অ্যারে এবং প্রত্যেক অ্যারেতে ২ টা করে এলিমেনট। অন্যভাবে বলতে গেলে, ৩ টা রো এবং ২ টা কলাম।

[[1, 2], [3, 4], [5, 6]]

অ্যারের shape চেঞ্জ করা (1D থেকে 3D)

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newArr = arr.reshape(2, 3, 2)

বিঃদ্রঃ এখানে arr অ্যারেটা ১ম ডাইম্যানসন এর এবং newArr অ্যারেটা (২, ৩, ২) ডাইম্যানসন এর। মানে ২ টা অ্যারে, আবার ওই ২ অ্যারে এর প্রত্যেকটা তে ৩ টা করে অ্যারে এবং এক এক অ্যারেতে ২ টা করে এলিমেনট।

[[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]

৫ ডাইম্যানসন অ্যারে তৈরি করা
```
arr5D = np.array([1, 2, 3], ndmin=5)
```

অ্যারে ইনডেক্সিং

arr[0]
লাস্ট উপাদানঃ arr[-1]

১ম ডাইম্যানসন(রো) এর চতুর্থ উপাদান
```
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print(arr[0, 3])
```

অ্যারে স্লাইস ([স্টার্ট:এন্ড] এবং [স্টার্ট:এন্ড:স্টেপ] হল স্টেপ সহ)

ইনডেক্স ১ থেকে ৫ এর জন্যঃ arr[1:5]
ইনডেক্স ১ থেকে ৫ এর জন্য ২ স্টেপ পর পরঃ arr[1:5:2]
ইনডেক্স ৩ থেকে লাস্ট এর জন্যঃ arr[3:]
ইনডেক্স 0 থেকে ৪ এর জন্যঃ  arr[:5]

বিঃদ্রঃ [স্টার্ট:এন্ড] এখানে, এন্ড অন্তর্ভুক্ত না। মানে arr[:4] এর জন্য ইনডেক্স ০,১,২,৩ এর ভালু দেখাবে, কিন্তু ইনডেক্স ৪ এর ভালু দেখাবেনা।

নামপাই-এ ডেটা টাইপস

i - পূর্ণসংখ্যা (integer)
b - বুলিয়ান (boolean)
u - আনসাইনড পূর্ণসংখ্যা (unsigned integer)
f - ফ্লোট (float)
c - কমপ্লেক্স ফ্লোট (complex float)
m - টাইমডেল্টা (timedelta)
M - ডেটটাইম (datetime)
O - অবজেক্ট (object)
S - স্ট্রিং (string)
U - ইউনিকোড স্ট্রিং (unicode string)
V - ভয়েড (void)

বিঃদ্রঃ চেক ডেটাটাইপঃ arr.dtype

অ্যারে ইটারেটিং (1D)

arr = np.array([1, 2, 3])
for x in arr:
	print(x)

অ্যারে ইটারেটিং (2D)

arr = np.array([[1, 2, 3], [4, 5, 6]])
for x in arr:
	for y in x:
		print(y)

অ্যারে ইটারেটিং (3D)

arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
for x in np.nditer(arr):
	print(x)

অ্যারে ইটারেট (বিভিন্ন স্টেপ এ)

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
for x in np.nditer(arr[:, ::2]):
	print(x)

বিঃদ্রঃ এখানে ১ টা করে এলিমেনট বা উপাদান স্কিপ করে শো করবে। ::3 হলে ২ টা করে স্কিপ করে শো করতো। যেহেতু ::2, তাই রেজাল্ট শো করবে 1 3 5 7

অ্যারে ইটারেট (ইনডেক্স নাম্বার সহ)

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
for i, x in np.ndenumerate(arr):
	print(i, x)

বিঃদ্রঃ এখানে i হল ইনডেক্স এবং x হল ভেলু

দুটি অ্যারে জয়েন (1D)

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
newArr = np.concatenate((arr1, arr2))

দুটি অ্যারে জয়েন (2D)

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
newArr = np.concatenate((arr1, arr2), axis=1)

বিঃদ্রঃ এখানে axis=1 মানে রো। ১ম অ্যারে এর ১ম রো এবং ২য় অ্যারে এর ১ম রো হবে নিউ অ্যারে এর ১ম রো। আর যদি axis=0 দেয়া হতো তাহলে কলাম অনুযায়ী নিউ অ্যারে হতো। সেক্ষেত্রে, ১ম অ্যারে এর ১ম এবং ২য় রো হতো নিউ অ্যারে এর ১ম এবং ২য় রো। ২য় অ্যারে এর ১ম, ২য় হবে নিউ অ্যারে এর ৩য়, ৪র্থ রো।

stact() মেথড দিয়ে দুটি অ্যারে জয়েন

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
newArr = np.stack((arr1, arr2), axis=1)

hstact() মেথড দিয়ে রো ভাবে দুটি অ্যারে জয়েন
```
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
newArr = np.hstack((arr1, arr2))
```
vstact() মেথড দিয়ে কলাম ভাবে দুটি অ্যারে জয়েন
```
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
newArr = np.vstack((arr1, arr2))
```

দুটি অ্যারে এর একই ইনডেক্স নিয়ে dstack() মেথড দিয়ে অ্যারে জয়েন

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
newArr = np.dstack((arr1, arr2))

বিঃদ্রঃ এখানে দুটি অ্যারে এড় 0 ইনডেক্স নিয়ে নিউ অ্যারে এর ১ম রো এবং ইনডেক্স 1 নিয়ে নিউ অ্যারে এর ২য় রো। তাই রেজাল্ট হবে [[[1, 4], [2, 5], [3, 6]]]

অ্যারে split

arr = np.array([1, 2, 3, 4, 5, 6])
newArr = np.array_split(arr, 3)

বিঃদ্রঃ এখানে 3 ব্যাবহার করা হয়েছে ৩ ভাগ এ ভাগ করার জন্য

রো অনুযায়ী একটি 2D অ্যারে কে ৩টি 2D তে ভাগ(split) করা

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
newarr = np.array_split(arr, 3, axis=1)

where() মেথড দিয়ে অ্যারে থেকে কোন ভেলু সার্চ

arr = np.array([1, 2, 3, 4, 5, 4, 4])
x = np.where(arr == 4)

বিঃদ্রঃ এখানে রেজাল্ট হিসেবে (array([3, 5, 6],) পাবো। আমরা চাইলে whire() মেথড এর মদ্ধে আরও কনডিসন ব্যাবহার করতে পারি। জোর সংখ্যা এর জন্য arr%2 == 0 এরকম।

searchsorted() মেথড দিয়ে অ্যারে কে অটো সর্ট করে তারপর কোন ভেলু এর ইনডেক্স সার্চ করা

arr = np.array([6, 8, 9, 7])
x = np.searchsorted(arr, 7)

বিঃদ্রঃ এখানে রেজাল্ট হিসেবে আমরা 1  পাবো, কারণ সর্ট করার পর 7 এর ভেলু ইনডেক্স 1 এ আসবে। মানে সর্ট করা অ্যারে টা হল [6, 7, 8, 9]। তাই রেজাল্ট 1 আসবে, যেহেতু 7 এর ইনডেক্স 1

ইনডেক্সগুলি সন্ধান করুন যেখানে 2, 4 এবং 6 মানগুলি ইন্সার্ট করানো উচিত
```
arr = np.array([1, 5, 8, 9])
x = np.searchsorted(arr, [2, 4, 6])

বিঃদ্রঃ এখানে রেজাল্ট [1, 1, 2]
```

অ্যারে সর্ট (1D)

arr = np.array([3, 2, 0, 1])
newArr = np.sort(arr)

অ্যারে সর্ট (2D)

arr = np.array([[3, 2, 4], [5, 0, 1]])
newArr = np.sort(arr)

বিঃদ্রঃ এখানে রেজাল্ট [[2, 3, 4], [0, 1, 5]]

filter

arr = np.array([10, 20, 30, 40])
x = [True, False, True, False]
newArr = arr[x]

বিঃদ্রঃ এখানে রেজাল্ট [10, 30], কারণ নতুন ফিল্টারটিতে কেবলমাত্র সেই মান রয়েছে যেখানে ফিল্টার অ্যারের মানটি সত্য ছিল

0 থেকে 1 পর্যন্ত একটি রেনডম পূর্ণসংখ্যা তৈরি করুন
```
from numpy import random
x = random.rand()
```
0 থেকে 100 পর্যন্ত একটি রেনডম পূর্ণসংখ্যা তৈরি করুন
```
from numpy import random
x = random.randint(100)
```
৫ সংখ্যার একটি রেনডম অ্যারে তৈরি করা (1D)
```
x=random.randint(100, size=(5))
```
৩ রো এবং ৫ কলাম এর একটি রেনডম পূর্ণসংখ্যার অ্যারে তৈরি করা (2D)
```
x = random.randint(100, size=(3, 5))
```
৩ রো এবং ৫ কলাম এর একটি রেনডম দশমিক সংখ্যার অ্যারে তৈরি করা (2D)
```
x = random.rand(3, 5)
```
প্রদত্ত অ্যারে এর মানগুলি ব্যাবহার করে ৩ রো এবং ৫ কলাম এর একটি 2D অ্যারে তৈরি করুন
```
x = random.choice([3, 5, 7, 9], size=(3, 5))
```