Python3 列表
2016-06-15 08:33
344 查看
list是一种有序的集合,可以随时添加和删除其中的元素。
获取
当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是
如果要取最后一个元素,除了计算索引位置外,还可以用
以此类推,可以获取倒数第2个、倒数第3个:friends[-1],friends[-2]
list是一个可变的有序表,所以,可以往list中追加元素到末尾:
list里面的元素的数据类型也可以不同,比如:
list元素也可以是另一个list,比如:
要拿到
现在,classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用
不可变的tuple有什么意义?因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。
tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来。
如果要定义一个空的tuple,可以写成
但是,要定义一个只有1个元素的tuple,如果你这么定义:
定义的不是tuple,是
所以,只有1个元素的tuple定义时必须加一个逗号
Python在显示只有1个元素的tuple时,也会加一个逗号
最后来看一个“可变的”tuple:
这个tuple定义的时候有3个元素,分别是
表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向
只要
计算1-10的和
Python提供一个
第二种循环是while循环,只要条件满足,就不断循环,条件不满足时退出循环。比如我们要计算100以内所有奇数之和,可以用while循环实现:
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} >>> d['Michael'] 95
为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。
第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。
dict就是第二种实现方式,给定一个名字,比如
你可以猜到,这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。
把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:
由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉,如果key不存在,dict就会报错:
要避免key不存在的错误,有两种办法,一是通过
二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:
要删除一个key,用
务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较,dict有以下几个特点:
查找和插入的速度极快,不会随着key的增加而增加;
需要占用大量的内存,内存浪费多。
而list相反:
查找和插入的时间随着元素的增加而增加;
占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)
要创建一个set,需要提供一个list作为输入集合:
重复元素在set中自动被过滤:s = set([1, 2, 3, 3]) # s = (1, 2, 3)
通过
通过
set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:
set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。
对于可变对象,比如list,对list进行操作,list内部的内容是会变化的
而对于不可变对象,比如str,对str进行操作呢:
要始终牢记的是,
所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates ['Michael', 'Bob', 'Tracy']
获取
>>> classmates[2] 'Tracy'
当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是
len(classmates) - 1。
如果要取最后一个元素,除了计算索引位置外,还可以用
-1做索引,直接获取最后一个元素:
以此类推,可以获取倒数第2个、倒数第3个:friends[-1],friends[-2]
list是一个可变的有序表,所以,可以往list中追加元素到末尾:
friends.append("zx") friends.insert(0, "yyn") friends.pop() // 删除最后一个元素 friends.pop(1) // 删除索引1对应的元素 friends[0] = "hh" // 直接对索引0赋值
list里面的元素的数据类型也可以不同,比如:
>>> L = ['Apple', 123, True]
list元素也可以是另一个list,比如:
>>> s = ['python', 'java', ['asp', 'php'], 'scheme'] >>> len(s) 4
要拿到
'php'可以写
s[2][1]
tuple
另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改,比如同样是列出同学的名字>>> classmates = ('Michael', 'Bob', 'Tracy')
现在,classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用
classmates[0],
classmates[-1],但不能赋值成另外的元素。
不可变的tuple有什么意义?因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。
tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来。
如果要定义一个空的tuple,可以写成
()
但是,要定义一个只有1个元素的tuple,如果你这么定义:
>>> t = (1) >>> t 1
定义的不是tuple,是
1这个数!这是因为括号
()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是
1。
所以,只有1个元素的tuple定义时必须加一个逗号
,,来消除歧义:
>>> t = (1,) >>> t (1,)
Python在显示只有1个元素的tuple时,也会加一个逗号
,,以免你误解成数学计算意义上的括号。
最后来看一个“可变的”tuple:
>>> t = ('a', 'b', ['A', 'B']) >>> t[2][0] = 'X' >>> t[2][1] = 'Y' >>> t ('a', 'b', ['X', 'Y'])
这个tuple定义的时候有3个元素,分别是
'a',
'b'和一个list
表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向
'a',就不能改成指向
'b',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!
条件判断
if判断条件还可以简写,比如写:
if x: print('True') else: print('False');
只要
x是非零数值、非空字符串、非空list等,就判断为
True
if <条件判断1>: <执行1> elif <条件判断2>: <执行2> elif <条件判断3>: <执行3> else: <执行4>
input()返回的数据类型是
str,Python提供了
int()函数来进行数据转换。
循环
Python的循环有两种,一种是for...in循环,依次把list或tuple中的每个元素迭代出来,看例子:names = ['Michael', 'Bob', 'Tracy'] for name in names: print(name)
计算1-10的和
sum = 0 for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]: sum = sum + x print(sum)
Python提供一个
range()函数,可以生成一个整数序列,再通过
list()函数可以转换为list。比如
range(5)生成的序列是从0开始小于5的整数:
>>> list(range(5)) [0, 1, 2, 3, 4]
sum = 0 for x in range(101): sum = sum + x print(sum)
第二种循环是while循环,只要条件满足,就不断循环,条件不满足时退出循环。比如我们要计算100以内所有奇数之和,可以用while循环实现:
sum = 0 n = 99 while n > 0: sum = sum + n n = n - 2 print(sum)
dict
Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} >>> d['Michael'] 95
为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。
第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。
dict就是第二种实现方式,给定一个名字,比如
'Michael',dict在内部就可以直接计算出
Michael对应的存放成绩的“页码”,也就是
95这个数字存放的内存地址,直接取出来,所以速度非常快。
你可以猜到,这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。
把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:
>>> d['Adam'] = 67 >>> d['Adam'] 67
由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉,如果key不存在,dict就会报错:
要避免key不存在的错误,有两种办法,一是通过
in判断key是否存在:
>>> 'Thomas' in d False
二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:
>>> d.get('Thomas') >>> d.get('Thomas', -1) -1
要删除一个key,用
pop(key)方法,对应的value也会从dict中删除:
务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较,dict有以下几个特点:
查找和插入的速度极快,不会随着key的增加而增加;
需要占用大量的内存,内存浪费多。
而list相反:
查找和插入的时间随着元素的增加而增加;
占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)
set
set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。要创建一个set,需要提供一个list作为输入集合:
>>> s = set([1, 2, 3])
重复元素在set中自动被过滤:s = set([1, 2, 3, 3]) # s = (1, 2, 3)
通过
add(key)方法可以添加元素到set中,可以重复添加,但不会有效果
通过
remove(key)方法可以删除元素
>>> s.remove(4)
set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:
>>> s1 = set([1, 2, 3]) >>> s2 = set([2, 3, 4]) >>> s1 & s2 {2, 3} >>> s1 | s2 {1, 2, 3, 4}
set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。
不可变对象
上面我们讲了,str是不变对象,而list是可变对象。对于可变对象,比如list,对list进行操作,list内部的内容是会变化的
>>> a = ['c', 'b', 'a'] >>> a.sort() >>> a ['a', 'b', 'c']
而对于不可变对象,比如str,对str进行操作呢:
>>> a = 'abc' >>> a.replace('a', 'A') 'Abc' # replace方法创建了一个新字符串'Abc'并返回 >>> a 'abc'
要始终牢记的是,
a是变量,而
'abc'才是字符串对象!有些时候,我们经常说,对象
a的内容是
'abc',但其实是指,
a本身是一个变量,它指向的对象的内容才是
'abc':
所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。
相关文章推荐
- python的2.5与2.7版本中ftp模块的一个小区别
- Python ftplib模块
- python常用技巧
- Python NLP相关工具
- 一个最简单的博客园文章密码暴力破解器-python3实现
- python实现概率分布
- Python \x invalid escape error 和 windows 下的文件路径使用问题
- 安装MYSQL-PYTHON包报错mysql_config not found解决办法
- Python学习笔记(五)
- [leetcode]53. Maximum Subarray 最大连续子串python实现【medium】
- python 读取全国城市aqi数据,差值生成png图片
- python3.5仿微软计算器程序
- 使用python3.5仿微软记事本notepad
- python3音乐播放器简单实现代码
- Numpy 入门教程(2)
- (转载)NumPy详细教程
- python fabric实现远程操作和部署
- python自定义模块导入方法
- Python fabric远程自动部署简介
- NumPy的详细教程