Day 4 list 列表的使用方法

 https://www.cnblogs.com/fanison/p/7123532.html

s="abcdefg"
print("s[3]:",s[3])
print("s[3:5]:",s[3:5])
print("s[:5]:",s[:5])
print("s[3:]:",s[3:])
print("s[::2]:",s[::2])
print("s[::-1]",s[::-1])
print("s[-2:-5]",s[-2:-5])
print("s[-5:-1]:",s[-5:-1])

s[3]: d
s[3:5]: de
s[:5]: abcde
s[3:]: defg
s[::2]: aceg
s[::-1] gfedcba
s[-2:-5]  左边比右边大的话什么都不输出
s[-5:-1]: cdef

1. 列表的增删改查
l1 = ["alex","taibai","wusir","oldboy",3,3,4,1,1,1,1]
#1. 切片索引
print(l1[0],type(l1[0]))
print(l1[0:3])
#增 append
l1.append("小黑")
print(l1)
l1.append([1,2,3])
print(l1)
#insert
l1.insert(3,"mengbin")
print(l1)
#extend 迭代插入，已最小单位从后面插入
l1.extend((4,"您好"))
print(l1)

#删除,不加索引默认从后面删除
l1.pop()
print(l1)

l1.pop(4)#加索引从索引处删除
print(l1)

# l1.remove("alex")#按元素删除，无返回值.
print(l1)

#del l1#删除列表

del l1[0:3] #按切片删除，索引删除
print(l1)

#改
l1[0]="男神" #按索引改
print(l1)

l1[0:2]="屌丝"#按切片改
print(l1)

l1 = ["alex","taibai","wusir","oldboy",3,3,4,1,1,1,1]
#查查询
a=l1[0]
print(a)

#len长度
print(len(l1))

#count个数元素个数
print(l1.count(True))

# #index通过元素找索引
# print(l1.index("wusir"))

l2=[1,2,3,7,3,2,0,9,8]
#sort 排序从小到大
l2.sort()
print(l2)
l2.sort(reverse=True)
print(l2)

2. 列表的嵌套

 1. 输出结果为alex 的A 大写.

l1 = ["小新","alex","xiaoli","xiaowang",[1,"tian",3],4,4]

#方法1
a=l1[1].capitalize()
l1[1]=a
print(l1)
print(a)
#方法2
l1[1]=l1[1].capitalize()
print(l1)
#方法3 
l1[1] ='Alex'
print(l1)

 　　
2. tian都大写

l1 = ["小新","alex","xiaoli","xiaowang",[1,"tian",3],4,4]
l1[4][1]=l1[4][1].upper()
print(l1)

3. 元祖

4. Range

for i in range (1,10):

    print(i)

#打印处1 到10 十个数字。 

for i in  range (11):# 等于 for i in range (0,11)
    print(i)

for i in range (1,10,2):
    print(i)
#打印结果：1 3 5 7 9 

for i in range (10,0,-1):
　　print(i)
#打印结果是10  9 8 7 6 5 4 3 2 1 

3. 习题  

#打印出列出一下所有的字符
l1 = [1,2,3,'alex',[2,3,'wusir'],7]

l2 = l1[2]
for i in l1:
    if type(i) == list:
        for j in i :
            print(j)
    else:
            print(i)

Python序列类型

 

Python序列类型

序列：字符、列表、元组

    所有序列都支持迭代
    序列表示索引为非负整数的有序对象集合
    字符和元组属于不可变序列，列表可变
    

1)字符

    字符串字面量:把文本放入单引号、双引号或三引号中；
    '    ''    '''
        >>> str1 = ' hello, fanison '
        >>> type(str1)
        str

    如果要使用unicode编码，则在字符之前使用字符u进行标识
        >>> str2 = u'你好，fanison'
        >>> type(str2)
        unicode

    文档字串：模块、类或函数的第一条语句是一个字符的话，该 字符串就成为文档字符串，可以使用__doc__属性引用；
        例：
            >>> def printName():
                    "the function is print hello"
                    print 'hello'
            >>> printName.__doc__

    运算符：
        索引运算符          s[i]        返回一个序列的元素i
        切片运算符          s[i:j]      返回一个切片
        扩展切片运算符      s[i:j:stride]

        例：
            >>> str3 = 'hello,fanison'
            >>> str2[0:]
            'hello,fanison'      返回所有元素
            >>> str2[0:7]
            'hello,f'            返回索引7之前的所有元素
            >>> str2[0:7:2]
            'hlof'               返回从索引0到6内步径为2的元素，即隔一个取一个
            >>> str2[7:0:-2]
            'a,le'               从索引7处倒着隔一个取一个取到索引1处
            >>> str2[-4:-1]
            'iso'                从索引-4处取到-2处
            >>> str2[-4::-1]
            'inaf,olleh'         从-4处到开始处倒着取
        注意：
            步径为正表示  正着取，索引从小到大          i < j
            步径为负表示  倒着取，索引从大到小          i > j

    支持运算：
        索引、切片、min()、max()、len()等

            len(s)              s中的元素个数
            min(s)              s的最小值
            max(s)              s的最大值

   支持方法：
        S.index(sub [,start [,end]])            找到指定字符串sub首次出现的位置
        S.upper()                               将一个字符串转换为大写形式
        S.lower()                               将一个字符串转化为小写形式
        S.join(t)                               使用s作为分隔符连接序列t中的字符串
                    >>> l1 = list(str1)
                    >>> l1
                    ['h', 'e', 'l', 'l', 'o', ',', 'f', 'a', 'n', 'i', 's', 'o', 'n']
                    >>> ''.join(l1)
                    'hello,fanison'             使用空字符作为分隔符连接列表l1
       S.replace(old, new[, count])             替换一个字符串
                    >>> str1.replace('fan','FAN')
                    'hello,FANison'
    注意：
        使用 help()获取其帮助
                >>> help(str.join)
                

2)列表

列表：容器类型
         任意对象的有序集合，通过索引访问其中的元素，可变对象，长度可变，异构，任意嵌套

      支持在原处修改
            修改指定的索引元素，修改指定的分片，删除语句，内置方法

         >>> list1 = [ 1,2,3,'x','n' ]
         >>> list1[1]=56
         >>> print list1
         [1, 56, 3, 'x', 'n']
         >>> list1[1:3]=[]              会删除索引1到索引3之前的元素
         >>> print list1
         [1, 'x', 'n']
         >>> del(list1[1])              使用del函数删除list索引为1的元素
         >>> print list1
         [1, 'n']
            注意：
                 因为支持原处修改，不会改变内存位置，可使用  id() 查看其位置变化

       内置方法：
                 L.count(value)                     计算value值出现的次数
                 L.append(object)                   将一个新元素追加到L末端
                 L.extend(iterable)                 增加合并列表(第二个列表内容会以单个元素追加至末端)
                        >>> l1 = [ 1,2,3 ]
                        >>> l2 = [ 'x','y','z']
                        >>> l1.append(l2)
                        >>> l1
                        [1, 2, 3, ['x', 'y', 'z']]          使用append方法会以其原有存在形式追加
                        >>> l1 = [ 1,2,3 ]
                        >>> l1.extend(l2)
                        >>> l1
                        [1, 2, 3, 'x', 'y', 'z']            注意两种增加的区别
                L.pop([index])                      返回元素index并从列表中移除它，如果省略则返回并移除列表最后一个元素
                L.remove(key)                       移除值为key的元素
                        >>> l1 = [ 'x',2,'abc',16,75 ]
                        >>> l1.pop(2)                       pop方法是按索引移除
                        'abc'
                        >>> l1
                        ['x', 2, 16, 75]
                        >>> l1.remove(16)                   remove方法是按值移除
                        >>> l1
                        ['x', 2, 75]
                L.index(value)                        指定值首次出现的位置
                L.insert(index, object)               在索引index处插入值
                        >>> l1.insert(1,'abc')
                        >>> l1
                        ['x', 'abc', 2, 75]
                L.sort()                              排序
                L.reverse()                           逆序
                        >>> l1.sort()
                        [2, 75, 'abc', 'x']
                        >>> l1.reverse()
                        ['x', 'abc', 75, 2]

        l1 + l2: 合并两个列表，返回一个新的列表；不会修改原列表；
                        >>> l1 = [ 1,2,3]
                        >>> l2 = [ 'x','y','z']
                        >>> l1 + l2
                        [1, 2, 3, 'x', 'y', 'z']

        l1 * N: 把l1重复N次，返回一个新列表;
                        >>> l1 * 3
                        [1, 2, 3, 1, 2, 3, 1, 2, 3]         使用id()查看是否生成新列表

        成员关系判断字符：
                        in              用法：   item in container
                        not in               item not in container
                            >>> l1 = [ 'x','y',3 ]
                            >>> 'y' in l1
                            True
                            >>> 'x' not in l1
                            False

       列表解析：[]

       列表复制方式：
            浅复制:两者指向同一内存对象
                    >>> l1 = [ 1,2,3,4 ]
                    >>> l2 = l1
                    >>> id(l1) == id(l1)
                    True                            可以看出两者内存地址相同
                    >>> l1.append('x')
                    >>> print l1
                    [ 1,2,3,4,'x' ]
                    >>> print l2
                     [ 1,2,3,4,'x' ]
            深复制：两者指向不同内存对象
                    1)导入copy模块，使用deepcoop方法
                     >>> import copy
                     >>> l3 = copy.deepcopy(l1)
                     >>> id(l3) == id(l1)
                     False                          地址不同

                    2)复制列表的所有元素，生成一个新列表
                    >>> l4 = l1[:]
                    >>> print l4
                    [ 1,2,3,4,'x' ]
                    >>> l1.append(6)
                    >>> print l1
                    [ 1,2,3,4,'x',6 ]               l1改变
                    >>> print l4
                    [ 1,2,3,4,'x' ]                 l4不变

3)元组

    表达式符号：()

    容器类型
        任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定，异构，嵌套

    常见操作：
        ()
                    >>> t1 = ( 1,2,3,'xyz','abc')
                    >>> type(t1)
                    tuple
                    >>> len(t1)
                    5
                    >>> t2 = ()                             定义一个空元组
                    >>> t3 = ( , )
                    SyntaxError: invalid syntax             报错：使用逗号分隔的条件是最少要有一个元素

        (1,)
                    >>> t1[:]
                    ( 1,2,3,'xyz','abc' )
                    >>> t1[1:]
                    (2, 3, 'xyz', 'abc')

        (1,2)
                    >>> t1[1:4]
                    (2, 3, 'xyz')
                    >>> t4 = 'x',1,'yz',45,[2,4,6]              注意!!!这样也可以生成元组
                    >>> t4
                    ('x', 1, 'yz', 45, [2, 4, 6])

        t1 + t4: 合并两个元组，返回一个新的元组；不会修改原元组；
                    >>> t1 + t4
                    (1, 2, 3, 'xyz', 'abc', 'x', 1, 'yz', 45, [2, 4, 6])

       t1 * N:  把l1重复N次，返回一个新元组;
                    >>> t1 * 3
                    (1, 2, 3, 'xyz', 'abc', 1, 2, 3, 'xyz', 'abc', 1, 2, 3, 'xyz', 'abc')

        成员关系判断
                in
                not in

        注意：
            虽然元组本身不可变，但如果元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组；
                例：
                    >>> t4 = ('x', 1, 'yz', 45, [2, 4, 6])
                    >>> id(t4)
                    44058448
                    >>> t4[4]
                    [2, 4, 6]
                    >>> t4[4].pop()                     弹出列表内一个元素
                    6
                    >>> print t4[4]
                    [2, 4]
                    >>> print t4
                    ('x', 1, 'yz', 45, [2, 4])
                    >>> id(t4)
                    44058448                            由此可见，对元组内列表内的修改也会使元组发生改变，没有返回新元组

4)序列操作总结