Understanding the "Is" Operator

Understanding the is operator

You misunderstood what the is operator tests. It tests if two variables point the same object, not if two variables have the same value.

From the documentation for the is operator:

The operators is and is not test for object identity: x is y is true if and only if x and y are the same object.

Use the == operator instead:

print(x == y)

This prints True. x and y are two separate lists:

x[0] = 4
print(y)  # prints [1, 2, 3]
print(x == y)   # prints False

If you use the id() function you'll see that x and y have different identifiers:

>>> id(x)
4401064560
>>> id(y)
4401098192

but if you were to assign y to x then both point to the same object:

>>> x = y
>>> id(x)
4401064560
>>> id(y)
4401064560
>>> x is y
True

and is shows both are the same object, it returns True.

Remember that in Python, names are just labels referencing values; you can have multiple names point to the same object. is tells you if two names point to one and the same object. == tells you if two names refer to objects that have the same value.

Understanding the and operator - Why is None and None not False?

According to the official documentation:

help('and')

[...] The expression "x and y" first evaluates x; if x is false,
its value is returned; otherwise, y is evaluated and the resulting
value is returned. [...]

can anyone explain the mechanism of working of is operator in list?

is operator checks if both the operands refer to the same object or not. In this l1 and l2 are two different objects, so, it returns False.

Please note that two list instances don't refer to the same object just because they have the same contents.

You can use id to check if both are reference to same object. Check the below code. In this case, you can see that l1 and l2 are different objects, whereas l2 and l3 refer to the same object. Please note that use of == operator in the below code and how it returns True if the contents of the list are same.

l1=[1,2,3]
l2=[1,2,3]
l3 = l2
print("l1 = %s" %(id(l1)))
print("l2 = %s" %(id(l2)))
print("l3 = %s" %(id(l3)))
print(l1 is l2)
print(l2 is l3)
print(l1 == l2)
print(l2 == l3)

Output:

l1 = 139839807952728
l2 = 139839807953808
l3 = 139839807953808
False
True
True
True

Note: If you want to compare two objects based on their content, use the == operator

Understanding the '&' operator

You seems to have trouble understanding how integers are stored in memory. Take 5411 as example.

5411 = 1010100100011

this number 13 binary digits has however, since an int is 32-bit, it must be pad to 32 digits

5411 = 00000000 00000000 00010101 00100011

On a little endian machine (x86, ARM by default), the least significant bytes are stored in the front, so in the memory:

00100011   00010101    00000000    00000000
^
c          c + 1       c + 2       c + 3
ip

Therefore, *c should return 00100011 i.e. 35 ('#').

Understanding the <$> operator

However is Cop a function in this case? I know that Cop is a value constructor that takes two arguments of type Res.

Yes, Cop is a function with two parameters. It has the type Cop :: Res -> Res -> Res.

If one argument of type Res is passed to Cop, this would return another function which takes a value of type Res.

Yes. Cop <$> findmatch a :: Functor f => f (Res -> Res)

What would the type of the result that is returned by this second function that resulted from the partial application.

It's the type of the value that is constructed by the Cop constructor: it's constructing Res values.

Understanding the | operator in scala

| is the bitwise OR operator:

val a = 0 | 1
a: Int = 1

00  0
01  1
-----
01  1

val a = 0 | 1 | 2 | 3
a: Int = 3

00  0
01  1
10  2
11  3
------
11  3

val a = 0 | 1 | 2 | 3 | 4
a: Int = 7

000  0
001  1
010  2
011  3
100  4
-------
111  7

Understanding == operator for Object Comparison in Java

It is specified that comparing reference types which cannot be converted between them must result in a compile error. See the JLS chapter 15.21.3:

15.21.3. Reference Equality Operators == and !=

[...]

It is a compile-time error if it is impossible to convert the type of either operand to the type of the other by a casting conversion (§5.5). The run-time values of the two operands would necessarily be unequal (ignoring the case where both values are null).

Understanding the arrow operator -> in C

pnt->second is a shorthand for (*pnt).second which means "take the struct pointed to by pnt and from that struct, get the element second".

---

Related Topics