标签：python
# coding:utf-8
#-------------------------------------- 通用序列操作 -----------------------------------------------
#索引
greeting = ‘Hello‘
print greeting[0] #第一位是0
#H
print greeting[-1] #最后一位是-1，不是-0
#o
print ‘Hello‘[1] #字符串字面值直接使用索引，和上面方法效果一样
#e
#fourth = raw_input(‘Year: ‘)[3] #函数返回序列使用索引，只拿取第四位字符
#Year: 2005
#print fourth
#5
#实例脚本详见date.py
#分片
#分片通过冒号隔开的两个索引来实现：
tag = ‘<a href="http://www.python.org">Python web site<\a>‘
print tag[9:30]
#http://www.python.org
print tag[32:-4]
#Python web sit
numbers = [1,2,3,4,5,6,7,8,9,10]
print numbers[3:6]
#[4, 5, 6]
print numbers[0:1]
#[1]
print numbers[7:10] #索引10指向第11个元素，这个元素不存在，却是在最后一个元素之后
#[8, 9, 10]
print numbers[-3:-1] #倒数方式，无法取得最后一位
#[8, 9]
print numbers[-3:] #取得最后一位方式
#[8, 9, 10]
print numbers[:3] #从第一位开始
#[1, 2, 3]
print numbers[:]
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#脚本例子
#对http://www.abc.com 形式的URL进行分割
#url = raw_input(‘Please enter the URL: ‘) #需要输入URL，比如http://www.abc.com
#domain = url[11:-4]
#print "Domain name: " + domain
#Please enter the URL: http://www.abc.com
#Domain name: abc
#更大的步长
numbers = [1,2,3,4,5,6,7,8,9,10]
print numbers[0:10:1] #步长为1
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print numbers[0:10:2] #步长为2
#[1, 3, 5, 7, 9]
print numbers[3:6:3]
#[4]
print numbers[::4] #每4个元素第一个提取出来
#[1, 5, 9]
print numbers[8:3:-1] #步长负数就是倒着来
#[9, 8, 7, 6, 5]
print numbers[10:0:-2]
#[10, 8, 6, 4, 2]
print numbers[0:10:-2] #步长负数正着来无法显示
#[]
print numbers[::-2]
#[10, 8, 6, 4, 2]
print numbers[5::-2]
#[6, 4, 2]
print numbers[:5:-2]
#[10, 8]
#序列相加
numbers = [1,2,3] + [4,5,6]
print numbers
#[1, 2, 3, 4, 5, 6]
numbers = ‘Hello, ‘ + ‘world!‘
print numbers
#Hello, world!
#numbers = [1,2,3] + ‘word!‘ #列表和字符串无法连接一起，会报错
#print numbers
#乘法
print ‘python‘ * 5 #重复5次
#pythonpythonpythonpythonpython
print [42] * 10
#[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
sequence = [None] * 10 #None代表空列表
print sequence
#[None, None, None, None, None, None, None, None, None, None]
#判断成员资格
#为了检查一个值是否在序列中，可以使用in运算符。
permissions = ‘rw‘
if ‘w‘ in permissions: print True
#True
if ‘x‘ not in permissions: print False
#False
#users = [‘mlh‘, ‘foo‘, ‘bar‘]
#if raw_input(‘Enter your user name: ‘) in users: print True
#Enter your user name: mlh
#True
subject = ‘$$$ Get rich now!!! $$$‘
if ‘$$$‘ in subject: print True
#True
database = [
[‘albert‘, ‘1234‘],
[‘dilbert‘, ‘4242‘],
[‘smith‘, ‘7524‘],
[‘jones‘, ‘9843‘]
]
#username = raw_input(‘User name: ‘)
#pin = raw_input(‘PIN code: ‘)
#if [username, pin] in database: print ‘Access granted‘
#User name: albert
#PIN code: 1234
#Access granted
#长度最小值最大值
numbers = [100, 34, 678]
print len(numbers) #元素的数量
#3
print max(numbers) #最大的元素
#678
print min(numbers) #最小的元素
#34
print max(2, 3) #显示最大元素
#3
print min(9, 3, 2, 5) #显示最小元素
#2
#-------------------------------------------------- 列表 -------------------------------------------------------
#列表是可变的，可修改。
#list函数
print list(‘Hello‘) #字符串转换列表
#[‘H‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘]
print ‘‘.join([‘H‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘]) #列表转换字符串
#Hello
#基本列表操作
#改变列表：元素赋值
x = [1, 1, 1] #不能为一个位置不存在的元素进行赋值。如果列表长度为2，那么不能为索引为100的元素赋值。如果要那样做，就必须创建一个长度为101或者更长的列表。
x[1] = 2
print x
#[1, 2, 1]
#删除元素
names = [‘Alice‘, ‘Beth‘, ‘Cecil‘, ‘Dee-Dee‘, ‘Earl‘]
del names[2] #除了删除列表中的元素，del还可以删除其他元素，比如字典元素或是其他变量元素。
print names
#[‘Alice‘, ‘Beth‘, ‘Dee-Dee‘, ‘Earl‘]
#分片赋值
name = list(‘Perl‘)
print name
#[‘P‘, ‘e‘, ‘r‘, ‘l‘]
name[2:] = list(‘ar‘)
print name
#[‘P‘, ‘e‘, ‘a‘, ‘r‘]
name = list(‘Perl‘)
name[1:] = list(‘ython‘)
print name
#[‘P‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
numbers = [1, 5]
print numbers
#[1, 5]
numbers[1:1] = [2, 3, 4] #可以在不需要替换任何原有元素的情况插入新的元素
print numbers #这个程序只是“替换”了一个空的分片，因此实际的操作是插入了一个序列。
#[1, 2, 3, 4, 5]
numbers[1:4] = [] #通过分片赋值来删除元素
print numbers
#[1, 5]
numbers[1:-1] = [2, 3, 4]
print numbers
#[1, 2, 3, 4, 5]
del numbers[1:-2]
print numbers
#[1, 4, 5]
numbers[1:-2] = [2, 3]
print numbers
#[1, 2, 3, 4, 5]
#列表方法
#方法调用：对象.方法（参数）
#append追加
lst = [1, 2, 3] #不可以用内建函数list作为变量
lst.append(4) #在列表末尾追加新的对象
print lst
#[1, 2, 3, 4]
#count统计
#count方法统计某个元素在列表中出现的次数
print [‘to‘, ‘be‘, ‘or‘, ‘not‘, ‘to‘, ‘be‘].count(‘to‘)
#2
x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
print x.count(1)
#2
print x.count([1,2])
#1
#extend追加列表
#extend方法可以在列表的末尾一次性追加另一个序列中的多个值。换句话说，可以用新列表扩展原有的列表：
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print a
#[1, 2, 3, 4, 5, 6]
#这个操作看起来很像连接操作，两者最主要区别在于：extend方法修改了被扩展的序列（在这个例子中，就是a）。而原始的连接操作则不然，它会返回一个全新的列表。
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print a
#[1, 2, 3]
print c
#[1, 2, 3, 4, 5, 6]
a = a + b #这样的并没有被修改，而是创建了一个a和b副本的新列表，这样的方式效率比较低。
print a
#[1, 2, 3, 4, 5, 6]
a = [1, 2, 3]
b = [4, 5, 6]
a[len(a):] = b #我们可以使用分片赋值来实现相同结果，但代码可读性就不如使用extend方法
print a
#[1, 2, 3, 4, 5, 6]
#index 查找索引
#index方法用于从列表中找出某个值第一个匹配项的索引位置：
knights = [‘We‘, ‘are‘, ‘the‘, ‘knights‘, ‘who‘, ‘say‘, ‘ni‘]
print knights.index(‘who‘)
#4
print knights[knights.index(‘who‘)] #同等于print knights[4]
#who
#insert 插入对象
#insert方法用于将对象插入到列表中：
numbers = [1, 2, 3, 5, 6, 7]
numbers.insert(3, ‘four‘)
print numbers
#[1, 2, 3, ‘four‘, 5, 6, 7]
#与extend方法一样，insert方法的操作也可以用分片赋值来实现。
numbers = [1, 2, 3, 5, 6, 7]
numbers[3:3] = [‘Four‘] #可读性不如insert
print numbers
#[1, 2, 3, ‘four‘, 5, 6, 7]
#pop 移除元素
#pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值：
x = [1, 2, 3]
print x.pop() #默认删除最后一个
#3
print x
#[1, 2]
print x.pop(0)
#1
print x
#[2]
#栈，先进后出FIFO队列。就是顶部放入，底部移出。入栈（push）和出栈（pop），python没有入栈方法，可以用append也可以用insert(0,...)替代。出栈可以用pop
#remove 移除第一个匹配的元素
x = [‘to‘, ‘be‘, ‘or‘, ‘not‘, ‘to‘, ‘be‘]
x.remove(‘be‘) #可以看到remove是一个没有返回值的原位置改变方法，它修改了列表却没有返回值，这与pop方法相反。
print x
#[‘to‘, ‘or‘, ‘not‘, ‘to‘, ‘be‘]
#reverse 反向存放
x = [1, 2, 3]
x.reverse() #reverse不返回值，就像remove和sort
print x
#[3, 2, 1]
#sort 排序
#sort方法用于在原位置对列表进行排序。在“原位置排序”意味着改变原来的列表，从而让其中的元素按一定的顺序排序，而不是简单地返回一个已排序的列表副本。
x = [4, 6, 2, 1, 7, 9]
x.sort() #x变量的列表已经被修改，但不会返回值。
print x
#当用户需要一个排好序的列表副本，同时又保留原有列表不变的时候，问题就出现了：
x = [4, 6, 2, 1, 7, 9]
y = x.sort() #Don‘t do this!
print y
#None
#因为sort方法修改了x却返回了空值，那么最后得到的是已排序的x以及值为None的y。实现这个功能正确方法是，首先把x的副本赋值给y，然后对y进行排序：
x = [4, 6, 2, 1, 7, 9]
y = x[:]
y.sort()
print x #保留x变量
#[4, 6, 2, 1, 7, 9]
print y #显示y变量的排序
#[1, 2, 4, 6, 7, 9]
#再次调用x[:]得到的是包含了x所有元素的分片，这是一种很有效率的复制整个列表的方法。只是简单的把x赋值给y是没用的，因为这样做让x和y都指向同一个列表了。
y = x #指向了同一个列表
y.sort() #x和y是同一个列表，所以列表排序后，x和y都会被排序。
print x
#[1, 2, 4, 6, 7, 9]
print y
#[1, 2, 4, 6, 7, 9]
#另一种获取已排序的列表副本方法是sorted函数：
x = [4, 6, 2, 1, 7, 9]
y = sorted(x)
print x #x的列表保留不变
#[4, 6, 2, 1, 7, 9]
print y
#[1, 2, 4, 6, 7, 9]
#想把一些元素按相反方向的顺序排列，可以先使用sort（或者sorted），然后调用reverse方法。
#注意需要分两次调用，如果打算通过x.sort().reverse()来实现，会发现行不通，因为x.sort()返回的是None空值。正确方法：
x = [4, 6, 2, 1, 7, 9]
x = sorted(x)
x.reverse()
print x
#高级排序
print cmp(42, 32) #42比32大，返回正数
#1
print cmp(99, 100) #99比100小，返回负数
#-1
print cmp(10, 10) #相等返回0
#0
numbers = [5, 2, 9, 7]
numbers.sort(cmp) #根据cmp函数方式排序
print numbers
#[2, 5, 7, 9]
x = [‘aardvark‘, ‘abalone‘, ‘acme‘, ‘add‘, ‘aerate‘]
x.sort(key=len) #根据key进行排序，key需要创建一个键函数，根据len键字符长度排序
print x
#[‘add‘, ‘acme‘, ‘aerate‘, ‘abalone‘, ‘aardvark‘]
x = [4, 6, 2, 1, 7, 9]
x.sort(reverse=True) #reverse反向排序，指明True反向排序，指明False正向排序
print x
#[9, 7, 6, 4, 2, 1]
#-------------------------------- 元组 ---------------------------------------------------
#元素不可变，无法修改
#创建元组
x = 1, 2, 3
print x
#(1, 2, 3)
x = (1, 2, 3)
print x
#(1, 2, 3)
x = () #空元组
print x
#()
x = 42, #一个值的元组，也需要逗号
print x
#(42,)
x = (42, )
print x
#(42,)
x = 42 #没有逗号不是元组
print x
#42
x = 3*(40+2) #不是元组
print x
#126
x = 3*(40+2, ) #是元组。逗号很重要，加个逗号能彻底改变表达式的值。
print x
#(42, 42, 42)
#tuple 转换为元组
print tuple([1, 2, 3]) #列表转换元组
#(1, 2, 3)
print tuple(‘abc‘) #字符串转换元组
#(‘a‘, ‘b‘, ‘c‘)
print tuple((1, 2, 3)) #本身是元组，返回同样元组
#(1, 2, 3)
#元组基本操作
#元组其实并不复杂--除了创建元组的访问元组元素之外，没有太多其他操作。
x = 1, 2, 3
print x[1]
#2
print x[0:2] #元组的分片还是元组，就像列表的分片还是列表一样
#(1, 2)
#涉及的函数
#cmp(x,y) #比较两个值
#len(seq) #返回序列的长度
#list(seq) #把序列转换成列表
#max(args) #返回序列或者参数集合中的最大值
#min(args) #返回序列或者参数集合中的最小值
#reversed(seq) #对序列进行反向迭代
#sorted(seq) #返回已排序的包含seq所有元素的列表
#tuple(seq) #把序列转换成元组
本文出自 “桃子技术” 博客，请务必保留此出处http://taozijishu.blog.51cto.com/11320335/1976373
标签：python
原文地址：http://taozijishu.blog.51cto.com/11320335/1976373
