python学习基础篇之数据类型

　　Python 是一种面向对象、解释型计算机程序设计语言，是一款自由，开源软件，遵循GPL协议。

　　Python具有丰富和强大的库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的最终界面），然后对pythoner有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C/C++重写，而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。

　　为什么我要学python？

　　在这个IT迅速发展的时代，作为一个运维不会一门开发语言，是一件很悲剧的事。具备开发能力的运维是大势所趋，同时掌握开发思想，对运维是大有裨益。

　　那么，开启python学习之旅。

 

数据类型：

　　字符串：可由各种字符、数字和符号等共同组成，同时需要使用单引号或者双引号来标识。否则会被python当作变量处理，如 “abc_1”,"ab"。

　　数值：不需要引号等符号标识，如 2。

　　列表：对数据类型进行分组，用逗号隔开，如 ["aa",'list',3]。

　　字典：以关键字为字符串或数值为索引的键与对应的值组成键值队，如 {1:"a",2:"b"}。

　　集合：包含不同元组的无序集合，如 set(['a', 'b', 'e'])。

 

赋值操作

　　"="：用于将变量名与内存中的某对相对绑定：由同一模块创建对象时，如果对象已存在，则直接进行绑定不会创建新的对象，否则会由"="创建引用的对象。如果对变量进行了数学运算，其结果则会一个新建的对象。

　　变量：python中变量不需要特殊符号，来标识其为变量，如var。

python默认变量命令规则：

　　以单一下划线开头的变量名（_x）不会被from module import * 语句导入，前后都有下划线的变量名（_x_）是系统定义的变量名，对python解释器有特殊意义，以两个下划线开头但结尾没有下划线的变量名（__x）是类的本地变量，交互式模式下，变量名“_”用于保存最后表达式的结果

注意：变量名没有类型，对象才会有类型

 

数据常用操作：

　　数值：

>>> abs(-2)  #取绝对值
2
>>> cmp(3,4) #比较大小
-1
>>> max([11,2,3])  #取最大值
11
>>> min([11,2,3])  #取最小值
2
>>> pow(2,3)     #2的3次方
8
>>> round(4.333) #四舍五入
4.0
>>> 11/3  #取整数
3
>>> 11%3  #取余数
2
>>> import math
>>> math.ceil(4.3)   #返回数值整数部分+1
5.0
>>> math.floor(4.6)  #返回数值的整数部分
4.0
>>> math.fabs(-10)   #绝对值
10.0
>>> math.exp(2)      #e的2值幂
7.3890560989306504
>>> math.log(100,10)
2.0
>>> math.log10(100)
2.0
>>> math.modf(4.3)
(0.29999999999999982, 4.0)

　　字符串：

>>> s="python"
>>> s.capitalize()    #首字母大写
'Python'
>>> s.title()    #
'Python'
>>> s.index('t',1,4)  #从2到第5个字符之前，首次出现字符t的索引
2
>>> s.find("t",1,4)   #同上
2
>>> ".".join(s) #以"."为分隔符，分隔字符串 
'p.y.t.h.o.n' 
>>> s.replace('t',".") #把字符t替换成"." 
'py.hon' >>> m=s.replace("t",".") #赋值操作 
>>> m.split(".") #把字符串以"."分片 
['py', 'hon'] 
>>> a=" python " 
>>> a 
' python ' 
>>> a.strip() #去掉字符串左右两边的空白 
'python' 
>>> s.endswith("n") #判断是字符串是否以n结尾 
True
>>> s.islower()   #判断是字符串是否以n结尾
True
>>> s.upper()   
'PYTHON'
>>> s.encode()    #字符编码
'python'
>>> s.decode()    #字符解码
u'python'
>>> min(s)  #取出字符串中最小的字符，asccii值对应值做比较 'h' 
>>> max(s)  #取出最大的值 'y'

　　列表操作：

>>> l=["python1","python2"]
>>> l.append("python3")   #列表添加元素
>>> l
['python1', 'python2', 'python3']
>>> l.extend("python")      #把"python"的每个字符添加到列表
>>> l
['python1', 'python2', 'python3', 'p', 'y', 't', 'h', 'o', 'n']
>>> l.count("python1")      #统计出现"python1"的次数
1
>>> l.index("python3")      #找到"python3"的索引
2
>>> l.insert(1,"position2") #在第2个位置插入"position2"
>>> l
['python1', 'position2', 'python2', 'python3', 'p', 'y', 't', 'h', 'o', 'n']
>>> l.remove("python3")    #移除列表元素"python3"
>>> l
['python1', 'position2', 'python2', 'p', 'y', 't', 'h', 'o', 'n']
>>> l.pop()    #弹出一个列表元素，默认从最后一个弹出
'n'
>>> l.pop(-1)  #支持弹出指定索引元素
'o'
>>> l.reverse()#翻转列表成员顺序
>>> l
['h', 't', 'y', 'p', 'python2', 'position2', 'python1']
>>> l.sort()
>>> l
['h', 'p', 'position2', 'python1', 'python2', 't', 'y']
list.sort(...)
      L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
      cmp(x, y) -> -1, 0, 1  
      #cmp是一个比较函数，x<y返回-1，x=y，返回0，x>y，返回1
      #key是一个只接受有一个参数，切返回一个元素的函数
      #reverse表示是够接受排序，True表示倒序返回

>>> l.clear()   #清空列表内容

　　字典：

>>> d={'a':1,'b':2,'c':3}
>>> d.get('c')  #根据key取值，d[key]取值时，当key不存在时，会抛出异常
3
>>> d.keys()    #取出所有的key值，其结果为一个列表
['a', 'c', 'b']
>>> d.values()  #取出所有的key对应的值
[1, 3, 2]
>>> d.items()   #由键值对组成各种元组，返回由元组为元素的一个列表
[('a', 1), ('c', 3), ('b', 2)]
>>> t=d.iterkeys()  #有key组成的迭代对象，
>>> t.next()
'a'
>>> t.next()
'c'
>>> t.next()
'b'
>>> d.pop('11','err')  #弹出一个'11'为键值的元素，否则返回第2个参数
'err'
>>> d.popitem()   #弹出一个键值对
('a', 1)
>>> d['c']='ccc'  #字典修改key对应的值
>>> d
{'c': 'ccc', 'b': 2}
>>> d['d']=4      #字典增加键值对
>>> d
{'c': 'ccc', 'b': 2, 'd': 4}
>>> d.setdefault('d','none')   #取key为'd'所对应的值
4
>>> d.setdefault('e','none')   #取key为'e'对应的值，如果没有则添加此键值对
'none'
>>> d
{'c': 'ccc', 'b': 2, 'e': 'none', 'd': 4}
>>> key_list=d.keys()    #按key的顺序取出所有值
>>> key_list.sort()
>>> for key in key_list:
...     print(key,d[key])
... 
('b', 2)
('c', 'ccc')
('d', 4)
('e', 'none')
>>> d.clear()   #清空字典元素
>>> d
{}

　　集合：

>>> a1 = [1,2,4,3,4,2,6,1,9]
>>> set_1=set(a1)    #设置集合
>>> set_2=set(a1)    #设置集合
>>> print(set_1,set_2)
(set([1, 2, 3, 4, 6, 9]), set([1, 2, 3, 4, 6, 9]))
>>> set_1.clear()   #清空集合元素 
>>> set_1
set([])
>>> set_1=set_2.copy()   #拷贝集合
>>> set_2
set([1, 2, 3, 4, 6, 9])
>>> set_1.add(0)   #添加元素到集合,若元素存在则不添加
>>> set_1
set([0, 1, 2, 3, 4, 6, 9])  
>>> set_1.difference(set_2)  #差集(set_1中存在而set_2中没有的元素)
set([0])
>>> set_1.difference_update(set_2) #差集，并把结果更新到set_1集合中
>>> set_1
set([0])
>>> set_2.discard(100)   #删除集合中指定元素，如果不存在，不进行任何操作，不会抛出异常
>>> set_2
set([1, 2, 3, 4, 6, 9])
>>> set_2.discard(1)
>>> set_2
set([2, 3, 4, 6, 9]) 
>>> set_2.pop()   #删除一个元素,从左边删除 
2
>>> set_2.remove(3) #删除集合中的一个元素, 删除的元素必须存在于集合中,不存在则报错
>>> set_2
set([4, 6, 9]) 
>>> set_3=set(a1) 
>>> set_3
set([1, 2, 3, 4, 6, 9])
>>> set_3.intersection(set_2)  #set_2和set_3的交集
set([9, 4, 6]) 
>>> set_3.intersection_update(set_2)  #set_2和set_3的交集，并把结果更新到set_3中
>>> set_3
set([9, 4, 6])
>>> set_1.isdisjoint(set_2)  #两个集合的交集为空，返回True  
True
######
>>> set_3
set([1, 2, 3, 4, 6, 9])
>>> set_2
set([ 4, 6, 9])
>>> set_2.issubset(set_3)   #集合set_2是set_3的子集 
True  
>>> set_3.issuperset(set_2) #集合set_3是set_2的超集
True
>>> set_2.symmetric_difference(set_3) #对称差(将两个集合的相同元素删除后的并集）
set([1, 2, 3])  
>>> set_2.symmetric_difference_update(set_3) #对称差，并把结果更新到set_2中
>>> set_2
set([1, 2, 3]) 
>>> set_3
set([1, 2, 3, 4, 6, 9])
>>> set_2.add(10)
>>> set_2
set([1, 2, 3, 10])
>>> set_2.union(set_3)   #并集
set([1, 2, 3, 4, 6, 9, 10])
>>> set_2.update(set_3)  #并集，并把集合更新到set_2中
>>> set_2
set([1, 2, 3, 4, 6, 9, 10])