1 | initial version |

Here is a personal comment, there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
sage: t = 2
```

As if `var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

Then, conistently, i tend to use `SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

2 | No.2 Revision |

Here is a personal comment, there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
sage: t = 2
```

As if `var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

Then, conistently, i tend to use `SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

3 | No.3 Revision |

Here is a personal comment, there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
sage: t = 2
```

As if `var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

Then, conistently, i tend to use `SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

4 | No.4 Revision |

*symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, for example we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
sage: t = 2
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

5 | No.5 Revision |

Here is a personal comment, there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, ~~for example ~~as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
sage: t = 2
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

6 | No.6 Revision |

Here is a personal comment, there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
```~~sage: ~~....: t = 2
....: # do something with t

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

7 | No.7 Revision |

Here is a personal comment, there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
....: t = 2
....: # do something with t
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr =`

~~exp(t)~~exp(t) + sqrt(2)`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

8 | No.8 Revision |

Here is a personal comment, there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
....: t = 2
....: # do something with t
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t) + sqrt(2)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

Then, conistently, i tend to use `SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*~~.~~, whichs is very non-Pythonic.

9 | No.9 Revision |

*symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
....: t = 2
....: # do something with t
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t) + sqrt(2)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

Then, conistently, i tend to use `SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*~~, whichs is very non-Pythonic.~~.

10 | No.10 Revision |

*symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
....: t = 2
....: # do something with t
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t) + sqrt(2)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

I would vote +1 if there were a `SR.symbols`

doing the same wrapping as `SR.var`

. Note that théy do not have the same semantics:

```
sage: a = SR.symbol('a,z')
sage: a
a,z
sage: a + a
2*a,z
sage: a = SR.var('a,z')
sage: a
(a, z)
sage: a[0]^2
a^2
```

11 | No.11 Revision |

Here is a personal ~~comment, ~~comment: there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
....: t = 2
....: # do something with t
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t) + sqrt(2)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

I would vote +1 if there were a `SR.symbols`

doing the same wrapping as `SR.var`

. Note that théy do not have the same semantics:

```
sage: a = SR.symbol('a,z')
sage: a
a,z
sage: a + a
2*a,z
sage: a = SR.var('a,z')
sage: a
(a, z)
sage: a[0]^2
a^2
```

12 | No.12 Revision |

Here is a personal comment: there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the following things:

```
sage: var("t")
....: t = 2
....: # do something with t
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t) + sqrt(2)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

I would vote +1 if there were a `SR.symbols`

doing the same wrapping as `SR.var`

. Note that ~~théy ~~`SR.symbol`

and `SR.var`

do not have the same semantics:

```
sage: a = SR.symbol('a,z')
sage: a
a,z
sage: a + a
2*a,z
sage: a = SR.var('a,z')
sage: a
(a, z)
sage: a[0]^2
a^2
```

13 | No.13 Revision |

Here is a personal comment: there is a real pedagogical benefit in using *symbol* instead of *variable*, as *variable* has too many meanings, and causes a lot of confusions, as a consequence we do not count the number of examples provided on ask.sagemath.org with the ~~following things:~~things like:

```
sage: var("t")
....: t = 2
....: # do something with t
```

`var`

was used to delcare a variable. Instead, i prefer to use separate denominations for distincts concepts:

`t`

is a*Python name*when we write`t=2`

`t`

is a*symbol*when we write`expr = exp(t) + sqrt(2)`

`t`

is an*indeterminate*when we write`R.<t> = PolynomialRing(QQ)`

`SR.symbol`

instead of `SR.var`

, not to mention the ugly `var`

, which both creates a *Python name* and returns a *symbol*.

I would vote +1 if there were a `SR.symbols`

doing the same wrapping as `SR.var`

. Note that `SR.symbol`

and `SR.var`

do not have the same semantics:

```
sage: a = SR.symbol('a,z')
sage: a
a,z
sage: a + a
2*a,z
sage: a = SR.var('a,z')
sage: a
(a, z)
sage: a[0]^2
a^2
```

Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.