Python_列表

最新推荐文章于 2023-10-01 08:26:10 发布

、直接动手

最新推荐文章于 2023-10-01 08:26:10 发布

阅读量1.5k

点赞数

分类专栏： # Python 文章标签： python 列表

本文链接：https://blog.csdn.net/qq_45714082/article/details/102577076

版权

Python 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

列表

有序可变序列
有0个或多个数据组成的有序数列

1、创建列表
-创建列表的简单方法用方括号[]将元素括起来：

      ['spam', 2.0, 5, 40]

-一个列表作为另一个列表的元素称为列表的嵌套：

      ['hello', 16.0, 25,[1, 2, 3]]

-不含任何元素的列表称为空列表，使用空的方括号([])创建一个空列表。（赋初值时可以用到）
例：

         cheeses = ['Cheddar', 'Edam']
         numbers = [17, 123]
         empty = []
         print (cheeses, numbers, empty)

          ['Cheddar', 'Edam'] [17, 123] []

2、列表是可变的
-列表元素的访问与字符串的字符的访问语法是一样，使用方括号操作符。
-方括号内的表达式指定索引位置。（索引从0开始，如果索引值为负表示从列表尾部算起且还是-1开头）
-列表中的索引位置必须为整数
-与字符串不同的是列表可变。你可以改变列表中元素的顺序，或者对列表中元素重新赋值。
例：

          cheeses = ['Cheddar', 'Edam']
          numbers = [17, 123]
          numbers[1] = 5
          print (cheeses[0],cheeses[-1])
          print(numbers)

            Cheddar Edam
            [17, 5]

3、列表的遍历
-如果只需遍历列表元素用for循环

     cheeses = ['Cheddar', 'Edam']
     for i in cheeses:
         print(i)

                Cheddar
                Edam

-in操作符算法。在列表中，Python中采用线性搜索策略，搜索时间与列表长度成正比。

但如果想写入或更新元素，这时就需要索引。一个常见的方法是range函数和len函数(得到列表长度)的结合：
例：

         ls =[1,2,3,4,5,6,6,7,8,9]
         for i in range(len(ls)):
             ls[i] = ls[i] * 2
         print(ls)

          [2, 4, 6, 8, 10, 12, 12, 14, 16, 18]
    #对于空列表来说，for循环不会执行函数体

尽管一个列表可以包含另一个列表，但被包含的列表只能被看作一个元素。
例:

           la = ['spam',1 ,[ 'Brie', 'Roquefort', 'Pol le veq'],[1,2,3]]
           ly = la[2]
           print(ly, len(la))

         ['Brie', 'Roquefort', 'Pol le veq']  4

4、列表类型操作函数和方法
-len(ls) 得到列表ls的长度

-用"+"运算符连接多个列表，更新列表ls,将列表lt元素增加到列表ls中
例：

             a = [1,2,3]
             b = [4,5,6]
             c = a + b
             print(c)

             [1, 2, 3, 4, 5, 6]

-用"*"运算符对列表进行给定次数的重复，将列表ls重复n次
例：

               a = [1,2,3]
               a = a *3
               print(a)

             [1, 2, 3, 1, 2, 3, 1, 2, 3]

-ls[i] = x 替换列表la第i元素为x
例：

              ls =[1,2,3,4,5,6,7,8,9]
              ls[6] = 'a'
              print(ls)

             [1, 2, 3, 4, 5, 6, 'a', 8, 9]

-ls[i: j: k] = lt

用列表替换ls切片后对应元素子列表
lt元素个数要和ls切片所得的元素个数相同，lt列表的元素才能到ls列表的对应位置
切片操作，时常记得"不到 j"即其中不包含第j个元素，k可以省略，此时默认步数为1
例：

            ls = [1,2,3,4,5,6,7,8,9]
            lt = [66,77,88,99]
            ls[0: 8: 2] = lt
            print(ls)

            [66, 2, 77, 4, 88, 6, 99, 8, 9]

-del ls[i] 删除列表ls 中第i元素

-del ls[i: j: k] 删除列表ls中第i到"第j"(切片操作，"不到j"即其中不包含第j个元素,j前一个元素为止)以K为步长的元素，k可以省略，此时默认步数为1
例：

              ls = [1,2,3,4,5,6,7,8,9]
              del ls[0: 8: 2] 
              print(ls)

              [2, 4, 6, 8, 9]

-ls.append(x) 在列表ls最后增加一个元素x
例：

             ls = [1,2,3,4,5,6,7,8,9]
             ls.append('f')
             print(ls)

             [1, 2, 3, 4, 5, 6, 7, 8, 9, 'f']

-ls.extend() 可以将列表作为参数，并把一个列表的所有元素添加到另一个列表的尾部。
例：

               ls = [1,2,3,4,5,6,7,8,9]
               lt = ['a','b','c']
               ls.extend(lt)
               print(ls)

               [1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c']

-ls.insert(i,x) 在列表ls的第i位置插入元素，后面元素依次后移
例：

                ls = [1,2,3,4,5,6,7,8,9]
                ls.insert(4,'k')
                print(ls)

                [1, 2, 3, 4, 'k', 5, 6, 7, 8, 9]

-ls.pop(i) 在列表ls的第i位置元素取出并删除该元素
例：

                ls = [1,2,3,4,5,6,7,8,9]
                ls.pop(4)
                print(ls)

                [1, 2, 3, 4, 6, 7, 8, 9]

-ls.remove(x) 将列表ls中出现的第一个元素x删除
例：

               ls = [1,2,3,4,5,6,6,7,8,9]
                ls.remove(6)
                print(ls)

                 [1, 2, 3, 4, 5, 6, 7, 8, 9]

-ls.sort() 将列表元素从低到高排序

要求同种类型，即字符型与数值型不能比较
如果是多个字符的字符串从把第一个字母开始比较，相同则比较第二个字母，小写字母一般大于大写字母（由Unicode编码可知）
例：

               ls = [1,6,3,4,7,9,8,5,2]
               lt = ['A','F','a','b','y']
               ls.sort()
               lt.sort()
               print(ls)
               print(lt)

                   [1, 2, 3, 4, 5, 6, 7, 8, 9]
                   ['A', 'F', 'a', 'b', 'y']

-ls.sort(cmp=None, key=None, reverse=False) 函数用于对原列表进行排序

如果指定参数，则使用比较函数指定的比较函数。
该方法没有返回值，但是会对列表的对象进行排序。
cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
例1：

      vowels = ['e', 'a', 'u', 'o', 'i'] 
      vowels.sort(reverse=True) 
      print ( '降序输出:', vowels )

     降序输出: ['u', 'o', 'i', 'e', 'a']

例2：

def takeSecond(elem): 
return elem[1]         # 获取列表的第二个元素
random = [(2, 2), (3, 4), (4, 1), (1, 3)] 
random.sort(key=takeSecond)    # 指定第二个元素排序
print ('排序列表：', random)

排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

例3 ：
提示 key=lambda x: x[0]

x:x[]字母可以随意修改，按照中括号[]里面的维度排序，[0]按照第一位，[1]按照第二位。

def two_d_list_sort():  
    list=[ ["1","c++","demo"],  
           ["1","c","test"],  
           ["2","java",""],  
           ["8","golang","google"],  
           ["4","python","gil"],  
           ["5","swift","apple"]  
    ]  
    list.sort(key=lambda ele:ele[0])   # 根据第1个元素排序  
    print(list)  
    list.sort(key=lambda ele:ele[1])   #根据第2个元素排序  
    print(list)  
    list.sort(key=lambda ele:ele[1]+ele[0])   #先根据第2个元素排序，再根据第1个元素排序  
    print(list)

[['1', 'c++', 'demo'], ['1', 'c', 'test'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple'], ['8', 'golang', 'google']]  
[['1', 'c', 'test'], ['1', 'c++', 'demo'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]  
[['1', 'c++', 'demo'], ['1', 'c', 'test'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]

-sorted(iterable, key=None, reverse=False) 函数对所有可迭代的对象进行排序操作。返回重新排序的列表。

iterable – 可迭代对象。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

例1：

 sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})

  [1, 2, 3, 4, 5]       #对字典用sorted函数，对字典只对键排序生成一个新的列表

例2：

       example_list = [5, 0, 6, 1, 2, 7, 3, 4]
       result_list = sorted(example_list, key=lambda x: x*-1)   #sorted函数返回值是一个新的列表  
       print(result_list)

  [7, 6, 5, 4, 3, 2, 1, 0]

例3：

ls = (1,6,3,4,7,9,8,5,2)
lt =('A','F','apple','b','y')
print(sorted(ls))           #对元组排序，将其转化为一个新的列表形式，再排序处理
print(sorted(lt))

   [1, 2, 3, 4, 5, 6, 7, 8, 9]
   ['A', 'F', 'apple', 'b', 'y']

-ls.reverse() 将列表ls 中的元素反转
例：

                ls = [1,2,3,4,5,6,7,8,9]
                ls.reverse()
                print(ls)

                   [9, 8, 7, 6, 5, 4, 3, 2, 1]

-ls.clear() 删除列表ls中所有元素
例：

           ls = [1,2,3,4,5,6,7,8,9]
                 ls.clear()
                 print(ls)
                    []

-ls.copy() 生成一个新的列表，复制ls中所有元素
例：

              ls = [1,2,3,4,5,6,7,8,9]
              lt = ls.copy()
              print(lt)

               [1, 2, 3, 4, 5, 6, 7, 8, 9]

5.列表与函数
- sum() 求列表元素之和，当列表元素全为数字时才起作用
- max() 求列表元素最大值
- min() 求列表元素最小值
- 其他函数如max()、min()等对字符串列表和其他可进行比较的数据类型才会起作用。
例：

         nums =[3,41,12,9,74,15]
         print(len(nums))
         print(max(nums))
         print(min(nums))
         print(sum(nums))
         print(int(sum(nums)/len(nums)))

实例：基本统计计算
例：

  def getNum():
         nums = []
         iNumStr = input("请输入数字:")
         while iNumStr != "":
             nums.append(eval(iNumStr))
             iNumStr = input("请输入数字（直接回车计算）:")
         return nums

    def mean(numbers): #计算平均值
        s = sum(numbers)
        return s/len(numbers)

   def dev(numbers,mean):  #计算方差
       sdev = 0.0
       for num in numbers:
           sdev = sdev +(num - mean)**2
       return pow (sdev /(len(numbers)-1),0.5)

   def median(numbers):     #计算中位数
      sorted(numbers)
      size = len(numbers)
      if size % 2 == 0:
          med = (numbers[size//2+1]+numbers[size//2])/2
      else:
          med = numbers[size//2+1]
      return med
 n = getNum()
 m = mean(n)
 print("平均值:{},方差:{:.2},中位数:{}.".format(m, dev(n,m),median(n)))

6、列表与字符串
- 字符串是字符的序列，而列表是一系列值的序列。字符列表与字符串是不同的。
- list内置函数方法，把字符串转换成字符列表

list函数将字符串转化成一些单独的字母
例1：

              s = 'spam'
              t = list(s)
              print (t)

       ['s', 'p', 'a', 'm']

-使用split函数把一个字符分成单独的单词
例2：

            a = 'pining for the fjords'
            t = a.split()           
            print (t)
            print(t[2])       #一旦使用split函数将字符串分解成单词组成的序列，你就可以利用索引操作符(方括号)来访问列表中特定单词了。

          ['pining', 'for', 'the', 'fjords']
           the

-join函数与split函数的作用相反。它使用字符串列表，把列表元素连接起来。

join是字符串方法，所以必须指定分隔符，将列表作为参数。
例：

               t = ['pining', 'for', 'the', 'fjords']
               delimiter = ' '        #此时空字符串("")作为分隔符
               a = delimiter.join(t)
               print(a)

                pining for the fjords

7、行间解析
-str.rstrip([chars]) 删除 str字符串末尾的指定字符（默认为空格，返回删除 str 字符串末尾的指定字符chars（默认为空格）后生成的新字符串。
例:

str = "     this is string example....wow!!!     "
print(str.rstrip())
str = "88888888this is string example....wow!!!8888888"
print(str.rstrip('8'))

           this is string example....wow!!!
88888888this is string example....wow!!!

-str.startswith(str, beg=0,end=len(str)) 用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。

str检测的字符串。
beg可选参数用于设置字符串检测的起始位置,
end可选参数用于设置字符串检测的结束位置。
如果参数 beg 和 end 指定值，则在指定范围内检查。
例：

    str = "this is string example....wow!!!"
    print (str.startswith( 'this' ))
    print (str.startswith( 'string', 8 ))
    print (str.startswith( 'this', 2, 4 ))

True
True
False

-利用以上函数编写一个小程序；找到以”from”开头的句子，然后把句子分解，最后输出句子中第三个单词：

fhand = open(‘mbox-short.txt’)
for line in fhand:
     line = line.lstrip()
if not line.startswith(‘from‘) : continue
words = line.split()
print (words[2])

8、对象与值
-id([object]) 函数用于获取对象object的内存地址,
返回对象为内存地址
例：

a = 'runoob'
print(id(a))
b = a
print(id(b))

2248775347648
2248775347648

-is即判断是否是同一个对象，相同则返回Ture,不同则False
执行下面赋值语句：

a = 'banana'
b = 'banana'
a is b

    Ture
              #表示Python只创建了一个对象，a和b都指向它。

-如果创建两个列表就会得到两个对象：

a = [1,2,3]
b = [1,2,3]
print(id(a))
print(id(b))
a is b

 2248691441544
 2248691421064 
 False

  #两个列表等价，但不能说它们是同一个，它们是不同的对象

-对象拥有值。当执行语句a = [1,2,3]，元素a会指向一个列表对象。这个列表对象的值是一个特定元素序列。此时，如果有另外一个列表与它的元素相同，那只能说它们拥有相同的值。

9、别名引用
-如果a指向一个对象，当执行b = a后，两个变量都指向同一个对象：

a = [1,2,3]
b = a
print(id(a))
print(id(b))
a is b

   2248691417160
   2248691417160
   Ture

       #变量与对象之间的关系称为引用，在上述例子中，同一个对象有两个引用。
 拥有多个引用的对象就会有多个名称，这种现象称作对象被赋予了别名。

-但由其他类型转化而来的元组会事先建立一个地址，赋值式只赋予元素而未赋予地址，所以不是同一个对象：

        m = 'I am very fun'
        print(id(m.split()))
        a= m.split()
        print(id(a))
        b = a
        print(id(b))
        m.split() is a

2520073157768
2520073830280
2520073830280
False

-如果别名化的对象是可变的，那么一个别名的变化，将影响到其他别名的引用。

a = [1,2,3]
b = a
print(b is a)
b[0] = 17
print(a)

      True    
[17, 2, 3]
        #尽管这行为是有用的，但容易造成错误。一般而言，可变对象最好不要使用别名

-两个列表自二元操作符运算不改变地址与指向
例1：

num= [100]
print(id(num))
num += 2*num 
print(id(num))

     2692697770376
     2692697770376

例2：

num= [100]
print(id(num))
a = num +num
print(id(a))
num = a
print(id(num))

     2692698614600
     2692697770376
     2692697770376

例3：

num= [100]
print(id(num))
num = num +num
print(id(num))

  2692697941576
  2692697902984

、直接动手

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Python_列表

列表有序可变序列有0个或多个数据组成的有序数列1、创建列表-创建列表的简单方法用方括号[]将元素括起来： ['spam', 2.0, 5, 40]-一个列表作为另一个列表的元素称为列表的嵌套： ['hello', 16.0, 25,[1, 2, 3]]-不含任何元素的列表称为空列表，使用空的方括号([])创建一个空列表。（赋初值时可以用到）例： ...
复制链接

扫一扫

专栏目录