python 入门系列2---python 中的运算符

墨蓝 2022-06-13 12:49 204阅读 0赞

# 一、输入和输出 #

## 1.1 输出 ##

`print()`函数用来向终端输出数据(其实也可以向文件输出数据，后面再讲)

--------------------

*  可以传递多个参数，则输出的时候多个参数的值中间用空格隔开。
    
        print("hell", "world", "你好")
    
    ![64979012.jpg][]

--------------------

*  `print()`函数默认会在末尾自动添加一个 `\n` 。如果不想换行则可以传递一个参数 `end=""`
    
        print("hell", "world", "你好", end="")
        print("哈哈哈")
    
    ![22862553.jpg][]

--------------------

## 1.2 输入 ##

`input()` 可以获取用户在键盘的输入，输入的数据都会成为字符串。

name = input()    # 把从键盘输入的数据存储到变量 name 中
    print("你的名字是:", name)

![90548427.jpg][]

--------------------

如果在用户输入前给用户一个提示语，可以在 `input` 中传入参数，则 `python` 会把传入的参数先使用 `print()` 函数输出，然后再等待用户输入数据。

name = input("请输入你的姓名:")
    print("你的名字是:", name)

![88336884.jpg][]

# 二、运算符和表达式 #

## 2.1 表达式 ##

我们前面编写的大多数代码都包含了表达式(`Expressions`)。 比如 `2 + 3` 就是一个表达式。

表达式可以可以进一步拆分为运算符(Operators)和操作数(Operands)

例如：

表达式：`2 + 3 * 4`

其中：

`+、*` 就是运算符

`2、3、4` 就是操作数

--------------------

python 提供了很多各种各样的运算符。

任何的数据类型都可以作为操作数。

## 2.2 运算符 ##

### 2.2.1 算术运算符 ###

#### 加法：`+` ####

当 `+` 的两端都是数字时，则就是数学中的加法运算。

当 `+` 两端都是字符串时，则就是把两端的字符串连接起来。

注意：

1.  布尔值 `True` 可以作为数字 `1` 来使用， `False` 可以作为数字 `0` ,所以他们可以和数字相加。
2.  python 不允许字符串和数字相加

add1 = 3 + 4
    print(add1)   # 7
    
    add2 = 3 + True
    print(add2)    # 4
    
    add3 = 3 + False
    print(add3)    # 3
    
    add4 = True * 0
    print(add4)    # 0
    
    # add5 = "a" + 3 # 错误！不允许字符串和数字相加

![16896084.jpg][]

--------------------

#### 减法：`-` ####

减法只能用于操作数字。

#### 乘法：`*` ####

得到两个数的乘积。如果有一个是字符串一个是整数，则得到的重复整数次的字符串。

result1 = 3 * 4.1
    print(result1)
    
    result2 = 2 * "Hello "
    print(result2)
    
    result3 = "world " * 3
    print(result3)

![30896719.jpg][]

#### 幂：`**` ####

`x ** y` 返回 `x` 的 `y` 次方 `x^y`

#### 除法：`/` ####

`/` 就是指的数学上的除法，总能得到浮点数的值。和其他语言差别较大。

result1 = 10 / 2
    print(result1)
    
    result2 = 10 / 3
    print(result2)
    
    result3 = -11.3 / 3
    print(result3)

![13929206.jpg][]

#### 整除：`//` ####

整除一般用来操作两个整数。(虽然也可以操作浮点数，但是没人这么做)

result1 = 10 // 2
    print(result1)
    
    result2 = 10 // 3
    print(result2)
    
    result3 = -10 // 3
    print(result3)
    
    result4 = 10 // -3
    print(result4)

![96901933.jpg][]

#### 取余(取模)：`%` ####

返回除法运算后的余数。一般用于整数取模。浮点数也可以用

result1 = 10 % 2
    print(result1)
    
    result2 = 10 % -3    # 余数的符号与除数的符号相同。
    print(result2)
    
    result3 = -10 % 3
    print(result3)
    
    result4 = -2.4 % 2  # 取模一般用于整数运算。浮点数意义不大
    print(result4)

![82931060.jpg][]

### 2.2.2 赋值运算符 ###

`=` 赋值运算符最常见的。

还有一种叫做复合赋值运算符的。

`+=`

a = 3
    a += 2   # 等价于 a = a + 2
    print(a)  # 5

算术运算符都有对应的复合赋值运算符。

### 2.2.3 比较运算符 ###

比较两个操作数大小关系。

1.  如果是两个数字则比较他们数学上的大小。
2.  如果是两个字符串比较，则是比较的他们在码表中的顺序。先比较第一个字母，如果相等再比较第二个…
3.  如果有布尔值参与比较，则 `True` 做 `1` 来用，`False` 做 `0` 来用。
4.  数字和字符串不能进行比较！
5.  比较运算符计算的结果一定是布尔值。

比较运算符包括以下运算符：

`> 、< 、>=、<=、==、!=`

其中： `==` 判断两个操作数是否相等、`!=` 用来判断两个操作数是否不等。

r1 = 3 > 2
    print(r1)   # True
    
    r2 = "ab" > "b1"
    print(r2)   # False
    
    r3 = True > False
    print(r3)   # True
    
    r4 = 1 == True
    print(r4)   # True

#### 注意： ####

python 中的比较运算符与其他语言最大的一个不同是，python 中的比较运算符可以组成链接。只有每个运算符计算的结果都是 `True` ，最终的结果才会为 `True`。否则就是 `False`

r1 = 5 > 4 > 3
    print(r1)    # True 因为 5 大于 4是 True，并且 4 大于 3 是 True
    
    r2 = 5 > 4 == (2 + 1)
    print(r2)    # False 因为 5 大于 4 是 True，但是 4 == 2 + 1 是 False

### 2.2.4 逻辑运算符 ###

python 共支持 3 种逻辑运算符。

`not、and、or`

#### 逻辑非：`not` ####

r1 = not True
    print(r1)    # False
    
    r2 = not False
    print(r2)    # True

注意：

1.  对 `not` 来说，结果总是 `True 或 False`，但是操作数可以是任意类型的。
2.  内容为空的数据，会作为 `False` 来对待，所以 `not` 之后会成为 `Teue`

r1 = not True
    print(r1)    # False
    
    r2 = not False
    print(r2)    # True
    
    print(not 1)    # False
    
    print(not 0)    # True
    
    print(not "")    # True 
    
    print(not [])    # True
    
    print(not ())    # True
    
    print(not {})    # True

#### 逻辑与：`and` ####

有一个是 `False` 结果就是 `False`

由于任何类型都可以参与运算，所以更加准确的规则应该是：

**如果第一个是** `False`*\* 或者相当于 **`False`** ,则结果就是第一个数据，否则最终的结果就应该是第二个数据\**。

print(False and True)    # False
    print(False and False)    # Fasle
    
    print(0 and True)    # 0
    print([] and False)    # []
    print([1] and 20) # 20
    print("a" and []) # 20

`and` 具有短路的效果，也就是说，如果第一个表达式是 `False` 或者相当于 `False`, 则不会再去判断第二个表达式。

print(True and print("abc"))
    
    print(False and print("bcd"))    # 由于第一个表达式是 False，所以不会计算第二个表达式的值

![24047855.jpg][]

备注：是 `False` 的7种数据

`False、None、0、""、[]、()、{}`

#### 逻辑或：`or` ####

有一个是 `True` 结果就是 `True`

由于任何类型都可以参与运算，所以更加准确的规则应该是：

**如果第一个是** `True`*\* 或者相当于 **`True`** ,则结果就是第一个数据，否则最终的结果就应该是第二个数据\**。

print(True or False)
    print(False or True)
    print(False or False)
    print(1 or False)
    print("" or 100)
    print([] or (2,))

![25446971.jpg][]

`or` 也具有短路的效果，也就是说，如果第一个表达式是 `True` 或者相当于 `Ttue`, 则不会再去判断第二个表达式。

### 2.2.5 位操作符 ###

补充二进制知识：原、反、补码。

python 共提交了4中位操作符

#### 按位取反：`~` ####

二进制的每一位 0 变 1 ， 1 变 0

#### 按位与：`&` ####

两个数的每一位进行与操作，有一个是 `0` 结果就是 `0`

#### 按位或：`|` ####

两个数的每一位进行或操作，有一个是 `1` 结果就是 `1`

#### 按位异或：`^` ####

两个数的每一位进行或操作，相同结果是 `0` ,不同结果是 `1`

print(~2) // 
    print(1 & 3)
    print(1 | 3)
    print(1 ^ 3)

![83579610.jpg][]

### 2.2.6 移位操作符 ###

python 提供了两种移位操作符：

#### 左移：`<<` ####

数字的二进制位向左移动指定的位数。右边用 `0` 补齐。

由于python 的整数可以表示任何大的数，所以左移时，高位不会溢出。这是与其他语言的区别。

print(1 << 2)    # 4 向左移动 2 位

注意：向左移 1 位相当于 `*2`

#### 右移：`>>` ####

数字的二进制位向右移动指定的位数。 低位溢出。移动的过程中符号不变。(正数仍然是正数，负数仍然是负数)

print(15 >> 2)    # 3

注意：向左移 1 位相当于 `//2`

# 三、运算符的优先级 #

<table> 
 <thead> 
  <tr> 
   <th align="left"><a href="https://docs.python.org/3/reference/expressions.html#lambda" rel="nofollow"><code>lambda</code></a></th> 
   <th align="left">Lambda expression</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><a href="https://docs.python.org/3/reference/compound_stmts.html#if" rel="nofollow"><code>if</code></a> – <a href="https://docs.python.org/3/reference/compound_stmts.html#else" rel="nofollow"><code>else</code></a></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><a href="https://docs.python.org/3/reference/expressions.html#or" rel="nofollow"><code>or</code></a></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><a href="https://docs.python.org/3/reference/expressions.html#and" rel="nofollow"><code>and</code></a></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><a href="https://docs.python.org/3/reference/expressions.html#not" rel="nofollow"><code>not</code></a> <code>x</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><a href="https://docs.python.org/3/reference/expressions.html#in" rel="nofollow"><code>in</code></a>, <a href="https://docs.python.org/3/reference/expressions.html#not-in" rel="nofollow"><code>not in</code></a>, <a href="https://docs.python.org/3/reference/expressions.html#is" rel="nofollow"><code>is</code></a>, <a href="https://docs.python.org/3/reference/expressions.html#is-not" rel="nofollow"><code>is not</code></a>, <code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code>, <code>&gt;=</code>, <code>!=</code>, <code>==</code></td> 
  </tr> 
  <tr> 
   <td align="left">`</td> 
   <td align="left">`</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>^</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>&amp;</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>&lt;&lt;</code>, <code>&gt;&gt;</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>+</code>, <code>-</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>*</code>, <code>@</code>, <code>/</code>, <code>//</code>, <code>%</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>+x</code>, <code>-x</code>, <code>~x</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>**</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>await</code> <code>x</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>x[index]</code>, <code>x[index:index]</code>, <code>x(arguments...)</code>, <code>x.attribute</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"><code>(expressions...)</code>, <code>[expressions...]</code>, <code>{key: value...}</code>, <code>{expressions...}</code></td> 
  </tr> 
 </tbody> 
</table>

优先级是从上往下越来越高。

**实际使用的时候，对于不是很明确的地方，建议添加圆括号(**`()`**)来更改优先级。从而可读性更强。**

比如：虽然你知道 `*` 的优先级高于 `+`,但是 代码1 明显要好于代码 2

**代码1：**

`2 + (3 * 4)`

**代码2：**

`2 + 3 * 4`

但是括号的使用也不要滥用。比如下面的就有点滥用了。最外面的完全不需要。

`(2 + (3 * 4))`

### 2.2.7 与数字类型相关的几个内置函数 ###

`abs(x)` 返回 `x` 的绝对值

参数 `x` 必须是整数或浮点数

`int(x)` 把 `x` 转换为整数

`x` 可以说浮点数和整数。如果传入的是字符串，则字符串中的字符必须是整数

`float(x)` 把 `x` 转换为 `float`

`x` 可以是浮点数、整数、字符串。

`pow(x, y)` 等价于 `x ** y`

print(abs(-20))
    print(int(20.3))
    print(int("40"))
    print(float("20.4"))

[64979012.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/64979012.jpg
[22862553.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/22862553.jpg
[90548427.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/90548427.jpg
[88336884.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/88336884.jpg
[16896084.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/16896084.jpg
[30896719.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/30896719.jpg
[13929206.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/13929206.jpg
[96901933.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/96901933.jpg
[82931060.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/82931060.jpg
[24047855.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/24047855.jpg
[25446971.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/25446971.jpg
[83579610.jpg]: http://o7cqr8cfk.bkt.clouddn.com/17-7-2/83579610.jpg