Python中利用sorted函数排序的简单教程（共10篇）由网友“奇思妙想李歪歪”投稿提供，以下是小编为大家准备的Python中利用sorted函数排序的简单教程，仅供参考，欢迎大家阅读。
篇1：Python中利用sorted函数排序的简单教程
作者：廖雪峰 字体：[增加 减小] 类型：
这篇文章主要介绍了Python中利用sorted函数排序的简单教程,sorted()函数有返回值,在Python的排序实现中发挥着相当重要的作用,需要的朋友可以参考下
排序算法
排序也是在程序中经常用到的算法，无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。
Python内置的sorted()函数就可以对list进行排序：
>>> sorted([36, 5, 12, 9, 21])[5, 9, 12, 21, 36]
此外，sorted()函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如，如果要倒序排序，我们就可以自定义一个reversed_cmp函数：
def reversed_cmp(x, y): if x > y: return -1 if x < y: return 1 return 0
传入自定义的比较函数reversed_cmp，就可以实现倒序排序：
>>> sorted([36, 5, 12, 9, 21], reversed_cmp)[36, 21, 12, 9, 5]
我们再看一个字符串排序的例子：
>>> sorted([‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘])[‘Credit‘, ‘Zoo‘, ‘about‘, ‘bob‘]
默认情况下，对字符串排序，是按照ASCII的大小比较的，由于‘Z‘ < ‘a‘，结果，大写字母Z会排在小写字母a的前面，
现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能定义出忽略大小写的比较算法就可以：
def cmp_ignore_case(s1, s2): u1 = s1.upper() u2 = s2.upper() if u1 < u2: return -1 if u1 > u2: return 1 return 0
忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。
这样，我们给sorted传入上述比较函数，即可实现忽略大小写的排序：
>>> sorted([‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘], cmp_ignore_case)[‘about‘, ‘bob‘, ‘Credit‘, ‘Zoo‘]
从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。
篇2：python使用sorted函数对列表进行排序的方法
作者：令狐不聪 字体：[增加 减小] 类型：转载
这篇文章主要介绍了python使用sorted函数对列表进行排序的方法,涉及Python使用sorted函数的技巧,非常具有实用价值,需要的朋友可以参考下
本文实例讲述了python使用sorted函数对列表进行排序的方法，分享给大家供大家参考。具体如下：
python提供了sorted函数用于对列表进行排序，并且可以按照正序或者倒序进行排列
#创建一个数字组成的列表numbers = [5, 1, 4, 3, 2, 6, 7, 9] #输出排序后的数字数组print sorted(numbers) #输出原始数组，并未被改变print numbers my_string = [‘aa‘, ‘BB‘, ‘zz‘, ‘CC‘, ‘dd‘, “EE”] #按字符顺序对字符串列表进行排序，默认为按字符顺序排序print sorted(my_string) #使用reverse=True按照首字符的倒序进行排序print sorted(strs, reverse=True)## [‘zz‘, ‘aa‘, ‘CC‘, ‘BB‘]
希望本文所述对大家的Python程序设计有所帮助，
篇3：Python中自定义函数的教程
作者：廖雪峰 字体：[增加 减小] 类型：
这篇文章主要介绍了简单讲解Python中内置函数的使用,函数的使用是Python学习当中的基本功,需要的朋友可以参考下
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回，
我们以自定义一个求绝对值的my_abs函数为例：
def my_abs(x): if x >= 0: return x else: return -x
请自行测试并调用my_abs看看返回结果是否正确。
请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
return None可以简写为return。
空函数
如果想定义一个什么事也不做的空函数，可以用pass语句：
def nop: pass
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
pass还可以用在其他语句里，比如：
if age >= 18: pass
缺少了pass，代码运行就会有语法错误。
参数检查
调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError：
>>> my_abs(1, 2)Traceback (most recent call last): File “ 但是如果参数类型不对，Python解释器就无法帮我们检查。试试my_abs和内置函数abs的差别： >>> my_abs(‘A‘)‘A‘>>> abs(‘A‘)Traceback (most recent call last): File “ 当传入了不恰当的参数时，内置函数abs会检查出参数错误，而我们定义的my_abs没有参数检查，所以，这个函数定义不够完善， 让我们修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance实现： def my_abs(x): if not isinstance(x, (int, float)): raise TypeError(‘bad operand type‘) if x >= 0: return x else: return -x 添加了参数检查后，如果传入错误的参数类型，函数就可以抛出一个错误： >>> my_abs(‘A‘)Traceback (most recent call last): File “ 错误和异常处理将在后续讲到。 返回多个值 函数可以返回多个值吗？答案是肯定的。 比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标： import mathdef move(x, y, step, angle=0): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny 这样我们就可以同时获得返回值： >>> x, y = move(100, 100, 60, math.pi / 6)>>> print x, y151.961524227 70.0 但其实这只是一种假象，Python函数返回的仍然是单一值： >>> r = move(100, 100, 60, math.pi / 6)>>> print r(151.96152422706632, 70.0) 原来返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。 小结 定义函数时，需要确定函数名和参数个数； 如果有必要，可以先对参数的数据类型做检查； 函数体内部可以用return随时返回函数结果； 函数执行完毕也没有return语句时，自动return None。 函数可以同时返回多个值，但其实就是一个tuple。 作者：Yi_Zhi_Yu 字体：[增加 减小] 类型：转载 时间：-08-17 这篇文章主要介绍了Python中map,reduce,filter和sorted函数的使用方法,是Python入门学习中的基础知识,需要的朋友可以参考下 map map(funcname, list) python的map 函数使得函数能直接以list的每个元素作为参数传递到funcname中, 并返回响应的新的list 如下: def sq(x): return x*x #求x的平方map(sq, [1,3, 5,7,9]) #[1, 9, 25, 49, 81] 在需要对list中的每个元素做转换的时候, 会很方便 比如,把list中的每个int 转换成str map(str, [23,43,4545,324]) #[‘23‘, ‘43‘, ‘4545‘, ‘324‘] 当然, 第二个参数是list, 也可以是tuple 或者是set类list结构的, dict 是不行的,不过返回的结果都是list map(sq, (1,3, 5,7,9)) # tuple [1, 9, 25, 49, 81]map(sq, set([1,3, 5,3,7,9])) # set [1, 9, 81, 25, 49] 这里顺便说一下, dict的结构是用{} 表示的,如 {“name”: “Yi_Zhi_Yu”, “age”:25} 是直观的key-value形式, 那么如果{}中的是一个类list的结构呢, 如: {“Yi_Zhi_Yu”, 25} 其实, 这就是set的最终返回形式, 等价于: set([“Yi_Zhi_Yu”, 25])# 你会看到最终的输出形式是{25, ‘Yi_Zhi_Yu‘} 那么, 自然{}有重复值得时候也会去重 {1,3, 5, 3, 7, 9} #{1, 3, 5, 7, 9} reduce reduce(funcname, list) 与map相比 , reduce类似于一个聚合类的应用方法, 把list中的参数, 依次传递给funcname, 每次funcname的参数都是上个funcname 执行结果和下一个list中的元素, 所以, funcname 的 参数必须是两个. 从执行过程看, 有点像递归 例如: 求range(1, 101)(不包括101)的和, def c_sum(x, y): return x + y;reduce(c_sum, range(1,101)) #5050 filter filter(funcname, list) 执行过程依次将list中的元素传递到funcname函数中, 根据funcname返回的True或False 保留或丢弃元素 例: 返回某个list中的所有int数据 def is_int(x): if isinstance(x, (int)): return True else: return False filter(is_int, [“Yi”,2, “3”, 4]) #[2, 4]sortedsorted( list, [comp_func]) 排序方法, 第二个是可选参数, 根据可选参数返回的值, 对结果进行排序, comp_func 接受两个参数(x, y), 最终返回的结果应该是-1.0,1, 如果返回的是-1, 表示x 默认是正序排序: sorted([3,4, 12, 5, 9, 1]) #[1, 3, 4, 5, 9, 12] 如果是需要倒序排列, 自定义方法: def m_order(x, y): if(x > y): return -1 elif(x == y): return 0 else: return 1sorted([3,4, 12, 5, 9, 1], m_order) #[12, 9, 5, 4, 3, 1]
简介 函数是重用的程序段，它们允许你给一块语句一个名称，然后你可以在你的程序的任何地方使用这个名称任意多次地运行这个语句块。这被称为 调用 函数。我们已经使用了许多内建的函数，比如len和range。 函数通过def关键字定义。def关键字后跟一个函数的 标识符 名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。下面这个例子将说明这事实上是十分简单的： 定义函数 例7.1 定义函数 # Filename: function1.py def sayHello: print 'Hello World!' # block belonging to the function sayHello() # call the function （源文件：code/function1.py） 输出 Hello World! 它如何工作 我们使用上面解释的语法定义了一个称为sayHello的函数。这个函数不使用任何参数，因此在圆括号中没有声明任何变量。参数对于函数而言，只是给函数的输入，以便于我们可以传递不同的值给函数，然后得到相应的结果。 函数形参 函数取得的参数是你提供给函数的值，这样函数就可以利用这些值 做 一些事情。这些参数就像变量一样，只不过它们的值是在我们调用函数的时候定义的，而非在函数本身内赋值。 参数在函数定义的圆括号对内指定，用逗号分割。当我们调用函数的时候，我们以同样的方式提供值。注意我们使用过的术语——函数中的参数名称为 形参 而你提供给函数调用的值称为 实参 。 使用函数形参 例7.2 使用函数形参 # Filename: func_param.py def printMax(a, b): if a > b: print a, 'is maximum' else: print b, 'is maximum' printMax(3, 4) # directly give literal values x = 5 y = 7 printMax(x, y) # give variables as arguments （源文件：code/func_param.py） 输出 4 is maximum 7 is maximum 它如何工作 这里，我们定义了一个称为printMax的函数，这个函数需要两个形参，叫做a和b。我们使用if..else语句找出两者之中较大的一个数，并且打印较大的那个数。 在第一个printMax使用中，我们直接把数，即实参，提供给函数。在第二个使用中，我们使用变量调用函数。printMax(x, y)使实参x的值赋给形参a，实参y的值赋给形参b。在两次调用中，printMax函数的工作完全相同。 局部变量 当你在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。 使用局部变量 例7.3 使用局部变量 # Filename: func_local.py def func(x): print 'x is', x x = 2 print 'Changed local x to', x x = 50 func(x) print 'x is still', x （源文件：code/func_local.py） 输出 x is 50 Changed local x to 2 x is still 50 它如何工作 在函数中，我们第一次使用x的 值 的时候，Python使用函数声明的形参的值。 接下来，我们把值2赋给x。x是函数的局部变量。所以，当我们在函数内改变x的值的时候，在主块中定义的x不受影响。 在最后一个print语句中，我们证明了主块中的x的值确实没有受到影响。 使用global语句 如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。我们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。 你可以使用定义在函数外的变量的值（假设在函数内没有同名的变量）。然而，我并不鼓励你这样做，并且你应该尽量避免这样做，因为这使得程序的读者会不清楚这个变量是在哪里定义的。使用global语句可以清楚地表明变量是在外面的块定义的。 例7.4 使用global语句 # Filename: func_global.py def func(): global x print 'x is', x x = 2 print 'Changed local x to', x x = 50 func() print 'Value of x is', x （源文件：code/func_global.py） 输出 x is 50 Changed global x to 2 Value of x is 2 它如何工作 global语句被用来声明x是全局的——因此，当我们在函数内把值赋给x的时候，这个变化也反映在我们在主块中使用x的值的时候。 你可以使用同一个global语句指定多个全局变量。例如global x, y, z。 默认参数值 对于一些函数，你可能希望它的一些参数是 可选 的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值。这个功能借助于默认参数值完成。你可以在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。 注意，默认参数值应该是一个参数。更加准确的说，默认参数值应该是不可变的——这会在后面的章节中做详细解释。从现在开始，请记住这一点。 使用默认参数值 例7.5 使用默认参数值 # Filename: func_default.py def say(message, times = 1): print message * times say('Hello') say('World', 5) （源文件：code/func_default.py） 输出 Hello WorldWorldWorldWorldWorld 它如何工作 名为say的函数用来打印一个字符串任意所需的次数， 如果我们不提供一个值，那么默认地，字符串将只被打印一遍。我们通过给形参times指定默认参数值1来实现这一功能。 在第一次使用say的时候，我们只提供一个字符串，函数只打印一次字符串。在第二次使用say的时候，我们提供了字符串和参数5，表明我们想要 说 这个字符串消息5遍。 重要 只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。 这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，但是def func(a=5, b)是 无效 的。 关键参数 如果你的某个函数有许多参数，而你只想指定其中的一部分，那么你可以通过命名来为这些参数赋值——这被称作 关键参数 ——我们使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。 这样做有两个 优势 ——一，由于我们不必担心参数的顺序，使用函数变得更加简单了。二、假设其他参数都有默认值，我们可以只给我们想要的那些参数赋值。 使用关键参数 例7.6 使用关键参数 # Filename: func_key.py def func(a, b=5, c=10): print 'a is', a, 'and b is', b, 'and c is', c func(3, 7) func(25, c=24) func(c=50, a=100) （源文件：code/func_key.py） 输出 a is 3 and b is 7 and c is 10 a is 25 and b is 5 and c is 24 a is 100 and b is 5 and c is 50 它如何工作 名为func的函数有一个没有默认值的参数，和两个有默认值的参数。 在第一次使用函数的时候， func(3, 7)，参数a得到值3，参数b得到值7，而参数c使用默认值10。 在第二次使用函数func(25, c=24)的时候，根据实参的位置变量a得到值25。根据命名，即关键参数，参数c得到值24。变量b根据默认值，为5。 在第三次使用func(c=50, a=100)的时候，我们使用关键参数来完全指定参数值。注意，尽管函数定义中，a在c之前定义，我们仍然可以在a之前指定参数c的值。 return语句 return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值 。 使用字面意义上的语句 例7.7 使用字面意义上的语句 # Filename: func_return.py def maximum(x, y): if x > y: return x else: return y print maximum(2, 3) （源文件：code/func_return.py） 输出 3 它如何工作 maximum函数返回参数中的最大值，在这里是提供给函数的数。它使用简单的if..else语句来找出较大的值，然后 返回 那个值。 注意，没有返回值的return语句等价于return None。None是Python中表示没有任何东西的特殊类型。例如，如果一个变量的值为None，可以表示它没有值。 除非你提供你自己的return语句，每个函数都在结尾暗含有return None语句。通过运行print someFunction()，你可以明白这一点，函数someFunction没有使用return语句，如同： pass pass语句在Python中表示一个空的语句块。 DocStrings Python有一个很奇妙的特性，称为 文档字符串 ，它通常被简称为 docstrings 。DocStrings是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。你甚至可以在程序运行的时候，从函数恢复文档字符串！ 使用DocStrings 例7.8 使用DocStrings # Filename: func_doc.py def printMax(x, y): '''Prints the maximum of two numbers. The two values must be integers.''' x = int(x) # convert to integers, if possible y = int(y) if x > y: print x, 'is maximum' else: print y, 'is maximum' printMax(3, 5) print printMax.__doc__ （源文件：code/func_doc.py） 输出 5 is maximum Prints the maximum of two numbers. The two values must be integers. 它如何工作 在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意，DocStrings也适用于模块和类，我们会在后面相应的章节学习它们。 文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议 你在你的函数中使用文档字符串时遵循这个惯例。 你可以使用__doc__（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。请记住Python把 每一样东西 都作为对象，包括这个函数。我们会在后面的类一章学习更多关于对象的知识。 如果你已经在Python中使用过help()，那么你已经看到过DocStings的使用了！它所做的只是抓取函数的__doc__属性，然后整洁地展示给你。你可以对上面这个函数尝试一下——只是在你的程序中包括help(printMax)。记住按q退出help。 自动化工具也可以以同样的方式从你的程序中提取文档。因此，我 强烈建议 你对你所写的任何正式函数编写文档字符串。随你的Python发行版附带的pydoc命令，与help()类似地使用DocStrings。 概括 我们已经学习了函数的很多方面的知识，不过注意还有一些方面我们没有涉及。然而，我们已经覆盖了大多数在日常使用中，你可能用到的Python函数知识。 接下来，我们将学习如何创建和使用Python模块。 这篇文章主要介绍了在Python中使用sort()方法进行排序的简单教程,是Python学习中的基础知识,需要的朋友可以参考下 sort()方法排序列表中的对象，比较使用func(如果给定)， 语法 以下是sort()方法的语法： list.sort([func]) 参数 func -- 这是一个可选参数，如果有将使用该函数，对列表中的对象进行排序 返回值 此方法不返回任何值，但是从列表中给定的对象进行排序 例子 下面的例子显示了sort()方法的使用 #!/usr/bin/pythonaList = [123, ‘xyz‘, ‘zara‘, ‘abc‘, ‘xyz‘];aList.sort();print “List : ”, aList; 当我们运行上面的程序，它会产生以下结果： List : [123, ‘abc‘, ‘xyz‘, ‘xyz‘, ‘zara‘]
作者：廖雪峰 字体：[增加 减小] 类型： 这篇文章主要介绍了Python中的filter函数的用法,代码基于Python2.x版本,需要的朋友可以参考下 Python内建的filter()函数用于过滤序列， 和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。 例如，在一个list中，删掉偶数，只保留奇数，可以这么写： def is_odd(n): return n % 2 == 1filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])# 结果: [1, 5, 9, 15] 把一个序列中的空字符串删掉，可以这么写： def not_empty(s): return s and s.strip()filter(not_empty, [‘A‘, ‘‘, ‘B‘, None, ‘C‘, ‘ ‘])# 结果: [‘A‘, ‘B‘, ‘C‘] 可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数， 练习 请尝试用filter()删除1~100的素数。 作者：廖雪峰 字体：[增加 减小] 类型：转载 这篇文章主要介绍了Python中函数的参数,掌握函数中的参数传递在任何一门语言的学习过程当中都是基本功,需要的朋友可以参考下 定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了，对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。 Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。 默认参数 我们仍以具体的例子来说明如何定义函数的默认参数。先写一个计算x2的函数： def power(x): return x * x 当我们调用power函数时，必须传入有且仅有的一个参数x： >>> power(5)25>>> power(15)225 现在，如果我们要计算x3怎么办？可以再定义一个power3函数，但是如果要计算x4、x5……怎么办？我们不可能定义无限多个函数。 你也许想到了，可以把power(x)修改为power(x, n)，用来计算xn，说干就干： def power(x, n): s = 1 while n > 0: n = n - 1 s = s * x return s 对于这个修改后的power函数，可以计算任意n次方： >>> power(5, 2)25>>> power(5, 3)125 但是，旧的调用代码失败了，原因是我们增加了一个参数，导致旧的代码无法正常调用： >>> power(5)Traceback (most recent call last): File “ 这个时候，默认参数就排上用场了。由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2： def power(x, n=2): s = 1 while n > 0: n = n - 1 s = s * x return s 这样，当我们调用power(5)时，相当于调用power(5, 2)： >>> power(5)25>>> power(5, 2)25 而对于n > 2的其他情况，就必须明确地传入n，比如power(5, 3)。 从上面的例子可以看出，默认参数可以简化函数的调用。设置默认参数时，有几点要注意： 一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）； 二是如何设置默认参数。 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。 使用默认参数有什么好处？最大的好处是能降低调用函数的难度。 举个例子，我们写个一年级小学生注册的函数，需要传入name和gender两个参数： def enroll(name, gender): print ‘name:‘, name print ‘gender:‘, gender 这样，调用enroll()函数只需要传入两个参数： >>> enroll(‘Sarah‘, ‘F‘)name: Sarahgender: F 如果要继续传入年龄、城市等信息怎么办？这样会使得调用函数的复杂度大大增加。 我们可以把年龄和城市设为默认参数： def enroll(name, gender, age=6, city=‘Beijing‘): print ‘name:‘, name print ‘gender:‘, gender print ‘age:‘, age print ‘city:‘, city 这样，大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数： >>> enroll(‘Sarah‘, ‘F‘)Student:name: Sarahgender: Fage: 6city: Beijing 只有与默认参数不符的学生才需要提供额外的信息： enroll(‘Bob‘, ‘M‘, 7)enroll(‘Adam‘, ‘M‘, city=‘Tianjin‘) 可见，默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无论是简单调用还是复杂调用，函数只需要定义一个。 有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如调用enroll(‘Bob‘, ‘M‘, 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。 也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll(‘Adam‘, ‘M‘, city=‘Tianjin‘)，意思是，city参数用传进去的值，其他默认参数继续使用默认值。 默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑，演示如下： 先定义一个函数，传入一个list，添加一个END再返回： def add_end(L=[]): L.append(‘END‘) return L 当你正常调用时，结果似乎不错： >>> add_end([1, 2, 3])[1, 2, 3, ‘END‘]>>> add_end([‘x‘, ‘y‘, ‘z‘])[‘x‘, ‘y‘, ‘z‘, ‘END‘] 当你使用默认参数调用时，一开始结果也是对的： >>> add_end()[‘END‘] 但是，再次调用add_end()时，结果就不对了： >>> add_end()[‘END‘, ‘END‘]>>> add_end()[‘END‘, ‘END‘, ‘END‘] 很多初学者很疑惑，默认参数是[]，但是函数似乎每次都“记住了”上次添加了‘END‘后的list。 原因解释如下： Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。 所以，定义默认参数要牢记一点：默认参数必须指向不变对象！ 要修改上面的例子，我们可以用None这个不变对象来实现： def add_end(L=None): if L is None: L = [] L.append(‘END‘) return L 现在，无论调用多少次，都不会有问题： >>> add_end()[‘END‘]>>> add_end()[‘END‘] 为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误， 此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。 可变参数 在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。 我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。 要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下： def calc(numbers): sum = 0 for n in numbers: sum = sum + n * n return sum 但是调用的时候，需要先组装出一个list或tuple： >>> calc([1, 2, 3])14>>> calc((1, 3, 5, 7))84 如果利用可变参数，调用函数的方式可以简化成这样： >>> calc(1, 2, 3)14>>> calc(1, 3, 5, 7)84 所以，我们把函数的参数改为可变参数： def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return sum 定义可变参数和定义list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数： >>> calc(1, 2)5>>> calc()0 如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做： >>> nums = [1, 2, 3]>>> calc(nums[0], nums[1], nums[2])14 这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去： >>> nums = [1, 2, 3]>>> calc(*nums)14 这种写法相当有用，而且很常见。 关键字参数 可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例： def person(name, age, **kw): print ‘name:‘, name, ‘age:‘, age, ‘other:‘, kw 函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数： >>> person(‘Michael‘, 30)name: Michael age: 30 other: {} 也可以传入任意个数的关键字参数： >>> person(‘Bob‘, 35, city=‘Beijing‘)name: Bob age: 35 other: {‘city‘: ‘Beijing‘}>>> person(‘Adam‘, 45, gender=‘M‘, job=‘Engineer‘)name: Adam age: 45 other: {‘gender‘: ‘M‘, ‘job‘: ‘Engineer‘} 关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。 和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去： >>> kw = {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}>>> person(‘Jack‘, 24, city=kw[‘city‘], job=kw[‘job‘])name: Jack age: 24 other: {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘} 当然，上面复杂的调用可以用简化的写法： >>> kw = {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}>>> person(‘Jack‘, 24, **kw)name: Jack age: 24 other: {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘} 参数组合 在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中某些，但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。 比如定义一个函数，包含上述4种参数： def func(a, b, c=0, *args, **kw): print ‘a =‘, a, ‘b =‘, b, ‘c =‘, c, ‘args =‘, args, ‘kw =‘, kw 在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。 >>> func(1, 2)a = 1 b = 2 c = 0 args = () kw = {}>>> func(1, 2, c=3)a = 1 b = 2 c = 3 args = () kw = {}>>> func(1, 2, 3, ‘a‘, ‘b‘)a = 1 b = 2 c = 3 args = (‘a‘, ‘b‘) kw = {}>>> func(1, 2, 3, ‘a‘, ‘b‘, x=99)a = 1 b = 2 c = 3 args = (‘a‘, ‘b‘) kw = {‘x‘: 99} 最神奇的是通过一个tuple和dict，你也可以调用该函数： >>> args = (1, 2, 3, 4)>>> kw = {‘x‘: 99}>>> func(*args, **kw)a = 1 b = 2 c = 3 args = (4,) kw = {‘x‘: 99} 所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。 小结 Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。 默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误！ 要注意定义可变参数和关键字参数的语法： *args是可变参数，args接收的是一个tuple； **kw是关键字参数，kw接收的是一个dict。 以及调用函数时如何传入可变参数和关键字参数的语法： 可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))； 关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{‘a‘: 1, ‘b‘: 2})。 使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。 作者：崔庆才 字体：[增加 减小] 类型： 这篇文章主要介绍了Python中正则表达式的详细教程,正则表达式是Python学习进阶当中的重要内容,需要的朋友可以参考下 1.了解正则表达式 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑， 正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念，Python同样不例外，利用了正则表达式，我们想要从返回的页面内容提取出我们想要的内容就易如反掌了。 正则表达式的大致匹配过程是： 1.依次拿出表达式和文本中的字符比较， 2.如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。 3.如果表达式中有量词或边界，这个过程会稍微有一些不同。 2.正则表达式的语法规则 下面是Python中正则表达式的一些匹配规则，图片资料来自CSDN 3.正则表达式相关注解 （1）数量词的贪婪模式与非贪婪模式 正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字 符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量 词”ab*?”，将找到”a”。 注：我们一般使用非贪婪模式来提取。 （2）反斜杠问题 与大多数编程语言相 同，正则表达式里使用””作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符””，那么使用编程语言表示的正则表达式里将需要4个反 斜杠””：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。 Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r””表示。同样，匹配一个数字的”d”可以写成r”d”。有了原生字符串，妈妈也不用担心是不是漏写了反斜杠，写出来的表达式也更直观勒。 4.Python Re模块 Python 自带了re模块，它提供了对正则表达式的支持。主要用到的方法列举如下 #返回pattern对象re.compile(string[,flag]) #以下为匹配所用函数re.match(pattern, string[, flags])re.search(pattern, string[, flags])re.split(pattern, string[, maxsplit])re.findall(pattern, string[, flags])re.finditer(pattern, string[, flags])re.sub(pattern, repl, string[, count])re.subn(pattern, repl, string[, count]) 在介绍这几个方法之前，我们先来介绍一下pattern的概念，pattern可以理解为一个匹配模式，那么我们怎么获得这个匹配模式呢？很简单，我们需要利用re.compile方法就可以。例如 pattern = re.compile(r‘hello‘) 在参数中我们传入了原生字符串对象，通过compile方法编译生成一个pattern对象，然后我们利用这个对象来进行进一步的匹配。 另外大家可能注意到了另一个参数 flags，在这里解释一下这个参数的含义： 参数flag是匹配模式，取值可以使用按位或运算符‘|‘表示同时生效，比如re.I | re.M。 可选值有： ? re.I(全拼：IGNORECASE): 忽略大小写（括号内是完整写法，下同） ? re.M(全拼：MULTILINE): 多行模式，改变‘^‘和‘$‘的行为（参见上图） ? re.S(全拼：DOTALL): 点任意匹配模式，改变‘.‘的行为 ? re.L(全拼：LOCALE): 使预定字符类 w W b B s S 取决于当前区域设定 ? re.U(全拼：UNICODE): 使预定字符类 w W b B s S d D 取决于unicode定义的字符属性 ? re.X(全拼：VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。 在刚才所说的另外几个方法例如 re.match 里我们就需要用到这个pattern了，下面我们一一介绍。 注：以下七个方法中的flags同样是代表匹配模式的意思，如果在pattern生成时已经指明了flags，那么在下面的方法中就不需要传入这个参数了。 （1）re.match(pattern, string[, flags]) 这个方法将会从string（我们要匹配的字符串）的开头开始，尝试匹配pattern，一直向后匹配，如果遇到无法匹配的字符，立即返回 None，如果匹配未结束已经到达string的末尾，也会返回None。两个结果均表示匹配失败，否则匹配pattern成功，同时匹配终止，不再对 string向后匹配。下面我们通过一个例子理解一下 __author__ = ‘CQC‘# -*- coding: utf-8 -*- #导入re模块import re # 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”pattern = re.compile(r‘hello‘) # 使用re.match匹配文本，获得匹配结果，无法匹配时将返回Noneresult1 = re.match(pattern,‘hello‘)result2 = re.match(pattern,‘helloo CQC!‘)result3 = re.match(pattern,‘helo CQC!‘)result4 = re.match(pattern,‘hello CQC!‘) #如果1匹配成功if result1: # 使用Match获得分组信息 print result1.groupelse: print ‘1匹配失败！‘ #如果2匹配成功if result2: # 使用Match获得分组信息 print result2.group()else: print ‘2匹配失败！‘ #如果3匹配成功if result3: # 使用Match获得分组信息 print result3.group()else: print ‘3匹配失败！‘ #如果4匹配成功if result4: # 使用Match获得分组信息 print result4.group()else: print ‘4匹配失败！‘ 运行结果 hellohello3匹配失败！hello 匹配分析 1.第一个匹配，pattern正则表达式为‘hello‘，我们匹配的目标字符串string也为hello，从头至尾完全匹配，匹配成功。 2.第二个匹配，string为helloo CQC，从string头开始匹配pattern完全可以匹配，pattern匹配结束，同时匹配终止，后面的o CQC不再匹配，返回匹配成功的信息。 3.第三个匹配，string为helo CQC，从string头开始匹配pattern，发现到 ‘o‘ 时无法完成匹配，匹配终止，返回None 4.第四个匹配，同第二个匹配原理，即使遇到了空格符也不会受影响。 我们还看到最后打印出了result.group()，这个是什么意思呢？下面我们说一下关于match对象的的属性和方法 Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。 属性： 1.string: 匹配时使用的文本。 2.re: 匹配时使用的Pattern对象。 3.pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。 4.endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。 5.lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。 6.lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。 方法： 1.group([group1, …]): 获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。 2.groups([default]): 以元组形式返回全部分组截获的字符串， 相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。 3.groupdict([default]): 返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。 4.start([group]): 返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。 5.end([group]): 返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。 6.span([group]): 返回(start(group), end(group))。 7.expand(template): 将匹配到的分组代入template中然后返回。template中可以使用id或g、g引用分组，但不能使用编号0。id与g是等价的；但10将被认为是第10个分组，如果你想表达1之后是字符‘0‘，只能使用g0。 下面我们用一个例子来体会一下 # -*- coding: utf-8 -*-#一个简单的match实例 import re# 匹配如下内容：单词+空格+单词+任意字符m = re.match(r‘(w+) (w+)(?P.*)‘, ‘hello world!‘) print “m.string:”, m.stringprint “m.re:”, m.reprint “m.pos:”, m.posprint “m.endpos:”, m.endposprint “m.lastindex:”, m.lastindexprint “m.lastgroup:”, m.lastgroupprint “m.group():”, m.group()print “m.group(1,2):”, m.group(1, 2)print “m.groups():”, m.groups()print “m.groupdict():”, m.groupdict()print “m.start(2):”, m.start(2)print “m.end(2):”, m.end(2)print “m.span(2):”, m.span(2)print r“m.expand(r‘g gg‘):”, m.expand(r‘2 13‘) ### output #### m.string: hello world!# m.re: # m.pos: 0# m.endpos: 12# m.lastindex: 3# m.lastgroup: sign# m.group(1,2): (‘hello‘, ‘world‘)# m.groups(): (‘hello‘, ‘world‘, ‘!‘)# m.groupdict(): {‘sign‘: ‘!‘}# m.start(2): 6# m.end(2): 11# m.span(2): (6, 11)# m.expand(r‘2 13‘): world hello! （2）re.search(pattern, string[, flags]) search方法与match方法极其类似，区别在于match()函数只检测re是不是在string的开始位置匹配，search()会扫描整个string查找匹配，match只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回None。同样，search方法的返回对象同样match()返回对象的方法和属性。我们用一个例子感受一下 #导入re模块import re # 将正则表达式编译成Pattern对象pattern = re.compile(r‘world‘)# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None# 这个例子中使用match()无法成功匹配match = re.search(pattern,‘hello world!‘)if match: # 使用Match获得分组信息 print match.group()### 输出 #### world （3）re.split(pattern, string[, maxsplit]) 按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。我们通过下面的例子感受一下。 import re pattern = re.compile(r‘d+‘)print re.split(pattern,‘one1two2three3four4‘) ### 输出 #### [‘one‘, ‘two‘, ‘three‘, ‘four‘, ‘‘] （4）re.findall(pattern, string[, flags]) 搜索string，以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下 import re pattern = re.compile(r‘d+‘)print re.findall(pattern,‘one1two2three3four4‘) ### 输出 #### [‘1‘, ‘2‘, ‘3‘, ‘4‘] （5）re.finditer(pattern, string[, flags]) 搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。我们通过下面的例子来感受一下 import re pattern = re.compile(r‘d+‘)for m in re.finditer(pattern,‘one1two2three3four4‘): print m.group(), ### 输出 #### 1 2 3 4 （6）re.sub(pattern, repl, string[, count]) 使用repl替换string中每一个匹配的子串后返回替换后的字符串。 当repl是一个字符串时，可以使用id或g、g引用分组，但不能使用编号0。 当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。 count用于指定最多替换次数，不指定时全部替换。 import re pattern = re.compile(r‘(w+) (w+)‘)s = ‘i say, hello world!‘ print re.sub(pattern,r‘2 1‘, s) def func(m): return m.group(1).title() + ‘ ‘ + m.group(2).title() print re.sub(pattern,func, s) ### output #### say i, world hello!# I Say, Hello World! （7）re.subn(pattern, repl, string[, count]) 返回 (sub(repl, string[, count]), 替换次数)。 import re pattern = re.compile(r‘(w+) (w+)‘)s = ‘i say, hello world!‘ print re.subn(pattern,r‘2 1‘, s) def func(m): return m.group(1).title() + ‘ ‘ + m.group(2).title() print re.subn(pattern,func, s) ### output #### (‘say i, world hello!‘, 2)# (‘I Say, Hello World!‘, 2) 5.Python Re模块的另一种使用方式 在上面我们介绍了7个工具方法，例如match，search等等，不过调用方式都是 re.match，re.search的方式，其实还有另外一种调用方式，可以通过pattern.match，pattern.search调用，这样 调用便不用将pattern作为第一个参数传入了，大家想怎样调用皆可。 函数API列表 match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]) 具体的调用方法不必详说了，原理都类似，只是参数的变化不同。小伙伴们尝试一下吧~ 小伙伴们加油，即使这一节看得云里雾里的也没关系，接下来我们会通过一些实战例子来帮助大家熟练掌握正则表达式的。 作者：廖雪峰 字体：[增加 减小] 类型：转载 这篇文章主要介绍了在Python中使用模块的教程,示例代码基于Python2.x版本,需要的朋友可以参考下 Python本身就内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用， 我们以内建的sys模块为例，编写一个hello的模块： #!/usr/bin/env python# -*- coding: utf-8 -*-‘ a test module ‘__author__ = ‘Michael Liao‘import sysdef test(): args = sys.argv if len(args)==1: print ‘Hello, world!‘ elif len(args)==2: print ‘Hello, %s!‘ % args[1] else: print ‘Too many arguments!‘if __name__==‘__main__‘: test() 第1行和第2行是标准注释，第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码； 第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释； 第6行使用__author__变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名； 以上就是Python模块的标准文件模板，当然也可以全部删掉不写，但是，按标准办事肯定没错。 后面开始就是真正的代码部分。 你可能注意到了，使用sys模块的第一步，就是导入该模块： import sys 导入sys模块后，我们就有了变量sys指向该模块，利用sys这个变量，就可以访问sys模块的所有功能。 sys模块有一个argv变量，用list存储了命令行的所有参数。argv至少有一个元素，因为第一个参数永远是该.py文件的名称，例如： 运行python hello.py获得的sys.argv就是[‘hello.py‘]； 运行python hello.py Michael获得的sys.argv就是[‘hello.py‘, ‘Michael]。 最后，注意到这两行代码： if __name__==‘__main__‘: test() 当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。 我们可以用命令行运行hello.py看看效果： $ python hello.pyHello, world!$ python hello.py MichaelHello, Michael! 如果启动Python交互环境，再导入hello模块： $ pythonPython 2.7.5 (default, Aug 25 2013, 00:04:04) [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] on darwinType “help”, “copyright”, “credits” or “license” for more information.>>> import hello>>> 导入时，没有打印Hello, word!，因为没有执行test()函数， 调用hello.test()时，才能打印出Hello, word!： >>> hello.test()Hello, world! 别名 导入模块时，还可以使用别名，这样，可以在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库，这两个库的接口和功能是一样的，但是cStringIO是C写的，速度更快，所以，你会经常看到这样的写法： try: import cStringIO as StringIOexcept ImportError: # 导入失败会捕获到ImportError import StringIO 这样就可以优先导入cStringIO。如果有些平台不提供cStringIO，还可以降级使用StringIO。导入cStringIO时，用import ... as ...指定了别名StringIO，因此，后续代码引用StringIO即可正常工作。 还有类似simplejson这样的库，在Python 2.6之前是独立的第三方库，从2.6开始内置，所以，会有这样的写法： try: import json # python >= 2.6except ImportError: import simplejson as json # python <= 2.5 由于Python是动态语言，函数签名一致接口就一样，因此，无论导入哪个模块后续代码都能正常工作。 作用域 在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。 正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等； 类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名； 类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等； 之所以我们说，private函数和变量“不应该”被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。 private函数或变量不应该被别人引用，那它们有什么用呢？请看例子： def _private_1(name): return ‘Hello, %s‘ % namedef _private_2(name): return ‘Hi, %s‘ % namedef greeting(name): if len(name) > 3: return _private_1(name) else: return _private_2(name) 我们在模块里公开greeting()函数，而把内部逻辑用private函数隐藏起来了，这样，调用greeting()函数不用关心内部的private函数细节，这也是一种非常有用的代码封装和抽象的方法，即： 外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。 ★ 排序算法总结 ★ 近邻作文 【Python中利用sorted函数排序的简单教程（共10篇）】相关文章： python开发的小球完全弹性碰撞游戏代码2022-12-05 InnoDBInsert（插入）操作（下）mysql技术内幕2022-04-30 网数据库的代码集合2022-12-27 python实现中文分词FMM算法实例2023-05-16 python基础教程之基本内置数据类型介绍2022-08-15 python基础教程之字典操作详解2023-04-25 回调函数（真好理解）2022-09-24 python使用正则表达式检测密码强度源码2022-09-03 uniqueidentifier 数据类型数据库教程2022-09-27 python自定义解析简单xml格式文件的方法2022-05-07篇4：Python中map,reduce,filter和sorted函数的使用方法
篇5：简明Python教程 第7章 函数
#!/usr/bin/python$ python function1.py#!/usr/bin/python$ python func_param.py#!/usr/bin/python$ python func_local.py#!/usr/bin/python$ python func_global.py#!/usr/bin/python$ python func_default.py#!/usr/bin/python$ python func_key.py#!/usr/bin/python$ python func_return.pydef someFunction():#!/usr/bin/python$ python func_doc.py篇6：在Python中使用sort方法进行排序的简单教程
篇7：Python中的filter函数的用法
篇8：理解Python中函数的参数
篇9：Python中正则表达式的详细教程
篇10：在Python中使用模块的教程
