1.内置函数补充
callable(object)
检查对象object是否可调用
1、类是可以被调用的
2、实例是不可以被调用的，除非类中声明了call方法
def f1():
print("test")
f2 = "test"
print(callable(f1))
print(callable(f2))
True
False
chr(i)
返回整数i对应的ASCII字符
print(chr(81))
odr(c)
参数c是一个ascii字符，返回值是对应的十进制整
print (ord('b'))
随机验证码
import random
li = []
for i in range(5):
temp = random.randrange(65,91)
c = chr(temp)
li.append(c)
result = "".join(li)
print(result)
compile(source, filename, mode[, flags[, dont_inherit]])
将source编译为代码或者AST对象。代码对象能够通过exec语句来执...
compile(source, filename, mode[, flags[, dont_inherit]])
中文说明：将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
参数source：字符串或者AST（Abstract Syntax Trees）对象。
参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。
参数flag和dont_inherit：这两个参数暂不介绍，可选参数。
版本：在python2.3、2.6、2.7、3.2中均有不同，使用时要引起注意，兼容python3
英文说明：
Compile the source into a code or AST object. Code objects can be executed by an exec statement or evaluated by a call to eval(). source can either be a string or an AST object. Refer to the ast module documentation for information on how to work with AST objects.
The filename argument should give the file from which the code was read; pass some recognizable value if it wasn’t read from a file ('<string>' is commonly used).
The mode argument specifies what kind of code must be compiled; it can be 'exec' if source consists of a sequence of statements, 'eval' if it consists of a single expression, or 'single' if it consists of a single interactive statement (in the latter case, expression statements that evaluate to something other than None will be printed).
The optional arguments flags and dont_inherit control which future statements (see PEP 236) affect the compilation of source. If neither is present (or both are zero) the code is compiled with those future statements that are in effect in the code that is calling compile. If the flags argument is given and dont_inherit is not (or is zero) then the future statements specified by the flags argument are used in addition to those that would be used anyway. If dont_inherit is a non-zero integer then the flags argument is it – the future statements in effect around the call to compile are ignored.
Future statements are specified by bits which can be bitwise ORed together to specify multiple statements. The bitfield required to specify a given feature can be found as the compiler_flag attribute on the _Feature instance in the future module.
This function raises SyntaxError if the compiled source is invalid, and TypeError if the source contains null bytes.
Note When compiling a string with multi-line code in 'single' or 'eval' mode, input must be terminated by at least one newline character. This is to facilitate detection of incomplete and complete statements in the code module.
Changed in version 2.3: The flags and dont_inherit arguments were added.
Changed in version 2.6: Support for compiling AST objects.
Changed in version 2.7: Allowed use of Windows and Mac newlines. Also input in 'exec' mode does not have to end in a newline anymore.
exec(r)
执行python代码，接收：代码或者字符串
exec(print("test"))
eval(s)
执行表达式，并且获取结果
eval(7*8)
dir(class)
快速查看，对象提供了哪些功能
dir(dict)
help(class)
获取帮助
help(dict)
divmod(d,d)
共：97，每页显示10条，需要多少页
n1 n2 = divmod(97, 10)
isinstance(instance,class)
用于判断，对象是否是类的实例
s = "test"
print(isinstance(s, str))
filter(函数, 可迭代对象)
循环第二个参数，让每个循环元素执行函数，如果函数返回值为True，则元素是合法的。
li = [ 1, 2, 3, 4 ]
ret = filter(None, li)
print(list(ret))
lamda()
默认返回结果为返回值
map(函数,可迭代的对象(可以for循环的东西))
可迭代对象每个元素应用到函数中，返回结果为列表。
filter() #函数返回True，将元素添加到结果中
map() #将函数返回值添加到结果中
globals()
所有的全局变量
locals()
所有的局部变量
hash(s)
转换成hash值，一般用于字典的key
len(s)
返回一个对象的长度
s = "字符"
print(len(s))
b = bytes(s, encoding = "utf-8")
print(len(b))
max([list])
返回列表中的最大值
li = [11, 22, 33]
r = max([li])
zip()
将列表的每列值组成一个无组
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = zip(x, y, z)
print xyz
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
2.Alex鸡汤
推荐书：《林达看美国》
json.loads(s)
将一个字符串，转换成python的基本数据类型，字符串形式的字典必须是双引号引用key value
3.装饰器
装饰器，我的理解是在不影响原函数的情况下（包括执行过程，返回结果，返回值等），增加其它功能（原函数前或后），即达到在不修改原代码的前提下，实现增加的功能。
所以，其优点有：
1.代码修改量小，不影响原函数内部逻辑等；
2.不修改原函数代码，避免原功能因代码语法性错误；
3.灵活性强，在需要增加功能的函数前加简单代码就行；
#def outer(func):
# print(123,func)
#def outer(func):
# return "111"
def outer(func):
def inner(*args,**kwargs): #支持不定传参
print("before")
r = func(*args,**kwargs)
return r #返回原函数返回值
print("after")
return inner
# @ + 函数名
# 功能：
# 1. 自动执行outer函数并且将其下面的函数名f1当作参数传递
# 2. 将outer函数的返回值，重新赋值给f1
@outer
def f1():
print("F1")
