[ 列表]
列表(list)是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。
列表是可变的(mutable)——即:可以改变列表的内容。
相关操作:
1 查([])
names_class2=['张三','李四','王五','赵六']#print(names_class2[2])#print(names_class2[0:3])#print(names_class2[0:7])#print(names_class2[-1])#print(names_class2[2:3])#print(names_class2[0:3:1])#print(names_class2[3:0:-1])#print(names_class2[:])
2 增(append,insert)
insert 方法用于将对象插入到列表中,而append方法则用于在列表末尾追加新的对象
names_class2.append('jesson')
names_class2.insert(2,'pitter')print(names_class2)
3 改(重新赋值)
names_class2=['张三','李四','王五','赵六']
names_class2[3]='赵七'names_class2[0:2]=['jesson','pitter']print(names_class2)
4 删(remove,del,pop)
names_class2.remove('jesson')delnames_class2[0]delnames_class2
names_class2.pop()#注意,pop有返回值
5 其他操作
5.1 count
count 方法统计某个元素在列表中出现的次数:
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')2
>>> x = [[1,2], 1, 1, [2, 1, [1, 2]]]>>> x.count(1)2
>>> x.count([1,2])1
5.2 extend
extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。
>>> a = [1, 2, 3]>>> b = [4, 5, 6]>>>a.extend(b)>>>a
[1, 2, 3, 4, 5, 6]
extend 方法修改了被扩展的列表,而原始的连接操作(+)则不然,它会返回一个全新的列表。
>>> a = [1, 2, 3]>>> b = [4, 5, 6]>>>a.extend(b)>>>a
[1, 2, 3, 4, 5, 6]>>>
>>> a +b
[1, 2, 3, 4, 5, 6, 4, 5, 6]>>>a
[1, 2, 3, 4, 5, 6]
5.3 index
index 方法用于从列表中找出某个值第一个匹配项的索引位置:
names_class2.index('李四')
5.4 reverse
reverse 方法将列表中的元素反向存放。
names_class2.reverse()print(names_class2)
5.5 sort
sort 方法用于在原位置对列表进行排序。
x = [4, 6, 2, 1, 7, 9]
x.sort()#x.sort(reverse=True)
注意:
列表中有个地方需要注意下,即Python在操作列表的时候,None数据类型 和 空‘ ’保存在列表中的时候,都是有效元素。
Python 3.5.2 (v3.5.2:4def2a2901a5,2016, 22:18:55) [MSC v.1900 64bit (AMD64)] on win32
Type"help", "copyright", "credits" or "license" formore information.>>> L =[]>>> L.append('')>>>L
['']>>> len(L) #列表元素个数
1
>>>L.append(None)>>>L
['', None]>>>len(L)2
5.6 列表的切片操作
Python2中可以直接用L=range(0,100)构造一个列表:[0,1,2,3,4,........,98,99]
python3中的构造方法有点区别:L = list(range(0,100))
可以通过切片轻松取出某一段数列。比如前10个数:
>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
后10个数:
>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
前11-20个数:
>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
前10个数,每两个取一个:
>>> L[:10:2]
[0, 2, 4, 6, 8]
所有数,每5个取一个:
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
甚至什么都不写,只写[:]就可以原样复制一个list:
>>>L[:]
[0, 1, 2, 3, ..., 99]
tuple也是一种list,唯一区别是tuple不可变。因此,tuple也可以用切片操作,只是操作的结果仍是tuple:
>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)
字符串'xxx'也可以看成是一种list,每个元素就是一个字符。因此,字符串也可以用切片操作,只是操作结果仍是字符串:
>>> 'ABCDEFG'[:3]'ABC'
>>> 'ABCDEFG'[::2]'ACEG'
[ tuple (元组)]
元组被称为只读列表,即数据可以被查询,但不能被修改,所以,列表的切片操作同样适用于元组。
元组类似与列表,用逗号(,)来分隔存储的数据,与列表不同的是元组是不可变类型(immutable),列表可以任你插入或改变,而元组不行。所以,元组适用于你的数据是固定且不需改变的情形。从内存的角度来看,使用元组有一大好处是,Python可以明确地知道需要分配多少内存给元组(同样 Frozensets 也有这个好处)。
元组写在小括号(())里,元素之间用逗号隔开。
虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
tup1 = () #空元组
tup2 = (20,) #元组中只有一个元素的时候,需要在元素后添加逗号,以消除歧义,避免解释器误解成数学计算意义上的括号。
# 这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,一个元素不加逗号,就产生了歧义。
Python规定,不加逗号情况下,按小括号进行计算,这里计算结果是20;
所以,只有1个元素的元组定义时,元素后边必须加一个逗号,,来消除歧义。
作用:
1对于一些数据我们不想被修改,可以使用元组;2 另外,元组的意义还在于,元组可以在映射(和集合的成员)中当作键使用——而列表则不行;元组作为很多内建函数和方法的返回值存在。
元组相关操作:
1 创建元组
tup1 = ('jesson', 'pitter', 1997, 2000);
tup2= (1, 2, 3, 4, 5);
tup3= "a", "b", "c", "d";print(tup1,type(tup1))print(tup2,type(tup2))print(tup3,type(tup3))#输出结果#('jesson', 'pitter', 1997, 2000) #(1, 2, 3, 4, 5) #('a', 'b', 'c', 'd')
元组与字符串类似,下标索引从0开始,可以进行截取,组合等。
2 访问元组
tup1 = ('jesson', 'pitter', 1997, 2000);
tup2= (1, 2, 3, 4, 5, 6, 7);print ("tup1[0]是:", tup1[0]) #访问元组tup1的第一个元素
print ("tup2[1:5]是:", tup2[1:5]) #对元组tup2中的元素 从索引下标1开始到4 进行切片操作
#输出结果:#tup1[0]是: jesson#tup2[1:5]是: (2, 3, 4, 5)
3 修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:
tup1 = (12, 34.56);
tup2= ('abc', 'xyz');#tup1[0] = 100; # 这种修改元组元素操作是非法的,编译的时候会报错。
tup3 = tup1 + tup2; #可以 创建一个新的元组
print(tup3)#输出结果:#(12, 34.56, 'abc', 'xyz')
4 删除元组
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组。
tup = ('jesson', 'pitter',"你好",1997, 2000);print(tup)del(tup)print("执行del删除操作后的元组 tup:")print(tup)#以上实例元组被删除后,输出变量会有异常信息,输出如下所示:#Traceback (most recent call last):#File "J:/元组 tuple.py", line 51, in #print(tup)#NameError: name 'tup' is not defined
5 元组运算符
与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
6 元组内置函数
Python元组包含了以下内置函数1、cmp(tuple1, tuple2):比较两个元组元素。2、len(tuple):计算元组元素个数。3、max(tuple):返回元组中元素最大值。4、min(tuple):返回元组中元素最小值。5、tuple(seq):将列表转换为元组。
7 元组总结
tuple和list非常类似,但是tuple一旦初始化就不能修改;这样也就有了一个要求,就是:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来。
既然元组是不能修改的,那么它的这种不可变性有什么意义?
因为tuple不可变,所以代码更安全;如果可能,能用tuple(元组)代替list(列表)就尽量用tuple。
[ Dictionary (字典)]
字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
创建字典:
dic1={'name':'jesson','age':26,'sex':'male'}
dic2=dict((('name','jesson'),))print(dic1)print(dic2)
相关操作:
1 增
dic3={}
dic3['name']='jesson'dic3['age']=26
print(dic3)#{'name': 'jesson', 'age': 26}
a=dic3.setdefault('name','pitter')
b=dic3.setdefault('ages',25)print(a,b)print(dic3)
2 查
dic3={'name': 'jesson', 'age': 26}#print(dic3['name'])#print(dic3['names'])#
#print(dic3.get('age',False))#print(dic3.get('ages',False))
print(dic3.items())print(dic3.keys())print(dic3.values())print('name' in dic3)#py2: dic3.has_key('name')
print(list(dic3.values()))
3 改
dic3={'name': 'jesson', 'age': 26}
dic3['name']='pitter'dic4={'sex':'male','hobby':'sports','age':26}
dic3.update(dic4)print(dic3)
4 删
dic4={'name': 'jesson', 'age': 26,'class':1}#dic4.clear()#print(dic4)
del dic4['name']print(dic4)
a=dic4.popitem()print(a,dic4)#print(dic4.pop('age'))#print(dic4)
#del dic4#print(dic4)
5 字典其他操作以及涉及到的方法
5.1 dict.fromkeys
d1=dict.fromkeys(['host1','host2','host3'],'Mac')print(d1)
d1['host1']='jesson'
print(d1)#######
d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])print(d2)
d2['host1'][0]='jesson'
print(d2)
5.2 d.copy() 对字典 d 进行浅复制,返回一个和d有相同键值对的新字典
5.3 sorted(dict) : 返回一个有序的包含字典所有key的列表
dic={5:'555',2:'222',4:'444'}print(sorted(dic))
5.4 d.get() 获取字典 d 中的相关值;
d = {'name':'jesson','age':'18'}print(d['name']) #输出结果:jesson 通过字典的键 获取对应值
print(d.get('name')) #输出结果:jesson 通过get方法获取相应键的值
print(d.get('sex','male')) #输出结果:male # 字典的get()方法操作,如果字典中没有键(sex)#默认返回值是:none 这里可以在键"sex"后 添加默认值,比如:(male)#如果原字典中可以找到该键,就输出相应的值;如果找不到键,就输出添加的默认值。
5.5 字典的遍历
dic5={'name': 'jesson', 'age': 26}#print(dic5.keys())#print(dic5.values())
for i indic5:print(i, dic5[i])#输出结果#age 26#name jesson
for items indic5.items():print(items)#输出结果#('age', 26)#('name', 'jesson')
for keys, values indic5.items():print('key:{},value:{}'.format(keys,values)) #Python两种字符串拼接方式 实现输出功能一样
print('key:%s,value:%s' %(keys, values))#输出结果#age 26#name jesson
5.6 通过字典来存取班级学生信息:
dic={'zhangsan':{'age':23,'sex':'male'},'李四':{'age':33,'sex':'male'},'王五':{'age':27,'sex':'women'}
}
5.7 update合并:
用法待补充
[ Set (集合)]
把不同的元素组成一起形成集合,是python基本的数据类型。
集合元素(set elements):组成集合的成员(不可重复)
li=[1,2,'a','b']
s=set(li)print(s) #{1, 2, 'a', 'b'}
li2=[1,2,1,'a','a']
s=set(li2)print(s) #{1, 2, 'a'}
集合对象是一组无序排列的可哈希的值:集合成员可以做字典的键
li=[[1,2],'a','b']
s=set(li) #TypeError: unhashable type: 'list'
print(s)
集合分类:可变集合、不可变集合
可变集合(set):可添加和删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素
不可变集合(frozenset):与上面恰恰相反
li=[1,'a','b']
s=set(li)
dic={s:'123'} #TypeError: unhashable type: 'set'
集合相关操作:
1、创建集合
由于集合没有自己的语法格式,只能通过集合的工厂方法set()和frozenset()创建
s1 = set('jesson')
s2= frozenset('pitter')print(s1,type(s1)) #{'l', 'v', 'i', 'a', 'n'}
print(s2,type(s2)) #frozenset({'n', 'y', 'a', 'u'})
2、访问集合
由于集合本身是无序的,所以不能为集合创建索引或切片操作,只能循环遍历或使用in、not in来访问或判断集合元素。
s1 = set('jesson')print('a' ins1)print('b' ins1)#s1[1] #TypeError: 'set' object does not support indexing
for i ins1:print(i)
#输出结果:
False
False
s
j
n
o
e
3、更新集合
可使用以下内建方法来更新:
s.add()
s.update()
s.remove()
注意只有可变集合才能更新:
#s1 = frozenset('jesson')#s1.add(0) #输出报错:AttributeError: 'frozenset' object has no attribute 'add'
s2= set('jesson')#s2.add('mm')#print(s2) #输出结果: {'e', 'mm', 'o', 's', 'n', 'j'} # 注意:.add()和.update()的区别,两者都可以更新集合内元素,
但是.add()方法是把()中新值,当作整体去更新;而.update()方法是将()中的新值分开,单个,一个一个的添加更新。
#s2.update('HO') # 添加多个元素#print(s2) #输出结果: {'j', 'o', 'n', 'e', 'H', 'O', 's'}
#s2.remove('e')#print(s2) #输出结果: {'j', 'o', 's', 'n'}
del:删除集合本身
4、集合类型操作符
(1) in ,not in
(2) 集合等价与不等价(==, !=)
(3) 子集、超集
s=set('jessonwang')
s1=set('jesson')print('e' ins)print(s1
(4) 联合(|)
联合(union)操作与集合的or操作其实等价的,联合符号有个等价的方法,union()。
s1=set('jesson')
s2=set('wang')
s3=s1|s2print(s3) #输出结果:{'e', 'o', 'a', 'w', 's', 'g', 'n', 'j'}
print(s1.union(s2)) #输出结果:{'e', 'o', 'a', 'w', 's', 'g', 'n', 'j'}
(5) 交集(&)
与集合and等价,交集符号的等价方法是intersection()
s1 = set('jessonWang')
s2= set('pitterZhao')
s3= s1 &s2print(s3) #输出结果:{'e', 'a', 'o'}
print(s1.intersection(s2)) #输出结果:{'e', 'a', 'o'}
(6) 查补(-)
等价方法是difference()
s1 = set('jesson')
s2= set('wang')
s3= s1 -s2print(s3) #输出结果:{'j', 's', 'o', 'e'}
print(s1.difference(s2)) #输出结果:{'j', 's', 'o', 'e'}
(7) 对称差分(^)
对称差分是集合的XOR(‘异或’),取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()
s1 = set('jesson')
s2= set('wang')
s3= s1 ^s2print(s3) #输出结果: {'s', 'a', 'o', 'w', 'e', 'j', 'g'}
print(s1.symmetric_difference(s2)) #输出结果:{'s', 'a', 'o', 'w', 'e', 'j', 'g'}
应用技巧:
'''最简单的去重方式'''
lis = [1,2,3,4,1,2,3,4]print list(set(lis)) #[1, 2, 3, 4]
补充:http://www.jb51.net/article/84869.htm
Json 序列化数据
Json数据类型 虽然不是Python的基本数据类型,但是,在日常开发中,涉及到的数据交互类型中,却经常会遇到Json 数据类型,因此这里有必要,针对性的学习一下。
Json 数据类型格式:
小技巧:学习json的时候,格式类比python中的字典!但是,Python中一切皆对象,字典是字典对象,json是json格式的字符串对象;另外,注意,Json格式的数据中,没有单引号!!!一般都是双引号!!!
Json相关的操作中,常用的有四个参数,分别是:json.dumps和json.loads json.dump和json.load,它们是成对出现的。
json.dumps 是将一个Python数据类型列表进行json格式的编码解析,
示例如下:
>>> import json #导入python 中的json模块
>>> l = [‘iplaypython’,[1,2,3], {‘name’:’xiaoming’}] #创建一个l列表
>>> encoded_json = json.dumps(l) #将l列表,进行json格式化编码
>>> print repr(l) #输出结果: ['iplaypython', [1, 2, 3], {'name': 'xiaoming'}]
>>> print encoded_json #输出结果 ["iplaypython", [1, 2, 3], {"name": "xiaoming"}]
这样我们就将一个list列表对象,进行了json格式的编码转换。
解码python json格式,可以用这个模块的json.loads()函数的解析方法,
示例如下:
>>> decode_json =json.loads(encoded_json)>>> print type(decode_json) #查看一下解码后的对象类型
>>> print decode_json #输出结果 ['iplaypython', [1, 2, 3], {'name': 'xiaoming'}]
将python json格式解码成Python数据风格
json.dump和json.dumps很不同,json.dump主要用来json文件读写,和json.load函数配合使用。
json.dump(x,f),x是对象,f是一个文件对象,这个方法可以将json字符串写入到文本文件中。
importjson
data= [{"a":"aaa","b":"bbb","c":[1,2,3,(4,5,6)]},33,'tantengvip',True]
data2=json.dumps(data)print(data2)
f= open('./tt.txt','a')
json.dump(data2,f)
这样就生成了一个tt.txt文件,保存了json格式的数据。dumps还提供pritty print,格式化的输出。
json.load加载json格式文件 下面是从txt文件中读取了json数据。
f = open('./tt.txt','r')
hehe=json.load(f)print(hehe)
dumps & loads针对内存对象,
即将Python内置数据序列化为字串
如使用json.dumps序列化的对象d_json=json.dumps({'a':1, 'b':2}),在这里d_json是一个字串'{"b": 2, "a": 1}'d=json.loads(d_json) #{ b": 2, "a": 1},使用load重新反序列化为dict
dump & load 针对文件句柄,(即,json.dump()方法,增加了对文件的操作,可以直接将支持序列化的数据,dump成json格式的字符串,并将其保存到指定文件;反之,json.load()方法是将json格式字符串
从指定文件中读取出来,反序列化为原来dump之前的数据格式!) 比如:本地有一个json文件a.json则可以d=json.load(open('a.json')), 而如果是dump操作,就是将内置类型序列化为json对象后写入指定的文件!
Json总结:
json.dumps : dict转成str json.dump 是将python数据---->>序列化为json格式的字符串,并将其保存到指定文件中;
json.loads : str转成dict json.load 是从某个数据文件中读取json格式的数据 ---->>将其反序列化成Python数据