当前位置: 澳门新濠3559 > 编程 > 正文

空值是Python里一个特殊的值,List有序的包含对象

时间:2019-09-03 11:16来源:编程
Python成长之路第一篇(2)-初识列表和元组,python成长之路 可以将列表和元组当成普通的“数组”,他能保存任意数量任意类型的Python对象,和数组一样都是通过数字0索引访问元素,列

Python成长之路第一篇(2)-初识列表和元组,python成长之路

可以将列表和元组当成普通的“数组”,他能保存任意数量任意类型的Python对象,和数组一样都是通过数字0索引访问元素,列表和元组可以存储不同类型的对象,列表和元组有几处重要区别。列表元素用([])包括,元素的个数和值可以改变,而元组用({})包括,不能更改。元组可以看成是只读的列表

一、初识列表

1、下面是一个正常的列表

>>> lis = ['xiaoyuan',25]
在序列中,可以包含其他的序列,也就是列表可以包含列表元组等
>>> lis = ['xiaoyuan',25] 
>>> lis_jo = ['john',30]         
>>> date = [lis,lis_jo]         
>>> date         
[['xiaoyuan', 25], ['john', 30]]
注意:Python中还有一种名为容器(container)的数据结构。容器基本上是包含其他对象的任意对象。序列型(例如列表,元组)和映射型(例如字典)。序列中的每个元素都有自己的编号,而映射的每一个元素都有一个名字(也称为键)。后续会介绍,至于不是序列也不是映射的容器类型,例如集合(set),后序介绍
2、序列的通用操作
所有序列类型都可以进行某种特定的操作,这些操作包括:索引(indexing),分片(sliceing),加(adding),乘(multiplying)以及检查每个元素是否属于序列的成员(判断元素是否存在于序列)。还有计算序列的长度,找出最大元素和最小元素的内建函数。以后还有一个重要的操作进行讲解,迭代(iteration)。对序列进行迭代的意思。
 
(1)索引序列中的所有元素都有编号这个编号从0开始递增:
>>> lis = ['xiaoyuan',25]      
>>> lis_jo = ['john',30]       
>>> date = [lis,lis_jo]       
>>> date       
[['xiaoyuan', 25], ['john', 30]]       
>>> sta = 'hellow'       
>>> sta[0]       
'h'       
>>> sta[-1]       
'w'       
>>> date[0]       
['xiaoyuan', 25]
由此可见【-1】表示最后一个元素
 
(2)分片
①我们可以使用分片来对一个范围的元素进行操作
>>> tist = [1,2,3,4,5,6]      
>>> new = "abcdefg"       
>>> tist[1:3]       
[2, 3]       
>>> new[0:4]       
'abcd'
>>> tist[2:]   #从第二个元素到最后      
[3, 4, 5, 6]
②当我们想要从后面取元素怎么办?相信大家也知道了就是使用‘ – ’
>>> tist = [1,2,3,4,5,6]      
>>>       
>>> tist[-3:-1]       
[4, 5]       
>>> tist[-4:]   #这里也就是从倒数第四个元素到最后       
[3, 4, 5, 6]
小练习1
我们知道域名是由www.xxxx.cn其中分为三个部分.cn为中国,xxxx表示域名,www,表示万维网那么我们想要取出域名怎么办呢?
1 >>> url = 'www.aaa.cn' 
2 >>> name = url[4:-3] 
3 >>> name
4 
5 'aaa'
6 
7 >>> print 'donaim name:<' name '>' 'type:' url[-2:] 
8 donaim name:<aaa>type:cn

小练习1

③步长,也就是按照步长的长度来取元素,当步长为1的时候就会输出所以的元素

>>> tist = [1,2,3,4,5,6,7,8,9,10]

>>> tist[0:10:1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> tist[0:10:2]
[1, 3, 5, 7, 9]

如果我们想将元素从头到最后每个3个元素取出一个那么只需要这样即可

>>> tist[::3]
[1, 4, 7, 10]

 

(4)追加元素 list.append

>>> lis = [1,2,3,4,5,6]
>>> lis.append(7)
>>> lis
[1, 2, 3, 4, 5, 6, 7]

 

(5)列表删除元素del list[]

>>> lis
[1, 2, 3, 4, 5, 6, 7]
>>> del lis[0]
>>> lis
[2, 3, 4, 5, 6, 7]

 

(6)列表长度:len()

>>> len(lis)
6

 

(7)查找某个元素是否包含:“ 5“ in lis当存在返回True(真)否则为False(假)

>>> 5 in lis
True
>>> 1 in lis
False

 

(8)将列表变成字符串并定义连接方式 “_”.join(lis)

>>> name_lis = ["a","b","c"] 
>>> '_'.join(name_lis)       
'a_b_c’
 
(9)序列相加
>>> [1,2,3] [4,5,6]      
[1, 2, 3, 4, 5, 6]
>>> 'hell' 'world!'      
'hellworld!'
 
(10)乘法 *
>>> 'hell'*5      
'hellhellhellhellhell'       
>>> [1]*5       
[1, 1, 1, 1, 1]
 
(11)list函数,因为字符串不能像列表一样修改所以,将字符串转换成列表是就需要使用list(list函数适用于所有类型的序列)
>>> tup = 'asdfghj'
>>> list(tup)      
['a', 's', 'd', 'f', 'g', 'h', 'j']
 
(12)元素赋值
>>> tup = list(tup)      
>>> tup       
['a', 's', 'd', 'f', 'g', 'h', 'j']       
>>> tup[0] = 'A'       
>>> tup       
['A', 's', 'd', 'f', 'g', 'h', 'j']
小练习2:
需求编写一个欢迎信息,要求格式化成方盒进行输出,并根据用户输入的内容而变换
      1 inpot = raw_input("your name:") #欢迎信息
 2 text = len(inpot)
 3 scr = 17 text    #设置一个长度
 4 left = (scr) // 2     #设置前方空格的空隙
 5 #下方输出的内容可以根据输入字符串的长度进行变化
 6 print   #输出空
 7 print ' ' * left   ' '  '-'*(scr)   ' '
 8 print ' ' * left   '|'  ' '*scr   '|'
 9 print ' ' * left   '|' 'Nice to meet you:'  inpot  '|'
10 print ' ' * left   '|'  ' '*scr   '|'
11 print ' ' * left   ' '  '-'*(scr)   ' '

小练习2

 

二、初识元组

1、下面是一个正常的元组
>>> name = ('a','b','c')      
>>> name       
('a', 'b', 'c')
元组的基本操作跟列表类似,唯一的区别就是列表可以修改元组不可以修改
当我们查看a是否包含在name_tup元组中可以正常执行,但是想删除的时候就报错错误为元组对象不支持项删除
>>> name_tup = ('a','b','c')      
>>> 'a' in name_tup       
True       
>>> del name_tup[0] 
Traceback (most recent call last):      
  File "<pyshell#45>", line 1, in <module>       
    del name_tup[0]       
TypeError: 'tuple' object doesn't support item deletion

最后推荐大家使用的编译器Pycharm

可以将列表和元组当成普通的数组,他能保存任意数量任意类型的Python对象,和...

1、空(None) 表示该值是一个空对象,空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。
2、布尔类型(Boolean)
在Python中,None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False,还有自定义类型,如果实现了__nonzero__()或__len__()方法且方法返回0或False,则其实例也被当作False,其他对象均为True
布尔值和布尔代数的表示完全一致,一个布尔值只有True、False两种值,要么是True,要么是False,在Python中,可以直接用True、False表示布尔值(请注意大小写),也可以通过布尔运算计算出来:

python入门之列表和元组

List(列表)

在Python中,用方括号表示一个List,[ ]
List是Python中最主要的内置数据类型之一。
List中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。
List有序的包含对象,且用户可以自由的增加和删除List里的对象。

复制代码 代码如下:

获得更多资料欢迎进入我的网站或者 csdn或者博客园

前面一张主要学习了Python的安装,以及第一个程序helloword的编写,以及简单的输入和输出函数

特点:

  1. 可变
  2. 可包含不同类型的元素

>>> True
True
>>> False
空值是Python里一个特殊的值,List有序的包含对象。False
>>> 3 > 2
True
>>> 3 > 5
False

序列

 这章主要介绍的是列表和元组,而列表和元组是序列的六种内型中的两种,主要区别。列表可以修改,而元组不能。而序列很好用比如要操作一组人的名字和年龄可以这样:

peace=[‘peace one’,23]
rong=[‘sisi’,22]
data=[peace,rong]
data
[[‘peace one’,23],[‘sisi’,22]]
序列可以包含其他序列;比如data包含了peace和rong序列

Methods

list.append(x)
添加一个元素到列表的末尾。相当于a[len(a):] = [x]。


list.extend(L)
将给定列表L中的所有元素附加到原列表a的末尾。相当于a[len(a):] = L。亦同 a L。


list.insert(i, x)
在给定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引,所以 a.insert(0, x) 在列表的最前面插入,a.insert(len(a), x) 相当于 a.append(x)。


list.remove(x)
删除列表中第一个值为 x 的元素。如果没有这样的元素将会报错。 del


list.pop([i])
删除列表中给定位置的元素并返回它。如果未指定索引,a.pop() 删除并返回列表中的最后一个元素。


list.clear()
删除列表中所有的元素。相当于del a[:]。


list.index(x)
返回列表中第一个值为 x 的元素的索引。如果没有这样的元素将会报错。


list.count(x)
返回列表中 x 出现的次数。


list.sort(cmp=None, key=None, reverse=False)
原地排序列表中的元素。
cmp参数可以允许你提供一个比较函数,根据提供的比较函数来进行排序。改参数在Python3中已经取消。
key参数和cmp参数类似,可以提供一个函数,这个函数为每个元素生成一个键,然后根据元素的键来排序。
reverse参数是一个Boolean类型的参数,当设置为True时,表示反向排序


list.reverse()
反转列表中的元素。相当于[::-1]


list.copy()
返回列表的一个浅拷贝。等同于a[:]。


注:append, extend, insert, remove, sort, reverse之类的方法只修改列表而没有返回值打印出来, 它们其实返回了默认值None

布尔值还可以用and、or和not运算。

索引

 1、序列名按序号索引

peace[1]
23
data[1][1]
22
 2、字符串直接按序号索引还可对输入进行索引
‘hello’[1]
‘e’
two=raw_input(‘year: ‘)[1]
year: 2015
two
‘0’

切片

切片操作符在Python中的原型是
[start:stop:step]
即:[开始索引:结束索引:步长值]
开始索引:同其它语言一样,从0开始。序列从左向右方向中,第一个值的索引为0,最后一个为-1
结束索引:切片操作符将取到该索引为止,不包含该索引的值。
步长值:默认是一个接着一个切取,如果为2,则表示进行隔一取一操作。步长值为正时表示从左向右取,如果为负,则表示从右向左取。步长值不能为0


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


print li[1:]
输出[2,3,4,5,6,7],省略终止索引,表示取起始索引之后的所有值,等效于li[1:len(li)]

print li[:3]
输出[1,2,3],省略起始索引,表示从0开始取,等效于li[0:3]


print li[:]
输出[1,2,3,4,5,6,7],省略起始索引、终止索引、步长值表示取全部,等效于li[0:len(li):1]


print li[::]
输出[1,2,3,4,5,6,7],省略起始索引、终止索引、步长值表示取全部,等效于li[0:len(li):1]


print li[::-1]
输出[7,6,5,4,3,2,1],省略起始索引、终止索引,步长值为-1,表示反向获取

1).and运算是与运算,只有所有都为True,and运算结果才是True:

分片索引、

 1跟按序号索引类似,可以使用分片操作来访问一定范围内的元素。分片通过冒号分隔开来实现;

tag=’My name is one peace’
tag[11:20]
‘one peace’
注意:第一个索引是分片的第一个元素索引,第二个索引是分片元素最后一个元素索引 1;哪怕像上面的 1索引不存在也没关系.同样制空最后一个索引也是可以的;如下:
tag[-9: ]
‘one peace’
 2更大的步长,在两个索引后面再加一个冒号和步长;
tag[1:11:2]
‘ynm s’
注意:同样步长也可以为负数,不过为负数时,是从后往前输出。此时必须第一个索引再第二个索引的后面;比如:
tag[11:1:-2]
‘os mn’

和*

两个list可以使用数学运算符 ,表示将两个list连接成一个大的list
list可以与一个整数使用运算符,表示将list重复n次,形成一个大的list(n是的整数)

复制代码 代码如下:

序列运算

 1相加又称连接

[1,2,3] [3,4,6,]
[1,2,3,4,5,6]

注意:两种相同类型才能进行连接操作;比如:[1,2] ’hello’会返回错误
 2相乘用列表乘以数字x,得到的新的序列会重复被乘序列x次

[42]*5
[42,42,42,42,42]
 3成员资格,检查一个值是否在序列当中,可以使用in运算。
‘p’ in tag
True
‘pe’ in tag
True
‘px’ in tag
False
 4长度,最大值,最小值
#长度函数len
len(tag)
20
#最大值函数max
max([3,4,5])
5
min([3,4,5])
3

>>> True and True
True
>>> True and False
False
>>> False and False
False

列表

2).or运算是或运算,只要其中有一个为True,or运算结果就是True:

list函数

 1,list函数,创建列表;

str=list(‘hello’)
str
[‘h’,’e’,’l’,’l’,’o’]

复制代码 代码如下:

列表操作

 1改变列表,元素赋值

str[1]=’p’
str
[‘h’,’p’,’l’,’l’,’o’]
 2删除元素 使用del来删除
del str[1]
str
[‘h’,’l’,’l’,’o’]
 3分片赋值。主要作用如下:
#1,可以使用与原序列不等长的序列将分片替换
str[1: ]=list(‘peace’)
str
[‘h’,’p’,’e’,’a’,’c’,’e’]
#2,可以不替换任可元素的情况下插入元素
str[1:1]=list(‘one’)
str
[‘h’,’o’,’n’,’e’,’p’,’e’,’a’,’c’,’e’]
#3,当然也可以删除、
str[1:4]=list()
str
[‘h’,’p’,’e’,’a’,’c’,’e’]

>>> True or True
True
>>> True or False
True
>>> False or False
False

列表方法

方法是一个与对象紧密相关的函数。直接对象.方法进行调用
列表有append(末尾追加),count(统计次数),extend(新列表追加),index(找到元素为知),insert(按序号插入)
pop(按序号删除)remove(按值删除)reverse(元素翻转),sort(排序),sorted(获取排序后的结果),特殊排序:
sort(cmp)通过比较类型排序,sort(key=len)通过建函数排序(此去是长度len),sort(reverse=True)通过True和false来判断是否翻转排序;
方法操作如下:

#append方法
 >>> name = list(scott)
 >>> name
 ['s', 'c', 'o', 't', 't']
 >>> name.append(list( tiger))
 >>> name
 ['s', 'c', 'o', 't', 't', [' ', 't', 'i', 'g', 'e', 'r']]
>>> name = list(scott)
>>> name
['s', 'c', 'o', 't', 't']
>>> name.append(A,B)        #添加多个元素即将报错
Traceback (most recent call last):
  File , line 1, in ?
TypeError: append() takes exactly one argument (2 given)
>>> name.append(A)
>>> name
['s', 'c', 'o', 't', 't', 'A']
#count方法
>>> name = list(scott)
>>> name
['s', 'c', 'o', 't', 't']
>>> name.count('s')
1
>>> name.count(t)
2
>>> name.count(A)
0
>>> name.append(list(Python))
>>> name
['s', 'c', 'o', 't', 't', ['P', 'y', 't', 'h', 'o', 'n']]
>>> name.count(['P', 'y', 't', 'h', 'o', 'n'])
1
#extend方法
 >>> name = list(scott)
 >>> name
 ['s', 'c', 'o', 't', 't']
 >>> name.extend(list( tiger))
 >>> name
 ['s', 'c', 'o', 't', 't', ' ', 't', 'i', 'g', 'e', 'r']
#index方法
>>> name = list(scott)
>>> name
['s', 'c', 'o', 't', 't']
>>> name.index('t')    ##第一个字母t的索引位置是3
3   
>>> name.index('a')
Traceback (most recent call last):
  File , line 1, in ?
ValueError: list.index(x): x not in list
>>> 'a' in name
False
>>> 'a' not in name
True
#insert方法
>>> name = list(scott)
 >>> name
 ['s', 'c', 'o', 't', 't']
 >>> name.insert(2,'tiger')     ##在索引为2的地方插入字符串tiger  
 >>> name
 ['s', 'c', 'tiger', 'o', 't', 't']
 #pop方法
>>> name = list(scott)
>>> name
['s', 'c', 'o', 't', 't']
>>> name.pop()
't'
>>> name
['s', 'c', 'o', 't']
>>> name.append(t)
>>> name
['s', 'c', 'o', 't', 't']
#remove方法
>>> name = list(scott)
>>> name
['s', 'c', 'o', 't', 't']
>>> name.remove(t)    #去掉第一个t
>>> name
['s', 'c', 'o', 't']
>>> name.remove(A)    #不存在会报错
Traceback (most recent call last):
  File , line 1, in ?
ValueError: list.remove(x): x not in list
>>> A not in name
True
>>> name.remove(s,c)  #一次只能移除一个元素
Traceback (most recent call last):
  File , line 1, in ?
TypeError: remove() takes exactly one argument (2 given)
#reverse方法
 >>> name = list(scott)
 >>> name
 ['s', 'c', 'o', 't', 't']
 >>> name.reverse()
 >>> name
 ['t', 't', 'o', 'c', 's']
#sort方法
 >>> result = [8,5,5,3,9]
 >>> result.sort()
 >>> result
 [3, 5, 5, 8, 9]

 #sorted方法

 >>> result = [8,5,5,3,9]
 >>> result2 = sorted(result)
 >>> result
 [8, 5, 5, 3, 9]
 >>> result2
 [3, 5, 5, 8, 9]

3).not运算是非运算,它是一个单目运算符,把True变成False,False变成True:

元组

元组
元组与列表一样,也是一种序列,唯一不同的是元组不可以修改:

复制代码 代码如下:

元组操作

>>> 1,2,3

(1, 2, 3)

>>> ()

()
#对于单个元素必须加上逗号,加上逗号后就表示数字是元组了
>>> 42

42

>>> 42,

(42,)

>>> (42,)

(42,)

>>> not True
False
>>> not False
True

元组tuple函数

>>> tuple([1,2,3])

(1, 2, 3)

>>> tuple('abc')

('a', 'b', 'c')

>>> tuple((1,2,3))

(1, 2, 3)

4).布尔值经常用在条件判断中,比如:

列表与元组的相互转化

>>> T=('cc','aa','dd','bb')

>>> tmp=list(T)

>>> tmp

['cc', 'aa', 'dd', 'bb']

>>> T=tuple(tmp)

>>> T

('cc', 'aa', 'dd', 'bb')

 

获得更多资料欢迎进入我的网站或者 csdn或者博客园 前面一张主要学习了Python的安装,以及第一个程序helloword的编写...

复制代码 代码如下:

if age >= 18:
    print 'adult'
else:
    print 'teenager'

3、整型(Int) 在Python内部对整数的处理分为普通整数和长整数,普通整数长度为机器位长,通常都是32位,超过这个范围的整数就自动当长整数处理,而长整数的范围几乎完全没限制
Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1,100,-8080,0,等等。
4、浮点型(Float) Python的浮点数就是数学中的小数,类似C语言中的double。
在运算中,整数与浮点数运算的结果是浮点数
浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是相等的。浮点数可以用数学写法,如1.23,3.14,-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。
整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。
5、字符串(String) Python字符串即可以用单引号也可以用双引号括起来,甚至还可以用三引号括起来
字符串是以''或""括起来的任意文本,比如'abc',"xyz"等等。请注意,''或""本身只是一种表示方式,不是字符串的一部分,因此,字符串'abc'只有a,b,c这3个字符。如果'本身也是一个字符,那就可以用""括起来,比如"I'm OK"包含的字符是I,',m,空格,O,K这6个字符。

如果字符串内部既包含'又包含"怎么办?可以用转义字符来标识,比如:

复制代码 代码如下:

'I'm "OK"!'

表示的字符串内容是:

复制代码 代码如下:

I'm "OK"!

转义字符可以转义很多字符,比如n表示换行,t表示制表符,字符本身也要转义,所以\表示的字符就是,可以在Python的交互式命令行用print打印字符串看看:

复制代码 代码如下:

>>> print 'I'm ok.'
I'm ok.
>>> print 'I'm learningnPython.'
I'm learning
Python.
>>> print '\n\'

如果字符串里面有很多字符都需要转义,就需要加很多,为了简化,Python还允许用r''表示''内部的字符串默认不转义,可以自己试试:

复制代码 代码如下:

>>> print '\t\'
      
>>> print r'\t\'
\t\

如果字符串内部有很多换行,用n写在一行里不好阅读,为了简化,Python允许用'''...'''的格式表示多行内容,可以自己试试:

复制代码 代码如下:

>>> print '''line1
... line2
... line3'''
line1
line2
line3

上面是在交互式命令行内输入,如果写成程序,就是:

复制代码 代码如下:

print '''line1
line2
line3'''

多行字符串'''...'''还可以在前面加上r使用,请自行测试。
6、列表(List)
用符号[]表示列表,中间的元素可以是任何类型,用逗号分隔。list类似C语言中的数组,用于顺序存储结构
内建函数:

复制代码 代码如下:

append(x)追加到链尾
extend(L)追加一个列表,等价于 =
insert(i,x)在位置i插入x,其余元素向后推,如果i大于列表长度,就在最后添加,如果i小于0,就在最开始添加
remove(x)删除第一个值为x的元素,如果不存在会抛出异常
reverse()反转序列
pop([i])返回并删除位置为i的元素,i默认为最后一个元素
index(x)返回x在列表中第一次出现的位置,不存在则抛出异常
count(x)返回x出现的次数
sort()排序
len(List)返回List的长度
del list[i]删除列表list中指定的第i 1个变量
切片
切片指的是抽取序列的一部分,其形式为:list[start:end:step]。其抽取的规则是:一般默认的步长为1,但也可自定义。

7、元组(Tuple)
元组是和列表相似的数据结构,但它一旦初始化就不能更改,速度比list快,同时tuple不提供动态内存管理的功能,需理解一下规则:
tuple可以用下标返回一个元素或子tuple
表示只含有一个元素的tuple的方法是:(d,)后面有个逗号,用来和单独的变量相区分
8、集合(Set) 集合是无序的,不重复的元素集,类似数学中的集合,可进行逻辑运算和算术运算
9、字典(Dict)

字典是一种无序存储结构,包括关键字(key)和关键字对应的值(value)。字典的格式为:dictionary

{key:value}。关键字为不可变类型,如字符串、整数、只包含不可变对象的元组,列表等不可作为关键字。如果列表中存在关键字对,可以用dict()直接构造字典

表示该值是一个空对象,空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空...

编辑:编程 本文来源:空值是Python里一个特殊的值,List有序的包含对象

关键词: 澳门新濠3559