神刀安全网

聊聊python中的数据类型

本文系转载于本人博客 前端小吉米

在python3中, 一共有4种基本的容器类型, list,tuple,dict,set

list

list相当于js中的array. array能做的事情, 差不多list都可以做到, 比如什么可变性,删除,添加,转变为字符串等基本操作,都是木有问题滴.我们来看一下,怎么声明一个list.

name = ['sam','jimmy'] //就酱

在说之前,安利一下,3个函数,也是python中, 很有用的. len,max,min.

  • len(): 用来获取list的长度

>>> len(lists) 5
  • max(list|Numbers): 用来判断list中,最大的数字.

>>> max(lists) 5 >>> max(1,2,3,4,5) 5
  • min(list|Numbers): 用来判断list中,最小的数字

另外, 这里补充一个生成有序list最快捷的方式, 使用list comprehension.即, 在括号里面使用 for statement. 实际上, 就是一个list 派生出另外一个list. 看一个demo

>>> lists = [x for x in range(10)] >>> lists [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range就是用来生成一个iterable

//help 一下 range(start, stop[, step]) -> range object

具体含义就是born 一定范围的值. 比如range(10): 0~10.

回到 list comprehension, 这个表达式 x for x in range(10) 实际上, 就相当于

lists = [] for x in range(10):    lists.append(x)

了解了LC 之后,我们就可以脱离手码lists的困扰了. python 很方便有木有

接下来我们来look python中的两个特性 切片 , 迭代

切片

通常,我们想要获取list中的某个元素,直接使用下标即可. 但是,如果你想要取出list中间连续的几个,那么就会用到切片这一神奇的功能.

>>> my_list = ['p','r','o','g','r','a','m'] >>> my_list[2:5]    # elements 3rd to 5th ['o', 'g', 'r'] >>> my_list[:-5]    # 可以使用负数的index ['p', 'r', 'o', 'g'] >>> my_list[5:]     # 从5一直到最末 ['a', 'm', 'i', 'z'] >>> my_list[:]      # 获取所有的ele ['p', 'r', 'o', 'g', 'r', 'a', 'm']

关于切片,想吐槽一下,就是colon两边的数字代表的意义特么还不一样.

比如: my_list[2:5] 实际表现的意义是, 获取list中[2,5-1]的元素.(Ps: 下标从0开始)

实际上, 关于切片,还有一个隐藏的parameter.

>>> len[0:5:2] [1, 3, 5]

第三个的参数的相当于设置步长, x+step. 比如,你可以获得,奇数元素或者偶数元素等等.

迭代

实际上,这里的迭代,我们理解为for…in…循环就好. 如下格式

>>> for v in len: ...     print(v)

v就代表,len中的每一个元素. 然后你就可以执行相关的操作即可.另外, 如果你的list是这样的

>>> lists = [[1,2],[2,3]] >>> for [a,b] in lists: ...     print(a,b)

则,你也可以套用同样的格式即可.

built-in method

ok, 现在正是介绍一下, 关于python里相关操作list的方法. 同样,无外乎就是CRUD.这里先放一个图谱吧:

聊聊python中的数据类型

添加

在python中, 常有append,extend,insert 3个方法用来进行添加. 不过,在介绍这3个方法之前,我们先要体会一下python flexibility– + , * , 切片 . 利用这3个trick来进行添加.

+

我们使用+, 来对list进行扩展. 但实际上,他并不会修改原始的list 。 所以这就有点尴尬了

>>> lists+[1] [1, 2, 3, 4, 5, 1]

that’s all.

*

使用 * 进行翻倍扩展.但,同样不会改变原值

>>> lists * 2 [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

切片

使用切片,来对list直接修改.

>>> lists[1:3]=[1,2,3]  //只能使用另外一个list进行替代 >>> lists [1, 1, 2, 3, 4, 5]

这里简要说一下分片的原理吧. 分片实际上是,内部创建一个list,然后进行替换, 所以,对应的类型只能是list.比如下面, 就会报错

>>> lists[1:3]=1 TypeError: can only assign an iterable

现在,我们来正式看看python中的built-method.

append

这里就是向list中,尾加一个ele.

>>> lists.append(1)

extend

用来向list中,添加多个ele.

>>> lists.extend([1,2,3,4])

他和 + 操作的区别就是, + 不会改变原始的list,而extend会!

insert

用来往指定index后添加一个ele.

>>> lists.insert(0,123) >>> lists.insert(0,[1,23])

ok, 添加就到此为止了.

删除

list里面的移除也是有很多讲究的, 常用的方法有pop,remove,del,clear

pop

这里,我们就要将list理解为一个栈(Ps:一种数据结果). 他的结果就是先进后出(FILO). 相当于一个瓶子,你最后放的,会被最先拿出来. 实际上, 他和append是完全相反的.

append->入栈

pop->出栈

使用pop时, 他会返回被删除的元素

>>> lists = [1,2,3,4] >>> lists.pop() 4 >>> lists [1, 2, 3]

我们对比看一下,append

>>> lists.append(4) >>> lists [1, 2, 3, 4]

另外, pop还可以用来删除指定index的ele.

//删除第一个元素 >>> lists.pop(0)

remove

remove是用来移除指定值. 并且,一次只会移除一个

>>> lists = [1,2,3,1,1,1] >>> lists.remove(1) >>> lists [2, 3, 1, 1, 1]

del && clear

前面说了pop,用来删除最新的栈元素, 但是我怎么删除list中最先放入, 也就是 list[0]的元素呢?一个是用remove()造一个trick. 或者上面的pop例子

>>> lists.remove(lists[0]) >>> lists.pop(0)

不过使用remove的可读性超级差(pop的还可以), 所以, 我们可以使用 python中的内置函数, del 进行删除

del lists[0]

这里,我们来对比一下,3者的复杂度

  • del O(n – i)

  • pop O(n – i)

  • remove O(n)

很容器看出, del和pop的复杂度,比remove小, 所以,如果你想删除以下标开始的list的话,pop和del都行.

最后,我们如果想删除list的所有元素的话, 直接刚他. 使用clear()即可.

>>> lists.clear() >>> lists []

排序操作

实际上, 这应该算是一切算法的根源了, 算法做的工作就是筛选和排序. 在list中,提供了两个方法供我们选择 sort, reverse.

reverse()

实际上就是倒叙, 将你现在的list的顺序,逆向一遍》

>>> lists [1, 2, 3, 4] >>> lists.reverse() >>> lists [4, 3, 2, 1]

sort([fn])

sort应该是最有用的一个方法了. 他根据fn的返回值来判断你原来顺序中的大小. fn接受两个参数fn(pre,next). 代表按照顺序的list的相邻两个元素.

  • fn>0: 则保持现在的顺序

  • fn<0: 交换两者顺序继续比较

  • fn=0: 保留两者的顺序

你可以自定义函数, 也可以直接使用默认的从小到大的排列.即:

>>> lists = [1,3,2,4,2,3] >>> lists.sort() >>> lists [1, 2, 2, 3, 3, 4]

这里需要注意一点《 在python3里面, 自带的cmp参数已经被移除了. 可以使用help(list.sort) 检查一遍不过, sort本身自带了两个参数,可以用来决定排列的顺序: key,reverse

>>> lists=['ss','sss','s','ss'] >>> lists.sort(key=len) >>> lists ['s', 'ss', 'ss', 'sss']

或者指明使用reverse=True

>>> lists=['ss','sss','s','ss'] >>> lists.sort(reverse=True) >>> lists ['sss', 'ss', 'ss', 's']

当然, 如果你不想对原来的list进行改变, 可以使用sorted方法,返回一个新的list进行相关操作.我们使用,help(sorted)来看一下具体用法

sorted(iterable, key=None, reverse=False)     Return a new list containing all items from the iterable in ascending order.

同样, 他默认情况下也是升序表示

>>> lists [5, 4, 3, 2, 1] >>> sorted(lists) [1, 2, 3, 4, 5]

同样,你也可以使用reverse和key进行相关指定. 同,list这里就不赘述了.

查询

在list 查询中, python也提供了我们两个方法, index,count.

  • index(ele): 用来查找具体ele,在list中的序号,没有则会出现ValueError的错误.具体表达式为:

L.index(value, [start, [stop]])

看到这个表示之后,我们大概就可以猜到index的基本用法了, 限定范围查找, 也是很重要的一个feature

  • count(ele): 用来统计具体ele在list中出现的次数.

>>> lists.count(2) 1

当然, 如果有同学相到, in 关键字能否实现这个查询的功能呢?答案 is yes!!!

即, 我们判断一个ele 是否存在于list 可以使用 in 来判断

>>> if 1 in lists: ...     print(1) ...  1 //或者使用index >>> if lists.index(1): ...     print(1) ...  1

这都是完全行得通的

复制

如果你想复制一个list最快的方法就是使用分片. 即

>>> lists [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> newOne = lists[0:3] >>> newOne [0, 1, 2]

不过, python提供了我们另外一个更加语义的方法,copy().

newOne = lists.copy(); //或者使用 newOne = lists[:]

这样,就避免了 内存地址重叠的problem了.

额外方法

除了上面说了的max,min,list等转换方法外, python 内置的还有sum,all,any.

  • sum(): 这里就不写说了, 就是返回 list中所有元素之和

sum(lists)
  • all(): 是为了判断, lists中所有元素 通过bool(ele)之后都为True,则返回True. 所以,当list元素中有 '' , 0 , [] 的话,则会返回False 另外, 如果list为空的话, 返回的也是True

  • any(): 使用bool(ele) 判断list中的每一个元素, 如果有一个为ture的话, 返回True, 相当于或的意思. 如果list为空的话返回的是False

>>> lists [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> any(lists) True >>> all(lists)  //存在0 False >>> lists = [] >>> any(lists) //没有元素,不通过 False >>> all(lists)  //没有元素,通过 True

Tuple

另外, 还有一个和list 很像的数据tuple. 中文叫元组. 他和list的主要区别就是, tuple是一开始就定义好的, 即, assign first, 之后就永远不能被改变了. 所以, 一般全局比较重要的数据,我们都是使用tuple进行存放的.OK, 首先,我们来创建一个Tuple

创建一个Tuple

通常来说,Tuple是放在parentheses 即, 圆括号 () 内部.

>>> tub = (1,2,3) >>> type(tub) <class 'tuple'>

不过, 最近很流行的是 without parentheses. 即, 不加括号的方式. show:

>>> tub = 1,2,3 >>> type(tub) <class 'tuple'>

这个名叫, tuple packing . 鄙人翻译为, 元组包.

不过在, 使用tuple 的时候,需要注意,只有一个元素的tuple的创建(md,一个元素你还创建tuple干嘛,浪费内存?)

一个元素的tuple创建, 需要在末尾+ , 进行相关标识

>>> tub = 1, // 或者 >>> tub = (1,) >>> type(tub) <class 'tuple'>

如果,你想访问tuple的话, 和访问list 是一个道理

>>> tub = (1,2,3,4,5,6,7) >>> tub[0] 1 //当然,你也可以取负值 >>> tub[-1] 7

所以,这里我们也可以使用for…in…进行 遍历.

不变的Tuple

所以, 你一般创建了一个tuple, 之后你就用于无法改变他的值了, 也就是你不能删除, 或者添加. 不过, 如果你的tuple里面放一些可变的内容的话, 比如,list的话, 那情况就不一样了。 基于这一点,我们理解tuple 应该说为 shallow 不变形. 即, 不能改变值类型,但可以改变引用类型.

>>> tup (1, 2, 3, [2, 3], 5) >>> tup[3] [2, 3] >>> tup[3].append(1) >>> tup (1, 2, 3, [2, 3, 1], 5) //删除tup, 会报错 >>> del tup[0] Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: 'tuple' object doesn't support item deletion

虽然,我们不能对tuple执行CD操作, 但相关的查询方法我们还是可以使用的

Tuple 查询

在tuple里面有两个查询方法, index和count, 另外你使用 in 也是没有问题的》

>>> my_tuple = ('a','p','p','l','e',) >>> my_tuple.count('p') 2 >>> my_tuple.index('l') 3 >>> 'a' in my_tuple True

同样, 关于list的一些built-in methond. 在tuple身上也是使用的, 有 max,min,sum,all,any,len,sorted. 这几个, 都是木有问题的.

ok, 总结一下:

聊聊python中的数据类型

什么时候我们用Tuple

不费话了, tuple就是用来放不变的数据, 并且tuple 在内部中有遍历加速(因为不变).

ok~

That’s all

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » 聊聊python中的数据类型

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址