python改造为函数 python 改写

为什么print在python3中变成了函数

print语句与print函数的区别

print语句

在Python 2中，print语句最简单的使用形式就是print A，这相当于执行了sys.stdout.write(str(A) + '\n')。如果你以逗号为分隔符，传递额外的参数（argument），这些参数会被传递至str()函数，最终打印时每个参数之间会空一格。例如，print A, B, C相当于sys.stdout.write(' '.join(map(str, [A, B, C])) + '\n')。如果print语句的最后再加上一个逗号，那么就不会再添加断行符（\n），也就是说：print A相当于sys.stdout.write(str(A))。

从 2.0版本开始，Python引入了print 的语法，作用是重定向print语句最终输出字符串的文件。例如，print output, A相当于output.write(str(A) + '\n')。

print函数

如果用Python来实现print函数，它的函数定义应该是这样的：

import sysdef print(*objects, sep=None, end=None, file=None, flush=False): """A Python translation of the C code for builtins.print().""" if sep is None: sep = ' ' if end is None: end = '\n' if file is None: file = sys.stdout file.write(sep.join(map(str, objects)) + end) if flush: file.flush()

从上面的代码中，我们可以发现：Python 3中的print函数实现了print语句的所有特性。

print A == print(A)

print A, B, C == print(A, B, C)

print A, == print(A, end='')

print output, A == print(A, file=output)

从上面的示例代码中我们就可以看出，使用print函数有明显的好处：与使用print语句相比，我们现在能够指定其他的分隔符（separator）和结束符（end string）。

关键在于灵活性

将print变成函数的真正巧妙之处在与灵活性，但这点并不容易被人发觉。print成为函数之后，给Python用户和Python开发团队带来了很大的灵活性。对于用户来说，这可以让你把print当作表达式（expression）使用；相比之下，print语句就只能作为语句使用。举个例子，假设你想在每一行后面打印一个省略号（ellipsis），表示这行尚未结束。使用print语句的话，你有两种选择：

# 手动实现 ...

print A, '...'

# 可复用的实现（这种方式也适用于print函数） ...

def ellipsis_print(*args):

for arg in args:

print arg, '',

print '...'

但是在Python 3中，你可以选择更好的解决方式：

# 手动实现 ...print(A, end='...\n')# 多个可复用的解决方案，利用print语句无法实现...ellipsis_print = lambda *args, **kwargs: print(*args, **kwargs, end='...\n')# 或者 ...import functoolsellipsis_print = functools.partial(print, end='...\n')

换句话说，变成函数之后，print就可以组件化了，作为语句的print是无法支持的。还有，你还可以编写自己喜欢的print函数，将其赋值给builtins.print，就可以覆盖掉自带的函数实现了。这一点在Python 2中是不可能实现的。

对于Python开发团队来说，他们不必再从语法层面来实现print的相关功能了。例如，如果你想让print语句也一样可以灵活地支持指定分隔符，你要怎样去实现呢？这会是一个相当难解决的设计难题。但是如果print变成了函数，只需要新增一个参数就解决了。在Python中，函数可以接受任意数量的参数，这比从底层实现语法带来的灵活性要大的多。

我们还要注意，语法实现应该仅限于那些非这样做不可的功能，或者是以语法形式实现后，大幅提高了可读性的功能。在print这个案例中，print A与print(A)之间的区别可以忽略不计，因此并没有影响可读性。而且，由于我们能够完全将print语句替换为函数，对于Python语言的功能性也没有损失。这就是为什么将print变成函数的原因。

相关问答

Q1: python 从键盘输入n 计算1*2*...*n的值？（要求：改为用函数实现）？

def multi(n):

f=1

for i in range(1,n+1):

f = f*i

print(f)

num = int(input("Input number:"))

multi(num )

honey@DESKTOP-H6QG9QG:~% python3 mypy.py

Input number:5

120

Q2: python如何字符串转化为函数计算得小数？eval（）只能转化为整数。就像"2/9-3"结果是-2.77777而不是-3

Python 2.7.1 (r271:86832, Jun 25 2011, 05:09:01)

[GCC 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2335.15.00)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

a = "2/9-3"

print eval(a)

-3

b = "2.0/9-3"

print eval(b)

-2.77777777778

看看a和b的区别，能解决你的问题吗

Q3: python中使用闭包及修改外部函数的局部变量

在python中python改造为函数，函数可以被嵌套定义，也就是说，函数中可以定义函数。该函数还可以将其内部定义的函数作为返回值返回。

闭包的定义：一般来说，我们可以认为，如果一个函数可以读取其他函数中的局部变量，那么它们就构成python改造为函数了闭包。

注意 ：闭包的定义不是特别清晰，但大体上的意思是这样的。

我们知道，普通的函数是可以使用全局变量的

类似的，函数中定义的函数，也是可以使用外部函数的变量的。因此，满足了函数读取了其他函数局部变量的这一条件，他们因此构成了闭包。

在闭包的使用中，我们可以先给外部的函数赋予不同的局部变量，然后再调用其中内部的函数时，就可以读取到这些不同的局部变量了。

外部变量的使用 在普通函数中，虽然可以直接使用全局变量，但是不可以直接修改全局变量。从变量的作用域来说，一旦python改造为函数你尝试修改全局变量，那么就会尝试创建并使用一个同名的局部变量。因此，如果你需要在普通函数中修改全局变量，需要使用global

同样的，如果你希望通过定义在内部的函数去修改其外部函数的变量，那么必须使用nonlocal

Q4: 怎么把下面的Python代码封装成函数

Python：常用函数封装：

def is_chinese(uchar):

"""判断一个unicode是否是汉字"""

if uchar = u'\u4e00' and uchar=u'\u9fa5':

return True

else:

return False

def is_number(uchar):

"""判断一个unicode是否是数字"""

if uchar = u'\u0030' and uchar=u'\u0039':

return True

else:

return False

def is_alphabet(uchar):

"""判断一个unicode是否是英文字母"""

if (uchar = u'\u0041' and uchar=u'\u005a') or (uchar = u'\u0061' and uchar=u'\u007a'):

return True

else:

return False

def is_other(uchar):

"""判断是否非汉字python改造为函数，数字和英文字符"""

if not (is_chinese(uchar) or is_number(uchar) or is_alphabet(uchar)):

return True

else:

return False

def B2Q(uchar):

"""半角转全角"""

inside_code=ord(uchar)

if inside_code0x0020 or inside_code0x7e: #不是半角字符就返回原来的字符

return uchar

if inside_code==0x0020: #除python改造为函数了空格其python改造为函数他的全角半角的公式为:半角=全角-0xfee0

inside_code=0x3000

else:

inside_code+=0xfee0

return unichr(inside_code)

def Q2B(uchar):

"""全角转半角"""

inside_code=ord(uchar)

if inside_code==0x3000:

inside_code=0x0020

else:

inside_code-=0xfee0

if inside_code0x0020 or inside_code0x7e: #转完之后不是半角字符返回原来的字符

return uchar

return unichr(inside_code)

def stringQ2B(ustring):

"""把字符串全角转半角"""

return "".join([Q2B(uchar) for uchar in ustring])

def uniform(ustring):

"""格式化字符串，完成全角转半角，大写转小写的工作"""

return stringQ2B(ustring).lower()

def string2List(ustring):

"""将ustring按照中文，字母，数字分开"""

retList=[]

utmp=[]

for uchar in ustring:

if is_other(uchar):

if len(utmp)==0:

continue

else:

retList.append("".join(utmp))

utmp=[]

else:

utmp.append(uchar)

if len(utmp)!=0:

retList.append("".join(utmp))

return retList

关于python改造为函数和python 改写的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。