Python 学习笔记 列表和元组

元组创建好之后就是不可变的，但是列表是可以变的，可以修改的。

创建元组使用圆括号，创建列表使用方括号。

元组和列表的切片，用法同字符串。slice 的完整语法格式 [start , end ,step]，step 步长默认是 1 咯。

元组和列表的加法，就是将包含的元素加到一块，注意这里不会删除重复的元素。列表只能和列表相加，元组只能和元组相加，不能混合相加。

元组和列表的乘法，就是把元素重复 n 次。

当元组只有一个元素的时候，必须要在唯一的元素后面加上逗号，而列表则不用这样。

>>> c=('123')
>>> print(c)
123
>>> type(c)

>>> 
>>> d=(123)
>>> type(d)

>>> e=(123,)
>>> f=('123',)
>>> print(type(e),type(f))
 

列表则不用

>>> a=[123]
>>> print(a)
[123]
>>> type(a)

>>> b=['123']
>>> type(b)

运算符 in 和 not in 判断元组和列表里是否包含有某个元素。

列表和元组的三个全局函数， len() 返回元素个数，max()返回最大元素，min() 返回最小元素，比较的时候是采用字典序比较。

序列封包，是指将多个值赋给一个变量，这个变量保存为元组类型。

序列解包，就是元组或者列表赋给多个变量，这多个变量分别保存一个序列的元素。

注意，封包时只能封装成元组，解包时可以对元组解包，也可以对列表解包。

>>> a,b,c,d,e = tuple(range(1,10,2))
>>> print(a,b,c,d,e)
1 3 5 7 9

>>> a,b,c,d,e = range(1,10,2)
>>> print(a,b,c,d,e)
1 3 5 7 9

>>> a = 10,20,30
>>> print(a)
(10, 20, 30)
>>> type(a)

第一个演示代码里，将 range() 返回的一个区间对象转成元组，可以看出元组和列表都可以解包。

在此基础上，同时运用封包和解包，就可以让赋值运算符支持同时将多个值赋给多个变量。

>>> x,y,z = 10,20,30
>>> print(x,y,z)
10 20 30

在此基础上，可以不用中间变量就可以直接交换变量的值。

>>> x,y,z = y,z,x
>>> print(x,y,z)
20 30 10

解包的时候，在左边的变量前面加上 * 符号，表示这个变量是一个列表，这样就可以实现不完全解包。

>>> a,*b,c = range(10)
>>> print(a,b,c)
0 [1, 2, 3, 4, 5, 6, 7, 8] 9
>>> 
>>> a,*b,*c = range(1,10)
SyntaxError: two starred expressions in assignment
>>> 

创建元组和列表时，除了用括号显式地创建之外，还可以用 list() 和 tuple() 函数来创建，其实是强转。

在 Python 3 里面，range() 函数返回的是一个区间对象，不是列表。

利用列表的三个成员方法 append() ，entend()，insert() 给列表添加元素。

append() 和 extend() 都是在末尾添加元素。当添加的是列表或者元组的时候，append() 把它们看成一个整体，形成列表中的嵌套。而 extend() 不看成整体，值是追加列表或者元组里的每一个元素。

insert() 方法的两个参数是插入的位置（一个索引和待插入的对象）。

>>> a = [1,2,3]
>>> a.insert(1,"abc")
>>> print(a)
[1, 'abc', 2, 3]

>>> a.insert(3,tuple('hahah'))
>>> print(a)
[1, 'abc', 2, ('h', 'a', 'h', 'a', 'h'), 3]
>>> 

这里 "hahah" 作为一个字符串，强转为元组的时候，字符串的每一个字符都被拆开了。如果是只有这个字符串一个元素的元组，后面必须要有一个逗号，否则它就不是元组而是一个字符串。可以看出，当插入一个元组的时候，这个元组是作为一个整体的，在外面有一个括号括起来的。

del 语句删除列表元素和变量。

>>> a = list(range(10))
>>> print(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del a[2:-2:2]
>>> print(a)
[0, 1, 3, 5, 7, 8, 9]
>>> 
>>> b = 20
>>> del b
>>> print(b)
Traceback (most recent call last):
  File "", line 1, in 
    print(b)
NameError: name 'b' is not defined

列表的 remove() 方法，按值删除元素，并且只删除第一个。

>>> a = list(range(10))
>>> print(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a.extend([1,2,6,8,9])
>>> print(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 6, 8, 9]
>>> a.remove(6)
>>> print(a)
[0, 1, 2, 3, 4, 5, 7, 8, 9, 1, 2, 6, 8, 9]

列表 clear() 方法，清空列表。

>>> a.clear()
>>> print(a)
[]

修改列表元素，既可以按照索引修改，也可以使用分片修改。分片修改时，并不要求新赋值的元素个数与原来的元素个数相等，也就说可以通过修改来增加元素，也可以通过修改来减少元素。

>>> a = [1,2,3,4,5,6,7,8,9,10]
>>> a[1:3] = ['a','b']
>>> print(a)
[1, 'a', 'b', 4, 5, 6, 7, 8, 9, 10]
>>> a[2:2]='abc'
>>> print(a)
[1, 'a', 'a', 'b', 'c', 'b', 4, 5, 6, 7, 8, 9, 10]
>>> a[8:] = []
>>> print(a)
[1, 'a', 'a', 'b', 'c', 'b', 4, 5]
>>> a[1:6:2] = ['cdd','ff','g']
>>> print(a)
[1, 'cdd', 'a', 'ff', 'c', 'g', 4, 5]
>>> a[2] = "hahaha"
>>> print(a)
[1, 'cdd', 'hahaha', 'ff', 'c', 'g', 4, 5]
>>> a[2:4] = ["kkg","gkk"]
>>> print(a)
[1, 'cdd', 'kkg', 'gkk', 'c', 'g', 4, 5]

如果使用字符串赋值，Python 会自动把字符串当成序列处理，将字符串解析成序列，其中每个字符都是一个元素。如果在分片赋值的时候，指定了步长，那么符号两边的数量一定要相等。

不太理解什么时候会将字符串解析成字符序列，什么时候不会解析。

list.count() 参数是某个元素的值，返回这个元素出现的次数。

list.index() 参数是要查找的值，返回第一次出现的位置。还可以加上第二个参数，指定从哪儿开始找起。

list.pop() 出栈函数，删除列表最后一个元素，并返回这个弹出的元素。 list.append() 函数就相当于入栈函数了。

list.reverse() 将列表元素反转。

list.sort() 函数排序，按照字典序从小到大排序。

list.sort() 函数可以指定  key 为按照什么来排序，指定 reverse 参数为 True 则实现从大到小排序。

>>> a = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
>>> print(a.count('Go'))
1
>>> print(a.index('Ruby'))
2
>>> print(a.index('Ruby',3))
Traceback (most recent call last):
  File "", line 1, in 
    print(a.index('Ruby',3))
ValueError: 'Ruby' is not in list
>>> print(a.pop())
Erlang
>>> print(a)
['Python', 'Swift', 'Ruby', 'Go', 'Kotlin']
>>> a.reverse()
>>> print(a)
['Kotlin', 'Go', 'Ruby', 'Swift', 'Python']
>>> a.sort()
>>> print(a)
['Go', 'Kotlin', 'Python', 'Ruby', 'Swift']
>>> a = ['Go', 'Kotlin', 'Python', 'Ruby', 'Swift']
>>> a.sort(key=len,reverse=True)
>>> print(a)
['Kotlin', 'Python', 'Swift', 'Ruby', 'Go']

这里，key = len，就是按照元素字符串的长度来排序。

创建字典时，需要根据 key 来访问 value ,所以字典的 key 不能有重复。

元组可以作为字典的 key ，但是列表不可以作为 key，因为列表内容可变。

>>> vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
>>> print(vegetables)
[('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
>>> 
>>> cars = [['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]
>>> print(cars)
[['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]

使用这种方法创建字典时，每一个列表或者元组都是一个 key_value 对，所以这里的列表或者元组都只能有两个元素。

通过 dict() 函数创建字典时，无参则创建空字典，指定参数创建字典的话，这时候 key 不能是表达式。

>>> a = dict(spinach = 1.39, cabbage = 2.59)
>>> print(a)
{'spinach': 1.39, 'cabbage': 2.59}

这里的 spinach 和 cabbage 都被视为是字符串。

通过 key 来访问字典

>>> a = dict()
>>> print(a)
{}
>>> a['语文'] = 100
>>> a['数学'] = 98
>>> print(a['语文'])
100
>>> del a['数学']
>>> print(a)
{'语文': 100}
>>> a['语文'] = 85
>>> print(a)
{'语文': 85}
>>> print('数学' in a)
False

注意：字典里面的 in 和 not in 判断都是基于 key 来判断的。

dict.update(dict_1) 函数是用 dict_1 这个词字典去更新 dict 这个 字典

>>> cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>> cars.update({'BMW':6,'ADD':12})
>>> print(cars)
{'BMW': 6, 'BENS': 8.3, 'AUDI': 7.9, 'ADD': 12}

items()、keys()、values()

items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。Python 不希望用户直接操作这几个方法，但可通过 list() 函数把它们转换成列表，然后通过访问列表来获得原来字典的 key-value，key，value。

>>> cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>> ims = cars.items()
>>> print(list(ims))
[('BMW', 8.5), ('BENS', 8.3), ('AUDI', 7.9)]
>>> print(list(ims)[1])
('BENS', 8.3)

pop() 函数的参数是一个 Key，函数会删除这个 key-value，并返回它的 value。

>>> cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>> print(cars.pop('BENS'))
8.3

popitem() 方法返回字典最底层存储的一个 key-value，并把它删除。得到的 key-value 是一个元组，可以序列解包的方法赋值给两个变量，分别保存 key 和 value。

>>> cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>> a = cars.popitem()
>>> print(a)
('AUDI', 7.9)
>>> print(cars)
{'BMW': 8.5, 'BENS': 8.3}
>>> x,y = a
>>> print(x,y)
AUDI 7.9

dict.setdefault() 两个参数分别是 key ,value，如果字典中存在这个 key ，则返回字典中这个 key 的 value ，并不会修改字典。如果不存在，添加这么一个 key-value ，并返回新加的 value。调用函数的时候 value 参数可省，默认是 None。

>>> cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>> print(cars.setdefault('BMW',6))
8.5
>>> print(cars)
{'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>> print(cars.setdefault('ABC',6))
6
>>> print(cars)
{'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9, 'ABC': 6}
>>> print(cars.setdefault('hhh'))
None
>>> print(cars)
{'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9, 'ABC': 6, 'hhh': None}

fromkeys() 函数使用多个指定的 keys 创建字典，这里的多个 keys 可以说元组形式，也可以是列表形式。可以在调用函数的时候给这些 keys 指定 value ，也可以省去，则默认是 None。

>>> a = dict.fromkeys(['a', 'b'])
>>> print(a)
{'a': None, 'b': None}
>>> b = dict.fromkeys(('a', 'b'))
>>> print(b)
{'a': None, 'b': None}
>>> c = dict.fromkeys(['a', 'b'],'sss')
>>> print(c)
{'a': 'sss', 'b': 'sss'}
>>> d = dict.fromkeys(['a', 'b'],[14,15])
>>> print(d)
{'a': [14, 15], 'b': [14, 15]}

如果函数给这多个 key 指定 value ，只能指定一个值，这个值被所有的 key 共有。

字典实现格式化输出

正常的输出：

>>> name = "Python基础教程"
>>> price = 99
>>> publish = "C语言中文网"
>>> print('教程是:%s, 价格是:%010.2f, 出版社是:%s'%(name,price,publish))
教程是:Python基础教程, 价格是:0000099.00, 出版社是:C语言中文网

用字典的时候，前面的字符串里面，必须要指定 key ,后面输出的时候就会用字典里对应的 value 去填充 %(key)4.8f 这样形式的占位符。

print('教程是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'%{'name':'Python基础教程', 'price': 99, 'publish': 'C语言中文网'})

或者

>>> a = '教程是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'
>>> b = {'name':'Python基础教程', 'price': 99, 'publish': 'C语言中文网'}
>>> print(a%b)
教程是:Python基础教程, 价格是:0000099.00, 出版社是:C语言中文网