Python从入门到全栈开发 python从入门到进阶

Python小白的进阶之路---Day2

• 1. 列表

• 1.1 标志
• 1.2 基本操作

• （1）创建列表
• （2）向列表添加元素
• （3）从列表删除元素
• （4）拷贝

• 1.3列表相关方法

• 2.元祖

• 2.1标志
• 2.2 基本操作

• （1）创建元组
• （2）不可变性

• 3.string 字符串

• 3.1 定义及基本操作
• 3.2 字符串相关方法

• 4. 字符串格式化问题

• 4.1`format()`
• 4.2 `%`格式化操作符

参考链接：

https://study.163.com/course/courseMain.htm?courseId=378003

1. 列表

1.1 标志

  列表的标志性符号为[]很多接触过编程朋友都听过“数组”这个概念。数组，就是把一大堆同种类型的数据挨个摆在一块，然后通过数组下标进行索引。但数组有一个基本要求，就是你所放在一起的数据必须类型一致。由于Python的变量没有数据类型，也就是说，Python是没有数组的。但是，Python加入了更为强大的列表。
  Python的列表有多强大？如果把数组比作一个集装箱的话，那么Python的列表就是一个工厂的仓库了。列表非常有用，基本上所有的Python程序都要使用到列表。

1.2 基本操作

（1）创建列表

  创建列表和创建普通变量一样，用中括号[ ]括起一堆数据就可以了，数据之间用逗号隔开，这样一个普普通通的列表就创建成功了。如果实在想不到要往列表里面塞什么数据的时候，可以先创建一个空列表。

>>> number=[1,2,3,4,5]
>>> number
[1, 2, 3, 4, 5]
>>>empty=[]    #创建一个空列表

（2）向列表添加元素

第一种是append()方法：

number=[1,2,3,4,5]
>>> number.append(8)
>>> number
[1, 2, 3, 4, 5, 8]

  中间这“.”，暂时可以理解为范围的意思：append()这个方法是属于一个叫做number的列表对象的。但是不能用append()同时添加多个元素。

number=[1,2,3,4,5]
number.append(8,9,10)
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    number.append(8,9,10)
TypeError: append() takes exactly one argument (3 given)

  这时候，我们就可以用第二种方法extend()，它事实上是使用一个列表来扩展另一个列表，所以它的参数应该是一个列表：

>>> number=[1,2,3,4,5]
>>> number.extend([7,8])
>>> number
[1, 2, 3, 4, 5, 7, 8]

  到目前为止，我们都是往列表的末尾添加数据，万一我想“插队”呢。最后，我们来学习这种方法，那就是insert()，它有两个参数：第一个参数代表在列表中的位置，第二个参数是在这个位置处插入一个元素。注意！凡是顺序索引，Python均从0开始，这也是大部分编程语言约定俗成的规范。

>>">>>> number.insert(1,'add')
>>> number
[1, 'add', 2, 3, 4, 5]

（3）从列表删除元素

在这里我们也可以用三种方法，分别为remove()、del、pop()。
  使用remove（）删除元素，你并不知道这个元素在列表的具体位置，只需要知道该元素存在在列表中就可以了。如果删除的东西不在列表中，程序就会报错。

>>> name=[1,2,3,4,5]
>>> name.remove(1)
>>> name
[2, 3, 4, 5]

>>> name.remove('1')
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    name.remove('1')
ValueError: list.remove(x): x not in list

  若想删除某个位置的元素，这就要用del来实现，del是一个语句，不是一个列表的方法，所以不必在它后面加上小括号。另外，如果你想删除整个列表，还可以用del加列表名删除。

>>> name=[1,2,3,4,5]
>>> del name[1]
>>> name
[1, 3, 4, 5]

>>> del name
>>> name
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    name
NameError: name 'name' is not defined

  最后，学习了pop()方法，它是默认弹出列表的最后一个元素。但pop()方法其实还可以灵活运用，当你为它加上一个索引值作为参数的时候，它会弹出这个索引值对应的元素。

>>> name=[1,2,3,4,5]
>>> name.pop()
5
>>> name
[1, 2, 3, 4]
>>>

>>> name=[1,2,3,4,5]
>>> name.pop(4)
5
>>> name
[1, 2, 3, 4]

（4）拷贝

  利用索引值，每次可以在列表中获取一个元素，但人总是贪心的，如果需要一次性获取多个元素呢？利用列表分片[:]，可以满足这个要求。

>>> name=['A','B','C','D','E']
>>> name[0:2]
['A', 'B']

  如上程序，用一个冒号隔开两个索引值，左边是开始的位置，右边是结束位置。要注意一点，结束位置上的元素是不包含的。

>>> name[:2]
['A', 'B']
>>> name[1:]
['B', 'C', 'D', 'E']
>>> name[:]
['A', 'B', 'C', 'D', 'E']

  列表分片可以简写，若没有开始的位置，会默认从0开始，同样道理，结尾也可以省去。如果没有放入任何索引值，而只有一个冒号，将得到整个列表的拷贝。
  列表分片就是建立原列表的一个拷贝（或副本），所以如果你想对列表做出某些修改，但还想同时保持原来的列表，就用分片的方法。
  注意列表拷贝的容易混淆的地方：

>>> list1=[1,3,2,9,7,8]
>>> list2=list1[:]
>>> list3=list1
>>> list3
[1, 3, 2, 9, 7, 8]
>>> list1.sort()
>>> list1
[1, 2, 3, 7, 8, 9]
>>> list2
[1, 3, 2, 9, 7, 8]
>>> list3
[1, 2, 3, 7, 8, 9]

分片方式得到的list2没有因为list1的改变而改变，达到了你想要拷贝的目的，以后写代码的时候要注意哦！请看分析图：

1.3列表相关方法

再来学习一些列表的常用方法：
  count()这个方法的作用是计算参数在列表出现的次数：

>>> list1=[1,1,2,3,4,1,5]
>>> list1.count(1)
3

  index()这个方法会返回它的参数在列表中的位置；index（）方法还有两个参数，用于限定查找的范围，这样就可以查找到第二个目标在list1的位置。

>>> list1.indext(1)
0

>>> start=list1.index(1)+1
>>> stop=len(list1)
>>> list1.index(1,start,stop)
1
>>>

  reserve()的作用是将列表原地翻转。

>>> list1=[1,2,3,4,5]
>>> list1.reverse()
>>> list1
[5, 4, 3, 2, 1]

  sort()使用指定的方式对列表的成员进行排序，默认不需要参数，从小到大排队。

>>> list=[1,4,5,6,2,6,3,9]
>>> list1=[1,4,5,6,2,6,3,9]
>>> list1.sort()
>>> list1
[1, 2, 3, 4, 5, 6, 6, 9]

有关列表的小结：

2.元祖

2.1标志

  元祖的标志性符号是“逗号”！如果要创建的元祖中只有一个元素，请在它的后面加上一个逗号（，），这样可以明确地告诉Python你要的是一个元祖，不要拿什么整型、浮点型来忽悠你。元组是有序的，不能修改。

2.2 基本操作

（1）创建元组

创建元组大部分用的是小括号()。若只有一个元素，则它的后面加上一个逗号。

>>> temp=(1,2,3)
>>> type(temp)
<class 'tuple'>

>>> temp=(1)
>>> type(temp)
<class 'int'>
>>> temp=(1,)
>>> type(temp)
<class 'tuple'>

  访问元组的方式与列表一样，并且也使用分片的方式复制元组。

（2）不可变性

  元组与多数Python集合（列表， 字典， 集，等待）一样，保存的是对象的引用。如果引用的元素是可变的，即元组本身不可变，元素依然可变。也就是说，元组的不可变性其实是指的是tuple数据结构的物理内容（即保存的引用）不可变，与引用的对象无关。
  若想更新元组，可以通过分片的方法让元组拆分为两部分，然后再使用连接操作符+合并成一个新元组，最后将原来的变量名指向连接好的新元组。
  在日常使用中，很少用del去删除整个元组，因为Python的回收机制会在元组不再被使用到的时候自动删除。

3.string 字符串

3.1 定义及基本操作

  我们所认知的字符串就是引号内的一切东西，字符串是文本与数字是截然不同的。它与元组一样，一旦定下来就不可修改。

3.2 字符串相关方法

4. 字符串格式化问题

  格式化字符串，就是按照统一的规格去输出一个字符串。如果规格不统一就会造成误会。字符串格式化允许在一个单个的步骤中对一个字符串执行多个特定类型的替换，特别是给用户提示的时候，格式化非常方便。我们来学习两种方法：

4.1format()

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

>>> "{0} love {1}{2}".format ('I','JJ','Lin')
'I love JJLin'

  字符串中的{0}{1}{2}和位置有关，依次被format()的三个参数替换，format()的三个参数就叫做位置参数。

>>> "{a} love {b}{c}".format (a='I',b='JJ',c='Lin')
'I love JJLin'

  {a}{b}{c}相当于三个标签，format()将参数等值的字符串替换进去，这就是关键字字符。
  如果将位置参数和关键字参数综合在一起使用，那么位置参数必须在关键字参数之前，否则会报错。

格式限定符
a.填充与对齐

• 填充常跟对齐一起使用
• ^、<、>分别是居中、左对齐、右对齐，后面带宽度
• :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

>>> '{:<9}'.format('1992')
'1992     '
>>> '{:>9}'.format('1992')
'     1992'
>>> '{:0>9}'.format('1992')
'000001992'
>>> '{:0<9}'.format('1992')
'199200000'
>>> '{:a<9}'.format('1992')
'1992aaaaa'

精度与类型f ：精度常跟类型f一起使用，如.2表示长度为2的精度，f表示float类型。

>>> '{:.2f}'.format(3.1415926)
    '3.14'

其他类型
　　主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。

>>> '{:b}'.format(9)
'1001'
>>> '{:d}'.format(9)
'9'
>>> '{:o}'.format(9)
'11'
>>> '{:x}'.format(9)
'9'

用‘，’号还能用来做金额的千位分隔符。

>>> '{:,}'.format(1234567890)
'1,234,567,890'

4.2 %格式化操作符

下面为实际运行的例子：

>>> '%c'% 65
    'A'