python3标准数据类型

#python3六种标准数据类型（数字，字符串，列表，元组，集合，字典）

#Number数字（int，float，bool，complex）
a,b,c,d=20,5.5,True,1+2j  # 1+2j还可表示为complex(1,2)
1.查询变量所指对象数据类型的方法有两种：
1.1python3内置的type()函数，使用如下：
print(type(a)),print(type(b)) #或者 type(a),type(b) 
#或者print(type(a),type(b),type(c),type(d))

'''1.2还可以用isinstance()函数来判断其数据类型，使用如下：'''
isinstance(a,int) #结果显示为：True

'''1.3函数type()与isinstance()的区别在于，
type()认为子类不是父类的一种类型，
即，判断父类的一个对象与子类数据类型的逻辑关系为False。
isinstance()则认为子类是父类的一种类型，
即，判断父类的一个对象与子类数据类型的逻辑关系为True。'''

'''1.4对象的删除
1.41 语法一，删除对象引用：'''
#del a[,b[,c[,d]]]#即，del var1[,var2[,var3[...,varN]]]]
''' 1.42 语法二，删除对象：'''
del a,b,c,d #即，del var1[,var2[,var3]]

'''1.5数值计算
1.51加+，减-，乘*，除/或者//，取余%，和乘方**
1.52两除号区别：
数值的除法（/）不管除号两边的数值类型如何，结果总是返回一个浮点数；
若要获取整数需使用（//），但当除号（//）两边有一个或两个浮点数时，结果为浮点数。
1.53需注意：
1.53.1混合计算时，python会把整型转换成浮点数；
1.53.2可以同时为多个变量赋值；
1.53.3一个变量可以通过赋值指向不同类型的对象；
1.53.4复数的实部和虚部均为浮点型；'''


#String字符串
str ='runoob'   
string="run"

'''2.2.5输出语句方式的不同，输出结果不同，如(后面对应输出结果)：'''
str    #输出:'runoob'
string  #输出:'run'
print(str) #输出:runoob
print(string) #输出:run
'''总结，把字符串对象赋值给变量时用单引号或双引号都可以。但统一的是，若只调用变量名显示完整输出，输出结果一律使用单引号；若调用print()函数，则输出完整字符串(此时，没有单引号括起来)'''

#字符串使用单引号或者双引号括起来，同时使用反斜杠（\）转义特殊字符；如'\n'

'''2.1字符串截取的语法格式：'''
str[0:2] #即，变量[头下标:尾下标]

'''2.2注意：
2.2.1反斜杠可以用来转义，使用r可以让反斜杠不发生转义；如：'''
print('ru\noob')
print(r'ru\noob')
''' 2.2.2字符串可以用+运算符连接在一起，用*运算符重复'''
print(str+'TEST')#或者print(str+string)
print(str*2)  #输出结果：两个字符串紧接着输出，中间没有空格或换行
''' 2.2.3字符串有两种索引方式，从左往右索引值以0为开始值，从右往左以-1开始'''
print(str[0:6])
print(str[-6:-1])
print(str[0])
print(str[1:])
''' 2.2.3.0区别于列表：(后面为输出结果)'''
str[0] #输出结果：'r'
str[0:1] #输出结果：'r'
print(str[0]) #输出结果：r

''' 2.2.4与C字符串不同，python字符串不能改变；如：'''
string[0]=h #系统将报错
''' 2.2.5Python3中没有单独的字符类型，一个字符就是长度唯一的字符串'''
''' 2.2.6反斜杠(\)可以作为续行符，表示下一行是上一行的延续；也可以使用''''''...''''''或者'''...'''跨越多行。'''


#List列表
alist=['abcde',798,2.23,'runoob',1+2j]
tinylist=[123,'runoob']
'''3.0列表Listl是写在方括号[]之间，用逗号隔开的元素列表。'''
#其他的表示方式，或者利用指向字符串对象的变量作为列表的一个元素，如：
strs='runoob'
alist=['abcde',798,2.23,strs,1+2j]
tinylist=[123,strs]

'''3.1列表List介绍：'''
''' 3.1.1列表是python3中使用最为频繁的数据类型；
它可以完成大多数集合类的数据结构实现'''
''' 3.1.2列表中元素的类型可以不相同，
它支持数字Number，字符串String，甚至列表List本身(即，嵌套)；
实例如下(带“>>>”为执行语句，下面为输出结果)：'''
>>> strs='runoob'
>>> tinylist=[123,strs]
>>> alist=['abcde',798,2.23,strs,1+2j,tinylist]
>>> strs
'runoob'    #输出结果
>>> tinylist
[123, 'runoob']   #输出结果
>>> alist
['abcde', 798, 2.23, 'runoob', (1+2j), [123, 'runoob']]    #输出结果
>>> print(alist)
['abcde', 798, 2.23, 'runoob', (1+2j), [123, 'runoob']]  #输出结果
'''总结，调用print()函数输出，或者直接用变量名输出均可，输出结果无区别'''

'''3.2列表可以被截取和索引，(与字符串类似)，
列表截取的语法格式如下，(列表被截取后返回一个包含所需元素的新列表)：'''
alist[0:5] #即，变量[头下标:尾下标]
''' 3.2.1列表可以用+运算符拼接在一起，用*运算符重复'''
print(alist+tinylist)#或者print(alist+[123,'runoob'])
print(tinylist*2)  #输出结果：列表元素重复2遍输出，并合并为一个列表
''' 3.2.2列表也有两种索引方式：从左往右索引值以0为开始值，从右往左以-1开始'''
print(alist[0:6])
print(alist[-6:-1])
print(alist[0])
print(alist[1:])
''' 3.2.2.0区别于字符串：(后面为输出结果)'''
alist[0] #输出结果：'abcde'（索引，仅取值）
alist[0:1] #输出结果：['abcde']（截取，获得新列表）
print(alist[0])#输出结果：abcde
''' 注意区分索引(获得的是列表的元素)和截取(会获得新列表)的输出不同'''
''' 3.2.3与字符串不同，列表中的元素是可以改变的；如：'''
>>> alist
['abcde', 798, 2.23, 'runoob', (1+2j), [123, 'runoob']]
>>> alist[0]=000#改变单个元素
>>> alist[2:5]=[8.9+9.8j,'xywz',[999,'abc']]#改变多个元素
>>> alist #输出改变后的结果
[0, 798, (8.9+9.8j), 'xywz', [999, 'abc'], [123, 'runoob']]
>>> alist[2:5]=[]#删除；或者可以用del语句，即：del alist[2:5]
>>> alist
[0, 798, [123, 'runoob']]
''' 并且，列表元素的个数可以为0,即，可以是空列表；也可以只含有一个元素的列表'''
''' 3.2.4切片在列表List和字符串String之间的异同'''
''' 3.2.5列表List内置了很多方法，如：append()，pop()'''


#Tuple元组
tuple=('abc',0,9+8.8j,str,alist)
tinytuple=(8+9.9j,0.99,tinylist)
atuple=(alist,tinytuple)
'''4.0元组语法格式：写在小括号()里，元素之间用逗号隔开(元组的元素不可更改)'''
'''4.1元组Tuple介绍：'''
''' 4.1.1元组中元素的类型可以不相同，(与列表类似)
支持数字Number，字符串String，列表List，甚至元组Tuple本身(即，嵌套)；
实例如下(带“>>>”为执行语句，下面为输出结果)：'''
str='runoob'
tinylist=[123,str]
tuple=(str,2.23,7+8.8j,tinylist)
tinytuple=(str,100,4+5.6j,tinylist)
atuple=(99.08,'bbs',str,tinylist,tinytuple)
''' 4.1.2输出语句方法(变量名，或者print函数)'''
>>> tuple
('runoob', 2.23, (7+8.8j), [123, 'runoob'])#输出结果
>>> print(tuple)
('runoob', 2.23, (7+8.8j), [123, 'runoob'])#输出结果
>>> atuple
(99.08, 'bbs', 'runoob', [123, 'runoob'], ('runoob', 100, (4+5.6j), [123, 'runoob']))#输出结果
>>> print(atuple)
(99.08, 'bbs', 'runoob', [123, 'runoob'], ('runoob', 100, (4+5.6j), [123, 'runoob']))#输出结果
'''总结，调用print()函数输出，或者直接用变量名输出均可，输出结果无区别'''

'''4.2元组可以被切片和索引，(与字符串类似)，其语法格式如下：'''
atuple[0:6] #即，变量[头下标:尾下标]
''' 4.2.1元组可以用+运算符拼接在一起，用*运算符重复'''
print(tinytuple+atuple)#或者print(atuple+(1.2+3.4j,))
print(tinytuple*2)  #输出结果：元组元素重复2遍输出，并合并为一个元组
''' 4.2.2元组也有两种索引方式：从左往右索引值以0为开始值，从右往左以-1开始'''
atuple[1:3]
atuple[2:]
atuple[-5:]
atuple[-6:-1]
''' 4.2.2.0区别于字符串：(后面为输出结果)'''
tuple[0] #输出结果：'runoob'（索引，仅取值）
tuple[0:1] #输出结果：('runoob',)（新元组）
print(tuple[0])#输出结果：runoob
atuple[0] #输出结果：99.08
atuple[0:1] #输出结果：(99.08,)（新元组）
print(atuple[0])#输出结果：99.08
tinytuple[0] #输出结果：(8+9.9j)
tinytuple[0:1]#输出结果：((8+9.9j),)（新元组）
print(tinytuple[0])#输出结果：(8+9.9j)
atuple[3] #输出结果：[123, 'runoob']
atuple[3:4] #输出结果：([123, 'runoob'],)（新元组）
print(atuple[3])#输出结果：[123, 'runoob']
print(atuple[3:4])#输出结果：([123, 'runoob'],)（新元组）

''' 元组被截取后返回一个包含所需元素的新元组；注意区分截取和索引(仅取值)的输出'''

''' 4.2.3与字符串一样，元组中的元素不可以被改变；如：'''
>>> atuple[2]='dod'
TypeError: 'tuple' object does not support item assignment    #系统报错
#注意：元素不可以被改变，同样也不可以被删除(两种删除语法均不可)
#但是元组可以包含可变的对象，比如list列表；即，可以通过在元组外面改变元组中其他数据类型的元素(如，list列表元素)从而间接改变元组。需注意的是，每改变其中的任意一个可变元素，都要再重新定义一遍原来元组的组成元素(这可能和python是脚本语言有关，只有短暂性的暂时记忆的缺陷)，然后再重新输出该元组即可。

''' 4.2.4构造包含0或1个元素的元组的特殊语法规则
元组元素的个数为0,即，空元组()；也可以是为1。实例如下：'''
tup1=() #输出结果：()
tup2=(1+2.2j,)#输出结果：((1+2.2j),)
tup3=(tup2,) #输出结果：(((1+2.2j),),)
#注意：当元组只包含一个元素时，须在元素后添加逗号。否则将不认为该变量是元组数据类型
''' 反例(当元组只包含一个元素时，元素后没有加逗号)如下：'''
tup4=(8+4.6j)
tup5=('runoob')
tup6=([9.9,'aas',[]])
>>> tup4+202 #输出结果：(210+4.6j)
>>> tup5+'youth'#输出结果：'runoobyouth'
>>> tup6+['bnn',8+7.9j]
#输出结果：[9.9, 'aas', [], 'bnn', (8+7.9j)]
#即，若不加逗号，则不认为是元组的数据类型，而是除去小括号后之内的数据类型。
''' 4.2.5切片在元组Tuple数据类型的应用'''

#总结，string字符串、list列表和tuple元组都属于sequence（序列）。


#Set集合
set={'mary','jake','bbs',9.89,2+4.5j,('ww','hh'),'jake','eason','jason'}
'''5.1.0集合输出语法格式：调用变量名，或者使用输出函数print，输出结果如下：'''
>>> set
{'eason', 'mary', 9.89, 'jason', ('ww', 'hh'), (2+4.5j), 'bbs', 'jake'}
>>> print(set)
{'eason', 'mary', 9.89, 'jason', ('ww', 'hh'), (2+4.5j), 'bbs', 'jake'}
#注意，无论用哪一种输出格式，输出集合时，重复的元素将被自动去掉；且输出时无序排列
'''5.0集合是一个无序不重复的序列。'''

'''5.1创建集合语法格式：
使用大括号{}，或者set()函数来创建(空集合除外)。实例如下：'''
aset={'Jay','hathaway',(2+4.5j),'mary',('ww','hh'),6+8.7j}
>>> aset #执行输出语句
{'Jay', 'mary', ('ww', 'hh'), (2+4.5j), 'hathaway', (6+8.7j)}
#注意，创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。
''' 5.1.1函数set()的使用方法，并注意区分使用方法的异同(重要区分一和二)：'''
#注意，如果已定义了集合(set)数据类型的对象并把它分配给变量名为set的变量，就不能再用set()函数来创建集合(set)数据类型的对象，并把它分配给某个变量。实例如下：
set={'mary','jake','bbs',9.89,2+4.5j,('ww','hh'),'jake','eason','jason'}
bset=set(['Jay','hathaway',(6+8.7j)])
#执行结果如下：
TypeError: 'set' object is not callable #可参考setexample.py文件
''' 5.1.1.0使用方法一：'''
a0 = set('abracadabra')
b0 = set('alacazam')
print(a0) #输出结果：{'r', 'a', 'b', 'c', 'd'}
'''set函数的括号内未带大括号或者中括号，则定义的是多个字符串长度均为一的字符串对象的集合的对象'''
''' 5.1.1.1使用方法二：'''
a1 = set(['abracadabra'])
b1 = set({'alacazam'})
print(a1) #输出结果：{'abracadabra'}
'''set函数的括号内使用了大括号或者中括号，则定义的是集合中元素个数为一的字符串集合的对象'''
''' 5.1.1.2使用方法三：'''
a2=set(['Jay','hathaway',(6+8.7j)])
b2=set({'Jay','hathaway',(6+8.7j),293})
print(a2) #输出结果：{'Jay', 'hathaway', (6+8.7j)}
#5.1.1的实例可参考setexample1.py文件

'''5.2集合中元素的类型可以不相同，(与元组不同)
但所含元素必须为：不可再分数据类型元素(即，unhashable type)；这类数据包括有：数字，字符串，元组；不包括：列表，集合，字典。
实例如下(带“>>>”为执行语句，下面为输出结果)：'''
aset={9.9+9.8j,'Jay',('bjwb',767,1+2.8j)
''' 5.2.1输出语句方法(变量名，或者print函数)'''
>>> aset
{('bjwb', 767, (1+2.8j)), 'Jay', (9.9+9.8j)}#输出结果
>>> print(aset)
{('bjwb', 767, (1+2.8j)), 'Jay', (9.9+9.8j)}#输出结果
'''总结，调用print()函数输出，或者直接用变量名输出均可，输出结果无区别'''

'''5.3和前面的字符串，列表，元组不同；
集合的基本功能(即，运算)是：进行成员关系测试和删除重复元素。实例如下：'''
>>> print(set-aset) #set和aset的差集
{9.89, 'eason', 'jason', 'jake', 'bbs'} #结果
>>> print(aset-set) #aset和set的差集
{'Jay', 'hathaway', (6+8.7j)} #结果
>>> print(aset|set) #set和aset的并集
{'Jay', 'eason', 'mary', 9.89, 'jason', ('ww', 'hh'), (2+4.5j), 'bbs', 'hathaway', 'jake', (6+8.7j)}#结果
>>> print(aset&set) #set和aset的交集
{'mary', ('ww', 'hh'), (2+4.5j)} #结果
>>> print(aset^set) #set和aset中不同时存在的元素
{'Jay', 'eason', 9.89, 'jason', 'bbs', 'hathaway', 'jake', (6+8.7j)}#结果


#Dictionary字典
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
'''6.0字典是python中另一个非常有用的内置数据类型；它是一种映射类型，用“{}”标识；它是一个无序的键(key):值(value)对集合，且键(key)必须使用不可变类型。'''
#在同一个字典中，键(key)必须是唯一的。

'''6.1创建字典的语法格式：
使用大括号{}，或者dict()函数来创建。实例如下：'''
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
>>> tinydict #执行输出语句;或者print(tinydict)
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
#注意，创建一个空字典可以用dict()也可以用{}。
''' 6.1.1函数dict()的使用方法，并注意区分使用方法的异同(重要区分一和二)：'''
#注意，如果已定义了字典(dictionary)数据类型的对象并把它分配给变量名为dict的变量，就不能再使用dict()函数来创建字典(dictionary)数据类型的对象，并把它分配给某个变量。实例如下：
dict = {}
dict['one']="1-菜鸟教程"
dict['two']="2-菜鸟工具"
dict["3"]='3-菜鸟学院'
dict[4]='4-菜鸟学员'
>>> dict #执行第一步
>>> dict({('runoob',1),('google',2),('taobao',3)}) #调用dict()函数
>>> g=dict()
#执行结果如下(仅能执行第一步)：
{'3': '3-菜鸟学院', 'one': '1-菜鸟教程', 'two': '2-菜鸟工具', 4: '4-菜鸟学员'}
TypeError: 'dict' object is not callable
''' 6.1.10使用方法一：'''
dict = {}
dict['one']="1-菜鸟教程"
dict['two']="2-菜鸟工具"
print(dict) #输出结果：{'one': '1-菜鸟教程', 'two': '2-菜鸟工具'}
''' 6.1.11使用方法二：'''
#使用中括号：
dict([('runoob',1),('google',2),('taobao',3)])
#或者使用大括号：
dict({('runoob',1),('google',2),('amazon',3)})
#或者大中括号均不使用，而是以赋值方式(即，“等式”)作为函数参数来创建对象：
dict(runoob=1,google=2,taobao=3)
#输出结果：{'google': 2, 'runoob': 1, 'taobao': 3}
''' 6.1.12使用方法三：'''
{x:x**2 for x in (2,4,6)}
#即元素不以键值对的方式写入到dict函数的参数中，直接用大括号来创建：
#输出结果：{2: 4, 4: 16, 6: 36}
#6.1.1的实例可参考dictexample.py文件


#总结，列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

#总结，不可再分数据类型元素(即，unhashable type)包括：数字，字符串，元组；不包括：列表，集合，字典。


#python3数据类型转换

#有时候需要对数据内置的类型进行转换，即数据类型的转换，将数据类型作为函数名即可。
'''以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。'''

int(x [,base]) #将x转换为一个整数
long(x [,base] ) #将x转换为一个长整数
float(x) #将x转换到一个浮点数
complex(real [,imag]) #创建一个复数
str(x) #将对象 x 转换为字符串
repr(x) #将对象 x 转换为表达式字符串
eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) #将序列 s 转换为一个元组
list(s) #将序列 s 转换为一个列表
set(s) #转换为可变集合
dict(d) #创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) #转换为不可变集合
chr(x) #将一个整数转换为一个字符
unichr(x) #将一个整数转换为Unicode字符
ord(x) #将一个字符转换为它的整数值
hex(x) #将一个整数转换为一个十六进制字符串
oct(x) #将一个整数转换为一个八进制字符串

#本单元扩展：

关于集合set两个内置函数set()和frozenset()的区别，以及关于集合其他内置函数的相关介绍，可参考链接：

http://www.cnblogs.com/panwenbin-logs/p/5519617.html#top