python一些常用方法

1.list 方法

一、创建一个列表

只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

二、访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

print "list1[0]: ", list1[0]

print "list2[1:5]: ", list2[1:5]

以上实例输出结果：

三、更新列表

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

list = ['physics', 'chemistry', 1997, 2000];

print "Value available at index 2 : "

print list[2];

list[2] = 2001;

print "New value available at index 2 : "

print list[2];

以上实例输出结果：

四、删除列表元素

可以使用del 语句来删除列表的的元素，如下实例：

list1 = ['physics', 'chemistry', 1997, 2000];

print list1;

del list1[2];

print "After deleting value at index 2 : "

print list1;

以上实例输出结果：

五、Python列表脚本操作符

列表对+ 和* 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。如下所示：

Python 表达式结果描述

len([1, 2, 3]) 3 长度

[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合

['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复

3 in [1, 2, 3] True 元素是否存在于列表中

for x in [1, 2, 3]: print x, 1 2 3 迭代

六、Python列表截取

Python的列表截取与字符串操作类型，如下所示：

操作：

Python 表达式结果描述

L[2] 'SPAM!' 读取列表中第三个元素

L[-2] 'Spam' 读取列表中倒数第二个元素

L[1:] ['Spam', 'SPAM!'] 从第二个元素开始截取列表

七、Python列表操作的函数和方法

列表操作包含以下函数:

1、cmp(list1, list2)：比较两个列表的元素

2、len(list)：列表元素个数

3、max(list)：返回列表元素最大值

4、min(list)：返回列表元素最小值

5、list(seq)：将元组转换为列表

列表操作包含以下方法:

1、list.append(obj)：在列表末尾添加新的对象

2、list.count(obj)：统计某个元素在列表中出现的次数

3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置

5、list.insert(index, obj)：将对象插入列表

6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

7、list.remove(obj)：移除列表中某个值的第一个匹配项

8、list.reverse()：反向列表中元素

9、list.sort([func])：对原列表进行排序

字典

一、什么是字典？

字典是Python语言中唯一的映射类型。

映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。

字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

字典类型与序列类型的区别：

1.存取和访问数据的方式不同。

2.序列类型只用数字类型的键（从序列的开始按数值顺序索引）；

3.映射类型可以用其他对象类型作键（如：数字、字符串、元祖，一般用字符串作键），和序列类型的键不同，映射类型的键直

4.接或间接地和存储数据值相关联。

5.映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。

6.映射类型用键直接“映射”到值。

字典是Python中最强大的数据类型之一。

二、如何创建字典和给字典赋值

简单地说字典就是用大括号包裹的键值对的集合。（键值对也被称作项）

一般形式：

或用dict()函数，如，adict = dict() 或adict = dict（（['x',1],['y',2]））这样写对吗？adict = dict（['x',1],['y',2]）。关键字参数创建字典，如：adict= dict(name='allen',age='40′)

或用fromkeys()方法，如，adict = {}.fromkeys((‘x','y'), -1) 这样创建的字典的value是一样的，若不给值，默认为None。

特点：

1、键与值用冒号“：”分开；

2、项与项用逗号“，”分开；

3、字典中的键必须是唯一的，而值可以不唯一。

注意：如果字典中的值为数字，最好使用字符串数字形式，如：'age':'040′ 而不用‘age':040

三、字典的基本操作

1、如何访问字典中的值？

adict[key] 形式返回键key对应的值value，如果key不在字典中会引发一个KeyError。2、如何检查key是否在字典中？

a、has_key()方法形如：adict.haskey(‘name') 有–>True，无–>False

b、in 、not in 形如：'name' in adict 有–>True，无–>False

3、如何更新字典？

a、添加一个数据项（新元素）或键值对

adict[new_key] = value 形式添加一个项

b、更新一个数据项（元素）或键值对

adict[old_key] = new_value

c、删除一个数据项（元素）或键值对

del adict[key] 删除键key的项/ del adict 删除整个字典

adict.pop(key) 删除键key的项并返回key对应的value值

四、映射类型操作符

标准类型操作符（+，-，*，<,>,<=,>=,==,!=,and,or, not)

a、字典不支持拼接和重复操作符（+，*）

b、字典的比较操作

先比较字典的长度也就是字典的元素个数

键比较

值比较

例子：

五、映射相关的函数

1、len() 返回字典的长度

2、hash() 返回对象的哈希值，可以用来判断一个对象能否用来作为字典的键

3、dict() 工厂函数，用来创建字典

六、字典的方法

1、adict.keys() 返回一个包含字典所有KEY的列表；

2、adict.values() 返回一个包含字典所有value的列表；

3、adict.items() 返回一个包含所有（键，值）元祖的列表；

4、adict.clear() 删除字典中的所有项或元素；

5、adict.copy() 返回一个字典浅拷贝的副本；

6、adict.fromkeys(seq, val=None) 创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；

7、adict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返

回default的值（default默认为None）；

8、adict.has_key(key) 如果key在字典中，返回True，否则返回False。现在用in 、not in；

9、adict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；

10、adict.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；

11、adict.setdefault(key, default=None) 和set()方法相似，但如果字典中不存在Key键，由adict[key] = default 为它赋值；

12、adict.update(bdict) 将字典bdict的键值对添加到字典adict中。

七、字典的遍历

1、遍历字典的key（键）

2、遍历字典的value（值）

3、遍历字典的项（元素）

4、遍历字典的key-value

集合

set 是一个无序的元素集合，支持并、交、差及对称差等数学运算，但由于set 不记录元素位置，因此不支持索引、分片等类序列的操作。

初始化

运行结果：

提示

1.s0、d0：使用{} 只能创建空字典，创建空集必须用set()；

2.ss、sl：set 中的元素是无序不重复的，可以利用这个特点去除列表中的重复元素。

运算操作

运行结果：

提示

1.非运算符的方法接受任何可迭代对象作为参数，如s.update([0, 1])；

2.其他等价操作：s.update(t) 与s |= t，s.intersection_update(t) 与s &= t，

s.difference_update(t) 与s -= t，s.symmetric_difference_update(t) 与s ^= t 等。基本方法

运行结果：

Str字符串方法1、去空格及特殊符号

2、复制字符串

3、连接字符串

4、查找字符

5、比较字符串

6、扫描字符串是否包含指定的字符

7、字符串长度

8、将字符串中的大小写转换

9、追加指定长度的字符串

10、字符串指定长度比较

11、复制指定长度的字符

12、将字符串前n个字符替换为指定的字符

13、扫描字符串

14、翻转字符串

15、查找字符串

16、分割字符串

17、连接字符串

18、PHP 中addslashes 的实现

19、只显示字母与数字

20、截取字符串

21、字符串在输出时的对齐

22、字符串中的搜索和替换

23、字符串的分割和组合

24、字符串的mapping，这一功能包含两个函数

25、字符串还有一对编码和解码的函数

26、字符串的测试、判断函数，这一类函数在string模块中没有，这些函数返回的都是bool 值

27、字符串类型转换函数，这几个函数只在string模块中有

tuple元组方法

一、创建元组

创建空元组

元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

二、访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

tup1 = ('physics', 'chemistry', 1997, 2000);

tup2 = (1, 2, 3, 4, 5, 6, 7 );

print "tup1[0]: ", tup1[0]

print "tup2[1:5]: ", tup2[1:5]

#以上实例输出结果：

#tup1[0]: physics

#tup2[1:5]: [2, 3, 4, 5]

三、修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup1 = (12, 34.56);

tup2 = ('abc', 'xyz');

# 以下修改元组元素操作是非法的。

# tup1[0] = 100;

# 创建一个新的元组

tup3 = tup1 + tup2;

print tup3;

#以上实例输出结果：

#(12, 34.56, 'abc', 'xyz')

四、删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

tup = ('physics', 'chemistry', 1997, 2000);

print tup;

del tup;

print "After deleting tup : "

print tup;

#以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

#('physics', 'chemistry', 1997, 2000)

#After deleting tup :

#Traceback (most recent call last):

# File "test.py", line 9, in

# print tup;

#NameError: name 'tup' is not defined[/code]

五、元组运算符

与字符串一样，元组之间可以使用+ 号和* 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

六、元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

七、无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组，如下实例：

print 'abc', -4.24e93, 18+6.6j, 'xyz';

x, y = 1, 2;

print "Value of x , y : ", x,y;

以上实例允许结果：

八、元组置函数

Python元组包含了以下置函数

1、cmp(tuple1, tuple2)：比较两个元组元素。

2、len(tuple)：计算元组元素个数。

3、max(tuple)：返回元组中元素最大值。

4、min(tuple)：返回元组中元素最小值。

5、tuple(seq)：将列表转换为元组。

九、另一种解读

tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple 代替list就尽量用tuple。

tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

如果要定义一个空的tuple，可以写成()：

但是，要定义一个只有1个元素的tuple，如果你这么定义：

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

在来看一个“可变的”tuple：

这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

别急，我们先看看定义的时候tuple包含的3个元素：

当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple 一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

理解了“指向不变”后，要创建一个容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。