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：适合于选择执行的情况

  if 表达式:
      语句块

   

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

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

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

   

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

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

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

   

  1. elif的个数没有限制

  2. else可以省略不写

  3. 每一部分的语句块都不可能同时执行，最多执行一个

数据类型

• 字符串

  s = 'hello'
  # 字符串的重叠
  s = 'hello' * 2
  # 字符串的拼接
  s = 'hello' + 'world'
  print(s)
  # 统计字符个数
  print(len(s))
  ​
  # 提取单个字符，通过下表提取
  # 从开头提取，下表从0开始
  print(s[0])
  # 从结尾提取，下表从-1开始
  print(s[-1])
  ​
  # 切片：s[开始:结束:步进]
  s = 'abcdefg'
  # 包括起始下表，不包括结束下表，默认的步进值为1
  print(s[0:3])
  print(s[2:4])
  # 当一边没有指定就提取到该边的边界
  print(s[:4])
  print(s[3:])
  print(s[1:-2])
  print(s[-4:])
  print(s[:])
  print(s[::2])
  # 倒序提取
  print(s[::])-1
  ​
  # 格式化
  ​
  # %s：字符串
  # %d：整数
  # %f：小数
  # %c：单个字符
  print('俺叫%s，暗恋%s，她今年%d岁了' % (name, like, age))
  ​
  print('我是{}，今年{}，暗恋{}'.format(name, age, like))
  print('我是{2}，今年{1}，暗恋{0}'.format(name, age, like))
  print('我是{nm}，今年{a}，暗恋{l}'.format(nm=name, a=age, l=like))

   

• 列表

  lt = [1, 2, 3, 4, 5]
  ​
  print(lt[0])
  print(lt[-1])
  print(lt[1:4])
  print(len(lt))
  ​
  # 修改
  lt[0] = 100
  ​
  # 添加的对象在列表是一个元素
  lt.append(250)
  # lt.append(['hello', 'world'])
  # 将可迭代对象的每个元素挨个添加
  lt.extend(['hello', 'world'])
  ​
  # 在指定位置插入元素
  lt.insert(3, 'good')
  ​
  # 根据下表删除元素
  del lt[0]
  # 根据值删除元素
  lt.remove(250)
  ​
  # 删除并返回指定下表的元素，默认最后一个元素
  last = lt.pop(4)
  print(last)
  ​
  # 查询索引号
  lt = [1, 2, 3, 1, 1]
  print(lt.index(1))
  # 逆序
  # lt.reverse()
  # 统计指定对象出现的次数
  print(lt.count(1))
  lt = [1, 5, 7, 3]
  # 排序，默认升序排序，可以通过reverse指定是否倒序排序
  lt.sort(reverse=true)
  print(lt)

   

 

ascii

• 说明：美国信息交换标准代码，其实就是给每个字符使用一个整数表示

• 函数：

  • ord：根据字符获取ascii码

  • chr：根据ascii码转换成字符

练习

• 从终端输入一个表示年份的整数，判断是否是闰年，是就打印xxx年是闰年，不是打印xxx年不是闰年

• 输入两个整数，打印较大值

• 输入三个整数，按照从小到大的顺序打印

• 输入一个三位整数，顺序打印个位、十位、百位上的数

• 输入一个整数，判断其是否既是3的倍数，又是5的倍数

• 输入一个字符，是小写转换为大写，大写转换为小写，其他字符原样输出