python之字符串与序列

Day2-Night

• Python中没有字符这种类型，（而C中用单引号表示字符，双引号表示字符串），python中所谓的字符，就是长度为1的字符串。
• 字符串的内置方法（太多，不一 一敲了，列举几个）
  • rstrip()(末尾)/lstrip()(开头)/strip()（两端）【剔除字符串空白】
  • 因含有空格的字符串与为含有空格的是两个不同的字符串，且最好再存储用户输入前对它进行清理
  • 【转】：https://blog.csdn.net/csdn15698845876/article/details/73469234
  • title()/lower()/upper()【调整英文字母大小写】
    

    # coding=gbk
    str="MaGgie"
    print(str.title())#首字母大写
    print(str.lower())#全小写
    print(str.upper())#全大写

     

  • count(sub[,start[,end]]):查找sub子字符串出现的次数（Python中，用方括号[]括起来表示为可选），start和end表示查找范围
    

    str1="AbcABCabCabcABCabc"
    print(str1.count('ab',0,15))#2

  • find（sub[,start[,end]]）或index(sub[,start[,end]])：查找某个子字符串在该字符串中的位置，若找到，则返回值是第一个字符的索引值；若找不到，则find()方法返回-1，而index()方法抛出异常（注：异常是可以被捕获并处理的错误）

    str1="I love Ian Somerhalder"
    print(str1.find("Ian"))#7
    print(str1.find("good"))#-1
    print(str1.index("Ian"))#7
    print(str1.index("good"))#ValueError: substring not found

  • join(sub):连接字符串，但其是以字符串作为分隔符，插入到sub字符串中所有的字符之间
    

    # coding=gbk
    print(' '.join("text"))#t e x t
    print('_'.join("Maggie"))#M_a_g_g_i_e 注意，最后一个没有_
    
    print('I'+' '+'love'+' '+'Ian')#I love Ian
    print(' '.join(['I','love','Ian']))#同上

    对于大量的字符串拼接来说，使用join()方法的效率比连接符号（+）要高，因为加号连接会引起内存复制以及垃圾回收操作

  • replace(old,new,[,count]):替换指定的字符串

    str1="I love you"
    2 print(str1.replace("you","Maggie"))#I love Maggie

  • split(sep=None,maxsplit=-1):用于拆分字符串，与join()相反
    
    • 不带参数时，默认以空格为分隔符

      str1="I love Maggie"
      print(str1.split())#['I','love','Maggie']

    • 带参数时，第一个参数为分隔符分割，后一个参数表示分割次数
      

      # coding=gbk
      str1='_'.join("Maggie")
      print(str1.split('_'))#['M','a','g','g','i','e']
      str2= "www.abcd.com.cn"
      print(str2.split('.'))#以'.'为分隔符 ['www','abcd','com','cn']
      print(str2.split('.',2))#分割两次 第三次不再分割 ['www','abcd','com.cn']

• 字符串的格式化（规范化）:按统一的规格去输出一个字符串（类比进制间的转换）
•  format()方法接受位置参数和关键字参数，二者均传递到replacement字段（在字符串内由大括号{}表示）【注：不要漏掉print("".format("",""))中的各类符号】
• 不带参数/带位置参数/带关键字参数/位置参数和关键字参数综合使用
  

  # coding=gbk
  print("{0} love {1}".format("I","Maggie"))#I love Maggie 其中format的两个参数({0}、{1})就叫做位置参数
  print("{0} love {a},{b}".format("I",a="you",b="Maggie"))#I love you,Maggie 其中，{a}、{b}就叫做关键字参数
  print('a1 = {} a2= {}  a3= {}'.format('first','second','third'))  #{}不带参数 'a1 = first a2= second  a3= third'
  print('a1 = {1} a2= {0} a3= {2}'.format('first','second','third')) #{}带位置参数的 'a1 = second a2= first  a3= third'
  print('your name is {name} , age is {age}'.format(name='maggie',age=19)) #'your name is maggie , age is 19' 带关键字参数的
  print('your name is {name} , age is {age}'.format(age=19,name='maggie')) #'your name is maggie , age is 19' 同样和位置无关

• 打印大括号
  

  # coding=gbk
  print("{{0}}".format("不打印"))#{0} 打印大括号，再在外层加一层大括号即可（类似打印转义字符\用\\）

• 替换域的使用
  

  # coding=gbk
  print("{0}:{1:.2f}".format("圆周率",3.14159))#圆周率：3.14

   位置参数{1}后面的冒号表示格式化符号的开始，".2"的意思是四舍五入到保留两位小数点，f是定点数

• 格式化操作符：%（Python格式化符号及含义/格式化操作符的辅助指令）略...
• Python的转义字符及含义 略...
• 序列：列表、元组、字符串的统称。下面介绍一个序列常用的BIF（内置方法）
  • list([iterable]):将一个可迭代对象转换为列表。
    
  • 迭代：重复反馈过程的活动，其目的通常是为了接近并达到所需的目标或结果。每一次对过程的重复称为一次“迭代”，而每一次迭代所得到的结果即作为下一次迭代的初始值（for循环）

  • # coding=gbk
    a=list()    #创建一个空列表
    print(a)    #[] 
    
    b=list("Maggie")#将字符串中的每个字符迭代放到列表中
    print(b)    #['M','a','g','g','i','e']
    
    c=list((1,2,3))#将元组中的每个元素迭代存放到列表中
    print(c)    #[1,2,3]
    10 d=list(("maggie",))#将元组中的每个元素迭代存放到列表中
    11 print(c)	      #['maggie']

  • tuple([iterable]):将一个可迭代对象转换为元组
  • str(obj):把obj对象转换为字符串
  • len(sub):返回sub参数的长度(可用str/list/tuple...)
  • max():返回序列或参数集合中的最大值
  • min():返回序列或参数集合中的最小值 【注：max()和min()方法都要保证序列或参数的数据类型统一，否则出错】
  • sum(iterable[,start]):返回序列iterable的总和，参数start默认为0，若设置参数，则表示从该值开始加起
  • sorted(iderable,key=None,reverse=False)：用于返回一个排序的列表
    • 列表的内建方法 sort()和sorted()虽然效果一致，但区别：sort()是按列表原地排序，而sorted()是返回一个排序后的新列表
      

      # coding=gbk
      list1=[1,18,13,0,-98,34,54,76,32]
      list2=list1[:]        #拷贝list1
      list1.sort()        #从小到大排序
      print(list1)        #[-98, 0, 1, 13, 18, 32, 34, 54, 76] list1发生改变
      print(sorted(list2))#[-98, 0, 1, 13, 18, 32, 34, 54, 76] 返回一个新列表
      print(list2)        #[1, 18, 13, 0, -98, 34, 54, 76, 32] list2不变

  • reversed(sequence):返回逆向迭代序列的值
  • 列表的内建方法 reverse()和reversed效果虽然一致，但区别：reverse()是原地翻转，而reversed()是返回一个翻转后的迭代器对象
    

    # coding=gbk
    list1=[1,18,13,0,-98,34,54,76,32]
    print(reversed(list1))#<list_reverseiterator object at 0x033B0810> 返回一个迭代器对象
    for each in reversed(list1):
        print(each,end=',')#32,76,54,34,-98,0,13,18,1,

    Q：迭代器？迭代器对象？
  • enumerate(iterable):生成由二元组（就是元素数量为2的元组）构成的一个迭代对象，每个二元组是由可迭代参数的索引号及其对应的元素组成的
    

    # coding=gbk
    str1="Maggie"
    for each in enumerate(str1):
        print(each)
    　　#(0, 'M')
    　　#(1, 'a')
    　　#(2, 'g')
    　　#(3, 'g')
    　　#(4, 'i')
    　　#(5, 'e')

  • zip(iter1[,iter2[...]]):返回由各个可迭代参数共同组成的元组
    

    # coding=gbk
    str1="Maggie"
    list1=[1,2,3,4,5,6]
    for each in zip(list1,str1):
        print(each)
    #(1, 'M')
    #(2, 'a')
    #(3, 'g')
    #(4, 'g')
    #(5, 'i')
    #(6, 'e')
    
    tuple1=(4,5,6,7,8,9)
    for each in zip(list1,str1,tuple1):
        print(each)
    #(1, 'M', 4)
    #(2, 'a', 5)
    #(3, 'g', 6)
    #(4, 'g', 7)
    #(5, 'i', 8)
    #(6, 'e', 9)

• End...