概述

        列表、元组和字符串同属于序列的一种，都有序列的特点，每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。

一、列表

1、定义方法

        列表名=[元素1，元素2，...]

        列表名=list（序列名）

        列表名=字符串.split()

        列表名=[含有变量名的表达式  for  变量名1  in  序列 [for  变量名2  in  序列]....]

        其中元素可以是任何类型，也可以是列表或元组，且可以各不相同。

        使用列表生成式生成列表时可以使用嵌套循环，还可以使用条件判断。

例：

names=["张三","李四","王五","马六"]    #元素为字符串的列表

students=[[1,"张三"],[2,"李四"],[ 3,"王五"]]    #元素为列表的列表

names=list("Hello")    #建立['H', 'e', 'l', 'l', 'o']列表

names=list()    #建立空列表

names=[None]*4    #建立[None, None, None, None]定长元素为空的列表

a=[x+x for x in range(5)]    #使用列表生成式建立[0, 2, 4, 6, 8]列表

a=[x+x for x in range(5) if x%2==0]    #使用列表生成式建立[0, 4, 8]列表

a=[x+y for x in range(5) if x%2==0 for y in range(5) if y%2==1]    #使用列表生成式建立[1, 3, 3, 5, 5, 7]列表

a="This is a test string from Andrew".split()    #使用split方法生成列表['This', 'is', 'a', 'test', 'string', 'from', 'Andrew']

2、基本操作方法

        查询：

            列表名[索引]    通过索引查询

            列表名[首索引:尾索引:步长]            通过切片查询

                说明

                索引是从0开始的整数，索引和步长都可以是负数。使用切片查询时，结果包括首索引元素不包括尾索引元素，即“顾首不顾尾”。

                当步长为正数时，以首索引位置自左向右按照步长查询，输出结果为列表相同顺序，所以首索引必须比尾索引小；当为负数时，以首索引位置自右向左按照步长查询，为列表反向顺序，所以首索引必须比尾索引大；步长不可以为0，且默认为1。

                当首索引和尾索引为相等的数值时，返回空列表。

                使用切片查询时，可以在切片的同时再切片，实现嵌套切片。

例：

names=["张三","李四","王五","马六"] 

#正索引：0        1           2        3

#负索引：-4       -3        -2        -1

print(names[1] )   #返回    李四

print(names[-1])    #返回    马六

print(names[0:2])    #返回     ['张三', '李四']

print(names[:2])    #返回     ['张三', '李四']

print(names[2:2])    #返回       []

print(names[1:3])    #返回     ['李四', '王五']

print(names[1:100] )   # 返回     ['李四', '王五', '马六']

print(names[1:][1:][1:] )   #返回   ['马六']

print(names[-3:-1] )   #返回     ['李四', '王五']

print(names[-3:] )   #返回     ['李四', '王五', '马六']

print(names[1:3:2] )   # 返回     ['李四']

print(names[::2] )   #返回     ['张三', '王五']

print(names[::-2] )   #返回     ['马六', '李四']

print(names[1:3:-1])    #返回      []

print(names[3:1：-1])    #返回      ['马六', '王五']

新增

        列表名=列表名+列表名    使用列表相加方法

        列表名=列表名*数值    使用列表乘积方法新增重复元素

        列表名.append(元素)    使用append方法结尾插入

        列表名.extend(元素)    使用extend方法结尾插入元素

        列表名.insert(索引,元素)    使用insert方法指定索引位置插入

        列表名[首索引:尾索引]=列表    使用首尾相同索引号切片赋值插入

        说明

        使用相加方法新增时新增的必须为列表；

        使用切片赋值时，首尾索引相等时，元素插在索引-1位置；

        使用乘积新增时，乘数必须为整数，乘数可以是计算结果为整数的表达式，当乘数为负数或0时，结果返回空列表；

例：

names=["张三","李四","王五","马六"]

names=names+["赵七"]    #输出names返回    ['张三', '李四', '王五', '马六', '赵七']

names=names*2   #输出names返回    ['张三', '李四', '王五', '马六', '张三', '李四', '王五', '马六']

names.append("赵七")    #输出names返回    ['张三', '李四', '王五', '马六', '赵七']

names.insert(1,"赵七")    #输出names返回     ['张三', '赵七', '李四', '王五', '马六']

names.extend("赵七")    #输出names返回     ['张三', '李四', '王五', '马六', '赵', '七']

names.extend(["赵七"])     #输出names返回    ['张三', '李四', '王五', '马六', '赵七']

names[2:2]="赵七"    #输出names返回      ['张三', '李四', '赵', '七', '王五', '马六']

names[2:2]=["赵七" ]    #输出names返回      ['张三', '李四', '赵七', '王五', '马六']

修改

列表名[索引]=值        通过索引赋值

列表名[首索引:尾索引:步长] =值     通过切片赋值

说明 

        通过索引赋值时，可以赋值所有对象，且将对象作为一个整体赋值；

        通过切片赋值时，当步长为1时，可以赋值与切片元素数不相同的序列，当步长不为1时，只能赋值与切片元素数相同的序列；

        通过切片赋值时，步长为1时，当尾索引小于或等于首索引时，元素插入到首索引-1位置，当尾索引大于首索引时，元素将赋值给首索引到尾索引（不包括）之间的元素；

        通过切片赋值时，只能赋值序列，且按照序列第一层最小单位元素赋值；

        使用切片赋值时，步长为正数时，元素自左向右赋值，步长为负数时，元素自右向左赋值。

例：

names=["张三","李四","王五","马六"]

names[2]="赵七"    # 输出names返回      ['张三', '李四', '赵七', '马六']

names[2]=("赵七")    # 输出names返回     ['张三', '李四', '赵七', '马六']

names[2]=("赵七","周八")     # 输出names返回     ['张三', '李四', ('赵七', '周八'), '马六']

names[2:]="赵七"    # 输出names返回    ['张三', '李四', '赵', '七']

names[2:]=["赵七"]    # 输出names返回      ['张三', '李四', ' 赵七 ', '马六']

names[3:1]="赵七"    # 输出names返回      ['张三', '李四', '王五', '赵', '七', '马六']

names[::2]="赵七"     # 输出names返回       ['赵', '李四', '七', '马六']

names[::2]=["赵七","周八"]     # 输出names返回    ['赵七', '李四', '周八', '马六']

names[::2]=("赵七","周八")    # 输出names返回    ['赵七', '李四', '周八', '马六']

names[::2]=(("赵七"),("周八"))    # 输出names返回    ['赵七', '李四', '周八', '马六']

names[-1:-2:-1]="赵"    # 输出names返回    ['张三', '李四', '王五', '赵']

names[-1:-2:-1]="赵七"     # 输出names返回错误

删除

        del 列表名[索引]        使用函数删除索引指定元素

        del 列表名       使用函数删除列表

        列表名.pop(索引)    使用函数删除索引指定元素

        列表名[首索引:尾索引]=[]    使用切片赋空索引删除

说明

        使用切片删除时不可以指定步长，当步长为-1时总返回原列表，无论首尾索引为何值，为其他不为1的值时提示错误；

例：

names=["张三","李四","王五","马六"]

del names[1]    # 输出names返回    ['张三', '王五', '马六']

names.pop()    # 输出names返回    ['张三', '李四', '王五']

names.pop(1)     # 输出names返回    ['张三', '王五', '马六']

names.pop(-1)      # 输出names返回     ['张三', '李四', '王五']

names[1:3]=[]       # 输出names返回     ['张三', '马六']

names[-3:-1:-1]=[]        # 输出names返回      ['张三', '李四', '王五', '马六']

3、相关函数

names=["张三","李四","王五","马六"]

operator.eq(list1, list2)

        比较两个列表的元素是否一样，是返回True，否返回False，使用前需要import operator

print(operator.eq(names,["我","是,","谁"]))    #输出返回    False

len(list)

        返回列表元素个数

print(len(names))    #输出返回    4

max(list)

        返回列表元素最大值

print(max(names))     #输出返回    马六        按照什么选择最大？

print(max('ardjtgoczmd'))      #输出返回     z

min(list)

        返回列表元素最小值

print(min(names))      #输出返回     张三        按照什么选择最小？

list(序列)

        将序列转换为列表

names=list("我是谁")    #输出names返回    ['我', '是', '谁']

obj in list

        判断对象是否在列表中存在，存在返回True，不存在返回False

print("张三" in names)    #输出返回    True

4、相关方法

names=["张三","李四","王五","马六"]

list.append(obj)

        在列表末尾添加新的对象,对象作为一个整体添加；

names.append([a for a in [1,2,3]])    # 输出names返回     ['张三', '李四', '王五', '马六', [1, 2, 3]]

list.count(obj)

        统计某个元素在列表中出现的次数，返回个数，不存在时返回0

print(names.count("李四"))    #输出返回    1

list.extend(序列)

        在列表末尾添加新的序列，将序列第一层每个元素作为单独元素添加；

names.extend([a for a in [1,2,3]])    # 输出names返回    ['张三', '李四', '王五', '马六', 1, 2, 3]

names.extend([a for a in [[0,1],2,3]])    # 输出names返回     ['张三', '李四', '王五', '马六', [0, 1], 2, 3]

names.extend("我是谁")     # 输出names返回      ['张三', '李四', '王五', '马六', '我', '是', '谁']

list.index(obj,首索引,尾索引)

        从列表检索区间中找出某个值第一个从左至右匹配项的索引位置，当找不到时返回错误；

        检索区间按照顾首不顾尾原则；

        当首尾索引相同时，检索区间为空，提示错误；

        首尾索引可以使用负数；

        检索时总是从首索引位置向右进行检索，直到尾索引；

print(names.index("李四"))    #输出返回    2

print(names.index("李四",-1,0))    #输出返回错误

print(names.index("李四",0,-1))    #输出返回    1

print(names.index("李四",-4,3))     #输出返回    1

list.insert(index, obj)

        在列表指定索引元素前添加新的对象,对象作为一个整体添加；

        索引可以使用负数；

names.insert(1,"周八")     # 输出names返回      ['张三', '周八', '李四', '王五', '马六']

names.insert(-2,"周八")      # 输出names返回    ['张三', '李四', '周八', '王五', '马六']

list.pop(obj=list[-1])

        移除列表中的指定索引元素（默认最后一个元素），并且返回该元素的值；

        索引可以使用负数；

        当索引超出界限时提示错误；

names.pop(-3)    # 输出names返回      ['张三', '王五', '马六']

names.pop(0)    # 输出names返回      ['李四', '王五', '马六']

names.pop()     # 输出names返回       ['张三', '李四', '王五']

list.remove(obj)

        移除列表中某个值的第一个匹配项，当未找到时提示错误；

        obj不可以是除了字符串的序列；

names.remove("王五")     # 输出names返回      ['张三', '李四', '马六']

names.remove(["王五"])      #返回错误

list.reverse()

        反向列表中元素

names.reverse()      # 输出names返回      ['马六', '王五', '李四', '张三']

list.sort(key=[func],reverse[True,False])

        对原列表进行排序,key用于指定用什么来比较的函数，reverse用于指定是否按照相反顺序排列，默认值为False

names=["张三","马六","李四","王五"]

print(names.sort())     # 输出错误

names.sort() 

print(names)        # 输出names返回        ['张三', '李四', '王五', '马六']

name2=names.sort

name2()

print(names)         # 输出names返回        ['张三', '李四', '王五', '马六']

names.sort(reverse=True)    #按反向排序

print(names)        # 输出names返回      ['马六', '王五', '李四', '张三']

names.sort(key=id)    #按内存地址排序

print(names)        # 输出names返回        ['张三', '李四', '王五', '马六']

    list.copy

    对原列表进行浅拷贝，对原列表中多层元素进行修改时，新列表也会被修改；

names=["张三","李四",["王五","马六"]]

name=names.copy

name2=names.copy()

print(name)       # 输出name返回新函数地址       <built-in method copy of list object at 0x0061E6E8>

print(name2)       # 输出name2返回      ["张三","李四",["王五","马六"]]  

print(name())       # 输出name返回     ["张三","李四",["王五","马六"]]

names[0]="赵七"

names[2][0]="周八"

print(name())       # 输出name返回    ['赵七', '李四', ['周八', '马六']]

print(name2)       # 输出name2返回   ['张三', '李四', ['周八', '马六']]

二、元组

        与列表一样，元组也是序列，唯一的差别在于元组是不能修改

1、定义方法

例    （1,2,3）

        （1，）

        tuple（'张三', '李四', '王五', '马六'）

注：当元组只有一个元素时，元素后需添加逗号，否则不能定义成元组，只代表被小括号括起来的元素

print(names=("赵七"))    #返回    赵七

print(len(("1")))     #返回    1

print(len(("1",)))     #返回    1

2、相关函数

        tuple（序列）

        将序列第一层每个元素作为单独元素转换为元组；

names=["张三","李四","王五","马六"]

print(tuple(names))    #输出    ('张三', '李四', '王五', '马六')

names="张三"

print(tuple(names))     #输出     ('张', '三')

2、基本操作方法

        tuple.index(obj,首索引,尾索引)

        与列表相同

        tuple.count(obj)

        与列表相同