Teachnique
      CourseRoadmaps
      Login

      OverviewCommentsUser InputNumbersBooleansHistoryHello World ProgramEnvironment SetupSyntaxVariablesData TypesType CastingUnicode SystemLiteralsOperators

      Control FlowBreak StatementContinue StatementPass StatementNested LoopsDecision MakingIf StatementIf-else StatementNested IF StatementMatch-Case StatementLoopsFor LoopsFor-else LoopsWhile Loops

      FunctionsBuilt-in FunctionsDefault ArgumentsKeyword ArgumentsKeyword-Only ArgumentsPositional ArgumentsPositional-Only ArgumentsArbitrary ArgumentsVariable ScopeFunction AnnotationsModules

      StringSlicing StringsModify StringsString ConcatenationString FormattingEscape CharactersString MethodsString Exercises

      ListsList ExercisesAccess List ItemsChange List ItemsAdd List ItemsRemove List ItemsLoop ListsList ComprehensionSort ListsCopy ListsJoin ListsList Methods

      TuplesAccess Tuple ItemsUpdate TuplesUnpack Tuple ItemsLoop TuplesJoin TuplesTuple MethodsTuple Exercises

      SetsAccess Set ItemsAdd Set ItemsRemove Set ItemsLoop SetsJoin SetsCopy SetsSet OperatorsSet MethodsSet Exercises

      DictionariesDictionary ExercisesAccess Dictionary ItemsChange Dictionary ItemsAdd Dictionary ItemsRemove Dictionary ItemsDictionary View ObjectsLoop DictionariesCopy DictionariesNested DictionariesDictionary Methods

      ArraysAccess Array ItemsAdd Array ItemsRemove Array ItemsLoop ArraysCopy ArraysReverse ArraysSort ArraysJoin ArraysArray MethodsArray Exercises

      File HandlingWrite to FileRead FilesRenaming and Deleting FilesDirectoriesFile Methods

      OOP ConceptsDynamic BindingDynamic TypingAbstractionObject and ClassesEncapsulationInterfacesPackagesInner ClassesAnonymous Class and ObjectsSingleton ClassWrapper ClassesEnumsReflectionClass AttributesClass MethodsStatic MethodsConstructorsAccess ModifiersInheritancePolymorphismMethod OverridingMethod Overloading

      Feedback

      Submit request if you have any questions.

      Course
      Unpack Tuple Items

      Python Tutorial

      This Python tutorial has been written for the beginners to help them understand the basic to advanced concepts of Python Programming Language. After completing this tutorial, you will find yourself at a great level of expertise in Python, from where you can take yourself to the next levels to become a world class Software Engineer.

      Unpack Tuple Items

      The term "unpacking" refers to the process of parsing tuple items in individual variables. In Python, the parentheses are the default delimiters for a literal representation of sequence object.
      Following statements to declare a tuple are identical.
      >>> t1 = (x,y)
      >>> t1 = x,y
      >>> type (t1)
      <class 'tuple'>

      Example 1

      To store tuple items in individual variables, use multiple variables on the left of assignment operator, as shown in the following example 
      tup1 = (10,20,30)
      x, y, z = tup1
      print ("x: ", x, "y: ", "z: ",z)
      It will produce the following output
      x: 10 y: 20 z: 30
      That's how the tuple is unpacked in individual variables.

      Using to Unpack a T uple

      In the above example, the number of variables on the left of assignment operator is equal to the items in the tuple. What if the number is not equal to the items?

      Example 2

      If the number of variables is more or less than the length of tuple, Python raises a ValueError.
      tup1 = (10,20,30)
      x, y = tup1
      x, y, p, q = tup1
      It will produce the following output
        x, y = tup1
        ^^^^
      ValueError: too many values to unpack (expected 2)
        x, y, p, q = tup1
        ^^^^^^^^^^
      ValueError: not enough values to unpack (expected 4, got 3)
      In such a case, the "*" symbol is used for unpacking. Prefix "*" to "y", as shown below
      tup1 = (10,20,30)
      x, *y = tup1
      print ("x: ", "y: ", y)
      It will produce the following output
      x: y: [20, 30]
      The first value in tuple is assigned to "x", and rest of items to "y" which becomes a list.

      Example 3

      In this example, the tuple contains 6 values and variables to be unpacked are 3. We prefix "*" to the second variable.
      tup1 = (10,20,30, 40, 50, 60)
      x, *y, z = tup1
      print ("x: ",x, "y: ", y, "z: ", z)
      It will produce the following output
      x: 10 y: [20, 30, 40, 50] z: 60
      Here, values are unpacked in "x" and "z" first, and then the rest of values are assigned to "y" as a list.

      Example 4

      What if we add "*" to the first variable?
      tup1 = (10,20,30, 40, 50, 60)
      *x, y, z = tup1
      print ("x: ",x, "y: ", y, "z: ", z)
      It will produce the following output
      x: [10, 20, 30, 40] y: 50 z: 60
      Here again, the tuple is unpacked in such a way that individual variables take up the value first, leaving the remaining values to the list "x".

      Practice with Online Editor

      Note: This Python online Editor is a Python interpreter written in Rust, RustPython may not fully support all Python standard libraries and third-party libraries yet.
      Remember to save code(Ctrl + S Or Command + S) before run it.