python的数据类型简介

　　ipython:原生python不具有命令行补全等功能，这个工具提供了类似shell的功能，方便学习使用
　　安装：
　　wget  https://repo.continuum.io/archive/Anaconda2-5.1.0-Linux-x86_64.sh  #利用这个工具来管理python版本
　　sh Anaconda2-5.1.0-Linux-x86_64.sh
　　conda search  python
　　conda create -n py27 python=2.7 Anaconda  #创建2.7的环境
　　1."一切皆对象“
　　

例子1：　　

　　
In [3]: name='jerry'
　　


　　
In [4]:>　　
Out[4]: 140621392396080
　　

　　
In [6]: name='tom'
　　


　　
In [7]:>　　
Out[7]: 140621403686472
　　

　　
name='jerry'，为了方便理解可以看成name的值是'jerry'，但是当我们对name重新赋值的时候，并不是改变jerry这个值，而是新建一个值'tom'，再把name重新指向到tom，所以两次name的id不一样，'jerry'和'tom'这种值在python中不叫值，而是被认为是一个对象
　　

　　
python的核心概念就是'一切皆对象'，根据值的可变与否可以分为可变和不可变对象，我个人是这么理解的：
　　"可变对象都是对不可变对象的引用集合，改变可变对象的值的时候，对象/值本身不改变，而是引用改变了"
　　

　　
例子2：
　　

　　
In [107]: l1="hehe"
　　

　　
In [108]: l2=[l1,"66"]
　　

　　
In [109]: print l2
　　
['hehe', '66']
　　

　　
In [110]: l1="haha"
　　

　　
In [111]: print l2
　　
['hehe', '66']
　　


　　
In [112]:>　　
Out[112]: 139910507684560
　　

　　
In [113]: l3="haha"
　　


　　
In [114]:>　　
Out[114]: 139910507684560
　　

　　
In [115]: l2=["haha","xxx"]
　　


　　
In [116]:>　　
Out[116]: 139910507684560
　　

　　
从这个例子可以看出：
　　l2[0]引用的是l1的数据对象部分，当对l1重新赋值的时候，并不影响l2的值
　　l1、l3和l2[0],引用的都是同一数据对象，所以id都相同
　　
从上面就不难理解：'python的变量没有类型，数据才有类型'这句话，因为变量只是个引用，类似于c语言中的指针
　　

　　2.python类的属性和方法
　　参考：http://python.jobbole.com/82297/ （写的很详细，推荐看一看）
　　

类：python的类也是一种对象，它类似于一种框架，当我们需要用到它的时候就对它进行实例化，比如：　　name='jerry'，name可以看做字符类型str()的一个实例
　　
属性：数据，可以用" 类的实例.属性名 "引用
　　
方法：操作，可以用" 类的实例.方法名()"引用
　　

　　
属性与方法的区别在于，属性引用的是数据，而方法引用的是一段代码，属性是在类实例化过程中进行赋值的，而方法则类定义时就已经写好，所以，当某个变量属于某个类时，它能使用的方法/操作也就确定了
　　

　　例子：
　　

In [132]: val=1　　

　　
In [133]: val.__doc__
　　
Out[133]: "int(x=0) -> int or long\nint(x, base=10) -> int or long\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given.  If x is floating point, the conversion truncates towards zero.\nIf x is outside the integer range, the function returns a long instead.\n\nIf x is not a number or if base is given, then x must be a string or\nUnicode object representing an integer literal in the given base.  The\nliteral can be preceded by '+' or '-' and be surrounded by whitespace.\nThe base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to\ninterpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4"
　　

　　
In [134]: val.bit_length()
　　
Out[134]: 1
　　

　　
In [135]: type(val)
　　
Out[135]: int
　　

　　
这个例子中__doc__就是int类的内置属性，bit_length()则是int类的内置方法，val则是int类的实例
　　

　　相关内置函数：
　　type(object)：显示对象的类型
　　dir([object]):显示对象内置的属性，和支持的方法（或者操作）
　　help(builtin.object):打印对应函数的帮助，比如要查找bit_length()的使用帮助，则输入"help(val.bit_length)"或者 "help(int.bit_length)"，因为val是int类的实例，所以是一样的代码，帮助文档也一样
　　3.数据类型
　　字符串：
　　python中字符串比较特别的地方在于它是一种序列而且又是不可变对象
　　例子:
　　

In [165]: s1='haha'　　

　　
In [166]: s2=str('haha')
　　


　　
In [167]:>　　
Out[167]: 139910507684560
　　


　　
In [168]:>　　
Out[168]: 139910507684560
　　

　　
In [169]: s1+s2
　　
Out[169]: 'hahahaha'
　　

　　
不难看出，s1='haha'和s2=str('haha')效果是一样的，str()其实就是字符类型的实例化函数，也是所谓的工厂函数，这里两种写法之所以等价，是因为python规定了一系列规则，使得解释器可以识别，这里相关的规则如下：
　　<1>数字不能作为变量名开头
　　<2>字符串赋值必须用''、""、''' ''' 或者""" """括起来，(三个引号的可以换行)
　　
这些特殊使得解释器遇到没引号的字符是认为它是变量，而带引号则认为是字符。
　　
还有一点是当字符串出现在函数方法定义的第一行的时候，则表示对函数的_doc_属性赋值(这个属性相当于函数的简介)，例子如下：
　　

　　In [175]: def Testchar():
　　...:     "it just a test"
　　...:
　　

　　In [176]: Testchar.__doc__
　　Out[176]: 'it just a test'
　　

　　布尔类型：
　　布尔类型跟其他语言一样，就两个值：True和False (首字母大写)
　　例子：
　　

In [187]: '2xxx' in s　　
Out[187]: True
　　

　　
In [188]: a = 1 in s
　　

　　
In [189]: print a
　　
False
　　

　　
In [190]: a = '1' in s
　　

　　
In [191]: print a
　　
True
　　

　　
因为"一切皆对象"，变量只是对对象的引用，所以布尔类型也是赋值给变量，这里第一次a为False的原因在于，s里面的1是字符，不是数字
　　

　　整数、浮点数，数字：
　　这些没什么好说的，参考：http://www.cnblogs.com/linjiqin/p/3608541.html
　　这里copy对应的可能有用的函数
　　

数字类型转换：　　int(x [,base]) 将x转换为一个整数
　　float(x ) 将x转换到一个浮点数
　　complex(real [,imag]) 创建一个复数
　　str(x) 将对象x转换为字符串
　　repr(x) 将对象x转换为表达式字符串
　　eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
　　tuple(s) 将序列s转换为一个元组
　　list(s) 将序列s转换为一个列表
　　chr(x) 将一个整数转换为一个字符
　　unichr(x) 将一个整数转换为Unicode字符
　　ord(x) 将一个字符转换为它的整数值
　　hex(x) 将一个整数转换为一个十六进制字符串
　　oct(x) 将一个整数转换为一个八进制字符串
　　

　　
数学函数：
　　abs(x)    返回数字的绝对值，如abs(-10) 返回 10
　　ceil(x)    返回数字的上入整数，如math.ceil(4.1) 返回 5
　　cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
　　exp(x)    返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
　　fabs(x)    返回数字的绝对值，如math.fabs(-10) 返回10.0
　　floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
　　log(x)    如math.log(math.e)返回1.0,math.log(100,10)返回2.0
　　log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
　　max(x1, x2,...)    返回给定参数的最大值，参数可以为序列。
　　min(x1, x2,...)    返回给定参数的最小值，参数可以为序列。
　　modf(x)    返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
　　pow(x, y) x**y 运算后的值。
　　round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
　　sqrt(x)    返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
　　

　　列表：
　　列表的特点在于它的元素是可变的，而且因为它是序列，所以支持序列的所有方法
　　元素：这里的元素其实也是对象，但是它可以是任意类型的(所谓的异构），简单地说就是不一定要整数或者字符串比如：
　　[[1,'b'],'b','c']
　　列表里面还有列表，列表是用[]括起来的一堆元素的集合
　　例子1：
　　

In [193]: l1=['1','2']　　


　　
In [194]:>　　
Out[194]: 139910507832240
　　


　　
In [195]:>　　
Out[195]: 139910739440504
　　

　　
In [196]: l1[0]="3"
　　

　　
In [197]: print l1
　　
['3', '2']
　　


　　
In [198]:>　　
Out[198]: 139910738702424
　　


　　
In [199]:>　　
Out[199]: 139910507832240
　　

　　
可以看出，在第一个元素发生变化的时候，l1引用的位置也是不变的，而l1[0]引用的位置则发生了变化
　　

　　例子2：
　　

In [212]: l1=['1','2']　　

　　
In [213]: l2=l1
　　

　　
In [214]: import copy
　　

　　
In [215]: l3=copy.deepcopy(l1)
　　

　　
In [216]: print l2,l3
　　
['1', '2'] ['1', '2']
　　

　　
In [217]: l1[0]=3
　　

　　
In [218]: print l2,l3
　　
[3, '2'] ['1', '2']
　　


　　
In [219]:>　　
Out[219]: 139910507811688
　　


　　
In [220]:>　　
Out[220]: 139910507811688
　　


　　
In [221]:>　　
Out[221]: 139910509285672
　　

　　
从例子可以看出l2=l1，其实是把l2指向到了l1的数据部分，也就是说l1和l2指向了相同的数据部分，而l3则是原样复制l1的数据，所以，当l1[0]变化时，l2[0]也会变化，l3则不变
　　

　　相关内置函数：
　　list.append(obj) 在列表末尾添加新的对象
　　list.count(obj) 统计某个元素在列表中出现的次数
　　list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
　　list.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始
　　list.insert(index, obj) 将对象插入列表
　　list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
　　list.remove(obj) 移除列表中某个值的第一个匹配项
　　list.reverse() 反向列表中元素，倒转
　　list.sort([func]) 对原列表进行排序
　　元组：
　　元组与列表相似(都是不同元素的集合)，但是它的元素是不可以改变的，也支持序列的所有操作，它是用()括起来的
　　例子1：
　　

In [226]: a=([1,'b'],'b','c')　　

　　
In [227]: a[2]='2'
　　
---------------------------------------------------------------------------
　　
TypeError                                 Traceback (most recent call last)
　　
<ipython-input-227-03bdd44bccdf> in <module>()
　　
----> 1 a[2]='2'
　　

　　
TypeError: 'tuple' object does not support item assignment
　　

　　例子2：
　　

In [228]: a=(1)　　

　　
In [229]: type(a)
　　
Out[229]: int
　　

　　
In [230]: a=(1,)
　　

　　
In [231]: type(a)
　　
Out[231]: tuple
　　

　　
当元组里面只有一个元素且是数字时，要加一个逗号，否则会被赋值为整型
　　

　　元组内置的函数：
　　cmp(tuple1, tuple2) 比较两个元组元素。
　　len(tuple) 计算元组元素个数。
　　max(tuple) 返回元组中元素最大值。
　　min(tuple) 返回元组中元素最小值。
　　tuple(seq) 将列表转换为元组。
　　字典：(抄自：http://www.cnblogs.com/linjiqin/p/3608541.html)
　　字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
　　

字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：　　

　　
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};
　　
也可如此创建字典：
　　

　　dict1 = { 'abc': 456 };
　　dict2 = { 'abc': 123, 98.6: 37 };
　　
每个键与值必须用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
　　

　　字典内置的函数：
　　cmp(dict1, dict2) 比较两个字典元素。
　　len(dict) 计算字典元素个数，即键的总数。
　　str(dict) 输出字典可打印的字符串表示。
　　type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
　　radiansdict.clear() 删除字典内所有元素
　　radiansdict.copy() 返回一个字典的浅复制
　　radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
　　radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
　　radiansdict.has_key(key) 如果键在字典dict里返回true，否则返回false
　　radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
　　radiansdict.keys() 以列表返回一个字典所有的键
　　radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
　　radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
　　radiansdict.values() 以列表返回字典中的所有值