python(vs. erlang)学习笔记之四 —— 数据类型 & 数据结构之一

erlang中的任何类型的数据都叫一个term。
1、number(byte/short/int/long/float/double)
erlang中只有两种数值类型，integer和float，integer长度都不受限制，而float的精度最长是15位；python有四种数值类型，plain integers(也叫integers),long integers,floating point numbers,imaginary numbers
   1.1、erlang:
   1.1.1、integer，可以直接用数值表示，也可以用$char和base#value表示;$char表示字符char的ASCII值，base#value表示value是base进制，其中2 =< base <= 36

	1> X = 3.
	3
	2> Y = $A.
	65
	3> Z = $&.
	38
	8> 2#1.
	1
	9> 4#13.
	7
	10> 8#17.
	15
	11> 36#ZDBCABDESSDFFFDDFAWTGHYHRT2343553.
	2240337205207617077098035105820684337245238765751495
	12> 36#Z.
	35
	13> 32457892340972398573249087523458239086723945.
	32457892340972398573249087523458239086723945

   1.1.2、float，可以直接用XX.XX表示或者用X.XXeYYY

	27> 532534563.34564356547567098350968473906.
	532534563.3456436
	28> 527893456345.324098798720349 * 40892435098234905932485.
	2.158684890238407e34
	40> 3.83e5.
	3.83e5
	41> 3.83342e5.
	383342.0

   1.2、python:
   1.2.1、plain integers 从-2147483648到2147483647，有符号位32位长

	>>> a = 423452
	>>> a
	423452
	>>> a = -43252
	>>> a
	-43252

   1.2.2、long integers 任意长度，最大和最小值由可用内存定，数字后边一般加L或l(小写L)

	>>> a = 42350892374598237593287592384#//我这里没有加L，python会自动加上
	>>> a
	42350892374598237593287592384L
	>>> a = -345235L
	>>> a
	-345235L

   1.2.3、floating point numbers 支持十进制和浮点型小数，浮点值按照双精度处理

	>>> f = 4.2345235
	>>> f
	4.2345235
	>>> f = 3.23452345e1222
	>>> f
	inf #//无限了？
	>>> f = 3.23452345e100
	>>> f
	3.23452345e+100

   1.2.4、imaginary numbers虚数 实虚部分由+号分开，虚数部分后边加j

	>>> n = 3 + 4j
	>>> n
	(3+4j)
	>>> m = 4 + 5j
	>>> m
	(4+5j)
	>>> m + n
	(7+9j)
	>>> m * n
	(-8+31j)

   1.2.5、参考资料
2、boolean
erlang中没有boolean数据类型，用true和false这两个atom表示boolean值；python中有单独的boolean数据类型，True和False表示，0、''、[]、{},()、None在boolean环境都为false，其他任何东西都为真
   2.1、erlang:

	1> 2 =:= 3.
	false
	2> a =:= a.
	true
	34> true or false.%//虽然官方文档上说没有这种数据类型但是这里却看起来像是有一样
	true
	37> a or b.
	** exception error: bad argument
		 in operator  or/2
			called as a or b

   2.2、python:

	>>> 2 == 2
	True
	>>> 2 == 3
	False
	>>> type(True)
	<type 'bool'>
	>>> [] or 3
	3
	>>> '' or 3
	3
	>>> () or 3
	3
	>>> {} or 3
	3
	>>> None or 3
	3
	>>> 0 or 3
	3

3、char
python和erlang都没有char类型
4、void
python和erlang都没有void类型
5、string
在erlang中，并无string这种数据类型，其本质上是一个list；而python中有，为str类型
   5.1、erlang:
   5.1.1、声明，输出。erlang的字符串只能放在双引号内，放在单引号内表示是atom

	1> X='xx'.
	xx
	2> is_atom(X).
	true
	3> Y="yy".
	"yy"
	4> is_list(Y).
	true
	5> Z = "zz".
	"zz"

   5.1.2、字符串用++相连

	6>  Y ++ Z.
	"yyzz"
	12> io:format("Y:~s\tZ:~p\n",[Y,Z]).
	Y:yy    Z:"zz"

   5.1.3、string模块，erlang有单独的string模块来操纵string

	20> A="abcdef".
	"abcdef"
	21> string:sub_string(A,1,2).
	"ab"
	22> string:len(A).
	6

   5.1.4、string的本质是一个list；如果list内的数字表示的是可打印字符，则list会打印成string，否则还是list；"AB"代表[$A,$B],也为[65,66]

   3> Y="yy".
	"yy"
	4> is_list(Y).
	true
	25> [65,66,67].
	"ABC"
	26> [65,66,267].
	[65,66,267]

   5.1.5、编译时，两个相邻的string会被连接在一起，两个list就会报错了

	28> "contact" "me".
	"contactme"
	29> [65,66] [67].
	* 1: syntax error before: '['

   5.2、python:
   5.2.1、声明，输出。python的字符串可以放在单引号或者双引号内

	>>> k="key"
	>>> k
	'key'
	>>> v = 'value'
	>>> v
	'value'
	>>> '%s=%s' %(k,v)
	'key=value'
	>>> len(k)
	3

   5.2.2、字符串用++相连

	>>> k+v
	'keyvalue'

   5.2.3、string对象，因为python是面向对象的，所以它不像erlang提供单独的模块，而是像java一样，每个字符串就是一个对象，直接调用相关的方法就好了

	>>> k.replace('k','a')
	'aey'
	>>> k.upper()
	'KEY'

   5.2.4、string的类型还是string，但是却可以像操纵list一样操纵

	>>> type(k)
	<type 'str'>
	>>> k[:]
	'key'
	>>> k[:3]
	'key'
	>>> k[:2]
	'ke'

   5.2.5、参考资料
6、list
   从以下的对比，可以清晰的感受到python是一门面向对象的语言，因为我们调用的都是list对象的方法；而erlang是一门函数型语言，因为变量都是不可变的
   6.1、erlang：
   6.1.1、创建List

	1> L=[1,2,3,4,5,6].
	[1,2,3,4,5,6]

   6.1.2、访问第一个元素

	3> [H|T] = L.
	[1,2,3,4,5,6]
	4> H.
	1

   6.1.3、访问第m到第n个元素

	7> [_,E1,E2,E3|_] = L.
	[1,2,3,4,5,6]
	8> [E1,E2,E3].
	[2,3,4]

或者直接调用lists的方法:

	9> lists:sublist(L,2,3).
	[2,3,4]

   6.1.4、增加元素，这里虽然是增加，但是已经不是在原有List上添加，而是新建了一个List，在erlang里边变量的值是不能改变的

	24> NewL = [new|L].
	[new,1,2,3,4,5,6]

这里只能把新加的元素放到开始的位置，如果是放在了后边就成了如下的效果：

	27> [L|7].
	[[1,2,3,4,5,6]|7]

当然可以通过调用lists的方法实现（注意append进去的元素必须是只有一个元素的List）：

	28> lists:append(L,[7]).
	[1,2,3,4,5,6,7]

   6.1.5、扩展/合并list

	45> lists:append(L,[7,8,9]).
	[1,2,3,4,5,6,7,8,9]
	46> lists:merge(L,[7,8,9]).
	[1,2,3,4,5,6,7,8,9]

   6.1.6、list运算符

	59> L ++ ['a',b].
	[1,2,3,4,5,6,a,b]

   6.1.7、其他

	55> lists:nth(3,L).
	3
	56> lists:delete(3,L).
	[1,2,4,5,6]

   6.2、python:
   6.2.1、创建List

	>>> li=[1,2,3,4,5,6]
	>>> li
	[1, 2, 3, 4, 5, 6]

   6.2.2、访问第一个元素

	>>> li[0]
	1

   6.2.3、访问第m到第n个元素，可以通过索引访问。索引从前边往后数是0到len(li) - 1，从后边往前边数是-1到-len(li)。list[start:end]是返回从start开始，并包含start，到end结束，且不包含end的元素列表

	>>> li[1:4]
	[2, 3, 4]
	>>> li[:2]%//如果start处为空，则表示从第一个元素开始访问
	[1, 2]
	>>> li[-6:-1]
	[1, 2, 3, 4, 5]
	>>> li[-5:]%//如果end处为空，则表示访问到最后一个元素
	[2, 3, 4, 5, 6]
	>>> li[-4:5]
	[3, 4, 5]
	>>> li[:]%//复制List
	[1, 2, 3, 4, 5, 6]

   6.2.4、增加元素

	>>> li.append('a')
	>>> li
	[1, 2, 3, 4, 5, 6, 'a']
	>>> li.insert(0,0)
	>>> li
	[0, 1, 2, 3, 4, 5, 6, 'a']

   6.2.5、扩展list

	>>> li.extend([7,8,9])
	>>> li
	[1, 2, 3, 4, 5, 6, 7, 8, 9]

   6.2.6、list运算符

	>>> li += ['a','b']
	>>> li
	[1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b']
	>>> li *= 2
	>>> li
	[1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9]

   6.2.7、其他

	>>> li.index(3)
	2

7、tuple
erlang中，tuple是由一定数量的terms组成的复合数据类型；python则，tuple是一种序列类型（string和list也是序列类型），由数个逗号分隔的任意类型值组成，一旦创建了一个tuple就不能以任何方式改变它
   7.1、erlang:
   7.1.1、定义，注意这里是大括号

	1> T={'a',adm,34,4.2,[2,4,d],{2,3,f}}.
	{a,adm,34,4.2,[2,4,d],{2,3,f}}
	2> T={'a',adm,34,4.2,[2,4,d],{2,3,f}}.
	{a,adm,34,4.2,[2,4,d],{2,3,f}}	
	3> is_tuple(T).
	true
	4> tuple_size(T).
	6

   7.1.2、从tuple提取值

	13> Person={person,
                {name,yymt},
                {height,174},
                {footsize,41},
                {age,26},
                {eyecolor,black}}.
	{person,{name,yymt},
			{height,174},
			{footsize,41},
			{age,26},
			{eyecolor,black}}
	14> {_,{_,Who},{_,_},{_,_},{_,Age},{_,_}} = Person.
	{person,{name,yymt},
			{height,174},
			{footsize,41},
			{age,26},
			{eyecolor,black}}
	15> io:format("~p is ~p years old\n",[Who,Age]).
	yymt is 26 years old
	ok

   7.2、python:
7.2.1、定义，注意这里是小括号

	>>> tt=(,) #//这样定义已经不行了
	  File "<stdin>", line 1
		tt=(,)
			^
	SyntaxError: invalid syntax
	>>> tt=()
	>>> tt
	()
	>>> tuple = (1,2,'tuple',[1,2,3.44,"list"],{3,"set"},{"key":"dictionary"})
	>>> tuple
	(1, 2, 'tuple', [1, 2, 3.44, 'list'], set([3, 'set']), {'key': 'dictionary'})
	>>> type(tuple)
	<type 'tuple'>

   7.2.2、像操纵list一样操纵tuple，但是tuple没有方法

	>>> tuple[1]
	2
	>>> tuple[:3]
	(1, 2, 'tuple')
	>>> tuple[-5:]
	(2, 'tuple', [1, 2, 3.44, 'list'], set([3, 'set']), {'key': 'dictionary'})
	>>> tuple.append(3)
	Traceback (most recent call last):
	  File "<stdin>", line 1, in <module>
	AttributeError: 'tuple' object has no attribute 'append'

8、set
set是一个无序不重复的元素的集合，python中可以求set的并集、交集、差和对称差，erlang中无直接求对称差的接口，只能自己实现
   8.1、erlang:

	1> S = sets:new().
	{set,0,16,16,8,80,48,
		 {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		 {{[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}
	2> sets:add_element(3,S).
	{set,1,16,16,8,80,48,
		 {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		 {{[],[3],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}
	3> S.
	{set,0,16,16,8,80,48,
		 {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		 {{[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}
	4> S2 = sets:add_element(3,S).
	{set,1,16,16,8,80,48,
		 {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		 {{[],[3],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}
	6> S3 = sets:from_list([1,2,a,b,"ele",{a,b,c},[23,2]]).
	{set,7,16,16,8,80,48,
		 {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		 {{[],
		   [a],
		   [b],
		   [],[],
		   ["ele"],
		   [2],
		   [],[],
		   [{a,b,c}],
		   [],
		   [1],
		   [[23,2]],
		   [],[],[]}}}
	7> sets:intersection([S2,S3]).
	{set,0,16,16,8,80,48,
		 {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		 {{[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}
	8> sets:is_element(a,S3).
	true
	10> sets:is_set(S3).
	true
	11> sets:to_list(S2).
	[3]
	12> sets:union(S2,S3).
	{set,8,16,16,8,80,48,
		 {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		 {{[],
		   [3,a],
		   [b],
		   [],[],
		   ["ele"],
		   [2],
		   [],[],
		   [{a,b,c}],
		   [],
		   [1],
		   [[23,2]],
		   [],[],[]}}}
   

   8.2、python:

	>>> s = {"fisr",1,2,'abc',3.44}
	>>> s
	set(['fisr', 3.44, 2, 'abc', 1])
	>>> type(s)
	<type 'set'>
	>>> list = [1,2,3,'a']
	>>> s2 = set(list)
	>>> s2
	set(['a', 1, 2, 3])
	>>> type(s2)
	<type 'set'>
	>>> s - s2 #//element in s but not in s2 - difference
	set(['fisr', 3.44, 'abc'])
	>>> s & s2 #//element in s and s2 - intersection
	set([1, 2])
	>>> s | s2 #//element in s or s2 - union
	set(['a', 3.44, 2, 'abc', 1, 'fisr', 3])
	>>> s ^ s2 #//element in s or s2 but not both - sysmmetric difference
	set(['a', 3, 3.44, 'fisr', 'abc'])
	>>> a=set('abcdeabjf')
	>>> a
	set(['a', 'c', 'b', 'e', 'd', 'f', 'j'])
	>>> 'a' in a
	True
	>>> 2 in a
	False

9、dictionary
   9.1、erlang:
   9.1.1、创建Dictionary

	1> Dict = dict:new().
	{dict,0,16,16,8,80,48,
		  {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		  {{[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}

   9.1.2、新增、修改、删除dictionary的元素;多种数据类型。这里dictionary实际是不可修改的，每次是新创建了一个新的dictionary

	2> Dict2 = dict:store(1,1,Dict).
	{dict,1,16,16,8,80,48,
		  {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		  {{[],[],[],[],[],[],[],[],[],[],[],[[1|1]],[],[],[],[]}}}
	4> Dict3 = dict:store(2,1,Dict2).
	{dict,2,16,16,8,80,48,
		  {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		  {{[],[],[],[],[],[],
			[[2|1]],
			[],[],[],[],
			[[1|1]],
			[],[],[],[]}}}
	13> Dict4 = dict:append(3,1,Dict3).
	{dict,3,16,16,8,80,48,
		  {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		  {{[],
			[[3,1]],
			[],[],[],[],
			[[2|1]],
			[],[],[],[],
			[[1|1]],
			[],[],[],[]}}}
	15> Dict5 = dict:erase(1,Dict4).
	{dict,2,16,16,8,80,48,
		  {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		  {{[],
			[[3,1]],
			[],[],[],[],
			[[2|1]],
			[],[],[],[],[],[],[],[],[]}}}
	19> Dict6 = dict:store(3,'4',Dict4).
	{dict,3,16,16,8,80,48,
		  {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
		  {{[],
			[[3|'4']],
			[],[],[],[],
			[[2|1]],
			[],[],[],[],
			[[1|1]],
			[],[],[],[]}}}	

   9.1.3、通过key访问Dictionary的元素

	18> dict:find(3,Dict5).
	{ok,[1]}
	20> dict:fetch(3,Dict5).
	[1]

   9.1.4、其他

	8> dict:to_list(Dict3).
	[{2,1},{1,1}]
	21> dict:fetch_keys(Dict5).
	[3,2]

   9.2、python:
   9.2.1、创建Dictionary

	>>> dict={1:1,"key":"value",'name':'lily','from':5}
	>>> dict
	{1: 1, 'from': 5, 'name': 'lily', 'key': 'value'}

   9.2.2、新增、修改、删除dictionary的元素;多种数据类型

	>>> dict['from'] = 'china'
	>>> dict
	{1: 1, 'from': 'china', 'name': 'lily', 'key': 'value'}
	>>> dict['from'] = 'usa'
	>>> dict
	{1: 1, 'from': 'usa', 'name': 'lily', 'key': 'value'}
	>>> del dict['from']
	>>> dict
	{1: 1, 'name': 'lily', 'key': 'value'}

   9.2.3、通过key访问Dictionary的元素

	>>> dict[1]
	1
	>>> dict['key']
	'value'

   9.2.4、其他

	>>> dict.keys()
	[1, 'name', 'key']
	>>> dict.items()
	[(1, 1), ('name', 'lily'), ('key', 'value')]
	>>> dict.clear()
	>>> dict
	{}

10、function
可以创建匿名函数，然后把函数作为参数传给其他函数
   10.1、erlang:

	26> Fun = fun(X) ->  X > 2 end.
	#Fun<erl_eval.6.13229925>
	27> is_function(Fun).
	true
	28> lists:filter(Fun,[1,2,3,4,5]).
	[3,4,5]

   10.2、python:

	>>> import string
	>>> type(string.join)
	<type 'function'>
	>>> f = lambda x: x > 2
	>>> filter(f,[1,2,3,4,5])
	[3, 4, 5]
	>>> type(f)
	<type 'function'>