列表、元组和字符串

列表、元组和字符串

---

列表

1.创建列表

创建列表和创建普通变量一样 ，用中括号括起一堆数据就可以了,数据之间用逗号隔开，这样一个普普通通的列表就创建成功了:

>>>number = [1, 2, 3, 4, 5]

我们说列表是打了激素的数组不是没有道理的,可以创建一个鱼龙混杂的列表:

>>>mix = [1, "小甲鱼"，3.14, [1, 2, 3]]

	可以看到上边这个列表里有整型、字符串、浮点型数据,甚至还可以包含着另一个列表。当然,如果实在想不到要往列表里边塞什么数据的时候，可以先创建一个空列表:

>>>empty = []

2.向列表里面添加元素

	append()方法(自动添加到末尾，而且只能添加一个元素)

举例说明：

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

	extend()方法，参数是一个列表，而且也只能添加到末尾

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

	insert(a,b)函数，a为插入的参数在列表中的位置，b为插入的元素

>>>number.insert(0,0)
>>>number
[1, 0, 2, 3, 4, 5, 6, 7, 8]

默认第一个元素为0位(和C语言一样)

3.从列表中获取元素

就举例说明吧…没有什么好说的

>>>name = ['a','b','c','d']
#如	果想要互换的话，下面举例说明
>>>name[1], name[3] = name[3], name[1]

4.从列表删除元素

	remove()，并不需要知道这个元素在列表中的具体位置，只要知道这个元素存在于列表中就可以了

>>>name.remove('a')
>>>name
['b', 'c', 'd']

	del()，是一个语句，不是一个列表的方法，不需要在后面加上()。而且，如果想要删除整个列表的话，就用del加上列表名

举例如下：

>>>del name[1]
>>>name
['b', 'd']

	pop()，弹出元素，默认弹出最后一个元素，但是如果加上一个索引值作为参数的话，他会弹出这个索引值对应的元素

>>>name['a', 'b', 'c', 'd']
>>>name.pop()
'd'
>>>name,pop()
'c'
>>>name
['a', 'b']

>>>name = ['a', 'b', 'c', 'd']
>>>name.pop(2)
'c'
>>>name
['a', 'b', 'c']

5.列表分片(一次性获得多个元素)

(个人感觉就是一种更加简单的写法)

• 列表名称[a:b] ：从a开始，一直到b-1结束
• 列表名称[:c] ：从头开始，一直到c-1
• 列表名称[d:] ：从d开始(包括d)，一直到最后
• 列表名称[:] ：全列表

如果不是顺序取元素呢？如果是隔一个取一个呢？

	列表名称[ a : b : c]第三个数指的是步长

>>>list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>list[0:9:2]
[1, 3, 5, 7, 9,]

更有意思的是，如果步长为负数，那么列表反转

>>>list[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

6.一些常用的操作符

(1)此前学过的大多数操作符都可以运用到列表上:

>>>listl=[123]
>>> list2 = [234]
>>> list1 > list2
False
>>> list3 = [ 'abc']
>>> list4 = [ 'bcd']
>>> list3 < list4
True

但是如果一个列表中有两个甚至多个元素呢

>>>list1 = [ 123，456]
>>>list2 = [ 234 , 1 23]
>>> list1 > list2
False

	由此得出结论：当列表包含多个元素的时候，默认是从第一个元素开始比较，只要有一个PK赢了，就算整个列表赢了。字符串比较也是同样的道理(字符串比较的是第一个字符对应的ASCII码值的大小)。

我们知道字符串可以用加号(+)来进行拼接,用乘号( * )来复制自身若干次。它们在列表身上也是可以实现的:

>>> list1 = [123, 456]
>>>list2 = [234, 123]
>>>list3 = list1 + list2
>>>list3
[123,456,234,123]

(2)重复操作符(*)：

>>> list1 = [123]
>>> list1 * 3
[123，123, 123]

(3)成员关系操作符：in和not in

>>>list1 = ["小猪"， "小猫"，"小狗"，"小甲鱼"]
>>>"小甲鱼”in list1
True
>>>"小护士”not in list1
True

之前说过列表里边可以包含另一个列表，那么对于列表中的列表元素呢？

>>>1ist1 = ["小猪"，"小猫"，["小甲鱼"，"小护士"]，"小狗"]
>>> "小甲鱼" in list1
False
>>> "小护士”not in list1
True

	所以我们知道，in和not in只能判断一个层次的成员关系，这跟break和continue语句只能作用于一个层次的循环是一个道理。那要判断列表里边的列表的元素，应该先进入一层列表:

>>> "小甲鱼" in list1[2]
True
>>> "小护士" not in list1[2]
False

那么，列表中的列表，应当这样访问

>>>1ist1 = ["小猪"，"小猫"，["小甲鱼"，"小护士"]，"小狗"]
>>>list1[2][0]
"小甲鱼"

(4)count()：计算它的参数在列表中出现的伙数

>>>list1=[1,1,2,3,5,8,13,21]
>>>list1. count(1)
2

(5)index()：返回它的参数在列表中的位置

	如果只有一个参数的话，返回所找到的第一个位置，即使这个元素出现了多次

>>>list1. index(1)
0

	如果有两个参数的话,用于限定查找的范围。因此可以这样查找第二个目标在list1 的位置:

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

(6)reverse()：将整个列表原地翻转，就是排最后的放到最前边，排最前的放到最后,那么排倒数第二的就排在第二，以此类推(就是逆序)

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

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

>>>list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0]
>>>list1.sort()
>>>list1
[0, 1, 2, 3, 5, 6, 8, 9, 10]

	如果想要逆序排序，使用.sort(reserve = True)

>>>list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0]
>>>list1.sort(reserve = True)
>>>list1
[10, 9, 8, 6, 5, 3, 2, 1, 0]

---

元组

(和列表相比，是不可改变的)

	创建列表用的是中括号，创建元组用的是小括号(里面的元素是int类型)

>>>tuple1 = {1, 2, 3, 4, 5, 6, 7, 8}
>>>tuple1[1]
2
>>>tuple1[5:]
(6, 7, 8)

更新与删除元组的方法

更新：就是先拆分，再相加合并
删除：del()

---

字符串

	与列表相比，用双引号

例如：

>>>str1 = "I love python.jpg"

在python里面，没有所谓字符的概念，所谓’字符’，就是长度为1的字符串

1.格式化

	format()方法：接受位置和关键字参数

先看一个例子:

>>> "{0} love {1}. {2}". format("I", "FishC", "com")
'I love FishC. com'

怎么回事呢?仔细看，字符串中的{0}、{1}和{2}应该跟位置有关,依次被format()的三个参数替换，那么format()的三个参数就叫作位置参数。那什么是关键字参数呢,再来看一个例子:

>>> "{a} love {b}. {c}". format(a= "I", b= "FishC", c= "com" )
'I love FishC. com'

>>> "{0} : {1:.2f}". format("圆周率", 3. 14159)
'圆周率: 3. 14'

在替换域中，冒号表示格式化符号的开始，“2”的意思是四舍五人到保留两位小数点，而f的意思是浮点数，所以按照格式化符号的要求打印出了3. 14。

	格式化操作符: %

当%的左右均为数字的时候 .那么它表示求余数的操作
但当它出现在字符中的时候，它表示的是格式化操作符

>>>'%c' % 97
'a'
>>>'% c % c % c % c' (70, 105, 115, 104, 67)
'FishC'
>>>'%d转换为八进制是: %o' % (123, 123)
'123转换为八进制是: 173'
>>>'%f用科学计数法表示为: %e' % (14500000, 149500000)
149500000. 00000用科学计数法表示为: 1. 495000e + 08'

>>>' % 5.1f' % 27.658
'27.7'
>>>' % .2e' % 27.658
'2. 77e+01'
>>>' % 10d' % 5
'         5'
>>>' % -10d' % 5
'5         '
>>>' % 010d' % 5
'0000000005'
>>>' % # X' % 100
'0X64'

格式化操作符的辅助指令：

符号	含义
m,n	m显示的是最小总宽度，n是小数点后的位数
-	结果左对齐
+	在正数前面加上加号(+)
#	在八进制数前面现实’0o’，在十六进制数前面显示’0x’或’0X’
0	显示的数前面填充’0’代替空格

5.序列

(1)list([iterable])

	用于把一个可迭代对象转换为列表

#创建一个空列表
>>>a = list()
>>>a
[ ]
#将字符串的每个字符迭代存放到列表中
>>>b = list("FishC")
>>>b
['E', 'i', 's', 'h', 'C']
#井将元组中的每个元素迭代存放到列表中
>>>c = list((1, 1, 2, 3, 5, 8, 13))
>>>c
[1, 1, 2, 3, 5, 8, 13]

2.tuple([iterable])

	把一个可迭代对象转换成元组，用法和list一样

3.str(obj)

	把obj对象转换成字符串

4. len( sub)

	用于返回sub参数的长度:

>>> str1 = "I love fishe. com"
>>> len( str1)
16
>>>list1=[1,1,2,3,5,8,13]
>>> len(list1)
”
>>> tuplel = "这"， "是"，"_", "个"，"元组">>> len( tuple1)
5

5. max(…)

	返回序列或者参数集合中的最大值

也就是说max()的参数可以是一个序列，返回值是该序列中的最大值；也可以是多个参数，那么max()将返回这些参数中最大的一个:

>>> list1 = [1, 18，13, 0, - 98，34, 54, 76, 32]
>>> max(list1)
76
>>> str1 = "I love f ishc. com"
>>> max(str1)
'v'
>>> max(5, 8, 1, 13, 5, 29，10，7)
29

6. min(…)

	返回序列或者参数集合中的最小值。

min()方法跟max()用法一样，但效果相反

注意：使用max()方法和min()方法都要保证序列或参数的数据类型统一，否则会出错。

>>> list1 = [1, 18，13，0, - 98，34, 54, 76，32]
>>> list1. append("x")
>>> max( list1)
Traceback ( most recent call last) ;
File "< pyshell# 22>", line 1, in < module>
max(list1)
TypeError: unorderable types: str() > int()
>>> min(123, 'oo', 456, 'xx')
Traceback (most recent call last):
File "< pyshell#23>", line 1, in < module>
min(123, 'oo', 456, 'xx')
TypeError: unorderable types: str() < int()

错误原因：字符串型不能和整形做比较
7. sum( iterable[, start])

	用于返回序列iterable 的总和,用法跟max()和min()一样。

但sum()方法一个可选参数(start),如果设置该参数,表示从该值开始加起,默认值是0:

>>>tuplel=1,2,3,4,5
>>>sum( tuple1)
15
>>> sum(tuple1, 10)
25

8. sorted( iterable, key= None, reverse = False)

	用于返回一个排序的新列表(sort()是实现列表原地排序)

>>> list1 = [1, 18, 13, 0, - 98, 34, 54, 76, 32]
>>> list2 = list1[:]
>>> list1. sort( )
>>> list1
[ -98, 0, 1, 13, 18，32, 34, 54, 76]
>>> sorted(list2)
[-98, 0, 1, 13, 18，32, 34, 54, 76]
>> > list2
[1, 18, 13, 0, -98, 34, 54, 76, 32]

9. reversed( sequence )

	返回逆向迭代序列的值。同样的道理，实现效果跟列表的内建方reverse()一致。

区别是列表的内建方法是原地翻转,而reversed()是返回一个翻转后的迭代对象

10. enumerate( iterable)

	生成由一元组(二元组就是元素数量为二的元组)构成的一个迭代对象

每个二元组是由可迭代参数的索引号及其对应的元素组成的

>>> str1 = "FishC"
>>> for each in enumerate(str1);
print( each)
(0, 'F')
(1, 'i'
(2, 's')
(3, 'h')
(4, 'C')

11. zip(iter1 [ ,iter2…])

	返回由各个可迭代参数共同组成的元组

>>> list1 = [1, 3, 5, 7, 9]
>>> str1 = "FishC"
>>> for each in zip(list1, str1):
	print( each)
(1, 'E')
(3, 'i')
(5, 's')
(7, 'h')
(9, 'C')
>>> tuplel = (2, 4, 6, 8, 10)
>>> for each in zip(list1, str1, tuple1):
	print( each)
(1, 'F', 2)
(3, 'i', 4)
(5, 's', 6)
(7, 'h', 8)
(9, 'C', 10)

---

列表，元组，字符串之间的共同点:

• 都可以通过索引得到每一个元素。
• 默认索引值总是从0开始(当然灵活的Python还支持负数索引)
• 可以通过分片的方法得到一个范围内的元素的集合
• 有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)。