{
    "id": "python3-cheat-sheet",
    "title": "পাইথন ৩ চিটশিট",
    "slug": "python3-cheat-sheet",
    "description": "পাইথন ৩ প্রোগ্রামিং এর চিটশিট",
    "colorPref": "#ffff00",
    "contents": [{
            "title": "বেইস টাইপস (Base Types)",
            "items": [{
                    "definition": "পূর্ণ সংখ্যা",
                    "code": "int উদাহরণ: 234, 0, -193, 0b010, 0xF3"
                },
                {
                    "definition": "ফ্লোটিং পয়েন্ট সংখ্যা",
                    "code": "float উদাহরণ: 9.23, 0.0, -1.7e-6"
                },
                {
                    "definition": "বুলিয়ান",
                    "code": "bool উদাহরণ: True, False"
                },
                {
                    "definition": "স্ট্রিং অথবা অক্ষর",
                    "code": "str উদাহরণ: 'hello', \"world\""
                },
                {
                    "definition": "বাইটস",
                    "code": "bytes উদাহরণ: b'toto\\xfe\\775'"
                }
            ]
        },
        {
            "title": "টাইপ যাচাই (Type Verification)",
            "items": [{
                "definition": "যে কোনো ভ্যারিয়েবলের টাইপ যাচাই",
                "code": "type(variable)"
            }]
        },
        {
            "title": "কনটেইনার টাইপস (Container Types)",
            "items": [{
                    "definition": "লিস্ট",
                    "code": "list উদাহরণ: [1, 2, 3], ['x', 22, -3, 2]"
                },
                {
                    "definition": "ডিকশনারি",
                    "code": "dict উদাহরণ: {'one': 1, 'two': 2}"
                },
                {
                    "definition": "টুপল (ইমিউটেবল বা অপরিবর্তনযোগ্য ডেটা টাইপ)",
                    "code": "tuple উদাহরণ: (1, 2, 'x',)"
                },
                {
                    "definition": "সেট",
                    "code": "set উদাহরণ: {1, 2, 'y'}"
                }
            ]
        },
        {
            "title": "ভ্যারিয়েবল এসাইনমেন্ট (Variable Assginment)",
            "items": [{
                    "code": "x = 1.2 + 8 + sin(0)",
                    "definition": "এখানে x হলো ভ্যারিয়েবল এবং সমান চিহ্নের ডান পাশে রয়েছে কম্পিউটেড এক্সপ্রেশন অথবা ভ্যালু"
                },
                {
                    "code": "y, z, r = 9.2, -7.6, 'bad'",
                    "definition": "একাধিক ভ্যারিয়েবল এসাইনমেন্টঃ ডানপাশে ভ্যারিয়েবল সমূহ এবং বাম পাশে কমা দ্বারা বিভক্ত এদের ভ্যালু সমূহ ক্রমান্বয়ে সজ্জিত"
                },
                {
                    "code": "x += 3 (or x = x + 3)",
                    "definition": "Increment: ইনক্রিমেন্ট"
                },
                {
                    "code": "x -= 3 (or x = x + 3)",
                    "definition": "Decrement: ডিক্রিমেন্ট"
                }
            ]
        },
        {
            "title": "টাইপ কনভারসন (Type Conversion)",
            "items": [{
                    "definition": "স্ট্রিং কে int নাম্বারে পরিবর্তন",
                    "code": "int('15') → 15"
                },
                {
                    "definition": "int নাম্বারের পরিবর্তনের ক্ষেত্রে বেইস এর ব্যবহার: উদাহরন ১ ও ২ এ যথাক্রমে বেইস ১৬ এবং বেইস ১০ ব্যবহার করা হয়েছে",
                    "code": "উদাহরণ ১:  int('3f', 16) → 63 উদাহরণ ২: int('123', 10) → 123"
                },
                {
                    "definition": "দশমিকের পরের অংশের কর্তন",
                    "code": "int(15.56) → 15"
                },
                {
                    "definition": "float নাম্বারে পরিবর্তন",
                    "code": "float('-11.24e8') → -1124000000.0"
                },
                {
                    "definition": "round এর মাধ্যমে একটি দশমিক ভগ্নাশের দশমিকের পরের অংশের নম্বরের সংখ্যা কমিয়ে আনা হয়",
                    "code": "round(15.56, 1) → 15.6"
                },
                {
                    "definition": "বুলিয়ানে পরিবর্তন",
                    "code": "bool(x) → উত্তর False হবে যদি x এর মান None অথবা '' (শূন্য স্ট্রিং) হয়, True হবে x এর অন্যান্য মান এর জন্যে"
                },
                {
                    "definition": "স্ট্রিং এ পরিবর্তন",
                    "code": "str(x) → '...' এখানের x এর যেকোন ভ্যালু স্ট্রিং এ রূপান্তরিত হবে"
                },
                {
                    "definition": "ক্যারাক্টার বা chr এ পরিবর্তন",
                    "code": "chr(64) → '@' এখানে পূর্ণ সংখ্যাটি (64) হলো ইউনিকোডে রূপান্তরিত ক্যারাক্টারের (@) অবস্থানের ক্রম। আরেকটি উদাহরনঃ ইউনিকোডে a এর অবস্থান ৬৫ পয়েন্টে।"
                },
                {
                    "definition": "বাইটস বা bytes এ পরিবর্তন",
                    "code": "bytes([72,9,64]) → b'H\t@' এখানে একটি লিস্টকে বাইটসে রূপান্তরিত করা হয়েছে।"
                },
                {
                    "definition": "স্ট্রিং(str) কে লিস্টে(list) পরিবর্তন",
                    "code": "list('abc') → ['a','b','c']"
                },
                {
                    "definition": "ডিকশনারিতে (dict) এ পরিবর্তন",
                    "code": "dict([(3, 'three'),(1, 'one')]) → {1: 'one', 3: 'three'}"
                },
                {
                    "definition": "সেট (set) এ পরিবর্তন",
                    "code": "set(['one',  'two']) → {'one', 'two'}"
                }
            ]
        },
        {
            "title": "পাইথন স্টিং মেথড",
            "items": [{
                    "definition": "একটি স্ট্রিং এর প্রথম অক্ষরকে বড় হাতের অক্ষরে রূপান্তর করা",
                    "code": "txt.capitalize()"
                },
                {
                    "definition": "একটি স্ট্রিং এর প্রথম অক্ষরকে ছোট হাতের অক্ষরে রূপান্তর করা",
                    "code": "txt.casefold()"
                },
                {
                    "definition": "সেপারেটর দ্বারা স্ট্রিংকে সাব-স্ট্রিংয়ে বিভক্ত করা",
                    "code": "string.split('separator')   \nউদহারণ: \nstring = 'Hello, World!'   \nstring.split(',') → ['Hello', ' World!']"
                },
                {
                    "definition": "স্ট্রিং এর সাথে নাম্বার সংযুক্ত করা",
                    "code": "string.format(number)  \nউদহারণ: \nstring = 'I am {} years old'   \nstring.format(21) → 'I am 21 years old'"
                },
                {
                    "definition": "একটি স্ট্রিং, একটি নির্দিষ্ট সাব-স্ট্রিং দ্বারা শেষে হয়েছে কিনা বের করা",
                    "code": "string.endswith(substring)  \nউদহারণ: \nstring ='End with'   \nstring.endswith('th') → True"
                },
                {
                    "definition": "স্ট্রিংটি কেবল অক্ষর দ্বারা গঠিত কিনা দেখা",
                    "code": "string.isalpha()  \nউদহারণ: \nstring ='string'   \nstring.isalpha() → True"
                },
                {
                    "definition": "স্ট্রিংটি কেবল সংখ্যা দ্বারা গঠিত কিনা দেখা",
                    "code": "string.isdigit()  \nউদহারণ: \nstring ='123'   \nstring.isdigit() → True"
                },
                {
                    "definition": "স্ট্রিংটি আইডেন্টিফায়ার (কেবল অক্ষর, সংখা ও আন্ডারস্কোর('_') বহন করবে) কিনা",
                    "code": "string.isidentifier()  \nউদহারণ: \nstring ='It_123'   \nstring.isidentifier() → True"
                },
                {
                    "definition": "একটি স্ট্রিংকে বড় হাতের অক্ষরে রূপান্তর করা",
                    "code": "txt.upper()"
                },
                {
                    "definition": "একটি স্ট্রিংকে ছোট হাতের অক্ষরে রূপান্তর করা",
                    "code": "txt.lower()"
                },
                {
                    "definition": "একটি স্ট্রিংয়ের বড় হাতের অক্ষরকে ছোট হাতের অক্ষরে রূপান্তর করা এবং ছোট হাতের অক্ষরকে বড় হাতের অক্ষরে রূপান্তর করা",
                    "code": "txt.swapcase()"
                },
                {
                    "definition": "একটি স্ট্রিং এর প্রথম ও শেষের স্পেস রিমুভ করা",
                    "code": "txt.strip()"
                },
                {
                    "definition": "প্রতিটি শব্দের প্রথম অক্ষর কে বড় হাতের অক্ষরে রূপান্তর করা",
                    "code": "txt.title()"
                },
                {
                    "definition": "একটি স্ট্রিং থেকে কোন অক্ষর খুঁজা",
                    "code": "string.find(value)"
                },
                {
                    "definition": "একটি স্ট্রিং সাথে আর একটি স্ট্রিং যোগ করা",
                    "code": "string.join(iterable)"
                },
                {
                    "definition": "একটি স্ট্রিংকে আর একটি স্ট্রিং দিয়ে রিপ্লেস করা",
                    "code": "string.replace(oldvalue, newvalue)"
                },
                {
                    "definition": "একটি স্ট্রিং এ একটি অক্ষর কত বার আছে বের করা",
                    "code": "string.count(value)"
                }
            ]
        },
        {
            "title": "পাইথন লিস্ট মেথড (Python List Methods)",
            "items": [{
                    "definition": "লিস্টের শেষে নতুন উপাদান সংযুক্ত করা",
                    "code": "_oldList.append('item1')"
                },
                {
                    "definition": "লিস্টের সকল উপাদান মুছে ফেলা",
                    "code": "_oldList.clear()"
                },
                {
                    "definition": "লিস্টের প্রতিলিপি করা",
                    "code": "_newList = _oldList.copy()"
                },
                {
                    "definition": "লিস্টে একটি উপাদান কতবার আছে গণনা করা",
                    "code": "_oldList.count('item1')"
                },
                {
                    "definition": "লিস্টের শেষে অন্য একটি লিস্টের উপাদান সংযুক্ত করা",
                    "code": "_AList.extend(_BList)  \nউদাহরণ: \n_AList = ['itemA']   \n_BList = ['itemB']   \n_AList.extend(_BList)   \nprint(_AList) → ['itemA','itemB']"
                },
                {
                    "definition": "লিস্টে একটি উপাদান অবস্থান বের করা এবং উপাদানটি একাধিক বার থাকলে প্রথম অবস্থান বের করা",
                    "code": "_oldList.index('item1')"
                },
                {
                    "definition": "লিস্টের নির্দিষ্ট স্থানে নতুন উপাদান সংযুক্ত করা",
                    "code": "list.insert(position,'item')  \nউদাহরণ: \n_AList = ['itemA','itemC']   \n_AList.insert(1,'itemB')   \nprint(_AList) → ['itemA','itemB','itemC']"
                },
                {
                    "definition": "লিস্টের নির্দিষ্ট স্থানের উপাদান মুছে ফেলা",
                    "code": "list.pop(position)  \nউদাহরণ: \n_AList = ['itemA','itemC']   \n_AList.pop(1)   \nprint(_AList) → ['itemA']"
                },
                {
                    "definition": "লিস্টের নির্দিষ্ট উপাদান মুছে ফেলা",
                    "code": "list.remove(item)  \nউদাহরণ: \n_AList = ['itemA','itemC']   \n_AList.remove('itemA')   \nprint(_AList) → ['itemC']"
                },
                {
                    "definition": "লিস্টের উপাদান উল্টো দিক থেকে সাজানো",
                    "code": "list.reverse()  \nউদাহরণ: \n_AList = ['itemA','itemC']   \n_AList.reverse()   \nprint(_AList) → ['itemC','itemA']"
                },
                {
                    "definition": "লিস্টের উপাদান ঊর্ধ্বক্রম এবং অধঃক্রম অনুসারে সাজানো",
                    "code": "list.sort() \nউদাহরণ: \n_AList = ['A','C']   \n_AList.sort(reverse=False)   \nprint(_AList) → ['A','C']   \n_AList.sort(reverse=True)   \nprint(_AList) → ['C','A']"
                }
            ]
        },
        {
            "title": "পাইথন টুপল মেথড (Python Tuple Methods)",
            "items": [{
                    "definition": "টুপলে একটি উপাদান কতবার আছে গণনা করা",
                    "code": "_tuple.count(value)"
                },
                {
                    "definition": "টুপলে একটি উপাদানের অবস্থান বের করা",
                    "code": "_tuple.index(value)"
                }
            ]
        },
        {
            "title": "পাইথন সেট মেথড (Python Set Methods)",
            "items": [{
                    "definition": "সেটে নতুন উপাদান সংযুক্ত করা",
                    "code": "_set.add('item')"
                },
                {
                    "definition": "সেটের সকল উপাদান মুছে ফেলা",
                    "code": "_set.clear()"
                },
                {
                    "definition": "সেটের প্রতিলিপি করা",
                    "code": "_newSet = _set.copy()"
                },
                {
                    "definition": "দুটি সেটের পার্থক্য বের করা",
                    "code": "_cSet = _aSet.difference(_bSet)"
                },
                {
                    "definition": "একটি সেটের এমন উপাদান বাদ দেওয়া যা অন্য একটি সেটে আছে",
                    "code": "_aSet.difference_update(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_aSet.difference_update(_bSet)   \nprint(_aSet) → {'banana'}"
                },
                {
                    "definition": "দুটি সেটের সাধারণ উপাদান ব্যতীত সকল উপাদান বের করা",
                    "code": "_cSet = _aSet.symmetric_difference(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_cSet=_aSet.symmetric_difference(_bSet)   \nprint(_cSet) → {'cherry', 'banana'}"
                },
                {
                    "definition": "দুটি সেটের সাধারণ উপাদান বাদ দেওয়া এবং ঐ দুটি সেটের সাধারণ উপাদান ব্যতীত সকল উপাদান একটি সেটে সংযুক্ত করা",
                    "code": "_aSet.symmetric_difference_update(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_aSet.symmetric_difference_update(_bSet)   \nprint(_aSet) → {'cherry', 'banana'}"
                },
                {
                    "definition": "দুটি সেটে ছেদ/সাধারণ উপাদান আছে কিনা যাচাই করা",
                    "code": "_result = _aSet.isdisjoint(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_result = _aSet.isdisjoint(_bSet)   \nprint(_result) → False"
                },
                {
                    "definition": "দুটি সেটের ছেদ/সাধারণ উপাদান বের করা",
                    "code": "_cSet = _aSet.intersection(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_cSet=_aSet.intersection(_bSet)   \nprint(_cSet) → {'apple'}"
                },
                {
                    "definition": "একটি সেটের এমন উপাদান বাদ দেওয়া যা অন্য একটি সেটে নেই",
                    "code": "_aSet.intersection_update(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_aSet.intersection_update(_bSet)   \nprint(_aSet) → {'apple'}"
                },
                {
                    "definition": "দুটি সেটের ইউনিয়ন বের করা",
                    "code": "_cSet = _aSet.union(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_cSet=_aSet.union(_bSet)   \nprint(_cSet) → {'apple', 'cherry', 'banana'}"
                },
                {
                    "definition": "একটি সেটের সব উপাদান অন্য একটি সেটে উপস্থিত কিনা যাচাই করা",
                    "code": "_result = _aSet.issubset(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'banana','cherry', 'apple'}   \n_result = _aSet.issubset(_bSet)   \nprint(_result) → True"
                },
                {
                    "definition": "একটি সেটে অন্য একটি সেটের সব উপাদান উপস্থিত কিনা যাচাই করা",
                    "code": "_result = _aSet.issuperset(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'cherry', 'banana'} \n_bSet = {'banana', 'apple'}   \n_result = _aSet.issuperset(_bSet)   \nprint(_result) → True"
                },
                {
                    "definition": "একটি সেটে অন্য একটি সেটের সব উপাদান সংযুক্ত করা",
                    "code": "_aSet.update(_bSet)  \nউদাহরণ: \n_aSet = {'apple', 'banana'} \n_bSet = {'cherry', 'apple'}   \n_aSet.update(_bSet)   \nprint(_aSet) → {'apple', 'banana', 'cherry'}"
                },
                {
                    "definition": "সেটের নির্দিষ্ট উপাদান মুছে ফেলা",
                    "code": "_aSet.discard(item)/_aSet.remove(item)"
                }
            ]
        },
        {
            "title": "ফাইল পরিচালনা (File Handling)",
            "items": [{
                    "definition": "ফাইল খোলা (ফাইল উপস্থিত না থাকলে এরর দেখাবে)",
                    "code": "file = open(fileLocation, 'r') \nউদাহরণ: \nfile = open('D:\\myfiles\\myFile.txt', 'r')"
                },
                {
                    "definition": "সম্পূর্ণ ফাইল পড়া",
                    "code": "file.read()"
                },
                {
                    "definition": "ফাইলের নির্দিষ্ট সংখ্যক লাইন পড়া",
                    "code": "file.readline()"
                },
                {
                    "definition": "ফাইল বন্ধ করা",
                    "code": "file.close()"
                },
                {
                    "definition": "নতুন ফাইল তৈরি করা",
                    "code": "newFile = open(fileName,'x') \nউদাহরণ: \nfile = open('D:\\myfiles\\myNewFile.txt', 'x')"
                },
                {
                    "definition": "পুরাতন ফাইল আপডেট করা",
                    "code": "updateFile = open(fileName,'w') \nউদাহরণ: \nfile = open('D:\\myfiles\\myNewFile.txt', 'w')"
                },
                {
                    "definition": "ফাইল অপসারণ করা",
                    "code": "os.remove(newFile) \nউদাহরণ: \nos.remove('D:\\myfiles\\myNewFile.txt')"
                },
                {
                    "definition": "ফাইল বাইনারি বা টেক্সট মোড হিসাবে পরিচালনা করতে পারেন (b - বাইনারি, t - টেক্সট)",
                    "code": "file = open(fileLocation, 'rb') \nউদাহরণ: \nfile = open('D:\\myfiles\\myFile.png', 'rb')\n\nবিঃদ্রঃ এখানে, পড়ার জন্য 'r', এবং বাইনারির জন্য 'b'"
                }
            ]
        },
        {
            "title": "মড্যুল এবং নেইম ইমপোর্ট (Module and Name import)",
            "items": [{
                    "definition": "as এর ব্যবহার করে সরাসরি names এর এক্সেস",
                    "code": "from monmod import nom1, nom2 as fct"
                },
                {
                    "definition": "মড্যুল এক্সেস এর অন্য উপায় হতে পারে monmod.nom1",
                    "code": "import monmod"
                }
            ]
        },
        {
            "title": "পান্ডাস ডাটাফ্রাম (Pandas Dataframe)",
            "items": [{
                    "definition": "পান্ডাস ইম্পোর্ট করা",
                    "code": "import pandas as pd"
                },
                {
                    "definition": "সিএসভি ফাইল রিড করা এবং ভেরিয়েবলে রাখা",
                    "code": "df = pd.read_csv(file_path)"
                },
                {
                    "definition": "ডাটাফ্রেমের রো, কলাম সংখ্যা",
                    "code": "df.shape"
                },
                {
                    "definition": "ডাটাফ্রেমের ইন্ডেক্স(রো লেবেল)",
                    "code": "df.index"
                },
                {
                    "definition": "ডাটাফ্রেমের সব কলামের নাম",
                    "code": "df.columns"
                },
                {
                    "definition": "ডাটাফ্রেমের প্রথম n রো",
                    "code": "df.head(n)"
                },
                {
                    "definition": "ডাটাফ্রেমের শেষের n রো",
                    "code": "df.tail(n)"
                },
                {
                    "definition": "র‍্যান্ডমলি ডাটাফ্রেমের ৯ টি রো সিলেক্ট করে",
                    "code": "df.sample(n=9)"
                },
                {
                    "definition": "ডাটাফ্রেমের ইনফো",
                    "code": "df.info()"
                },
                {
                    "definition": "পুরো ডাটাফ্রেমের সামারি পরিসংখ্যান",
                    "code": "df.describe()"
                },
                {
                    "definition": "নিউমেরিক কলামগুলোর গড়",
                    "code": "df.mean()"
                },
                {
                    "definition": "নিউমেরিক কলামগুলোর মিডিয়ান",
                    "code": "df.median()"
                },
                {
                    "definition": "কোন একটি ফাংশন এপ্লাই করা",
                    "code": "df.apply(func)"
                },
                {
                    "definition": "ভ্যালু অনুযায়ী সোর্ট করা",
                    "code": "df.sort_values(by='column_name')"
                },
                {
                    "definition": "কলামের ভ্যালুগুলোর ফ্রিকুয়েন্সি",
                    "code": "df['column_name'].value_counts()"
                },
                {
                    "definition": "ডাটাফ্রেমের ইন্ডেক্স সোর্ট করে",
                    "code": "df.sort_index()"
                },
                {
                    "definition": "কলামের ইউনিক ভ্যালুর সংখ্যা",
                    "code": "df['column_name'].nunique()"
                },
                {
                    "definition": "NA/null মান রয়েছে এমন কলাম বাদ দেয়া",
                    "code": "df.dpropna()"
                },
                {
                    "definition": "NA/null ভ্যালু এর মান value-এ পরিবর্তন করা",
                    "code": "df.fillna(value)"
                },
                {
                    "definition": "কলামের নাম পরিবর্তন করা",
                    "code": "df.rename(columns = {'old_name': 'new_name'})"
                }
            ]
        },
        {
            "title": "নামপাই লাইব্রেরি (Numpy Library)",
            "items": [{
                    "definition": "নামপাই ইনস্টল করা",
                    "code": "pip install numpy"
                },
                {
                    "definition": "নামপাই ইম্পোর্ট করা",
                    "code": "import numpy as np\n\nবিঃদ্রঃ এখানে, np হল alias বা শর্ট নেম। ফুল numpy না লেখে np লেখলেও হবে এখন থেকে"
                },
                {
                    "definition": "ভার্সন চেক করা",
                    "code": "np.__version__"
                },
                {
                    "definition": "অ্যারে তৈরি করা (নামপাই-এ অ্যারে অবজেক্টকে ndarray বলা হয়)",
                    "code": "arr = np.array([1, 2, 3, 4, 5])"
                },
                {
                    "definition": "অ্যারে copy করা",
                    "code": "arr = np.array([1, 2, 3, 4, 5])\nnewArr = arr.copy()"
                },
                {
                    "definition": "অ্যারের ডাইম্যানসন চেক করা",
                    "code": "arr.ndim"
                },
                {
                    "definition": "অ্যারের shape চেক করা",
                    "code": "arr.shape"
                },
                {
                    "definition": "অ্যারের shape চেঞ্জ করা (1D থেকে 2D)",
                    "code": "arr = np.array([1, 2, 3, 4, 5, 6])\nnewArr = arr.reshape(3, 2)\n\nবিঃদ্রঃ এখানে arr অ্যারেটা ১ম ডাইম্যানসন এর এবং newArr অ্যারেটা (৩, ২) ডাইম্যানসন এর। মানে ৩ টা অ্যারে এবং প্রত্যেক অ্যারেতে ২ টা করে এলিমেনট। অন্যভাবে বলতে গেলে, ৩ টা রো এবং ২ টা কলাম।\n\n[[1, 2], [3, 4], [5, 6]]"
                },
                {
                    "definition": "অ্যারের shape চেঞ্জ করা (1D থেকে 3D)",
                    "code": "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\nnewArr = arr.reshape(2, 3, 2)\n\nবিঃদ্রঃ এখানে arr অ্যারেটা ১ম ডাইম্যানসন এর এবং newArr অ্যারেটা (২, ৩, ২) ডাইম্যানসন এর। মানে ২ টা অ্যারে, আবার ওই ২ অ্যারে এর প্রত্যেকটা তে ৩ টা করে অ্যারে এবং এক এক অ্যারেতে ২ টা করে এলিমেনট।\n\n[[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]"
                },
                {
                    "definition": "৫ ডাইম্যানসন অ্যারে তৈরি করা",
                    "code": "arr5D = np.array([1, 2, 3], ndmin=5)"
                },
                {
                    "definition": "অ্যারে ইনডেক্সিং",
                    "code": "arr[0]\nলাস্ট উপাদানঃ arr[-1]"
                },
                {
                    "definition": "১ম ডাইম্যানসন(রো) এর চতুর্থ উপাদান",
                    "code": "arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])\nprint(arr[0, 3])"
                },
                {
                    "definition": "অ্যারে স্লাইস ([স্টার্ট:এন্ড] এবং [স্টার্ট:এন্ড:স্টেপ] হল স্টেপ সহ)",
                    "code": "ইনডেক্স ১ থেকে ৫ এর জন্যঃ arr[1:5]\nইনডেক্স ১ থেকে ৫ এর জন্য ২ স্টেপ পর পরঃ arr[1:5:2]\nইনডেক্স ৩ থেকে লাস্ট এর জন্যঃ arr[3:]\nইনডেক্স 0 থেকে ৪ এর জন্যঃ  arr[:5]\n\nবিঃদ্রঃ [স্টার্ট:এন্ড] এখানে, এন্ড অন্তর্ভুক্ত না। মানে arr[:4] এর জন্য ইনডেক্স ০,১,২,৩ এর ভালু দেখাবে, কিন্তু ইনডেক্স ৪ এর ভালু দেখাবেনা।"
                },
                {
                    "definition": "নামপাই-এ ডেটা টাইপস",
                    "code": "i - পূর্ণসংখ্যা (integer)\nb - বুলিয়ান (boolean)\nu - আনসাইনড পূর্ণসংখ্যা (unsigned integer)\nf - ফ্লোট (float)\nc - কমপ্লেক্স ফ্লোট (complex float)\nm - টাইমডেল্টা (timedelta)\nM - ডেটটাইম (datetime)\nO - অবজেক্ট (object)\nS - স্ট্রিং (string)\nU - ইউনিকোড স্ট্রিং (unicode string)\nV - ভয়েড (void)\n\nবিঃদ্রঃ চেক ডেটাটাইপঃ arr.dtype"
                },
                {
                    "definition": "অ্যারে ইটারেটিং (1D)",
                    "code": "arr = np.array([1, 2, 3])\nfor x in arr:\n\tprint(x)"
                },
                {
                    "definition": "অ্যারে ইটারেটিং (2D)",
                    "code": "arr = np.array([[1, 2, 3], [4, 5, 6]])\nfor x in arr:\n\tfor y in x:\n\t\tprint(y)"
                },
                {
                    "definition": "অ্যারে ইটারেটিং (3D)",
                    "code": "arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\nfor x in np.nditer(arr):\n\tprint(x)"
                },
                {
                    "definition": "অ্যারে ইটারেট (বিভিন্ন স্টেপ এ)",
                    "code": "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\nfor x in np.nditer(arr[:, ::2]):\n\tprint(x)\n\nবিঃদ্রঃ এখানে ১ টা করে এলিমেনট বা উপাদান স্কিপ করে শো করবে। ::3 হলে ২ টা করে স্কিপ করে শো করতো। যেহেতু ::2, তাই রেজাল্ট শো করবে 1 3 5 7"
                },
                {
                    "definition": "অ্যারে ইটারেট (ইনডেক্স নাম্বার সহ)",
                    "code": "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\nfor i, x in np.ndenumerate(arr):\n\tprint(i, x)\n\nবিঃদ্রঃ এখানে i হল ইনডেক্স এবং x হল ভেলু"
                },
                {
                    "definition": "দুটি অ্যারে জয়েন (1D)",
                    "code": "arr1 = np.array([1, 2, 3])\narr2 = np.array([4, 5, 6])\nnewArr = np.concatenate((arr1, arr2))"
                },
                {
                    "definition": "দুটি অ্যারে জয়েন (2D)",
                    "code": "arr1 = np.array([[1, 2], [3, 4]])\narr2 = np.array([[5, 6], [7, 8]])\nnewArr = np.concatenate((arr1, arr2), axis=1)\n\nবিঃদ্রঃ এখানে axis=1 মানে রো। ১ম অ্যারে এর ১ম রো এবং ২য় অ্যারে এর ১ম রো হবে নিউ অ্যারে এর ১ম রো। আর যদি axis=0 দেয়া হতো তাহলে কলাম অনুযায়ী নিউ অ্যারে হতো। সেক্ষেত্রে, ১ম অ্যারে এর ১ম এবং ২য় রো হতো নিউ অ্যারে এর ১ম এবং ২য় রো। ২য় অ্যারে এর ১ম, ২য় হবে নিউ অ্যারে এর ৩য়, ৪র্থ রো।"
                },
                {
                    "definition": "stact() মেথড দিয়ে দুটি অ্যারে জয়েন",
                    "code": "arr1 = np.array([1, 2, 3])\narr2 = np.array([4, 5, 6])\nnewArr = np.stack((arr1, arr2), axis=1)"
                },
                {
                    "definition": "hstact() মেথড দিয়ে রো ভাবে দুটি অ্যারে জয়েন",
                    "code": "arr1 = np.array([1, 2, 3])\narr2 = np.array([4, 5, 6])\nnewArr = np.hstack((arr1, arr2))"
                },
                {
                    "definition": "vstact() মেথড দিয়ে কলাম ভাবে দুটি অ্যারে জয়েন",
                    "code": "arr1 = np.array([1, 2, 3])\narr2 = np.array([4, 5, 6])\nnewArr = np.vstack((arr1, arr2))"
                },
                {
                    "definition": "দুটি অ্যারে এর একই ইনডেক্স নিয়ে dstack() মেথড দিয়ে অ্যারে জয়েন",
                    "code": "arr1 = np.array([1, 2, 3])\narr2 = np.array([4, 5, 6])\nnewArr = np.dstack((arr1, arr2))\n\nবিঃদ্রঃ এখানে দুটি অ্যারে এড় 0 ইনডেক্স নিয়ে নিউ অ্যারে এর ১ম রো এবং ইনডেক্স 1 নিয়ে নিউ অ্যারে এর ২য় রো। তাই রেজাল্ট হবে [[[1, 4], [2, 5], [3, 6]]]"
                },
                {
                    "definition": "অ্যারে split",
                    "code": "arr = np.array([1, 2, 3, 4, 5, 6])\nnewArr = np.array_split(arr, 3)\n\nবিঃদ্রঃ এখানে 3 ব্যাবহার করা হয়েছে ৩ ভাগ এ ভাগ করার জন্য"
                },
                {
                    "definition": "রো অনুযায়ী একটি 2D অ্যারে কে ৩টি 2D তে ভাগ(split) করা",
                    "code": "arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])\nnewarr = np.array_split(arr, 3, axis=1)"
                },
                {
                    "definition": "where() মেথড দিয়ে অ্যারে থেকে কোন ভেলু সার্চ",
                    "code": "arr = np.array([1, 2, 3, 4, 5, 4, 4])\nx = np.where(arr == 4)\n\nবিঃদ্রঃ এখানে রেজাল্ট হিসেবে (array([3, 5, 6],) পাবো। আমরা চাইলে whire() মেথড এর মদ্ধে আরও কনডিসন ব্যাবহার করতে পারি। জোর সংখ্যা এর জন্য arr%2 == 0 এরকম।"
                },
                {
                    "definition": "searchsorted() মেথড দিয়ে অ্যারে কে অটো সর্ট করে তারপর কোন ভেলু এর ইনডেক্স সার্চ করা",
                    "code": "arr = np.array([6, 8, 9, 7])\nx = np.searchsorted(arr, 7)\n\nবিঃদ্রঃ এখানে রেজাল্ট হিসেবে আমরা 1  পাবো, কারণ সর্ট করার পর 7 এর ভেলু ইনডেক্স 1 এ আসবে। মানে সর্ট করা অ্যারে টা হল [6, 7, 8, 9]। তাই রেজাল্ট 1 আসবে, যেহেতু 7 এর ইনডেক্স 1"
                },
                {
                    "definition": "ইনডেক্সগুলি সন্ধান করুন যেখানে 2, 4 এবং 6 মানগুলি ইন্সার্ট করানো উচিত",
                    "code": "arr = np.array([1, 5, 8, 9])\nx = np.searchsorted(arr, [2, 4, 6])\n\nবিঃদ্রঃ এখানে রেজাল্ট [1, 1, 2]"
                },
                {
                    "definition": "অ্যারে সর্ট (1D)",
                    "code": "arr = np.array([3, 2, 0, 1])\nnewArr = np.sort(arr)"
                },
                {
                    "definition": "অ্যারে সর্ট (2D)",
                    "code": "arr = np.array([[3, 2, 4], [5, 0, 1]])\nnewArr = np.sort(arr)\n\nবিঃদ্রঃ এখানে রেজাল্ট [[2, 3, 4], [0, 1, 5]]"
                },
                {
                    "definition": "filter",
                    "code": "arr = np.array([10, 20, 30, 40])\nx = [True, False, True, False]\nnewArr = arr[x]\n\nবিঃদ্রঃ এখানে রেজাল্ট [10, 30], কারণ নতুন ফিল্টারটিতে কেবলমাত্র সেই মান রয়েছে যেখানে ফিল্টার অ্যারের মানটি সত্য ছিল"
                },
                {
                    "definition": "0 থেকে 1 পর্যন্ত একটি রেনডম পূর্ণসংখ্যা তৈরি করুন",
                    "code": "from numpy import random\nx = random.rand()"
                },
                {
                    "definition": "0 থেকে 100 পর্যন্ত একটি রেনডম পূর্ণসংখ্যা তৈরি করুন",
                    "code": "from numpy import random\nx = random.randint(100)"
                },
                {
                    "definition": "৫ সংখ্যার একটি রেনডম অ্যারে তৈরি করা (1D)",
                    "code": "x=random.randint(100, size=(5))"
                },
                {
                    "definition": "৩ রো এবং ৫ কলাম এর একটি রেনডম পূর্ণসংখ্যার অ্যারে তৈরি করা (2D)",
                    "code": "x = random.randint(100, size=(3, 5))"
                },
                {
                    "definition": "৩ রো এবং ৫ কলাম এর একটি রেনডম দশমিক সংখ্যার অ্যারে তৈরি করা (2D)",
                    "code": "x = random.rand(3, 5)"
                },
                {
                    "definition": "প্রদত্ত অ্যারে এর মানগুলি ব্যাবহার করে ৩ রো এবং ৫ কলাম এর একটি 2D অ্যারে তৈরি করুন",
                    "code": "x = random.choice([3, 5, 7, 9], size=(3, 5))"
                }
            ]
        }
    ]
}