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

最新推荐文章于 2023-05-13 20:13:34 发布

yueyemaitian

最新推荐文章于 2023-05-13 20:13:34 发布

阅读量424

点赞数

分类专栏： python 文章标签：数据结构 Erlang Python F# D语言

本文链接：https://blog.csdn.net/yueyemaitian/article/details/83681231

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

erlang中的任何类型的数据都叫一个term。
[size=medium][b]1、number(byte/short/int/long/float/double)[/b][/size]
erlang中只有两种数值类型，integer和float，integer长度都不受限制，而float的精度最长是15位；python有四种数值类型，plain integers(也叫integers),long integers,floating point numbers,imaginary numbers
[b]1.1、erlang:[/b]
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

[b]1.2、python:[/b]
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、[url="http://zonghe.17xie.com/book/10646322/58161.html"]参考资料[/url]
[size=medium][b]2、boolean[/b][/size]
erlang中没有boolean数据类型，用true和false这两个atom表示boolean值；python中有单独的boolean数据类型，True和False表示，0、''、[]、{},()、None在boolean环境都为false，其他任何东西都为真
[b]2.1、erlang:[/b]


	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

[b]2.2、python:[/b]


	>>> 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

[size=medium][b]3、char[/b][/size]
python和erlang都没有char类型
[size=medium][b]4、void[/b][/size]
python和erlang都没有void类型
[size=medium][b]5、string[/b][/size]
在erlang中，并无string这种数据类型，其本质上是一个list；而python中有，为str类型
[b]5.1、erlang:[/b]
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: '['

[b]5.2、python:[/b]
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、[url=http://www.pythonclub.org/python-basic/string]参考资料[/url]
[size=medium][b]6、list[/b][/size]
从以下的对比，可以清晰的感受到python是一门面向对象的语言，因为我们调用的都是list对象的方法；而erlang是一门函数型语言，因为变量都是不可变的
[b]6.1、erlang：[/b]
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]

[b]6.2、python:[/b]
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

[size=medium][b]7、tuple[/b][/size]
erlang中，tuple是由一定数量的terms组成的复合数据类型；python则，tuple是一种序列类型（string和list也是序列类型），由数个逗号分隔的任意类型值组成，一旦创建了一个tuple就不能以任何方式改变它
[b]7.1、erlang:[/b]
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

[b]7.2、python:[/b]
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'

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


	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]],
		   [],[],[]}}}

[b]8.2、python:[/b]


	>>> 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

[size=medium][b]9、dictionary[/b][/size]
[b]9.1、erlang:[/b]
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]

[b]9.2、python:[/b]
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
	{}

[size=medium][b]10、function[/b][/size]
可以创建匿名函数，然后把函数作为参数传给其他函数
[b]10.1、erlang:[/b]


	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]

[b]10.2、python:[/b]


	>>> 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'>