Question: I have an app in which the main view is a `PopupWindow` with a couple of `ImageViews` and an `EditText` on top of them. My problem is when I enter a very long text and the text box expands down and pushing the image views out of the view and I can't see them, and in order to see them back I need to delete some text.

What is the proper way of overcoming this?

thanks.

Answer: 
This can probably best be shown:

```
>>> a = [1, 2, 3]
>>> id(a)
45556280
>>> del a[:]
>>> id(a)
45556280
>>> b = [4, 5, 6]
>>> id(b)
45556680
>>> b = []
>>> id(b)
45556320

```

When you do `a[:]` you are referring to all elements within the list "assigned" to `a`. The `del` statement removes references to objects. So, doing `del a[:]` is saying "remove all references to objects from within the list assigned to `a`". The list itself has not changed. We can see this with the id function, which gives us a number representing an object in memory. The id of the list before using `del` and after remains the same, indicating the same list object is assigned to `a`.

On the other hand, when we assign a non-empty list to `b` and then assign a new *empty* list to `b`, the id changes. This is because we have actually moved the `b` reference from the existing `[4, 5, 6]` list to the new `[]` list.

Beyond just the identity of the objects you are dealing with, there are other things to be aware of:

```
>>> a = [1, 2, 3]
>>> b = a
>>> del a[:]
>>> print a
[]
>>> print b
[]

```

Both `b` and `a` refer to the same list. Removing the elements from the `a` list without changing the list itself mutates the list in place. As `b` references the same object, we see the same result there. If you did `a = []` instead, then `a` will refer to a new empty list while `b` continues to reference the `[1, 2, 3]` list.
```
>>> list1 = [1,2,3,4,5]
>>> list2 = list1

```

**To get a better understanding, let us see with the help of pictures what happens internally.** 

```
>>> list1 = [1,2,3,4,5]

```

This creates a list object and assigns it to `list1`.
![Initialization of list1 in memory](https://i.stack.imgur.com/zkQ8F.png) 

```
>>> list2 = list1

```

The list object which `list1` was referring to is also assigned to `list2`.
![](https://i.stack.imgur.com/IM5Ra.png) 

Now, lets look at the methods to empty an list and what actually happens internally. 

**METHOD-1: Set to empty list [] :** 

```
>>> list1 = []
>>> list2
[1,2,3,4,5]

```

![Set list1 to empty list](https://i.stack.imgur.com/FQWAL.png)

This does not delete the elements of the list but deletes the reference to the list. So, `list1` now points to an empty list but all other references will have access to that old `list1`.  

This method just creates a new list object and assigns it to `list1`. Any other references will remain.

**METHOD-2: Delete using slice operator[:] :**

```
>>> del list1[:]
>>> list2
[]

```

![Delete all elements of list1 using slice operator](https://i.stack.imgur.com/qSgVB.png)

When we use the slice operator to delete all the elements of the list, then all the places where it is referenced, it becomes an empty list. So `list2` also becomes an empty list.