python字符串与列表与运算_转--Python基础之---列表 元组 字典 字符串 集合(set) 切片运算...

本文简单讲述了在python中对列表，元组，字典的常用操作(正确拷贝一个对象)。

在Python中有三种内建的数据结构——列表、元组和字典。访问内部元素时，三者都是通过方括号[]来访问。

print('=======================列表(这与JS里的数组类似)====================')

print('string is ',len('string'))#长度

shoplist = ['apple', 'mango', 'carrot', 'banana']

print('我的购物车里有',len(shoplist),'个东西,它们分别是：\n') #len函数返回一个对象长度

#循环输出

for item in shoplist:

print(item)

print('\n我还需要买rice')

#添加元素

shoplist.append('rice') #append方法

########################

# 这里也可以采用extend方法，虽然结果表现都一样：都是在列表末尾添加新元素，

#不过该方法的使用与append本质上完全不一样，

# shoplist.extend(['rice'])  #extend方法

# extend是可以迭代追加多个元素到列表中的，因此传入参数

# 必须是能够迭代运算的而且传入的类型最好是相同类型的，

# 如：字符串'rice'，列表 ['rice','apple','banana']，当这里shoplist.extend(2)

这样写也不会报错

# 如果传入参数为：shoplist.extend('potato'),则返回：

# ['apple', 'mango', 'carrot', 'banana', 'rice', 'p', 'o', 't',

'a', 't', 'o']

# 如果传入参数为：shoplist.extend(['potato','cabbage'])，则返回：

#  ['apple', 'mango', 'carrot', 'banana', 'rice',

'potato', 'cabbage']

技巧1:

#coding:utf-8

#快速产生数字序列

suzi = range(0,10)

#快速产生字母序列

zimu = [chr(x) for x in xrange(65,91)]

#合并两个序列

suzi.extend(zimu)

#随机返回列表值

>>> import random

>>> random.choice(['a','b','c'])

'b'

>>> random.choice(['a','b','c'])

'a'

#产随机的四位

code = ''

for i in xrange(0,4):

index = random.randint(0,len(suzi)-1)

code+=str(suzi[index])

print code

#随机化序列

>>> import random

>>>lis=[1,5,'a','d',9]

>>>random.shuffle(lis)

>>>printlis

[1,'a',5,'d',9]

>>>random.shuffle(lis)

>>>printlis

['a',5,1,9,'d']

技巧2:返回列表下标与值

l=['a','b','c']

fori,vinenumerate(l):

printi,v

技巧3:排序

>>>fromoperatorimportitemgetter

>>>l=[['a','c','b'],[2,1,5,3,7,6],[1,6,3,5,2]]

>>>l.sort(key=itemgetter(2,1))

>>>l

[[1,6,3,5,2],[2,1,5,3,7,6],['a','c','b']]

技巧：MD5

importhashlib

xxx=hashlib.md5('xxxx').hexdigest()

#########################

print('现在，我的shoplist里有：',shoplist)

#排序

print('我对我的购物车排序：')

shoplist.sort()

print('现在shoplist为：',shoplist)

#访问

print('我购物车里第2个东西为：',shoplist[1])

print('我不想',shoplist[1],'将它删除')

#删除

del shoplist[1]

print('现在购物车为:',shoplist)

#连续删除

a = [1,2,3,4,5]

del a[0:2] #连续删除，左闭右开

print(a) #输出 [3, 4, 5]

#列表要分隔成字符串需要：

import string as S #导入string模块

S.join(list, ‘ ‘) #将list转string，以空格连接

S.split(str, ‘ ‘) #将string转list，以空格切分

附表列表的常用操作方法：

print('=================================元组================================')

################

#元组和列表十分类似，只不过元组和字符串一样是

#不可变的 即你不能修改元组

################

print('空元组的定义：')

n = ()

print('一个元组的定义：')

s_n = ('only one')

print(s_n)

print('嵌套的元组')

zoo = ('one','two','three')

new_zoo = (1,2,3,zoo)

print('长度为：',len(new_zoo),new_zoo)

print('访问元组单元:',new_zoo[3])

print('访问元组单元:',new_zoo[3][2])

################

#使用元组将字符串格式化输出：

################

string = 'which'

number = 3

print('%s you choose ? %d ?'%(string,number)) #注意用法：在元组前面加%号

################

#python print函数的这种功能与c,php里的printf()函数一样：用于格式化输出字符串

#另注：在PHP里也有print函数，不过在PHP里print仅仅打印输出一个字符串

################

print('当单个打印字符时，格式如下：')

print('number is %d:'%number)

实际上我们从上可以看出： 元组通过逗号构造，而不是括号。如：

>>> a = 1,2,3

>>> a

(1, 2, 3)

>>> a = list(a)

>>> a

[1, 2, 3]

所以元组里只有一个元素时：尾随逗号是必须的！如：

>>> a = (1)

>>> list(a)

Traceback (most recent call last):

File "", line 1, in

list(a)

TypeError: 'int' object is not iterable

>>> a =(1)

>>> b = (1,)

>>> list(b)

[1]

print('=========

==============================字典========================')

##############

#字典(熟悉JS的朋友很容易就撑握，因为这和JS里的对象类似)

# 和列表类似，只过它有特定的键值

# 访问内部元素时，也是通过方括号[]来访问

# 记住字典中的键/值对是没有顺序的。

# 如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。

# 另外字典是dict类的实例/对象，提供了：items,values,keys等方法

#############

w = {

'one':'a',

'two':'b',

'three':'c'

}

print('直接访问：',w['one'])

w['four'] = 'd' #注意：这样直接加入时：会加入到字典开头

print('添加键值对',w)

del w['one'] #直接删除

print('直接删除值：',w)

print('取得长度：',len(w)) #注意JS中，对象是不能直接取得长度的

print('输出所有的键值对 w.items()：',w.items())

print('输出所有的键 w.keys()：',w.keys())

print('输出所有的值 w.values()：',w.values())

print('循环输出键值对：')

for key,value in w.items(): #字典的items方法，来使用字典中的每个键/值对

print ('key

is %s----value is %s'%(key,value))

print('判断某键的存在？')

if 'two' in w: #此处还能用w.has_key('two')

print(w['two'])

print('判断某值的存在？')

if 'c' in w.values():

print('c is

here')

#字典默认值的设置

from collections import defaultdict

s = 'asdfwfaw2edxwserwasdxcsc'

#提供默认值

cs = defaultdict(int)

for c in s:

cs[c] +=1

#或者取使用cs[c] = cs.get(c, 0)

+1

print dict(cs)

附表字典中的常用方法：

print('=========================================字符串================================')

string = 'fclamp'

#以某字符开始

if string.startswith('fc'):

print('YES,Starts with "fc"')

#寻找某字符：

if 'la' in string:

print('YES,It contains the string "la"')

if string.find('mp'):

print('YES,it contains the string"mp"')

#分割列表

dem = '||'

lists = ['aa','bb','cc','dd','ee','ff','gg']

print(dem.join(lists))

附表字符串中的操作方法：

另外注意：string模块

>>>importstring

>>>string.lowercase[:]

'abcdefghijklmnopqrstuvwxyz'

>>>string.letters

'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'

>>>string.digits

'0123456789'

全角半角字符串之间的转换

#全角转半角(注意ustr是:unicode对象)

defq2b(ustr):

return''.join(unichr(0x0020ifc==0x3000elsec-0xfee0if0xff00<c<0xff80elsec)forcinmap(ord,ustr))

#半角转全角(注意ustr是:unicode对象)

defb2q(ustr):

return''.join(unichr(0x3000ifc==0x0020elsec+0xfee0if0x0020<c<0x0080elsec)forcinmap(ord,ustr))

print('==============================================集合set 操作===============================')

使用内置set() 来定义一个集合：无序不重复的。相应的有len(set),

和for x in set等方法。

而内置的set()方法基于从 Sets 模块中提供的Set对象所得到的(Sets

模块提供了构建和处理独立对象的无序集合的类)，不过与

classsets.Set([iterable])

不同之处在于：

1Set 和 ImmutableSet 被重新命名为 set 和 frozenset。

2 判断某个对象是否是一个 set：使用 isinstance(x, (set, frozenset))

3 内置版本没有 union_update() 方法，取而代之，使用等效的 update() 方法

4 内置版本没有 _repr(sorted=True) 方法，取而代之，使用内置的 repr()

和 sorted() 函数：repr(sorted(s)

相关方法：

>>> n = set([1,2,3,1,2,3,4,5]) #创建一个数字集合

>>> n

set([1, 2, 3, 4, 5])

>>> s = set('hello')  #创建字符集合

>>> s

set(['h', 'e', 'l', 'o'])

>>> list(s)  #输出成列表

['h', 'e', 'l', 'o']

>>>

>>> a = set('hello')

>>> b = set('world')

>>>

a.add('f') #添加一项

>>> a

set(['h', 'e', 'l', 'o', 'f'])

>>>

a.update('f','c') #添加多项

>>> a

set(['c', 'e', 'f', 'h', 'l', 'o'])

>>>

n.update([6,7]) #添加多项

>>> n

set([1, 2, 3, 4, 5, 6, 7])

>>>

>>>

n.remove(7) #删除一项

>>> n

set([1, 2, 3, 4, 5, 6])

>>>

a.remove('o') #删除一项

>>> a

set(['c', 'e', 'f', 'h', 'l'])

>>>

>>>

len(a) #求长度

5

集合的相关运算

>>> t1 = a |

b #并集

>>> t1

set(['e', 'd', 'h', 'l', 'o', 'r', 'w'])

>>> t2 = a &

b #交集

>>> t2

set(['l', 'o'])

>>> t3 = a -

b #差集

>>> t3

set(['h', 'e'])

>>> t4 = a ^

b #不同时出现a,b中

>>> t4

set(['e', 'd', 'h', 'r', 'w'])

其它方法：

x in

s 测试 x 是否是 s 的成员

x not in

s 测试 x 是否不是 s

的成员

s.discard(x) 如果在 set “s”中存在元素 x, 则删除

s.pop()  删除并且返回 set

“s”中的一个不确定的元素, 如果为空则引发 KeyError

s.clear() 删除 set “s”中的所有元素

s.copy() 返回 set “s”的一个浅复制

s.symmetric_difference(t) 返回一个新的 set 包含 s 和 t 中不重复的元素

s.difference(t) 返回一个新的 set 包含 s 中有但是 t 中没有的元素

s.intersection(t) 返回一个新的 set 包含 s 和 t 中的公共元素

s.union(t) 返回一个新的 set 包含 s 和 t 中的每一个元素

s.issuperset(t) 测试是否 t 中的每一个元素都在 s 中

s.issubset(t) 测试是否

s 中的每一个元素都在 t 中

总结：恩，应该说列表(或者称为数组？)，字典都是对象的实例。列表、元组和字符串都是序列，下面我们来说说常的操作序列的方法 。

print('===================================序列一些常用操作=============================')

在Python中，我们可以通过

[from:to:step]的格式来取得序列中某一部分，这一操作称之为切片运算。

其中：from,to,step是可选的，":"是必须的(注意to不是长度，是索引值)。

#coding:gbk

lists=['a','b','c','d','e','f']

strs='abcdef'

#索引取元素

printlists[2]#c

printstrs[2]#c

#获取最后一个元素(当索引为负数时，从右往左开始计数，不过注意起始是1，而不在是0)

printlists[-1]#f

printstrs[-1]#f

#切片取一段(在PHP中可使用array_slice函数实现,js里可用：lists.slice(1,3)实现)

print'去掉最一个元素:%s'%(lists[:-1])#['a', 'b', 'c', 'd', 'e']

print'去掉最一个元素:%s'%(strs[:-1])#abcde

print'取出1到3的元素：%s'%(lists[1:3])#['b', 'c']

print'取出1到3的元素：%s'%(strs[1:3])#bc

print'取出3到最后的元素：%s'%(lists[3:])#['d', 'e', 'f']

#注意：负数时必须已正数为起，否则返回空，另外：负数的项是取不到的(左闭右开)

print'取出1到-1的元素：%s'%(lists[1:-1])#['b', 'c', 'd', 'e']

print '切取序列，歩长为2：%s'%(lists[::2]) #['a', 'c', 'e']

print'切取序列，歩长为3：%s'%(lists[::3])#['a', 'd']

#返回整个序列的拷贝

lists2=lists[:]

dellists[1]

printlists#['a', 'c', 'd', 'e', 'f']

printlists2#['a', 'b', 'c', 'd', 'e', 'f']

#反转一个序列(歩长为负数)

printlists[::-1]#['f', 'e', 'd', 'c', 'a']

printstrs[::-1]#fedcba

深入对比

#coding:gbk

lists=['a','b','c','d','e','f']

strs='abcdef'

#from为负数时表示：右往左数的第'from'开始切(计数为1)。

print'切取序列，from为-3：%s'%(lists[-3:])#切取序列，from为-3：['d', 'e', 'f']

#to为负数时表示：切到右往左数的第'to'-1(计数为1)。

print'切取序列，to为-3：%s'%(lists[:-3])#切取序列，to为-3：['a', 'b', 'c']

#歩长为负数时表示：从右往左切(即反转)。

print'切取序列，歩长为-3：%s'%(lists[::-3])#切取序列，歩长为-3：['f', 'c']

从上可以看出：1)

from、to、step为负数时，都是从右开始(数或者切)，但只有step为负数时是从右往左切(即反转)。

2) to

索引所在的值是永远取不到的(即 左闭右开 )。

类比range 函数

range([start],stop,[step])函数用于快速产生一个列表，其参数有：

start开始于，不是必填的

stop结束于，必填的

step歩长，不是必填的

range(1,5)#代表从1到5(不包含5)，有点像数学上的集合，左闭右开

[1, 2, 3, 4]

range(1,5,2) #代表从1到5，间隔2(不包含5)

[1, 3]

range(5) #代表从0到5(不包含5)

[0,1, 2, 3, 4]

使用range快速产一个倒序的数字列表:

range(10,0,-1)

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

摘至：http://archive.cnblogs.com/a/2054493/

#################################

# 如何正确拷贝一个对象

# 有一点要特别说明一下：

# 当你创建一个对象并给它赋一个变量的时候，这个变量仅仅 参考 那个对象，

# 而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。

# 这被称作名称到对象的绑定。

# 记住列表的赋值语句不创建拷贝。你得使用切片操作符来建立序列的拷贝。

#################################

mylist = lists

print('mylist------------lists',(mylist,lists))

del lists[0]

print('删除过后：')

print(mylist)

#因为它们都是指向的是同一个对象

#所以如果：如果你只是想要使用另一个变量名，两个名称都 参考 同一个对象，

#那么如果你不小心的话，可能会引来各种麻烦

#你的通过[:]“切片”来拷贝一个完整的对象

print('正确拷贝：')

lists = ['aa','bb','cc','dd','ee','ff','gg']

mylist = lists[:]

del lists[0]

print(mylist)

#########################

# 实际上：在PHP,JS里直接赋值都是不能创建拷贝的

# eg:(在PHP里)

# class w{

#private $s = array('a','b','c');

#function get_s(){

#return $this->s;

#}

#function del_s(){

#unset($this->s[0]);

#}

# }

#

# $aa = new w();

# $bb = $aa; #通过关键字：clone来复制一个对象: $bb = clone $aa;

# $aa->del_s();

# var_dump($aa->get_s());

# echo '

';

# var_dump($bb->get_s());

#########################