python数据类型

python数据类型

标签（空格分隔）： python

Python常用的组合数据类型：

  • 序列类型：
    • 列表：使用[]创建；
    • 元组：使用()创建，不可变数据类型；
    • 字符串：不可变数据类型；
  • 集合类型：
    • 集合；
  • 映射类型：
    • 字典

序列类型的特点：

  • 序列可以使用索引和切片操作；
  • 都支持迭代；
  • 可以使用len()求长度；
  • 可以使用"+"连接两个序列，使用"*"表示重复显示('#' * 50)；
    • '+'连接的应该是两个相同的序列类型，不能一个是字串，一个是列表；
    • '*'后面必须是数字，表示重复多少次，不能使用字串；
  • 可以使用in/not in进行成员运算，计算元素是否在序列中；
  • 可以使用cmp()进行比较，看是否相同：
In [30]: cmp(a,'abcde')
Out[30]: 0

In [31]: cmp(a,'abcdef')
Out[31]: -1

In [32]: cmp(a,'abcd')
Out[32]: 1
  • 可以做数据的拆分：
# 字串：
In [51]: s = 'abc'

In [52]: first,second,third = s

In [53]: first
Out[53]: 'a'

# 元组：
In [47]: t = ('a','b','c')

In [48]: first,second,third = t

In [49]: first
Out[49]: 'a'

In [50]: third
Out[50]: 'c'

每个数据类型的所有方法都可以通过dir()这个函数获得。

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

所有类型的__XXX__这种带下划线的方法都是有特殊功能的，是python解释器内部自动调用的，无需我们手动管理。比如123+456，python解释器会将其转换为123.__add___(456)这种方式进行计算。

列表和字典都支持深复制和浅复制这两种复制方式。浅复制是同一个对象指向多个变量，其中一个变量进行的修改，会应用到所有变量；而深复制会在内存中再创建一个相同的对象，这就和源对象分开了，因此它们之间的修改并不会影响到对方。深复制可使用copy模块中的deepcopy()实现。

Python中的所有对象都是“第一类”，这意味着使用标识符命名的所有对象都具有相同状态。因此，能够命名的所有对象都可以直接当数据进行处理。

Python中，组合数据类型也是对象，因此其可以嵌套：

['hello','world',[1,2,3]]

实质上，列表和元组并不真正存储数据，而是存放对象引用；

['this']

在这个列表中，this这个字串并不是存储在列表中，而是存储在内存中的某个地方，然后把其位置放在这个列表中；

字串本身不可变，列表中的字串的改变同样还是引用位置发生改变；

Python对象可以具有其可以被调用的特定"方法(函数)"。数据没有方法，方法属于类；

元组、列表以及字符串等数据类型是“有大小的”，也就是说其长度可使用内置函数len()测量。

查看数据类型：type(变量名)

>>> type(4)
<type 'int'>
>>> type(str(4))
<type 'str'> # 数字转换成字符串

# 因为数字不能写入文件，因此转换为字符串

Python数据类型转换：

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值：
函数 描述
int(x [,base]) 将x转换为一个整数
long(x [,base] ) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

int

integra，整型。整型是不可变的：

>>> num = 1
>>> num = 2

这不是修改了，而是变量的引用地址发生了改变，可以使用id函数进行查看：

>>> id(num)
16147232
>>> num = 3
>>> id(num)
16147208

两次的结果是不一样的，可以理解为它们在内存中的地址并不相同。也就是说1和2都还好好的在内存中呆着，并没有被替换。只是num这个变量所指向的内存空间发生了改变。

当执行a = 123时，实际上执行的是a = int(123)，也就是将123传递给int类中的__init__方法，它的int方法支持两个参数__init__(self, x, base=10)，base=10表示10进制，源码中也有示例：

>>> int('0b100', base=0)
4

# base=0相当于base=2，二进制

int类型的赋值范围是-2147483648 -> 2147483648，也就是2的32次方个数字，其中0。如果超过这个值怎么赋值呢？

In [11]: a = 54545488888888888888888888888

In [12]: a
Out[12]: 54545488888888888888888888888L

In [13]: type(a)
Out[13]: long

我们可以发现其实也可以赋值，只不过是长整型。我们也可以定义一个数字为长整型：

In [14]: b = 100l

In [15]: type(b)
Out[15]: long

定义一个16进制为长整型：

In [17]: 0x34al
Out[17]: 842L

0x就是表示16进制，34a转换成数字就是842。

int类型的方法：

  • bit_length()：用于返回这个数值对应二进制的最小位数。比如4的二进制是00000100，使用这个方法后返回的就是3(100正好3位)，前面的0都舍弃。

布尔值

布尔型只有True和False，并且没有引号。布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False。True表示非空的量(比如string,tuple,list,set,dictionary)，所有非零数；False表示0、None、空的量等。在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

布尔值可以用and、or和not运算。and运算是与运算，只有所有都为True，and运算结果才是True：

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True

or运算是或运算，只要其中有一个为True，or运算结果就是True：

>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 5 > 3 or 1 > 3
True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>> not True
False
>>> not False
True
>>> not 1 > 2
True

布尔值经常用在条件判断中，比如：

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

字符串

它是编程语言中表示文本的数据类型，需要使用引号引起来。需要注意的是，字符串在Python中属于序列这种数据结构，是把多个字符按照特定次序组织起来的数据结构，是可以通过索引(下标)进行引用的。

>>> name = "Jerry"
>>> name[1]
'e'

字符串和元组是不可变的数据类型。虽然我们可以对一个变量进行多次赋值，但是之前的值还在内存中，只是变量的引用发生了改变，可以通过id()进行查看：

In [37]: id(a)
Out[37]: 22818464

In [38]: id('abcde')
Out[38]: 22818464

In [39]: a = 'xyz'

In [40]: id(a)
Out[40]: 12212576

In [41]: id('abcde')
Out[41]: 22818464

索引和切片

由于字串本身是不可变的，因此切片后会产生新的内存对象。python的字串列表有2种取值顺序：

(1)	从左到右索引默认0开始的，最大范围是字符串长度少1；
(2)	从右到左索引默认-1开始的，最大范围是字符串开头。

如果你确实要取得一段子串的话，可以用到变量[头下标:尾下标:偏移量]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。[2:5]表示大于等于2，小于5。比如:

s = 'ilovepython' 
>>> s[1:5]
'love'
>>> s[1:5:2]
'lv'
>>> s[:2]
'il'
>>> s[2:]
'ovepython'

如何倒序？

In [21]: a = 'abcde'

In [26]: a[-1::-1]
Out[26]: 'edcba'

In [28]: a[-2:-4:-1]
Out[28]: 'dc'

如果知道字串的长度？

>>> a = 'abcde'
>>> len(a)
5

加号(+)是字符串连接运算符(就是往字符串变量中添加内容)，星号(*)是重复操作。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = 'Hello World!'

print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第五个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串，就是往字符串变量中添加内容

以上实例输出结果：

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

字符串的方法

  • capitalize：首字符变大写；
  • center：S.center(width[, fillchar])。让S句中，width用于指定字串的总长度，不够的用fillchar进行填充，默认使用空格填充。
>>> 'abc'.center(10, '*')
'***abc****'
  • count：S.count(sub[, start[, end]])。指定一个字串在S中出现的次数，可以指定开始结束位置。
>>> 'hello world'.count('l')
3

  • decode：S.decode([encoding[,errors]])。解码，可以将utf-8、gbk这样的格式解码成Unicode。这是python2的方法，python3中已经不能显示指定Unicode。

  • encode：S.encode(encoding='utf-8', errors='strict')。编码成对应的格式，python3支持各编码之间直接转换，而无需经过Unicode。

  • endswith：S.endswith(suffix[, start[, end]]) -> bool。是否以某字串结尾，和startswith相反。同时还可以指定在某个位置是否以指定字串结尾，大于start，小于end。

  • expandtabs：S.expandtabs(tabsize=8) -> str。将tab键换成空格，默认一个tab对应8个空格。

  • find：S.find(sub[, start[, end]]) -> int。查找子串在字串S中的位置，如果返回值为-1表示没有找到。

>>> a = 'qwerty'
>>> a.find('q')
0 # 在第一个位置
>>> a.find('w')
1 # 在第二个位置
>>> a.find('qw')
0 # 以第一个字串为主
>>> a.find('wr')
-1 # 不存在
>>> a.find('rt')
3
  • format：S.format(*args, **kwargs) -> str。字符串的格式化，相当于print中的%s。
>>> a = 'hello {0}, age {1}'
>>> a.format('Tom', 14)
'hello Tom, age 14'
  • index：S.index(sub[, start[, end]]) -> int，找到指定子串sub首次在字串S中出现的位置，没找到会报错，与find比较相似。因此使用find就好，这个功能可以忽略掉。
>>> test = "hello world"
>>> test.index("o")
4
>>> test.index("or")
7
>>> test.index("o",5) # 从5开始找那就只有第7个了
7
  • isalnum：判断字串是否是字母和数字，它返回的是一个布尔值。
  • isalpha：判断字串是否是字母。
  • isdigit：判断字串的值是否为数字。
  • islower：是否全部小写。
  • isspace：是否全部是空格。
  • istitle：是否是标题。也就是是否所有的单词首字母都大写。
  • isupper：是否全部是大写。
  • join：S.join(iterable) -> str。它接收一个可迭代的对象，用S将可迭代对象中的字串连接在一起。当我们想要将一个列表转换成字串的时候，就可以使用''.join(l1)。这比遍历这个字串，然后使用字串+=的方式更节省内存。因为它只申请一次内存空间：
>>> '-'.join("abc")
'a-b-c'

>>> '***'.join(['abc','xyz','efg'])
'abc***xyz***efg'
>>> ''.join(['abc','xyz','efg'])
'abcxyzefg'

# 很显然列表是一个可迭代的对象
  • ljust：S.ljust(width[, fillchar]) -> str。内容左对齐，右侧填充。与center作用基本相同，只不过center是居中。
  • lower：S.lower() -> str。全部转化为小写，可用于用户交互时将大写转换成小写，然后只判断小写就好了。
#!/usr/bin/env python
yn = raw_input("Please input [Yes/No]: ").strip().lower()
if yn == 'y' or yn == 'yes':
    print 'True'
elif yn == 'no' or yn == 'n':
    print 'False'
else:
print "Please input [Yes/No]"

# 因为raw_input输入的结果一定是字串，因此可以直接使用lower方法
  • lstrip：S.lstrip([chars]) -> str。默认移除字串S左边的空格、制表符、换行符等，但是也可以移除指定字符。
>>> 'assd '.lstrip('a')
'ssd '
  • partition：S.partition(sep) -> (head, sep, tail)。使用序列对字串S进行分割，返回一个三元素的元组。
>>> 'hello world'.partition('o w')
('hell', 'o w', 'orld')

  • replace：S.replace(old, new[, count]) -> str，将指定字串替换成想要的字串，使用maxreplace指定替换的次数，默认全部替换。

  • rfind：S.rfind(sub[, start[, end]]) -> int。同find，只不过这是从右往左找。

  • rindex：同index，只不过是从右往左找。

  • rjust：S.rjust(width[, fillchar]) -> str。字符串放右边，左边填充。

  • rpartition：同partition，从右往左找。

  • rsplit：同split，从右往左找。

  • rstrip：用法同lstrip，只不过移除的是右边的。

  • split：S.split(sep=None, maxsplit=-1)-> list of strings。通过指定seq(默认为空格)作为分隔符对字符串进行切片，通过maxsplit指定最大切片次数，返回一个列表。

>>> url = "www.qq.com"
>>> url.split(".")
['www', 'qq', 'com']

>>> url.split(".",1)
['www', 'qq.com']

  • splitlines：S.splitlines([keepends]) -> list of strings。按照换行符分割，返回一个包含各行作为元素的列表，如果num指定则仅切片num个行。num表示分割行的次数。

  • startswith：S.startswith(prefix[, start[, end]]) -> bool。用于检查字符串是否是以指定子字符串开头，如果是返回True，否则返回False。如果参数beg和end指定值，则在指定范围内检查。

  • strip：用法同lstrip，只不过移除的是字串首尾的。

  • swapcase：S.swapcase() -> str。字符串小写变大写，大写变小写。

  • title：S.title() -> str。返回"标题化"的字符串，就是说所有单词都是以大写开始，其余字母均为小写(见istitle())。

  • translate：S.translate(table) -> str。根据参数table给出的表(包含256个字符)转换字符串的字符, 要过滤掉的字符放到del参数中。

    • table：翻译表，翻译表是通过maketrans方法转换而来。
    • deletechars：字符串中要过滤的字符列表。
#!/usr/bin/python
from string import maketrans # 导入maketrans函数

intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!";
print str.translate(trantab);

# 以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!

# 以上实例去除字符串中的 'x' 和 'm' 字符：
#!/usr/bin/python
from string import maketrans   # Required to call maketrans function.
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!";
print str.translate(trantab, 'xm');

# 以上实例输出结果：
th3s 3s str3ng 21pl2....w4w!!!
  • upper：S.upper() -> str。将字符串中的小写字母转为大写字母。
  • zfill：S.zfill(width) -> str。返回指定长度的字符串，原字符串右对齐，前面填充0，width表示指定长度。这个功能和前面的rjust相比弱爆了。

列表

List（列表）是Python中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现，它支持字符、数字、字符串甚至可以包含列表（所谓嵌套）；列表用[]标识，是python最通用的复合数据类型。

由于列表属于序列，因此列表可以用切片的方式截取相应的元素，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。

列表就是处理和存放一组数据的列表，用途有购物列表、工资列表、送礼列表等。其实就是shell的数组，下标啊啥的。

列表的一些特性：

列表是可变的；
用len()函数可以获得list元素的个数；
存储在列表中的数据并非数据本身，而是数据在内存中的引用位置；
可以对列表中的数值直接进行修改，不过修改的并不是数据本身，而是内存中的引用位置；
对列表操作有返回值的表示原列表并没有发生改变，无返回值的表示列表本身改变了；

加号(+)可以作为列表连接运算符：

>>> l1 = [1,2,3]
>>> l2 = ['x','y','z']
>>> l1 + l2
[1, 2, 3, 'x', 'y', 'z']

# 但是两个列表本身并没有改变：
>>> l1
[1, 2, 3]
>>> l2
['x', 'y', 'z']

星号(*)是重复操作：

>>> l1 * 2
[1, 2, 3, 1, 2, 3]
>>> l1 * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

# 列表本身同样并没有改变：
>>> l1
[1, 2, 3]

索引和切片

>>> names = ['zhangsan','lisi','wanger'] # 定义一个列表
>>> names
['zhangsan', 'lisi', 'wanger']
>>> names[1] # 取第二个元素
'lisi'
>>> names[0] # 取第一个元素
'zhangsan'
>>> names.extend(range(100)) # 再往这个列表中存入100个值
>>> names = names + range(100) # 这种方法和上面一样
>>> names[-1] # 取最后一个元素
99
>>> names[0:5] # 取0-4共5个元素
['zhangsan', 'lisi', 'wanger', 0, 1]
>>> names[:5] # 取前5
['zhangsan', 'lisi', 'wanger', 0, 1]
>>> names[5:15]
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> names[-5:] # 取最后5个元素
[95, 96, 97, 98, 99]
>>> names[::5] # 隔5个取1个
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
>>> names[10:50:5]
[10, 15, 20, 25, 30, 35, 40, 45]

删除列表中的元素

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

>>> del(list[2]) # 使用内置函数删
>>> list
[0, 1, 6, 7, 8, 9]

当一个列表中有很多元素，我们需要取其中一个值时，就要先知道这个值的下标是多少，然后根据下标取值。names有index()这个方法：

>>> names.index(59)
62
>>> names[names.index(59)] # 这样就可以直接取出来了
59

# 它能够将第一个为59的元素的下标(索引)给打印出来，并且只打印第一个：
>>> names.append(59) # 再往列表中追加一个59的元素
>>> names[-1] # 最后一个是59没问题
59
>>> names.index(59)
62 # 但是就是只显示一个

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> classmates
['Michael', 'Bob', 'Tracy']
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

可用的方法

  • append：L.append(object) -> None。往列表中追加元素，如果追加一个列表，它会加入整个列表，而非这个列表中的元素。
>>> l1 = [1,[],3,5]
>>> l1
[1, [], 3, 5]
>>> l1[1].append(4)
>>> l1
[1, [4], 3, 5]
  • count：L.count(value) -> integer。计数，统计同一个元素在列表中出现了几次。
>>> names.count(59)
2 # 59这个元素在names列表中出现了2次
>>> names.insert(50,'abc') # 往列表中第50个下标的位置插入abc这个元素
>>> names[50]
'abc'
  • extend：L.extend(iterable) -> None。将一个可迭代的对象和列表L结合在一起，同样用于将两个列表合起来，就是往前一个列表中追加元素。注意是元素，而不是整个列表(可迭代对象更合适)作为一个元素，它和append是不同的。
  • index：L.index(value, [start, [stop]]) -> integer。索引，和字符串的index方法是一样的，查看元素对应的索引。
  • insert：L.insert(index, object)，在指定位置之前插入元素。
  • pop：L.pop([index]) -> item。默认把最后一个元素删掉。但是也可以通过指定索引的方式删除指定位置的元素，如names.pop(1)。需要注意的是，它会将删除的元素给打印出来，也就是说我们可以使用一个变量去接收弹出的元素。
>>> names.pop() 
99 # 删除最后一个元素
>>> names[-1]
98 # 最后一个变成98了
  • remove：L.remove(value) -> None。通过指定元素来删除元素，pop是指定索引。
>>> names.insert(22,'xz')
>>> names.remove('xz')
  • reverse：L.reverse()。把整个列表反转。
>>> a=[]
>>> a=a+range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a.reverse()
>>> a
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  • sort：L.sort(key=None, reverse=False) -> None。简单的排序，基本不会用到。
>>> a
[0, 1, 2, 3, '(', '&', '*', '^', '%', '$', '@', '#', '!', 4, 5, 6, 7, 8, 9, '7', 'A', 'a']
>>> a.sort()
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, '!', '#', '$', '%', '&', '(', '*', '7', '@', 'A', '^', 'a']

将所有元素替换

先插入几个abc：

>>> names.insert(55,'abc')
>>> names.insert(59,'abc')
>>> names.insert(69,'abc')
>>> names.count('abc')
4

然后使用循环替换：

>>> for i in range(names.count('abc')):
...   names[names.index('abc')] = 'def'

首先肯定不能循环整个列表，因为如果有的列表中有几千万的元素就太麻烦了。其实就是将替换前元素的下标重新赋值为新的元素就可以了。

names.index只能显示第一次出现的元素，但是当我们把第一个替换后，它就显示第二个了，当我们把第二个替换后，它就显示第三个，依此就可以将其全部替换。

字符串转列表

>>> a=string.ascii_lowercase
>>> a
'abcdefghijklmnopqrstuvwxyz' # 这是一个元素
>>> list(a) # 使用list函数就能把字符串变成列表
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

将列表再次合并：

>>> str(a)
'abcdefghijklmnopqrstuvwxyz'

如果str不好用的话可以使用join()：

>>> b 
['a', 'b', 'c', 'd', 'e', 'f']
>>> type(b) # b是列表没错
<type 'list'>
>>> ''.join(b) # 直接合并
'abcdef'
>>> '_'.join(b) # 以下划线的格式合并
'a_b_c_d_e_f'

列表的其他用法

in成员关系判断：

>>> list
[0, 1, 6, 7, 8, 9]
>>> 4 in list
False
>>> 6 in list
True

列表复制：

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

由于引用的是同一个内存位置，修改一个另一个也会修改。不会改变的方法：

>>> l1
[1, 2, 3, 4]
>>> l3 = l1[:] # 到最后一个元素
>>> l1.append(5)
>>> l1
[1, 2, 3, 4, 5]
>>> l3
[1, 2, 3, 4]

删除列表中的元素：

>>> a=range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

现在要删除5-8：

>>> a[5:9] # 要删除就要先取出来
[5, 6, 7, 8]
>>> del a[5:9]
>>> a
[0, 1, 2, 3, 4, 9]

del是Python内置的函数，可以删除一切变量。

列表嵌套：

>>> a = [['a',1],['b',2],['c',3]]
>>> a[0] # 显示第一个元素
['a', 1]
>>> a[0][1] # 显示第一个元素中的第二个元素
1

当然列表中可以嵌套元组。

元组

和列表几乎一样，但是元组的内容一旦生成就不可修改。用处在于有些变量就不希望别人改。元组的括号可以省略。

>>> c=('a','b','c') # 它使用小括号而非中括号进行定义
>>> c
('a', 'b', 'c')
>>> type(c)
<type 'tuple'> # 元组是tuple

但是当元组中只有一个元素时，元素的后面要加上逗号，不然python为认为是字串：

In [42]: t1 = ('a')

In [43]: type(t1)
Out[43]: str

In [44]: t2 = ('a',)

In [45]: type(t2)
Out[45]: tuple

数据的接收，这和列表、字串是一样的，也就是说这是序列的操作：

In [47]: t = ('a','b','c')

In [48]: first,second,third = t

In [49]: first
Out[49]: 'a'

In [50]: third
Out[50]: 'c'

它只有两种方法，和list是一样的：

c.count(
c.index(

元组和列表互换：

元组转列表：

>>> type(c)
<type 'tuple'>
>>> b=list(c) # 使用list
>>> type(b)
<type 'list'>

列表转元组：

>>> d=tuple(b) # 使用tuple
>>> type(d)
<type 'tuple'>
>>> d
('a', 'b', 'c')

tuple的陷阱：

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

>>> t = (1, 2)
>>> t
(1, 2)

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

>>> t = ()
>>> t
()

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

>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> t = (1,)
>>> t
(1,)

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

如果元组中的元素是列表的话，由于列表是可变的，因此会导致这个元组是可变的。

列表练习程序：

(1) 让用户输入工资
(2) 输入购物菜单及产品价格
(3) 计算用户是否可支付
(4) 输出用户剩余的钱，问用户是否继续购物，如果选择继续则继续进行，直到钱不够为止。

#!/usr/bin/env python
import sys
salary = 'a' # 给salary一个初始值以便进入循环
msg = '\033[31;1mThis is a wrong option, please choice again!\033[0m'
while not salary.isdigit(): # 如果salary不是数字就一直循环
    salary = raw_input('Please input your salary: ') # 
salary = int(salary) # raw_input接收的只会是字符串，要将其转换成数字才能进行计算
products = [ # 一定一个菜单列表
    ['Iphone',5800], 
    ['MacPro',12000],
    ['NB Shoes',680],
    ['MX4',2500],
]
#create a shopping list of empty
shopping_list = [] # 这个列表用来存储用户购买的物品，在用户退出时打印出来
while True: # 全部放在死循环中
    for p in products: # 先打印列表菜单
        print products.index(p),p[0],p[1] # 数字、商品、价格
    choice = raw_input('\033[32;1mPlease choose sth to buy: \033[0m').strip() # 让用户输入选择
    if choice == 'quit': # 退出后打印购物车
        print 'You have bought below stuff:'
        for i in shopping_list:
            print '\t',i
        sys.exit('Goodbye!')
    if not choice.isdigit(): # 如果用户的选择不是数字，就从头开始循环
        print msg
        continue
    choice = int(choice) # 将用户的选择转换成数字
    if choice >= len(products): # 如果用户输入的是给定之外的选项，从头开始循环
        print msg
        continue
    pro = products[choice] # 这个用户选择的元素，也就是商品名和价格
    if salary >= products[choice][1]: # 只有当用户的余额大于等于所选商品时，才能扣款
        salary = salary - pro[1]
        shopping_list.append(pro) # 将商品加入购物车，以便退出时打印出来
        print '\033[34;1mAdding %s to shopping list, you have %s left\033[0m' % (pro[0],salary)
    else: # 否则提示钱不够
        print "\033[33;1mThe price of %s is %s, but your current balance is %s, so try another one\033[0m" % (pro[0],pro[1],salary)
        continue

函数的执行结果默认为false。

#!/usr/bin/env python

def isnum(c, q=False):
    while True:
        a = input(c)
        if a.isdigit():
            return int(a)
        elif q:
            if a == 'q':
                return 'q'
        else:
            print('\033[31;1m请输入一个数字！\033[0m')

money = isnum('pls input your salary: ')

def deposit():
    global money
    s = isnum('请输出充值金额：')
    print('充值成功!')
    money += s

def shopping():
    global money
    if money < 30:
        print('你买不起任意一个商品！')
        return True

    print('你的余额：%d' % money)

    for i, v in enumerate(l1, 1):
        print('%s %s: %s' % (i, v, product[v]))

    num = isnum('请输入商品序号(按q退出)：', True)

    if num == 'q':
        return True
    if num > len(l1) or not num:
        print('\033[31;1m范围超出，请重新选择！\033[0m')
    else:
        p = l1[num-1]
        if product[p] > money:
            print('\033[31;1m这个东西你买不起，请重新选择！\033[0m')
        else:
            money -= product[p]
            l2.append(p)
            print('已将\033[31;1m%s\033[0m加入购物车！' % p)

def shopcart():
    if l2:
        for i, v in enumerate(l2, 1):
            print(i, v)
    else:
        print('你的购物车是空的！')
        return True

    s = isnum('输入商品前的序号以删除对应商品(按q退出)：', True)
    if s == 'q':
        return True
    elif s > len(l2) or not s:
        print('\033[31;1m范围超出，请重新选择！\033[0m')
    else:
        print('已从购物车中移除\033[31;1m%s\033[0m' % l2[s-1])
        global money
        money += product[l2[s-1]]
        del l2[s-1]

product = {
    '电脑': 5000,
    '手机': 3000,
    '鼠标垫': 30,
    '键盘': 300,
    '相机': 10000
}
l1 = [i for i in product]
func = ['购物', '充值', '查看购物车']
l2 = []

while True:
    print('你的余额：%d' % money)
    for i, v in enumerate(func, 1):
        print(i, v)

    s = isnum('请选择一个功能(按q退出)：', True)
    if s == 'q':
        break
    elif s > len(func) or not s:
        print('\033[31;1m范围超出，请重新选择！\033[0m')
        continue
    elif s == 1:
        while True:
            if not shopping():
                continue
            else:
                break
    elif s == 2:
        deposit()
    elif s == 3:
        while True:
            if shopcart():
                break
            else:
                continue

字典

字典是python中唯一的映射类型。字典的对象是可变的，但是字典的键必须使用不可变对象。一个字典中可以使用不同的键值。字典的每个元素都是元组键值对。

字典就是一个key对应一个或多个值，但是key不能重复，字典同样是可变的。而列表中的数据是可以重复的。如果key相同，后面的会覆盖之前的，key对应的Value可以是列表、元组、字典等基本上任意的数据类型。需要注意的是，字典是无序的，因为字典没有索引，只能通过key来引用其数据。

字典在其他变成语言中又称为关联数组或散列表。

只有可哈希的对象才能当作键，因为字典的查找方式是将键作为哈希表进行查找的，这样查看速度是最快的。

字典本身是不可哈希的，不能把字典本身当作键，不过可以把字典当值。当字典嵌套字典时，可以当内部字典当作值。

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢；第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如'Michael'，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。

你可以猜到，这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

  1. 查找和插入的速度极快，不会随着key的增加而变慢；
  2. 需要占用大量的内存，内存浪费多。

而list相反：

  1. 查找和插入的时间随着元素的增加而增加；
  2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

字典的索引就是它的key，简单使用：

>>> dic = {}
>>> dic['x'] = "abc"
>>> dic
{'x': 'abc'}
>>> dic['x'][1]
'b'
>>> dic['x'][1:]
'bc'

定义字典：

DicName = {
    'key1' : "value1",
    'key2' : 'value2'
}
Contacs = {
    'Alex' : '13825698457',
    'Rachel Chan' :
    '154824' :
    'Rain Wang':
}

使用：

Contacts = {
    '3951' : ['Alex','IT','SA'],
    '4092' : ['Jack','HR','HR'],
    '5122' : ['Tom','Sales','SecurityGuard']
}
print Contacts['5122'] # 打印key对应的值
Contacts['5122'][2] = 'Cleaner' # 将'SecurityGuard'改成cleaner，[2]是列表的索引
Contacts['5122'] = ['a','b','c'] # 将整个key的值都改掉，这是在值并不多的情况下
print Contacts['5122']

往字典中添加k/v：

Contacts['name'] = 'Tom' # 如果key存在就覆盖，不存在就添加

字典循环

循环字典法一：

for i in Contacts:
    print i,Contacts[i]

循环法二：

for k,v in Contacts.items():
    print k,v

法二的缺点在于循环时会先将字典转换成列表，当字典中数据量非常大时，这种方法会慢。因此量多时用法一，量少时可以使用法二。

字典方法

  • clear：清空整个字典让其为空，要删除使用del。
  • copy：复制一个副本，让源字典或复制的字典发生改变时，都不会影响到对方。复制有深copy和浅copy之分，深cp会直接在内存中划分一段空间，当一个字典非常大时，会很吃内存；而浅复制则是让两个字典引用的内存地址完全相同，这样一个字典修改了，另一个字典同样会发生改变，如dict1 = dict2就是浅复制。
  • fromkeys：dict.fromkeys(S[,v])。S是序列，也就是使用序列当key，v当值。值如果不指定，默认为none。适用于key都相等的情况。
>>> dic1
{'a': 10, 'b': 20}
>>> dic1.fromkeys('abc')
{'a': None, 'c': None, 'b': None}
>>> dic1.fromkeys('abc',10)
{'a': 10, 'c': 10, 'b': 10}
>>> dic1.fromkeys(range(4),10)
{0: 10, 1: 10, 2: 10, 3: 10}
  • get：D.get(k[,d])。当我们使用key查询对应的Value时，如果有value就返回value；如果没有默认返回None，但是我们也可以指定返回一个任意值。
>>> b = a.get('1122') # key不存在时
>>> print b
None # 为空
>>> b = a.get('3951')
>>> b
['Alex', 'IT', 'SA']

# 如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
  • has_key：当通过key查询对应的值时，如果不存在会返回False，存在则Ture。python3中没有这个方法，可以使用'xxx' in D.keys进行替代。
  • items：它会将字典中的所有内容显示成一个列表，其中每一个key和其对应的Value会组成列表的一个元素，并且元素本身是元组。
>>> dict1 = {'a': 111,'b': 222}
>>> dict1
{'a': 111, 'b': 222}
>>> dict1.items()
[('a', 111), ('b', 222)]

>>> t1,t2 = dict1.items() # 这是变量解包
>>> t1
('a', 111)
>>> t2
('b', 222)
  • iteritems：迭代器，返回的是键值对。迭代器一般用来处理大数据的。
  • iterkeys：迭代器，这个返回的是key。
  • itervalues：迭代器，返回的是值。
  • keys：打印所有key。
>>> a.keys()
['4092', '3951', '5122']
  • pop：将指定的key删除。
>>> a.pop('4092')
['Jack', 'HR', 'HR'] # 这些都被删除了
>>> a.keys() # 剩余的key
['3951', '5122']
  • popitem：删除1个key及对应的值，慎用！因为字典是无序的，说不定把不该删的给删了。
>>> a.popitem() # 删除了一个key
('3951', ['Tom', 'IT', 'SA'])
  • setdefault：可以给其传key这一个参数，也可以传key和Value这两个参数。传一个参数时，如果字典中不存在传递的key，那么就会往字典中添加这个key，并将其赋值为none，当字典中有这个key时，那就啥事不干；如果同时传递k/v两个参数时，如果key不存在时，就添加key，并赋值Value。它可以保护字典中的数据。
>>> c = {}
>>> c
{}
>>> c.setdefault('name')
>>> c
{'name': None}
>>> c.setdefault('name','Alex')
>>> c
{'name': None}
>>> c.setdefault('age','22')
'22'
>>> c
{'age': '22', 'name': None}
  • update：D.update([E, ]**F) -> None。将ab两个字典合并。如果ab中有key相同时，后面会覆盖前面的。
  • values：显示所有的值，这在所有Value都表示同一种数值时有用，如Value都是身高，可以将其取出来后，做统计、分布之类的。
  • viewitems：以集合的方式显示k/v。
  • viewkeys：以集合的方式显示key。
  • viewvalues：以集合的方式显示Value。

创建字典的方法

>>> dict(a=10,b=20)
{'a': 10, 'b': 20}

>>> dict([('name','Tom'),('age',20)])
{'age': 20, 'name': 'Tom'}

给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

字典排序：
按照字典value排序，类似于sort -k命令。字典是无序的，字典排序会用到sorted函数，函数的用法在这。

小程序：创建公司员工信息表，员工号、姓名、邮件、部门、职位、手机。提供用户查找接口，通过员工号查询用户信息。

# coding=utf-8
#！/usr/bin/env python

# 如果是员工信息是文件的话
# staff_dic = {} 
# f = file('stu_info.txt')
# for line in f.xread.lines():
#     stu_id,stu_name,mail,company,title,phone = line.split()
#     staff_dic[stu_id] = [stu_name,mail,company,title,phone]
# 
msg = {
    '0001' : ['zhangsan','001@ex.com','shangwu','beiguoxia','121212'],
    '0002' : ['lisi','002@ex.com','jishu','kaifa','213355'],
    '0003' : ['wangwu','003@ex.com','anbao','baoan','323441']
}
while 1:
    query = raw_input('\033[31;1mSearch info: \033[0m').strip()
    if len(query) < 3:
        print '输入的字符串要大于3'
        continue
    count = int(0)
    for i in msg:
        v = msg[i]
        index = i.find(query) # 如果能匹配key
        if index != -1: # 必须要能在key中查到才行
            print i[:index] + '\033[32;1m%s\033[0m' %query + i[len(query) + index:],v # 上色，将查询到的内容高亮
            count += 1
        else:
            str_v = ' '.join(v)
            index = str_v.find(query)
            if index != -1: # 如果能匹配Value
                print i,str_v[:index] + '\033[32;1m%s\033[0m' %query + str_v[len(query) + index:]
                count += 1
    print count # 打印总共匹配的次数

集合

set(集合)。python的set和其他语言类似，是一个无序不重复元素集，基本功能包括关系测试和消除重复元素。集合对象还支持union(联合)， intersection(交)，difference(差)和sysmmetric difference(对称差集)等数学运算。sets支持x in set, len(set)和for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持indexing, slicing或其它类序列（sequence-like）的操作。

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

特性：

无序排列
可哈希
支持成员关系测试in
支持迭代
不可重复
分为可变set()和不可变frozenset()
没有特定语法格式，只能通过工厂函数(set,frozenset)创建；

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以在set中没有重复的key。要创建一个set，需要提供一个list作为输入集合：

>>> s3 = set('xyz')
>>> s3
set(['y', 'x', 'z'])

这样添加的字符串都会拆开，如果想要添加一个完整的字符串进去可以使用add方法：

>>> s3.add('abc')
>>> s3
set(['y', 'x', 'z', 'abc'])

因此可以定义一个空集合，然后向其中添加字符串：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。

下面来点简单的小例子说明吧：

>>> x = set('spam')  
>>> y = set(['h','a','m'])  
>>> x, y  
(set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))

再来些小应用：

>>> x & y # 交集  
set(['a', 'm'])  
 
>>> x | y # 并集  
set(['a', 'p', 's', 'h', 'm'])  
  
>>> x - y # 差集  
set(['p', 's'])

记得以前个网友提问怎么去除海量列表里重复元素，用hash来解决也行，只不过感觉在性能上不是很高，用set解决还是很不错的，示例如下：

>>> a = [11,22,33,44,11,22]  
>>> b = set(a)  
>>> b  
set([33, 11, 44, 22])  
>>> c = [i for i in b]  
>>> c  
[33, 11, 44, 22]

很酷吧，几行就可以搞定。

集合用于包含一组无序的对象。要创建集合，可使用set()函数并像下面这样提供一系列的项：

s = set([3,5,9,10]) # 创建一个数值集合  
t = set("Hello") # 创建一个唯一字符的集合

与列表和元组不同，集合是无序的，也无法通过数字进行索引。此外，集合中的元素不能重复。例如，如果检查前面代码中t集合的值，结果会是：

>>> t 
set(['H', 'e', 'l', 'o'])  

# 注意只出现了一个'l'

集合支持一系列标准操作，包括并集、交集、差集和对称差集，例如：

a = t | s # t 和 s的并集  
b = t & s # t 和 s的交集  
c = t – s # 求差集（项在t中，但不在s中）  
d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）

基本操作：

t.add('x') # 添加一项  
s.update([10,37,42]) # 在s中添加多项  

# 使用remove()可以删除一项：  
t.remove('H')  
 
# set的长度
len(s)  

# 测试x是否是s的成员
x in s  

# 测试x是否不是s的成员 
x not in s  

# 测试是否s中的每一个元素都在t中
s.issubset(t)  
s <= t  

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

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

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

# 返回一个新的set包含s中有但是t中没有的元素  
s.difference(t)  
s - t  
  
# 返回一个新的set包含s和t中不重复的元素   
s.symmetric_difference(t)  
s ^ t  

# 返回set 's'的一个浅复制   
s.copy()

另外，Set和ImmutableSet两者都支持 set 与 set 之间的比较。两个 sets 在也只有在这种情况下是相等的：每一个 set 中的元素都是另一个中的元素（二者互为subset）。一个 set 比另一个 set 小，只有在第一个 set 是第二个 set 的 subset 时（是一个 subset，但是并不相等）。一个 set 比另一个 set 打，只有在第一个 set 是第二个 set 的 superset 时（是一个 superset，但是并不相等）。

子 set 和相等比较并不产生完整的排序功能。例如：任意两个 sets 都不相等也不互为子 set，因此以下的运算都会返回 False：a<b, a==b, 或者a>b。因此，sets 不提供 cmp 方法。因为 sets 只定义了部分排序功能（subset 关系），list.sort() 方法的输出对于 sets 的列表没有定义。

集合可用的方法：

  • s.discard(x)：如果在 set “s”中存在元素 x, 则删除；
  • s.intersection(x)：返回s和x中同时存在的元素；
  • s.intersection_update(t)：s &= t，等同于返回只保留含有 set “t”中元素的 set “s”
  • s.isdisjoint()
  • s.issubset(x)：如果s是x的一个子集，返回True；
  • s.issuperset(x)：如果s包含x就返回True；
  • s.pop()：删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError；
  • s.remove(x)：从 set “s”中删除元素 x, 如果不存在则引发 KeyError
  • s.symmetric_difference(t)：求对称差。返回所有在s或t中，但又不同时在这两个集合中的元素；
  • s.symmetric_difference_update(t)：等同于s ^= t，返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”
  • s.union(t)：求并集
  • s.update(t)：等同于s |= t，往集合中添加多项
  • s.add(x)：向 set “s”中增加元素 x
  • s.clear()：清空set “s”中的所有元素
  • s.copy()
  • s.difference()：求差集，如a.difference(b)，求a中有的b中没有的
  • s.difference_update(t)：等同于s -= t，返回删除了 set “t”中含有的元素后的 set “s”

请注意：非运算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()将会接受任意 iterable 作为参数。从 2.3.1 版本做的更改：以前所有参数都必须是 sets。

还请注意：这个模块还包含一个 union_update() 方法，它是 update() 方法的一个别名。包含这个方法是为了向后兼容。程序员们应该多使用 update() 方法，因为这个方法也被内置的 set() 和 frozenset() 类型支持。

类型转换

函数 描述
int(x [,base]) 将x转换为一个整数
long(x [,base] ) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象x转换为字符串
repr(x) 将对象x转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式，并返回一个对象
tuple(s) 将序列s转换为一个元组
list(s) 将序列s转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典，d必须是一个序列(key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

16进制字符串转为10进制：

>>> int('12',16)
18
>>> int('0x12',16)
18

10进制转换为16进制：

>>> hex(10)
'0xa'

转换成字串：

>>> str([1,3])
'[1, 3]'
>>> str({2:4})
'{2: 4}'
>>> str(('d','s'))
"('d', 's')"
>>> str(33)
'33'

字串转换成列表：

>>> a = 'abc'
>>> list(a)
['a', 'b', 'c']

转换回字串：

>>> ''.join(list(a))
'abc'

字串和元组之间的转换同列表，使用tuple函数。

字典转换成列表：

>>> dic = {'a':1,'b':2}
>>> dic.items()
[('a', 1), ('b', 2)]

列表转换为字典：

>>> l1
[('a', 1), ('b', 2)]
>>> dict(l1)
{'a': 1, 'b': 2}

但不是所有的列表都能转换成字典，要能一一对应才行。

练习题

列表l1=[0,1,2,3,4,5,6]，列表l2=['Sun','Mon','Tue','Wed','Thu','Fri','Sat']，以第一个列表中的元素为键，以第二列表中的元素为值，生成字典d1：

l1 = [0,1,2,3,4,5,6]
l2 = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']

d2 = {}
count = 0
if len(l1) == len(l2):
    while count < len(l1):
        d1[l1[count]] = l2[count]
        count += 1
print d2
posted @ 2016-10-19 14:21  陈顺吉  阅读(480)  评论(0)    收藏  举报