[ 列表]

列表（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')del names_class2[0]del names_class2names_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 64 bit (AMD64)] on win32Type "help", "copyright", "credits" or "license" for more 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']=26print(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 in dic5:    print(i, dic5[i])#输出结果# age 26# name jessonfor items in dic5.items():    print(items)# 输出结果# ('age', 26)# ('name', 'jesson')for keys, values in dic5.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' in s1)print('b' in s1)# s1[1]  #TypeError: 'set' object does not support indexingfor i in s1:    print(i) #输出结果：FalseFalsesjnoe

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' in s)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字符串写入到文本文件中。

import jsondata = [{
   "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重新反序列化为dictdump & 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数据