Python学习笔记：02数据类型

Python 数据类型

python中标准的数据类型有

基础类型

• 整型（长整型）
• 浮点型
• 复数型
• 布尔型

序列类型

• 字符串
• 列表
• 元组
• 字典

整型

整型和长整型并不严格区分,整型int的表达范围和计算范围从（－2^31到231-1）或者（-2^63到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)

<ipython-input-44-26034086c917> in <module>()
----> 1 a[1]=100
      2 a

NameError: name 'a' is not defined

删除元素

del a[1]
a

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

NameError                                 Traceback (most recent call last)

<ipython-input-45-b2bf79fc00ca> in <module>()
----> 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)

<ipython-input-61-efe65c35efbe> in <module>()
----> 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)

<ipython-input-63-e7eb8b51a6fa> in <module>()
----> 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)

<ipython-input-77-57cb67973001> in <module>()
----> 1 prices['apple']

KeyError: 'apple'