Swift 十二曰 第四段 范围区间与跨和常用全局函数 (draft)python学习笔记(二)

by admin on 2018年9月19日

(范围区间和跨这三独词,中文翻译过来好别扭。下文尽可能采取Range,Interval,Stride。)

 python数据结构

1. Ranges

Rangs表示整数限量的有序聚集。有些许种植定义方法,第一种是密闭的Ranges,也就是说包含两只端点的平头。第二种植是半开始的。使用两个点和小于号。例如:

var x = 1...5
for i in x {println(i)}
//输出为 1 2 3 4 5
x = 4..<6
for i in x {println(i)}
//输出为4 5

当Swift内部,闭合Range被换成半开头之正式格式。如下例子:

 var xx = 4...6
 print(xx)  //输出为 4..<7

Range有零星个有效之性,startIndex和endIndex。如下例:

var xx = 2...5
println(xx.startIndex)   //输出2
println(xx.endIndex)    //输出为6. endIndex指的是转换为标准半开格式后的endIndex

一经首先只例子所示,Ranges经常于for in loop里面用。

  学一派别语言,最基础与要紧之就算是数据结构了,而当python中尽中心的数据结构是排,也得以领略为数组,但貌似比数组强大。

2. Intervals

Interval是一个象征区间的数据类型。但不得不使用“在无在斯距离里”这个论断,不克用for
in loop遍历区间。所以Intervals
的端点可以是浮点数。简单说,Intervals就是起start,end属性,以及contains()方法的数据类型。

例如:

var x = 1.0...6.0
println(x.contains(1.2)) //输出true
println(x.start) //输出1.0
println(x.end)  //输出6.0

顾上例如果未用1.0暨6.0,而之所以了1及6,
编译器会认为是Ranges,而并未contains方法,所以会见报错的。两独端点里面要用了一个浮点数,编译器则会正确的推理出类型。换句话说:

var x = 1.0...6
var x = 1...6.0

x都见面于看是Intervals。

>>> jason=['jason',42]
>>> james=['james',45]
>>> database=[jason,james]
>>> database
[['jason', 42], ['james', 45]]
>>> 

3. Stride

Stride就是富含了启幕接触,末点,和宽度的数据类型。定义之要字采用through,则带有末点。不然,则无带有。如果涨幅不可知整除,则末点不含有。如下例:

var s1 = stride(from: 2, through: 8, by: 2)
for i in s1
{println(i)}
//输出2 4 6 8

var s2 = stride(from: 2, to:8, by: 2)
for i in s2
{println(i)}
//输出2 4 6

var s3 = stride(from: 2, through: 8, by: 2.1)
for i in s3
{println(i)}
//因为不能被整除,所以输出2.0 4.1 6.2

var s4 = stride(from: 2, to:8, by: 2.1)
for i in s4
{println(i)}
//输出2.0 4.1 6.2

    索引:

4. 片常用之大局函数

Swift语言自带森有效之大局函数。这里大概介绍几单最常用之。

读者可以当Playground键入函数称呼,然后command+option+点击函数称呼,调出函数的定义跟片系统自带的讲。

  • reverse(x)
    回一个逆序数组。例如你一旦假定拿一个字符串逆序:

 println(String(reverse("abc")))
//输出"cba"
  • print(x):
    输出x。

  • println(x)
    输出x,换行。

  • max(x), abs(x), last(x), isEmpty(x),minElement(x)
    当时几乎单函数的意都异常直白。这里就是非详细说明了。

  • sort(&x)
    x被改为排序后底x。

  • sort(&x,{closure})

这里的closure用来指定两只要素大之于头里还是当晚。
例如:

var x = [2,5,7,8,-1]
sort(&x,<)
println (x)  //输出[-1, 2, 5, 7, 8]
sort(&x,> )
println (x) //输出[8, 7, 5, 2, -1]
  • sorted(x)和sorted(x,{closure})

立刻有限单函数返回给排序后的数组。但是本数组本身不叫转。closure的用法及sort
相同。

  • join(分隔符,字符串数组)

join的一体化定义比较复杂。这里举例说明其最常用用法,
就是管字符数组加上分隔符然后联合。

println(join(" :-| ",["对不起","你是个好人"]))
//输出为: 对不起 :-| 你是个好人
  • map(a, {closure})

回去一个数组按照closure的规则转换成的另一个数组。例如:

var a = [1,2,3,4]
println(map(a,{$0*$0+2}))//a的元素逐项平方,然后加2
println(a)

图片 1

>>> greeting='hello'
>>> greeting[0]
'h'
>>> greeting[-1]  ==>反着的时候从-1而不是0开始开始
'o'
>>> digital=raw_input ("year:")[3]
year:2013
>>> digital
'3'

图片 2

    索引示例:

图片 3

>>> months=['January','February','March','April',\
    'May','June','July','August','September','October'\
    'November','December']   #根据指定的年月日以数字形式打印出日期
>>> endings=['st','nd','rd']+17*['th']+['st','nd','rd']+7*['th']+['st'] #以1-31的数字作为结尾的列表
>>> year=raw_input ("Year:")
Year:2013
>>> month=raw_input('Month(1-12):')
Month(1-12):3
>>> day=raw_input('Day(1-31):')
Day(1-31):30
>>> month_num=int(month)
>>> day_num=int(day)
>>> month_name=months[month_num-1]   ==>注意这里索引要减1
>>> ordinal=day+endings[day_num-1]
>>> print month_name +' '+ordinal + ', '+ year
March 30th, 2013
>>> 

图片 4

  分片:

 
 使用索引能看单个元素,使用分片能顾必将范围之要素,分片通过冒号相隔的简单独寻引来实现。

>>> tag='<a href="http://www.python.org">Python web site</a>'
>>> tag[9:30]
'http://www.python.org'
>>> tag[32:-4]
'Python web site'>>> 

图片 5

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[3:6]
[4, 5, 6]
>>> numbers[-3:-1]
[8, 9]
>>> numbers[-3:0]  #分片中的最左边的索引比它右边索引的晚出现在序列中,结果就是一个空序列
[]
>>> numbers[-3:] #默认到最后
[8, 9, 10]
>>> numbers[:3] #默认从第一个开始
[1, 2, 3]
>>> numbers[:]   #默认全部
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

图片 6

  很鲜明,分片操作的兑现需要提供零星独目录作为边界,第一独目录的素包含在分片内,而第二单不含有在分片内。

  分片步长:默认步长没有写,是1,分片格式:上边界:下界:步长

图片 7

>>> numbers[0:10:1]  #默认步长是1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:10:2]   #步长设为2
[1, 3, 5, 7, 9]
>>> numbers[3:6:3]   #步长设为3
[4]
>>> numbers[::4]  
[1, 5, 9]
>>> numbers[8:3:-1]   #步长不能为0,因为不会向下执行,可以为负数,向前执行
[9, 8, 7, 6, 5]
>>> numbers[10:0:-2]  #当步长为负数时,开始索引必须大于结束索引
[10, 8, 6, 4, 2]
>>> numbers[0:10:-2]
[]
>>> numbers[::-2]
[10, 8, 6, 4, 2]
>>> numbers [5::-2]
[6, 4, 2]
>>> numbers[:5:-2]
[10, 8]
>>> 

图片 8

     序列相加:

图片 9

>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> [1,2,3]+'world'   #列表和字符串都是序列,但是不能连在一起,两种同类型的序列才能进行连接操作

Traceback (most recent call last):
  File "<pyshell#141>", line 1, in <module>
    [1,2,3]+'world'
TypeError: can only concatenate list (not "str") to list
>>> 

图片 10

     序列乘法:

>>> 'python'*5
'pythonpythonpythonpythonpython'
>>> [25]*10
[25, 25, 25, 25, 25, 25, 25, 25, 25, 25]

  空列表可以简单的通过[
]意味着,但要想要创建一个占用十独要素空间,却未包外有效之实惠之始末列表。这时需要使用None,None是Python的内建值,初始化一个长也10之列表如下:

>>> sequence=[None]*10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

     序列乘法示例:(存在脚本中运作)

图片 11

sentence=raw_input ("Sentence:")
screen_width=60
text_width=len(sentence)
box_width=text_width+6
left_margin=(screen_width-box_width)//2
print
print ' ' * left_margin + '+' + '-' * (box_width-2)  + '+'
print ' ' * left_margin + '|   ' + ' ' * text_width  +' |'
print ' ' * left_margin + '|   ' +          sentence +' |'
print ' ' * left_margin + '|   ' + ' ' * text_width  +' |'
print ' ' * left_margin + '+' + '-' * (box_width-2)  + '+'
print
raw_input()

图片 12

结果如下:

图片 13

  in运算符:检查一个值是否以排中

图片 14

>>> permission='rwx'   #有木有觉得这个像判断Linux中某个文件的执行权限,确实可以这么判断
>>> 'w' in permission
True
>>> 'xx' in permission
False
>>> users=['jason','james','jzhou']
>>> raw_input ("enter your name:") in users
enter your name:jzhou
True

图片 15

     序列成员身价示例:

database=[['jason','42'],['james','45'],['jzhou','22']]
username=raw_input("Username:")
age=raw_input("Age:")
if [username,age] in database:
    print "OK,right"
raw_input()

     内建函数len、min、max

图片 16

>>> numbers
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> len(numbers)
10
>>> max(numbers)
10
>>> min(numbers)
1
>>> 

图片 17

    **列表**:

 列表不同让元组和字符串,列表是可变的,而且列表有好多特意的措施。字符串不可知像列表一样被修改,但是列表中之list函数可以兑现修改。列表的常用用法:

图片 18

>>> list('hello')
['h', 'e', 'l', 'l', 'o']
>>> x=[1,1,1]
>>> x[1]=2    #可以改变列表为元素赋值
>>> x[2]=3
>>> x
[1, 2, 3]
>>> names=['james','jason','jzhou','liwear']  #可以删除列表中的元素
>>> del names[3]
>>> names
['james', 'jason', 'jzhou']
>>> name=list('jzhou')
>>> name
['j', 'z', 'h', 'o', 'u']
>>> name[2:]=list('1314')   #可以分片赋值
>>> name
['j', 'z', '1', '3', '1', '4']

图片 19
图片 20

>>> numbers=[1,5]  #分片赋值可以在不需要替换任何元素的情况下插入新元素
>>> numbers[1:1]=[2,3,4]
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4]=[]  #也可以变相的删除元素
>>> numbers
[1, 5]

图片 21

  列表的方法主要发生append,
count,extend,index,insert,pop,remove,reverse,sort
,简单用法如下:

图片 22

 >>> list=[1,2,3]
 >>> list .append(4)  # append用于在列表末尾追加新目标
 >>> list
 [1, 2, 3, 4]

>>> ['to','be','or','to'].count('to')  #count用于统计某个元素在列表中出现的次数
2
>>> x=[[1,2],1,1,[2,1,[1,2]]]
>>> x.count(1)
2
>>> x.count([1,2])
1
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a.extend(b)   #extend在列表的末尾一次性追加另一个序列的多个值,扩展原有列表
>>> a
[1, 2, 3, 4, 5, 6]   #注意这个操作与连接操作不同,extend修改了被扩展的序列即a,而连接只是临时显示并没有变
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a[len(a):]=b   #也可以通过分片赋值来扩展,但是可读性不强
>>> a
[1, 2, 3, 4, 5, 6]
>>> sentence=['we','are','good','student']
>>> sentence.index ('are')    #index用于从列表中找出某个值第一个匹配项的索引位置
1
>>> numbers=[1,2,3,4,5,6,7]
>>> numbers.insert(3,'four')  #insert用于将对象插入列表中,和数据结构中的链表操作非常相似
>>> numbers
[1, 2, 3, 'four', 4, 5, 6, 7]
>>> numbers=[1,2,3,4,5,6,7]
>>> numbers[3:3]=['four']   #也可以使用分片赋值的方法实现,但是可读性不强
>>> numbers
[1, 2, 3, 'four', 4, 5, 6, 7]
>>> x=[1,2,3]   
>>> x.pop()  #出栈操作,和数据结构中的栈操作一样,即移除列表中的最后一个,并且返回该元素的值
3
>>> x
[1, 2]
>>> x.pop()
2
>>> x=[1,2,3]
>>> x.append(x.pop())   #这个操作和数据结构中的push、pop是一样的,追加刚刚出栈的值,很有趣,最后得到的还是是原来的值
>>> x
[1, 2, 3]
>>> x=['to','be','or','not','to','be']
>>> x.remove ('be')  #remove用于移除列表中某个值的第一个匹配项
>>> x         #值得注意的是remove方法是没有返回值的原位置改变方法,注意和pop的区别
['to', 'or', 'not', 'to', 'be']
>>> x=[1,2,3]
>>> x.reverse ()  #将列表中的元素反向存放,注意这种方法改变了列表但没有返回值
>>> x
[3, 2, 1]
>>> x=[4,5,6,7,1,2,3]
>>> x.sort()  #sort用于在原位置对列表进行排序,也改变了序列的值,但是没有返回值
>>> x
[1, 2, 3, 4, 5, 6, 7]
>>> 

图片 23

  注意上述办法除了count和index,都是会见如列表的情的起变化。

   介于sort方法修改列表但是并未返回值的景有待细说一下:

>>> x=[4,6,2,1,7,9]
>>> y=x.sort()   #因为x.sort()不反回值,所以y并没有赋到值
>>> print y
None
>>> 

   看下正确的做法吧,其实为就算是用步骤拆起来要曾经:(sort函数不倒回值的特性决定了未克以它的背后继续持续操作,比如x.sort().reverse(),但是serted(x).reverse()是对的)

图片 24

>>> x=[4,6,2,1,7,9]
>>> y=x[:]   #先将x复制给y
>>> y.sort() #将y排序
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]
>>> x=y>>> x
[1, 2, 4, 6, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

图片 25

  另一样栽获得已排序的列表副本的章程是采取sorted函数:

>>> x=[4, 6, 2, 1, 7, 9]
>>> y=sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

     sorted函数可以用于其他序列,却连续回到一个列表:

>>> sorted("Python")   #默认按ASCII码排序
['P', 'h', 'n', 'o', 't', 'y']

   如果想把有些要素以倒的次第排起,可以先行用sort或者sorted函数,在调用reverse函数。嵌套使用的效力很有力。

  关于尖端排序:元素能随一定的点子进行排序,可以使用compare(x,y)自定义比较函数,compare(x,y)函数会当x<y时返回负值,x>y时回来正值,x=y时返回回0。定义好该函数之后,就好供给sort方法作为参数了。

图片 26

>>> cmp(42,23)
1
>>> cmp(99,100)
-1
>>> cmp(1,1)
0
>>> numbers=[5,2,6,7]
>>> numbers.sort(cmp)    #这个机制之后会介绍
>>> numbers
[2, 5, 6, 7]

图片 27

   元组——不可变阵

  元组和列表一样,也是同等种植阵,唯一的两样是元组不可知改改,字符串也是这般;创建元素很简单,用逗号分隔一些价,就机关创建了元组:

图片 28

>>> 1,2,3
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)
>>> (42,)  # 逗号说明它是一个元组,不然加括号(如:(42))也没用
(42,)
>>> 3*(40+2)  #这个例子说明了逗号的重要性,42和(42)是完全一样的
126
>>> 3*(40+2,)    
(42, 42, 42)
>>> 

图片 29

  tuple函数:

  
tuple函数的成效以及list函数基本等同:以一个行作为参数将她换为元组。如果参数是屡组,那么该参数就会见为形容返回:

>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1,2,3))
(1, 2, 3)

  元组其实就算是几度组,除了创建与做客之外,没有太多操作,和其他类的行列操作看似:

>>> x=1,2,3
>>> x[1]
2
>>> x[0:2]  #元组的分片还是元组,就像列表的分片还是列表一样
(1, 2)

  那么元组的是意义是啊为,首先元组可以在照中当做键使用,而列表不行;其次,元组作为广大内建函数和措施的归来值是。只要非干到修改元组,大部分场面下及列表基本功能相同。一般的话,列表可又能够满足对班的具有要求。

 

    

   
   用到的函数总结:cmp(x,y)、len(seq)(返回序列长度)、list(seq)(把班转换成列表)、max(args)、min(args)、reverse(seq)(对班进行反向迭代)、sorted(seq)(返回就排序的含有seq所有因素的列表)、tuple(seq)(把班转换成元组)

 

                                                                  

http://www.bkjia.com/Pythonjc/440647.htmlwww.bkjia.comtruehttp://www.bkjia.com/Pythonjc/440647.htmlTechArticlepython数据结构
学一派语言,最基础及重点之即是数据结构了,而在python中极核心的数据结构是排,也足以知道为数组,但一般比数组强大…

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图