dividing by list not possible?

[SchroedingersLion]

Greetings!

I was wondering why it is possible to create a new list by multiplying or adding constants to an old list, but not to create a new list through division of a float by an old list.

import numpy as np
import matplotlib.pyplot as plt

N=500;
R=0.5;

pressure_list=[16,25,40]
expectation_val_V=[445.186, 412.284, 390.5]
expectation_eta=(float(4)/3 *np.pi *R**3)/expectation_val_V

eta=np.linspace(0.5,0.70,100000)
p_red=6/(np.pi)*eta*( (12-3*(4*(1-(3*np.sqrt(2))/(np.pi)*eta)))/(4*(1-(3*np.sqrt(2))/(np.pi)*eta)) 
            +2.557696+0.1253077*(4*(1-(3*np.sqrt(2))/(np.pi)*eta)) 
            +0.1762393*(4*(1-(3*np.sqrt(2))/(np.pi)*eta))**2 
            -1.053308*(4*(1-(3*np.sqrt(2))/(np.pi)*eta))**3
            +2.818621*(4*(1-(3*np.sqrt(2))/(np.pi)*eta))**4 
            -2.921934*(4*(1-(3*np.sqrt(2))/(np.pi)*eta))**5
            +1.118413*(4*(1-(3*np.sqrt(2))/(np.pi)*eta))**6)


plt.plot(eta,p_red)
plt.show()

In this example, p_red is well defined. However, expectation_eta cannot be created. It gives the error 'TypeError: unsupported operand type(s) for /: 'float' and 'list''
Isn't this a bit contradictory from a programming point of view?

Regards!

[buran]

Isn't this a bit contradictory from a programming point of view?

No, it depends on the implementation for a particular type/object. i.e. the creators of numpy implemented this functionality for numpy array object (that is what np.linspace returns). The python core developers did not implement that functionality for the list. You can use list comprehension instead. Or convert expectation_val_V to numpy array.
Also note that when you multiply a list by int constant, the new list is not constructed by multiplying individual elements of the original list.

[ichabod801]

Also, I think the numpy authors were trying to emulate matrix operations. Mathematicians don't divide matrices, mainly because matrix multiplication is not commutative, leading to an ambiguous definition of the inverse operation.

[volcano63]

Also, I think the numpy authors were trying to emulate matrix operations. Mathematicians don't divide matrices, mainly because matrix multiplication is not commutative, leading to an ambiguous definition of the inverse operation.

Dividing and multiplying numpy.array is possible

Output:
In [19]: N=500
    ...: R=0.5
    ...: 
    ...: pressure_list=np.array([16,25,40])
    ...: expectation_val_V=np.array([445.186, 412.284, 390.5])
    ...: expectation_eta=(4/3 *np.pi *R**3)/expectation_val_V
    ...: 
    ...: 

In [20]: expectation_eta
Out[20]: array([0.00117613, 0.00127   , 0.00134084])

Elements of numpy.array all have the same type

Output:
In [24]: pressure_list.dtype
Out[24]: dtype('int64')

and if the dtype of an array allows for math operation (as long as shapes of arrays are compatible) - you are free to apply math operations on arrays.

Output:
In [51]: np.reshape(np.arange(6), (2, 3)) * np.arange(6, 9)
Out[51]: 
array([[ 0,  7, 16],
       [18, 28, 40]])

---

list in Python is agnostic of the type of elements - which (element(s)) may be replaced by element(s) of another type dynamically, therefor math operations between lists (excluding addition - below) are meaningless.

List addition is basically interpreted as list concatenation

Output:
In [22]: list.__add__?
Signature:      list.__add__(self, value, /)
Call signature: list.__add__(*args, **kwargs)
Type:           wrapper_descriptor
String form:    <slot wrapper '__add__' of 'list' objects>
Namespace:      Python builtin
Docstring:      Return self+value.

---

PS

numeric numpy.array may also be multiplied or divided by a scalar digital value; power op is applicable too

Output:
In [52]: np.arange(6, 9) ** 2
Out[52]: array([36, 49, 64])

---

PPS
WHat is inefficient - from any point of view - is the calculation of the expression below several times; redundant brackets - together with lack of spaces - reduce readability too
(4*(1-(3*np.sqrt(2))/(np.pi)*eta))

[SchroedingersLion]

Thank you guys! Almost forgot about the thread, sorry!

@volcano63
So if I want to use these elementwise array operations, I have to make sure that I am using an actual "numpy array" and not the standard Python lists.

PPS
WHat is inefficient - from any point of view - is the calculation of the expression below several times; redundant brackets - together with lack of spaces - reduce readability too

Yeah sorry, I added the brackets because I did not know how well Python deals with the order of mathematical operation:
Can I write it like this?

4*(1 - 3*np.sqrt(2)/np.pi *eta)

And yeah, I should have used a variable instead, thanks for the hint!

[volcano63]

Thank you guys! Almost forgot about the thread, sorry!

@volcano63
So if I want to use these elementwise array operations, I have to make sure that I am using an actual "numpy array" and not the standard Python lists.

Right, one of the operators must be numpy array; another may be either an array of compatible shape or a scalar numeric value

Output:
In [11]: a =  np.arange(6, 9)

In [12]: print(9 / a, a / 9, a ** 2, 2 ** a, sep='\n')
[1.5        1.28571429 1.125     ]
[0.66666667 0.77777778 0.88888889]
[36 49 64]
[ 64 128 256]

---

PPS
WHat is inefficient - from any point of view - is the calculation of the expression below several times; redundant brackets - together with lack of spaces - reduce readability too

Yeah sorry, I added the brackets because I did not know how well Python deals with the order of mathematical operation:
Can I write it like this?

4*(1 - 3*np.sqrt(2)/np.pi *eta)

And yeah, I should have used a variable instead, thanks for the hint!

PEP-8 expression guidlines recommend - among other things - to surround operators by single spaces, so the following form is fully compatible, and sparse enough to be readable

4 * (1 - 3 * np.sqrt(2) / np.pi * eta)