Python之路，第六篇：Python入门与基础6
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
#!/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的更多相关文章
- Python之路(第六篇)Python全局变量与局部变量、函数多层嵌套、函数递归
一.局部变量与全局变量 1.在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量.全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序. 全局变量没有任何缩进,在任何位置都可 ...
- 【Python之路】第九篇--Python基础之线程、进程和协程
进程与线程之间的关系 线程是属于进程的,线程运行在进程空间内,同一进程所产生的线程共享同一内存空间,当进程退出时该进程所产生的线程都会被强制退出并清除.线程可与属于同一进程的其它线程共享进程所拥有的全 ...
- Python之路(第五篇) Python基本数据类型集合、格式化、函数
一.变量总结 1.1 变量定义 记录某种状态或者数值,并用某个名称代表这个数值或状态. 1.2 变量在内存中的表现形式 Python 中一切皆为对象,数字是对象,列表是对象,函数也是对象,任何东西都是 ...
- 【Python之路】特别篇--Python面向对象（进阶篇）
上一篇<Python 面向对象(初级篇)>文章介绍了面向对象基本知识: 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个“函数”供使 ...
- Python之路【第九篇】堡垒机基础&数据库操作
复习paramiko模块 Python的paramiko模块,是基于SSH用于连接远程服务器并执行相关操作. SSHClient #!/usr/bin/env python #-*- coding:u ...
- Python之路(第八篇)Python内置函数、zip()、max()、min()
一.python内置函数 abs() 求绝对值 例子 print(abs(-2)) all() 把序列中每一个元素做布尔运算,如果全部都是true,就返回true, 但是如果是空字符串.空列表也返回t ...
- Python之路(第七篇)Python作用域、匿名函数、函数式编程、map函数、filter函数、reduce函数
一.作用域 return 可以返回任意值例子 def test1(): print("test1") def test(): print("test") ret ...
- 【Python之路】特别篇--Python切片
字符串切片操作 切片操作符是序列名后跟一个方括号,方括号中有一对可选的数字,并用冒号分割. 注意: 数是可选的,而冒号是必须的. consequence[start:end:step] 切片操作符中的 ...
- 【Python之路】特别篇--Python内置函数
abs() 求绝对值 i = abs(-100) print(i) # 100 all() 循环里面的参数 如果每个元素都为真,那么all返回值为真 假: 0 False None "&q ...
- 【Python之路】特别篇--Python文件操作
文件操作 open函数,该函数用于文件处理 操作文件时,一般需要经历如下步骤: (1)打开文件 (2)操作文件 一.打开文件 文件句柄 = open('文件路径', '模式','编码') 打开文件时, ...
随机推荐
- iOS runtime实用篇--和常见崩溃say good-bye！
程序崩溃经历 其实在很早之前就想写这篇文章了,一直拖到现在. 程序崩溃经历1 我们公司做的是股票软件,但集成的是第三方的静态库(我们公司和第三方公司合作,他们提供股票的服务,我们付钱).平时开发测试的 ...
- 自定义putty主题
PuTTY很早之前就没有更新了(0.62),因为都是开源的所以有人branch出来做了增强,如这个PuTTY tray,增加了超链等功能: https://puttytray.goeswhere.co ...
- linux network
Linux 1◆ 提供连接 2◆ connection baidu.com 3◆ vm tools install Reboot
- Win10系列：VC++ Direct3D图形绘制1
通过前面的介绍,相信读者已经了解了如何新建一个用于开发Direct3D应用程序的项目模版,以及这个项目模版中用于绘制立体图形的主要函数.在本小节中,将通过一个具体的示例来介绍如何使用Visual St ...
- learning ddr mode reigster set command cycle time tMRD and tMOD
tMRD: tMOD:
- python3 线程池-threadpool模块与concurrent.futures模块
多种方法实现 python 线程池 一. 既然多线程可以缩短程序运行时间,那么,是不是线程数量越多越好呢? 显然,并不是,每一个线程的从生成到消亡也是需要时间和资源的,太多的线程会占用过多的系统资源( ...
- MySQL 数据库备份策略：全备与增量备份
一.备份策略1.周日全备份,周一至周六增量备份2.全备份目录/u03/backup/innobackup/full_backup3.增量备份目录/u03/backup/innobackup/incre ...
- SpringCloud调用服务示例
SpringCloud調用服務示例. SpringCloud简介: Spring Cloud是一系列框架的有序集合.它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务 ...
- javascript进阶笔记(1)
学习js已经有一段时间了,大大小小还是能够做出一些东西来.不过觉得可惜的是,还是对js本身这门语言不是很熟悉,总有一点雾里看花的感觉,看得见,但是看不清楚.最近发现有一本关于js的叫做<忍者秘籍 ...
- 依赖倒置（DIP）、控制反转(IOC)和依赖注入(DI)
原文: https://blog.csdn.net/briblue/article/details/75093382 写这篇文章的原因是这两天在编写关于 Dagger2 主题的博文时,花了大量的精力来 ...