python 运算符与分支结构

运算符

• 赋值运算符

  • 用’='表示，左边只能是变量

• 算术运算符

  • +、-、*：加、减、乘
  • /：除法运算，结果是浮点型
  • //：除法运算，结果是整型
  • %：求余
  • **：求幂

• 复合运算符

  • +=、-=、*=、/=、//=、%=、**=
  • 示例：a = a+b 等价于 a += b

• 关系运算符

  • >、<、==、>=、<=、!=
  • 表达式：由操作数和运算符构成的式子
  • 关系表达式：由操作数和关系运算符构成的式子
  • 关系表达式是有值的：符合数学逻辑值为真(True)，不符合数学逻辑值为假(False)

• 逻辑运算符

  • 与(and)：两边的表达式同时为真，结果才为真

    a = 20
    print(a >= 0 and a <= 100)
    # python特有的写法
    print(0 <= a <= 100)
    b = 10
    print(b%3==0 and b%5==0)
    

  • 或(or)：两边的表达式一个为真，结果就为真

    # 判断闰年
    year = int(input('请输入一个年份:'))
    print((year%4==0 and year%100!=0) or (year%400==0))
    

  • 非(not)：用于取反表达式，真变假，假变真

    • 逻辑非经常伴随着隐式类型转换
    • 很多时候是为简化表达式的书写

• 成员运算符

  • in、not in：判断一个变量是否在/不在另一个变量中

  • 一般用在字符串、列表、元组、集合、字典等成员的判断

  • 示例：

    lt = [1, 2, 3]
    print('in：', 8 in lt)
    print('not in：', 8 not in lt)
    
    d = {'name': 'xiaoming', 'age': 20}
    # 字典：判断键是否存在
    print('name' in d)
    

• 位运算符(了解)

  • &：按位与，对应的数据位同时为1，结果才为1

    0b1010
    0b1100   &
    -----------
    0b1000
    

  • |：按位或，对应的数据位一个为1，结果就为1

  • ^：按位异或，对应的数据位相同时值为0，不同时值为1

  • ~：按位取反，对应的数据位，1变0，0变1

  • <<：按位左移，左移一位相当于乘2

  • 》：按位右移，右移一位相当于除2

• 优先级与结合性

  • python语法中没有明确规定运算符的优先级与结合性，即使提供了明确说明你也不一定能记住
  • 建议：使用时不用刻意记录运算符的优先级与结合性问题，实在不行添加()即可解决

流程控制

• 说明：

  • 按照程序的执行流程，程序可以分为三种结构：顺序结构、分支结构、循环结构
  • 顺序结构：就是代码按照从上到下的顺序依次执行，没有语法要求
  • 代码层次：python中代码块不适于大括号区分，而是使用缩进来完成

分支结构(if-else)

- 格式1：适合于选择执行的情况

```python
if 表达式:
	语句块
```

> 执行流程：当程序执行到if语句时，首先判断表达式的真假。若表达式的值为真，则执行对应的语句块；若表达式的值为假，则跳过语句块，之后后面的内容

- 格式2：适合于解决生活中非此即彼的问题

```python
if 表达式:
	语句块1
else:
	语句块2
```

> 执行流程：当程序执行到if-else语句时，首先判断表达式的真假。若表达式的值为，则执行语句块1；若表达式的值为假，则执行else后面的语句块(语句块2)。

- 格式3：适合于解决生活中多种选择的问题

```python
if 表达式1:
	语句块1
elif 表达式2:
	语句块2
。。。
else:
	语句块
```

> 1. elif的个数没有限制
> 2. else可以省略不写
> 3. 每一部分的语句块都不可能同时执行，最多执行一个

循环结构(while)

• 格式

  while 表达式:
  	语句块
  

  执行流程：当程序执行到while语句时，首先判断表达式的真假。若表达式的值为真，则执行对应的语句块，之后返回while继续判断表达式的真假；若表达式的值为假，则跳过语句块，跳过while。

• 说明：

  • 表达式：也叫循环条件
  • 语句块：也叫循环体
  • 死循环：表达式的值一直为真，称为死循环
  • break：结束循环的执行(立即跳出循环)
  • continue：结束本次循环，直接进入下次循环
  • else：结合while使用

  i = 1
  while i <= 10:
      print(i)
      i += 1
      break
  else:
      # 循环正常退出会执行，非正常(break)退出时不会执行
      print('while正常结束')
  

循环结构(for-in)

• 说明：也是一种循环结构，常用于遍历可迭代的对象，如：字符串、列表、元组、字典、集合

• 格式：

  for x in y:
  	循环体
  

  执行流程：x依次表示y中的一个元素，遍历完所有元素后结束循环。

• 示例：遍历字符串、列表、字典

列表生成式

• 可迭代对象：列表、元组、字典等都是可迭代对象，可以遍历的对象

• range函数：

  print(range(10))
  print(range(0, 10))
  
  # range保存的是范围内的连续整数的生成方式
  # 可以遍历
  for i in range(10):
      print(i)
  
  # 可以转换为列表
  lt = list(range(10))
  print(lt)
  

• 列表生成式：可以快速生成有特定规律的列表

  # print([i for i in range(1, 11)])
  # print([i*2 for i in range(1, 11)])
  # print([i*i for i in range(1, 11)])
  # print([str(i) for i in range(1, 11)])
  print([i for i in range(1, 11) if i%2==0])
  

循环的嵌套

• 示例：

  '''
  从终端输入一个整数n，打印如下图形
  1
  1 2
  1 2 3
  1 2 3 4
  ...
  1 2 3 4 ... n
  '''
  
  # 外层循环控制打印多少行
  i = 1
  while i < n+1:
      # 内层循环控制每一行的打印
      j = 1
      while j <= i:
          print(j, end='')
          j += 1
      i += 1
      print()
     
  

双重循环

• 冒泡排序

  lt = [1, 5, 7, 3, 2, 4]
  
  # 计算元素的个数
  n = len(lt)
  # 外层循环控制圈数
  for i in range(n-1):
      for j in range(n-1-i):
          # 不合适，交换数据
          # 此处是升序排序，若想降序需要将 > 改为 <
          if lt[j] > lt[j+1]:
              # 其他语言
              # temp = lt[j]
              # lt[j] = lt[j+1]
              # lt[j+1] = temp
              # python特有
              lt[j], lt[j+1] = lt[j+1], lt[j]
  
  print(lt)
  

• 选择排序

  思想：
  	取出第一个元素，依次与后面的元素进行比较，不合适交换位置，直至比较结束，一轮可以确定开头一个
  	每轮确定一个元素，依次向后，n个元素需要n-1轮比较
  lt = [1, 4, 2, 8, 6, 5]
  n = len(lt)
  for i in range(n-1):
      for j in range(1+i,n):
          if lt[i] > lt[j]:
              lt[i], lt[j] = lt[j], lt[i]
  print(lt)