02-python基础知识-运算符与分支机构

运算符与分支结构

运算符

  • 赋值运算符

    • 用’='表示,左边只能是变量。
  • 算术运算符

    • +、-、*:加、减、乘
    • /:除法,结果是浮点数
    • //:除法,结果是整数
    • %:求余
    • **:求幂,也可以使用函数pow
  • 复合运算符

    • +=、-=、*=、…
    • 示例:a += b等价于a = a + b
  • 关系运算符

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

    • 说明:逻辑运算就是用来合并或取反表达式的
    • 运算:与、或、非
    • 与(and):两边的表达式同时为真,结果才为真
    a = 200
    # 其他语法也通用的写法
    print(a > 10 and a < 100)
    # python中特有的形式
    print(10 < a < 100)
    print(a%3 == 0 and a%5 == 0)
    
    • 或(or):两边的表达式一个为真,结果就为真
    y = int(input('请输入一个年份:'))
    print((y%4==0 and y%100!=0) or (y%400==0))
    
    • 非(not):用于取反表达式,真变假,假变真
      • 使用not是为了简化表达式的书写
      • 经常伴随着隐式类型转换
  • 成员运算符

    • in、not in:判断一个值是否在另一个里面
    • 说明:经常用在字符串、列表、元组、集合、字典等成员的判断
    • 示例:
    lt = [1, 2, 3]
    print(8 not in lt)
    dt = {'name':'xiaoli', 'age': 18}
    # 对于字典,判断的是键
    print('name' in dt)
    
  • 位运算符(了解)

    • &:按位与,对应的数据位同时为1,结果上对应的位才为1
    • |:按位或,对应的数据位一个为1,结果上对应的为就为1
    • ^:按位异或,对应的数据位相同是结果为0,不同时结果为1
    • ~:按位取反,数据的每一位0变1,1变0
    • <<:按位左移,左移一位相当于乘以2
    • >>:按位右移,右移一位相当于除2
  • 运算符的优先级与结合性

    • 语法中没有明确规定优先级与结合性,即使是明确说明了你也记不住
    • 建议:使用时不用刻意记录优先级与结合性,当需要明确指定时添加括号即可

流程控制

  • 说明:

    • 按照代码的执行流程,程序可以分为三种结构:顺序结构、分支结构、循环结构
    • 顺序结构:代码按照从上到下的顺序依次执行的结构,没有语法要求
    • 代码层次:python中的代码层次不是通过大括号表示的,而是通过缩进体现的
  • 分支结构(if-elif-else)

    • 格式1:适合于解决生活中的条件执行问题
    if 表达式:
    	语句块
    

    执行流程:当程序执行到if语句时,首先会判断表达式的真假。若表达式的值为真,则执行后面缩进的语句块;若表达式的值为假,则跳过语句块,执行后面的内容。

    • 格式2:适合于解决生活中的非此即彼的问题
    if 表达式:
    	语句块1
    else:
    	语句块2
    

    执行流程:当程序执行到if-else语句时,首先会判断表达式的真假。若表达式的值为真,则执行语句块1;若表达式的值为假,则执行语句块2.

    • 格式3:适合于解决生活中的多种选择问题
    if 表达式1:
    	语句块1
    elif 表达式2:
    	语句块2
    ...
    else:
    	语句块n
    
    1. elif的个数没有限制
    2. else可以省略不写
    3. 所有的互斥选择语句块最多只能执行一个

相关类型操作

  • 字符串切片

    s1 = "hello"
    s2 = "world"
    # 两个字符串拼接
    s3 = s1 + s2
    print(s3)
    
    # *可以重复字符串次数
    s4 = "abc" * 3
    print(s4)
    
    # len函数统计字符长度
    print(len(s1))
    
    s = "abcdefg"
    # 从头开始进行提取,下标从0开始
    print(s[0])
    # 葱末未进行提取,下标从-1开始
    print(s[-1])
    # 切片
    # 格式:s[开始:结束:步进],左包含,右不包含
    print(s[1:3])
    # 指定步进值,默认为1
    print(s[::2])
    # 逆序提取
    print(s[::-1])
    
    
    # 字符串格式化
    # %s:字符串
    # %d:整型
    # %f:浮点
    # %c:字符
    name = "二狗"
    like = "大花"
    age = 18
    # print("俺叫%s,暗恋%s,她今年%d岁" % (name, like, age))
    print("俺叫"+name, "暗恋"+like, "她今年"+str(age))
    
    # python中特有的解决方案
    # print("俺叫{},暗恋{},她今年{}岁".format(name, like, age))
    # print("俺叫{2},暗恋{1},她今年{0}岁".format(name, like, age))
    # print("俺叫{l},暗恋{n},她今年{a}岁".format(n=name, l=like, a=age))
    
    
  • 列表操作

    lt = [1, 2, 3, 4, 5]
    
    print(lt[0])
    print(lt[-1])
    print(len(lt))
    
    
    # 修改元素
    lt[0] = 100
    # 元素追加
    lt.append(200)
    # lt.append([300, 400])
    # 将可迭代对象的元素添加到列表中
    lt.extend([300, 400])
    # 插入元素
    lt.insert(2, 250)
    # 删除元素
    # 根据索引号删除
    del lt[0]
    # 根据值进行删除,只会删除第一个
    lt.remove(250)
    # 返回并删除指定下标元素,默认是最后一个
    ele = lt.pop(2)
    # print(ele)
    # print(lt)
    
    lt = [1, 2, 3, 4, 5, 3]
    # 查询元祖在列表中的索引号
    # 找到就会返回其索引号,第一个出现的位置
    # 若不在列表中会报错
    print(lt.index(3))
    # 统计元素在列表中出现的次数
    print(lt.count(3))
    
    # 逆序
    lt.reverse()
    # 排序
    # reverse = True
    lt.sort(reverse=True)
    print(lt)
    
  • 元组操作

    # tp1 = (1, 2, 3)
    # tp1 = (1,)
    tp1 = 1, 2, 3
    tp2 = (4, 5, 6)
    # 可以直接拼接在一起
    # tp3 = tp1 + tp2
    # print(tp3, type(tp3))
    # 重复指定次数
    tp4 = tp1 * 3
    print(tp4)
    # 统计元素个数
    print(len(tp4))
    tp = (1, 2, 3, 4, 5, 6)
    # 切片操作
    print(tp[0], tp[-1])
    print(tp[1:-1])
    # 获取指定元素的索引
    print(tp.index(3))
    # 统计元素出现的次数
    print(tp.count(3))
    # 最大值
    print(max(tp))
    # 最小值
    print(min(tp))
    
  • 集合操作

    s = {'彦炯', '露露', '彦博', '启明', '吕威', '二狗'}
    
    # 添加元素
    s.add('继光')
    
    # 删除元素
    # s.remove('二狗')
    # 删除不存在元素会报KeyError错
    # s.remove('狗蛋')
    # 删除元素,元素存在则删除,不存在也不报错
    s.discard('狗蛋')
    
    # 返回并删除,元素是随机的
    # print(s.pop())
    
    # 清空元素
    s.clear()
    
    # print(s)
    
    s1 = {'小马', '小乔', '小周'}
    s2 = {'小王', '小杜', '小马', '小乔', '小周'}
    
    # 并集
    # print(s1.union(s2))
    
    # 交集
    # print(s1.intersection(s2))
    # 求交集,并用交集覆盖原来的集合
    # s1.intersection_update(s2)
    
    # 差集
    # print(s1.difference(s2))
    # 求差集,并用差集覆盖原来的集合
    # s1.difference_update(s2)
    # print(s1)
    
    # 判断是否没有交集
    print(s1.isdisjoint(s2))
    # 判断是否是另一集合的子集
    print(s1.issubset(s2))
    # 判断是否是另一集合的父集/超集
    print(s2.issuperset(s1))
    
  • 字典操作

    d = {'name': 'xiaoming', 'age': 20}
    
    # 获取元素
    # 有就返回对应的值,没有就报KeyError错
    print(d['name'])
    # 有就返回对应的值,没有就返回None,可以指定默认值
    print(d.get('namexxx', '默认值'))
    
    # 修改元素
    # 键存在则修改对应的值
    d['name'] = '二狗'
    # 键不存在则添加键值对
    d['height'] = 180
    
    # 更新:存在的键会覆盖,不存在的键会添加
    d.update({'name': 'dahua', 'weight': 50})
    
    # 删除元素
    # del d['weight']
    # 返回并删除
    print(d.pop('weight'))
    
    # 清空元素
    d.clear()
    
    print(d)
    

猜你喜欢

转载自blog.csdn.net/weixin_44147782/article/details/85265619