python 列表

序列类型简介（sequence）

字符串str
                         列表list
                         元祖tuple

概念：

列表是由一系列特定元素组成的，元素之间可能没有任何关联，但是他们之间有先后顺序关系
                     列表可以改变各个元素的值
                     列表是一个容器。

空列表： L = [ ]  # 空列表

L = list（）  # 空列表，是一个函数

创建一个非空列表：

L = [1,2,3,4,5]

列表的生成函数list（）：

list（）生成一个空列表等同于[ ]  ;

list(iterable)     用一个可迭代对象初始化列表

例子：

 >>> l=list(range(11))

 >>> l

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

 >>>

 >>> s='abcdefg'

 >>> l=list(s)

 >>> l

 ['a', 'b', 'c', 'd', 'e', 'f', 'g']

 >>>

list1

列表的运算符

+     、 +=    、  *  、 *=

说明： + 号运算符用于拼接列表；  += 运算符用于原来列表与右侧列表拼接生成的新列表（x = x+y 等同于 x +=y）

* 号运算符用于生成重复的列表 ；   * =号运算符用于原列表生成重复的列表，并改变变量的绑定；

 >>> x=[1,2,3]

 >>> y=[4,5,6]

 >>> z = x + y

 >>> z

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

 >>> len(z)

 6

 >>> m = y + x

 >>> m

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

 >>> len(m)

 6

 >>>

+号拼接

 >>> x=[1,2,3]

 >>> y=[4,5,6]

 >>> x += y

 >>> x

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

 >>> y

 [4, 5, 6]

 >>>

+=号拼接

 >>> [1,2] * 3

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

 >>> 3 * [1,2]

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

 >>>

*

 >>> x = [1,2,3]

 >>> x *= 4

 >>> x

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

 >>>

*=

列表的关系(比较)运算符:

>     >=    <     <=    ==    !=

 >>> x = [1,2,3]

 >>> y = [2,3,4]

 >>> x != y

 True

 >>> x > y

 False

 >>> x < y

 True

 >>> x == y

 False

 >>> [1,2,3] == [3,2,1]

 False

 >>> [1,'two'] < ['two',1]

 Traceback (most recent call last):

   File "<pyshell#59>", line 1, in <module>

     [1,'two'] < ['two',1]

 TypeError: unorderable types: int() < str()

 >>>#字符串和列表是不能比较的

列表的 in   /  not in 运算符

 >>> x = [,'two', 3.0, "four"]

 >>>  in x

 True

 >>>  not in x

 True

 >>> "" in x

 False

 >>>  in x

 False

 >>>

in、not in

列表的基本操作

索引（indes）： 列表[ 索引 ] ，等同于字符串索引；正向索引（0  ， len（x）-1 ），反向索引（- len（x） ，-1），

 >>> x

 [1, 'two', 3.0, 'four']

 >>> x[0]

 1

 >>> x[1]

 'two'

 >>> x[2]

 3.0

 >>> x[4]

 Traceback (most recent call last):

   File "<pyshell#11>", line 1, in <module>

     x[4]

 IndexError: list index out of range

 >>>

列表是可变的，可以通过赋值改变列表的元素；

 >>> x = [1,2,3,4]

 >>> x[2]=3.14

 >>> x

 [1, 2, 3.14, 4]

 >>>

可变的list

切片slice      [ : ]   [ : : ]

列表的切片规则等同于字符串的切片规则；

 >>> x

 [1, 2, 3.14, 4]

 >>> x[1:2]

 [2]

 >>> x[:]

 [1, 2, 3.14, 4]

 >>> x[::]

 [1, 2, 3.14, 4]

 >>> x[::2]

 [1, 3.14]

 >>>

slice,步长

切片赋值：

作用：可以改变原列表的排列，及插入删除数据，列表中可以用切片改变列表对应的元素的值；

 >>> x

 [1, 2, 3.14, 4]

 >>> x[0:1]

 [1]

 >>> x[0:1]=[1.1,2.2]

 >>> x

 [1.1, 2.2, 2, 3.14, 4]

 >>> x[1:1] #空值

 []

 >>> x[1:1]=[3.3,4.4]

 >>> x

 [1.1, 3.3, 4.4, 2.2, 2, 3.14, 4]

 >>>

切片赋值

注意事项：对于步长大于1 的切片可能会出现赋值错误；

切片赋值是改变原列表，不会生成新列表；

 >>> x

 [1.1, 3.3, 4.4, 2.2, 2, 3.14, 4]

 >>> x[0::2]

 [1.1, 4.4, 2, 4]

 >>> x[0::2]=[11,12]   #赋值的数量不够4个

 Traceback (most recent call last):

   File "<pyshell#27>", line 1, in <module>

     x[0::2]=[11,12]

 ValueError: attempt to assign sequence of size 2 to extended slice of size 4

 >>> x[0::2]=[11,22,33,44]

 >>> x

 [11, 3.3, 22, 2.2, 33, 3.14, 44]

 >>>

切片

python3中常用的序列函数：

len（x）   返回序列的长度

max（x） 返回序列最大值的元素

min（x） 返回序列最小值的元素

sum（x） 返回序列中所有元素的总和；

any（x）  真值测试，如果列表其中一个值为真值，则返回True

all（x）    真值测试，如果列表所有值都为真值，则返回True

序列函数

练习：求列表的最大值，最小值，平均值

 #!/usr/bin/python

 n1 = int(input("请输入第一个整数："))

 n2 = int(input("请输入第二个整数："))

 n3 = int(input("请输入第三个整数："))

 list1=[n1,n2,n3]

 print("列表：",list1)

 print("列表的最大值是：",max(list1))

 print("列表的最小值是：",min(list1))

 n = len(list1)

 print("列表的平均值是：",sum(list1)//n)

 >>> ================================ RESTART ================================

 >>>

 请输入第一个整数：20

 请输入第二个整数：30

 请输入第三个整数：40

 列表： [20, 30, 40]

 列表的最大值是： 40

 列表的最小值是： 20

 列表的平均值是： 30

 >>>

list1

list2

 #!/usr/bin/python

 n1 = int(input("请输入第一个整数："))

 n2 = int(input("请输入第二个整数："))

 n3 = int(input("请输入第三个整数："))

 #list1=[n1,n2,n3]

 list1 = []

 list1[0:0]=[n1]

 list1[0:0]=[n2]

 list1[0:0]=[n3]

 print("列表：",list1)

 print("列表的最大值是：",max(list1))

 print("列表的最小值是：",min(list1))

 n = len(list1)

 print("列表的平均值是：",sum(list1)//n)

 >>> ================================ RESTART ================================

 >>>

 请输入第一个整数：20

 请输入第二个整数：30

 请输入第三个整数：40

 列表： [40, 30, 20]

 列表的最大值是： 40

 列表的最小值是： 20

 列表的平均值是： 30

 >>>

python3中常用的列表方法：

见help（lsit）

L.index(v,[,begin[,end]] )             #返回对应元素的索引下标，begin为开始索引，end为结束索引
L.insert(index,obj)                       #将某个元素插放到列表中指定的位置
L.count(x)                                    # 返回列表中元素的个数
L.remove(x)                                #从列表中删除第一次出现在列表中的值
L.copy()                                     #复制此列表（只复制一层，不进行深层复制）
L.append(x)                               #在列表的尾部添加单个元素
L.extend(list)                             #向列表追加另一个列表
L.clear()                                    #清空列表，等同于L[:] = []
L.sort(reverse=False)               #将列表的顺序按值的小到大顺序进行排列(升序)；reverse=True 降序；
L.reverse()                               #列表反转（头变尾，尾变头）
L.pop([index])                           #删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回移除元素 

 >>>

 >>> l=[1,2,3,4,5,6,7,8]

 >>> l.index(2)

 1

 >>> l.index(4)

 3

 >>> l.index(3,5)

 Traceback (most recent call last):

   File "<pyshell#50>", line 1, in <module>

     l.index(3,5)

 ValueError: 3 is not in list

 >>> l.index(3,1)

 2

 >>> l.index(6, 3, 8)

 5

 >>> l

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

 >>> l.insert(3,10)

 >>> l

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

 >>> l.count(5)

 1

 >>> l.remove(4)

 >>> l

 [1, 2, 3, 10, 5, 6, 7, 8]

 >>> l.remove(11)

 Traceback (most recent call last):

   File "<pyshell#59>", line 1, in <module>

     l.remove(11)

 ValueError: list.remove(x): x not in list

 >>> l.append(11)

 >>> l

 [1, 2, 3, 10, 5, 6, 7, 8, 11]

 >>> l.extend([12,13,14,15])

 >>> l

 [1, 2, 3, 10, 5, 6, 7, 8, 11, 12, 13, 14, 15]

 >>> l.clear(0

 KeyboardInterrupt

 >>> l.clear()   #clear方法清空

 >>> l

 []

 >>> l = [1,2,3,4,5]

 >>> l[:] = []

 >>> l

 []

 >>> l = [1,2,3,4,5]

 >>> l

 [1, 2, 3, 4, 5]

 >>> l2 = l

 >>> l

 [1, 2, 3, 4, 5]

 >>> l2

 [1, 2, 3, 4, 5]

 >>> l[:] = []   #切片清空

 >>> l

 []

 >>> l2

 []

 >>> l = [1,2,3,4,5]

 >>> l2 = l

 >>> l2

 [1, 2, 3, 4, 5]

 >>> l = []

 >>> l

 []

 >>> l2

 [1, 2, 3, 4, 5]

 >>> l = [5,7,3,8,4,1,10]

 >>> l.sort()

 >>> l

 [1, 3, 4, 5, 7, 8, 10]

 >>> l.sort(reverse=True)

 >>> l

 [10, 8, 7, 5, 4, 3, 1]

 >>> l

 [10, 8, 7, 5, 4, 3, 1]

 >>> l = [ 2,7,1,5,8]

 >>> l.reverse()

 >>> l

 [8, 5, 1, 7, 2]

 >>> l.reverse()

 >>> l

 [2, 7, 1, 5, 8]

 >>> l.pop()

 8

 >>> l

 [2, 7, 1, 5]

 >>> l.pop([2])

 Traceback (most recent call last):

   File "<pyshell#97>", line 1, in <module>

     l.pop([2])

 TypeError: 'list' object cannot be interpreted as an integer

 >>> l.pop(2)

 1

 >>> l

 [2, 7, 5]

 >>> l2 = l

 >>> l2

 [2, 7, 5]

 >>> l2 = l.copy()

 >>> l2

 [2, 7, 5]

 >>> id(l2)

 57182664

 >>> id(l)

 57183112

 >>> l2 = l

 >>> l2

 [2, 7, 5]

 >>> id(l)

 57183112

 >>> id(l2)

 57183112

 >>>

list方法

嵌套列表

 >>> L = [20,21,22]

 >>> L1 = [10,L,30]

 >>> L1

 [10, [20, 21, 22], 30]

 >>> L2 = L1.copy()

 >>> L2

 [10, [20, 21, 22], 30]

 >>> L1[0] = 9

 >>> L1

 [9, [20, 21, 22], 30]

 >>> L2

 [10, [20, 21, 22], 30]

 >>> L1[1][1] = 21.5

 >>> L1

 [9, [20, 21.5, 22], 30]

 >>> L2

 [10, [20, 21.5, 22], 30]

 >>>

list

复制列表

两种：深拷贝和浅拷贝；

浅拷贝（shallow  copy）： L.copy()  和 L[ ：] 切片复制是浅拷贝

深拷贝（deep copy） ： 将对象逐层复制（复制后对象完全独立）

 >>> import copy

 >>> L

 [20, 21.5, 2222]

 >>> L1

 [9, [20, 21.5, 2222], 30]

 >>> L2 =copy.deepcopy(L1)  #调用深拷贝函数进行复制

 >>> L2

 [9, [20, 21.5, 2222], 30]

 >>> L[2] = 25

 >>> L

 [20, 21.5, 25]

 >>> L1

 [9, [20, 21.5, 25], 30]

 >>> L2

 [9, [20, 21.5, 2222], 30]

 >>>

深拷贝

del 运算符

用于删除列表元素；

 >>> cities = ['北京','上海','深圳']

 >>> cities.remove('深圳')

 >>> cities

 ['北京', '上海']

 >>> cities = ['北京','上海','深圳']

 >>> cities.pop(2)

 '深圳'

 >>> cities

 ['北京', '上海']

 >>> cities = ['北京','上海','深圳']

 >>> del cities[2]

 >>> cities

 ['北京', '上海']

 >>>

删除列表元素

练习：

 #!/usr/bin/python

 primes = [] #用来存放质数

 while True:

     n = int(input("请输入一个大于0的整数："))

     if n <= 1:

         break #终止死循环

     for  x in range(2, n):

         if n % x == 0:

             break   #不是质数（素数）

     else:

         print(n,"是质数")

         primes.append(n) #存入列表

 print("所有质数：",primes)

 print("end！")

 >>> ================================ RESTART ================================

 >>>

 请输入一个大于0的整数：2

 2 是质数

 请输入一个大于0的整数：3

 3 是质数

 请输入一个大于0的整数：4

 请输入一个大于0的整数：5

 5 是质数

 请输入一个大于0的整数：0

 所有质数： [2, 3, 5]

 end！

 >>>

列表是可迭代对象；（字符串也是可迭代对象）

 >>> L = [2,3,4,5,6,7]

 >>> for x in L:

     print(x)

 2

 3

 4

 5

 6

 7

 >>>

迭代

列表推导式（list comprehension）
列表推导式是用可迭代对象，依次生成列表内元素的方式。
语法：
[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 条件表达式]
例如：

 >>> L = [x**2 for x in range(1,11)]

 >>> L

 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 >>> [x**2 for x in range(1,11,2)]

 [1, 9, 25, 49, 81]

 >>>

list推导式

列表推导式嵌套

语法：[表达式1 for 变量1 in 可迭代对象1 (if 条件表达式1)表达式2 for 变量2 in 可迭代对象2 (if 条件表达式2)]

嵌套

列表和字符串的比较：

1， 都是序列，有先后顺序； 2 列表是可变的，字符串是不变的；  3 列表可以存储任意类型的数，字符串只能存储字符；

字符串的文本解析方法：

s.split( sep=None)    将字符串s分割成字符串列表；

s.join(iterable)          将可迭代对象进行拼接，中间用字符串进行分割；

 >>>

 >>> s = "welcome to china"

 >>> words = s.split(' ')

 >>> print(words)

 ['welcome', 'to', 'china']

 >>>

 >>> path = '/home/test/a.txt'

 >>> path.split('/')

 ['', 'home', 'test', 'a.txt']

 >>> path.split('/')[-1]

 'a.txt'

 >>> s = 'AcBcDcE'

 >>> s.split('c')

 ['A', 'B', 'D', 'E']

 >>>

 >>> l = ["C:","windows","system32"]

 >>> '\\'.join(l)

 'C:\\windows\\system32'

 >>> print(s)

 AcBcDcE

 >>> s = '\\'.join(l)

 >>> print(s)

 C:\windows\system32

 >>>

练习：

 >>> s = 'hello'

 >>> ' '.join(s)

 'h e l l o'

 >>> s1 = ' '.join(s)

 >>> print(s1)

 h e l l o

 >>> s1

 'h e l l o'

 >>> s2 = '-'.join(s)

 >>> s2

 'h-e-l-l-o'

 >>>

Python之路，第六篇：Python入门与基础6的更多相关文章

  1. Python之路(第六篇)Python全局变量与局部变量、函数多层嵌套、函数递归

    一.局部变量与全局变量 1.在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量.全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序. 全局变量没有任何缩进,在任何位置都可 ...

  2. 【Python之路】第九篇--Python基础之线程、进程和协程

    进程与线程之间的关系 线程是属于进程的,线程运行在进程空间内,同一进程所产生的线程共享同一内存空间,当进程退出时该进程所产生的线程都会被强制退出并清除.线程可与属于同一进程的其它线程共享进程所拥有的全 ...

  3. Python之路(第五篇) Python基本数据类型集合、格式化、函数

    一.变量总结 1.1 变量定义 记录某种状态或者数值,并用某个名称代表这个数值或状态. 1.2 变量在内存中的表现形式 Python 中一切皆为对象,数字是对象,列表是对象,函数也是对象,任何东西都是 ...

  4. 【Python之路】特别篇--Python面向对象（进阶篇）

    上一篇<Python 面向对象(初级篇)>文章介绍了面向对象基本知识: 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个“函数”供使 ...

  5. Python之路【第九篇】堡垒机基础&数据库操作

    复习paramiko模块 Python的paramiko模块,是基于SSH用于连接远程服务器并执行相关操作. SSHClient #!/usr/bin/env python #-*- coding:u ...

  6. Python之路(第八篇)Python内置函数、zip()、max()、min()

    一.python内置函数 abs() 求绝对值 例子 print(abs(-2)) all() 把序列中每一个元素做布尔运算,如果全部都是true,就返回true, 但是如果是空字符串.空列表也返回t ...

  7. Python之路(第七篇)Python作用域、匿名函数、函数式编程、map函数、filter函数、reduce函数

    一.作用域 return 可以返回任意值例子 def test1(): print("test1") def test(): print("test") ret ...

  8. 【Python之路】特别篇--Python切片

    字符串切片操作 切片操作符是序列名后跟一个方括号,方括号中有一对可选的数字,并用冒号分割. 注意: 数是可选的,而冒号是必须的. consequence[start:end:step] 切片操作符中的 ...

  9. 【Python之路】特别篇--Python内置函数

    abs() 求绝对值 i = abs(-100) print(i) # 100 all() 循环里面的参数 如果每个元素都为真,那么all返回值为真  假: 0 False None "&q ...

  10. 【Python之路】特别篇--Python文件操作

    文件操作 open函数,该函数用于文件处理 操作文件时,一般需要经历如下步骤: (1)打开文件 (2)操作文件 一.打开文件 文件句柄 = open('文件路径', '模式','编码') 打开文件时, ...

随机推荐

  1. 一、I/O操作（缓存流，数据流，对象流）

    一.缓存流 以介质是硬盘为例子说明,字节流和字符流的缺点: 每次读写的时候,都会访问硬盘,如果读写频率比较高的时候,性能不佳.为了解决问题,采用缓存流. 缓存流在读取的时候,会一次性读较多的数据到缓存 ...

  2. maven聚合工程使用如何debug

    maven聚合工程在正常情况下,使用debug时会出错,因为没有源码,就不会显示代码和断点行数条. 进行如下操作: 默认情况下source下只有默认的default文件夹,点击remove进行删除(这 ...

  3. Linux/AIX/Windows端口和进程互查

    经常我们需要通过端口号查是哪个进程占用,或想查看某个进程占用了哪些端口. 1.1Linux上通过端口查找进程 比如我们想知道当前系统中80端口是哪个进程所占用 netstat -anp| |more ...

  4. Java文档注释导出帮助文档和项目的jar包导入和导出。

    1.1      文档注释导出帮助文档 在eclipse使用时,可以配合文档注释,导出对类的说明文档,从而供其他人阅读学习与使用. 通过使用文档注释,将类或者方法进行注释用@简单标注基本信息.如@au ...

  5. ubuntu 调节音量命令 声卡驱动

    alsamixer 安装驱动http://www.realtek.com/downloads/downloadsCheck.aspx?Langid=1&PNid=24&PFid=24& ...

  6. Win10系列：JavaScript 项目模板中的文件和项模板文件

    通过上面内容的学习,相信读者已经对各种项目模板和项模板有了大致的了解,本节将进一步介绍项目模板中默认包含的项目文件以及项模板文件,首先讲解这些文件中的初始内容以及作用,然后介绍在一个页面中如何添加控件 ...

  7. java -jar 使用要点

    1.在将进程设为脱离终端运行时,输出流不能输出到当前窗口.否则,退出终端后,进程会pause.pause是停滞,是僵尸进程. 2.包含资源文件的war.jar文件是无法独立运行的.需要解压到临时目录. ...

  8. vue-router-1-安装与基本使用

    npm install vue-router import Vue from 'vue' import VueRouter from 'vue-router' Vue.use(VueRouter) / ...

  9. leetcode python 005

    ##  给定字符串,寻找最长回文子串##  单回文,双回文 def findh(s):    ## 单回文    ld,l=[],len(s)    if len(s)<3:        re ...

  10. ７.5 C++基本序列式容器

    参考:http://www.weixueyuan.net/view/6402.html 总结: vector可以理解为可以在两端插入.删除数据的数组,它提供了丰富的成员函数,用于操作数据. begin ...