python数据类型介绍_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]: id(name)

Out[4]: 140621392396080

In [6]: name='tom'

In [7]: id(name)

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]: id(l1)

Out[112]: 139910507684560

In [113]: l3="haha"

In [114]: id(l3)

Out[114]: 139910507684560

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

In [116]: id(l2[0])

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]: id(s1)

Out[167]: 139910507684560

In [168]: id(s2)

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是字符,不是数字

数字类型转换:

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]: id(l1)

Out[194]: 139910507832240

In [195]: id(l1[0])

Out[195]: 139910739440504

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

In [197]: print l1

['3', '2']

In [198]: id(l1[0])

Out[198]: 139910738702424

In [199]: id(l1)

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]: id(l1)

Out[219]: 139910507811688

In [220]: id(l2)

Out[220]: 139910507811688

In [221]: id(l3)

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)

in ()

----> 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() 以列表返回字典中的所有值

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值