Python赋值原理和运算符

Day 3 - Python 变量赋值原理，运算符

变量赋值原理：

# id函数：id(变量) - 获取变量的地址
num = 100
print(id(num))
num = 'abc'
print(id(num))

在给变量赋值时，是根据数据大小开辟内存空间，然后将数据对应的内存和变量关联。重新赋值时，又会重新开辟内存空间然后将新的数据和变量相关联，并且删除变量之前关联的数据。

运算符：

python中的运算符：数学运算符、比较运算符、逻辑运算符和赋值运算符

1. 数学运算符：+、 -、 *、 /、 %、 //、 **

   1. ±*/和数学里的加减乘除功能一样

      注意：/的结果是浮点数

      print(1/1)  # 1.0
      print(5/2)  # 2.5
      

   2. % - 取余

      •  print(5 % 2)  # 求5除于2的余数
         print(8 % 3)  # 2
         # 应用1：判断整数的奇偶性
         # 根据整数对2取余的结果来判断这个数是否是偶数
         print(10 % 2)  # 0
         print(14 % 2)  # 0
         print(15 % 2)  # 1
         
         # 应用2：取整数的低位数
         num = 2898
         print(num % 10)
         print(num % 100)
        

   3. // - 整除

      • print(5 / 2)  # 2.5
        print(5 // 2)  # 2
        print(2 // 3)  # 0
        print(-5 // 2)  # -3
        
        # 应用：取整数的高位数
        num = 234
        print(num // 100)
        
        # 练习：将num中十位数取出来
        print((num // 10) % 10)
        

   4. ** - 幂运算

      • # x ** y - 求 x 的 y 次方
        print(2 ** 3)
        print(16 ** 0.5)  # 4/0
        

2. 比较运算符：> < == <= >= !=

   • # 所有的比较运算符的结果都是布尔值
     print(10 > 20)  # False
     print(100 == 100)   # True
     # python中的比较运算符支持表示范围的连写方式
     
     age = 80
     print(10 <= age <= 100)
     

3. 逻辑运算符：and(逻辑与运算)、or(逻辑或运算)、not(逻辑非运算）

   实际开发过程中，逻辑运算符的运算对象一般都是布尔值，结果也是布尔值

   1. and - 逻辑运算符

      1. 运算规则：全是True结果就是True, 有False结果就是False

         True and True - True
         True and False - False
         False and True - False
         False and False - False

      2. 应用：如果需要多个条件同时满足，就使用and将条件进行连接

         • # 练习：定义两个变量分别保存一个学生的绩点和操评分，最后根据分数的值打印这个学生能否能拿奖学金。
           # （条件：绩点不低于3.5，操评分大于90）
           # 是否能拿奖学金： True/False
           gpa = 3.9
           grade = 100
           print(gpa >= 3.5 and grade > 90)
           

   2. or - 逻辑或

      1. 运算规则: 只要有一个是True结果就是True, 全部都是False结果才是False
         True or True - True
         True or False - True
         False or True - True
         False or False - False

      2. 应用：多个条件中只要有一个满足就行，那么就是or将多个条件进行连接；相当于生活中的或者

         • # 练习：判断一个数能否能够被3或者7整除
           # xxx能被3或者7整除：True or False
           
           num = 10
           print("此数能被3或者7整除", num % 3 == 0 or num % 7 == 0)
           

   3. not - 逻辑非

      1. 运算对象：not 条件

         • not True - Flase

         • not False - True

         • age = 20
           print('是否成年：', age >= 18)
           print('是否未成年: ', not age >= 18)
           
           # 练习：判断一个数是否不能同时被3和7整除
           num = 7
           print("此数能否不能同时被3和7整除： ", not (num % 3 == 0 and num % 7 == 0))
           # 正向写：a.能被3整除，不能被7整除 b.能被7整除，不能被3整除 c.既不能被3整除，也不能被7整除
           # (num % 3 == 0 and num % 7 != 0) or (num % 3 != 0 and num % 7 == 0) or (num % 3 != 0 and num % 7 != 0)
           print(not num % 21 == 0)
           
           # 练习2：判断指定的年是否是闰年
           # 闰年的条件：1）能被4整除但是不能被100整除 2）能被400整除
           year = 2004
           print('是否是闰年： ', ((year % 4 == 0 and year % 100 != 0) or year % 400 == 0))
           

   4. 逻辑运算符的运算对象不是布尔

      • # 表达式1 and 表达式2 - 如果表达式1的布尔值是True,那么整个运算的结果就是表达式2的值。如果是False, 整个运算结果就是表达式1的值。
        # 表达式1 or 表达式2 - 如果表达式1的布尔值是True,那么整个运算的结果就是表达式1的值。如果是False, 整个运算结果就是表达式2的值。
        # 数据的布尔值怎么确定：只有为0为空的数据是False（数字的0，0.0, '', {},[], (), None）, 其他所有的数据的布尔值都是True.
        print(7 and 8)
        print(7 or 8)
        print(not 7)  # False
        print(not 0)  # True
        

   5. 短路操作

      • # 表达式1 and 表达式2 - 如果表达式1的结果是False, 就不会去执行表达式2
        # 表达式1 or 表达式2 - 如果表达式1的结果是True, 就不会去执行表达式2
        
        False and name > 2
        True or name > 2
        

4. 赋值运算符：=、+=、-=、*=、/=、%=、//=、**=

   1. 所有的赋值运算符最终的目的都是给变量赋值，所以赋值运算符的左边必须是变量

   2. 变量 = 数据 - 将右边的数据赋给左边的变量

   3. 复合的赋值运算符

      • 变量 += 数据：将变量中的数据取出来和制定的数据相加求和，然后将这个和重新赋值给变量；变量 = 变量 + 数据

      • 注意：复合的赋值运算符的左边变量必须是已经赋值过的变量

      • num = 10
        num += 2  # num = num + 2 = 10 + 2 =12
        print(num)
        
        num *= 2
        print(num)  # 24
        
        num %= 2  # num = num % 2 = 24 % 2 = 0
        print(num)  # 0
        

5. 运算符的优先级

   • 数学运算符 >比较运算符 > 逻辑运算符 > 赋值运算符

   • ** > * / % // > + -

   • 有括号先算括号里面

   • and优先级比or高

   • print(7 or 8 and 9)  # 先算or: 9 先算and: 7
     

​

​