为什么要使用函数？
&在说明原因之前，我们先来看一个需求，比如你的boss需要你写实现以下的打印输出，并插入在某段程序代码的20个位置都条件此打印输出：
********************
********************
hello,python!
********************
********************
&你咔咔咔就用代码实现了需求，并将代码添加到了程序的20个位置，代码如下，但是你的boss看着你的代码却不是很认可，他说：如果我现在需要你把所有的"*"都换成"#"。你一脸懵逼，难道要一个一个的改吗？
********************
********************
hello,python!
********************
********************
&苦苦思索不得果，询问boss，boss捋了捋袖子，几下就给你搞定了，对你说：去学学函数吧，便离去，深藏功与名，代码如下：
"""打印符号"""
print('*'*20)
"""打印问候"""
print("hello,python!")
你看了一眼代码豁然开朗，那么这里这么写到底有什么好处呢？
1.如果你现在需要将所有的"*"改为"#"，只需要将函数index中的"*"替换为"#"
2.如果你现在需要打在问候前后各打印3行符号，只需要在say()前后各加一个index()
3.如果你现在还需要在其他程序其他的地方再打印这五行输出，只需要复制粘贴下面的五行代码
这就是函数带来的好处，也就是为什么要使用函数
1.减少了重复的代码
2.更有利于阅读代码，便于调试，可维护性增强
3.增加了代码整体结构的层次化，使组织结构更清晰
&在python中函数大致可以分为两类：
&1.内置函数
&比如用来求和的sum函数，求最大值的max函数，求最小值的min函数等等
print(sum((1,2,3)))
print(max(1,2,3))
#打印最大值
print(min(1,2,3))
#打印最小值
&在python3.x中，print本身也是一个内置的函数，但是在python2.x不是函数。
&2.自定义函数
&说了那么多函数的好处，那么我们该怎么定义函数呢？一般格式如下:
def 函数名(arg1,arg2,arg3)：
"""描述信息"""
def为函数的关键字，函数名为自定义，最好是具有描述性的名字且不能与python的关键字一致，arg1等为函数的形参，可以有也可以没有，数量可以是一个或者是无穷个，引号处为描述信息，强烈的要求你在定义函数的时候请写上描述信息，便于其他人一眼看到你定义的函数的时候，知道是做什么的，函数体定义了一系列的具体操作，return用来返回值，当一个函数没有使用return来返回值，python解释器默认会返回一个None值。
在python中，函数必须是先定义后使用的，可以从是否向函数内传入参数将函数的定义分为以下三种：
1.无参函数
函数体内只是简单的命令，不需要依赖外部传入的参数
def my_python():
"""This is my python"""
print("From my python!")
print(my_python.__doc__)
#可打印注释信息
2.有参函数
需要依赖外部传入的值
def my_max(x,y):
"""求2个数的最大值"""
max_number=x if x & y else y
return max_number
在一个项目的前期，可以使用空函数来定义整个项目的框架
def auth():
def goods():
&那么定义了这么的函数，怎么去用呢？下面我们就来讲讲函数的调用
&函数的调用
我们也从是否传递参数来说明函数的调用
1.无参函数的调用
在调用无参函数的时候只需要使用函数名加小括号即可调用
def my_python():
"""This is my python"""
print("From my python!")
my_python()
From my python!
2.有参函数的调用
在调用有参函数的时候，需要向函数里面传递值
def my_max(x,y):
"""求2个数的最大值"""
max_number=x if x & y else y
return max_number
res=my_max(100,2)
print(res)
&如上函数，我们将100和2传递给了函数my_max，函数求出最大值并返回最大值，这里将最大值返回给了res，然后打印res。
通常情况下无参函数不需要使用return返回值
1.无参函数返回值
在无参函数中不写return，默认会返回一个None
def foo():
"""打印"""
print("From the foo")
print(res)
From the foo
&2.return一个值
def my_max(x,y):
"""求2个数的最大值"""
max_number=x if x & y else y
return max_number
res=my_max(100,2)
print(res)
&3.return可以返回任意类型的多个值
def bar(x,y):
"""测试return"""
return x,y,3,4,5,[1,2],{'a':2},{1,2},(1,2)
res=bar(1,2)
print(res)
(1, 2, 3, 4, 5, [1, 2], {'a': 2}, {1, 2}, (1, 2))
return返回多个值的时候，返回的是一个元组
那如果我们在一个函数内同时使用多个返回值呢？
def mul_retu():
print(mul_retu())
&当函数体内有多个返回值，仅执行一条
&形参和实参
形参：在定义函数的时候，括号里面的参数，相当于变量
实参：在调用函数的时候，括号里面的参数，相当于值，实参也可以被当成变量值
举个例子：
def my_max(x,y):
"""求2个数的最大值"""
max_number=x if x & y else y
return max_number
res=my_max(100,2)
print(res)
这里的函数名后括号内的x和y就是形参，而在调用函数的时候函数名括号里面的（100,2）就是实参。只有在调用阶段的时候，形参和实参才会有绑定关系，也就是说函数只有在被调用时生效。
我们来看以下几个函数：
def bar(x):
def bar1(y):
y.append(5)
y=[1,2,3,4]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
def bar1(z):
z=(1,2,3,4)
(1, 2, 3, 4)
(1, 2, 3, 4)
以上几个函数都试图去修改外部传入的变量的值，但是只有个别修改成功了，这里总结以下：
如果向函数内传递的是不可变类型（字符串，元组，整型），函数则不能修改其值
如果向函数内传递的是可变的类型（列表，字典），函数会修改其值
所以在向函数内部传递值的时候，部件以传递可变类型，这样函数会修改外部的值，除非你想要这么做。
&位置参数和默认参数
前面我们写过实参和形参，现在我们就站在不同的角度去看传值。
实参的角度，先来一个函数：
def foo(x,y):
"""大于2个数"""
既然我们是通过实参的角度，那么通过实参有以下两种方式的传值：
1.按照位置传值给函数
这里的1必定传给了x，2必定传给了y。
2.按关键字传值
我们可以在传值的时候就指定x,y传的值，那么不管x在前还是在后，都能正确的传给形参x和y
foo(x=1,y=2)
foo(y=2,x=1)
3.混合传值
也可以把按位置传值和按关键字传值放在一起，这个时候按关键字传值就必须要在前面，而且对于关键字传值，一个参数不能重复的赋值
&从形参的角度来看
def foo(x,y):
"""大于2个数"""
位置参数是必须要传值的，一个位置参数就必须传一个值
但是也可以存在不一定要传值的默认参数，可以在定义函数的时候，就在形参后跟值
def foo(x,y=1):
foo(y=2,x=1)
&我们来看函数max()求最大值的函数
&&& max(1,2,3,4)
&&& max(1,2,3,4,56,12)
&&& max(123,221,324,32,123,3,1,23,2)
可以看到我们不管给函数max传递多少个值，他都能接受，这是怎么实现的呢？
*args & & （args可以用任何合法的字符串代替，默认一般使用args）
*args是一个可变的形参，看下面的函数：
def foo(x,*args):
print(args)
foo(1,2,3,4,5)
(2, 3, 4, 5)
从实参的角度来看，1会传给x，呃，那么2,3,4,5该怎么办，按位置传值的时候，多余的实参会传给args，生成一个元组
当*args与位置形参和默认形参混合的时候，位置形参要放在最前面，默认形参要放在最后面：
def foo(x,*args,y=1):
#一般*args不会和默认参数放在一起用
print(args)
foo(1,2,3,4,5,y=100)
(2, 3, 4, 5)
#从形参的角度
def foo(*args):
#foo(x,y,z)
print(args)
foo(1,2,3)
#从实参的角度
#*args=*(1,2,3)
def bar(x,y,z):
bar(*(1,2,3)) #bar(1,2,3)
&除了*args之外还有个**kwargs，我们来看一个例子，当按关键字传值的时候，多余的会传给kwargs，生成一个字典：
def foo(x,**kwargs):
print(kwargs)
foo(1,y=2,a=3,b=4)
{'a': 3, 'b': 4, 'y': 2}
#从实参的角度
def foo(x,y,z=1):
foo(**{'x':1,'y':2,'z':3}) #foo(x=1,y=2,z=3)
&*args和**kwargs混合
def auth(name,passwd,sex='male'):
print(name)
print(passwd)
print(sex)
def foo(*args,**kwargs):
# print("From the foo")
auth(*args,**kwargs)
foo("Frank","123")
foo(name='claire',passwd='123',sex="female")
名称空间和作用域
从字面的意思来看就是存放名字的空间，当我们定一个变量的这个，例如x=1，那么x就是名称，它会放到一个所谓的&空间&中，当我们调用它的名称的时候就可以获得其值。在python中有3种类型的名称空间。
1.内置名称空间
解释器一启动就有的，比如sum,print,max这些函数名都内置的名称
2.全局名称空间
在一个文件中，顶头写的就是定一个全局的名称，比如顶头定一个变量，列表或者字典，那么这些对象的名称就是全局名称
3.局部名称空间
在函数内部定义的对象的名称
作用域：就是名称空间的作用范围
看一下下面的例子
def foo():
&根据结果我们可以知道，当在函数内部，打印一个变量的时候，她会现在局部名称空间里面去找有没有这个变量，如果有就打印其值，当我们在全局名称空间里面打印变量值的时候，它会在全局下面找，而不会去局部名称空间里面去找。
def foo():
来看一下上面的例子，当我们在局部名称空间里面并没有定义值，它会去全局的名称空间去找。
所有在函数内部需要一个变量的时候，寻找名称空间顺序是局部==&全局==&内置，如果在全局下需要一个变量的时候，会现在全局找，再在内置找，不会去局部名称空间里面去找。
这里内置名称空间和全局名称空就是全局作用域，局部名称空间就是局部作用域。
名称空间的查询
查询名称空间可以使用如下函数：
globals()：查看全局名称空间
locals()：查看局部名称空间
1.在全局作用域下查询
在全局作用域下查询，全局名称空间和局部名称空间是一样的
my_function():
print(globals())
#查看全局名称空间
print(locals())
#查看局部名称空间
{'__name__': '__main__', '__doc__': None, 'x': 1, '__package__': None, '__loader__': &_frozen_importlib_external.SourceFileLoader object at 0xF17E6A58&, 'my_function': &function my_function at 0xF1CA0268&, '__spec__': None, '__file__': 'E:/py_fullstack/函数/名称空间和作用域.py', '__cached__': None, '__builtins__': &module 'builtins' (built-in)&}
{'__name__': '__main__', '__doc__': None, 'x': 1, '__package__': None, '__loader__': &_frozen_importlib_external.SourceFileLoader object at 0xF17E6A58&, 'my_function': &function my_function at 0xF1CA0268&, '__spec__': None, '__file__': 'E:/py_fullstack/函数/名称空间和作用域.py', '__cached__': None, '__builtins__': &module 'builtins' (built-in)&}
2.在局部作用域内查询
2.在局部作用域内查询
在局部作用域内查询，即在函数内部查询，全局名称空间为函数外部的名称空间（内置名称空间和全局名称空间），而局部名称空间只有函数内部定义的名称（局部名称空间）
my_function():
print(globals())
print(locals())
my_function()
{'__builtins__': &module 'builtins' (built-in)&, 'x': 1, '__doc__': None, '__file__': 'E:/py_fullstack/函数/名称空间和作用域.py', '__name__': '__main__', '__package__': None, '__cached__': None, '__loader__': &_frozen_importlib_external.SourceFileLoader object at 0x0000016AAF6F6A58&, '__spec__': None, 'my_function': &function my_function at 0x0000016AAFB20268&}
函数的嵌套
1.函数的嵌套调用
函数可以被其他的函数放在函数体内调用，举例如下：
def my_max(x,y):
return x if x &y else y
print(my_max(10,100))
def my_max4(a,b,c,d):
res1=my_max(a,b)
res2=my_max(res1,c)
res3=my_max(res2,d)
return res3
print(my_max4(1,20,2,111))
2.函数的嵌套定义
意思就是可以在函数内定义函数
print("from the f1")
print("from the f2")
print("from the f3")
from the f1
from the f2
在Python中有句话是&一切皆对象&，函数也不例外，函数作为对象可以赋值给一个变量、可以作为元素添加到集合对象中，可以作为参数传递给其他的函数，也可以作为返回值，这一类特性就是&第一类对象&所有的：
def foo():
print("foo")
print(foo)
&function foo at 0x0048&
函数可以被赋值
def foo():
print('foo')
# print(foo)
&function foo at 0xC59F0048&
函数可以被当作参数传递
def foo():
print('foo')
def bar(func):
print(func)
&function foo at 0x570048&
把函数当作容器类型的元素
def search():
print('===search')
def add():
print('===add')
def delete():
print('===delete')
'search':search,
'add':add,
'delete':delete,
def tell_message():
search:查询
delete:删除
print(msg)
while True:
tell_message()
choice = input("Please input your choice:").strip()
cmd_dic[choice]()
首先我们来看下面这个例子
#返回f2的内存地址
&function f1.&locals&.f2 at 0x01E0&
闭包：首先必须是内部定义的函数，该函数包含对外部作用域而不是全局作用域名字的引用，上面的f2就是一个闭包函数
闭包的应用（爬取一个页面），这里的f2也是一个闭包函数：
from urllib.request import urlopen
def f1(url):
print(urlopen(url).read())
python=f1('http://www.python.org')
#返回了函数f2的功能和对外部作用域定义的url==》python
阅读(...) 评论()如何编写Python脚本替换文件中的多行字符？_西西软件资讯
西西软件园多重安全检测下载网站、值得信赖的软件下载站！
→ 如何编写Python脚本替换文件中的多行字符？
3.13 win32 英文安装版
类型：编程工具大小：21M语言：英文 评分：8.7
&在大概3个月之前，Python对我来说一直是个迷。然而，就在3个月前我经理给我一个任务――删除（替换）所有项目源码文件中包含特定几行内容的所有注释。整个项目源码的大小有1G，在Linux服务器（中高档）上编译需要半个多小时，可见代码量之大，不可能手动去一个一个改。肯定得用脚本去处理，于是我想到了Python。在这之前没有接触过Python，花了2个星期一顿恶补之后，总算顺利交差了。一直很想和大家分享一下碰到的问题及我如何解决的（可能我的方案并不好，但是他能够解决我的问题），但一直拖到现在是因为我感觉我还对Python的了解还不够。因为要在短时间内完成上面交下来的任务，在学习Python的时候，都是走马观花，对解决自己的问题不相关的直接跳过，看资料也静不下心，脑海里都是问题。前几天我静下心把Python的书从头到尾浏览了一遍，感觉现在是时候要进行总结了。本文的主要内容如下：问题描述 解题思路 代码实现 Python的特点 1、问题描述项目源码很大，属于C/C++混合的那种，编程风格也很多样，有'.c'、'.cc'、'cpp'、'.h'、'.hh'等文件。我要完成的任务是：把包含特定几行内容的注释删掉，如（声明：下面的内容只是我随便举的一个例子，项目源码中不涉及下面的内容。）/* * Copyright 2002 Sun Microsystems, Inc. All rights reserved.** Redistribution and use in source and binary forms, with or without* modification, are permitted provided that the following conditions* are met:** - Redistributions of source code must retain the above copyright* notice, this list of conditions and the following disclaimer.** - Redistribution in binary form must reproduce the above copyright* notice, this list of conditions and the following disclaimer in* the documentation and/or other materials provided with the* distribution.** Neither the name of Sun Microsystems, Inc. or the names of* contributors may be used to endorse or promote products derived* from this software without specific prior written permission.*/但是格式有很多种，如有的在“ Copyright 2002 Sun Microsystems, Inc. All rights reserved.”前面有一段关于本源码文件的描述、有的在“from this software without specific prior written permission.”后面有一段关于本源码文件的描述、有的是C++风格的注释用"//",而不是“/**/”、还有的没有“ * - Redistribution in binary form must reproduce the above copyright* notice, this list of conditions and the following disclaimer in* the documentation and/or other materials provided with the* distribution.”等等还有其他一些。总之一句话，我要删除的包含特定几行内容的注释有很多中格式！于是我决定要用Python来编写脚本处理。要匹配特定的内容，我想到了用正则表达式，但苦于不知道如何去构建正则来匹配上面描述的内容（您知道的话，希望能够告诉我）！我只有另辟路径了。2、解题思路我的思路――要删除所有项目源码中包含特定几行内容的注释，脚本要满足以下几点功能：脚本要能够遍历所有的源码文件（'.c'、'.cc'、'cpp'、'.h'、'.hh'），并只处理上面的几种类型的文件 找出包含特定几行内容的注释，并删除之 能够处理一些特殊情况，如软连接文件 上面的几点的处理步骤可以表示如下：Step 1：输入要处理源码文件夹名，或者源码文件名；Step 2：如果是文件名，检查文件的类型是否为'.c'、'.cc'、'cpp'、'.h'、'.hh'，否则不处理；Step 3：检查文件是否是软连接，如果是软连接则不处理；Step 4：查找文件中是否存在匹配的注释，存在则删掉，否则不处理；Step 5：如果是文件夹，则对文件夹中的每个文件、文件夹进行处理，转Step2.思路很明确，关键是如何查找文件中是否包含匹配的内容，并删除！还有就是，对于一个没用过Python等脚本语言的人来说，如何编码实现也是一个问题！如何确定注释是否为包含特定几行内容的注释？我的思路如下：（因为正则表达式学的不好，只有通过下面的方法了）如果是/*、//则记录下当前的文件行数，即行号startLine 以行为单位查找是否存在特定的几行，如“ Copyright 2002 Sun Microsystems, Inc. All rights reserved.”等等 直到遇到*/，或注释结束了（对于//）。如果存在，则记录下注释结束的行号endLine 最后，删掉这从startLine ~ endLine的内容。 3、代码实现废话我不多说了，直接按照上面的实例实现代码，如果你对Python不熟，请参阅相关资料。#!/usr/bin/env python#Filename: comment.pyimport os, sys, fileinput#-------------------------------------------------------------def usage():&&& print u'''&&& help: comment.py &filename | dirname&&&& [dirname]: Option, select a directory to operate&&& [filename]: Option, select a file to operate&&& Example: python comment.py /home/saylor/test&&& '''#--------------------------------------------------------------def commentFile(src, fileList):&&& '''&&& description: comment files&&& param src: Operate file name&&& '''&&& #if file exist?&&& ifnot os.path.exists(src):&&&&&&& print'Error: file - %s doesn\'t exist.'% src&&&&&&& return False&&& if os.path.islink(src):&&&&&&& print'Error: file - %s is just a link, will not handle it.'&&&&&&& return False&&& filetype = (os.path.splitext(src))[1]&&& ifnot filetype in ['.c','.h']:&&&&&&& return False&&& try:&&&&&&& ifnot os.access(src, os.W_OK):&&&&&&&&&&& os.chmod(src, 0664)&&& except:&&&&&&& print'Error: you can not chang %s\'s mode.'% src&&& try:&&&&&&& inputf = open(src, 'r')&&&&&&& outputfilename = src +'.tmp'&&&&&&& outputf = open(outputfilename, 'w')&&& beginLine = 0&&& endLine =&&& isMatched = False&&& #-----find the beginLine and endLine -------------------&&&&&&& for eachline in fileinput.input(src):&&&&&&& if eachline.find('/*') &= 0:&&&&&&& beginLine = fileinput.lineno()&&&&&&& if eachline.find('Copyright 2002 Sun Microsystems, Inc. All rights reserved.') &= 0:&&&&&&&&&&& isMatched = True&&&&&&& if eachline.find('*/') &= 0 and isMatched:&&&&&&& endLine = fileinput.lineno()&&&&&&& break&&& &&& #-----delete the content between beginLine and endLine-----&&& print beginLine, endLine&&& lineNo =1&&& for eachline in inputf:&&&&&&& if lineNo & beginLine:&&&&&&& print eachline&&&&&&& outputf.write(eachline)&&&&&&& elif lineNo & endLine:&&&&&&& print eachline&&&&&&& outputf.write(eachline)&&&&&&& lineNo = lineNo +1&&&&&&& &&&&&&& inputf.close()&&&&&&& outputf.close()&&&&&&& os.rename(outputfilename, src)&&&&&&& fileList.append(src)&&& except:&&&&&&& print'Error: unexcept error.'&&&&&&& inputf.close()&&&&&&& outputf.close()&&& return True#--------------------------------------------------------------def commentDir(src, fileList):&&& '''&&& description:&&&&&&&& comment files in src(dir)&&& param src:&&&&&&&& operate files in src(dir)&&& '''&&& #if dir exist?&&& ifnot os.path.exists(src):&&&&&&& print'Error: dir - %s is not exist.'%s (src)&&&&&&& return False&&& filelists = os.listdir(src)&&& for eachfile in filelists:&&&&&&& eachfile = src +'/'+eachfile&&&&&&& if os.path.isdir(eachfile):&&&&&&&&&&& commentDir(eachfile, fileList)&&&&&&& elif os.path.isfile(eachfile):&&&&&&&&&&& commentFile(eachfile, fileList)&&& return True#--------------------------------------------------------------def main():&&& if len(sys.argv) &2:&&&&&&& usage()&&&&&&& sys.exit(1)&&& src = sys.argv[1]&&& if os.path.isdir(src):&&&&&&& dire = os.path.abspath(src)&&&&&&& dirFlag = True&&& elif os.path.isfile(src):&&&&&&& fl = os.path.abspath(src)&&&&&&& dirFlag = False&&& else:&&&&&&& print'Error'&&& fileList = []&&& if dirFlag:&&&&&&& commentDir(dire, fileList)&&& else:&&&&&&& commentFile(fl, fileList)&&& if fileList:&&&&&&& print'Successful handle file: ...'&&&&&&& for eachfile in fileList:&&&&&&&&&&& print eachfile&&& print'Done'&&& return True#--------------------------------------------------------------if__name__=='__main__':&&& main()
4、Python的特点Python入门我强烈推荐下面的资料，深入学习请阅读其它资料：《A Byte of Python》http://www.swaroopch.com/notes/Python《简明 Python 教程》http://woodpecker.org.cn/abyteofpython_cn/chinese/Python的设计哲学是“优雅”、“明确”、“简单”。因此，Perl语言中“总有多种方法来做同一件事”的理念在Python开发者中通常是难以忍受的。Python开发者的哲学是“用一种方法，最好是只有一种方法来做一件事”。在设计Python语言时，如果面临多种选择，Python开发者总会拒绝花哨的语法，而选择明确的没有或者很少有歧义的语法。由于这种设计观念的差异，Python源代码通常认为比Perl具备更好的可读性。Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python内。所以很多认为Python很慢。不过，根据二八定律，大多数程序对速度要求不高。在某些对运行速度要求很高的情况，Python程序员倾向于使用JIT技术，或者用使用C/C++语言改写这部分程序。目前可用的JIT技术是Pysco。Cython可以将Python代码转换成C代码。相对于Lisp这种传统的函数式编程语言，Python对函数式编程只提供了有限的支持。有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式编程工具。虽然Python可能被粗略地分类为「脚本语言」（script language），但实际上一些大规模软件开发计划例如Zope、Mnet及BitTorrent，Google也广泛地使用它。Python的支持者较喜欢称它为一种高阶动态编程语言，原因是「脚本语言」泛指仅作简单编程任务的语言，如shell script、JavaScript等只能处理简单任务的编程语言，K不能与Python相提并论。Python本身被设计为可扩展的。并非所有的特性和功能都集成到语言核心。可以使用C语言、C++、Cython来编写扩展模块。Python解释器本身也可以被集成到其它需要脚本语言的程序内。因此，很多人还把Python作为一种「胶水语言」（glue language）使用。使用Python将其他语言编写的程序进行集成和封装。在Google内部的很多项目使用C++编写性能要求极高的部分，然后用Python调用相应的模块。Python的特点：1、第一行是特殊形式的注释：它被称作 组织行 ――源文件的头两个字符是#!，后面跟着一个程序。这行告诉你的Linux/Unix系统当你 执行 你的程序的时候，它应该运行哪个解释器。建议使用这种形式――#!/usr/bin/env python，而不是――#!/usr/bin/python。 2、缩进很重要。Python使用缩进而不是一对花括号来划分语句块。 3、关键参数的概念很有用 4、None 返回"没有任何东西"，每一个函数默认返回None 5、pass 空语句块 6、文档字符串，__doc__，没多大用。但是一个好的Python程序，应该要有文档字符串，且一般遵循：“文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 ” 6、python中引入模块后（import）首先就要执行模块的主块，当然模块中可能全是函数。如果要避免使用模块名称：from 模块名 import 符号名，那麽使用该符号名就不用使用模块名＋点号＋符号名，但是不推荐，容易造成程序不容易读，而且容易出错（特别是在python简洁而简单的语法的基础上）　import... as ...　起一个别名 7、模块的__name__属性，相当有用，解决了import的缺点，可以实现如果不是运行的本模块而被调用，不调用主块#!/usr/bin/env python# Filename: using_name.pyif __name__ == '__main__':print 'This program is being run by itself'else:print 'I am being imported from another module'8、删除一个变量/名称，你将无法再使用该变量――它就好像从来没有存在过一样。 9、可以使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表 10、元组语法与list相似，意义相当于枚举，可以为空，如果只含有一个元素，需要加逗号以区别于表达式（“one”, ） 11、元组最通常的用法是用在打印语句中，可以使用格式控制符#!/usr/bin/env python# Filename: print_tuple.pyage = 22name = 'Swaroop'print '%s is %d years old' % (name, age)print 'Why is %s playing with that python?' % name12、有一个内建的字典类型，但是没有冲突的解决方案，但这确实是字典的定义，想要更好的结构就自己实现吧。语法：｛key:value, key1:value1,...｝ 13、序列的概念：列表、元组和字符串都是序列，支持索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列。索引可以是负数，在那样的情况下，位置是从序列尾开始计算的。序列的神奇之处在于你可以用相同的方法访问元组、列表和字符串。 14、如果你想要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单 对象 ），那么你必须使用切片操作符来取得拷贝。如果你只是想要使用另一个变量名，两个名称都 参考 同一个对象，那么如果你不小心的话，可能会引来各种麻烦。［浅拷贝和深拷贝的关系］ 15、str类有很多方法，如果要非常熟悉str的操作，参考help(str) 16、剩下的就是掌握很多系统库了，这个要靠经验，比如说os.system(命令)可用于执行shell命令，了解的库越多，python就会让你完成更强大的功能。 17、接下来是面向对象，基本概念一样，this由代替self， 而且这个名字不一定要写成self，任何名字都可以，这也带来了一个缺点，你必须在形参里面指定，调用函数时不用传递该参数。构造函数：__init__(self, ......)析构函数：__del__ 对象灭亡时或者调用del时被调用Python中所有的类成员（包括数据成员）都是公共的 ，所有的方法都是有效的 。只有一个例外：如果你使用的数据成员名称以 双下划线前缀 比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。支持多重继承 18、如果你已经厌烦了java、c＋＋的读写文件，那么python会让你重新喜欢上文件读写，python主张解决问题的方案越少越好，写文件就一个f ＝ file(name, 'w')，f.write(...)读文件也一样，f = file(name)，f.read或readline，最后close 19、cPickle和pickle是叫做存储器的重要模块，可以非常方便地将一个对象存储到一个文件，然后再取存储从文件中取出来pickle.dump(object, file object)，构造对象时，pickle.load(file object) [储存、取存储] 20、异常：raise，except,try...finally 21、sys模块和os模块有很多强大功能。 22、在函数中接收元组和列表当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。这种方法在函数需要获取可变数量的参数的时候特别有用。 23、lambda形式：lambda语句被用来创建新的函数对象，并且在运行时返回它们。lambda语句用&来创建函数对象。本质上，lambda需要一个参数，后面仅跟单个表达式作为函数体，而表达式的值被这个新建的函数返回。注意，即便是print语句也不能用在lambda形式中，只能使用表达式。 24、exec、eval、assert、repr函数和反引号用来获取对象的可打印的表示形式。你可以通过定义类的__repr__方法来控制你的对象在被repr函数调用的时候返回的内容。 最后，感谢实习所在公司给我足够的时间和机会去学习新的东西。还有要感谢学习Python期间，编写参阅资料的人。期间我参阅了下面的资料（包括上面推荐的资料）：wiki：http://zh.wikipedia.org/zh/Python Chinaunix的Python论坛资料 《OReilly-Learning-Python-4th-Edition-Oct-2009》 当然还有前面提到过的入门资料：简明 Python 教程（中），对应的英文版是A Byte of Python
01-2601-2601-0608-1708-0104-2202-2502-1611-0610-21
阅读本文后您有什么感想? 已有23人给出评价!
名称大小下载