# Python in Functional Style: How to add 2 lists of integers without using loops

Usually you’d add a list of integers this way:

``````a = [2, 2, 2, 2]
b = [2, 2, 2, 2]
c = []
for i in range(len(a)):
c.append(a[i] + b[i])``````

You can do it functionally without any loops in different ways:

#### Using map and a lambda that adds them up

``c = list(map(lambda x,y: x+y, a, b))``

or you can import the add operator as a named function

``````from operator import add

#### Ever zipped two lists into a list of tuples?

There’s another more convoluted way if you want to play with “zip”.

Imagine a jacket zipper and the teeth on each side of the zipper is one element on each one of the list.

When you zip the lists a and b, you end up with a list of tuples of matching elements from the given lists.

``````>>> list(zip(a,b))
[(2, 2), (2, 2), (2, 2), (2, 2)]``````

you could now map a function to add the elements within each tuple on that list.

``````>>> list(map(lambda tup: tup[0]+tup[1], zip(a,b)))
[4, 4, 4, 4]``````

Notice how we don’t convert to list after zip, we can work directly with the zip iterator, we only convert to list with the final map iterator.

Python 2 & 3 Note:

In Python 2 it’s not necessary to use list(), the map() and zip() methods return lists there. But stay away from Python 2, a lot of projects are now discontinuing support.

# How to create a list that holds different object types using `void*` in C.

I remember being in school back around 1998 and not knowing enough about C to do this. After coding in other languages, then going back to C++ and understanding at a lower level how references and pointers work, this was pretty easy to figure out.

In this exercise I store elements of different types in a forward linked list.
In order to know what to dereference as I iterate through the list’s elements, I’ve put a “.type” field, which has an int value representing the type of the object stored.

The “.value” is simply a `void*`, which lets me store a pointer of any kind, and it works pretty well.

Here’s the code for your enjoyment, I hope this is useful to C apprentices.

The example shows how you can store native types like int, or more complex `char*` or even a `struct person*` (which is the more useful probably to your purposes)

It’s a good exercise to see the uses of the “address of” operator “&”, which is used to initialize pointers (the ‘&’ can also be used differently to create references, which I call in my mind as ‘aliases’, but this is not shown in this example)

I also play with a not so popular syntax to access a pointer’s sub-fields:

`(*myPointer).structField == myPointer-&gt;structField`

to teach you that the `-&gt;` is a short hand for dereferencing a pointer and accessing one of its fields.

``````//
// An exercise to play with a struct that stores anything using a void* field.
//

#include <stdio.h>

#define TRUE 1

int TYPE_INT = 0;
int TYPE_STRING = 1;
int TYPE_BOOLEAN = 2;
int TYPE_PERSON = 3;

struct node {
struct node* next;
int type;
void* value;
};

struct person {
char* name;
int age;
};

int main(int args, char **argv) {

struct person aPerson;
aPerson.name = "Angel";
aPerson.age = 35;

// Define a linked list of objects.
// We use that .type field to know what we're dealing
// with on every iteration. On .value we store our values.
struct node nodes[] = {
{ .next = &nodes[1], .type = TYPE_INT    , .value=1                   },
{ .next = &nodes[2], .type = TYPE_STRING , .value="anyfing, anyfing!" },
{ .next = &nodes[3], .type = TYPE_PERSON , .value=&aPerson            },
{ .next = NULL     , .type = TYPE_BOOLEAN, .value=TRUE                }
};

// We iterate through the list
for ( struct node *currentNode = &nodes[0]; currentNode;  currentNode = currentNode->next) {
int currentType = (*currentNode).type;
if (currentType == TYPE_INT) {
printf("%s: %dn", "- INTEGER", (*currentNode).value); // just playing with syntax, same as currentNode->value
} else if (currentType == TYPE_STRING) {
printf("%s: %sn", "- STRING", currentNode->value);
} else if (currentType == TYPE_BOOLEAN) {
printf("%s: %dn", "- BOOLEAN (true:1, false:0)", currentNode->value);
} else if (currentType == TYPE_PERSON) {
// since we're using void*, we end up with a pointer to struct person, which we *dereference
// into a struct in the stack.
struct person currentPerson = *(struct person*) currentNode->value;
printf("%s: %s (%d)n","- TYPE_PERSON", currentPerson.name, currentPerson.age);
}
}

return 0;
}``````

The output is this:

``````- INTEGER: 1
- STRING: anyfing, anyfing!
- TYPE_PERSON: Angel (35)
- BOOLEAN (true:1, false:0): 1
``````