opython3l_Python学习笔记：02数据类型

Python 数据类型

python中标准的数据类型有

基础类型

整型(长整型)

浮点型

复数型

布尔型

序列类型

字符串

列表

元组

字典

整型

整型和长整型并不严格区分,整型int的表达范围和计算范围从(－231到231-1)或者(-263到263-1)。长整形的表达范围同C或者Java不一样，可以非常大，同内存有关

整型(int)

type(3)

int

长整型(long)

type(3L)

long

type(100000000000000000000000)

long

十六进制

0x1F

31

八进制

010

8

布尔型

布尔型，可以认为是整型的子类，只有连个取值True和False，分别使用整型中的1和0存储

True

True

type(True)

bool

int(True)

1

浮点型

浮点型，相当于数学中的实数型，同时也支持科学计数法。计算机中的浮点型存在精度问题

type(3.14)

float

3.1e3

3100.0

复数型

复数型，支持数学中的虚数

3j

3j

1j*1j

(-1+0j)

序列类型(sequence)

序列中的每一个元素都被分配了一个索引：0,1,2,...

序列类型分为字符型，列表，元组，(还有不太常见的buffer，xrange，unicode字符串)

序列类型的通用标准类型运算符分为:

值比较: ,>=,!=,<>,==

对象身份比较:is,is not

布尔运算:not,and,or

序列类型的通用序列类型运算符分为：

获取: ＝

重复: *

连接: +

判断: in

切片: [:]

长度: len()

最大最小值: max(),min()

序列类型的工厂转换函数：

list()

str()

unicode()

basestring()

tuple()

序列类型的可用内建函数：

enumerate()

len()

max()

min()

reversed()

sorted()

sum()

zip()

标准类型运算符：

序列类型的通用标准类型运算符分为:

值比较: ,>=,!=,<>,==

对象身份比较:is,is not

布尔运算:not,and,or

'apple' < 'banna'

True

al=[1,2,3]

bl=al

al is not bl

False

序列是对象引用赋值

al=[1,2,3]

al.append(4)

bl=al

bl

[1, 2, 3, 4]

字符串的每一次赋值，都是对象引用的改变

astr='hello'

bstr=astr

astr='world'

print bstr

hello

序列类型运算符

序列类型的通用序列类型运算符分为：

获取: ＝

重复: *

连接: +

判断: in

切片: [:]

长度: len()

最大最小值: max(),min()

al=[1,2,3]

al*3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

bl=al+al

bl

[1, 2, 3, 1, 2, 3]

[1,2] in [1,2,3]

False

'ap' in 'apple'

True

bl[1:3]

[2, 3]

len(al)

3

max(al)

3

min(al)

1

工厂转换函数

序列类型的工厂转换函数：

list()

str()

unicode()

basestring()

tuple()

mystr='hello'

mylist=list(mystr)

mylist

['h', 'e', 'l', 'l', 'o']

mytuple=tuple(mystr)

mytuple

('h', 'e', 'l', 'l', 'o')

newstr=str(mystr)

newstr

'hello'

myuni=unicode(mystr)

myuni

u'hello'

type(myuni)

unicode

字符型

字符串采用单引号，双引号和三引号表示；字符串是不可变的序列

mystr='helo'

print mystr

helo

mystr="hello"

print mystr

hello

mystr='''hello'''

print mystr

hello

print mystr[1]

e

print mystr[1:-1]

ell

打印原生态的字符串，在字符串之前加r

s=r'd:\note'

s

'd:\\note'

格式化输出

format_string % (arguments_to_convert)

s='%s puls %s' % (1,1)

s

'1 puls 1'

s='pi is %.2f' % 3.14159

s

'pi is 3.14'

查找函数find

title="Montyh Python's Flying Cirucs"

title.find('Monty')

0

title.find('Python')

7

title.find('Not')

-1

Join字符串拼接函数

seq=[1,2,3]

strseq=[str(c) for c in seq]

strseq

['1', '2', '3']

'+'.join(strseq)

'1+2+3'

其他字符串函数：

lower

replace

split

strip

translate

列表

列表可以说是python中最常用的数据类型，列表本身可变，而且列表中的元素可以是不同类型的。列表作为可变的数据类型，拥有赋值和删除操作外，还具备一些函数方法。列表的特点有：

动态创建列表

简单灵活有用

a=[1,2,3,4,5]

type(a)

列表赋值

a[1]=100

a

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in ()

----> 1 a[1]=100

2 a

NameError: name 'a' is not defined

删除元素

del a[1]

a

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in ()

----> 1 del a[1]

2 a

NameError: name 'a' is not defined

列表方法

append

count

extend

index

insert

pop

remove

reverse

sort

a=[1,2,3,4]

a.append(4)

a

[1, 2, 3, 4, 4]

a.count(4)

2

a.pop()

a

[1, 2, 3, 4]

a.extend([5,6])

a

[1, 2, 3, 4, 5, 6]

a.index(2)

1

a=[1,2,3,4,5]

a.remove(4)

a

[1, 2, 3, 5]

a=[1,2,3,5]

a.insert(3,'four')

a

[1, 2, 3, 'four', 5]

a=[1,2,3,4,5]

a.reverse()

a

[5, 4, 3, 2, 1]

a=[1,5,4,2,3]

a.sort()

a

[1, 2, 3, 4, 5]

x=['apple','box','chair']

x.sort(key=len)

x

['box', 'apple', 'chair']

列表解析

[[expr1,expr2...,exprN] for expr1 in sequence1 for expr2 in sequence2... for exprN in sequenceN if condition]

[x**2 for x in range(10)]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[(x,y) for x in range(3) for y in range(3)]

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

[(x,y) for x in range(3) for y in range(3) if (x+y)%2==0]

[(0, 0), (0, 2), (1, 1), (2, 0), (2, 2)]

元组

元组是不可变的序列，通过逗号分隔就可以创建。一般我们还会加上圆括号()

对于适用于列表的赋值，排序等改变自身内容的方法，无法调用

对于创建副本不改变自身内容的方法，可以调用

元组适用的场景

在映射类型中当作键来使用

作为函数的特殊类型参数

作为很多内建函数的返回值

a=1,2

a

(1, 2)

a=(1,2)

a

(1, 2)

a[0]=3

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

----> 1 a[0]=3

TypeError: 'tuple' object does not support item assignment

sorted((1,3,2))

[1, 2, 3]

a.sort()

---------------------------------------------------------------------------

AttributeError Traceback (most recent call last)

in ()

----> 1 a.sort()

AttributeError: 'tuple' object has no attribute 'sort'

def func(args1, *argst):

print args1

print argst

func(1,2,3,4)

1

(2, 3, 4)

def func():

return 1,2,3

func()

(1, 2, 3)

字典

字典是Python中唯一内建的映射类型

字典的创建：

直接定义，使用花括号{}

dict函数，通过其他映射(比如其他字典)或者(键，值)

prices={'apple':10.8,'banna':5.6}

prices

{'apple': 10.8, 'banna': 5.6}

type(prices)

dict

prices=dict([('apple',10.8),('banna',5.6)])

prices

{'apple': 10.8, 'banna': 5.6}

prices=dict(apple=10.8,banna=5.6)

prices

{'apple': 10.8, 'banna': 5.6}

prices['apple']

10.8

len(prices)

2

'apple' in prices

True

'pear' in prices

False

字典的常用函数

copy

clear

get 比直接通过［］操作符访问更安全，当键不存在时，［］访问会报错，而get会返回一个None

prices={'apple':10.8,'banna':5.6}

price2=prices.copy()

price2

{'apple': 10.8, 'banna': 5.6}

prices.clear()

prices

{}

print prices.get('apple')

None

prices['apple']

---------------------------------------------------------------------------

KeyError Traceback (most recent call last)

in ()

----> 1 prices['apple']

KeyError: 'apple'