python笔记 —— 列表 （1）

目录

                一、列表定义

二、下标、索引

        1. index             

三、 列表元素               

四、列表访问、修改、切片赋值修改

        1.index

        2.[ start: end: length ]

五、列表操作

          1.增 insert append  extend

          2.删 del  pop  remove  clear

          3. 查 index count len max min    in / not in 

          4.排 sort  sorted  reserve 

          5.列表的复制  copy    *n

 六、列表的嵌套      

七、列表切片

          1. [ start : end ; length ]   

八、字符串与列表的转化

          1.list ( )     

          2." _" . join ( )

        

                                                         本文关键知识点汇总

 （这是以前查资料的时候不知道从哪位大神那里下载的图，这里借用一下，非常感谢）

一、列表 由  [   ]  定义，也可用 list ( (  ) ) 定义

注意：用list ( (  ) ) 创建列表时 一定为双括号

二、下标、索引  index              

        正向下标（索引）从 0 开始 ，负向下标（索引）从 -1 开始

list = [ "my" , "U" , 5 , "two",["a", 52]]
           
(index)    0     1    2    3       4       # 正向
下标索引号 -5    -4   -3   -2      -1       # 反向

 

三、 列表元素               

        元素类型可以不一样，可以是 字符串、数字、子列表

四、列表访问、修改、切片赋值修改  index  [ ]

        1. 列表名 [ index ]            对 相应 index 下标 的元素进行访问

        2. 列表名 [ index ] = 新值       对 相应index 下标 的 旧元素 替换为 新值新元素

list = [ "my" , "U" , 5 , "two",["a", 52]]    # 列表中含子列表，各元素类型不一样
listone = list[0]        # 访问列表下标索引 0 的元素
print(listone)

print(list[1])

list[1] = "人间理想"     # 对列表下标索引为 1 的元素赋予新值新元素 
print(list)

>>my
U
['my', '人间理想', 5, 'two', ['a', 52]]    # list列表中下标索引为 1 的元素被更改

        3. 列表名 [ start : end : length ] = [ "", " ", " ", .....]     对列表元素进行左闭右开切片赋值

list[:2] = ["my", "mihoyo"]      # 对列表前两个元素进行切片赋值
print(list)

>>['my', 'mihoyo', 'b', 'c']

五、列表操作

  统一列表为：

list = ["my", "a", "b", "c"]    # 统一列表为 list

        1.增 insert append  extend

                · 列表名.insert ( index, value或变量名 )     按位插入

list.insert ( 1,"a" )

                · 列表名.append ( value或变量名 )       表尾追加

list.append ("p")

                · 列表名.extend (列表变量名或列表或value)     两个列表的合并连接，多个元素的增加

注意： 如果添加元素为一串单词或短语，会被拆分成各个单字元素加入列表末尾

num = [999, 888]
list.extend (num)    # 括号内为列表的变量名
print(list)

list.extend([ "o"])    # 括号内为列表及其内具体元素
print(list)

>>["my", "a", "b", "c",999, 888]
["my", "a", "b", "c",999, 888, "o"]

注意：extend(  )  括号内只能存在 一个列表或者变量名，且添加的元素、列表位于 末尾

                · 列表名 + 列表名                              实现列表之间的合并、连接

newlist = ["I", "L", "U"]
combination = newlist + list
print(combination)

>>['I', 'L', 'U', 'my', 'a', 'b', 'c', 'd']

       

        2.删 del  pop  remove  clear

                · del 列表名 [ index: start: end ]      按位删除，不再使用   删除区间左闭右开

del list[0]

注意： del 列表名[ : ]       删除整个列表 

                · 列表名.pop( index )      按位删除，还可以用变量接收使用，只是元素变为“不可见”

list.pop(1)
popnum = list.pop(1)     # popnum变量 用于接收被删除的元素
print(list,popnum)

>>[ "my", "b", "c" ]     
a

注意 ：括号里没有输入 index 时，默认删除 末尾元素

                · 列表名.remove ( value )       按值删除

list.remove("c")

注意：多个value指定值出现时，remove只删除第一个value指定值

                · 列表名.clear ( )         清除列表所有元素 

list.clear ( )
print (list)

>> [ ]

        3. 查 index count len max min    in / not in 

                · 列表名.index (value, start, end)    查找出在左闭右开区间元素(value)的下标索引号

list = ["my", "a", "b", "c", "d"]
number = list.index("my")         # 查找 ”my“ 的下标索引号并 赋值给变量 number
print( list.index ("c"), number )   

>>3 0

                · 列表名.count ( value )       查看某个元素(value)在列表中出现的次数

print( "a在列表中出现的次数为:", list.count("a") )

>>a在列表中出现的次数为：1

                · 列表名.find (value, start, end)     同 index   左闭右开区间 查找并返回下标索引号 

                · len (列表名)             查询列表长度     

                · max (列表名)           查询 纯数字列表 中的 最大值    

                · min (列表名)            查询 纯数字列表 中的 最小值

list = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
print (len (list) )

print (min (list) )

print (max (list) )

>>10
1
19

                 · value in 列表 或 列表名            查找某元素 value 是否在列表中

list = ["my", "a", "b", "c"]
print ( "a" in list )

>>True         # “a”  在列表中

                · value not in 列表 或 列表名          查找某元素 value 是否不在列表中

list = ["my", "a", "b", "c"]
print ( "a" not in list )

>>False   # "a" 在列表中

注意： 此两种 in / not in 还有 迭代遍历 的写法，在后续的板块再见

       

         4.排 sort  sorted  reserve 

                  · 列表名.sort (key = _ )     永久性排序（与字母顺序相同）  默认升序 (非递减)

new_list = ["人间理想", "mihoyo", "我", "爱了"]
new_list.sort (key = len)       # 让列表进行字符长度排序
print(new_list)

new_list [1] = "my"         # 更改列表元素   此时再用列表list其顺序就是更改后的顺序
new_list.sort ( )           # 对列表行猎ASCII顺序排列（可理解为英文字母顺序排列）
print(new_list)

>>['我', '爱了', '人间理想', 'mihoyo']
['mihoyo', 'my', '人间理想', '我']

注意：sort 对列表进行 永久性排序，即排序之后再也无法恢复到原来的顺序

                · 列表名.sort (reverse = True)    永久性排序 （语字母顺序相反）

new_list = ["人间理想", "mihoyo", "我", "爱了"]
new_list.sort( reverse = True )            # 对列表进行永久性排序（与字母顺序相反）
print(new_list) 

>>['爱了', '我', '人间理想', 'mihoyo']

                 · sorted ( 列表名 )        临时性排序   

new_list = ["人间理想", "mihoyo", "我", "爱了"]  
print( sorted(new_list) )   # 对列表进行临时性排序

new_list [1] = "my"     # 对列表元素进行修改
print(new_list)       


>>['mihoyo', '人间理想', '我', '爱了']      
['人间理想', 'my', '我', '爱了']            # 此处的元素顺序已经变回修改前的顺序

注意：sorted (列表名) 是对列表的 临时性排序，即排序之后还能恢复到原来的顺序

                ·列表名.reverse ( )            倒序

list = ["my", "a", "b", "c"]
list.reverse ( )
print (list)

>>['c', 'b', 'a', 'my']

        5.列表的复制  copy    *n

                · 列表.copy ( )             对列表进行浅复制 

list = ["my", "a", "b", "c"]
copy_list = list.copy ( )            # 对列表进行浅复制
print ( copy_list )

>>['my', 'a', 'b', 'c']

注意：浅复制指 复制内容指向原内存地址   故 被复制对象内容改变 会影响 浅复制对象内容

                · 列表 * n        n为正整数  以实现列表元素的重复 n 遍

list = ["my", "a", "b", "c"]
print ( list * 3 )

>>['my', 'a', 'b', 'c', 'my', 'a', 'b', 'c', 'my', 'a', 'b', 'c']

六、列表的嵌套

        1. 复合列表  （类似复合函数）

list = ["my", "a", "b", "c"]
new_list = ["人间理想", "mihoyo", "我", "爱了"]
compound_list = [list, new_list]         # 令两个列表组合成一个新列表
print(compound_list)
  
print( compound_list [0] )       # 输出新列表的下标索引号为 0 的元素——子列表

print( compound_list [0] [1] )   # 输出新列表的下标索引号为 0 的元素——子列表下标索引号为 1 的元素

>>[['my', 'a', 'b', 'c'], ['人间理想', 'mihoyo', '我', '爱了']]
['my', 'a', 'b', 'c']
a

七、列表切片 [ start : end ; length ]    

list = ["my", "a", "b", "c"]
num = list [0 : 3: 2]      # 对列表 0 — 3 左闭右开区间内 第一个元素开始取，每取一个元素下标 +2 
print(num)

>>['my', 'b']

注意：切片区间为 左闭右开 每取一个元素 下标索引号 +部常length 再取

八、字符串与列表的转化 list ( )     " _" . join ( )

        1. 字符串转列表 list ( str ) 

name = "全民制作人大家好，我是练习时长两年半的个人练习生"
new_name = list(name)
print (new_name)

>>['全', '民', '制', '作', '人', '大', '家', '好', '，', '我', '是', '练', '习', '时', '长', '两', '年', '半', '的', '个', '人', '练', '习', '生']

        2.列表转字符串 "(元素间连接方式)" . join ( list )

ikun_list = ['全', '民', '制', '作', '人', '大', '家', '好', '，', '我', '是', '练', '习', '时', '长', '两', '年', '半', '的', '个', '人', '练', '习', '生']
transfer_list = "".join (ikun_list)      # “”各元素之间的连接方式为 无空格
print (transfer_list)

>>全民制作人大家好，我是练习时长两年半的个人练习生