python - সহজ ভাষায় পাইথন ৩ pdf download




পাইথন একটি তালিকা শেষ উপাদান পেয়ে (10)

পাইথন ইন, আপনি একটি তালিকা শেষ উপাদান পেতে কিভাবে?

শুধু শেষ উপাদান পেতে,

  • তালিকা পরিবর্তন ছাড়া, এবং
  • আপনি যদি জানেন যে তালিকার একটি শেষ উপাদান রয়েছে (অর্থাত এটি অযৌক্তিক)

সাবস্ক্রিপ্ট নোটেশন পাস -1 :

>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'

ব্যাখ্যা

সূচী এবং টুকরা আর্গুমেন্ট হিসাবে নেতিবাচক পূর্ণসংখ্যা নিতে পারেন।

প্রতিটি সূচকের রেফারেন্সে কোন আইটেমটি নির্দেশ করে তা নির্দেশ করার জন্য আমি ডকুমেন্টেশন থেকে একটি উদাহরণ সংশোধন করেছি, এই ক্ষেত্রে স্ট্রিং "Python" -1 , শেষ উপাদানটি, চরিত্র, 'n' :

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

>>> p = 'Python'
>>> p[-1]
'n'

পুনরাবৃত্তিহীন unpacking মাধ্যমে বরাদ্দ

এই পদ্ধতিটি কেবলমাত্র শেষ উপাদানটি অর্জনের উদ্দেশ্যে অপ্রয়োজনীয়ভাবে দ্বিতীয় তালিকায় পরিণত হতে পারে, তবে সম্পূর্ণতার জন্য (এবং যেহেতু এটি কোনও পুনরাবৃত্তিযোগ্য - শুধুমাত্র তালিকাভুক্ত নয়):

>>> *head, last = a_list
>>> last
'three'

পরিবর্তনশীল নাম, মাথা অপ্রয়োজনীয় নবনির্মিত তালিকা আবদ্ধ করা হয়:

>>> head
['zero', 'one', 'two']

আপনি যদি সেই তালিকাটির সাথে কিছুই করার ইচ্ছা করেন তবে এটি আরও বেশি কার্যকর হবে:

*_, last = a_list

অথবা, সত্যিই, যদি আপনি এটি একটি তালিকা জানেন (অথবা অন্তত সাবস্ক্রিপ্ট নোটেশন গ্রহণ করে):

last = a_list[-1]

একটি ফাংশন

একটি মন্তব্যকারী বলেন:

আমি পাইথনের প্রথম () এবং শেষ () লিপের মত একটি ফাংশন ছিল ... এটা অপ্রয়োজনীয় Lambda ফাংশন থেকে অনেক পরিত্রাণ পেতে হবে।

এই সংজ্ঞায়িত করা বেশ সহজ হবে:

def last(a_list):
    return a_list[-1]

def first(a_list):
    return a_list[0]

অথবা operator.itemgetter ব্যবহার করুন।

>>> import operator
>>> last = operator.itemgetter(-1)
>>> first = operator.itemgetter(0)

উভয় ক্ষেত্রে:

>>> last(a_list)
'three'
>>> first(a_list)
'zero'

বিশেষ ক্ষেত্রে

আপনি যদি আরও জটিল কিছু করছেন তবে আপনি সামান্য ভিন্ন উপায়ে শেষ উপাদানটি পেতে এটি আরও বেশি পারফরম্যান্স পেতে পারেন।

আপনি যদি প্রোগ্রামিং করতে নতুন হন, তবে আপনাকে এই বিভাগটি এড়িয়ে চলতে হবে, কারণ এটি যৌথভাবে আলগোরিদিমগুলির সাথে আলাদা আলাদা আলাদা অংশ যুক্ত করে। আপনি যদি এক জায়গায় আপনার অ্যালগরিদম পরিবর্তন করেন, তবে এটি অন্য কোডের লাইনের উপর অপ্রত্যাশিত প্রভাব ফেলতে পারে।

আমি যতটা সম্ভব হিসাবে caveats এবং শর্ত প্রদান করার চেষ্টা করুন, কিন্তু আমি কিছু মিস করতে পারে। অনুগ্রহ করে মন্তব্য করুন যদি আপনি মনে করেন আমি একটি ক্যাভিট আউট রেখে যাচ্ছি।

slicing

একটি তালিকার একটি অংশ একটি নতুন তালিকা প্রদান করে - তাই আমরা যদি একটি নতুন তালিকাতে উপাদানটি চাইলে আমরা -1 থেকে শেষ পর্যন্ত ফাঁকা করতে পারি:

>>> a_slice = a_list[-1:]
>>> a_slice
['three']

তালিকার খালি থাকলে এটি ব্যর্থ হওয়ার ঊর্ধ্বগতি আছে:

>>> empty_list = []
>>> tail = empty_list[-1:]
>>> if tail:
...     do_something(tail)

সূচক দ্বারা অ্যাক্সেস করার চেষ্টা করার সময় একটি সূচক IndexError উত্থাপিত হয় যা পরিচালনা করতে হবে:

>>> empty_list[-1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

কিন্তু আবার, এই উদ্দেশ্যে শুধুমাত্র আপনি প্রয়োজন হলে slicing করা উচিত:

  • একটি নতুন তালিকা তৈরি
  • এবং পূর্ববর্তী তালিকা খালি ছিল যদি নতুন তালিকা খালি হতে।

loops for

পাইথনের বৈশিষ্ট্য হিসাবে, লুপের for কোন অভ্যন্তরীণ স্কোপিং নেই।

যদি আপনি ইতিমধ্যে তালিকাটিতে সম্পূর্ণ পুনরাবৃত্তি সম্পাদন করছেন তবে শেষ উপাদানটি এখনও লুপে দেওয়া পরিবর্তনশীল নামের দ্বারা উল্লেখ করা হবে:

>>> def do_something(arg): pass
>>> for item in a_list:
...     do_something(item)
...     
>>> item
'three'

এই semantically তালিকায় শেষ জিনিস নয়। এই semantically শেষ জিনিস যে নাম, item , আবদ্ধ ছিল।

>>> def do_something(arg): raise Exception
>>> for item in a_list:
...     do_something(item)
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 1, in do_something
Exception
>>> item
'zero'

সুতরাং এই যদি শুধুমাত্র আপনি শেষ উপাদান পেতে ব্যবহার করা উচিত

  • ইতিমধ্যে looping হয়, এবং
  • আপনি জানেন লুপটি শেষ হবে (ত্রুটির কারণে বিরতি বা প্রস্থান করবেন না), অন্যথায় এটি লুপ দ্বারা উল্লিখিত শেষ উপাদানটিকে নির্দেশ করবে।

পেয়ে এবং এটি অপসারণ

আমরা শেষ উপাদানটি সরিয়ে এবং ফিরিয়ে আনতে আমাদের আসল তালিকাটি পরিবর্তন করতে পারি:

>>> a_list.pop(-1)
'three'
>>> a_list
['zero', 'one', 'two']

কিন্তু এখন মূল তালিকা সংশোধন করা হয়।

( -1 আসলে ডিফল্ট আর্গুমেন্ট, তাই তালিকা. list.pop একটি সূচক যুক্তি ছাড়া ব্যবহার করা যেতে পারে):

>>> a_list.pop()
'two'

শুধুমাত্র যদি এই কাজ

  • আপনি তালিকায় উপাদান আছে জানেন, অথবা এটি খালি, এবং ব্যতিক্রম হ্যান্ডেল করতে প্রস্তুত হয়
  • আপনি তালিকা থেকে শেষ উপাদান মুছে ফেলার ইচ্ছা, একটি স্ট্যাক মত এটি চিকিত্সা।

এই বৈধ ব্যবহারের ক্ষেত্রে, কিন্তু খুব সাধারণ নয়।

পরবর্তী জন্য বিপরীত বাকি সংরক্ষণ:

আমি জানি না কেন আপনি এটি করবেন, কিন্তু সম্পূর্ণতার জন্য, reversed একটি ইটারেটার (যা ইটিয়েটর প্রোটোকলকে সমর্থন করে) প্রদান করে, তার পরে আপনি তার ফলাফলটি next প্রেরণ করতে পারেন:

>>> next(reversed([1,2,3]))
3

সুতরাং এটি এর বিপরীত করছেন:

>>> next(iter([1,2,3]))
1

কিন্তু আমি এটি করার একটি ভাল কারণ মনে করতে পারছি না, যতক্ষণ না আপনি পরবর্তী রিভার্স ইটারেটারের প্রয়োজন হবে, যা সম্ভবত এইরকম আরও দেখতে পাবে:

reverse_iterator = reversed([1,2,3])
last_element = next(reverse_iterator)

use_later = list(reverse_iterator)

এবং এখন:

>>> use_later
[2, 1]
>>> last_element
3

পাইথন ইন, আপনি একটি তালিকা শেষ উপাদান পেতে কিভাবে?


some_list = [1, 2, 3]

পদ্ধতি 1:

some_list[-1]

পদ্ধতি 2:

**some_list.reverse()** 

**some_list[0]**

পদ্ধতি 3:

some_list.pop() 

ঠিক আছে, কিন্তু প্রায় প্রতিটি ভাষা উপায় items[len(items) - 1] সাধারণ সম্পর্কে কি? এটি আইএমও শেষ উপাদান পেতে সবচেয়ে সহজ উপায়, কারণ এটি Pythonic জ্ঞান কিছু প্রয়োজন হয় না।


তারিখ: 2017-12-06

alist.pop()

আমি আপনার রেফারেন্সের জন্য সমস্ত তালিকা 11 টি পদ্ধতির একটি সম্পূর্ণ চিটশীট তৈরি করি।

{'list_methods': {'Add': {'extend', 'append', 'insert'},
                  'Entire': {'clear', 'copy'},
                  'Search': {'count', 'index'},
                  'Sort': {'reverse', 'sort'},
                  'Subtract': {'remove', 'pop'}}}

পাইথন তালিকা নেতিবাচক সূচী সমর্থন করে।

a = [1, 2, 3]

a[-1] # gives the last elements with negative indexes

অথবা

a[len(a) - 1] # gives the last elements len function


পাইথন শেষ উপাদান প্রদর্শন করার সবচেয়ে সহজ উপায়

>>> list[-1:] # returns indexed value
    [3]
>>> list[-1]  # returns value
    3

যেমন একটি লক্ষ্য অর্জন করার অনেক অন্যান্য পদ্ধতি আছে কিন্তু এই সংক্ষিপ্ত এবং মিষ্টি ব্যবহার করা হয়।


যদি আপনি তালিকাটির শেষ মানটি পেতে চান তবে আপনাকে এটি ব্যবহার করতে হবে:

your_list[-1]

কিন্তু যদি আপনি মূল্য পেতে চান এবং তালিকা থেকে এটি সরাতে চান তবে আপনি এটি ব্যবহার করতে পারেন:

your_list.pop()

অথবা: আপনি খুব সূচক সঙ্গে পপ করতে পারেন ...

your_list.pop(-1)

list[-1] তালিকা পরিবর্তন ছাড়া তালিকার শেষ উপাদান পুনরুদ্ধার করা হবে। list.pop() শেষ উপাদানটি পুনরুদ্ধার করবে, তবে এটি মূল তালিকার পরিবর্তন / পরিবর্তন করবে। সাধারণত, মূল তালিকা mutating সুপারিশ করা হয় না।

বিকল্পভাবে, যদি, কিছু কারণে, আপনি কম Pythonic কিছু খুঁজছেন, আপনি তালিকার খালি list[len(list)-1] ব্যবহার করতে পারেন, অনুমান তালিকা খালি না।


some_list[-1] ছোট এবং সবচেয়ে পাইথনিক।

আসলে, আপনি এই সিনট্যাক্স সঙ্গে আরো অনেক কিছু করতে পারেন। some_list[-n] সিনট্যাক্স nth-to-last উপাদানটি পায়। সুতরাং some_list[-1] শেষ উপাদানটি পায়, some_list[-2] দ্বিতীয়টি শেষ করে, ইত্যাদি, some_list[-len(some_list)] , যা আপনাকে প্রথম উপাদান দেয়।

আপনি এই ভাবে তালিকা উপাদান সেট করতে পারেন। এই ক্ষেত্রে:

>>> some_list = [1, 2, 3]
>>> some_list[-1] = 5 # Set the last element
>>> some_list[-2] = 3 # Set the second to last element
>>> some_list
[1, 3, 5]

উল্লেখ্য যে সূচী অনুসারে তালিকা আইটেমটি যদি সূচী আইটেমটি বিদ্যমান না থাকে তবে সূচী- IndexError করবে। এর অর্থ হল some_list[-1] some_list খালি থাকলে ব্যতিক্রম হবে কারণ একটি খালি তালিকাটির শেষ উপাদান থাকতে পারে না।


mylist = [ 1 , 2 , 3 , 4 , 5]

#------------------------------------
# Method-1 : Last index
#------------------------------------

print(mylist[-1])


#------------------------------------
# Method-2 : Using len 
#------------------------------------

print(mylist[len(mylist) - 1])


#------------------------------------
# Method-3 : Using pop, pop will remove the last 
#            element from the list.
#------------------------------------

print(mylist.pop())




indexing