python3.4入门——核心数据类型

变量、对象和引用

变量的创建：一个变量（即变量名，如a），当代码第一次给它赋值就创建了它。

变量类型：变量没有任何和它关联的类型信息约束。类型的概念存在于对象中，而不是变量名中。变量原本是通用的，只是在一个特点的时间点，简单的引用了一个特定的对象。

变量的使用：当变量出现在表达式中，它就会被当前所引用的对象代替。所有变量使用前都应该明确的赋值。

• 变量是一个系统表的元素，指向拥有对象的连接的空间。
• 对象是分配的一块内存，有足够的空间去表示他们代表的值。
• 引用是自动形成的从变量到对象的指针。

核心类型的分类：

不可变类型（数字、字符串、元祖、不可变集合）：不支持在原处修改，但可以运行表达式创建新的对象并将其结果分配给变量。

可变类型（列表、字典、可变集合）：可通过操作原处修改，而不用创建新的对象。

一、字符串:

一个有序字符的组合，被划分为不可变序列这一类别，意味着字符串包含着字符从左到右的位置顺序，并且他们不可以在原处修改。

‘spam',''spam",'''spam'''......

r'string':表示raw字符串，r（大写或小写）出现在引号前，它将会关闭转义机制。

s1+s2  #合并，重复　　　　s[i]  #索引　　　　s[i:j]    #分片   len（s）#求长度　　s.endswith('sp') #结束测试

s.find('pa') #搜索　　s.rstrip() #移除空格　　s.split(',')  #以逗号为分隔 　　s.replace('pa','xx') #替换

二、列表

列表的创建：list=[]。列表是任意对象的有序集合，列表的每一项的内容也是有序的，可以执行索引、分片、合并等操作。

>>> l=list('spam') 　　#可迭代项目的列表

>>> l
['s', 'p', 'a', 'm']

>>> l=['abc',['def','ghi']] 　　#嵌套的子列表
>>> l
['abc', ['def', 'ghi']]
>>> l[1][1]
'ghi'
>>> len(l)
2

>>> str([1,2])+"34"
'[1, 2]34'
>>> [1,2]+list('34')   # 符号‘+’的合并要求两边都是同等类型的序列
[1, 2, '3', '4']

列表解析 ：通过对列表序列中每一项应用一个表达式来构建一个新的列表的循环。

>>> res=[ c*4 for c in 'spam']
>>> res
['ssss', 'pppp', 'aaaa', 'mmmm']

>>> l=['abc','ABD','aBe']
>>> l.sort() 　　#默认是升序排序
>>> l
['ABD', 'aBe', 'abc']
>>> l.append('ABC') 　　#append函数允许传入单一对象而不是列表,与““+””表示的合并不同，append添加对象不产生新的列表。
>>> l
['ABD', 'aBe', 'abc', 'ABC']

>>> sorted(l,key=str.lower,reverse=True) #内置排序函数sorted（）排序之后返回新的对象
['aBe', 'ABD', 'abc', 'ABC']

>>> l=[1,2]
>>> l.extend([3,4,5]) #extend在末端插入多个元素
>>> l
[1, 2, 3, 4, 5]
>>> l.pop()  #pop()删除末尾的一个元素并取出
5
>>> l
[1, 2, 3, 4]
>>> l.reverse()
>>> l
[4, 3, 2, 1]

>>> l=['spam','eggs','ham']
>>> l.index('eggs') #返回元素的索引位置
1
>>> l.insert(1,'totast') #指定位置插入元素
>>> l
['spam', 'totast', 'eggs', 'ham']

三、字典

列表是有序的对象集合，那么字典是无序的对象的集合。字典的元素是通过键来存取的，而不是通过偏移量存取的。键：值（key,value）

如果说列表是支持位置读取的对象引用数组，那么字典就是支持键读取的无序对象引用表。和列表一样，字典存储的是对象引用。

>>> D={} #空字典
>>> D={'spam':2,'eggs':3}
>>> E={'food':{'ham':2,'egg':3}} #嵌套字典
>>> D['eggs'] #以键进行索引运算
3
>>> E['food']['egg']
3

>>> D.keys()　　#返回键的视图，而不是列表
dict_keys(['spam', 'eggs'])
>>> D.values()　　#返回值的视图，而不是列表
dict_values([2, 3])
>>> D.items() #取键+值。。。。。返回对象是的视图，而不是列表
dict_items([('spam', 2), ('eggs', 3)])

>>> D.get(key,default)  #取key的值，如果没有key，则赋值default，防止取元素出现错误

>>> D={'eggs':3,'ham':1,'spam':2}

>>> D['ham']=['grill','bake','fry'] 　　#原处修改字典
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry'], 'eggs': 3}

>>> D['brunch']='bacon' #每当对新字典进行赋值，就会在字典内生成一个新的元素
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry'], 'brunch': 'bacon', 'eggs': 3}

字典适用于稀疏矩阵数据结构：使用键对值表示数值非零数值的位置和值。

字典解析：zip函数总是能从单个调用中从键和值的列表来构建一个对应的字典。

>>> list(zip(['a','b'],[1,2]))
[('a', 1), ('b', 2)]
>>> D=dict(zip(['a','b'],[1,2]))
>>> D
{'b': 2, 'a': 1}
>>> D={x:x**2 for x in [1,2]}
>>> D
{1: 1, 2: 4}
>>> D=dict.fromkeys(['a','b','c'],0) #fromkeys函数可对相同值的键统一赋值
>>> D
{'b': 0, 'c': 0, 'a': 0}

字典视图：python3.0中 字典的keys，values，items都返回视图对象，而python2.6返回的是列表。

视图对象是可迭代的，即对象每次产生一个结果集，不是在内存中立即产生结果列表。

字典视图保持了字典最初的顺序，可以反映后来的修改，并支持集合操作。打印不显示自己的项。

字典排序：由于keys（）不返回列表，要么手动转化为为列表，要么在键的视图或字典上应用sorted（）函数，sorted函数可接受任何视图。

>>> ks=list(ks)
>>> ks.sort()
>>> for k in ks:print(k,D[k])

a 1
b 2
c 3
>>> D={'a':1,'b':2,'c':3}
>>> ks=D.keys()
>>> for k in sorted(ks):print(k,D[k]) 　　#pyhton的迭代结结构会迫使每次可迭代的对象产生一个结果

a 1
b 2
c 3 

四、元组

元组是任意对象的有序集合，类似于字符串，不支持在列表中任何原处进行修改。

元组与列表的区别在于，元组的不可变性提供了某种完整性，这样不会被某个引用修改。

>>> T=()　　#空元组
>>> (1,2)+(3,4)　　#元组的合并
(1, 2, 3, 4)
>>> T=(1,2,3,4)
>>> T[0],T[1:3]　　#元组的索引，切片
(1, (2, 3))

因为圆括号也可以把表达式括起来，如果圆括号里的单一对象是元组对象而不是简单的表达式，只需要在这个元组对象后面加一个逗号就可以。

>>> x=(40)
>>> x
40
>>> y=(40,)
>>> y
(40,)

列表解析也可用于元组的转换。

>>> T=(1,2,3,4,5)
>>> l=[x+20 for x in T]　　#列表解析总会产生新的列表，但也可遍历任何对象。
>>> l
[21, 22, 23, 24, 25]

>>> l.index(22) 　　#返回元素的索引
1
>>> l.count(22) 　　#统计元素的个数
1

元组的不可变性只适用于元组本身而非其内容，比如内容可以像往常一样修改。

>>> T=(1,[2,3],4)
>>> T[1]='spam'
Traceback (most recent call last):
File "<pyshell#18>", line 1, in <module>
T[1]='spam'
TypeError: 'tuple' object does not support item assignment
>>> T[1][0]='spam'
>>> T
(1, ['spam', 3], 4)

五、文件

1、文件对象是python对电脑上外部文件的主要接口。需要创建一个文件对象，通过内置的open函数以一个字符串形式传递给它一个外部的文件名和一个模式处理的字符串。

>>> f=open('C:/Users/dingjing/Desktop/d.txt','w')　　# ‘w’表示输出生成并打开文件，‘r’(一般为默认情况)表示输入打开文件，‘a’表示在文件末尾追加内容而打开文件。
>>> f.write('hello text file\n')
16
>>> f.write('goodbye text file\n')
18
>>> f.close()
>>> f=open('C:/Users/dingjing/Desktop/d.txt')
>>> f.readline()　　#每次读取一行，包括行结束符，以字符串形式返回一行
'hello text file\n'
>>> f.readlines()　　#一次读取整个文件，每一行为一个字符串，返回形式为包含多个字符串的列表
['goodbye text file\n']

而f.read()函数则是一次把整个文件读进一个字符串

在任何情况下，python的文本文件都采用字符串的形式，读取文件时返回的是字符串形式的文件。

>>> for line in f:
print(line,end=' ')

hello text file
goodbye text file 　　#这种迭代方式比较普遍，对内存也比较好使

文本与二进制文件：由open的第二个参数决定，当模式字符串包含'b'表示二进制文件。

可以用pickle模块存储python原生态对象。

六、集合

1.集合不是序列也不是映射，是唯一的不可变的对象的无序集合。集合支持一般的数学集合操作。

2.集合的创建

>>> x=set('spam')

>>> y={'h','a','m'}

>>> x,y ({'a','p','s','m'},{'a','h','m'})

3.集合作为可迭代的容器，支持len，for等循环，因为其无序的，所以不支持索引和切片。

>>> x=set('spam')
>>> x.add('on')
>>> x
{'on', 'm', 'p', 'a', 's'}
>>> for i in x:
print(i*3)

ononon
mmm
ppp
aaa
sss

4.集合包含不可变的对象类型，所以列表和字典不可嵌入集合中。

5.集合解析：编写在{}中作用于集合而不是列表。

>>> {x**2 for x in [1,2,3,4]}
{16, 1, 9, 4}

七、类型检验

在Python中可以使用type()与isinstance()这两个函数判断对象类型，而isinstance()函数的使用上比type更加方便。

1.isinstance()

# coding=utf-8

a = 10def b():

    pass
 
print isinstance(a,(int,str))
print isinstance(a,(float,str))
print isinstance(b,(str,int))
 
class c:
    pass
obj = c()
 
print isinstance(obj,(c,int))

执行结果：

True
False
False
True 

2、isinstance 和 type的区别

class A:
    pass

class B(A):

   pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

区别就是 对于subclass之类的 type就不行了。