零基础入门学Python系列内容的学习目录                                 →                            \rightarrow                 →零基础入门学Python系列内容汇总。

列表、元组和字符串（下）

• 1. 列表
• 2. 元组
• 3. 字符串
  • 3.2.1 format()
  • 3.2.2 格式化操作符：%
  • 3.2.3 Pyhton的转义字符及含义
  • 3.1 各种内置方法
  • 3.2 格式化
• 4. 序列

  需要学习的基础知识有：列表、元组、字符串、序列等。因本部分内容较多，故分为上下两个篇章。
    1、2部分内容见零基础入门学Python（五）—— 列表、元组和字符串（上）
    3、4部分内容见零基础入门学Python（五）—— 列表、元组和字符串（下）

1. 列表

2. 元组

  前半部分内容见零基础入门学Python（五）—— 列表、元组和字符串（上）。

3. 字符串

  字符串跟元组一样，都是一旦定下来就不能直接对它们进行修改了。对于之前应用到列表和元组中的分片概念，也可以应用于字符串之上，对字符串进行间接修改。

  example1:>>>str = “I am learning Python.”
       >>>str[ : 4 ]
       ‘I am’

  example2:>>>str = “I am learning Python.”
       >>>str[ : 4 ] + “插入的字符串” + str[ 4 : ]
       ‘I am插入的字符串 learning Python.’

  在C语言中，字符串和字符是两个不同的概念，字符用单引号' '表示，字符串用双引号" "表示。但在Python中并没有字符这个类型，对Python来说字符就是长度为1的字符串。当要访问字符串中的一个字符时，只需要用索引列表和元组的方法来索引字符串即可。

  example3:>>>str = “I am learning Python.”
       >>>str[ 6 ]
       e

3.1 各种内置方法

  Python有很多的字符串方法，表1总结了字符串所有方法及对应的含义。

3.2 格式化

  格式化字符串，就是按照统一的规格去输出一个字符串。关于格式化字符串这部分内容的学习，推荐两篇文章：1、Python格式化字符串，这个方法你值得拥有！；2、安利三个关于Python字符串格式化的进阶知识。

3.2.1 format()

  format()方法接受位置参数和关键字参数，二者均传递到一个叫做replacement的字段，这个replacement字段在字符串内由大括号{ }表示。

  example1:>>>"{0} am {1} {2}".format(" I " , " learning " , " Python ")
       ‘I am learning Python’
  example1中的{0}、{1}和{2}均跟位置有关，依次被format()的三个参数替换，那么format()的三个参数就叫作位置参数。

  example2:>>>"{a} am {b} {c}".format(a = " I ",b = " learning ",c = " Python ")
       ‘I am learning Python’
  example2中的{a}、{b}和{c}相当于三个标签，format()将参数中等值的字符串替换进去，这就是关键字参数。

  我们可以将位置参数和关键字参数综合起来一起使用，但是位置参数必须在关键字参数之前，否则会报错。
  example3:>>>"{0} am {b} {c}".format(" I ",b = " learning “,c = " Python “)
       ‘I am learning Python’
       >>>”{a} am {b} {0}”.format(a = " I ",b = " learning ", " Python ")
       SyntaxError: positional argument follows keyword argument

  如果想要把大括号打印出来，跟字符串转义字符有点像，只是需要用多一层大括号括起来即可。
  example4:>>>"{{0}}".format(" 不打印 ")
       ‘{0}’
  example4中的位置参数“不打印”并没有被打印出来，这是因为{0}的特殊功能被外层的大括号{ }剥夺了，因此没有字段可以输出。

  example5:>>>"{0}:{1:.2f}".format(" 圆周率",3.14159)
       ’ 圆周率:3.14’
  example5中可以看到位置参数{1}跟之前不同，后边多了一个冒号。在替换域中，冒号表示格式化符号的开始，".2"的意思是四舍五入保留到两位小数点，而f的意思是浮点数。

3.2.2 格式化操作符：%

  %：当%的左右均为数字的时候，那么它表示求余数的操作；但当它出现在字符中的时候，它表示的是格式化操作符。表2列举了Python的格式化符号及含义。

  example1:>>>’ % c ’ % 97
       ’ a ’
       >>>’ % d 转换为八进制是 % o ’ % (123, 123)
       ’ 123 转换为八进制是 173 ’
       >>>’% f 用科学计数法表示为：% e’ %(149500000, 149500000)
       ’ 149500000.000000 用科学计数法表示为： 1.495000e+08’

  Python还提供了格式化操作符的辅助指令，如表3所示。

  example2:>>>’ % 5.2f ’ % 27.658
       ’ 27.66 ’
       >>>’ % .2e ’ % 27.658
       ’ 2.77e+01 ’
       >>>’ % 10d ’ % 5
       ’     5 ’
       >>>’% -10d ’ % 5
       ’ 5     ’
       >>>’ % 010d ’ % 5
       ’ 000000005 ’
       >>>’ % #X ’ % 100
       ’ 0X64 ’

3.2.3 Pyhton的转义字符及含义

  Pyhton的转义字符及含义如表4所示。

4. 序列

  通过之前的学习，我们可以发现列表、元组和字符串之间有很多共同点：

• 都可以通过索引得到每一个元素‘
• 默认索引值总是从0开始；
• 可以通过分片的方法得到一个范围内的元素的集合；
• 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

  我们把它们统称为序列。

  学习一下关于序列常用的BIF。

• 1. list([iterable])
  list()方法用于把一个可迭代对象转换为列表。
    example1:>>># 创建一个空列表
         >>>a = list()
         >>>a
         [ ]
    example2:>>># 将字符串的每个字符迭代存放到列表中
         >>>b = list(“Python”)
         >>>b
         [‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]
    example3:>>># 将元组中的每个元素迭代存放到列表中
         >>>c = list((1, 1, 2, 3, 5, 8, 13))
         >>>c
         [1, 1, 2, 3, 5, 8, 13]
• 2. tuple([iterable])
  tuple()方法用于把一个可迭代对象转换为元组，具体用法和list一样。
    example1:>>>a = tuple()
         >>>a
         ()
    example2:>>>b = tuple(“Python”)
         >>>b
         (‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’)
    example3:>>>c = tuple((1, 1, 2, 3, 5, 8, 13))
         >>>c
         (1, 1, 2, 3, 5, 8, 13)
• 3. str(obj)
  str()方法用于把obj对象转换为字符串。
    example1:>>>a = 5.99
         >>>b=str(a)
         >>>b
         ‘5.99’
• 4. len(sub)
  len()方法用于返回sub参数的长度。
    example1:>>>str1 = “I am learning Python.”
         >>>len(str1)
         21
    example2:>>>list1 = [1, 1, 2, 3, 5, 8, 13]
         >>>len(list1)
         7
    example3:>>>tuple1 = “这”, “是”, “一”, “个”, “元组”
         >>>len(tuple1)
         5
• 5. max(…)
  max()方法用于返回序列或者参数集合中的最大值。max()参数可以是一个序列，返回值是该序列中的最大值；也可以是多个参数，返回值是这些参数中最大的一个。
    example1:>>>str1 = “I am learning Python.”
         >>>max(str1)
         ‘y’
    example2:>>>list1 = [1, 1, 2, 3, 5, 8, 13]
         >>>max(list1)
         13
    example3:>>>tuple1 = (1, 1, 2, 3, 5, 8, 13)
         >>>max(tuple1)
         13
• 6. min(…)
  min()方法用于返回序列或者参数集合中的最小值，跟max()效果相反。要注意的是，使用min()和max()方法都要保证序列或者参数的数据类型统一，否则会出错。
    example1:>>>list1 = [1, 1, 2, 3, 5, 8, 13]
         >>>list1.append(“x”)
         >>>max(list1)
         Traceback (most recent call last):
          File “
• 7. sum(iterable[, start])
  sum()方法用于返回序列iterable的总和，用法跟max()和min()一样。但是sum()方法有一个可选参数(start)，如果设置该参数，表示从该值开始加起，默认值是0。
    example1:>>>tuple1 = 1, 2, 3, 4, 5
         >>>sum(tuple1)
         15
         >>>sum(tuple1, 10)
         25
• 8. sorted(iterable, key = None, reverse = False)
  sorted()方法用于返回一个排序的列表。它跟列表的内建方法sort()效果一样，但是列表的内建方法sort()是实现列表原地排序；而sorted()是返回一个排序后的新列表。
    example1:>>>list1 = [1, 8, 13, 0, -98, 34, 54, 76, 32]
         >>>list2 = list1[ : ]
         >>>list1.sort()
         >>>list1
         [-98, 0, 1, 8, 13, 32, 34, 54, 76]
         >>>sorted(list2)
         [-98, 0, 1, 8, 13, 32, 34, 54, 76]
         >>>list2
         [1, 8, 13, 0, -98, 34, 54, 76, 32]
    通过example1中的结果可以看出，list1用sort()排序后自身发生了变化，而list2用sorted()排序后自身没有发生变化，得到了一个新列表。
• 9. reversed(sequence)
  reversed()方法用于返回逆向迭代序列的值。它跟列表的内建方法reverse()效果一样，但是列表的内建方法reverse()是原地翻转；而reversed()是返回一个翻转后的迭代器对象。
    example1:>>>list1 = [1, 8, 13, 0, -98, 34, 54, 76, 32]
         >>>reversed(list1)
         
• 10. enumerate(iterable)
  enumerate()方法生成由二元组（二元组就是元素数量为二的元组）构成的一个迭代对象，每个二元组是由可迭代参数的索引号及其对应的元素组成的。
    example1:>>>str1 =“Python”
         >>>for each in enumerate(str1):
             print(each)
         (0, ‘P’)
         (1, ‘y’)
         (2, ‘t’)
         (3, ‘h’)
         (4, ‘o’)
         (5, ‘n’)
• 11. zip(iter1[, iter2[…]])
  zip()方法用于返回由各个可迭代参数共同组成的元组。
    example1:>>>list1 =[1, 3, 5, 7, 9, 11]
         >>>str1 =“Python”
         >>>for each in zip(list1,str1):
             print(each)
         (1, ‘P’)
         (3, ‘y’)
         (5, ‘t’)
         (7, ‘h’)
         (9, ‘o’)
         (11, ‘n’)
    example2:>>>list1 =[1, 3, 5, 7, 9, 11]
         >>>tuple1 =(2, 4, 6, 8, 10, 12)
         >>>str1 =“Python”
         >>>for each in zip(list1,str1,tuple1):
             print(each)
         (1, ‘P’, 2)
         (3, ‘y’, 4)
         (5, ‘t’, 6)
         (7, ‘h’, 8)
         (9, ‘o’, 10)
         (11, ‘n’, 12)