测试派 Give testers a home.

python运算符&字符串

一、运算符

• 算术运算

  • 加、减、乘
  • 除
    • 10/3 (得到浮点数)
    • 10//3(取整除 - 向下取接近商的整数)
  • 幂运算（x**y）
    • 幂 - 返回x的y次幂
  • 取余/取模（%）
    print(10%3)
    1
    • 取模 - 返回除法的余数

• 赋值运算

  • =：简单的赋值运算符

  • 拓展知识

    • +=：加法赋值运算符
    • -=：减法赋值运算符
    • *=：乘法赋值运算符
    • /=：除法赋值运算符
    • %=：取模赋值运算符
    • **=：幂赋值运算符
    • //=：取整除赋值运算符

    num = 0
    num += 1
    print(num)
    输出：1

• 比较运算符

  • >、<、== 、!= 、>=、<=
  • 让计算机判断条是真还是假，是真就返回True，否则返回False

• 逻辑运算

  • 与 (and）
    print('逻辑运算:',num1 == 0 and num2 == 0)
    代码说明：让计算机判断 num1 ==0 和 num2 == 0 两个条件是真还是假，都是真才返回True，否则返回False
  • 或（or）
    print('逻辑运算:',num1 == 0 or num2 == 0)
    代码说明：让计算机判断 num1 ==0 或者 num2 == 0 是真还是假，只要有一个是真的就返回True，否则返回False
  • 非（!）
    print('逻辑运算:',num1 != 0)
    代码说明：让计算机判断 num1 !=0 是真还是假，是真的就返回True，否则返回False

二、字符串

• 字符串定义

  • 定义单行字符串
    • 单引号
    • 双引号
  • 定义多行字符串
    • 三个单引号
    • 三个双引号
  • 空字符串
    str = ""
  • 转换成字符串
    str(object)

• 字符串操作

  • 字符串访问

    • 顺序索引0开始
    • 倒序索引负1开始

  • 字符串切片

    字符串[起始索引,结束索引,步长]

    • 常用形式
      • 正序切片
        • 使用默认步长(1)
          string[start_index : stop_index]
        • 自定义步长
          string[start_index : stop_index : step]
        • 反转
          string[::-1]
      • 倒序切片
        [start_index : stop_index : step]
        起，未，步长都为必传，且都是负数
        • step>0 正数（或不传）：表示正序切片
        • step<0(负数)：表示倒序切（索引值也要为负数）
    • 注意点

      • 一个空格占一个索引位置

      • 正切默认起始索引0，默认步长1

      • 倒序切片默认起始索引-1，默认步长1

      • 不写结束索引默认为字符串长度

      • 左闭右开（取起始索引的值，不取结束索引的值）

      • start_index : stop_index : step 超过列表索引值，返回空

      • step参数中"+，-" 只是切片方式的标记，后面数字表示步长

      • 正序切片起始索引值必须小于结束索引值(建议记绝对值)

      • 正切就用正切的索引方式写索引（0开始）

      • 倒序切就用倒序的方式写索引（-1开始）

      • 代码演示
        """
        起始索引绝对值 > 结束索引绝对值
        正序：能取到值
        倒序：取不到值

        str_1[-3:-2]
        昨天说正序切片：起始索引绝对值 < 结束索引绝对值
        虽然能取到值，但是不好理解，这么说目的就是让大家不要用这种方式
        """
        str_1='123456789'
        str_2=str_1[-3:-2]
        str_3=str_1[-3:-2:-1]
        str_4=str_1[-1:2:-1]
        print('正序切片值：',str_2)
        print('倒序切片值：',str_3)
        print('倒序切片值：',str_4)
        输出：
        正序切片值： 7
        倒序切片值：
        倒序切片值： 987654

  • 字符串运算

    • 字符串拼接

      • “+”

    • 重复输出

  • 字符串转义

    • \n

  • 换行，打印字字符串过程中遇到 \n 会换行打印
    print('hello\npython')
    输出：
    hello
    python

    • \ 和 r
      • 在非特殊符号前面功能就是【续行符】
      • 在运算符或者特殊符号前面就是【关闭转义】

        • 打印\n

          print('\n')# r raw

          print(r'\n')
          \n# 打印引号

          print(""")
          print('"')
          输出："

      • 打印空格
        print(\000)

  • \\

    • 单独打印一个反斜杠是打印不出“\”的会报错

      • 正确打印方式# 通过转义打印

        print('\')

        \

      • 夹在字符串中间打印
        print('hello\hello')

  • 关闭转义（r）

    • 关闭转义，让等具有特殊意义的字符失效，按照原本的意思输出
      print(r'hello \n oython')

• 字符串常用方法

  • 单词大小写相关
    • upper：所有字母大写
      string.upper()
    • lower：所有字母小写
      string.lower()
    • 其他方法(了解)
      • capitalize：整个字符串首字母大写
        string.capitalize()
        new_str='python'
        print(new_str.capitalize())
        输出：Python
      • title：每个单词首字母大写
        string.title()
        new_str='hello python'
        print(new_str.title())
        输出：Hello Python
      • swapcase：大小写互换
        string.swapcase()

        new_str='Hello Python'
        print(new_str.swapcase())
        输出：hELLO pYTHON

  • 统计相关

    • count：返回子字符串在字符串中出现的次数
      string.count(sub, start= 0,end=len(string))

      • sub：搜索的子字符串
        • start：字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0
      • end：字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置

      str_1='1233333456789'
      new_str=str_1.count('3',0,len(str_1))
      print(new_str)
      输出：5

    • find：默认只查询第一个字符串，如果包含子字符串返回查找到的第一个字符串索引值，否则返回-1
      string.find(str, beg=0, end=len(string))

      • str：指定检索的字符串
      • beg：开始索引，默认为0
      • end：结束索引，默认为字符串的长度

      str_1='123456789'
      new_str=str_1.find('5',0,-1)
      print(new_str)
      4

    • rfind：返回字符串最后一次出现的位置，如果没有匹配项则返回 -1
      string.rfind(str,beg=0, end=len(string))

      • str：指定检索的字符串
      • beg：开始索引，默认为0
      • end：结束索引，默认为字符串的长度

      str_1='hello python'
      new_str=str_1.rfind('o')
      print(new_str)
      10

    • 判断相关

      • string.isupper()：判断字符串是否都是大写，返回布尔值
      • string.islower ()：判断字符串是否都是小写，返回布尔值
      • string.isalnum()：判断字符串是否由数字字母汉字组成，返回布尔值
      • string.isalpha()：判断字符串是否由字母汉字组成，返回布尔值
      • string.isspace()：判断是否有空格，返回布尔值
      • string.title()：判断字符串是否每个单词首字母大写，返回布尔值
  • 拆分&替换
    • string.split(sep=None, maxsplit=-1)：字符串拆分，默认空格拆分，可以指定字符切

      • sep：拆分字符
      • maxsplit=-1：最多进行多少次拆分，默认为-1表示不做限制，0表示不拆分
      • 拆分后的值作为一个list返回
      • 拆分过程中会丢弃拆分符号

        str="aafbbfccfddfee"
        new_str=str.split('f')
         ['aa','bb','cc','dd','ee']

    • string.join(iterable)：将序列中的元素以指定的字符连接生成一个新的字符串

      • iterable：元组、列表、字典、字符串
      • string：iterable内部元组间的连接符号

        # 用“-”连接
        new_string='-'.join(['I','love','python'])
        print(new_string)
         I-love-python

    • string.replace(old, new, count=None)：替换字符串，返回替换后的字符串，不会修改原来的字符串
      • old：需要替换的字符
      • new：替换后的字符
      • count：需要替换的个数，非必填，如不填，默认全部替换

        str_1 = '1233333333456789'
        # old, new, count=None
        new_str = str_1.replace('3', 'A', 1)
        print(new_str)
        输出：12A3333333456789

    • 其他方法
      • string.splitlines(keepends=None)：字符串拆分，按换行符进行拆分

        • \r：回车、\n：换行
        • keeppends(False) 在输出时是否去掉换行符(\r,\r\n,\n)默认False，如果改为True则保留换行符
      • string.zfill(width)：将 string 放右边，返回指定长度的字符串，长度不够在前面填充0

        • width：返回字符串的长度
      • string.center(width, fillchar=None)：将 string 放中间，返回指定长度的字符串，长度不够从字符串两边一起填充指定字符
        • width：返回字符串的长度
      • fillchar=None：指定填充字符，默认为None，填充空格
      • string.rjust(width, fillchar=None) 返回指定长度的字符串，从字符串左边填充指定字符
        • width：返回字符串的长度
    • fillchar=None：指定填充字符，默认为None，填充空格
  • string.ljust(width, fillchar=None) 返回指定长度的字符串，从字符串右边边填充指定字符
    • width：返回字符串的长度
    • fillchar=None：指定填充字符，默认为None，填充空格

• 字符串格式化输出

  • %（%相当于占位符）

    • %s：格式化字符串

      # 字符串
      price = 'the price is %s' %('none')
      print(price)
      the price is none
      
      # 数值
      price = 'the price is %s' %(100)
      print(price)
      输出：the price is 100

      • 注意点
        • 当%('test'）中 test 传的不是str类型，是数字的时候，会将数字强制转换成str

    • %d：格式化数值

      price = 'the price is %d' %(-100)
      print(price)
      输出：the price is -100

      • 注意点
        • 当%(10）括号中传的不是整数类型，且无法强制转换成整数类型的时候，会报错
        • 当%(10）括号中传的不是整数（int），是小数（float）的时候，会强制转换成整数，小数部分会被抹掉

    • %f：格式化浮点数

      • %f：不指定精度默认保留6位小数，无小数位就补0

        price = 'the price is %f' %(100)
        print(price)
        输出：the price is 100.000000

      • %.2f：指定保留两位小数

        price = 'the price is %.2f' %(100)
        print(price)
        输出：the price is 100.00

    • 其他用法

      • 百分号"%"，数字，点"."的用法

        • 数字在点前面：表示占多少个字符位置

          • 数字在点后面：表示保留几位小数

            """
            点前面的10表示该字浮点数前面占10个字符位置
            点后面的4表示该浮点数保留4位小数
            """
            print("this number is %10.4f" %(10.999)
            输出：this number is    10.9990

        • 横杠“-”的用法

          • 占位符数字前带杠（-）表示字符左对齐

          print ("Name:%-10s Age:%-8d Height:%-8.2f"%("Json",25,1.80))
          输出：Name:Json       Age:25       Height:1.80

          • 占位符数字前不带杠（-）表示字符右对齐
            print ("Name:%10s Age:%8d Height:%8.2f"%("Json",25,1.80))
            Name: Json Age: 25 Height: 1.80

    • format()函数

      • 按顺序取值
        print("my name is {} age {}".format('老王',20))
        输出：my name is 老王 age 20
      • 按索引取值
        print("my name is {1} age {0}".format('老王',20))
        输出：my name is 20 age 老王
      • 按关键字取值
        print("my name is {name} age {age}".format(age=20,name='老王'))
        输出：my name is 老王 age 20
      • 调整精度

        # .表示在小数点后面进行运算
        print('{:.2f}'.format(12.123456))
        输出：12.12

      • 百分比格式化

        # . 表示在小数点后面进行运算
        print("percent is {:.3%}".format(0.67899))
        输出：percent is 67.899%
        
        print("percent is {:%}".format(0.67899))
        输出：percent is 67.899000%
        
        print("percent is {:3%}".format(0.67899))
        输出：percent is 67.899000%

      • 其他用法
        • 进制转换

          # b:二进制； o: 八进制；x:十六进制)
          print('{:b}'.format(10))
          输出：1010

        • 千位分隔符

          print("{:,}".format(1234536789))
           输出：1,234,536,789

    • f"{}"

      name='老王'
      age=20
      print(f"my name is {name} age:{age}")
      输出：my name is 老王 age 20