【Datawhale | python基础 | Day2】认识序列

序列是python基本的数据结果，有6种内置类型，最常用的是列表和元组，序列都可以进行索引、切片、加、乘、检查成员的操作。

1、列表

1.1 创建列表

• 用方括号表示列表
• 用逗号分隔列表中的元素
• 列表的数据项不需要具有相同的类型
• 列表中的元素是有序的，即数据项的位置不可以置换
• 与字符串的索引一样，列表索引从0开始

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = [] #创建一个空列表

1.2 列表操作

• 访问列表元素：使用下标索引或方括号的形式截取字符
• 更新列表：通过重新赋值对列表中元素进行修改
• 新增列表元素：
  1）list.append(object)：在列表末尾添加新的对象；
  2）list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值,即用新列表扩展原来的列表；
  3）list.insert(index, obj)：将对象插入列表中某个索引位置.
• 删除列表元素：
  1）del；
  2）list.pop([index=-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值；
  3）list.remove(obj)：移除列表中某个值的第一个匹配项。
• 脚本操作：
  1）list1+list2：两个列表相加；
  2）list*n：列表中的元素复制n次；
  3）x in list：判断x是否在list里面，返回布尔类型的值。
• 排序和反转：
  1）list.reverse()将列表反转；
  2）list.sort()排序，默认升序；
  3）list.sort(reverse=True) 降序排列
  注：list 中有字符串，数字时不能排序，排序针对同类型
• 列表操作函数：
  1）len(list)：列表元素个数；
  2）max(list)：返回列表元素最大值 ；
  3）min(list)：返回列表元素最小值 ；
  4）list(seq)：将元组转换为列表；
  5）enumerate()：打印元素对应的下标。
• 列表其他方法
  1）list.count(obj)：统计某个元素在列表中出现的次数；
  2）list.index(obj)：从列表中找出某个值第一个匹配项的索引位置；
  3）list.clear()：清空列表；
  4）list.copy()：复制列表。
• 列表循环和切片
  1）循环：如果直接for 循环一个list 的时候，那么每次循环的值都是这个list 里面的元素；
  2）切片：list 取值的一种方法；
  list[n:m]：切片是不包含后面那个元素的值（顾头不顾尾）
  list[:m] 如果切片前面一个值缺省的话，从开头开始取
  list[n:] 如果切片后面的值缺省的话，取到末尾
  list[:] 如果全部缺省，取全部
  list[n: m: s] s是步长 ，隔多少个元素取一次，步长是正数，从左往右取；步长是负数，从右往左取
  注：切片同样适用于字符串，字符串也有下标。

print('-------0、创建列表-------')
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print('list1:',list1) 
print('list2:',list2) 
    
print('-------1、访问列表元素-------')
print ("list1[0]: ", list1[0])  #索引访问列表某元素位置
print ("list2[1:5]: ", list2[1:5])  #切片访问 
"""
运行结果：
list1[0]:  Google
list2[1:5]:  [2, 3, 4, 5]
"""

print('-------2、更新列表-------')
print ("第三个元素为 : ", list1[2])
list1[2] = 2001
print ("更新后的第三个元素为 : ", list1[2])
"""
运行结果：
第三个元素为 :  1997
更新后的第三个元素为 :  2001
"""


print('-------3、新增列表元素-------')
list1.append(2019)
print ('在list1的末尾添加2019：' , list1)
list1.append((2018,2019))
print('在list1的末尾添加(2018,2019)：', list1)  #append()括号中的内容将被作为一个元素添加到列表中
list1.extend(list2)
print('在list1的末尾添加list2中的元素：', list1)
list1.insert(2,'Datawhale')
print ('在list1中索引为2的位置，新增一个元素：', list1)

"""
运行结果：
在list1的末尾添加2019： ['Google', 'Runoob', 2001, 2000, 2019]
在list1的末尾添加(2018,2019)： ['Google', 'Runoob', 2001, 2000, 2019, (2018, 2019)]
在list1的末尾添加list2中的元素： ['Google', 'Runoob', 2001, 2000, 2019, (2018, 2019), 1, 2, 3, 4, 5, 6, 7]
在list1中索引为2的位置，新增一个元素： ['Google', 'Runoob', 'Datawhale', 2001, 2000, 2019, (2018, 2019), 1, 2, 3, 4, 5, 6, 7]
"""

print('-------4、删除列表元素--------')
print('原始列表为：' , list1)
del list1[2]
print ('删除list1中索引为2的元素之后：' , list1)
list1.pop(-2)
print('删除list1中索引为-2的元素之后：', list1)  
list1.remove(2019)
print ('移除第一个2019之后：', list1)

"""
运行结果：
原始列表为： ['Google', 'Runoob', 'Datawhale', 2001, 2000, 2019, (2018, 2019), 1, 2, 3, 4, 5, 6, 7]
删除list1中索引为2的元素之后： ['Google', 'Runoob', 2001, 2000, 2019, (2018, 2019), 1, 2, 3, 4, 5, 6, 7]
删除list1中索引为-2的元素之后： ['Google', 'Runoob', 2001, 2000, 2019, (2018, 2019), 1, 2, 3, 4, 5, 7]
移除第一个2019之后： ['Google', 'Runoob', 2001, 2000, (2018, 2019), 1, 2, 3, 4, 5, 7]
"""


print('-------5、脚本操作--------')
print('求list1+list2:', list1+list2)
print('求list1中的元素复制4次', list1*4)
print('判断Datawhale是否在list里面，返回布尔类型的值:','Datawhale' in list1)

"""
运行结果：
求list1+list2: ['Google', 'Runoob', 2001, 2000, (2018, 2019), 1, 2, 3, 4, 5, 7, 1, 2, 3, 4, 5, 6, 7]
求list1中的元素复制4次 ['Google', 'Runoob', 2001, 2000, (2018, 2019), 1, 2, 3, 4, 5, 7, 'Google', 'Runoob', 2001, 2000, (2018, 2019), 1, 2, 3, 4, 5, 7, 'Google', 'Runoob', 2001, 2000, (2018, 2019), 1, 2, 3, 4, 5, 7, 'Google', 'Runoob', 2001, 2000, (2018, 2019), 1, 2, 3, 4, 5, 7]
判断Datawhale是否在list里面，返回布尔类型的值: False
"""


print('-------6、排序和反转--------')
list2.reverse()
print('反转list2；:', list2)
list2.sort(reverse=True)
print('降序排列:',list2)

"""
运行结果：
反转list2；: [7, 6, 5, 4, 3, 2, 1]
降序排列: [7, 6, 5, 4, 3, 2, 1]
"""

print('-------7、列表操作函数--------')
print('求list2的长度:', len(list2))
print('返回列表元素最大值:', max(list2))
print('返回列表元素最小值:', min(list2))
for i ,v in enumerate(list2):
    print('元素%s对应的下标是%s'%(v,i))

"""
运行结果：
求list2的长度: 7
返回列表元素最大值: 7
返回列表元素最小值: 1
元素7对应的下标是0
元素6对应的下标是1
元素5对应的下标是2
元素4对应的下标是3
元素3对应的下标是4
元素2对应的下标是5
元素1对应的下标是6
"""

print('-------8、列表其他方法--------')
print('求list1中1出现的次数:',list1.count(1))
print('从list1中找出第一个1匹配项的索引位置:',list1.index(1))
list1.copy()
list1.clear()
"""
运行结果：
求list1中1出现的次数: 1
从list1中找出第一个1匹配项的索引位置: 5ß
"""

print('-------9、列表循环--------')
#  循环
for i in list2:
    print(i)
"""
运行结果：
7
6
5
4
3
2
1
"""
    
print('-------10、列表生成式--------')
list1 = list(range(1,11))
list2 = list(x * x for x in range(1,11))
list3 = [m + n for m in 'ABC' for n in 'XYZ']
print('\n',list1,'\n',list2,'\n',list3)

"""
运行结果：
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 
 ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
"""

2、元组

2.1 创建元组

• 元组与列表类似，不同之处在于元组的元素不能修改
• 元组使用小括号，列表使用方括号
• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"  #  不需要括号也可以
type(tup3)
tup4 = () # 创建空元组

>>>tup5 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup5 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

2.2 元组操作

• 访问元组
  元组可以使用下标索引来访问元组中的值
• 修改元组
  元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
• 删除元组
  元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
• 元组操作与内置函数
  1）tuple1+tuple2：两个元组相加
  2）tuple*n：元组列表中的元素复制n次
  3）x in tuple：判断x是否在元组里面，返回布尔类型的值
  4）len(tuple)：元组元素个数
  5）max(tuple)：返回元组元素最大值
  6）min(tuple)：返回元组元素最小值

print('-------0、创建元组--------')
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print('\n','tup1=',tup1,'\n','tup2=',tup2)

print('-------1、访问元组--------') 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

print('-------2、修改元组--------') 
 # 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2;
print ('通过拼接生成新元组：',tup3)

print('-------3、删除元组--------') 
print (tup3)
del tup3;
print ("删除后的元组 tup3 : ")
# print (tup3)

print('-------4、元组操作与内置函数--------') 
print('tup1+tup2=', tup1 + tup2)
print('tup1*4=',tup1*4)
print('1997  in tup1 的结果为', 1997  in tup1)
print('tup1的元素个数',len(tup2))
print('返回元组元素最大值:', max(tup2))
print('返回元组元素最小值:', min(tup2)) 

"""
运行结果：
tup1+tup2= ('Google', 'Runoob', 1997, 2000, 1, 2, 3, 4, 5, 6, 7)
tup1*4= ('Google', 'Runoob', 1997, 2000, 'Google', 'Runoob', 1997, 2000, 'Google', 'Runoob', 1997, 2000, 'Google', 'Runoob', 1997, 2000)
1997  in tup1 的结果为 True
tup1的元素个数 7
返回元组元素最大值: 7
返回元组元素最小值: 1
"""

3、列表VS元组

• list(tuple)：将元组转换为列表
• tuple(list)：将列表转换为元组

list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1 = tuple(list1)
print('list转tuple',tuple1)
list2 = list(tuple1)
print('tuple转list',list2)

"""
list转tuple ('Google', 'Taobao', 'Runoob', 'Baidu')
tuple转list ['Google', 'Taobao', 'Runoob', 'Baidu']
"""

4、任务打卡

定义一个列表，包含自己的家庭成员，并在指定位置插入给定元素，例如你的男女朋友名称等。再将男女朋友名字移除等操作。

# 定义列表
list1 = ['爷爷','奶奶','爸爸','妈妈','妹妹']
print(list1)
# 新增一个元素‘男朋友’在妹妹前面
list1.insert(-1,'男朋友')
print('新增一个元素‘男朋友’在妹妹前面:',list1)
list1.pop(-1)
print('删除妹妹:',list1)