# “Cloning” row or column vectors

| | | | |

Sometimes it is useful to "clone" a row or column vector to a matrix. By cloning I mean converting a row vector such as

``````[1, 2, 3]
``````

Into a matrix

``````[[1, 2, 3],
[1, 2, 3],
[1, 2, 3]]
``````

or a column vector such as

``````[[1],
[2],
[3]]
``````

into

``````[[1, 1, 1]
[2, 2, 2]
[3, 3, 3]]
``````

In MATLAB or octave this is done pretty easily:

`````` x = [1, 2, 3]
a = ones(3, 1) * x
a =

1   2   3
1   2   3
1   2   3

b = (x") * ones(1, 3)
b =

1   1   1
2   2   2
3   3   3
``````

I want to repeat this in numpy, but unsuccessfully

``````In [14]: x = array([1, 2, 3])
In [14]: ones((3, 1)) * x
Out[14]:
array([[ 1.,  2.,  3.],
[ 1.,  2.,  3.],
[ 1.,  2.,  3.]])
# so far so good
In [16]: x.transpose() * ones((1, 3))
Out[16]: array([[ 1.,  2.,  3.]])
# DAMN
# I end up with
In [17]: (ones((3, 1)) * x).transpose()
Out[17]:
array([[ 1.,  1.,  1.],
[ 2.,  2.,  2.],
[ 3.,  3.,  3.]])
``````

Why wasn"t the first method (`In [16]`) working? Is there a way to achieve this task in python in a more elegant way?

## "Cloning" row or column vectors find: Questions

Finding the index of an item in a list

Given a list `["foo", "bar", "baz"]` and an item in the list `"bar"`, how do I get its index (`1`) in Python?

3740

``````>>> ["foo", "bar", "baz"].index("bar")
1
``````

Reference: Data Structures > More on Lists

# Caveats follow

Note that while this is perhaps the cleanest way to answer the question as asked, `index` is a rather weak component of the `list` API, and I can"t remember the last time I used it in anger. It"s been pointed out to me in the comments that because this answer is heavily referenced, it should be made more complete. Some caveats about `list.index` follow. It is probably worth initially taking a look at the documentation for it:

``````list.index(x[, start[, end]])
``````

Return zero-based index in the list of the first item whose value is equal to x. Raises a `ValueError` if there is no such item.

The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.

## Linear time-complexity in list length

An `index` call checks every element of the list in order, until it finds a match. If your list is long, and you don"t know roughly where in the list it occurs, this search could become a bottleneck. In that case, you should consider a different data structure. Note that if you know roughly where to find the match, you can give `index` a hint. For instance, in this snippet, `l.index(999_999, 999_990, 1_000_000)` is roughly five orders of magnitude faster than straight `l.index(999_999)`, because the former only has to search 10 entries, while the latter searches a million:

``````>>> import timeit
>>> timeit.timeit("l.index(999_999)", setup="l = list(range(0, 1_000_000))", number=1000)
9.356267921015387
>>> timeit.timeit("l.index(999_999, 999_990, 1_000_000)", setup="l = list(range(0, 1_000_000))", number=1000)
0.0004404920036904514

``````

## Only returns the index of the first match to its argument

A call to `index` searches through the list in order until it finds a match, and stops there. If you expect to need indices of more matches, you should use a list comprehension, or generator expression.

``````>>> [1, 1].index(1)
0
>>> [i for i, e in enumerate([1, 2, 1]) if e == 1]
[0, 2]
>>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1)
>>> next(g)
0
>>> next(g)
2
``````

Most places where I once would have used `index`, I now use a list comprehension or generator expression because they"re more generalizable. So if you"re considering reaching for `index`, take a look at these excellent Python features.

## Throws if element not present in list

A call to `index` results in a `ValueError` if the item"s not present.

``````>>> [1, 1].index(2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 2 is not in list
``````

If the item might not be present in the list, you should either

1. Check for it first with `item in my_list` (clean, readable approach), or
2. Wrap the `index` call in a `try/except` block which catches `ValueError` (probably faster, at least when the list to search is long, and the item is usually present.)

3740

One thing that is really helpful in learning Python is to use the interactive help function:

``````>>> help(["foo", "bar", "baz"])
Help on list object:

class list(object)
...

|
|  index(...)
|      L.index(value, [start, [stop]]) -> integer -- return first index of value
|
``````

which will often lead you to the method you are looking for.

3740

The majority of answers explain how to find a single index, but their methods do not return multiple indexes if the item is in the list multiple times. Use `enumerate()`:

``````for i, j in enumerate(["foo", "bar", "baz"]):
if j == "bar":
print(i)
``````

The `index()` function only returns the first occurrence, while `enumerate()` returns all occurrences.

As a list comprehension:

``````[i for i, j in enumerate(["foo", "bar", "baz"]) if j == "bar"]
``````

Here"s also another small solution with `itertools.count()` (which is pretty much the same approach as enumerate):

``````from itertools import izip as zip, count # izip for maximum efficiency
[i for i, j in zip(count(), ["foo", "bar", "baz"]) if j == "bar"]
``````

This is more efficient for larger lists than using `enumerate()`:

``````\$ python -m timeit -s "from itertools import izip as zip, count" "[i for i, j in zip(count(), ["foo", "bar", "baz"]*500) if j == "bar"]"
10000 loops, best of 3: 174 usec per loop
\$ python -m timeit "[i for i, j in enumerate(["foo", "bar", "baz"]*500) if j == "bar"]"
10000 loops, best of 3: 196 usec per loop
``````

## "Cloning" row or column vectors mean: Questions

Meaning of @classmethod and @staticmethod for beginner?

By user1632861

Could someone explain to me the meaning of `@classmethod` and `@staticmethod` in python? I need to know the difference and the meaning.

As far as I understand, `@classmethod` tells a class that it"s a method which should be inherited into subclasses, or... something. However, what"s the point of that? Why not just define the class method without adding `@classmethod` or `@staticmethod` or any `@` definitions?

tl;dr: when should I use them, why should I use them, and how should I use them?

1726

Though `classmethod` and `staticmethod` are quite similar, there"s a slight difference in usage for both entities: `classmethod` must have a reference to a class object as the first parameter, whereas `staticmethod` can have no parameters at all.

## Example

``````class Date(object):

def __init__(self, day=0, month=0, year=0):
self.day = day
self.month = month
self.year = year

@classmethod
def from_string(cls, date_as_string):
day, month, year = map(int, date_as_string.split("-"))
date1 = cls(day, month, year)
return date1

@staticmethod
def is_date_valid(date_as_string):
day, month, year = map(int, date_as_string.split("-"))
return day <= 31 and month <= 12 and year <= 3999

date2 = Date.from_string("11-09-2012")
is_date = Date.is_date_valid("11-09-2012")
``````

## Explanation

Let"s assume an example of a class, dealing with date information (this will be our boilerplate):

``````class Date(object):

def __init__(self, day=0, month=0, year=0):
self.day = day
self.month = month
self.year = year
``````

This class obviously could be used to store information about certain dates (without timezone information; let"s assume all dates are presented in UTC).

Here we have `__init__`, a typical initializer of Python class instances, which receives arguments as a typical `instancemethod`, having the first non-optional argument (`self`) that holds a reference to a newly created instance.

Class Method

We have some tasks that can be nicely done using `classmethod`s.

Let"s assume that we want to create a lot of `Date` class instances having date information coming from an outer source encoded as a string with format "dd-mm-yyyy". Suppose we have to do this in different places in the source code of our project.

So what we must do here is:

1. Parse a string to receive day, month and year as three integer variables or a 3-item tuple consisting of that variable.
2. Instantiate `Date` by passing those values to the initialization call.

This will look like:

``````day, month, year = map(int, string_date.split("-"))
date1 = Date(day, month, year)
``````

For this purpose, C++ can implement such a feature with overloading, but Python lacks this overloading. Instead, we can use `classmethod`. Let"s create another "constructor".

``````    @classmethod
def from_string(cls, date_as_string):
day, month, year = map(int, date_as_string.split("-"))
date1 = cls(day, month, year)
return date1

date2 = Date.from_string("11-09-2012")
``````

Let"s look more carefully at the above implementation, and review what advantages we have here:

1. We"ve implemented date string parsing in one place and it"s reusable now.
2. Encapsulation works fine here (if you think that you could implement string parsing as a single function elsewhere, this solution fits the OOP paradigm far better).
3. `cls` is an object that holds the class itself, not an instance of the class. It"s pretty cool because if we inherit our `Date` class, all children will have `from_string` defined also.

Static method

What about `staticmethod`? It"s pretty similar to `classmethod` but doesn"t take any obligatory parameters (like a class method or instance method does).

Let"s look at the next use case.

We have a date string that we want to validate somehow. This task is also logically bound to the `Date` class we"ve used so far, but doesn"t require instantiation of it.

Here is where `staticmethod` can be useful. Let"s look at the next piece of code:

``````    @staticmethod
def is_date_valid(date_as_string):
day, month, year = map(int, date_as_string.split("-"))
return day <= 31 and month <= 12 and year <= 3999

# usage:
is_date = Date.is_date_valid("11-09-2012")
``````

So, as we can see from usage of `staticmethod`, we don"t have any access to what the class is---it"s basically just a function, called syntactically like a method, but without access to the object and its internals (fields and another methods), while classmethod does.

1726

Rostyslav Dzinko"s answer is very appropriate. I thought I could highlight one other reason you should choose `@classmethod` over `@staticmethod` when you are creating an additional constructor.

In the example above, Rostyslav used the `@classmethod` `from_string` as a Factory to create `Date` objects from otherwise unacceptable parameters. The same can be done with `@staticmethod` as is shown in the code below:

``````class Date:
def __init__(self, month, day, year):
self.month = month
self.day   = day
self.year  = year

def display(self):
return "{0}-{1}-{2}".format(self.month, self.day, self.year)

@staticmethod
def millenium(month, day):
return Date(month, day, 2000)

new_year = Date(1, 1, 2013)               # Creates a new Date object
millenium_new_year = Date.millenium(1, 1) # also creates a Date object.

# Proof:
new_year.display()           # "1-1-2013"
millenium_new_year.display() # "1-1-2000"

isinstance(new_year, Date) # True
isinstance(millenium_new_year, Date) # True
``````

Thus both `new_year` and `millenium_new_year` are instances of the `Date` class.

But, if you observe closely, the Factory process is hard-coded to create `Date` objects no matter what. What this means is that even if the `Date` class is subclassed, the subclasses will still create plain `Date` objects (without any properties of the subclass). See that in the example below:

``````class DateTime(Date):
def display(self):
return "{0}-{1}-{2} - 00:00:00PM".format(self.month, self.day, self.year)

datetime1 = DateTime(10, 10, 1990)
datetime2 = DateTime.millenium(10, 10)

isinstance(datetime1, DateTime) # True
isinstance(datetime2, DateTime) # False

datetime1.display() # returns "10-10-1990 - 00:00:00PM"
datetime2.display() # returns "10-10-2000" because it"s not a DateTime object but a Date object. Check the implementation of the millenium method on the Date class for more details.
``````

`datetime2` is not an instance of `DateTime`? WTF? Well, that"s because of the `@staticmethod` decorator used.

In most cases, this is undesired. If what you want is a Factory method that is aware of the class that called it, then `@classmethod` is what you need.

Rewriting `Date.millenium` as (that"s the only part of the above code that changes):

``````@classmethod
def millenium(cls, month, day):
return cls(month, day, 2000)
``````

ensures that the `class` is not hard-coded but rather learnt. `cls` can be any subclass. The resulting `object` will rightly be an instance of `cls`.
Let"s test that out:

``````datetime1 = DateTime(10, 10, 1990)
datetime2 = DateTime.millenium(10, 10)

isinstance(datetime1, DateTime) # True
isinstance(datetime2, DateTime) # True

datetime1.display() # "10-10-1990 - 00:00:00PM"
datetime2.display() # "10-10-2000 - 00:00:00PM"
``````

The reason is, as you know by now, that `@classmethod` was used instead of `@staticmethod`

1726

`@classmethod` means: when this method is called, we pass the class as the first argument instead of the instance of that class (as we normally do with methods). This means you can use the class and its properties inside that method rather than a particular instance.

`@staticmethod` means: when this method is called, we don"t pass an instance of the class to it (as we normally do with methods). This means you can put a function inside a class but you can"t access the instance of that class (this is useful when your method does not use the instance).

## Shop

Best laptop for Fortnite

\$

Best laptop for Excel

\$

Best laptop for Solidworks

\$

Best laptop for Roblox

\$

Best computer for crypto mining

\$

Best laptop for Sims 4

\$

Best laptop for Zoom

\$499

Best laptop for Minecraft

\$590

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

NUMPYNUMPY

How to convert Nonetype to int or string?

NUMPYNUMPY

How to specify multiple return types using type-hints

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

## Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method