Can an object appear more than once in a list Python?

Array elements that appear more than once

Given an integer array, print all repeating elements (Elements that appear more than once) in the array. The output should contain elements according to their first occurrences.

Table of Contents Show

Array elements that appear more than once
8. Compound statements¶
inspect — Inspect live objects¶
Python Lists
Lists and Tuples in Python

Examples:

Input: arr[] = {12, 10, 9, 45, 2, 10, 10, 45} Output: 10 45 Input: arr[] = {1, 2, 3, 4, 2, 5} Output: 2 Input: arr[] = {1, 1, 1, 1, 1} Output: 1

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

The idea is to use Hashing to solve this in O(n) time on average. We store elements and their counts in a hash table. After storing counts, we traverse input array again and print those elements whose counts are more than once. To make sure that every output element is printed only once, we set count as 0 after printing the element.

C++

// C++ program to print all repeating elements
#include <bits/stdc++.h>

using namespace std;

void printRepeating(int arr[], int n)
{

// Store elements and their counts in

// hash table

unordered_map<int, int> mp;

for (int i = 0; i < n; i++)

mp[arr[i]]++;

// Since we want elements in same order,

// we traverse array again and print

// those elements that appear more than

// once.

for (int i = 0; i < n; i++) {

if (mp[arr[i]] > 1) {

cout << arr[i] << " ";

// This is tricky, this is done

// to make sure that the current

// element is not printed again

mp[arr[i]] = 0;

}

}
}
// Driver code

int main()
{

int arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };

int n = sizeof(arr) / sizeof(arr[0]);

printRepeating(arr, n);

return 0;
}

Java

// Java program to print all repeating elements

import java.util.*;

import java.util.Map.Entry;

import java.io.*;

import java.lang.*;

public class GFG {

static void printRepeating(int arr[], int n)

{

// Store elements and their counts in

// hash table

Map<Integer, Integer> map

= new LinkedHashMap<Integer, Integer>();

for (int i = 0; i < n; i++) {

try {

map.put(arr[i], map.get(arr[i]) + 1);

}

catch (Exception e) {

map.put(arr[i], 1);

}

}

// Since we want elements in the same order,

// we traverse array again and print

// those elements that appear more than once.

for (Entry<Integer, Integer> e : map.entrySet()) {

if (e.getValue() > 1) {

System.out.print(e.getKey() + " ");

}

}

}

// Driver code

public static void main(String[] args) throws IOException

{

int arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };

int n = arr.length;

printRepeating(arr, n);

}
}
// This code is contributed by Wrick

Python3

# Python3 program to print
# all repeating elements

def printRepeating(arr, n):

# Store elements and

# their counts in

# hash table

mp = [0] * 100

for i in range(0, n):

mp[arr[i]] += 1

# Since we want elements

# in same order, we

# traverse array again

# and print those elements

# that appear more than once.

for i in range(0, n):

if (mp[arr[i]] > 1):

print(arr[i], end = " ")

# This is tricky, this

# is done to make sure

# that the current element

# is not printed again

mp[arr[i]] = 0

# Driver code

arr = [12, 10, 9, 45,

2, 10, 10, 45]

n = len(arr)
printRepeating(arr, n)
# This code is contributed 
# by Smita

// C# program to print all repeating elements

using System;

using System.Collections.Generic;

class GFG
{

static void printRepeating(int []arr, int n)
{

// Store elements and their counts in

// hash table

Dictionary<int,

int> map = new Dictionary<int,

int>();

for (int i = 0 ; i < n; i++)

{

if(map.ContainsKey(arr[i]))

{

var val = map[arr[i]];

map.Remove(arr[i]);

map.Add(arr[i], val + 1);

}

else

{

map.Add(arr[i], 1);

}

}

// Since we want elements in the same order,

// we traverse array again and print

// those elements that appear more than once.

foreach(KeyValuePair<int, int> e in map)

{

if (e.Value > 1)

{

Console.Write(e.Key + " ");

}

}
}
// Driver code

public static void Main(String[] args)
{

int []arr = { 12, 10, 9, 45, 2, 10, 10, 45 };

int n = arr.Length;

printRepeating(arr, n);
}
}
// This code is contributed by PrinciRaj1992

Javascript

<script>

// JavaScript program to print all
// repeating elements

function printRepeating(arr, n)
{

// Store elements and their counts in

// hash table

var mp = new Map();

for (var i = 0; i < n; i++)

{

if(mp.has(arr[i]))

mp.set(arr[i], mp.get(arr[i])+1)

else

mp.set(arr[i], 1)

}

// Since we want elements in same order,

// we traverse array again and print

// those elements that appear more than

// once.

for (var i = 0; i < n; i++) {

if (mp.get(arr[i]) > 1) {

document.write( arr[i] + " ");

// This is tricky, this is done

// to make sure that the current

// element is not printed again

mp.set(arr[i], 0);

}

}
}
// Driver code

var arr = [ 12, 10, 9, 45, 2, 10, 10, 45 ];

var n = arr.length;
printRepeating(arr, n);
</script>

Output: 10 45

Time Complexity: O(n) under the assumption that hash insert and search functions work in O(1) time.

Method #2:Using Built-in Python functions:

Count all the frequencies of all elements using Counter() function.
Traverse in this frequency dictionary and print all keys whose value is greater than 1.

Below is the implementation of above approach:

Python3

# Python3 program to print
# all repeating elements

from collections import Counter

def printRepeating(arr, n):

# Counting frequencies

freq = Counter(arr)

# Traverse the freq dictionary and

# print all the keys whose value

# is greater than 1

for i in freq:

if(freq[i] > 1):

print(i, end=" ")
# Driver code

arr = [12, 10, 9, 45,

2, 10, 10, 45]

n = len(arr)
printRepeating(arr, n)
# This code is contributed by vikkycirus

Output:

10 45

Article Tags :

Arrays

Hash

Amazon

cpp-unordered_map

Practice Tags :

Amazon

Arrays

Hash

Read Full Article

8. Compound statements¶

Compound statements contain (groups of) other statements; they affect or control the execution of those other statements in some way. In general, compound statements span multiple lines, although in simple incarnations a whole compound statement may be contained in one line.

The if, while and for statements implement traditional control flow constructs. try specifies exception handlers and/or cleanup code for a group of statements, while the with statement allows the execution of initialization and finalization code around a block of code. Function and class definitions are also syntactically compound statements.

A compound statement consists of one or more ‘clauses.’ A clause consists of a header and a ‘suite.’ The clause headers of a particular compound statement are all at the same indentation level. Each clause header begins with a uniquely identifying keyword and ends with a colon. A suite is a group of statements controlled by a clause. A suite can be one or more semicolon-separated simple statements on the same line as the header, following the header’s colon, or it can be one or more indented statements on subsequent lines. Only the latter form of a suite can contain nested compound statements; the following is illegal, mostly because it wouldn’t be clear to which if clause a following else clause would belong:

if test1: if test2: print(x)

Also note that the semicolon binds tighter than the colon in this context, so that in the following example, either all or none of the print() calls are executed:

if x < y < z: print(x); print(y); print(z)

Summarizing:

Note that statements always end in a NEWLINE possibly followed by a DEDENT. Also note that optional continuation clauses always begin with a keyword that cannot start a statement, thus there are no ambiguities (the ‘dangling else’ problem is solved in Python by requiring nested if statements to be indented).

The formatting of the grammar rules in the following sections places each clause on a separate line for clarity.

inspect — Inspect live objects¶

Source code: Lib/inspect.py

The inspect module provides several useful functions to help get information about live objects such as modules, classes, methods, functions, tracebacks, frame objects, and code objects. For example, it can help you examine the contents of a class, retrieve the source code of a method, extract and format the argument list for a function, or get all the information you need to display a detailed traceback.

There are four main kinds of services provided by this module: type checking, getting source code, inspecting classes and functions, and examining the interpreter stack.

Python Lists

Lists are one of the four built-in data structures in Python. Other data structures that you might know are tuples, dictionaries, and sets. A list in Python is different from, for example, int or bool, in the sense that it's a compound data type: you can group values in lists. These values don't need to be of the same type: they can be a combination of boolean, String, integer, float values.

List literals are a collection of data surrounded by brackets, and the elements are separated by a comma. The list is capable of holding various data types inside it, unlike arrays.

For example, let's say you want to build a list of courses then you could have:

courses = ['statistics', 'python', 'linear algebra']

Note that lists are ordered collections of items or objects. This makes lists in Python "sequence types", as they behave like a sequence. This means that they can be iterated using for loops. Other examples of sequences are Strings, tuples, or sets.

Lists are similar in spirit to strings you can use the len() function and square brackets [ ] to access the data, with the first element indexed at 0.

Tip: if you'd like to know more, test, or practice your knowledge of Python lists, you can do so by going through the most common questions on Python lists here.

Now, on a practical note: you build up a list with two square brackets (start bracket and end bracket). Inside these brackets, you'll use commas to separate your values. You can then assign your list to a variable. The values that you put in a Python list can be of any data type, even lists!

Take a look at the following example of a list:

# Assign integer values to `a` and `b` a = 4 b = 9 # Create a list with the variables `a` and `b` count_list = [1,2,3,a,5,6,7,8,b,10] count_list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Note that the values of a and b have been updated in the list count_list.

Creation of List

A list is created by placing all the items inside a square bracket [] separated by commas. It can have an infinite number of elements having various data types like string, integer, float, etc.

list1 = [1,2,3,4,5,6] #with same data type list1 [1, 2, 3, 4, 5, 6] list2 = [1, 'Aditya', 2.5] #with mixed data type list2 [1, 'Aditya', 2.5]

Accessing Elements from a List

Elements from the list can be accessed in various ways:

Index based: You can use the index operator to access the element from a list. In python, the indexing starts from 0 and ends at n-1, where n is the number of elements in the list.
Indexing can be further categorized into positive and negative indexing.

index = [1,2,3,4,5] index[0], index[4] #positive indexing (1, 5) index[5] #this will give an error since there is no element at index 5 in the list --------------------------------------------------------------------------- IndexError Traceback (most recent call last) in ----> 1 index[5] #this will give an error since there is no element at index 5 in the list IndexError: list index out of range index[-1], index[-2] #negative indexing, here -1 means select first element from the last (5, 4)

Slice based: This is helpful when you want to access a sequence/range of elements from the list. The semicolon (:) is used as a slice operator to access the elements.

index[:3], index[2:] ([1, 2, 3], [3, 4, 5])

List Methods

Some of the most commonly used list methods are :

Lists and Tuples in Python

by John Sturtz basics python

Mark as Completed

Tweet Share Email

Table of Contents

Remove ads

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Lists and Tuples in Python

Lists and tuples are arguably Python’s most versatile, useful data types. You will find them in virtually every nontrivial Python program.

Here’s what you’ll learn in this tutorial: You’ll cover the important characteristics of lists and tuples. You’ll learn how to define them and how to manipulate them. When you’re finished, you should have a good feel for when and how to use these object types in a Python program.

Take the Quiz: Test your knowledge with our interactive “Python Lists and Tuples” quiz. Upon completion you will receive a score so you can track your learning progress over time:

Take the Quiz »