#绝对值

abs()

#所有值都为真才为真

all()

#只要有一个值为真就为真

any()

#10进制转成二进制

bin()

#10进制转成八进制

oct()

#10进制转成十六进制

hex()

#布尔值

bool()

#字符转换成字节

bytes()

#字节转换成字符

str()

#对文件的操作

open()

#基本流程

#打开文件

op_file=open("file name","rwb+")

#操作文件

op_file.operation()

#关闭文件

op_file.close()

#检查函数是否可以被调用

callable()

#通过字节数查找Ascii中的字符

chr()

#通过Ascii中的字符查找字节

ord()

#随机数函数

random()

#把字符串编译成Python代码

compile()

#接收字符串，讲字符串当成表达式，有返回值

eval()

#执行Python代码，没有返回值

exec()

#快速获取对象提供的功能

dir()

#快速获取帮助

help()

#分页函数

divmod()

#判断对象为谁的实例是否为真

isinstacnce()

#函数返回值True，讲元素添加到结果中

filter()

#将函数返回值添加到结果中

map()

#不可变集合(未讲到)

frozenset()

#变为浮点数

float()

#所有全局变量都放在globals中

globals()

#所有局部变量都放在locals中

locals()

#生成hash值，把对象转换成hash值，一般用于字典中的key

hash()

#求最大值

max()

#求最小值

min()

#求和

sum()

#查看内存地址

memoryview()

#求次方

pow()

#范围函数

range()

#反转函数

reversed()

#四舍五入

round()

#切片

slice()

#排序

sorted()

#判断对象是什么类型

type()

#将不同元素的列表或元组（有序的）索引相同的组合成一个元祖，如果索引有差异则不显示

zip()

 #数字的绝对值

 >>> abs(-100)

 100

 >>> abs(100)

 100

 #判断是真是假

 >>> bool(0)

 False

 >>> bool(1)

 True

 >>> bool(2)

 True

 >>> bool("")

 False

 #所有为真才为真

 >>> all('')

 True

 >>> all([0, 1])

 False

 >>> all([1, 2])

 True

 #有一个为真即为真

 >>> any('')

 True

 >>> any([0, 1])

 True

 >>> any([0, ''])

 False

#0b表示10进制

>>> bin(10)

'0b1010'

 #0o表示10进制

 >>> oct(10)

 '0o12'

 #0x表示16进制

 >>> hex(10)

 '0xa'

#将字符转换成字节

>>> bytes("你好世界",encoding="utf-8")

b'\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xb8\x96\xe7\x95\x8c'

#将字节转换成字符串

>>> str(b'\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xb8\x96\xe7\x95\x8c',encoding="utf-8")

'你好世界'

 >>> import tab

 >>> def foo():

 ...     print("allright")

 ...

 #判断示例函数可否被调用

 >>> callable(foo)

 True

 #常用大写字母 ascii A-Z uncode 65-90

 #常用小写字母 ascii a-z uncode 97-122

 #常用数字 ascii 0-9  uncode 48-57

 >>> chr(65)

 'A'

 >>> chr(90)

 'Z'

 #常用大写字母 ascii A-Z uncode 65-90

 #常用小写字母 ascii a-z uncode 97-122

 #常用数字 ascii 0-9  uncode 48-57

 >>> ord("A")

 65

 >>> ord("Z")

 90

 >>>import random

 #在指定的范围内产生随机数

 >>> random.randrange(20,40)

 29

 >>> random.randrange(20,40)

 37

 >>> string="print(123)"

 #将字符串编译成Python代码(后面为固定格式)

 #编译格式"exec"(编译成Python代码)、"eval"(编译成表达式)、"single"(通常为当行程序)

 >>> result=compile(string,"<string>","exec")

 >>> print(string)

 print(123)

 >>> print(result)

 <code object <module> at 0x7fd1ee9aa660, file "<string>", line 1>

 #编译成Python代码后使用exec执行

 >>> exec(result)

 123

 #编译成Python代码后使用eval执行

 >>> eval(result)

 123

 #与exec的区别在与eval有返回值

 #eval() arg 1 must be a string, bytes or code object

 >>> result=eval("8*8")

 >>> print(result)

 64

 #获取str可以的使用的方法

 >>> print(dir(str))

 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__' ****** 'title', 'translate', 'upper', 'zfill']
  

 #获取字符串replace的用法

 >>> help(str.replace)

 Help on method_descriptor:

 replace(...)

     S.replace(old, new[, count]) -> str

     Return a copy of S with all occurrences of substring

     old replaced by new.  If the optional argument count is

     given, only the first count occurrences are replaced.

 #使用q退出

 #获取余数（除数，被除数）

 >>> ret1,ret2=divmod(100,10)

 >>> print(ret1,ret2)

 10 0

 >>> string="yorick"

 #判断对象是谁的实例是否为真

 #判断string是不是一个字符串

 >>> isinstance(string,str)

 True

 >>> def foo(arg):

 ...     if arg > 22:

 ...         return True

 ...

 >>> n_list=[11,22,33,44,55]

 #函数返回值True，将元素添加到结果中

 >>> result=filter(foo,n_list)

 #python3.0经过调优，不直接将结果输出出来，防止操作的内容过多

 >>> print(result)

 <filter object at 0x7f76f259a4a8>

 >>> print(list(result))

 [33, 44, 55]

 #使用lambda表达式

 >>> n_list=[11,22,33,44,55]

 >>> result = filter(lambda par: par > 22,n_list)

 >>> print(list(result))

 [33, 44, 55]

>>> n_list=[11,22,33,44,55]

>>> def foo(arg):

...     return arg + 100

...

#将返回的结果添加到result中组成一个列表

>>> result = map(foo,n_list)

>>> print(list(result))

[111, 122, 133, 144, 155]

>>> n_list=[11,22,33,44,55]

>>> def foo(arg):

...     return False

...

#将返回的结果添加到result中组成一个列表

>>> result = map(foo,n_list)

>>> print(list(result))

[False, False, False, False, False]

 >>> string="65.20"

 #将字符转换成浮点型

 >>> float(string)

 65.2

 >>> type(float(string))

 <class 'float'>

 >>> type(string)

 <class 'str'>

 >>> string=5

 >>> type(string)

 <class 'int'>

 #将整数型转换成浮点型

 >>> float(string)

 5.0

 >>> print(type(float(string)))

 <class 'float'>

>>> def foo():

...     n_list=[1234567]

...     print("This is Begin Globals".center(40,"-"))

#打印全局变量

...     print(globals())

...     print("This is Begin locals".center(40,"-"))

#打印局部变量

...     print(locals())

...

>>> foo()

---------This is Begin Globals----------

{'string': 5, 'tab': <module 'tab' from '/usr/local/python3.5/lib/python3.5/site-packages/tab.py'>, 'result': <map object at 0x7f76f259a550>, '__spec__': None, '__package__': None, 'n_list': [11, 22, 33, 44, 55], 'foo': <function foo at 0x7f76f256e9d8>, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None}

----------This is Begin locals----------

{'n_list': [1234567]}

 #较多应用为字典的key值

 #获取单个字符的hash值

 >>> hash("a")

 -6417969680733924203

 #获取长度较长的hash值

 >>> hash("sssssssssssssssssssssssssssssssssssssssssssssssssssssss")

 1067091481945040275

 #注意：必须为数字

 #max比较一个可迭代的序列中的最大值

 >>> max(11,222,3344,555)

 3344

 >>> max([11,2233,44,5566,664,23])

 5566

 #min比较一个可迭代的序列中的最小值

 >>> min(11,222,3344,555)

 11

 >>> min([11,2233,44,5566,664,23])

 11

 #sum将一个可迭代的序列求和[不能再sum()语法中添加过多的对象]

 >>> sum((11,22,33,44))

 110

 >>> sum([11,22,33,44])

 110

 >>> sum({11,22,33,44})

 110

 >>> pow(2,10)

 1024

 >>> 2**10

 1024

 #默认起始位置为0

 >>> for i in range(10):

 ...     print(i)

 ...

 0

 1

 2

 3

 4

 5

 6

 7

 8

 9

 >>> o_list=["","","","",""]

 >>> o_list

 ['', '', '', '', '']

 >>> n_list=reversed(o_list)

 >>> n_list

 <list_reverseiterator object at 0x7f76f259a630>

 >>> print(list(n_list))

 ['', '', '', '', '']

 #5舍去

 >>> round(4.5)

 4

 #6入

 >>> round(4.6)

 5

 >>> o_list=["Eric","Yorick","Alex","Bill"]

 >>> o_list

 ['Eric', 'Yorick', 'Alex', 'Bill']

 >>> n_list=sorted(o_list)

 >>> n_list

 ['Alex', 'Bill', 'Eric', 'Yorick']

 #判断对象的类型

 >>> foo1="string"

 >>> foo2=""

 >>> foo3=12345

 >>> foo4={1:""}

 >>> type(foo1),type(foo2),type(foo3),type(foo4)

 (<class 'str'>, <class 'str'>, <class 'int'>, <class 'dict'>)

 >>> list1=["Yorick","223123**12323123","xxx"]

 >>> list2=["is","123213*231231","oooo"]

 >>> list3=["God","89898989*898989","xxxxx"]

 #将不同元素的列表或元组（有序的）索引相同的组合成一个元祖，如果索引有差异则不显示

 >>> print(list(zip(list1,list2,list3)))

 [('Yorick', 'is', 'God'), ('223123**12323123', '123213*231231', '89898989*898989'), ('xxx', 'oooo', 'xxxxx')]

def outer(func):

    def inner():

        print('log')

        return func()

    return inner

@outer

def f1():

    print('f1')

@outer

def f2():

    print('f2')

@outer

def f3():

    print('f3')

#自动执行outer函数并且将其下面的函数名f1当做参数传递
#将outer函数的返回值，重新赋值给f1

def outer(func):

    def inner(*args,**kwargs):

        print('before')

        r = func(*args,**kwargs)#func==老的f1

        print('after')

        return r #获取f1的返回值

    return inner

@outer

def f1(*args,**kwargs):

    print('aaaa')

    return '是是是'