5. Python的变量与运算符

喜欢ヅ旅行 2024-04-17 05:25 164阅读 0赞

### 变量 ###

*  什么是变量？

变量可以理解为名字，变量是存储在内存中的值。Python中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号`=`用来给变量赋值。等号`=`运算符左边是一个变量名，等号`=`运算符右边是存储在变量中的值。

>>> list1 = [1, 2, 3, 4, 5, 6]
    
    >>> print(list1)
    [1, 2, 3, 4, 5, 6]

在定义变量名时，需要注意变量名可读性要强，这样在看到变量名时容易理解存储在变量中的值。

*  变量的命名规则：

1.  变量名中只能由字母、数字、下划线组成
2.  变量名的首字母不能是数字，可以是字母或下划线
3.  Python的保留关键字不能用在变量名中
4.  Python的变量名区分大小写

>>> if = 1
    SyntaxError: invalid syntax
    
    >>> and = 2
    SyntaxError: invalid syntax
    
    >>> import = 3
    SyntaxError: invalid syntax

*  值类型与引用类型：

Python中的变量无类型，对象有类型。Python中的变量都是指针，可以指向任意对象。

在Python中，数值（整型，浮点型），布尔型，字符串，元组属于值类型，本身不允许被修改（不可变类型）。

在Python中，列表，集合，字典是引用类型，本身允许修改（可变类型）。

不可变对象类型：

int
    float
    decimal
    complex
    bool
    str
    tuple
    range
    frozenset
    bytes

可变对象类型：

list
    dict
    set
    bytearray
    user-defined classes (unless specifically made immutable)

例子：

>>> a = 1
    
    >>> b = a
    
    >>> a = 3
    
    >>> print(b)
    1

>>> a = [1, 2, 3, 4, 5]
    
    >>> b = a
    
    >>> a[0] = '1'
    
    >>> print(a)
    ['1', 2, 3, 4, 5]
    
    >>> print(b)
    ['1', 2, 3, 4, 5]

比较上面两个例子，为什么会产生这种情况呢？

因为第一个例子是把int类型赋值给了变量a，而int类型为值类型，不可变，所以变量b为1；而第二个例子中是把list类型赋值给了变量b，list类型为引用类型，可变，所以变量b随着变量a的改变而改变。

*  列表的可变与元组的不可变：

列表的可变：

>>> a = [1, 2, 3]
    
    >>> id(a)
    2245520284552
    
    >>> a[0] = '1'
    
    >>> id(a)
    2245520284552
    
    >>> a
    ['1', 2, 3]

元组的不可变：

>>> b = (1, 2, 3)
    
    >>> b[0] = '1'
    Traceback (most recent call last):
      File "<pyshell#27>", line 1, in <module>
        b[0] = '1'
    TypeError: 'tuple' object does not support item assignment
    
    >>> b
    (1, 2, 3)

>>> c = (1, 2, 3, ['a', 'b', 'c'])
    
    >>> c[2] = '3'
    Traceback (most recent call last):
      File "<pyshell#30>", line 1, in <module>
        c[2] = '3'
    TypeError: 'tuple' object does not support item assignment
    
    >>> c[3] = ['aa', 'bb', 'cc']
    Traceback (most recent call last):
      File "<pyshell#31>", line 1, in <module>
        c[3] = ['aa', 'bb', 'cc']
    TypeError: 'tuple' object does not support item assignment
    
    >>> c[3][1] = 'bbb'
    
    >>> print(c)
    (1, 2, 3, ['a', 'bbb', 'c'])

可以看到，元组没有改变，改变的是列表。元组中的元素不可改变，但当元组中的元素是引用类型时，该元素内部是可变的。

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

### 运算符 ###

>>> 1 + True
    2
    
    >>> 1 - False
    1

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

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

赋值运算符是用来赋值的。

假设变量a的值10，变量b的值是20，则

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>=</code></td> 
   <td align="center">将右侧操作数的值分配给左侧操作数</td> 
   <td align="center"><code>c = a + b</code>表示将a + b的值分配给c</td> 
  </tr> 
  <tr> 
   <td align="center"><code>+=</code></td> 
   <td align="center">将右操作数相加到左操作数，并将结果分配给左操作数</td> 
   <td align="center"><code>c += a</code>等价于 <code>c = c + a</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>-=</code></td> 
   <td align="center">从左操作数中减去右操作数，并将结果分配给左操作数</td> 
   <td align="center"><code>c -= a</code> 等价于 <code>c = c - a</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>*=</code></td> 
   <td align="center">将右操作数与左操作数相乘，并将结果分配给左操作数</td> 
   <td align="center"><code>c *= a</code> 等价于 <code>c = c * a</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>/=</code></td> 
   <td align="center">将左操作数除以右操作数，并将结果分配给左操作数</td> 
   <td align="center"><code>c /= a</code> 等价于 <code>c = c / a</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>%=</code></td> 
   <td align="center">将左操作数除以右操作数的模数，并将结果分配给左操作数</td> 
   <td align="center"><code>c %= a</code> 等价于 <code>c = c % a</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>**=</code></td> 
   <td align="center">执行指数(幂)计算，并将值分配给左操作数</td> 
   <td align="center"><code>c **= a</code> 等价于 <code>c = c ** a</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>//=</code></td> 
   <td align="center">运算符执行地板除运算，并将值分配给左操作数</td> 
   <td align="center"><code>c //= a</code> 等价于 <code>c = c // a</code></td> 
  </tr> 
 </tbody> 
</table>

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

#### 比较（关系）运算符 ####

比较(关系)运算符比较它们两边的值，并确定它们之间的关系，结果是布尔值。它们也称为关系运算符。

假设变量a的值10，变量b的值是20，则

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>==</code></td> 
   <td align="center">如果两个操作数的值相等，则条件为真</td> 
   <td align="center"><code>(a == b)</code>求值结果为 <code>false</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>!=</code></td> 
   <td align="center">如果两个操作数的值不相等，则条件为真</td> 
   <td align="center"><code>(a != b)</code>求值结果为 <code>true</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>&gt;</code></td> 
   <td align="center">如果左操作数的值大于右操作数的值，则条件成为真</td> 
   <td align="center"><code>(a &gt; b)</code>求值结果为 <code>false</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>&lt;</code></td> 
   <td align="center">如果左操作数的值小于右操作数的值，则条件成为真</td> 
   <td align="center"><code>(a &lt; b)</code>求值结果为 <code>true</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>&gt;=</code></td> 
   <td align="center">如果左操作数的值大于或等于右操作数的值，则条件成为真</td> 
   <td align="center"><code>(a &gt;= b)</code>求值结果为 <code>false</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>&lt;=</code></td> 
   <td align="center">如果左操作数的值小于或等于右操作数的值，则条件成为真</td> 
   <td align="center"><code>(a &lt;= b)</code>求值结果为 <code>true</code></td> 
  </tr> 
 </tbody> 
</table>

>>> [1, 2, 3] < [2, 3, 4]
    True
    
    >>> (1, 2, 3) < (2, 3, 4)
    True
    
    >>> { 1, 2, 3} < { 2, 3, 4}
    False
    
    >>> { 1, 2, 3} > { 2, 3, 4}
    False
    
    >>> { 1, 2, 3} == { 2, 3, 4}
    False
    
    >>> { 1: 1, 2: 2, 3: 3}  < { 2: 2, 3: 2, 4: 4}
    Traceback (most recent call last):
      File "<pyshell#5>", line 1, in <module>
        { 1: 1, 2: 2, 3: 3}  < { 2: 2, 3: 2, 4: 4}
    TypeError: '<' not supported between instances of 'dict' and 'dict'

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

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

逻辑运算符的操作对象和结果都是布尔类型。str与int类型能够转换为bool类型。

假设变量a的值为True，变量b的值为False，则

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>and</code></td> 
   <td align="center">逻辑与，如果两个操作数都为真，则条件为真</td> 
   <td align="center"><code>(a and b)</code> 的结果为<code>False</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>or</code></td> 
   <td align="center">逻辑或，如果两个操作数中的任何一个为真，则条件为真</td> 
   <td align="center"><code>(a or b)</code> 的结果为<code>True</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>not</code></td> 
   <td align="center">逻辑非，用于反转操作数的逻辑状态</td> 
   <td align="center"><code>not(a and b)</code> 的结果为<code>True</code></td> 
  </tr> 
 </tbody> 
</table>

>>> 1 or 2
    1
    
    >>> 1 and 2
    2
    
    >>> not 3
    False
    
    >>> not 0
    True

>>> 'a' and 'b'
    'b'
    
    >>> 'a' or 'b'
    'a'
    
    >>> not 'c'
    False
    
    >>> not ''
    True

>>> not []
    True
    
    >>> [1] or []
    [1]
    
    >>> [] or [1]
    [1]

str、list、int、float类型能够转换为bool类型：

1. 对于int、float类型来说，非0表示True，而0表示False
    
    2. 对于str类型来说，非空字符串表示True，空字符串表示False
    
    3. 对于list类型来说，非空列表表示True，空列表表示False
    
    4. 对于and、or，涉及到短路逻辑时会返回第一个值，否则返回第二个值

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

#### 成员运算符 ####

成员运算符测试给定值是否为序列中的成员，例如字符串、列表、元组、集合和字典。成员运算符的返回值是布尔类型。

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>in</code></td> 
   <td align="center">如果在指定的序列中找到一个变量的值，则返回<code>true</code>，否则返回<code>false</code></td> 
   <td align="center">-</td> 
  </tr> 
  <tr> 
   <td align="center"><code>not in</code></td> 
   <td align="center">如果在指定序列中找不到变量的值，则返回<code>true</code>，否则返回<code>false</code></td> 
   <td align="center">-</td> 
  </tr> 
 </tbody> 
</table>

>>> b = 1
    
    >>> b in [1, 2, 3, 4, 5]
    True
    
    >>> b not in [1, 2, 3, 4, 5]
    False
    
    >>> b not in (1, 2, 3, 4, 5)
    False
    
    >>> b not in { 1, 2, 3, 4, 5}
    False
    
    >>> b in { 'a': 1}
    False
    
    >>> b = 'a'
    
    >>> b in { 'a': 1}
    True

对于字典类型来说，成员运算符判断的是key-value中的key。

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

#### 身份运算符 ####

身份运算符比较两个对象的内存位置，比较两个对象的身份是否相等。身份运算符的返回值仍然是布尔类型。

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>is</code></td> 
   <td align="center">如果运算符任一侧的变量指向相同的对象，则返回<code>True</code>，否则返回<code>False</code></td> 
   <td align="center">-</td> 
  </tr> 
  <tr> 
   <td align="center"><code>is not</code></td> 
   <td align="center">如果运算符任一侧的变量指向不同的对象，则返回<code>True</code>，否则返回<code>False</code></td> 
   <td align="center">-</td> 
  </tr> 
 </tbody> 
</table>

>>> a = 1
    
    >>> b = 1.0
    
    >>> a == b
    True
    
    >>> a is b
    False

>>> c = (1, 2, 3)
    
    >>> d = (2, 1, 3)
    
    >>> c == d
    False
    
    >>> c is d
    False

>>> e = { 1, 2, 3}
    
    >>> f = { 2, 1, 3}
    
    >>> e == f
    True
    
    >>> e is f
    False

元组是有序的，集合是无序的。

关系运算符`==`比较的是两个对象的值是否相等，而身份运算符`is`比较的是两个对象的身份是否相等。

Python中一切都是对象，对象有三个特征：值value、身份id、类型type。

前面判断了对象的值和身份，那么判断对象的身份呢？Python有一个内置函数`isinstance()`用于判断对象的类型，返回值是布尔类型。

>>> a = 'hello'
    
    >>> isinstance(a, str)
    True
    
    >>> isinstance(a, int)
    False
    
    >>> isinstance(a, (int, str, float))
    True

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

#### 位运算符 ####

位运算符把数当做二进制数执行逐位运算。Python的内置函数`bin()`可用于获取整数的二进制表示形式。

假设变量a = 60；和变量b = 13。现在以二进制格式，它们将如下

a = 0011 1100
    
    b = 0000 1101
    
    -----------------
    
    a&b = 0000 1100
    
    a|b = 0011 1101
    
    a^b = 0011 0001
    
    ~a = 1100 0011

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>&amp;</code></td> 
   <td align="center">按位与，如果它存在于两个操作数中，则操作符复制位到结果中</td> 
   <td align="center"><code>(a &amp; b)</code> 结果表示为 <code>0000 1100</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>|</code></td> 
   <td align="center">按位或，如果它存在于任一操作数，则复制位</td> 
   <td align="center"><code>(a | b) = 61</code> 结果表示为 <code>0011 1101</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>^</code></td> 
   <td align="center">按位异或，二进制异或。如果它是一个操作数集合，但不是同时是两个操作数则将复制位</td> 
   <td align="center"><code>(a ^ b) = 49</code> 结果表示为 <code>0011 0001</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>~</code></td> 
   <td align="center">按位取反，二进制补码，它是一元的，具有“翻转”的效果</td> 
   <td align="center"><code>(~a ) = -61</code>有符号的二进制数，表示为<code>1100 0011</code>的补码形式</td> 
  </tr> 
  <tr> 
   <td align="center"><code>&lt;&lt;</code></td> 
   <td align="center">左移动，二进制左移，左操作数的值由右操作数指定的位数左移</td> 
   <td align="center"><code>a &lt;&lt; 2 = 240</code> 结果表示为 <code>1111 0000</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>&gt;&gt;</code></td> 
   <td align="center">右移动，二进制右移，左操作数的值由右操作数指定的位数右移</td> 
   <td align="center"><code>a &gt;&gt; 2 = 15</code> 结果表示为 <code>0000 1111</code></td> 
  </tr> 
 </tbody> 
</table>

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

#### 运算符优先级 ####

下表列出了从最高优先级到最低优先级的所有运算符。

<table> 
 <thead> 
  <tr> 
   <th align="center">序号</th> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">1</td> 
   <td align="center"><code>**</code></td> 
   <td align="center">指数(次幂)运算</td> 
  </tr> 
  <tr> 
   <td align="center">2</td> 
   <td align="center"><code>~</code> <code>+</code> <code>-</code></td> 
   <td align="center">补码，一元加减(最后两个的方法名称是<code>+@</code>和<code>-@</code>)</td> 
  </tr> 
  <tr> 
   <td align="center">3</td> 
   <td align="center"><code>*</code> <code>/</code> <code>%</code> <code>//</code></td> 
   <td align="center">乘法，除法，模数和地板除</td> 
  </tr> 
  <tr> 
   <td align="center">4</td> 
   <td align="center"><code>+</code> <code>-</code></td> 
   <td align="center">-</td> 
  </tr> 
  <tr> 
   <td align="center">5</td> 
   <td align="center"><code>&gt;&gt;</code> <code>&lt;&lt;</code></td> 
   <td align="center">向右和向左位移</td> 
  </tr> 
  <tr> 
   <td align="center">6</td> 
   <td align="center"><code>&amp;</code></td> 
   <td align="center">按位与</td> 
  </tr> 
  <tr> 
   <td align="center">7</td> 
   <td align="center"><code>^</code> <code>|</code></td> 
   <td align="center">按位异或和常规的“<code>OR</code>”</td> 
  </tr> 
  <tr> 
   <td align="center">8</td> 
   <td align="center"><code>&lt;=</code> <code>&lt;</code> <code>&gt;</code> <code>&gt;=</code></td> 
   <td align="center">比较运算符</td> 
  </tr> 
  <tr> 
   <td align="center">9</td> 
   <td align="center"><code>&lt;&gt;</code> <code>==</code> <code>!=</code></td> 
   <td align="center">等于运算符</td> 
  </tr> 
  <tr> 
   <td align="center">10</td> 
   <td align="center"><code>=</code> <code>%=</code> <code>/=</code> <code>//=</code> <code>-=</code> <code>+=</code> <code>*=</code> <code>**=</code></td> 
   <td align="center">赋值运算符</td> 
  </tr> 
  <tr> 
   <td align="center">11</td> 
   <td align="center"><code>is</code> <code>is not</code></td> 
   <td align="center">身份运算符</td> 
  </tr> 
  <tr> 
   <td align="center">12</td> 
   <td align="center"><code>in</code> <code>not in</code></td> 
   <td align="center">成员运算符</td> 
  </tr> 
  <tr> 
   <td align="center">13</td> 
   <td align="center"><code>not</code> <code>or</code> <code>and</code></td> 
   <td align="center">逻辑运算符</td> 
  </tr> 
 </tbody> 
</table>

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