python面试大全

时间 2019-11-11

标签 python 面试大全栏目 Python 繁體版

原文原文链接

问题一：如下的代码的输出将是什么? 说出你的答案并解释。html

class Parent(object):前端

x = 1java

class Child1(Parent):python

passgit

class Child2(Parent):程序员

passgithub

print Parent.x, Child1.x, Child2.xweb

Child1.x = 2面试

print Parent.x, Child1.x, Child2.x正则表达式

Parent.x = 3

print Parent.x, Child1.x, Child2.x

答案

以上代码的输出是：

1 1 1

1 2 1

3 2 3

使你困惑或是惊奇的是关于最后一行的输出是 3 2 3 而不是 3 2 1。为何改变了 Parent.x 的值还会改变 Child2.x 的值，可是同时 Child1.x 值却没有改变？

这个答案的关键是，在 Python 中，类变量在内部是做为字典处理的。若是一个变量的名字没有在当前类的字典中发现，将搜索祖先类（好比父类）直到被引用的变量名被找到（若是这个被引用的变量名既没有在本身所在的类又没有在祖先类中找到，会引起一个 AttributeError 异常）。

所以，在父类中设置 x = 1 会使得类变量 X 在引用该类和其任何子类中的值为 1。这就是由于第一个 print 语句的输出是 1 1 1。

随后，若是任何它的子类重写了该值（例如，咱们执行语句 Child1.x = 2），而后，该值仅仅在子类中被改变。这就是为何第二个 print 语句的输出是 1 2 1。

最后，若是该值在父类中被改变（例如，咱们执行语句 Parent.x = 3），这个改变会影响到任何未重写该值的子类当中的值（在这个示例中被影响的子类是 Child2）。这就是为何第三个 print 输出是 3 2 3。

问题二：如下的代码的输出将是什么? 说出你的答案并解释？

def div1(x,y):

print("%s/%s = %s" % (x, y, x/y))

def div2(x,y):

print("%s//%s = %s" % (x, y, x//y))

div1(5,2)

div1(5.,2)

div2(5,2)

div2(5.,2.)

答案

这个答案实际依赖于你使用的是 Python 2 仍是 Python 3。

在 Python 3 中，指望的输出是：

5/2 = 2.5

5.0/2 = 2.5

5//2 = 2

5.0//2.0 = 2.0

在 Python 2 中，尽管如此，以上代码的输出将是：

5/2 = 2

5.0/2 = 2.5

5//2 = 2

5.0//2.0 = 2.0

默认，若是两个操做数都是整数，Python 2 自动执行整型计算。结果，5/2 值为 2，然而 5./2 值为 ```2.5``。

注意，尽管如此，你能够在 Python 2 中重载这一行为（好比达到你想在 Python 3 中的一样结果），经过添加如下导入：

from __future__ import division

也须要注意的是“双划线”（//）操做符将一直执行整除，而无论操做数的类型，这就是为何 5.0//2.0 值为 2.0。

注：在 Python 3 中，/ 操做符是作浮点除法，而 // 是作整除（即商没有余数，好比 10 // 3 其结果就为 3，余数会被截除掉，而 (-7) // 3 的结果倒是 -3。这个算法与其它不少编程语言不同，须要注意，它们的整除运算会向0的方向取值。而在 Python 2 中，/ 就是整除，即和 Python 3 中的 // 操做符同样，）

问题三：如下代码将输出什么?

list = ['a', 'b', 'c', 'd', 'e']

print list[10:]

答案

以上代码将输出 []，而且不会致使一个 IndexError。

正如人们所指望的，试图访问一个超过列表索引值的成员将致使 IndexError（好比访问以上列表的 list[10]）。尽管如此，试图访问一个列表的以超出列表成员数做为开始索引的切片将不会致使 IndexError，而且将仅仅返回一个空列表。

一个讨厌的小问题是它会致使出现 bug ，而且这个问题是难以追踪的，由于它在运行时不会引起错误。

问题四：如下的代码的输出将是什么? 说出你的答案并解释？

def multipliers():

return [lambda x : i * x for i in range(4)]

print [m(2) for m in multipliers()]

你将如何修改 multipliers 的定义来产生指望的结果

答案

以上代码的输出是 [6, 6, 6, 6] （而不是 [0, 2, 4, 6]）。

这个的缘由是 Python 的闭包的后期绑定致使的 late binding，这意味着在闭包中的变量是在内部函数被调用的时候被查找。因此结果是，当任何 multipliers() 返回的函数被调用，在那时，i 的值是在它被调用时的周围做用域中查找，到那时，不管哪一个返回的函数被调用，for 循环都已经完成了，i 最后的值是 3，所以，每一个返回的函数 multiplies 的值都是 3。所以一个等于 2 的值被传递进以上代码，它们将返回一个值 6 （好比： 3 x 2）。

（顺便说下，正如在 The Hitchhiker’s Guide to Python 中指出的，这里有一点广泛的误解，是关于 lambda 表达式的一些东西。一个 lambda 表达式建立的函数不是特殊的，和使用一个普通的 def 建立的函数展现的表现是同样的。）

这里有两种方法解决这个问题。

最广泛的解决方案是建立一个闭包，经过使用默认参数当即绑定它的参数。例如：

def multipliers():

return [lambda x, i=i : i * x for i in range(4)]

另一个选择是，你能够使用 functools.partial 函数：

from functools import partial

from operator import mul

def multipliers():

return [partial(mul, i) for i in range(4)]

问题五：如下的代码的输出将是什么? 说出你的答案并解释？

def extendList(val, list=[]):

list.append(val)

return list

list1 = extendList(10)

list2 = extendList(123,[])

list3 = extendList('a')

print "list1 = %s" % list1

print "list2 = %s" % list2

print "list3 = %s" % list3

你将如何修改 extendList 的定义来产生指望的结果

以上代码的输出为：

list1 = [10, 'a']

list2 = [123]

list3 = [10, 'a']

许多人会错误的认为 list1 应该等于 [10] 以及 list3 应该等于 ['a']。认为 list 的参数会在 extendList 每次被调用的时候会被设置成它的默认值 []。

尽管如此，实际发生的事情是，新的默认列表仅仅只在函数被定义时建立一次。随后当 extendList 没有被指定的列表参数调用的时候，其使用的是同一个列表。这就是为何当函数被定义的时候，表达式是用默认参数被计算，而不是它被调用的时候。

所以，list1 和 list3 是操做的相同的列表。而 ````list2是操做的它建立的独立的列表（经过传递它本身的空列表做为list``` 参数的值）。

extendList 函数的定义能够作以下修改，但，当没有新的 list 参数被指定的时候，会老是开始一个新列表，这更加多是一直指望的行为。

def extendList(val, list=None):

if list is None:

list = []

list.append(val)

return list

使用这个改进的实现，输出将是：

list1 = [10]

list2 = [123]

list3 = ['a']

最近，整理了一些Python常见的面试题目，语言是一种工具，可是多角度的了解工具能帮助咱们更好的工做。

从不少国内网站以及一些国外论坛翻译过来的，虽然本文标注为"原创"，可是仅仅是本身平常整理的材料，文章后面会附上参考来源。

第一部分：

简易/中等

什么是Python装饰器，如何使用？

你会如何设置不少项目，其中每个使用Python的不一样版本和第三方库？

什么是PEP8和你是如何遵循它的规范？

参数是如何传递的 - 传值仍是传引用？（容易，但又不那么容易，不肯定是否能清楚地回答这个问题）

什么是列表解析、字典解析？举个例子

请用三种不一样的方法完成"提取列表中每三个项目"？

你知道列表和元组之间的区别么？举个例子？

你知道range和xrange之间的区别？针对python2.x版本

谈谈Python2.x和3.x之间的一些区别？

with语句及其用法?

如何避免对模块或方法的重复import？

为何GIL重要？

什么是“特殊方法"（如<foo>）？它们如何工做的？

python中什么是一级对象(first-class objects)？如何将函数做为一级对象操纵呢？

"class Foo" 和 "class Foo(object)"之间的区别？

棘手的

Python中，如何读取大小为8GB的文件？ (即python如何读取大文件)

你为什么喜欢Python，又有哪些不喜欢的部分？

不能借助内置方法如string.atoi或者int()，可否将ASCII字符转换为整数？

主观的

你用制表符仍是空格，哪些是更好？

其余：(不断扩充.......本身整理......)

列表与元组的区别是什么.分别在什么状况下使用？

谈谈你用过的Python库？

对Python中装饰器的认识？

Python中文件/模块/包之间的关系？包文件夹下__init__.py做用是什么？

Python是如何进行内存管理的？

第二部分：基本数据结构

第三部分：

下面的题目看看便可。。。

1：Python如何实现单例模式？请参考:http://blog.csdn.Net/ghostfromheaven/article/details/7671853

2：什么是lambda函数？

Python容许你定义一种单行的小函数。定义lambda函数的形式以下：labmda 参数：表达式lambda函数默认返回表达式的值。你也能够将其赋值给一个变量。lambda函数能够接受任意个参数，包括可选参数，可是表达式只有一个：
>>> g = lambda x, y: x*y
>>> g(3,4)
12
>>> g = lambda x, y=0, z=0: x+y+z
>>> g(1)
1
>>> g(3, 4, 7)
14
也可以直接使用lambda函数，不把它赋值给变量：
>>> (lambda x,y=0,z=0:x+y+z)(3,5,6)
14
若是你的函数很是简单，只有一个表达式，不包含命令，能够考虑lambda函数。不然，你仍是定义函数才对，毕竟函数没有这么多限制。

3：Python是如何进行类型转换的？

Python提供了将变量或值从一种类型转换成另外一种类型的内置函数。int函数可以将符合数学格式数字型字符串转换成整数。不然，返回错误信息。
>>> int(”34″)
34
>>> int(”1234ab”) #不能转换成整数
ValueError: invalid literal for int(): 1234ab
函数int也可以把浮点数转换成整数，但浮点数的小数部分被截去。
>>> int(34.1234)
34
>>> int(-2.46)
-2
函数°oat将整数和字符串转换成浮点数：
>>> float(”12″)
12.0
>>> float(”1.111111″)
1.111111
函数str将数字转换成字符：
>>> str(98)
‘98′
>>> str(”76.765″)
‘76.765′
整数1和浮点数1.0在python中是不一样的。虽然它们的值相等的，但却属于不一样的类型。这两个数在计算机的存储形式也是不同。

4：Python如何定义一个函数

函数的定义形式如
下：
def <name>(arg1, arg2,… argN):
< statements>
函数的名字也必须以字母开头，能够包括下划线“ ”,但不能把Python的
关键字定义成函数的名字。函数内的语句数量是任意的，每一个语句至少有
一个空格的缩进，以表示此语句属于这个函数的。缩进结束的地方，函数
天然结束。
下面定义了一个两个数相加的函数：
>>> def add(p1, p2):
print p1, “+”, p2, “=”, p1+p2
>>> add(1, 2)
1 + 2 = 3
函数的目的是把一些复杂的操做隐藏，来简化程序的结构，使其容易
阅读。函数在调用前，必须先定义。也能够在一个函数内部定义函数，内
部函数只有在外部函数调用时才可以被执行。程序调用函数时，转到函数
内部执行函数内部的语句，函数执行完毕后，返回到它离开程序的地方，
执行程序的下一条语句。

5：Python是如何进行内存管理的？

Python的内存管理是由Python得解释器负责的，开发人员能够从内存管理事务中解放出来，致力于应用程序的开发，这样就使得开发的程序错误更少，程序更健壮，开发周期更短

6：如何反序的迭代一个序列？how do I iterate over a sequence in reverse order

若是是一个list, 最快的解决方案是：

list.reverse()
try:
for x in list:
“do something with x”
finally:
list.reverse()

若是不是list, 最通用可是稍慢的解决方案是：

for i in range(len(sequence)-1, -1, -1):
x = sequence[i]
< do something with x>

7：Python里面如何实现tuple和list的转换？

函数tuple(seq)能够把全部可迭代的(iterable)序列转换成一个tuple, 元素不变，排序也不变。

例如，tuple([1,2,3])返回(1,2,3), tuple(’abc’)返回(’a’.’b',’c').若是参数已是一个tuple的话，函数不作任何拷贝而直接返回原来的对象，因此在不肯定对象是否是tuple的时候来调用tuple()函数也不是很耗费的。

函数list(seq)能够把全部的序列和可迭代的对象转换成一个list,元素不变，排序也不变。

例如 list([1,2,3])返回(1,2,3), list(’abc’)返回['a', 'b', 'c']。若是参数是一个list, 她会像set[:]同样作一个拷贝

8：Python面试题：请写出一段Python代码实现删除一个list里面的重复元素

能够先把list从新排序，而后从list的最后开始扫描，代码以下：

if List:
List.sort()
last = List[-1]
for i in range(len(List)-2, -1, -1):
if last==List[i]: del List[i]
else: last=List[i]

9：Python文件操做的面试题

1. 如何用Python删除一个文件？
使用os.remove(filename)或者os.unlink(filename);

2. Python如何copy一个文件？
shutil模块有一个copyfile函数能够实现文件拷贝

10：Python里面如何生成随机数？

标准库random实现了一个随机数生成器，实例代码以下：

import random

random.random()

它会返回一个随机的0和1之间的浮点数

11：如何用Python来发送邮件？

能够使用smtplib标准库。

如下代码能够在支持SMTP监听器的服务器上执行。

import sys, smtplib

fromaddr = raw_input(”From: “)
toaddrs = raw_input(”To: “).split(’,')
print “Enter message, end with ^D:”
msg = ”
while 1:
line = sys.stdin.readline()
if not line:
break
msg = msg + line

# 发送邮件部分
server = smtplib.SMTP(’localhost’)
server.sendmail(fromaddr, toaddrs, msg)
server.quit()

12：Python里面如何拷贝一个对象？

通常来讲能够使用copy.copy()方法或者copy.deepcopy()方法，几乎全部的对象均可以被拷贝

一些对象能够更容易的拷贝，Dictionaries有一个copy方法：

newdict = olddict.copy()

13：有没有一个工具能够帮助查找python的bug和进行静态的代码分析？

有，PyChecker是一个python代码的静态分析工具，它能够帮助查找python代码的bug, 会对代码的复杂度和格式提出警告

Pylint是另一个工具能够进行coding standard检查。

14：如何在一个function里面设置一个全局的变量？

解决方法是在function的开始插入一个global声明：

def f()

global x

14：有两个序列a,b，大小都为n,序列元素的值任意整形数，无序；要求：经过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。

1. 将两序列合并为一个序列，并排序，为序列Source

2. 拿出最大元素Big，次大的元素Small

3. 在余下的序列S[:-2]进行平分，获得序列max，min

4. 将Small加到max序列，将Big加大min序列，从新计算新序列和，和大的为max，小的为min。

Python代码

def mean( sorted_list ):

if not sorted_list:

return (([],[]))

big = sorted_list[-1]

small = sorted_list[-2]

big_list, small_list = mean(sorted_list[:-2])

big_list.append(small)

small_list.append(big)

big_list_sum = sum(big_list)

small_list_sum = sum(small_list)

if big_list_sum > small_list_sum:

return ( (big_list, small_list))

else:

return (( small_list, big_list))

tests = [ [1,2,3,4,5,6,700,800],

[10001,10000,100,90,50,1],

range(1, 11),

[12312, 12311, 232, 210, 30, 29, 3, 2, 1, 1]

]

for l in tests:

l.sort()

print “Source List:\t”, l

l1,l2 = mean(l)

print “Result List:\t”, l1, l2

print “Distance:\t”, abs(sum(l1)-sum(l2))

print ‘-*’*40

输出结果

Python代码

Source List: [1, 2, 3, 4, 5, 6, 700, 800]

Result List: [1, 4, 5, 800] [2, 3, 6, 700]

Distance: 99

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 50, 90, 100, 10000, 10001]

Result List: [50, 90, 10000] [1, 100, 10001]

Distance: 38

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

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

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

Distance: 1

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 1, 2, 3, 29, 30, 210, 232, 12311, 12312]

Result List: [1, 3, 29, 232, 12311] [1, 2, 30, 210, 12312]

Distance: 21

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

15：用Python匹配HTML tag的时候，<.*>和<.*?>有什么区别？

当重复匹配一个正则表达式时候，例如<.*>, 当程序执行匹配的时候，会返回最大的匹配值

例如：

import re
s = ‘<html><head><title>Title</title>’
print(re.match(’<.*>’, s).group())

会返回一个匹配<html><head><title>Title</title>而不是<html>

而

import re
s = ‘<html><head><title>Title</title>’
print(re.match(’<.*?>’, s).group())

则会返回<html>

<.*>这种匹配称做贪心匹配 <.*?>称做非贪心匹配

16：Python里面search()和match()的区别？

match（）函数只检测RE是否是在string的开始位置匹配， search()会扫描整个string查找匹配, 也就是说match（）只有在0位置匹配成功的话才有返回，若是不是开始位置匹配成功的话，match()就返回none

例如：

print(re.match(’super’, ’superstition’).span())会返回(0, 5)
而print(re.match(’super’, ‘insuperable’))则返回None

search()会扫描整个字符串并返回第一个成功的匹配

例如：print(re.search(’super’, ’superstition’).span())返回(0, 5)

print(re.search(’super’, ‘insuperable’).span())返回(2, 7)

17：如何用Python来进行查询和替换一个文本字符串？

能够使用sub()方法来进行查询和替换，sub方法的格式为：sub(replacement, string[, count=0])

replacement是被替换成的文本

string是须要被替换的文本

count是一个可选参数，指最大被替换的数量

例子：

import re
p = re.compile(’(blue|white|red)’)
print(p.sub(’colour’,'blue socks and red shoes’))
print(p.sub(’colour’,'blue socks and red shoes’, count=1))

输出：

colour socks and colour shoes
colour socks and red shoes

subn()方法执行的效果跟sub()同样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量

例如：

import re
p = re.compile(’(blue|white|red)’)
print(p.subn(’colour’,'blue socks and red shoes’))
print(p.subn(’colour’,'blue socks and red shoes’, count=1))

输出

(’colour socks and colour shoes’, 2)
(’colour socks and red shoes’, 1)

18：介绍一下except的用法和做用？

Python的except用来捕获全部异常，由于Python里面的每次错误都会抛出一个异常，因此每一个程序的错误都被看成一个运行时错误。

一下是使用except的一个例子：

try:

foo = opne(”file”) #open被错写为opne

except:

sys.exit(”could not open file!”)

由于这个错误是因为open被拼写成opne而形成的，而后被except捕获，因此debug程序的时候很容易不知道出了什么问题

下面这个例子更好点：

try:
foo = opne(”file”) # 这时候except只捕获IOError
except IOError:
sys.exit(”could not open file”)

19：Python中pass语句的做用是什么？

pass语句什么也不作，通常做为占位符或者建立占位程序，pass语句不会执行任何操做，好比：

while False:

pass

pass一般用来建立一个最简单的类：

class MyEmptyClass:

pass

pass在软件设计阶段也常常用来做为TODO，提醒实现相应的实现，好比：

def initlog(*args):

pass #please implement this

20：介绍一下Python下range()函数的用法？

若是须要迭代一个数字序列的话，能够使用range()函数，range()函数能够生成等差级数。

如例：

for i in range(5)

print(i)

这段代码将输出0, 1, 2, 3, 4五个数字

range(10)会产生10个值，也可让range()从另一个数字开始，或者定义一个不一样的增量，甚至是负数增量

range(5, 10)从5到9的五个数字

range(0, 10, 3) 增量为三，包括0,3,6,9四个数字

range(-10, -100, -30) 增量为-30，包括-10, -40, -70

能够一块儿使用range()和len()来迭代一个索引序列

例如：

a = ['Nina', 'Jim', 'Rainman', 'Hello']

for i in range(len(a)):

print(i, a[i])

1. 如何用Python删除一个文件?
使用os.remove(filename)或者os.unlink(filename);

2. Python如何copy一个文件?
shutil模块有一个copyfile函数能够实现文件拷贝

1. 如何用Python删除一个文件?
使用os.remove(filename)或者os.unlink(filename);
2. Python如何copy一个文件?
shutil模块有一个copyfile函数能够实现文件拷贝

3. python程序中文输出问题怎么解决?

方法一：
用encode和decode
如：
import os.path
import xlrd,sys
Filename=’/home/tom/Desktop/1234.xls’
if not os.path.isfile(Filename):
raise NameError,”%s is not a valid filename”%Filename
bk=xlrd.open_workbook(Filename)
shxrange=range(bk.nsheets)
print shxrange
for x in shxrange:
p=bk.sheets()[x].name.encode(‘utf-8′)
print p.decode(‘utf-8′)方法二：
在文件开头加上
reload(sys)
sys.setdefaultencoding(‘utf8′)这2行，再试着运行一下

Python里面如何实现tuple和list的转换?

函数tuple(seq)能够把全部可迭代的(iterable)序列转换成一个tuple, 元素不变，排序也不变。例如，tuple([1,2,3])返回(1,2,3), tuple(‘abc’)返回(‘a’.'b’,'c’).若是参数已是一个tuple的话，函数不作任何拷贝而直接返回原来的对象，因此在不肯定对象是否是tuple的时候来调用tuple()函数也不是很耗费的。函数list(seq)能够把全部的序列和可迭代的对象转换成一个list,元素不变，排序也不变。例如 list([1,2,3])返回(1,2,3), list(‘abc’)返回['a', 'b', 'c']。若是参数是一个list, 她会像set[:]同样作一个拷贝

如何反序的迭代一个序列?how do I iterate over a sequence in reverse order

若是是一个list, 最快的解决方案是：
list.reverse()
try:
for x in list:
“do something with x”
finally:
list.reverse()

若是不是list, 最通用可是稍慢的解决方案是：
for i in range(len(sequence)-1, -1, -1):
x = sequence[i]

Python是如何进行类型转换的?

Python提供了将变量或值从一种类型转换成另外一种类型的内置函数。int函数可以将符合数学格式数字型字符串转换成整数。不然，返回错误信息。
>>> int(“34″)
34
>>> int(“1234ab”) #不能转换成整数
ValueError: invalid literal for int(): 1234ab
函数int也可以把浮点数转换成整数，但浮点数的小数部分被截去。
>>> int(34.1234)
34
>>> int(-2.46)
-2
函数°oat将整数和字符串转换成浮点数：
>>> float(“12″)
12.0
>>> float(“1.111111″)
1.111111
函数str将数字转换成字符：
>>> str(98)
’98′
>>> str(“76.765″)
’76.765′
整数1和浮点数1.0在python中是不一样的。虽然它们的值相等的，但却属于不一样的类型。这两个数在计算机的存储形式也是不同。

用Python匹配HTML tag的时候，<.*>和<.*?>有什么区别?

当重复匹配一个正则表达式时候，例如, 当程序执行匹配的时候，会返回最大的匹配值

例如：
import re
s = ‘Title’
print(re.match(‘’, s).group())会返回一个匹配Title而不是、

import re
s = ‘Title’
print(re.match(‘’, s).group())则会返回这种匹配称做贪心匹配称做非贪心匹配

Python的两道面试题

有没有一个工具能够帮助查找python的bug和进行静态的代码分析?有，PyChecker是一个python代码的静态分析工具，它能够帮助查找python代码的bug, 会对代码的复杂度和格式提出警告
Pylint是另一个工具能够进行coding standard检查。
2. 如何在一个function里面设置一个全局的变量?解决方法是在function的开始插入一个global声明：
def f()
global x

请用Python写一个获取用户输入数字，并根据数字大小输出不一样信息的脚本

代码以下(Python 3.0 下调试经过)
x = int(input(“Please enter an integer:”))
if x < 0:
x = 0
print (‘Negative changed to zero’)
elif x == 0:
print (‘Zero’)
elif x == 1:
print (‘Single’)
else:
print (‘More’)

Python面试题：Python里面如何生成随机数?

标准库random实现了一个随机数生成器，实例代码以下：
import random
random.random()

它会返回一个随机的0和1之间的浮点数

华为python面试题

有两个序列a,b，大小都为n,序列元素的值任意整形数，无序；
要求：经过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
有两个序列a,b，大小都为n,序列元素的值任意整形数，无序；

要求：经过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。

1. 将两序列合并为一个序列，并排序，为序列Source

2. 拿出最大元素Big，次大的元素Small

3. 在余下的序列S[:-2]进行平分，获得序列max，min

4. 将Small加到max序列，将Big加大min序列，从新计算新序列和，和大的为max，小的为min。
Python代码
def mean( sorted_list ):
if not sorted_list:
return (([],[]))
big = sorted_list[-1]
small = sorted_list[-2]
big_list, small_list = mean(sorted_list[:-2])
big_list.append(small)
small_list.append(big)
big_list_sum = sum(big_list)
small_list_sum = sum(small_list)
if big_list_sum > small_list_sum:
return ( (big_list, small_list))
else:
return (( small_list, big_list))
tests = [ [1,2,3,4,5,6,700,800],
[10001,10000,100,90,50,1],
range(1, 11),
[12312, 12311, 232, 210, 30, 29, 3, 2, 1, 1]]
for l in tests:
l.sort()
print
print “Source List:\t”, l
l1,l2 = mean(l)
print “Result List:\t”, l1, l2
print “Distance:\t”, abs(sum(l1)-sum(l2))
print ‘-*’*40输出结果
Python代码
Source List: [1, 2, 3, 4, 5, 6, 700, 800]
Result List: [1, 4, 5, 800] [2, 3, 6, 700]
Distance: 99
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Source List: [1, 50, 90, 100, 10000, 10001]
Result List: [50, 90, 10000] [1, 100, 10001]
Distance: 38
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Source List: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Result List: [2, 3, 6, 7, 10] [1, 4, 5, 8, 9]
Distance: 1
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Source List: [1, 1, 2, 3, 29, 30, 210, 232, 12311, 12312]
Result List: [1, 3, 29, 232, 12311] [1, 2, 30, 210, 12312]
Distance: 21
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

1 Python的函数参数传递

看两个例子:

a = 1

def fun(a):

a = 2

fun(a)

print a # 1

a = []

def fun(a):

a.append(1)

fun(a)

print a # [1]

全部的变量均可以理解是内存中一个对象的“引用”，或者，也能够看似c中void*的感受。

这里记住的是类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是能够修改的对象。(这就是这个问题的重点)

当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了.因此第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感受.而第二个例子就不同了,函数内的引用指向的是可变对象,对它的操做就和定位了指针地址同样,在内存里进行修改.

若是还不明白的话,这里有更好的解释: http://stackoverflow.com/questions/986006/how-do-i-pass-a-variable-by-reference14

2 Python中的元类(metaclass)

这个很是的不经常使用,可是像ORM这种复杂的结构仍是会须要的,详情请看:http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python

3 @staticmethod和@classmethod

Python其实有3个方法,即静态方法(staticmethod),类方法(classmethod)和实例方法,以下:

def foo(x):

print "executing foo(%s)"%(x)

class A(object):

def foo(self,x):

print "executing foo(%s,%s)"%(self,x)

@classmethod

def class_foo(cls,x):

print "executing class_foo(%s,%s)"%(cls,x)

@staticmethod

def static_foo(x):

print "executing static_foo(%s)"%x

a=A()

这里先理解下函数参数里面的self和cls.这个self和cls是对类或者实例的绑定,对于通常的函数来讲咱们能够这么调用foo(x),这个函数就是最经常使用的,它的工做跟任何东西(类,实例)无关.对于实例方法,咱们知道在类里每次定义方法的时候都须要绑定这个实例,就是foo(self, x),为何要这么作呢?由于实例方法的调用离不开实例,咱们须要把实例本身传给函数,调用的时候是这样的a.foo(x)(实际上是foo(a, x)).类方法同样,只不过它传递的是类而不是实例,A.class_foo(x).注意这里的self和cls能够替换别的参数,可是python的约定是这俩,仍是不要改的好.

对于静态方法其实和普通的方法同样,不须要对谁进行绑定,惟一的区别是调用的时候须要使用a.static_foo(x)或者A.static_foo(x)来调用.

|\|实例方法|类方法|静态方法|
|:--|:--|:--|:--|
|a = A()|a.foo(x)|a.class_foo(x)|a.static_foo(x)|
|A|不可用|A.class_foo(x)|A.static_foo(x)|

4 类变量和实例变量

class Person:

name="aaa"

p1=Person()

p2=Person()

p1.name="bbb"

print p1.name # bbb

print p2.name # aaa

print Person.name # aaa

类变量就是供类使用的变量,实例变量就是供实例使用的.

这里p1.name="bbb"是实例调用了类变量,这其实和上面第一个问题同样,就是函数传参的问题,p1.name一开始是指向的类变量name="aaa",可是在实例的做用域里把类变量的引用改变了,就变成了一个实例变量,self.name再也不引用Person的类变量name了.

能够看看下面的例子:

class Person:

name=[]

p1=Person()

p2=Person()

p1.name.append(1)

print p1.name # [1]

print p2.name # [1]

print Person.name # [1]

参考:http://stackoverflow.com/questions/6470428/catch-multiple-exceptions-in-one-line-except-block

5 Python自省

这个也是python彪悍的特性.

自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时可以得到对象的类型.好比type(),dir(),getattr(),hasattr(),isinstance().

6 字典推导式

可能你见过列表推导时,却没有见过字典推导式,在2.7中才加入的:

d = {key: value for (key, value) in iterable}

7 Python中单下划线和双下划线

>>> class MyClass():

... def __init__(self):

... self.__superprivate = "Hello"

... self._semiprivate = ", world!"

...

>>> mc = MyClass()

>>> print mc.__superprivate

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: myClass instance has no attribute '__superprivate'

>>> print mc._semiprivate

, world!

>>> print mc.__dict__

{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

__foo__:一种约定,Python内部的名字,用来区别其余用户自定义的命名,以防冲突.

_foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.

__foo:这个有真正的意义:解析器用_classname__foo来代替这个名字,以区别和其余类相同的命名.

详情见:http://stackoverflow.com/questions/1301346/the-meaning-of-a-single-and-a-double-underscore-before-an-object-name-in-python

或者: http://www.zhihu.com/question/197549413

8 字符串格式化:%和.format

.format在许多方面看起来更便利.对于%最烦人的是它没法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:

"hi there %s" % name

可是,若是name刚好是(1,2,3),它将会抛出一个TypeError异常.为了保证它老是正确的,你必须这样作:

"hi there %s" % (name,) # 提供一个单元素的数组而不是一个参数

可是有点丑..format就没有这些问题.你给的第二个问题也是这样,.format好看多了.

你为何不用它?

不知道它(在读这个以前)

为了和Python2.5兼容(譬如logging库建议使用%(issue #4))

stackoverflow.com 6

Python string formatting: % vs. .format

asked by NorthIsUp on 06:46PM - 22 Feb 11

python, performance, logging, string-formatting

9 迭代器和生成器

最近打算用Python作分词，在生成字典的时候，我采用的方法是逐个元素处理的方法，结果因为训练语料中的数据量过大，这样处理很慢。因此打算学学迭代器与生成器，看看能不能对序列进行批量处理（这点和matlab有点像）如下内容转载自：http://blog.csdn.net/chszs/archive/2009/01/24/3852669.aspx 把美文本身索罗到博客中来，个人博客就能够成为一个小的资料库了

Python的迭代器和生成器

Iterator是迭代器的意思，它的做用是一次产生一个数据项，直到没有为止。这样在 for 循环中就能够对它进行循环处理了。那么它与通常的序列类型(list, tuple等)有什么区别呢？它一次只返回一个数据项，占用更少的内存。但它须要记住当前的状态，以便返回下一数据项。它是一个有着next()方法的对象。而序列类型则保存了全部的数据项，它们的访问是经过索引进行的。

1、迭代器Iterators
迭代器仅是一容器对象，它实现了迭代器协议。它有两个基本方法：
1）next方法
返回容器的下一个元素
2）__iter__方法
返回迭代器自身

迭代器可以使用内建的iter方法建立，见例子：
>>> i = iter('abc')
>>> i.next()
'a'
>>> i.next()
'b'
>>> i.next()
'c'
>>> i.next()
Traceback (most recent call last):
File "<string>", line 1, in <string>
StopIteration:

class MyIterator(object):
def __init__(self, step):
self.step = step
def next(self):
"""Returns the next element."""
if self.step==0:
raise StopIteration
self.step-=1
return self.step
def __iter__(self):
"""Returns the iterator itself."""
return self
for el in MyIterator(4):
print el
--------------------
结果：
3
2
1
0

2、生成器Generators
从Python2.2起，生成器提供了一种简洁的方式帮助返回列表元素的函数来完成简单和有效的代码。
它基于yield指令，容许中止函数并当即返回结果。
此函数保存其执行上下文，若是须要，可当即继续执行。
例如Fibonacci函数：
def fibonacci():
a,b=0,1
while True:
yield b
a,b = b, a+b
fib=fibonacci()
print fib.next()
print fib.next()
print fib.next()
print [fib.next() for i in range(10)]
--------------------
结果：
1
1
2
[3, 5, 8, 13, 21, 34, 55, 89, 144, 233]

PEP Python Enhancement Proposal Python加强建议

tokenize模块
>>> import tokenize
>>> reader = open('c:/temp/py1.py').next
>>> tokens=tokenize.generate_tokens(reader)
>>> tokens.next()
(1, 'class', (1, 0), (1, 5), 'class MyIterator(object):\n')
>>> tokens.next()
(1, 'MyIterator', (1, 6), (1, 16), 'class MyIterator(object):\n')
>>> tokens.next()
(51, '(', (1, 16), (1, 17), 'class MyIterator(object):\n')

例子：
def power(values):
for value in values:
print 'powering %s' %value
yield value
def adder(values):
for value in values:
print 'adding to %s' %value
if value%2==0:
yield value+3
else:
yield value+2
elements = [1,4,7,9,12,19]
res = adder(power(elements))
print res.next()
print res.next()
--------------------
结果：
powering 1
adding to 1
3
powering 4
adding to 4
7

保持代码简单，而不是数据。
注意：宁肯有大量简单的可迭代函数，也不要一个复杂的一次只计算出一个值的函数。

例子：
def psychologist():
print 'Please tell me your problems'
while True:
answer = (yield)
if answer is not None:
if answer.endswith('?'):
print ("Don't ask yourself too much questions")
elif 'good' in answer:
print "A that's good, go on"
elif 'bad' in answer:
print "Don't be so negative"
free = psychologist()
print free.next()
print free.send('I feel bad')
print free.send("Why I shouldn't ?")
print free.send("ok then i should find what is good for me")
--------------------
结果：
Please tell me your problems
None
Don't be so negative
None
Don't ask yourself too much questions
None
A that's good, go on
None

10 *args and **kwargs

用*args和**kwargs只是为了方便并无强制使用它们.

当你不肯定你的函数里将要传递多少参数时你能够用*args.例如,它能够传递任意数量的参数:

>>> def print_everything(*args):

for count, thing in enumerate(args):

... print '{0}. {1}'.format(count, thing)

...

>>> print_everything('apple', 'banana', 'cabbage')

0. apple

1. banana

2. cabbage

类似的,**kwargs容许你使用没有事先定义的参数名:

>>> def table_things(**kwargs):

... for name, value in kwargs.items():

... print '{0} = {1}'.format(name, value)

...

>>> table_things(apple = 'fruit', cabbage = 'vegetable')

cabbage = vegetable

apple = fruit

你也能够混着用.命名参数首先得到参数值而后全部的其余参数都传递给*args和**kwargs.命名参数在列表的最前端.例如:

def table_things(titlestring, **kwargs)

*args和**kwargs能够同时在函数的定义中,可是*args必须在**kwargs前面.

当调用函数时你也能够用*和**语法.例如:

>>> def print_three_things(a, b, c):

... print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)

...

>>> mylist = ['aardvark', 'baboon', 'cat']

>>> print_three_things(*mylist)

a = aardvark, b = baboon, c = cat

就像你看到的同样,它能够传递列表(或者元组)的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.固然,你也能够在函数定义或者函数调用时用*.

stackoverflow.com

*args and **kwargs?

asked by MacPython on 08:28AM - 03 Aug 10

python, args, kwargs

11 面向切面编程AOP和装饰器

这个AOP一听起来有点懵,同窗面阿里的时候就被问懵了...

装饰器是一个很著名的设计模式，常常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，咱们就能够抽离出大量函数中与函数功能自己无关的雷同代码并继续重用。归纳的讲，装饰器的做用就是为已经存在的对象添加额外的功能。

12 鸭子类型

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就能够被称为鸭子。”

咱们并不关心对象是什么类型，究竟是不是鸭子，只关心行为。

好比在python中，有不少file-like的东西，好比StringIO,GzipFile,socket。它们有不少相同的方法，咱们把它们看成文件使用。

又好比list.extend()方法中,咱们并不关心它的参数是否是list,只要它是可迭代的,因此它的参数能够是list/tuple/dict/字符串/生成器等.

鸭子类型在动态语言中常用，很是灵活，使得python不想java那样专门去弄一大堆的设计模式。

13 Python中重载

函数重载主要是为了解决两个问题。

可变参数类型。

可变参数个数。

另外，一个基本的设计原则是，仅仅当两个函数除了参数类型和参数个数不一样之外，其功能是彻底相同的，此时才使用函数重载，若是两个函数的功能其实不一样，那么不该当使用重载，而应当使用一个名字不一样的函数。

好吧，那么对于状况 1 ，函数功能相同，可是参数类型不一样，python 如何处理？答案是根本不须要处理，由于 python 能够接受任何类型的参数，若是函数的功能相同，那么不一样的参数类型在 python 中极可能是相同的代码，没有必要作成两个不一样函数。

那么对于状况 2 ，函数功能相同，但参数个数不一样，python 如何处理？你们知道，答案就是缺省参数。对那些缺乏的参数设定为缺省参数便可解决问题。由于你假设函数功能相同，那么那些缺乏的参数终归是须要用的。

好了，鉴于状况 1 跟状况 2 都有了解决方案，python 天然就不须要函数重载了。

问题能够了解下(新式类是广度优先,旧式类是深度优先),里讲的也不少.

15 __new__和__init__的区别

这个__new__确实不多见到,先作了解吧.

__new__是一个静态方法,而__init__是一个实例方法.

__new__方法会返回一个建立的实例,而__init__什么都不返回.

只有在__new__返回一个cls的实例时后面的__init__才能被调用.

当建立一个新实例时调用__new__,初始化一个实例时用__init__.

stackoverflow

ps: __metaclass__是建立类时起做用.因此咱们能够分别使用__metaclass__,__new__和__init__来分别在类建立,实例建立和实例初始化的时候作一些小手脚.

16 单例模式

这个绝对常考啊.绝对要记住1~2个方法,当时面试官是让手写的.

1 使用__new__方法

class Singleton(object):

def __new__(cls, *args, **kw):

if not hasattr(cls, '_instance'):

orig = super(Singleton, cls)

cls._instance = orig.__new__(cls, *args, **kw)

return cls._instance

class MyClass(Singleton):

a = 1

2 共享属性

建立实例时把全部实例的__dict__指向同一个字典,这样它们具备相同的属性和方法.

class Borg(object):

_state = {}

def __new__(cls, *args, **kw):

ob = super(Borg, cls).__new__(cls, *args, **kw)

ob.__dict__ = cls._state

return ob

class MyClass2(Borg):

a = 1

3 装饰器版本

def singleton(cls, *args, **kw):

instances = {}

def getinstance():

if cls not in instances:

instances[cls] = cls(*args, **kw)

return instances[cls]

return getinstance

@singleton

class MyClass:

...

4 import方法

做为python的模块是自然的单例模式

# mysingleton.py

class My_Singleton(object):

def foo(self):

pass

my_singleton = My_Singleton()

# to use

from mysingleton import my_singleton

my_singleton.foo()

17 Python中的做用域

Python 中，一个变量的做用域老是由在代码中被赋值的地方所决定的。

当 Python 遇到一个变量的话他会按照这样的顺序进行搜索：

本地做用域（Local）→当前做用域被嵌入的本地做用域（Enclosing locals）→全局/模块做用域（Global）→内置做用域（Built-in）

18 GIL线程全局锁

线程全局锁(Global Interpreter Lock),即Python为了保证线程安全而采起的独立线程运行的限制,说白了就是一个核只能在同一时间运行一个线程.

见Python 最难的问题6

解决办法就是多进程和下面的协程(协程也只是单CPU,可是能减少切换代价提高性能).

19 协程

简单点说协程是进程和线程的升级版,进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间,而协程就是用户本身控制切换的时机,再也不须要陷入系统的内核态.

Python里最多见的yield就是协程的思想!能够查看第九个问题.

20 闭包

闭包(closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构，它一样提升了代码的可重复使用性。

当一个内嵌函数引用其外部做做用域的变量,咱们就会获得一个闭包. 总结一下,建立一个闭包必须知足如下几点:

必须有一个内嵌函数

内嵌函数必须引用外部函数中的变量

外部函数的返回值必须是内嵌函数

感受闭包仍是有难度的,几句话是说不明白的,仍是查查相关资料.

重点是函数运行后并不会被撤销,就像16题的instance字典同样,当函数运行完后,instance并不被销毁,而是继续留在内存空间里.这个功能相似类里的类变量,只不过迁移到了函数上.

闭包就像个空心球同样,你知道外面和里面,但你不知道中间是什么样.

21 lambda函数

其实就是一个匿名函数,为何叫lambda?由于和后面的函数式编程有关.

python 面试题总结

浪漫杀手 2012-10-13 11:27:37

Python面试题：请写出一段Python代码实现删除一个list里面的重复元素：
1、本身的思路：
遍历列表，发现元素不一样，添加到新列表C中。
最后将C列表赋值给原列表
def select(a):
        i=None
        c=[]
        for b in a:
                if i!=b:
                        c.append(b)
                i=b
        a[0:]=c

自我总结：
1.
迭代器的迭代方式（按索引迭代）
for b in c:
  print str(b)
这种迭代方式是按索引来的。
若是在迭代过程当中对原列表进行操做，会产生奇怪的记过。
例子：
>>> c=[1,2,3,4]
>>> for b in c:
        print "before:"+str(b)
        c.remove(b)
        print "after:"+str(b)


before:1
after:1
before:3
after:3
从这个例子能学到：若是在迭代时删除某个元素，会致使列表改变，可是迭代器依旧以原来的索引顺序迭代，这会致使数据错位，引发bug

2.编写循环逻辑注意点：
通常只是简单的for循环是比较简单的，可是若是伴随着相应变量的变动，变量的读取，就会比较容易出错。
2.1怎么减少错误呢？.最简单的方法，画图，一个循环一个图，就比较容易想清楚了。
2.2怎么提升编程能力？特别面对循环时？
首先，是积累，脑子里须要创建一个知识库。（相似的问题该怎么解决）
其次，是在编程时，用到积累的知识须要和环境结合，可能思惟会乱，能够画图
最后，就是概括第二步的思惟，这样就能写出程序了

3.参数传递，与值的改变
若是a引用了一个对象，那么将a传入select函数。在select改变行参的值不影响外界a的值。
只有改变a所指向内存的值，才能改变a的值
4.当对数据进行操做时，须要考虑此操做是否会影响之后的操做。
二：网上比较好的答案：
思路：从后往前，遍历，这样删除元素此也不会影响之后遍历时取值的操做
代码：
def sort_select(a):
        if not a: print 'there is nothing in a'
        else:
                temp = a[-1]
                for i in range(len(a)-2,-1,-1):
                        if a[i]==temp:del a[i]
                        else:temp=a[i]

总结：
range函数的起始于结束：
for i in range(100):
   print str(i)
输出结果：打印从1到99
for i in range(5,-1,-1):
  print str(i)
输出结果：打印从5到0

碰到这种问题的经验：
1.要用循环
2.由于是对列表删除操做，又要遍历整个列表，因此从后往前遍历比较好，就算删除了后面的元素，也不会影响前面元素的顺序
3.首先一个中间值（temp），temp等于该列表的最后一个值。
    将temp与从后往前遍从来的值对比
    若是相等，就删除
    不然就将值赋给temp，一边下次循环比较

简述__new__和__init__的区别

建立一个新实例时调用__new__,初始化一个实例时用__init__,这是它们最本质的区别。

new方法会返回所构造的对象，init则不会.

new函数必须以cls做为第一个参数，而init则以self做为其第一个参数

如何捕获异常，经常使用的异常机制有哪些？

若是咱们没有对异常进行任何预防，那么在程序执行的过程当中发生异常，就会中断程序，调用python默认的异常处理器，并在终端输出异常信息。

try…except…finally语句:当try语句执行时发生异常，回到try语句层，寻找后面是否有except语句。找到except语句后，会调用这个自定义的异常处理器。except将异常处理完毕后，程序继续往下执行。finally语句表示，不管异常发生与否，finally中的语句都要执行。

assert语句：判断assert后面紧跟的语句是True仍是False，若是是True则继续执行print，若是是False则中断程序，调用默认的异常处理器，同时输出assert语句逗号后面的提示信息。

with语句：若是with语句或语句块中发生异常，会调用默认的异常处理器处理，但文件仍是会正常关闭。

1 b 2b 3.b4a5c6a7c

高德软件有限公司python试题及答案

本文地址: http://blog.csdn.net/caroline_wendy/article/details/25230835

by Spike 2014.5.7

本题目仅供学术交流, 严禁用于其余目的, 答案仅供参考.

1. 在Python中, list, tuple, dict, set有什么区别, 主要应用在什么样的场景?

解答:

定义:

list: 链表, 有序的项目, 经过索引进行查找, 使用方括号"[]";

tuple: 元组, 元组将多样的对象集合到一块儿, 不能修改, 经过索引进行查找, 使用括号"()";

dict: 字典, 字典是一组键(key)和值(value)的组合, 经过键(key)进行查找, 没有顺序, 使用大括号"{}";

set: 集合,无序, 元素只出现一次, 自动去重, 使用"set([])";

应用场景:

list, 简单的数据集合, 能够使用索引;

tuple, 把一些数据当作一个总体去使用, 不能修改;

dict, 使用键值和值进行关联的数据;

set, 数据只出现一次, 只关心数据是否出现, 不关心其位置;

代码:

[python] view plain copy print ?

mylist = [1, 2, 3, 4, 'Oh']

mytuple = (1, 2, 'Hello', (4, 5))

mydict = {'Wang' : 1, 'Hu' : 2, 'Liu' : 4}

myset = set(['Wang', 'Hu', 'Liu', 4, 'Wang'])

mylist = [1, 2, 3, 4, 'Oh']

mytuple = (1, 2, 'Hello', (4, 5))

mydict = {'Wang' : 1, 'Hu' : 2, 'Liu' : 4}

myset = set(['Wang', 'Hu', 'Liu', 4, 'Wang'])

2. 静态函数, 类函数, 成员函数的区别?

解答:

定义:

静态函数(@staticmethod): 即静态方法,主要处理与这个类的逻辑关联;

类函数(@classmethod): 即类方法, 更关注于从类中调用方法, 而不是在实例中调用方法, 能够用做方法重载, 传入参数cls;

成员函数: 实例的方法, 只能经过实例进行调用;

具体应用:

日期的方法, 能够经过实例化(__init__)进行数据输出, 传入参数self;

能够经过类的方法(@classmethod)进行数据转换, 传入参数cls;

能够经过静态方法(@staticmethod)进行数据验证;

代码:

[python] view plain copy print ?

# -*- coding: utf-8 -*-

#eclipse pydev, python 3.3

#by C.L.Wang

class Date(object):

day = 0

month = 0

year = 0

def __init__(self, day=0, month=0, year=0):

self.day = day

self.month = month

self.year = year

def display(self):

return "{0}*{1}*{2}".format(self.day, self.month, self.year)

@classmethod

def from_string(cls, date_as_string):

day, month, year = map(int, date_as_string.split('-'))

date1 = cls(day, month, year)

return date1

@staticmethod

def is_date_valid(date_as_string):

day, month, year = map(int, date_as_string.split('-'))

return day <= 31 and month <= 12 and year <= 3999

date1 = Date('12', '11', '2014')

date2 = Date.from_string('11-13-2014')

print(date1.display())

print(date2.display())

print(date2.is_date_valid('11-13-2014'))

print(Date.is_date_valid('11-13-2014'))

# -*- coding: utf-8 -*-

#eclipse pydev, python 3.3

#by C.L.Wang

class Date(object):

day = 0

month = 0

year = 0

def __init__(self, day=0, month=0, year=0):

self.day = day

self.month = month

self.year = year

def display(self):

return "{0}*{1}*{2}".format(self.day, self.month, self.year)

@classmethod

def from_string(cls, date_as_string):

day, month, year = map(int, date_as_string.split('-'))

date1 = cls(day, month, year)

return date1

@staticmethod

def is_date_valid(date_as_string):

day, month, year = map(int, date_as_string.split('-'))

return day <= 31 and month <= 12 and year <= 3999

date1 = Date('12', '11', '2014')

date2 = Date.from_string('11-13-2014')

print(date1.display())

print(date2.display())

print(date2.is_date_valid('11-13-2014'))

print(Date.is_date_valid('11-13-2014'))

3. a=1, b=2, 不用中间变量交换a和b的值

解答:

两种形式: 加法或异或

代码:

[python] view plain copy print ?

a = 1

b = 2

a = a + b

b = a - b

a = a - b

print ('a = {0}, b = {1}'.format(a, b))

a = a ^ b

b = a ^ b

a = a ^ b

print ('a = {0}, b = {1}'.format(a, b))

a = 1

b = 2

a = a + b

b = a - b

a = a - b

print ('a = {0}, b = {1}'.format(a, b))

a = a ^ b

b = a ^ b

a = a ^ b

print ('a = {0}, b = {1}'.format(a, b))

4. 写一个函数, 输入一个字符串, 返回倒序排列的结果: 如: string_reverse(‘abcdef’), 返回: ‘fedcba’

(请采用多种方法实现, 并对实现方法进行比较)

解答:

5种方法的比较:

1. 简单的步长为-1, 即字符串的翻转;

2. 交换先后字母的位置;

3. 递归的方式, 每次输出一个字符;

4. 双端队列, 使用extendleft()函数;

5. 使用for循环, 从左至右输出;

代码:

[python] view plain copy print ?

string = 'abcdef'

def string_reverse1(string):

return string[::-1]

def string_reverse2(string):

t = list(string)

l = len(t)

for i,j in zip(range(l-1, 0, -1), range(l//2)):

t[i], t[j] = t[j], t[i]

return "".join(t)

def string_reverse3(string):

if len(string) <= 1:

return string

return string_reverse3(string[1:]) + string[0]

from collections import deque

def string_reverse4(string):

d = deque()

d.extendleft(string)

return ''.join(d)

def string_reverse5(string):

#return ''.join(string[len(string) - i] for i in range(1, len(string)+1))

return ''.join(string[i] for i in range(len(string)-1, -1, -1))

print(string_reverse1(string))

print(string_reverse2(string))

print(string_reverse3(string))

print(string_reverse4(string))

print(string_reverse5(string))

string = 'abcdef'

def string_reverse1(string):

return string[::-1]

def string_reverse2(string):

t = list(string)

l = len(t)

for i,j in zip(range(l-1, 0, -1), range(l//2)):

t[i], t[j] = t[j], t[i]

return "".join(t)

def string_reverse3(string):

if len(string) <= 1:

return string

return string_reverse3(string[1:]) + string[0]

from collections import deque

def string_reverse4(string):

d = deque()

d.extendleft(string)

return ''.join(d)

def string_reverse5(string):

#return ''.join(string[len(string) - i] for i in range(1, len(string)+1))

return ''.join(string[i] for i in range(len(string)-1, -1, -1))

print(string_reverse1(string))

print(string_reverse2(string))

print(string_reverse3(string))

print(string_reverse4(string))

print(string_reverse5(string))

5. 请用本身的算法, 按升序合并以下两个list, 并去除重复的元素:

list1 = [2, 3, 8, 4, 9, 5, 6]

list2 = [5, 6, 10, 17, 11, 2]

解答:

合并链表, 递归的快速排序, 去重连接;

代码:

[python] view plain copy print ?

import random

list1 = [2, 3, 8, 4, 9, 5, 6]

list2 = [5, 6, 10, 17, 11, 2]

def qsort(L):

if len(L)<2: return L

pivot_element = random.choice(L)

small = [i for i in L if i< pivot_element]

large = [i for i in L if i> pivot_element]

return qsort(small) + [pivot_element] + qsort(large)

def merge(list1, list2):

return qsort(list1 + list2)

print(merge(list1, list2))

import random

list1 = [2, 3, 8, 4, 9, 5, 6]

list2 = [5, 6, 10, 17, 11, 2]

def qsort(L):

if len(L)<2: return L

pivot_element = random.choice(L)

small = [i for i in L if i< pivot_element]

large = [i for i in L if i> pivot_element]

return qsort(small) + [pivot_element] + qsort(large)

def merge(list1, list2):

return qsort(list1 + list2)

print(merge(list1, list2))

注: 若是使用set方法, list(set(list1 + list2)), 便可.

6. 请写出打印结果

x = [0, 1]

i = 0

i, x[i] = 1, 2

print(x)

打印结果: [0, 2], python能够使用连续赋值, 从左至右.

g = lambda x, y=2, z : x + y**z

g(1, z=10) = ?

打印结果: 异常, 形参表末尾才能够有默认参数, z须要提供默认参数.

7. 说一下如下代码片断存在的问题

[python] view plain copy print ?

from amodule import * # amodule is an exist module

class dummyclass(object):

def __init__(self):

self.is_d = True

pass

class childdummyclass(dummyclass):

def __init__(self, isman):

self.isman = isman

@classmethod

def can_speak(self): return True

@property

def man(self): return self.isman

if __name__ == "__main__":

object = new childdummyclass(True)

print object.can_speak()

print object.man()

print object.is_d

from amodule import * # amodule is an exist module

class dummyclass(object):

def __init__(self):

self.is_d = True

pass

class childdummyclass(dummyclass):

def __init__(self, isman):

self.isman = isman

@classmethod

def can_speak(self): return True

@property

def man(self): return self.isman

if __name__ == "__main__":

object = new childdummyclass(True)

print object.can_speak()

print object.man()

print object.is_d

解答:

1. 警告: object是python新形式(new style)的一个基础类, 不该该被从新定义;

2. 警告: 类方法(classmethod)是类所拥有的方法, 传入的参数应该是cls, 而不是self;

3. 错误: Python没有new关键字, 如需修改new, 如单例模式, 能够重写(override)__new__;

4. 错误: @property, 表示属性, 不是方法, 则不须要加括号”()”, 直接调用object.man, 便可;

5. 错误: 若是想使用基类的成员, 则须要初始化基类, 如dummyclass.__init__(self), 便可;

6. 额外: 类名尽可能使用大写.

代码:

[python] view plain copy print ?

class dummyclass(object):

def __init__(self):

self.is_d = True

pass

class childdummyclass(dummyclass):

def __init__(self, isman):

dummyclass.__init__(self) #__init__

self.isman = isman

@classmethod

def can_speak(cls): return True #cls

@property

def man(self): return self.isman

if __name__ == "__main__":

o = childdummyclass(True) #new, object

print o.can_speak()

print o.man #property

print o.is_d

class dummyclass(object):

def __init__(self):

self.is_d = True

pass

class childdummyclass(dummyclass):

def __init__(self, isman):

dummyclass.__init__(self) #__init__

self.isman = isman

@classmethod

def can_speak(cls): return True #cls

@property

def man(self): return self.isman

if __name__ == "__main__":

o = childdummyclass(True) #new, object

print o.can_speak()

print o.man #property

print o.is_d

8. 介绍一下python的异常处理机制和本身开发过程当中的体会

解答:

Python的异常处理机制:

try: 尝试抛出异常;

raise: 引起异常;

except: 处理异常;

finally: 是否发生异常都须要作的事情;

建立新的异常类型, 须要继承Exception类, 能够定义类的属性, 便于处理异常;

开发体会:

异常主要处理读取文件, 也能够使用with的方法读取文件; 还能够用于网络链接, 异常能够包含大量的错误信息, 进行错误处理.

代码:

[python] view plain copy print ?

class ShortInputException(Exception):

def __init__(self, length, atleast):

Exception.__init__(self)

self.length = length

self.atleast = atleast

while True:

try:

text = raw_input('Enter somthing-->')

if len(text) < 3:

raise ShortInputException(len(text), 3)

except EOFError:

print('Why did you do an EOF on me')

except ShortInputException as ex:

print('ShortInputException The input was {0} long, \

excepted at least {1}. '.format(ex.length, ex.atleast))

else:

print('No exception was raised. ')

finally:

print('Over')

class ShortInputException(Exception):

def __init__(self, length, atleast):

Exception.__init__(self)

self.length = length

self.atleast = atleast

while True:

try:

text = raw_input('Enter somthing-->')

if len(text) < 3:

raise ShortInputException(len(text), 3)

except EOFError:

print('Why did you do an EOF on me')

except ShortInputException as ex:

print('ShortInputException The input was {0} long, \

excepted at least {1}. '.format(ex.length, ex.atleast))

else:

print('No exception was raised. ')

finally:

print('Over')

# -*- coding: gbk -*-

def print_prime_factors(num):

if num < 2:

print '请输入大于 1 的整数用于质因数分解'

return

print '输出:',

prime_num = 2

while prime_num <= num:

if prime_num == num:

print prime_num,

break

elif num % prime_num == 0:

print prime_num,

num /= prime_num

else:

prime_num += 1

if __name__ == '__main__':

num = int(raw_input('输入:'))

print_prime_factors(num)

第一题: give you two var a and b, print the value of a+b, just do it!

根据提议，给出两个变量 a 和 b 并打印出 a+b的值.

1 2	a, b = 1, 2 print a + b

固然也能够这么作

a = 1

b = 2

print a + b

第二题: 给你一个list, 如 L = [2, 8, 3, 5], 对L进行升序排序并输出。

L = sorted(L)

print L

#或

# sort() 内置函数会对列表自身排序而 sorted() 会生成一个新的排序列表

L.sort()

print L

第三题: 给你一个字符串a，如a = ‘12345', 对a进行逆序输出。

# 经过步进来逆序输出字符串。

a = a[::-1]

print a

第四题: 给你一个字典a = {1:1, 2:2, 3:3}, 输出字典a的key ,以',' 链接，如 ‘1,2,3'。

1 2	# dict.keys() 会以list返回字典的key.而join会把list按,字符串',' 链接起来。 print ','.join(a.keys())

第五题: 给你一个字符串a, 输出字符串奇数位置的字符串,如 a = ‘12345', 则输出 ‘135'

1 2	# 经过列表解析(也称列表推导式)来判断下表选取奇偶数。 print ''.join([a[x] for x in range(len(a)) if x % 2 == 0])

第六题: 输出全部100之内的素数, 素数之间以空格区分。

# 在加一行print 才能运行经过

L = [x for x in range(2, 101) if not [y for y in range(2, x) if x%y == 0]]

for i in L:

print L,

第七题: 已知矩形长a, 宽b, 输出其面积和周长，以一个空格隔开

1	print a * b, 2 * (a+b)

第八题: 给你一个list, 如 L = [0, 1, 2, 3, 4] 输出L的中位数

# 中位数是指对已排序的数集取其中间数，数集为偶数取中间两数的平均

print sorted(L)[len(L)/2] if len(L) % 2 != 0 else \

(sorted(L)[Len(L)/2] + sorted(L)[len(L)/2 -1 ])/2.0

第九题: 给你两个正整数a和b, 输出它们的最大公约数。

1	print max([x for x in range(1, a+1) if x in [y for y in range(1, b+1) if b%y == 0]])

第十题: 给你两个正整数a和b，输出它们的最小公倍数.

1	print min([x for x in range(a, a*b+1) if x%a==0 and x%b==0])

附加题: 利用map/reduce 函数实现数的阶乘如 5!+4!+3!+2!+1!.

print map(lambda x: reduce(lambda y,z: y*z, range(1, x+1)), range(1,6))

# print [1, 2, 6, 24, 120], 因此在用reduce合起来

print reduce(lambda a, b: a+b, map(lambda x: \

reduce(lambda y, z: y*z, range(1, x+1)),range(1,6)))

附加题: 使用filter函数实现素数

1	print filter(lambda x: not [x%i for i in range(2,x) if x%i==0], range(2, 101))

# -*- coding: utf-8 -*-
def bubbleSort(Data):
'''''冒泡排序：时间复杂度最好O(n)，平均O(n*n)，最坏O(n*n)，辅助空间 O(1)，算法稳定
n个数，每次从第一个数开始和相邻的数比较，将大的冒泡到后面去。第一趟将最大的冒泡到最后，
而后第二次只需比较0~n-1，将其中最大的冒泡到n-1，依次下去...总共进行n-1趟排序便可
'''
if Data:
for i in range(len(Data)):
10. for j in range(len(Data)-i-1):
11. if Data[j]>Data[j+1]:
12. Data[j],Data[j+1]=Data[j+1],Data[j]
13. return Data
14.

15. def quickSort(Data,low,high):

16. '''''快速排序：O(n*logn),O(n*logn),O(n*n),O(n*logn),不稳定
17. 冒泡的改进，被认为是当前最优秀的内部排序算法（固然这也不是绝对的，还要看具体状况）。实现基于分治法：分解-解决-合并。
18. 基本思想：
19. 1.从数列中取出一个基数，
20. 2.将数列中比他大的放在右边，小的在左边。
21. 3.两边区间重复2，直到各区间只有一个数。
22. 整个算法中的基数就是个坑，跳来跳去，总之比他小始终放一边，大的放另外一边就行
23. 参考：http://blog.csdn.net/morewindows/article/details/6684558
24. '''
25. if low < high:
26. left,right,base=low,high,Data[low]
27. while left <right:
28. #从后往前找比base小的数
29. while left <right and Data[right] >=base:
30. right-=1
31. if left < right:
32. Data[left]=Data[right]
33. #left+=1 这里直接+1更快，由于Data[left]必然小于base，下次循环不用算
34. #从前日后找比base大的数
35. while left <right and Data[left] < base:
36. left+=1
37. if left <right:
38. Data[right]=Data[left]
39. #right-=1
40. #left=right时一趟循环终止，base填回坑里去
41. Data[left]=base
42. quickSort(Data,low,left-1) #递归左边
43. quickSort(Data,left+1,high) #递归右边
44.

45. def insertSort(Data):

46. '''''插入排序：时间复杂度最好O(n)，平均O(n*n)，最坏O(n*n)，辅助空间 O(1)，算法稳定
47. 若是Data不为空则开始比较。Data[0]~Data[j]是排好的序列L1，key是未排待插入数据
48. 若是key小于L1的最大值则将进行插入操做，while循环找到比key小的index并将key插入
49. 在index后面。while循环用来寻找插入位置并将比key大的数后移，若是key自己比L1的
50. 最大值还大则无需插入，直接for循环比较下一个
51. '''
52. if Data:
53. for i in range(1,len(Data)):
54. key,j = Data[i],i-1
55. while j>=0 and Data[j] > key:
56. Data[j+1]=Data[j]
57. j-=1
58. Data[j+1]=key
59. return Data
60.

61. def selectSort(Data):

62. '''''选择排序：时间复杂度最好O(n*n)，平均O(n*n)，最坏O(n*n)，辅助空间 O(1)，算法不稳定
63. n个数，每一趟从待排序列L2中选择最大（或最小）数顺序放在已排好序列L1后面（或前面）
64. 总共通过n-1趟可排好，与插入排序相比，都是将数据分为已排和未排序列并将未排元素整理
65. 到已排序列中，不一样的是插入排序在未排序列中按序整理，选排则是按大小选择整理。
66. '''
67. if Data:
68. for i in range(len(Data)-1):
69. minnum=i
70. for j in range(i+1,len(Data)):#在L2中寻找最小值
71. if Data[j]<Data[minnum]:
72. minnum=j
73. if minnum != i:#若是找到直接交换，插入在L1后面
74. Data[i],Data[minnum]=Data[minnum],Data[i]
75. return Data
76.

77. def shellSort(Data):

78. '''''希尔排序: 时间复杂度最好未知，平均O(pow(n,1.25)，最坏未知，辅助空间 O(1)，不稳定
79. 插入排序的改进，将数据分组，每组m个（m叫步长）每次对每组的第i个元素排序，
80. 而后再分组，再排序，直到步长为1.至于分组的方法须要理论推导，此处每次步长都取n/2减半
81. 更好的步长选择方法见wiki:http://zh.wikipedia.org/wiki/希尔排序
82. 其余实现方法：http://blog.csdn.net/morewindows/article/details/6668714
83. '''
84. n=len(Data)
85. if n > 1:
86. gap=n/2
87. while gap > 0:
88. for i in range(gap):#按步长插入排序
89. for j in range(i+gap,n,gap):
90. if Data[j] < Data[j-gap]:
91. key = Data[j]
92. k=j-gap
93. while k >=0 and Data[k] > key:
94. Data[k+gap]=Data[k]
95. k-=gap
96. Data[k+gap]=key
97. gap/=2
98. return Data
99.
if __name__ =="__main__":
Data=[3,5,1,56,3,7,34,21,8]
print Data
#insertSort(Data)
#bubbleSort(Data)
#selectSort(Data)
#shellSort(Data)
quickSort(Data,0,len(Data)-1)
print Data

1、填空题（每空1分，共24分）

1．Python使用符号三引号 # 标示注释；还有一种叫作’’’’’’的特别注释。

2．表达式 1/4+2.75 的值是 2.75 ；

三、请给出计算2³¹ −1的Python表达式 2**31-1 :

四、给出range(1,10,3)的值（1，4，7）[1，4，7] :

五、Python的数据类型分为整型、字符串型、浮点型

、复数等类型。

六、Python序列类型包括元组、序列、字典三种；

字典是Python中惟一的映射类型。

七、Python的除法运算符是 / ，取余运算符是 % 。

八、设s=‘abcdefg’，则s[3]值是‘d’ ，s[3:5]值是 def ‘de’ ，s[:5]值是 abcdef’abcde’s[3:]值是 ‘defg’ ，s[::-1]值是 g 。’gfedcba’

九、删除字典中的全部元素的函数是 def.dictclear()返回列表的函数是 key()，返回包含字典中全部值的列表的函数是 values()判断键在字典中是否存在的函数是 has.dict(key) get()。

2、选择题（每题3分，共36分）

1．下列哪一个语句在Python中是非法的？（C ）B

A、x = y = z = 1 B、x = (y = z + 1)

C、x, y = y, x D、x += y

2．关于Python内存管理，下列说法错误的是（B ）

A、变量没必要事先声明 B、变量无须先建立和赋值而直接使用

C、变量无须指定类型 D、能够使用del释放资源

三、(1) 执行下列语句后的显示结果是什么? ( A)

>>> world=”world”

>>> print “hello”+ world

A、 helloworld B、 “hello”world

C、hello world D、语法错误

四、下面哪一个不是Python合法的标识符 B（）

A、int32 B、40XL C、self D、__name__

五、下列哪一种说法是错误的 A（）

A、除字典类型外，全部标准对象都可以用于布尔测试

B、空字符串的布尔值是False

C、空列表对象的布尔值是False

D、值为0的任何数字对象的布尔值是False

六、下列表达式的值为True的是（ C ）

A、5+4j > 2-3j B、3>2>2

C、(3,2)< (‘a’,’b’) D、’abc’ > ‘xyz’

七、Python不支持的数据类型有 A（）

A、char B、int C、float D、list

八、type(1+2L*3.14)的结果是: （ C ）

[A] <type ‘int’>

[B] <type ‘long’>

[C] <type ‘float’>

[D] <type ‘str’>

九、关于字符串下列说法错误的是（B ）

A、字符应该视为长度为1的字符串

B、字符串以\0标志字符串的结束

C、既能够用单引号，也能够用双引号建立字符串

D、在三引号字符串中能够包含换行回车等特殊字符

十、如下不能建立一个字典的语句是（ C ）

A、dict1 = {} B、dict2 = { 3 : 5 }

C、dict3 = dict( [2 , 5] ,[ 3 , 4 ] )

D、dict4 = dict( ( [1,2],[3,4] ) )

十一、下面不能建立一个集合的语句是（ C）

A、s1 = set () B、s2 = set (“abcd”)

C、s3 = (1, 2, 3, 4) D、s4 = frozenset( (3,2,1) )

十二、下列Python语句正确的是 D（）

A、min = x if x < y else y B、max = x > y ? x : y

C、if (x > y) print x D、while True : pass

3、简答题(每题8分，共40分)

一、编写一个python程序，输入两个数，比较它们的大小并输出其中较大者。

X=input(“输入第一个数：”)

Y=input(“输入第二个数：”)

If（x==y）：

Print “两数相同”

Elif（x>y）：

Print “较大数为x”

Else：

print“较大数为y”

二、给定一个整数N，判断N是否为素数

三、存在字符串“I，love，python”，取出love，并输出

S=”I,love,python”

A=S[2:6]

print A

四、用Python定义一个函数，输入一年份，判断该年份是不是闰年并输出结果请输入一个年份

Year=int(input（“请输入年份：”）)

if((year%4==0&&year%100!=0)||year%400==0)

if year%4==0 and year%100!=0 or year%100==0 :

print“是闰年“

else

print “不是闰年“

五、存在字符串“ab2b3n5n2n67mm4n2”,编程统计字符串中字母n出现的次数

S= “ab2b3n5n2n67mm4n2”

Count=0

For i in s[]

If s[i]==n

Count+=1

Print count

一. 选择题: 将惟一正确的选项写在题前括号中（每题1分，共15分）

【】1．表达式 '%d%%%d' %(3 / 4, 3 % 4)的值是：

A．'0%3' B．'0%%3' C．'3/4%3%4' D．'3/4%%3%4'

【】2．下面标识符中不是python语言的保留字的是：

A．continue B．except C．init D．pass

【】3．如下程序的输出结果是（提示：ord（' a '）==97）：

lista = [1，2，3，4，5，'a'，'b'，'c'，'d'，'e']

print lista[2] + lista[5]

A．100 B．'d' C．d D．TypeEror

【】4．下面的循环体执行的次数与其它不一样的是：

A． i = 0

while( i <= 100):

print i,

i = i + 1

B． for i in range(100):

print i,

C． for i in range(100, 0, -1):

print i,

D． i = 100

while(i > 0):

print i,

i = i – 1

【】5．自顶向下逐步求精的程序设计方法是指：

A．将一个大问题简化为一样形式的较小问题。

B．先设计类，再实例化为对象。

C．解决方案用若干个较小问题来表达，直至小问题很容易求解。

D．先设计简单版本，再逐步增长功能。

【】6．简单变量做为实参时，它和对应的形参之间数据传递方式是：

A．由形参传给实参 B．由实参传给形参

C．由实参传给形参，再由形参传给实参 D．由用户指定传递方向

【】7．如下说法不正确的是：

A．在不一样函数中能够使用相同名字的变量。

B．函数能够减小代码的重复，也使得程序能够更加模块化。

C．主调函数内的局部变量，在被调函数内不赋值也能够直接读取。

D．函数体中若是没有return语句，也会返回一个None值。

【】8．关于list和string下列说法错误的是：

A．list能够存听任意类型。

B．list是一个有序集合，没有固定大小。

C．用于统计string中字符串长度的函数是string.len()。

D．string具备不可变性，其建立后值不能改变。

【】9．下面问题属于计算机本质上不可解问题的是：

A．Hanoi塔问题 B．排序问题 C．求阶乘 D．Halting问题

【】10．python语言定义的class的初始化函数的函数名是：

A．init B．__init__ C．__init D．init__

【】11．已知x = 43，y = False；则表达式(x >= y and 'A' < 'B' and not y)的值是：

A．False B．语法错 C．True D．"假"

【】12．对n个数作归并排序(merge sort)，这个算法是：

A．nlogn时间的 B．线性时间的 C．logn时间的 D．n²时间的

【】13．下面不是计算思惟的特征的是：

A．概念化 B．数学与工程思惟的融合 C．面向全部的人 D．计算机的思惟

【】14．执行下面操做后，list2的值是：

list1 = [4,5,6]

list2 = list1

list1[2] = 3

A．[4,5,6] B．[4,3,6] C．[4,5,3] D．A,B,C都不正确

【】15．下列合法的变量名是：

A．main( ) B．car2 C．2car D．var-name

二．概念填空（每空1分，共10分）

1．表达式eval("4 * 2 + 5 % 2 + 4/3")的结果是。

2．print 'This float, %-10.5f, has width 10 and precision 5. ' % (3.1415926) 的输出结果是：

3．计算的本质是和。

4．执行 print 1.3 - 1 == 0.3，结果是False的缘由是。

5．下面语句的执行结果是。

s = "bb c"

print string.split(3 * s)

6．、、是科技创新的三大支柱。

7．无穷循环while True:的循环体中可用语句退出循环。

三．阅读程序并回答问题（每题5分，共40分）

1．当输入是54321时，写出下面程序的执行结果。

def main():

num = input(“请输入一个整数：”)

while num != 0:

print num % 10

num = num / 10

main()

答案：

2．写出下面程序的执行结果。

a = [1, 20, 32, 14, 5, 62, 78, 38, 9, 10]

for i in range(9):

if( a[i] > a[i+1] ):

a[i], a[i+1] = a[i+1], a[i]

print a

3．写出下面程序的执行结果。

def main():

lst = [2, 4, 6, 8, 10]

lst = 2 * lst

lst[1], lst[3] = lst[3], lst[1]

swap(lst, 2, 4)

for i in range(len(lst) - 4):

print lst[i], " "

def swap(lists, ind1, ind2):

lists[ind1], lists[ind2] = lists[ind2], lists[ind1]

main()

4．写出下面程序的执行结果。

import string

def main():

s = "I like python!"

s = string.lower(s)

alist = []

countlist = []

count=0

for i in range( len(s) ):

if (ord(s[i]) <= ord('Z') and ord(s[i]) >= ord('A')) \

or (ord(s[i]) <= ord('z') and ord(s[i]) >= ord('a')):

if (s[i] in alist):

sign = alist.index(s[i])

countlist[sign] += 1

else:

alist.append(s[i])

countlist.append(1)

count += 1

for i in range(count):

print alist[i], " ", countlist[i]

main()

1.list 方法

1、建立一个列表
只要把逗号分隔的不一样的数据项使用方括号括起来便可。以下所示：

复制代码代码以下:

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

与字符串的索引同样，列表索引从0开始。列表能够进行截取、组合等。
2、访问列表中的值
使用下标索引来访问列表中的值，一样你也能够使用方括号的形式截取字符，以下所示：

复制代码代码以下:

#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

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

以上实例输出结果：

复制代码代码以下:

list1[0]: physics
list2[1:5]: [2, 3, 4, 5]

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

复制代码代码以下:

#!/usr/bin/python

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];

以上实例输出结果：

复制代码代码以下:

Value available at index 2 :
1997
New value available at index 2 :
2001

4、删除列表元素
能够使用 del 语句来删除列表的的元素，以下实例：

复制代码代码以下:

#!/usr/bin/python

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

print list1;
del list1[2];
print "After deleting value at index 2 : "
print list1;

以上实例输出结果：

复制代码代码以下:

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

5、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	迭代

6、Python列表截取
Python的列表截取与字符串操做类型，以下所示：

复制代码代码以下:

L = ['spam', 'Spam', 'SPAM!']

操做：

Python 表达式	结果	描述
L[2]	'SPAM!'	读取列表中第三个元素
L[-2]	'Spam'	读取列表中倒数第二个元素
L[1:]	['Spam', 'SPAM!']	从第二个元素开始截取列表

7、Python列表操做的函数和方法
列表操做包含如下函数:
一、cmp(list1, list2)：比较两个列表的元素
二、len(list)：列表元素个数
三、max(list)：返回列表元素最大值
四、min(list)：返回列表元素最小值
五、list(seq)：将元组转换为列表
列表操做包含如下方法:
一、list.append(obj)：在列表末尾添加新的对象
二、list.count(obj)：统计某个元素在列表中出现的次数
三、list.extend(seq)：在列表末尾一次性追加另外一个序列中的多个值（用新列表扩展原来的列表）
四、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
五、list.insert(index, obj)：将对象插入列表
六、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），而且返回该元素的值
七、list.remove(obj)：移除列表中某个值的第一个匹配项
八、list.reverse()：反向列表中元素
九、list.sort([func])：对原列表进行排序

字典

1、什么是字典？

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

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

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

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

1.存取和访问数据的方式不一样。
2.序列类型只用数字类型的键（从序列的开始按数值顺序索引）；
3.映射类型能够用其余对象类型做键（如：数字、字符串、元祖，通常用字符串做键），和序列类型的键不一样，映射类型的键直4.接或间接地和存储数据值相关联。
5.映射类型中的数据是无序排列的。这和序列类型是不同的，序列类型是以数值序排列的。
6.映射类型用键直接“映射”到值。

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

2、如何建立字典和给字典赋值

简单地说字典就是用大括号包裹的键值对的集合。（键值对也被称做项）
通常形式：

复制代码代码以下:

adict = {}
adict = {key1：value2， key2：value2， …}

或用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。

特色：
一、键与值用冒号“：”分开；
二、项与项用逗号“，”分开；
三、字典中的键必须是惟一的，而值能够不惟一。

复制代码代码以下:

adict = {‘name':'allen', ‘name':'lucy', ‘age':'40′} 与 bdict = {‘name':'allen', ‘name2′:'allen', ‘age':'40′}

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

3、字典的基本操做

一、如何访问字典中的值？
adict[key] 形式返回键key对应的值value，若是key不在字典中会引起一个KeyError。

二、如何检查key是否在字典中？

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

三、如何更新字典？

a、添加一个数据项（新元素）或键值对
adict[new_key] = value 形式添加一个项
b、更新一个数据项（元素）或键值对
adict[old_key] = new_value
c、删除一个数据项（元素）或键值对
del adict[key] 删除键key的项 / del adict 删除整个字典
adict.pop(key) 删除键key的项并返回key对应的 value值

4、映射类型操做符

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

a、字典不支持拼接和重复操做符（+，*）
b、字典的比较操做
先比较字典的长度也就是字典的元素个数
键比较
值比较
例子：

复制代码代码以下:

adict = {}
bdict = {‘name':'allen', ‘age':'40′}
cmp(adict, bdict) < –>-1 or > –>1 or == –>0

5、映射相关的函数

一、len() 返回字典的长度
二、hash() 返回对象的哈希值，能够用来判断一个对象可否用来做为字典的键
三、dict() 工厂函数，用来建立字典

6、字典的方法

一、adict.keys() 返回一个包含字典全部KEY的列表；
二、adict.values() 返回一个包含字典全部value的列表；
三、adict.items() 返回一个包含全部（键，值）元祖的列表；
四、adict.clear() 删除字典中的全部项或元素；
五、adict.copy() 返回一个字典浅拷贝的副本；
六、adict.fromkeys(seq, val=None) 建立并返回一个新字典，以seq中的元素作该字典的键，val作该字典中全部键对应的初始值（默认为None）；
七、adict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；
八、adict.has_key(key) 若是key在字典中，返回True，不然返回False。如今用 in 、 not in；
九、adict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法同样，不一样的是它们返回一个迭代子，而不是一个列表；
十、adict.pop(key[,default]) 和get方法类似。若是字典中存在key，删除并返回key对应的vuale；若是key不存在，且没有给出default的值，则引起keyerror异常；
十一、adict.setdefault(key, default=None) 和set()方法类似，但若是字典中不存在Key键，由 adict[key] = default 为它赋值；
十二、adict.update(bdict) 将字典bdict的键值对添加到字典adict中。

7、字典的遍历

一、遍历字典的key（键）

复制代码代码以下:

for key in adict.keys():print key

二、遍历字典的value（值）

复制代码代码以下:

for value in adict.values(): print value

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

复制代码代码以下:

for item in adict.items():print item

四、遍历字典的key-value

复制代码代码以下:

for item，value in adict.items(): print ‘key=%s, value=%s' %(item, value) 或 for item，value in adict.iteritems(): print ‘key=%s, value=%s' %(item, value)

集合

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

初始化

复制代码代码以下:

s0 = set()
d0 = {}
s1 = {0}
s2 = {i % 2 for i in range(10)}
s = set('hi')
t = set(['h', 'e', 'l', 'l', 'o'])
print(s0, s1, s2, s, t, type(d0))

运行结果：

复制代码代码以下:

set() {0} {0, 1} {'i', 'h'} {'e', 'o', 'l', 'h'} <class 'dict'>

提示
1.s0、d0：使用 {} 只能建立空字典，建立空集必须用 set()；
2.ss、sl：set 中的元素是无序不重复的，能够利用这个特色去除列表中的重复元素。

运算操做

复制代码代码以下:

print(s.intersection(t), s & t)  # 交集
print(s.union(t), s | t)   # 并集
print(s.difference(t), s - t)  # 差集
print(s.symmetric_difference(t), s ^ t) # 对称差集
print(s1.issubset(s2), s1 <= s2) # 子集
print(s1.issuperset(s2), s1 >= s2)      # 包含

运行结果：

复制代码代码以下:

{'h'} {'h'}
{'l', 'h', 'i', 'o', 'e'} {'l', 'h', 'i', 'o', 'e'}
{'i'} {'i'}
{'i', 'l', 'o', 'e'} {'i', 'l', 'o', 'e'}
True True
False False

提示
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 等。

基本方法

复制代码代码以下:

s = {0}
print(s, len(s))   # 获取集合中的元素的总数
s.add("x")         # 添加一个元素
print(s)
s.update([1,2,3]) # 添加多个元素
print(s, "x" in s) # 成员资格测试
s.remove("x")      # 去掉一个元素
print(s, "x" not in s)
s.discard("x")     # 若是集合存在指定元素，则删除该元素
c = s.copy()       # 复制集合
print(s, s.pop()) # 弹出集合中的一个不肯定元素，若是原集合为空则引起 KeyError
s.clear()          # 删除集合中的元素
print(s, c)

运行结果：

复制代码代码以下:

{0} 1
{0, 'x'}
{0, 'x', 1, 2, 3} True
{0, 1, 2, 3} True
{1, 2, 3} 0
set() {0, 1, 2, 3}

Str字符串方法

1、去空格及特殊符号

复制代码代码以下:

s.strip().lstrip().rstrip(',')

2、复制字符串

复制代码代码以下:

#strcpy(sStr1,sStr2)
sStr1 = 'strcpy'
sStr2 = sStr1
sStr1 = 'strcpy2'
print sStr2

3、链接字符串

复制代码代码以下:

#strcat(sStr1,sStr2)
sStr1 = 'strcat'
sStr2 = 'append'
sStr1 += sStr2
print sStr1

4、查找字符

复制代码代码以下:

#strchr(sStr1,sStr2)
# < 0 为未找到
sStr1 = 'strchr'
sStr2 = 's'
nPos = sStr1.index(sStr2)
print nPos

5、比较字符串

复制代码代码以下:

#strcmp(sStr1,sStr2)
sStr1 = 'strchr'
sStr2 = 'strch'
print cmp(sStr1,sStr2)

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

复制代码代码以下:

#strspn(sStr1,sStr2)
sStr1 = '12345678'
sStr2 = '456'
#sStr1 and chars both in sStr1 and sStr2
print len(sStr1 and sStr2)

7、字符串长度

复制代码代码以下:

#strlen(sStr1)
sStr1 = 'strlen'
print len(sStr1)

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

复制代码代码以下:

S.lower() #小写
S.upper() #大写
S.swapcase() #大小写互换
S.capitalize() #首字母大写
String.capwords(S) #这是模块中的方法。它把S用split()函数分开，而后用capitalize()把首字母变成大写，最后用join()合并到一块儿
#实例：
#strlwr(sStr1)
sStr1 = 'JCstrlwr'
sStr1 = sStr1.upper()
#sStr1 = sStr1.lower()
print sStr1

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

复制代码代码以下:

#strncat(sStr1,sStr2,n)
sStr1 = '12345'
sStr2 = 'abcdef'
n = 3
sStr1 += sStr2[0:n]
print sStr1

10、字符串指定长度比较

复制代码代码以下:

#strncmp(sStr1,sStr2,n)
sStr1 = '12345'
sStr2 = '123bc'
n = 3
print cmp(sStr1[0:n],sStr2[0:n])

11、复制指定长度的字符

复制代码代码以下:

#strncpy(sStr1,sStr2,n)
sStr1 = ''
sStr2 = '12345'
n = 3
sStr1 = sStr2[0:n]
print sStr1

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

复制代码代码以下:

#strnset(sStr1,ch,n)
sStr1 = '12345'
ch = 'r'
n = 3
sStr1 = n * ch + sStr1[3:]
print sStr1

13、扫描字符串

复制代码代码以下:

#strpbrk(sStr1,sStr2)
sStr1 = 'cekjgdklab'
sStr2 = 'gka'
nPos = -1
for c in sStr1:
    if c in sStr2:
        nPos = sStr1.index(c)
        break
print nPos

14、翻转字符串

复制代码代码以下:

#strrev(sStr1)
sStr1 = 'abcdefg'
sStr1 = sStr1[::-1]
print sStr1

15、查找字符串

复制代码代码以下:

#strstr(sStr1,sStr2)
sStr1 = 'abcdefg'
sStr2 = 'cde'
print sStr1.find(sStr2)

16、分割字符串

复制代码代码以下:

#strtok(sStr1,sStr2)
sStr1 = 'ab,cde,fgh,ijk'
sStr2 = ','
sStr1 = sStr1[sStr1.find(sStr2) + 1:]
print sStr1
#或者
s = 'ab,cde,fgh,ijk'
print(s.split(','))

17、链接字符串

复制代码代码以下:

delimiter = ','
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)

18、PHP 中 addslashes 的实现

复制代码代码以下:

def addslashes(s):
d = {'"':'\\"', "'":"\\'", "\0":"\\\0", "\\":"\\\\"}
return ''.join(d.get(c, c) for c in s)

s = "John 'Johny' Doe (a.k.a. \"Super Joe\")\\\0"
print s
print addslashes(s)

19、只显示字母与数字

复制代码代码以下:

def OnlyCharNum(s,oth=''):
    s2 = s.lower();
    fomart = 'abcdefghijklmnopqrstuvwxyz0123456789'
    for c in s2:
        if not c in fomart:
            s = s.replace(c,'');
    return s;

print(OnlyStr("a000 aa-b"))

20、截取字符串

复制代码代码以下:

str = '0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的所有字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符以前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位以前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取，具体啥意思没搞明白？

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

复制代码代码以下:

S.ljust(width,[fillchar])
#输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
S.rjust(width,[fillchar]) #右对齐
S.center(width, [fillchar]) #中间对齐
S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足

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

复制代码代码以下:

S.find(substr, [start, [end]])
#返回S中出现substr的第一个字母的标号，若是S中没有substr则返回-1。start和end做用就至关于在S[start:end]中搜索
S.index(substr, [start, [end]])
#与find()相同，只是在S中没有substr时，会返回一个运行时错误
S.rfind(substr, [start, [end]])
#返回S中最后出现的substr的第一个字母的标号，若是S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
S.rindex(substr, [start, [end]])
S.count(substr, [start, [end]]) #计算substr在S中出现的次数
S.replace(oldstr, newstr, [count])
#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
S.strip([chars])
#把S中先后chars中有的字符所有去掉，能够理解为把S先后chars替换为None
S.lstrip([chars])
S.rstrip([chars])
S.expandtabs([tabsize])
#把S中的tab字符替换没空格，每一个tab替换为tabsize个空格，默认是8个

23、字符串的分割和组合

复制代码代码以下:

S.split([sep, [maxsplit]])
#以sep为分隔符，把S分红一个list。maxsplit表示分割的次数。默认的分割符为空白字符
S.rsplit([sep, [maxsplit]])
S.splitlines([keepends])
#把S按照行分割符分为一个list，keepends是一个bool值，若是为真每行后而会保留行分割符。
S.join(seq) #把seq表明的序列──字符串序列，用S链接起来

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

复制代码代码以下:

String.maketrans(from, to)
#返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，因此from和to必须是等长的。
S.translate(table[,deletechars])
# 使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。须要注意的是，若是S为unicode字符串，那么就不支持 deletechars参数，能够使用把某个字符翻译为None的方式实现相同的功能。此外还能够使用codecs模块的功能来建立更加功能强大的翻译表。

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

复制代码代码以下:

S.encode([encoding,[errors]])
# 其中encoding能够有多种值，好比gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和全部的经过codecs.register_error注册的值。这一部份内容涉及codecs模块，不是特明白
S.decode([encoding,[errors]])

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

复制代码代码以下:

S.startswith(prefix[,start[,end]])
#是否以prefix开头
S.endswith(suffix[,start[,end]])
#以suffix结尾
S.isalnum()
#是否全是字母和数字，并至少有一个字符
S.isalpha() #是否全是字母，并至少有一个字符
S.isdigit() #是否全是数字，并至少有一个字符
S.isspace() #是否全是空白字符，并至少有一个字符
S.islower() #S中的字母是否全是小写
S.isupper() #S中的字母是否即是大写
S.istitle() #S是不是首字母大写的

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

复制代码代码以下:

string.atoi(s[,base])
#base默认为10，若是为0,那么s就能够是012或0x23这种形式的字符串，若是是16那么s就只能是0x23或0X12这种形式的字符串
string.atol(s[,base]) #转成long
string.atof(s[,base]) #转成float

tuple元组方法

1、建立元组

复制代码代码以下:

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

建立空元组

复制代码代码以下:

tup1 = ();

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

复制代码代码以下:

tup1 = (50,);

元组与字符串相似，下标索引从0开始，能够进行截取，组合等。
2、访问元组
元组能够使用下标索引来访问元组中的值，以下实例:

复制代码代码以下:

#!/usr/bin/python

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]

3、修改元组
元组中的元素值是不容许修改的，但咱们能够对元组进行链接组合，以下实例:

复制代码代码以下:

#!/usr/bin/python

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# 如下修改元组元素操做是非法的。
# tup1[0] = 100;

# 建立一个新的元组
tup3 = tup1 + tup2;
print tup3;
#以上实例输出结果：
#(12, 34.56, 'abc', 'xyz')

4、删除元组
元组中的元素值是不容许删除的，但咱们能够使用del语句来删除整个元组，以下实例:

复制代码代码以下:

#!/usr/bin/python

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 <module>
# print tup;
#NameError: name 'tup' is not defined[/code]
5、元组运算符
与字符串同样，元组之间能够使用 + 号和 * 号进行运算。这就意味着他们能够组合和复制，运算后会生成一个新的元组。

6、元组索引，截取
由于元组也是一个序列，因此咱们能够访问元组中的指定位置的元素，也能够截取索引中的一段元素，以下所示：
元组：

复制代码代码以下:

L = ('spam', 'Spam', 'SPAM!')

7、无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组，以下实例：

复制代码代码以下:

#!/usr/bin/python

print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;

以上实例容许结果：

复制代码代码以下:

abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

8、元组内置函数
Python元组包含了如下内置函数
一、cmp(tuple1, tuple2)：比较两个元组元素。
二、len(tuple)：计算元组元素个数。
三、max(tuple)：返回元组中元素最大值。
四、min(tuple)：返回元组中元素最小值。
五、tuple(seq)：将列表转换为元组。

9、另外一种解读

tuple和list很是相似，可是tuple一旦初始化就不能修改，好比一样是列出同窗的名字：

复制代码代码以下:

>>> classmates = ('Michael', 'Bob', 'Tracy')

如今，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其余获取元素的方法和list是同样的，你能够正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
不可变的tuple有什么意义？由于tuple不可变，因此代码更安全。若是可能，能用tuple代替list就尽可能用tuple。
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时，也会加一个逗号,，以避免你误解成数学计算意义上的括号。

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

复制代码代码以下:

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

这个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的每个元素自己也不能变。