Declaring a variable of unknown type in Python?

Are you sure this is for Python beginners? For me, the cleanest way to do this is with reduce () and lambda, both of which are not typical beginner tools, and sometimes discouraging even experienced Python programmers:

def multiplyItemsByFour(argsList):
    if not argsList:
        return None
    newItems = [item * 4 for item in argsList]
    return reduce(lambda x, y: x + y, newItems)

      

        
        
        
      

    

Like Alex Martelli, I quickly checked the empty list at the beginning, which returns None. Please note, if you are using Python 3, you must import functools to use reduce ().

Basically, the reduce (lambda ...) solution is very similar to other suggestions for setting up an accumulator using the first input element and then processing the rest of the input; but just more concise.

You don't need to declare variable types in python; a variable has a type regardless of what is assigned to it.

EDIT:

To fix the re-expression issue, try the following:

def multiplyItemsByFour(argsList):

output = argsList.pop(0) * 4

for arg in argsList:
        output += arg * 4

return output

      

        
        
        
      

    

(This is probably not the most pythonic way to do it, but it should at least start with your output variable as the correct type, assuming the entire list is of the same type)

Python is dynamically typed, you don't need to declare the type of a variable, because a variable has no type, only values ​​matter. (Any variable can store any value; a value never changes its type during its existence.)

def do_something(x):
    return x * 5

      

        
        
        
      

    

This will work for whatever x

you pass it to, the actual result depending on what type the value is in x

. If it x

contains a number, it just does a regular multiplication, if it contains a string, the string will repeat five times in a row, for lists, etc. She will repeat the list five times, and so on. For custom types (classes), it depends on whether the class has an operation defined for the multiplication operator.

You have provided these ins and outs:

Input: ('a', 'b') Output: 'aaaabbbb' Input: (2,3,4) Output: 36

I don't want to write a solution to your homework for you, but I want to point you in the right direction. But I'm still not sure I understand what the problem is, because the problem I understand seems a bit tricky to introduce to a Python class.

The easiest way to solve this requires the arguments to be passed in a list. Then you can look at the first item in the list and work with it. Here is a function that requires the caller to pass a list of two elements:

def handle_list_of_len_2(lst):
   return lst[0] * 4 + lst[1] * 4

      

        
        
        
      

    

Now, how can we do this across two elements? Well, in your example code, you weren't sure what to assign to your output to a variable. How about assigning lst [0]? Then it always has the correct type. Then you can iterate over all other items in lst and accumulate in your output variable using + = as you wrote. If you don't know how to loop over a list of items but miss the first thing on the list, do a Google search for "python snippet list".

Now, how can we make this not require the user to collect everything into a list, but just call a function? What we really want is some way to take whatever arguments the user wants to pass to the function and make a list of them. There may be special syntax for declaring a function where you tell Python that you just want the arguments to be included in the list. You can check out a good tutorial and see what it says on how to define a function.

Now that we've covered (in general) how to accumulate a response using + =, let's look at other ways to accumulate a response. If you know how to use a list comprehension, you can use one of these to return a new list based on the list of arguments, with the multiplication being performed on each argument; you could somehow narrow the list down to one element and return it. Python 2.3 and newer have a built-in feature called sum()

and you can read about it. [EDIT: Oh drat, sum()

only works on numbers. See the note added at the end.]

Hope this helps. If you are still very confused, I suggest you contact your teacher and ask for clarification. Good luck.

PS Python 2.x has a built-in feature called reduce()

and can be implemented sum()

with reduce()

. However, the creator of Python thinks it's better to use sum()

, and in fact he removed it reduce()

from Python 3.0 (well, he moved it into a module called functools

).

PPS If you find that working on the list is working, here's one more thing to think about. If you use a list comprehension and then pass the result in sum()

, you are creating a list that will be used once and then discarded. Wouldn't it be neat if we could get the result, but instead of creating the entire list and then discarding it, we could just use the function sum()

on the list items as quickly as they are generated? You can read the following: Generator Expressions and List Comprehension

EDIT: Oh drat, I assumed the built-in Python sum()

would use duck typing. In fact, it's only documented to work with numbers. I am disappointed! I will need to search and see if there has been any discussion about this and see why they did it the way they did it; they probably had good reasons. Meanwhile, you can also use your + = solution. Excuse me.

EDIT: Ok, after reading the other answers, I now notice two ways suggested to remove the first item in the list.

For simplicity's sake, because you look like a Python beginner, I suggested simply using output = lst[0]

and then using list slicing to skip the previous item in the list. However, Wooble suggested using in his answer output = lst.pop(0)

, which is a very clean solution: it gets the null thing in the list, and then you can just loop over the list and automatically skip the null thing. However, this "mutates" the list! It is better if a function like this has no "side effects" like changing the list passed to it. (If the list is not a special list created just for this function call, for example in list*args

.) Another way is to use the "list slice" trick to make a copy of the list in which the first item was removed. Alex Martelli provided an example of how to make an "iterator" using a Python function called iter()

and then using an iterator to get the "next" thing. Since the iterator hasn't been used yet, the next thing is the null thing in the list. This isn't really a beginner, but it's the most elegant way to do it in Python; you can pass a really huge list to a function and Alex Martelli's solution won't mutate the list or waste memory by making a copy of the list.

No need to test objects, just multiply them!

'this is a string' * 6
14 * 6
[1,2,3] * 6

      

        
        
        
      

    

everything just work

Try the following:

def timesfourlist(list):
 nextstep = map(times_four, list)
 sum(nextstep)

      

        
        
        
      

    

map executes the function passed in each element of the list (returns a new list) and then sums + = in the list.

If you just want to fill a gap in your code, you can try setting object=arglist[0].__class__()

to give it the null equivalent value of that class.

>>> def multiplyItemsByFour(argsList):
    output = argsList[0].__class__()
    for arg in argsList:
            output += arg * 4
    return output

>>> multiplyItemsByFour('ab')
'aaaabbbb'
>>> multiplyItemsByFour((2,3,4))
36
>>> multiplyItemsByFour((2.0,3.3))
21.199999999999999

      

        
        
        
      

    

This will fail if the list is empty, but you can check this case at the beginning of the function and return whatever you think you want.