标签：表示 直接 false odi pen sorted 比较 mysl write
我们一起来看看python里的内置函数。什么是内置函数？就是Python给你提供的，拿来直接用的函数，比如print，input等等。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了，有些我们还没用到过，还有一些是被封印了。
描述 eval() 函数用来执行一个字符串表达式，并返回表达式的值。 语法 以下是 eval() 方法的语法: eval(expression[, globals[, locals]]) 参数 expression -- 表达式。 globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。 locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。 返回值 返回表达式计算结果。 实例 以下展示了使用 eval() 方法的实例： >>>x = 7 >>> eval( ‘3 * x‘ ) 21 >>> eval(‘pow(2,2)‘) 4 >>> eval(‘2 + 2‘) 4 >>> n=81 >>> eval("n + 4") 85
描述 exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。 需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。 语法 以下是 exec 的语法: exec obj 参数 obj -- 要执行的表达式。 返回值 exec 返回值永远为 None。 实例 以下展示了使用 exec 的实例： # 实例 1 >>>exec ‘print "Hello World"‘ Hello World # 单行语句字符串 >>> exec "print ‘runoob.com‘" runoob.com # 多行语句字符串 >>> exec """for i in range(5): ... print "iter time: %d" % i ... """ iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4 # 实例 2 x = 10 expr = """ z = 30 sum = x + y + z print(sum) """ def func(): y = 20 exec(expr) exec(expr, {‘x‘: 1, ‘y‘: 2}) exec(expr, {‘x‘: 1, ‘y‘: 2}, {‘y‘: 3, ‘z‘: 4}) func() 输出结果： 60 33 34
- exec和eval都可以执行 字符串类型的代码 - eval有返回值 —— 有结果的简单计算 - exec没有返回值 —— 简单流程控制 - eval只能用在你明确知道你要执行的代码是什么
ret=‘for i in range(5):print(i)‘ c=compile(ret,‘‘,‘exec‘) #用exec执行，有返回值 exec(c) ret=‘1+2+3+4‘ c=compile(ret,‘‘,‘eval‘) #‘‘引号原本的功能是放 print(eval(c)) # 用eval执行，没有返回值，所以需要打印
>>>a = input("input:") input:123 # 输入整数 >>> type(a) <type ‘int‘> # 整型 >>> a = input("input:") input:"runoob" # 正确，字符串表达式 >>> type(a) <type ‘str‘> # 字符串 >>> a = input("input:") input:runoob # 报错，不是表达式 Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<string>", line 1, in <module> NameError: name ‘runoob‘ is not defined <type ‘str‘>
>>>a = raw_input("input:") input:123 >>> type(a) <type ‘str‘> # 字符串 >>> a = raw_input("input:") input:runoob >>> type(a) <type ‘str‘> # 字符串 >>>
print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。
>>>print(1) 1 >>> print("Hello World") Hello World >>> a = 1 >>> b = ‘runoob‘ >>> print(a,b) 1 runoob >>> print("aaa""bbb") aaabbb >>> print("aaa","bbb") aaa bbb >>> >>> print("www","runoob","com",sep=".") # 设置间隔符 www.runoob.com
>>>hash(‘test‘) # 字符串 2314058222102390712 >>> hash(1) # 数字 1 >>> hash(str([1,2,3])) # 集合 1335416675971793195 >>> hash(str(sorted({‘1‘:1}))) # 字典 7666464346782421378
>>>a = ‘runoob‘ >>> id(a) 4531887632 >>> b = 1 >>> id(b) 140588731085608
r： 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 rb： 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 r+： 打开一个文件用于读写。文件指针将会放在文件的开头。 rb+： 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 w： 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb： 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 w+： 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb+： 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 a： 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 ab： 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 a+： 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 ab+： 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
file 对象方法
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。 file.readline()：返回一行。 file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。 for line in f: print line ：通过迭代器访问。 f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。 f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。 f.seek(偏移量,[起始位置])：用来移动文件指针。 偏移量: 单位为比特，可正可负 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾 f.close() 关闭文件
RUNOOB1 RUNOOB2 >>>f = open(‘test.txt‘) >>> f.read() ‘RUNOOB1\nRUNOOB2\n‘
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
>>>callable(0) False >>> callable("runoob") False >>> def add(a, b): ... return a + b ... >>> callable(add) # 函数返回 True True >>> class A: # 类 ... def method(self): ... return 0 ... >>> callable(A) # 类返回 True True >>> a = A() >>> callable(a) # 没有实现 __call__, 返回 False False >>> class B: ... def __call__(self): ... return 0 ... >>> callable(B) True >>> b = B() >>> callable(b) # 实现 __call__, 返回 True True
#!/usr/bin/env python #encoding: utf-8 import os print (‘在 a.py 文件中 %s‘ % id(os))
#!/usr/bin/env python #encoding: utf-8 import sys __import__(‘a‘) # 导入 a.py 模块
>>>help(‘sys‘) # 查看 sys 模块的帮助 ……显示帮助信息…… >>>help(‘str‘) # 查看 str 数据类型的帮助 ……显示帮助信息…… >>>a = [1,2,3] >>>help(a) # 查看列表 list 帮助信息 ……显示帮助信息…… >>>help(a.append) # 显示list的append方法的帮助 ……显示帮助信息……
>>>dir() # 获得当前模块的属性列表 [‘__builtins__‘, ‘__doc__‘, ‘__name__‘, ‘__package__‘, ‘arr‘, ‘myslice‘] >>> dir([ ]) # 查看列表的方法 [‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__delslice__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getslice__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__setslice__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]
>>>bool() False >>> bool(0) False >>> bool(1) True >>> bool(2) True >>> issubclass(bool, int) # bool 是 int 子类 True
>>>int() # 不传入参数时，得到结果0 0 >>> int(3) 3 >>> int(3.6) 3 >>> int(‘12‘,16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18 >>> int(‘0xa‘,16) 10 >>> int(‘10‘,8) 8
>>>float(1) 1.0 >>> float(112) 112.0 >>> float(-123.6) -123.6 >>> float(‘123‘) # 字符串 123.0
>>>complex(1, 2) (1 + 2j) >>> complex(1) # 数字 (1 + 0j) >>> complex("1") # 当做字符串处理 (1 + 0j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 >>> complex("1+2j") (1 + 2j)
>>>bin(10) ‘0b1010‘ >>> bin(20) ‘0b10100‘
>>>oct(10) ‘012‘ >>> oct(20) ‘024‘ >>> oct(15) ‘017‘ >>>
>>>hex(255) ‘0xff‘ >>> hex(-42) ‘-0x2a‘ >>> hex(1L) ‘0x1L‘ >>> hex(12) ‘0xc‘ >>> type(hex(12)) <class ‘str‘> # 字符串
#!/usr/bin/python print "abs(-45) : ", abs(-45) print "abs(100.12) : ", abs(100.12) print "abs(119L) : ", abs(119L) # 运行结果 abs(-45) : 45 abs(100.12) : 100.12 abs(119L) : 119
>>>divmod(7, 2) (3, 1) >>> divmod(8, 2) (4, 0) >>> divmod(1+2j,1+0.5j) ((1+0j), 1.5j)
print "round(80.23456, 2) : ", round(80.23456, 2) print "round(100.000056, 3) : ", round(100.000056, 3) print "round(-100.000056, 3) : ", round(-100.000056, 3) # 运行结果 round(80.23456, 2) : 80.23 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0
>>>sum([0,1,2]) 3 >>> sum((2, 3, 4), 1) # 元组计算总和后再加 1 10 >>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2 12
print "min(80, 100, 1000) : ", min(80, 100, 1000) print "min(-20, 100, 400) : ", min(-20, 100, 400) print "min(-80, -20, -10) : ", min(-80, -20, -10) print "min(0, 100, -400) : ", min(0, 100, -400) # 运行结果 min(80, 100, 1000) : 80 min(-20, 100, 400) : -20 min(-80, -20, -10) : -80 min(0, 100, -400) : -400
#!/usr/bin/python print "max(80, 100, 1000) : ", max(80, 100, 1000) print "max(-20, 100, 400) : ", max(-20, 100, 400) print "max(-80, -20, -10) : ", max(-80, -20, -10) print "max(0, 100, -400) : ", max(0, 100, -400) # 运行结果 max(80, 100, 1000) : 1000 max(-20, 100, 400) : 400 max(-80, -20, -10) : -10 max(0, 100, -400) : 100
#!/usr/bin/python # -*- coding: UTF-8 -*- import math # 导入 math 模块 print "math.pow(100, 2) : ", math.pow(100, 2) # 使用内置，查看输出结果区别 print "pow(100, 2) : ", pow(100, 2) print "math.pow(100, -2) : ", math.pow(100, -2) print "math.pow(2, 4) : ", math.pow(2, 4) print "math.pow(3, 0) : ", math.pow(3, 0) # 运行结果 math.pow(100, 2) : 10000.0 pow(100, 2) : 10000 math.pow(100, -2) : 0.0001 math.pow(2, 4) : 16.0 math.pow(3, 0) : 1.0
>>>tuple([1,2,3,4]) (1, 2, 3, 4) >>> tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple (1, 3) >>> tuple((1,2,3,4)) #元组会返回元组自身 (1, 2, 3, 4)
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
#!/usr/bin/python # -*- coding: UTF-8 -*- aTuple = (123, ‘xyz‘, ‘zara‘, ‘abc‘); aList = list(aTuple) print "列表元素 : ", aList
aList = [123, ‘xyz‘, ‘zara‘, ‘abc‘, ‘xyz‘] aList.reverse() print "List : ", aList # 运行结果 List : [‘xyz‘, ‘abc‘, ‘zara‘, ‘xyz‘, 123]
l2=reversed(l) #生成器 print(l2) #<list_reverseiterator object at 0x018539D0> for i in l2: print(i) #4,6,3,1
>>>myslice = slice(5) # 设置截取5个元素的切片 >>> myslice slice(None, 5, None) >>> arr = range(10) >>> arr [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> arr[myslice] # 截取 5 个元素 [0, 1, 2, 3, 4] >>>
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 ‘hello world‘ >>> "{0} {1}".format("hello", "world") # 设置指定位置 ‘hello world‘ >>> "{1} {0} {1}".format("hello", "world") # 设置指定位置 ‘world hello world‘
也可以设置参数
#!/usr/bin/python # -*- coding: UTF-8 -*- print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")) # 通过字典设置参数 site = {"name": "菜鸟教程", "url": "www.runoob.com"} print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数 my_list = [‘菜鸟教程‘, ‘www.runoob.com‘] print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的 # 运行结果 网站名：菜鸟教程, 地址 www.runoob.com 网站名：菜鸟教程, 地址 www.runoob.com 网站名：菜鸟教程, 地址 www.runoob.com
也可以像str.format()传入对象：
#!/usr/bin/python # -*- coding: UTF-8 -*- class AssignValue(object): def __init__(self, value): self.value = value my_value = AssignValue(6) print(‘value 为: {0.value}‘.format(my_value)) # "0" 是可选的 # 运行结果 value 为: 6
数字格式化：
>>> print("{:.2f}".format(3.1415926)); 3.14
需求把gbk编码的转换为utf-8，python是unicode编码，需要先把‘你好‘转为gbk 形式 print(bytes(‘美丽‘,encoding=‘GBK‘)) #等价于==print(‘美丽‘.encode(‘gbk‘)) # #b‘\xc4\xe3\xba\xc3‘把unicode转换为gbk的bytes类型 print((bytes(‘美丽‘,encoding=‘gbk‘)).decode(‘gbk‘).encode(‘utf-8‘)) #转换成功 注释： 网页编程是二进制存储 照片视频也是二进制 html网页爬取也是二进制
b_bytes=bytearray(‘你好‘,encoding=‘utf-8‘) print(b_bytes) #‘\xe4\xbd\xa0\xe5\xa5\xbd‘) print(b_bytes[0]) #228 print(b_bytes[1]) #189
memoryview(bytes(‘hello,eva‘,encoding=‘utf-8‘)
print(ord(‘你‘)) #20320 print(ord(‘1‘)) #49 print(ord(‘A‘)) #65 print(ord(‘?‘)) #10084
print(chr(97)) #a print(chr(98)) # print(chr(65)) #A
print(ascii(‘你‘) #‘\u4f60‘ print(ascii(‘A‘) ) #‘A‘
name=‘egg‘ print(‘你好%s‘%name) #你好egg print(‘你好%r‘%name) #你好‘egg‘ print(repr(‘1‘)) #‘1‘ print(‘1‘) #1 print(repr(1)) #1
>>>dict() # 创建空字典 {} >>> dict(a=‘a‘, b=‘b‘, t=‘t‘) # 传入关键字 {‘a‘: ‘a‘, ‘b‘: ‘b‘, ‘t‘: ‘t‘} >>> dict(zip([‘one‘, ‘two‘, ‘three‘], [1, 2, 3])) # 映射函数方式来构造字典 {‘three‘: 3, ‘two‘: 2, ‘one‘: 1} >>> dict([(‘one‘, 1), (‘two‘, 2), (‘three‘, 3)]) # 可迭代对象方式来构造字典 {‘three‘: 3, ‘two‘: 2, ‘one‘: 1}
>>>x = set(‘runoob‘) >>> y = set(‘google‘) >>> x, y (set([‘b‘, ‘r‘, ‘u‘, ‘o‘, ‘n‘]), set([‘e‘, ‘o‘, ‘g‘, ‘l‘])) # 重复的被删除 >>> x & y # 交集 set([‘o‘]) >>> x | y # 并集 set([‘b‘, ‘e‘, ‘g‘, ‘l‘, ‘o‘, ‘n‘, ‘r‘, ‘u‘]) >>> x - y # 差集 set([‘r‘, ‘b‘, ‘u‘, ‘n‘])
>>>a = frozenset(range(10)) # 生成一个新的不可变集合 >>> a frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> b = frozenset(‘runoob‘) >>> b frozenset([‘b‘, ‘r‘, ‘u‘, ‘o‘, ‘n‘]) # 创建不可变集合
>>>str = "runoob" >>> len(str) # 字符串长度 6 >>> l = [1,2,3,4,5] >>> len(l) # 列表元素个数 5
dic={‘a‘:‘b‘,‘c‘:‘d‘}
for k,i in enumerate(dic,1):
print(k,i)
print(all([‘ ‘,‘ni‘,‘你‘])) #True print(all([‘‘,‘ni‘,‘你‘])) #Flase 特殊情况 ： print(all([])) #Ture print(all([‘‘])) #Flase
>>>any([‘a‘, ‘b‘, ‘c‘, ‘d‘]) # 列表list，元素都不为空或0 True >>> any([‘a‘, ‘b‘, ‘‘, ‘d‘]) # 列表list，存在一个为空的元素 True >>> any([0, ‘‘, False]) # 列表list,元素全为0,‘‘,false False >>> any((‘a‘, ‘b‘, ‘c‘, ‘d‘)) # 元组tuple，元素都不为空或0 True >>> any((‘a‘, ‘b‘, ‘‘, ‘d‘)) # 元组tuple，存在一个为空的元素 True >>> any((0, ‘‘, False)) # 元组tuple，元素全为0,‘‘,false False >>> any([]) # 空列表 False >>> any(()) # 空元组 False
a=[‘a‘,‘b‘] #列表 b=[‘c‘,‘d‘] ret=zip(a,b) for i in ret: #(‘a‘, ‘c‘)(‘b‘, ‘d‘) print(i) a={‘a‘,‘b‘} #字典 b={‘c‘,‘d‘} ret=zip(a,b) for i in ret: print(i) ##(‘a‘, ‘c‘)(‘b‘, ‘d‘)和上面效果一样 #简化： a=[‘a‘,‘b‘] b=[‘c‘,‘d‘] c=[‘e‘,‘f‘] for i in zip(a,b,c): #(‘a‘, ‘c‘, ‘e‘)(‘b‘, ‘d‘, ‘f‘) print(i) #字典、列表、元祖混用拉链 a=[‘a‘,‘b‘,‘g‘] #不是一一对应的话，自动去除多余的 b={‘c‘,‘d‘]} #dict list tuple 都可以用zip 来拉链 c=(‘e‘,‘f‘]) for i in zip(a,b,c): #(‘a‘, ‘c‘, ‘e‘)(‘b‘, ‘d‘, ‘f‘) print(i)
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
def f(x): return x%2==0 g=filter(f,[1,3,5,6,7,8]) #filter 得到是一个迭代器 for i in g: print(i) #6 8 filter过滤的功能 def a(z): return z%2==1 #函数返回值为Ture，则放到新的迭代器中 ret=filter(a,[1,2,3,4,5,6]) #函数名不加括号，因为前面filter要来调用函数名，得到的ret是一个迭代器 for i in ret: #不调用不打印 print(i) 功能解析：把可迭代的值传给某个函数，函数来执行 def a(z): return z%2==0 ret=filter(a,[1,2,3,4,5,6]) for i in ret: print(i) 上面那个filter方法等于这个列表推导式的功能 c=[i for i in [1,2,3,4,5,6] if i%2==1] for i in c: print(i) 取出0到100中能够开方的整数 from math import sqrt def num(s): if sqrt(s)%1==0: return True ret=filter(num,range(0,101)) for i in ret: print(i)
>>>def square(x) : # 计算平方数 ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25] >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]
结论：filter（）之后元素个数会发生改变，map()之后元素个数不会改变。filter只管筛选，不会改变原来的值 map值会改变
sort与sorted区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
>>>a = [5,7,6,3,4,1,2] >>> b = sorted(a) # 保留原列表 >>> a [5, 7, 6, 3, 4, 1, 2] >>> b [1, 2, 3, 4, 5, 6, 7] >>> L=[(‘b‘,2),(‘a‘,1),(‘c‘,3),(‘d‘,4)] >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数 [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)] >>> sorted(L, key=lambda x:x[1]) # 利用key [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)] >>> students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)] >>> sorted(students, key=lambda s: s[2]) # 按年龄排序 [(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)] >>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序 [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
为了解决那些功能很简单的需求而设计的一句话函数
#这段代码 def calc(n): return n**n print(calc(10)) #换成匿名函数 calc = lambda n:n**n print(calc(10))
标签：表示 直接 false odi pen sorted 比较 mysl write
原文地址：https://www.cnblogs.com/xiaohei001/p/9782149.html
