【Python学习之一】list与tuple

Python学习第二篇之tuple

一、元组的值不能被修改

#!/usr/bin/python
tup =("a","b","c");
tup[1]=7

实行后出现如下错误:

Traceback (most recent call last):
File “C:\Program Files\Sublime Text 3\time.py”, line 3, in
tup[1]=7
TypeError: ‘tuple’ object does not support item assignment

二、元组的成分不能单个删除,只可以全体删减

#!/usr/bin/python

tup =("a","b","c");
del tup
print "After deleting tuple:\n"
print tup

实行结果:
After deleting tuple:
Traceback (most recent call last):
File “C:\Program Files\Sublime Text 3\time.py”, line 6, in

print tup
NameError: name ‘tup’ is not defined

三、唯有五个要素的元组圆括号必得有逗号,不然不会以为是元组

#!/usr/bin/python
tupleone=(1,)
print "tupleone is :",type(tupleone)
tupleoneerror=(1)
print "tupleanotherone is :",type(tupleoneerror)

实行结果;

tupleone is :

tupleanotherone is :

四、元组成分的拆分,定义变量

#!/usr/bin/python
myinfo=("jinhoward",30,"Male")
name,age,gender=myinfo
print "Name=",name
print "Age=",age
print "Gender=",gender

施行结果:

Name= jinhoward
Age= 30
Gender= Male

一、元组的不能够被改造
#!/usr/bin/pythontup =(“a”,”b”,”c”);tup[1]=7 试行后出现如下错误:
Traceback (most recent call last): File “C:…

list -> []

  list是python内置的雷打不动聚集数据类型,可每天增加和删除成分。比方:成立八个动物的列表:

animal = ['cat', 'dog', 'pig'

  len()函数能够赢得list的要素个数:

>>>len(animal)
>>>3

  可用索引访谈list内的因素(与C语言等数组看似):

>>>animal[0]
>>>'cat
>>>animal[1]
>>>'dog'
>>>animal[2]
>>>'pig'

  索引能够是负数:

>>>animal[-1]
>>>'cat
>>>animal[-2]
>>>'dog'
>>>animal[-3]
>>>'pig'

留意:list是多个可变的、有序的列表。

  可变在于:能够后list中加进元素:

  (1)加到末尾:

animal.append('chicken')
animal.extend(['fox', 'panda'])

  (2)加到钦点地方,比方索引号为1的位置:

 

animal.insert(1, 'duck')

  此时的animal为:

>>>animal
>>>['cat', 'duck', 'dog', 'pig', 'chicken',

'fox', 'panda'

]

 

  可变在于:还足现在list中删除成分:pop(i),i为索引。还是能够直接用某元素代替list中对应索引上的因素:

>>>animal[1] = 'cow'
>>>animal
>>>['cat', 'cow', 'dog', 'pig', 'chicken', 'fox', 'panda']

  通过remove移除有些成分、del 删除有个别成分可能有些列表:

animal.remove('panda')
del animal[5]
del animal  #删除列表animal

  第一的少数:list里面包车型客车要素数据类型能够差异。整数、浮点数、字符串、list、布尔型等等。

Python内置的一种数据类型是列表:list。list是一种有序的成团,能够随时增多和删除当中的要素。

类似于java中数组

1.主导格式

例子: name=[“张三”,“李四”,“王二麻子”]

name便是一个list类型 变量  能够用len()获取成分的个数

name[0]能够获得 元素的值

name[-1]能够得到尾数第一的成分,就那样推算

例子:

图片 1

例子

2.具体方法

list是多少个可变的有序表,它能够增欧元素

name.append(“liu”)      追欧成分

name.insert(1,’du’)    钦赐位子 插入成分

name.pop()             删除 末尾成分

name.pop(0)      引导位子 删除成分

name[1]=’tan’      钦定位子退换元素

图片 2

例子

  1. list里的因素类型也能够不平等

name=[‘du’,’tan’,’wang’,123,True]

也足以是个 list

name=[‘du’,’tan’,’wang’,123,True,[1,2,3]]  能够看成为二个二维数组

图片 3

例子


图片 4

另一种有系列表叫元组:tuple。tuple和list特别类似,可是tuple一旦初步化就不能够改改,比方同样是列出同学的名字:

tuple -> (,)

  那是Python的一种有序(不可变)的列表:元组。tuple一旦初叶化就不可能修改,剖断是或不是tuple关键在于’,’。

  尚未append(),insert()方法。但能够透过索引获取成分。

  tuple注意事项是:定义二个独有叁个成分的tuple,不能够定义为:

>>>t = (1)
>>>t
1

  定义的不是tuple,是1以此数!那是因为括号()既可以够象征tuple,又有什么不可代表数学公式中的小括号,那就时有发生了歧义,由此,Python规定,这种景色下,按小括号实行总结,计算结果自然是1。所以,独有1个成分的tuple定义时必得加贰个逗号’,’,来解除歧义:

  

>>>t = (1,)
>>>t
(1,)

  练习以下:用索引抽取钦点的数量:

# -*- coding: utf-8 -*-

L = (
        ['China', 'Japan', 'Korea'], 
        ['Panda', 'Dog', 'Cat', 'Duck'], 
        ['Cjv', 'Chen', 'Bluce']
    )

# 打印Cat:
print(L[1][2])
#把Chicken加到Dog后
L[1].insert(2, 'Chicken')

 

tuple

>>> classmates = ('Michael', 'Bob', 'Tracy')

另一种有类别表叫元组:tuple。tuple和list非常临近,但是tuple一旦初叶化就不可能改改,比方同样是列出同学的名字:

name={‘zhangsan’,’wanger’,’dusan ‘}

因为元组不能够改造 所以 没append()和insert()那样的诀窍

1.使用[ ]将list的具备因素都括起来,正是二个list对象

现行反革命,classmates那么些tuple不能够变了,它也并未有append(),insert()那样的办法。其余获取成分的点子和list是同等的,你能够健康地采取classmates[0],classmates[-1],但不能够赋值成其他的要素。

元组对于数据是安全的

要定义贰个唯有1个因素的tuple,假如您这么定义:

>>>t = (1)

>>>t

1

概念的不是tuple,是1这些数!这是因为括号()不只能够表示tuple,又足以象征数学公式中的小括号,那就生出了歧义,由此,Python规定,这种状态下,按小括号进行计算,计算结果当然是1。

>>> l=[‘Liu’,18,True]
>>> print l
[‘Liu’, 18, True]

不可变的tuple有何样意思?因为tuple不可变,所以代码更安全。假设大概,能用tuple代替list就玩命用tuple。

瞩目    所以,独有1个因素的tuple定义时必得加三个逗号,,来祛除歧义:

>>>t = (1,)

>>>t

(1,)

python是动态语言,所以list里能够放不一样品类的数码

tuple的陷阱:当你定义三个tuple时,在概念的时候,tuple的要素就亟须被明确下来,举个例子:

2.贰个要素也向来不的list,便是空list

>>> t = (1, 2)
>>> t
(1, 2)

>>> j = []
>>> type(j)
>>> print j
[]

倘诺要定义三个空的tuple,可以写成():

3.依据下标访谈list

>>> t = ()
>>> t
()

>>> print l
[‘Liu’, 18, True]
>>> l[0]
‘Liu’

不过,要定义七个独有1个要素的tuple,假若您这么定义:

4.倒序拜谒

>>> t = (1)
>>> t
1

>>> print l
[‘Liu’, 18, True]
>>> l[-1]
True
>>> l[-2]
18
>>> l[-3]
‘Liu’

概念的不是tuple,是1以此数!那是因为括号()既可以够代表tuple,又能够表示数学公式中的小括号,那就产生了歧义,因而,Python规定,这种情景下,按小括号进行测算,总括结果当然是1。

倒序下标从-1始发

因而,只有1个成分的tuple定义时必需加三个逗号,,来清除歧义:

5.添比索素

>>> t = (1,)
>>> t
(1,)

方法一:append()

Python在显示独有1个元素的tuple时,也会加贰个逗号,,防止你误会成数学总括意义上的括号。

>>> print l
[‘Liu’, 18, True]
>>> l.append(‘Wen’)
>>> print l
[‘Liu’, 18, True, ‘Wen’]

最终来看三个“可变的”tuple:

方法二:insert()

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

>>> print l
[‘Liu’, 18, True, ‘Wen’]
>>> l.insert(1,’insert’)
>>> print l
[‘Liu’, ‘insert’, 18, True, ‘Wen’]

这么些tuple定义的时候有3个要素,分别是’a’,’b’和贰个list。不是说tuple一旦定义后就不行变了吧?怎么后来又变了?

第一种为结尾插入,第二种为私自地方插入,比第一种格局灵活。

别急,我们先看看定义的时候tuple富含的3个成分:

6.去除成分

图片 5

方法:pop()

tuple-0

回到:被删去的因素

当大家把list的因素’A’和’B’修改为’X’和’Y’后,tuple变为:

(1)情况一(带下标):

图片 6

>>> print l
[‘Liu’, ‘insert’, 18, True, ‘Wen’]
>>> l.pop(3)
True
>>> print l
[‘Liu’, ‘insert’, 18, ‘Wen’]

tuple-1

(2)情状二(不麻疹标):

外界上看,tuple的因素确实变了,但实际变的不是tuple的要素,而是list的要素。tuple一同首针对的list并从未改成别的list,所以,tuple所谓的“不改变”是说,tuple的各个成分,指向恒久不改变。即针对’a’,就不能够改成指向’b’,指向二个list,就不可能改成指向其余对象,但针对的那几个list自己是可变的!

>>> print l
[‘Liu’, ‘insert’, 18, ‘Wen’]
>>> l.pop()
‘Wen’
>>> print l
[‘Liu’, ‘insert’, 18]

不风疹标的pop方法,私下认可删除最后五个因素。

7.替换到分

>>> print l
[‘Liu’, ‘insert’, 18]
>>> l[-1]=19
>>> print l
[‘Liu’, ‘insert’, 19]

8.特殊的有序list—tuple(元组)

(1)使用( )将成分括起来

(2)一旦成立完成,就不能够修改。

所以tuple没有append()、insert()和pop()

(3)通过下标索引成分,可是不能够再赋值为其余成分

(4)富含 0 个因素的 tuple,相当于空tuple,直接用 ()

带有1个因素的 tuple时不能够遵照如下的措施成立:

>>> t = (1)
>>> print t
1
>>> type(t)
<type ‘int’>

析:

因为()不仅能够代表tuple,又有什么不可用作括号表示运算时的优先级,结果 (1)
被Python解释器总计出结果 1,导致大家获取的不是tuple,而是整数 1。

解决:

Python 规定,单成分 tuple 要多加八个逗号“,”,那样就防止了歧义:

>>> t = (1,)
>>> print t
(1,)
>>> type(t)
<type ‘tuple’>

9.’可变’的tuple

例子:

>>> t = (‘a’, ‘b’, [‘A’, ‘B’])
>>> L = t[2]
>>> L[0] = ‘X’
>>> L[1] = ‘Y’
>>> print t
(‘a’, ‘b’, [‘X’, ‘Y’])

不是说tuple一旦定义后就无法更换了呢?怎么以后又足以转移了吧?

分析:

当大家定义tuple的时候:

图片 7

当大家把list的要素’A’和’B’修改为’X’和’Y’后,tuple变为:

图片2

图片 8

tuple一同头针对的list并不曾改成别的list,所以,tuple所谓的“不改变”是说,tuple的各个成分,指向永久不变。即针对’a’,就无法改成指向’b’,指向三个list,就不可能改成指向另外对象,但针对的那个list本人是可变的!

10.切片

格式:list[x:y:z]

解析:

x表示切成条初始的岗位
y表示切条到哪里截至
z表示切成条间隔数

负数用在从类别尾开始图谋的职位

切开的操作类型:

con[start_index]:再次回到索引值为start_index的对象。start_index为
-len(con)到len(con)-1里边自由整数。

con[start_index:
end_index]:重返索引值为start_index到end_index-1之间的连日对象。

con[start_index: end_index :
step]:重回索引值为start_index到end_index-1之间,并且索引值与start_index之差能够被step整除的连天对象。

con[start_index:
]:缺省end_index,表示从start_index开首到行列中最终叁个对象。

con[:
end_index]:缺省start_index,表示从连串中首先个目的到end_index-1之间的一部分。

con[:]:缺省start_index和end_index,表示从第叁个对象到结尾二个对象的完全片段。

con[::step]:缺省start_index和end_index,表示对全数系列依照索引能够被step整除的法规取值。

举例:

str[6:] #截取第一个字符到终极

str[:] #截取字符串的漫天字符

str[0:3] #截取第壹位到第二个人的字符

str[:-3] #截取从头初叶到尾数第多少个字符之前

str[2] #截取第多少个字符

str[-1] #截取倒数第一个字符

str[::-1] #创立多少个与原字符串顺序相反的字符串

str[-3:-1] #截取尾数第三人与尾数第四个人在此之前的字符

str[-3:] #截取尾数第贰人到结

str[:-5:-3] #逆序截取

发表评论

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