python之列表、元组

Day 2-Morning

• 创建列表
• 创建列表和创建普通变量一样，用中括号括起一堆数据即可（这里的数据可以是整型、字符串、浮点型...甚至可以包含另一个列表），数据间用逗号隔开。
• eg:number=[1,2,3,4,5]
• mix=[1,"maggie",3.14,[1,2,3]]
• 如果暂时不知道忘列表里加什么数据时，可先创建一个空列表
• eg:empty=[]
• 可结合range()创建列表————将一串数字转换为一个列表
  • eg:numbers=list(range(1,6))
    print(numbers)
    执行结果：[1,2,3,4,5]
    　　
• 向列表添加元素
• 在列表尾添加单个元素：append()  append()不是一个BIF，它属于列表对象的一个方法
• eg：number=[1,2,3,4,5]
  　　number.append(6)
      print(number)
  执行结果：[1,2,3,4,5,6]
• 在列表尾添加多个元素：extend()  用一个列表来扩展另一个列表，即它的参数应该是一个列表
• eg:number=[1,2,3,4,5]
     number.extend([7,8])
     print(number)　　
  执行结果：[1,2,3,4,5,7,8]
• 在列表任意位置插入元素：insert()  两个参数，第一个参数代表在列表中的位置，第二个参数是在该位置插入一个元素
• eg:number=[1,2,3,4,5]
     number.insert(1,0)
     print(number)
  执行结果：[1,0,2,3,4,5]
  该例子为在1后插入0；但因为0习惯用语表示第一个数，即，应该为在0后插入0
• eg:number=[1,2,3,4,5]
     number.insert(0,0)
     print(number)
  执行结果：[0,1,2,3,4,5]
• 从列表中获取元素
• 和数组一样，可通过元素的索引值(index)从列表获取单个元素（列表索引值从0开始）

• number=['0','1','2','4','3']
  print(number[3])
  number[3],number[4] = number[4],number[3]#交换位置，前面的位置顺序 = 后面的位置顺序
  print(number)
  

  　执行结果：'4'
  　　        ['0','1','2','3','4']

• 从列表删除元素
• remove() 删除元素：不需知道要删除元素在列表中的位置，只需知道它存在于该列表即可（若不存在，则报错；若有多个，则只删除第一个）

• number=['0','1','2','4','3']
  print(number[3])
  number.remove("4")
  print(number)
  

  　执行结果：'4'
             ['0','1','2','3']

• del 是一个语句，而不是一个列表的方法，因此不必有()小括号。且，del可指定删除某个位置的元素；也可直接删除整个列表（del 列表名）

  number=['0','1','2','4','3']
  print(number[3])
  del number[3]
  print(number)
  

  执行结果：'4'
             ['0','1','2','3']

• pop() 方法“弹出”元素：默认弹出列表中最后一个元素；但也可以将索引值作为参数，弹出相应元素

  number=['0','1','2','3','4']
  print(number.pop())
  print(number.pop())
  print(number.pop(0))
  print(number)
  

  执行结果：'4'
  　　        '3'
             '0'
             ['1','2']

  • 评判使用del语句还是pop()方法的标准：
    • 若要从列表中永久删除一个元素，且不再以任何方式使用它，则使用del语句
    • 若要在删除元素后还能继续使用它，则使用pop()方法
• 列表分片（slice）
  • 列表分片是建立在原列表上的一个拷贝（或副本），原列表不会发生改变。

    number=['0','1','2','3','4']
    print(number[0:2])　　#['0','1']
    print(number[:2])　　 #['0','1']
    print(number[1:])    #['1','2','3','4']
    print(number[:])     #['0','1','2','3','4']

    • 格式：开始位置 (冒号)： 结束位置 （不包括结束位置的元素）

    • 若没有开始位置，则默认0
    • 若没有结束位置，则从开始位置一直到列表末尾的所有元素
    • 若没有放入任何索引值，只有冒号，则将得到整个列表的拷贝
  • 进阶玩法：三个参数（第三个代表步长，默认为1）

    number=[0,1,2,3,4]
    print(number[0:3])    #[0,1,2]
    print(number[0:3:1])  #同上，默认步长为1
    print(number[0:5:2])  #[0,2,4] 步长为2（每两个取出一个）
    print(number[::2])    #同上
    print(number[::-1])   #[4,3,2,1,0] 步长为-1，相当于复制一个翻转的列表（逆序）

• 常用的操作符
• 比较运算符：列表比较大小，从第一个元素开始比较；同理，字符串也是从第一个字符对应的ASCII码值得大小开始比较

  list1=[123]
  list2=[234]
  print(list1>list2) #False
  
  list3=[123,456]
  list4=[234,123]
  print(list3>list4)  #False

• 连接操作符（+）：可将多个列表对象合并在一起(相当于extend())，但不能实现列表添加新元素的操作（用append()或insert()）

  list1=[123,456]
  list2=[234,123]
  list3=list1+list2
  print(list3)  #[123,456,234,123]

• 重复操作符(*)

  list1=[123]
  print(list1*3)  #[123,123,123]

• 复合赋值运算符

  list1=[123]
  list1*=3
  print(list1)  #[123,123,123]

• 成员关系操作符(in和not in)----只能判断一个层次的成员关系，若要判断列表里面的列表的元素，则应先进入一层列表

  list1=[123,456,[789]]
  print(123 in list1)		#True
  print(789 in list1)		#False
  print(789 in list1[2])	        #True
  

  可用索引号去访问列表中的值，那访问列表中的列表的值，就相当于访问二维数组，eg：list1[2][0] 结果为789

• 列表的方法：print(dir(list))
  • count():计算其参数在列表中出现的次数
  • index():返回其参数在列表中的位置
    • index()还有两个参数，用于限定查找范围。（因此可查找重复出现的目标的下一个位置）

      # coding=gbk
      list1=[1,1,2,3,5,8,13,21]
      print(list1.count(1))	#2 1出现2次
      print(list1.index(1))	#0 1在0位置（但其实在1位置仍出现，所以再加入参数限定范围查找）
      start=list1.index(1)+1	#起始点为0位置+1
      stop=len(list1)			#结束点为整个列表长度处（末尾）
      print(list1.index(1,start,stop))#1 这样就可以找完所有目标出现的位置
      

      　　Q：只能返回一个值？所以只能一个个地查找？而不能将start设为列表开头，stop设为列表结尾？

  • reverse():将整个列表原地翻转（逆序）eg：list1.reverse()
  • sort():用指定方式对列表的成员进行排序【永久性】，默认不需要参数，从小到大排序 eg：list1.sort()
  • 若需要从大到小的排序，则先sort()从小到大，在reverse()翻转
  • 或者：sort()三个参数：sort(func,key,reverse)
                       func和key参数用于设置排序的算法和关键字，默认是归并排序；reverse默认为False,要颠倒顺序，只需改为list1.sort(reverse=True)
  • sorted():临时排序，不影响列表元素原来的排列顺序
• 元组：不可改变（像字符串一样）————不可改变的列表称为元组
• 创建和访问一个元组：大部分时候用小括号（，逗号才是关键！）

  # coding=gbk
  tuple1=(1,2,3,4,5,6)
  print(tuple1)	#(1,2,3,4,5,6)
  print(tuple1[1]) #2 访问元组1的索引号为1的元素
  print(tuple1[4:]) #(5,6) 分片方式访问
  
  temp1=(1)
  print(type(temp1))#<class 'int'> type()为返回参数的类型
  temp2=1,2,3
  print(type(temp2))#<class 'tuple'> 没有小括号，有,逗号，temp还是元组类型,小括号只是起到补充的作用
  temp3=()
  print(type(temp3))#<class 'tuple'> 创建空元组，直接用小括号即可
  temp4=(1,)
  print(type(temp4))#<class 'tuple'> 若要创建的元组中只有一个元素，在后面加上一个,逗号，明确你要的是一个元组
  temp5=1,
  print(type(temp5))#<class 'tuple'>
  

  　　证明逗号(,)的关键作用例子：

  print(8*(8))		#64
  print(8*(8,))		#(8,8,8,8,8,8,8,8)

• 更新和删除元组：先构造一个新的元组（同字符串）
  • 同样使用分片的方法

    # coding=gbk
    temp=("小鸡","小鸭","小猪")
    temp=temp[:2]+("小狗",)+temp[2:]	#不能省略小括号(),也不能省略逗号(,)!
    print(temp)			#("小鸡","小鸭","小狗","小猪")
    
    temp=temp[:1]+temp[3:]		#保留第一个和最后一个，间接删除第二个和第三个
    print(temp)			#("小鸡","小猪")

　　暂告一段落~明天回家啦啦啦~