Python 学习笔记 （1）—— 字符串、元组、列表、字典

一、字符串、元组和列表都是序列

序列的两个主要特点是：索引操作符和切片操作符。

例子1（切片）：

>>> str1='abcde'
>>> str1[:]                 //取整个字符串
'abcde'
>>> str1[::2]            //取字符串的值，步长=2（即2步取一次值）
'ace'
>>> str1[:6]            //序列号从0开始，到n+1结束（即最后一个序列号的数是取不到的）
'abcde'
>>> str1[1:5]            //取字符串“bcde”
'bcde'

例子2

>>> tag = '<a href="http://www.python.org">Python web site</a>'
>>> tag[9:30]
'http://www.python.org'
>>> tag[32:-4]
'Python web site'
>>> tag[-19:-4]
'Python web site'

索引也可以是负数，位置从序列尾开始，例如str1[-1]取得最后一个元素，str1[-2]取得最后第二个元素。

切片的时候，数字是可选的，但是"："是必须有的！

切片的时候需要有两个边界来确定，其中第一个索引的元素是包含在列表中的，而第二个索引的元素则不包含在列表中，例如下面的例子：

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

实例

url = raw_input('Please enter the URL: ')
domain = url[11:-4]
print "Domain name: "  + domain

执行结果

[root@node1 python]# python 10.py
Please enter the URL: http://www.baidu.com
Domain name: baidu

序列的基本操作：

1. len()                    求序列长度

2. +                         连接2个序列

3. *                          重复序列元素

4. in                         判断元素是否存在于序列中

5. max()                    返回最大值

6. min()                    返回最小值

7. cmp(str1,str2)        比较2个序列值是否相同

例子2：

>>> str1="123456"
>>> str2="123456789"

# 取得字符串长度
>>> len(str2)
9

# 重复序列元素
>>> str1*2
'123456123456'

# 连接两个字符串
>>> str1+str2
'123456123456789'

# 判断元素是否存在于序列中
>>> '9' in str1
False
>>> '1' in str1
True

# 返回最大值（最小值）
>>> max(str1)
'6'
>>> min(str2)
'1'

# 对比两个字符串是否相同
>>> cmp(str1,str2)
-1
>>> str2=123
>>> cmp(str1,str2)
1
>>> str2="123456"
>>> cmp(str1,str2)
0

# 取得字符串长度

>>> len(str2)
9

# 重复序列元素

>>> str1*2
'123456123456'

# 连接两个字符串

>>> str1+str2
'123456123456789'

# 判断元素是否存在于序列中

>>> '9' in str1
False
>>> '1' in str1
True

# 返回最大值（最小值）

>>> max(str1)
'6'
>>> min(str2)
'1'

# 对比两个字符串是否相同

>>> cmp(str1,str2)
-1
>>> str2=123
>>> cmp(str1,str2)
1
>>> str2="123456"
>>> cmp(str1,str2)
0

二、元组( )

元组和列表十分类似，只不过元组和字符串一样都是不可变的即你不能修改元组。

例子3：

>>> tu1=("123","456","789")
>>> tu1[0]
'123'
>>> tu1[0]="321"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元组不可修改！！ 4000

字符串：

>>> str1="123"
>>> str1
'123'
>>> str1="456"
>>> str1
'456'

看到这里或许有人会说，上面不是说了字符串和元组一样也是不能修改的嘛，但是实际上实验结果说明是可以修改的，这是为什么呢？

其实这需要从存储的方式来理解，python存储方式是这样的，一开始我们将“123”这个字符串存入内存空间，并用str1作为标签指向“123”，当我们修改str1="456"的时候，实际上，它又开辟了新的地址空间给"456"存放，只是标签仍然用的是str1，因此严格来说它是不能改变数据的！

>>> id(str1)
3077629568L
>>> id(str1)
3077629664L

注意：仅有单个元素的元组格式如下：

>>> tu3=(2,)
>>> type(tu3)
<type 'tuple'>
>>> tu2=(2)
>>> type(tu3)
<type 'int'>

索引：

>>> tu4=("pmghong",22,"male")
>>> name,age,gender=tu4
>>> name
'pmghong'
>>> age
22
>>> gender
'male'

三、列表[ ]

list 是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。

列表是可变类型的数据

>>> list1=["pmghong",22,"male"]
>>> list1
['pmghong', 22, 'male']

列表操作：

(1). 取值

>>> list1
['pmghong', 22, 'male']

(2). 添加

>>> list1.append("hello")
>>> list1
['pmghong', 22, 'male', 'hello']

(3). 删除

>>> list1
['pmghong', 22, 'male', 'hello', 'world']
>>> del(list1[4])
>>> list1
['pmghong', 22, 'male', 'hello']
>>> list1.remove(list1[3])
>>> list1
['pmghong', 22, 'male']

(4). 修改

>>> list1[2]="female"
>>> list1
['pmghong', 22, 'female']

(5). 查找

>>> "pmghong" in list1
True

相比于元组和字符串，列表是可以修改的：

>>> list2=["hello","world"]
>>> list2
['hello', 'world']
>>> id(list2)
3077618156L
>>> list2[1]="worldd"
>>> list2
['hello', 'worldd']
>>> id(list2)
3077618156L

可以看到内存空间指向的是同一个地址，也就是说确实修改了数据。

方法：

append 方法：在列表末尾追加新的元素

>>> lst = [1,2,3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

append方法是直接修改原列表，而不是返回一个新的列表

count 方法：统计某个元素在列表中出现的次数

>>> 'lihuipeng'.count('i')
2

extend 方法：在列表的末尾一次性追加另一个序列中的多个值

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

index 方法：从列表中找出某个值第一个匹配项的索引位置

>>> worlds = ['aa', 'bbb']
>>> worlds.index('aa')
0

insert 方法：将元素插入到列表中

>>> a
[1, 2, 3, 4, 5, 6]
>>> a.insert(0,'li')
>>> a
['li', 1, 2, 3, 4, 5, 6]

pop 方法：移除最后一个元素（pop方法会将移除的元素返回）

>>> a
['li', 1, 2, 3, 4, 5, 6]
>>> a.pop()
6
>>> a
['li', 1, 2, 3, 4, 5]

remove 方法：移除列表中某个值的第一个匹配项

>>> a
['li', 1, 2, 3, 4, 5]
>>> a.remove('li')
>>> a
[1, 2, 3, 4, 5]

reverse 方法：将列表中的元素反向存放

>>> a
[1, 2, 3, 4, 5]
>>> a.reverse()
>>> a
[5, 4, 3, 2, 1]

sort 方法：对列表进行排序

>>> a
[5, 4, 3, 2, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]

sorted 方法：获取已排序的列表副本

>>> a
[5, 4, 3, 2, 1]
>>> b = sorted(a)
>>> b
[1, 2, 3, 4, 5]
>>> a
[5, 4, 3, 2, 1]

key参数：可以指定一个函数来排序

reverse参数：是否进行反向排序

>>> x = ['aardvark','abalone','acme','add','aerate']
>>> x
['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']
>>> x.sort(reverse=True)
>>> x
['aerate', 'add', 'acme', 'abalone', 'aardvark']

实例：

#!/usr/bin/python
months = [
'January',
'February',
'March',
'April',
'May',
'June',
'July',
'August',
'September',
'October',
'November',
'December'
]
endings = ['st', 'nd', 'rd'] + 17 * ['th'] \
+ ['st', 'nd', 'rd'] + 7 * ['th'] \
+ ['st']
year = raw_input('Year: ')
month = raw_input('Month(1-12): ')
day = raw_input('Day (1-31): ')
month_number = int(month)
day_number = int(day)
month_name = months[month_number-1]
ordinal = day + endings[day_number-1]
print month_name + ' ' + ordinal + '.' + year

执行结果：

[root@node1 python]# python 9.py
Year: 1974
Month(1-12): 8
Day (1-31): 16
August 16th.1974

四、字典

字典是python 中唯一的映射类型（哈希表）

字典对象是可变的，但是字典的键必须使用不可变的对象，并且一个字典中可以使用不同类型的键值

keys( )或者values( ) 返回键列表或者值列表

items（）返回包含键值对的元组

创建字典：

1. { }

>>> dic={'name':'pmghong','age':'22','gender':'male'}
>>> dic['name']
'pmghong'

2. 使用工厂方法dict( )

fdict=dict(['x',1],['y',2])

3. 内建方法：fromkeys( ) ，字典中的元素具有相同的值，默认为None

ddict={}.fromkeys(('x','y'),-1)

注意：

>>> a=123
>>> b=456
>>> dic2={a:'aaa','b':'bbb'}
>>> dic2
{123: 'aaa', 'b': 'bbb'}
>>> dic2[123]
'aaa'
>>> dic2[a]
'aaa'

访问字典中值的方法：

1. 直接使用Key访问：key 不存在会报错，可以使用has_key()或者in和not in 判断，但是has_key()方法即将废弃

2. 循环遍历

#!/usr/bin/python
dict={"a":"apple","b":"banana","o":"orange"}

print "##########dict######################"
for i in dict:
print "dict[%s]=" % i,dict[i]

print "###########items#####################"
for (k,v) in  dict.items():
print "dict[%s]=" % k,v

print "###########iteritems#################"
for k,v in dict.iteritems():
print "dict[%s]=" % k,v

print "###########iterkeys,itervalues#######"
for k,v in zip(dict.iterkeys(),dict.itervalues()):
print "dict[%s]=" % k,v

执行结果：

##########dict######################
dict[a]= apple
dict[b]= banana
dict[o]= orange
###########items#####################
dict[a]= apple
dict[b]= banana
dict[o]= orange
###########iteritems#################
dict[a]= apple
dict[b]= banana
dict[o]= orange
###########iterkeys,itervalues#######
dict[a]= apple
dict[b]= banana
dict[o]= orange

更新和删除：

1. 直接用键值访问更新：内建的update()方法可以将整个字典的内容拷贝到另一个字典中

2. del dic['a'] 删除字典中键值为a的元素

dic.pop('a')    删除并返回键为'a'的元素

dic.clear()      删除字典所有元素

del dic            删除整个字典

添加键、键值

>>> dic
{'gender': 'male', 'age': '22', 'name': 'pmghong'}
>>> dic['tel']='123456789'
>>> dic
{'gender': 'male', 'age': '22', 'tel': '123456789', 'name': 'pmghong'}

修改键值

>>> dic['tel']='8888888'
>>> dic
{'gender': 'male', 'age': '22', 'tel': '8888888', 'name': 'pmghong'}

删除元素

>>> del(dic['tel'])
>>> dic
{'gender': 'male', 'age': '22', 'name': 'pmghong'}

删除元素

>>> dic.pop('age')
'22'
>>> dic
{'gender': 'male', 'name': 'pmghong'}

清空字典

>>> dic.clear()
>>> dic
{}

删除整个字典

>>> del(dic)
>>> dic
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'dic' is not defined

字典中的函数：

len(),hash()        用于判断某个对象是否可以做一个字典的键，非哈希类型报TypeError错误。

dict.clear()         删除字典中的所有元素（字典变成空字典，但字典仍然存在）

dict.fromkeys(seq,value=None)        以seq中的元素为键创建并返回一个字典，val为指定的默认值

dict.get(key,default=None)                返回key的value，如果该键不存在返回default指定的值

dict.has_ke 24000 y(key)                判断字典中是否存在key，建议使用in和not in代替

dict.items()                        返回键值对元组的列表

dict.keys()                            返回字典中键的列表

dict.php(key[defalut]):            与get()相同，区别在若key存在，删除并返回dict[key]，若不存在且default为指定值，抛出KeyError异常

dict.setdefault(key,default=None)            同set()，若key存在则返回其value，若不存在，则dict[key]=default

dict.update(dict2)                将dict2中的键值对添加到字典dict中，如果有重复覆盖，原字典不存在的条码添加进去

dict.values()                返回字典中所有值的列表

实例

#简单数据库
#使用人名作为键的字典，每个人用另一个字典表示，其键‘phone’和‘addr’分别表示他们的电话号和地址，
people ={
'zhangsan':{
'phone':'2341',
'addr':'foo drive 23'
},
'lisi':{
'phone':'9102',
'addr':'bar street 42'
},
'wangwu':{
'phone':'3158',
'addr':'baz avenue 90'
}
}
#针对电话号码和地址使用的描述性标签，会在打印输出的时候用到
labels = {
'phone':'phone number',
'addr':'address'
}
name = raw_input('Name:')
#查找电话号码还是地址？ 使用正确的键：
request = raw_input('phone number(p) or address (a)?')
#使用正确的键：
if request == 'p':key = 'phone'
if request == 'a':key = 'addr'
#如果名字是字典中的有效键才打印信息：
if name in people: print "%s's %s is %s." %(name, labels[key], people[name][key])
------------------------#输入内容
>>>
Name:zhangsan
phone number(p) or address (a)?p
#打印结果
zhangsan's phone number is 2341.

字典用法：

1. clear : 清空字典中的项

>>> d = {}
>>> d['name'] = 'Pmghong'
>>> d['age'] = 24
>>> d
{'age': 24, 'name': 'Pmghong'}
>>> returned_value = d.clear()
>>> d
{}
>>> print returned_value
None

2.copy

返回一个具有相同键-值对的新字典（这个方法实现的是浅复制(shallow copy)），因为值本身就是相同的，而不是副本。

>>> x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> y = x.copy()
>>> y['username'] = 'mlh'
>>> y['machines'].remove('bar')
>>> x
{'username': 'admin', 'machines': ['foo', 'baz']}
>>> y
{'username': 'mlh', 'machines': ['foo', 'baz']}
>>> y['machines'].append('test')
>>> x
{'username': 'admin', 'machines': ['foo', 'baz', 'test']}
>>> y
{'username': 'mlh', 'machines': ['foo', 'baz', 'test']}
>>> y['username'] = 'pmghong'
>>> x
{'username': 'admin', 'machines': ['foo', 'baz', 'test']}
>>> y
{'username': 'pmghong', 'machines': ['foo', 'baz', 'test']}

  可以看到，当在副本中替换值的时候，原始字典不受影响，但是如果修改了某个值（原地修改，而不是替换），原始的字典也会改变，因为同样的值也存储在原字典中（如上面提到的machines）

  避免这个问题的一种方法就是使用深复制（deep copy），复制其包含所有的值，可以使用copy 模块的deepcopy函数来完成。

>>> from copy import deepcopy
>>> d = {}
>>> d['names'] = ['Alfred', 'Bertrand']
>>> c = d.copy()
>>> dc = deepcopy(d)
>>> d['names'].append('Clive')
>>> c
{'names': ['Alfred', 'Bertrand', 'Clive']}
>>> dc
{'names': ['Alfred', 'Bertrand']}

3.fromkeys

使用给定的键建立新的字典，每个键默认对应的值为None

>>> {}.fromkeys(['name', 'age'])
{'age': None, 'name': None}

或者

>>> dict.fromkeys(['name', 'age'])
{'age': None, 'name': None}

4.get

是个更加宽松的访问字典项的方法，一般来说，如果试图访问字典中不存在的项会出错

>>> print d['name']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'name'

使用get 则不会报错：

>>> print d.get('name')
None

5. has_key

可以检查字典中是否含有给出的键，d.has_keys(k) 相当于k  in d 。Python 3.0 中不包含这个函数

>>> d = {}
>>> d.has_key('name')
False
>>> d['name'] = 'pmghong'
>>> d.has_key('name')
True

6. pop

用来获得对应于给定键的值，然后将这个键-值对从字典中移除。

>>> d = {'x': 1, 'y': 2}
>>> d.pop('x')
1
>>> d
{'y': 2}

7.setdefault

在某种程度上类似于get 方法，就是能够获得与给定键相关联的值，除此之外，setdefault 还能在字典中不含有给定键的情况下设置相应的兼职。

>>> d = {}
>>> d.setdefault('name', 'N/A')
'N/A'
>>> d
{'name': 'N/A'}
>>> d['name'] = 'Pmghong'
>>> d.setdefault('name', 'N/A')
'Pmghong'
>>> d
{'name': 'Pmghong'}

8. update

利用一个字典项更新另外一个字典

>>> d = {
...     'title': 'Python Web Site',
...     'url': 'http://www.python.org',
...     'changed': '2013-10-26'
... }
>>> x = {'title': 'Python test Website'}
>>> d.update(x)
>>> d
{'url': 'http://www.python.org', 'changed': '2013-10-26', 'title': 'Python test Website'}

提供的字典中的项会被添加到旧的字典中，若有相同的键则会进行覆盖。

阅读更多