的值的函数value按format_spec的格式来格式化，然而函数解释format_spec是依据value的类型来决定的。不同的类型有不同的格式化解释。
 
当參数format_spec为空时，本函数等同于函数str(value)的方式。
 
事实上本函数调用时，是把format(value, format_spec)的方式转换为type(value).__format__(format_spec)方式来调用。因此在value类型里就查找方法__format__()，假设找不到此方法，就会返回异常TypeError。
 
当中format_spec的编写方式例如以下形式：
 
format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
 
fill        ::=  
 
align       ::=  "" | "=" | "^"
 
sign        ::=  "+" | "-" | " "
 
width       ::=  integer
 
precision   ::=  integer
 
type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
 
fill是表示能够填写不论什么字符。
 
align是对齐方式，是右对齐。^是居中对齐。
 
sign是符号，+表示正号，-表示负号。
 
width是数字宽度，表示总共输出多少位数字。
 
precision是小数保留位数。
 
type是输出数字值是的表示方式，比方b是二进制表示；比方E是指数表示。比方X是十六进制表示。
 
样例：
 
#format()
 
print(format(2918))
 
print(format(0x500, 'X'))
 
print(format(3.14, '0=10'))
 
print(format(3.14159, '05.3'))
 
print(format(3.14159, 'E'))
 
print(format('test', '<20'))
 
print(format('test', '>20'))
 
print(format('test', '^20'))
 
结果输出例如以下：
 
2918
 
500
 
0000003.14
 
03.14
 
3.141590E+00
 
test
 
test
 
test
 
蔡俊生  QQ:9073204 深圳
 
版权声明：本文博客原创文章，博客，未经同意，不得转载。

 
一、定义函数
 
形参：函数完成一项工作所需要的信息，在函数定义时完成
 
实参：调用函数时传递给函数的信息
 
二、传递实参
 
1.位置实参:每个实参都关联到函数定义中的一个形参
 
示例： def describe_pet(animal_type,pet_name):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
describe_pet('hamster','harry')
 
2.关键字实参是传递给函数的名称-值对 (直接在实参中将名称和值关联起来，这样无需考虑函数调用中的实参顺序)
 
def describe_pet(animal_type,pet_name):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
describe_pet(animal_type='hamster',pet_name='harry')
 
3.默认值：编写函数时，可给每个形参指定默认值。在调用函数时给形参指定了实参值时，python将使用指定实参值；否则，将使用形参的默认值。
 
def describe_pet(pet_name,animal_type='dog'):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
调用式1: describe_pet('hamster') 使用形参默认值
 
调用式2: describe_pet(pet_name='harry',animal_type='hamster')
 
显示的给animal_type提供了实参，因此python忽略了形参的默认值
 
注意：使用默认值时，在形参列表中必须先列出没有默认值的形参，在列出有默认值得形参，这让python能正确解读位置实参
 
4.等效的函数调用：指定实参时可以使用位置方式，也可以使用关键字方式
 
def describe_pet(pet_name,animal_type='dog'):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
#一条命为willie的小狗
 
describe_pet('willie')
 
describe_pet(pet_name='willie')
 
#一只名为Harry的仓鼠
 
describe_pet('harry','hamster') --位置实参
 
describe_pet(pet_name='harry',animal_type='hamster')--关键字实参
 
describe_pet(animal_type='hamster',pet_name='harry')
 
三、返回值： return语句将值返回到调用函数的代码行
 
1.返回简单的值
 
2.让实参变成可选的
 
def get_formatted_name(first_name,last_name,middle_name=''):ifmiddle_name:
 
full_name=first_name+' '+middle_name+' '+last_nameelse:
 
full_name=first_name+' '+last_name
 
reutn full_name
 
musician=get_formatted_name('zilong','zhou')
 
print(musician)
 
musician=get_formatted_name('xifeng','wang','lee')
 
print(musician)
 
为让中间名变成可选，可给形参middle_name一个默认值-空字符串,并在用户没有提供中间名时不使用这个实参
 
3.返回字典：函数可返回任何类型的值，包括列表和字典等较为复杂的数据结构
 
def build_person(first_name,last_name,age='')
 
person={'first_name':first_name,'last_name':last_name}
 
if age:
 
age=32
 
retun person
 
musician=build_person('yufang','ke',20)
 
print(musician)
 
4.将函数与while循环结合使用
 
def get_formatted_name(first_name,last_name)
 
full_name=first_name+' '+last_name
 
retun full_namewhile true:
 
print("please tell me your name|enter q to quit")
 
first_name=input("first name: ")if first_name == 'q':break;
 
last_name=input("last name: ")if last_name == 'q':break;
 
formatted_named=get_formatted_name(first_name,last_name)
 
print(formatted_named)
 
四、传递列表
 
1.在函数中修改列表：3D打印模型公司需要打印的设计存储在一个列表中，打印后移到另一个列表中
 
def print_models(unprinted_designs,completed_models):whileunprinted_designs:
 
current_design=unprinted_designs.pop()
 
completed_models.append(current_design)
 
def show_completed_models(completed_models):
 
print("the following models have been printed:")for completed_model incompleted_models：
 
print(completed_model)
 
unprinted_designs=['iphone case','robot pendant','dodecahedron']
 
completed_models=[]
 
print_models(unprinted_designs,completed_models)
 
show_completed_models(completed_models)
 
2.禁止函数列表修改(源代码参--在函数中修改列表)
 
print_models(unprinted_designs[:],completed_models)
 
unprinted_designs[:]获得列表unprinted_designs的副本，而不是列表unprinted_designs的本身，列表completed_models也将打印包含打印好的列表名称，但函数所做的修改不会影响到列表unprinted_designs
 
五、传递任意数量的实参
 
1.简单示例
 
制作比萨时需要接受很多配料，但无法预先确定顾客要多少配料，下面形参toppings能够接受任意多个实参
 
def make_pizza(*toppings):
 
print(toppings)
 
make_pizza('peper')
 
make_pizza('peper','extra cheese')
 
2.结合使用位置实参和任意数量实参
 
def make_pizza(size,*toppings):
 
print("making a"+str(size)+"-inch pizza with the following toppings:")for topping intoppings:
 
print("-"+topping)
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
3.使用任意数量的关键字实参：将函数编写能够接受任意数量的键-值对--调用语句提供多少就接受多少
 
build_profile()函数接受名和姓，同事还接受任意数量的关键字实参
 
def build_profile(first,last,**user_infos):
 
profile={}
 
profile['first_name']=first
 
profile['last_name']=lastfor key,value inuser_infos:
 
profile[key]=value
 
retun profile
 
user_profile=build_profile('albert','eisnst',location='princeton',field='physics')
 
print(user_profile)
 
六、将函数存储在模块中
 
函数的优点之一是使用它们可以和主程序分离；通过给函数指定描述性名称，可让主程序容易理解得多；你还可以将函数存储在称为模块的独立文件中，再将模块导入到主程序中。
 
import语句允许在当前运行的程序文件中使用模块中的代码
 
6.1导入整个模块
 
def make_pizza(size,*toppings):
 
print("making a"+str(size)+"-inch pizza with the following toppings: ")
 
for topping in toppings:
 
print("-"+topping)
 
接下来，我们在pizza.py文件所在目录创建另一个名为making_pizzas.py文件，这个文件导入刚创建的模块，再调用mkae_pizza()函数两次
 
import pizza
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
代码行import pizza让Python打开文件pizza.py，并将pizza.py文件中所有函数都复制到这个程序中
 
6.2 导入特定的函数
 
导入任意数量函数方法：from module import function_name;
 
对于前面making_pizzas.py示例，如果你只想导入使用的函数，代码将类似下面这样：
 
from pizza import make_pizza
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
6.3使用as给函数重命名
 
指定别名通用语法如下：
 
from module_name import function_name as fn
 
对于前面making_pizzas.py示例：
 
from pizza import make_pizza as mp
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
6.4使用as给模块指定别名
 
import pizza as p
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
给模块指定别名的通用方法如下：
 
import module_name as mn
 
6.5 导入模块中所有函数
 
使用*运算符可让python导入模块中的所有函数：
 
from pizza import *
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
6.6 函数编写指南
 
每个函数首先给函数指定描述性名称，且只在其中使用小写字母和下划线，并简要地阐述其功能注释，该注释应紧跟函数定义的后面

 
Python hex() 功能
 
hex()function是Python中的一个库函数，用于获取给定数字的十六进制值，它接受一个数字并返回一个十六进制值(字符串格式)。可用于将整数转换为十六进制值。
 
语法：
 
hex(number)
 
Parameter(s)： number-要转换为十六进制的有效数字。
 
返回值： str –以给定数字的字符串格式返回十六进制值。
 
示例
 
Input:
 
num = 12345
 
print("hex value of ", num, " is = ", hex(num))
 
Output:
 
hex value of  12345  is =  0x3039
 
Python代码获取给定数字的十六进制值
 
# python代码演示示例
 
# of hex() function
 
num = 0
 
print("hex value of ", num, " is = ", hex(num))
 
num = 10
 
print("hex value of ", num, " is = ", hex(num))
 
num = 12345
 
print("hex value of ", num, " is = ", hex(num))
 
num = -12345
 
print("hex value of ", num, " is = ", hex(num))
 
输出结果
 
hex value of  0  is =  0x0
 
hex value of  10  is =  0xa
 
hex value of  12345  is =  0x3039
 
hex value of  -12345  is =  -0x3039

 
注释中建议的ast模块最终运行良好。这是我创建的一个类，用于提取包中定义的函数或变量，这些函数或变量用于每个函数。在import ast
 
import types
 
import inspect
 
class CausalBuilder(ast.NodeVisitor):
 
def __init__(self, package):
 
self.forest = []
 
self.fnames = []
 
for name, obj in vars(package).items():
 
if isinstance(obj, types.ModuleType):
 
with open(obj.__file__) as f:
 
text = f.read()
 
tree = ast.parse(text)
 
self.forest.append(tree)
 
elif isinstance(obj, types.FunctionType):
 
mod, *_ = inspect.getmodule(obj).__name__.split('.')
 
if mod == package.__name__:
 
self.fnames.append(name)
 
self.causes = {n: [] for n in self.fnames}
 
def build(self):
 
for tree in self.forest:
 
self.visit(tree)
 
return self.causes
 
def visit_FunctionDef(self, node):
 
self.generic_visit(node)
 
for b in node.body:
 
if node.name in self.fnames:
 
self.causes[node.name] += self.extract_cause(b)
 
def extract_cause(self, node):
 
nodes = [node]
 
cause = []
 
while nodes:
 
for i, n in enumerate(nodes):
 
ntype = type(n)
 
if ntype == ast.Name:
 
if n.id in self.fnames:
 
cause.append(n.id)
 
elif ntype in (ast.Assign, ast.AugAssign, ast.Attribute,
 
ast.Subscript, ast.Return):
 
nodes.append(n.value)
 
elif ntype in (ast.If, ast.IfExp):
 
nodes.append(n.test)
 
nodes.extend(n.body)
 
nodes.extend(n.orelse)
 
elif ntype == ast.Compare:
 
nodes.append(n.left)
 
nodes.extend(n.comparators)
 
elif ntype == ast.Call:
 
nodes.append(n.func)
 
elif ntype == ast.BinOp:
 
nodes.append(n.left)
 
nodes.append(n.right)
 
elif ntype == ast.UnaryOp:
 
nodes.append(n.operand)
 
elif ntype == ast.BoolOp:
 
nodes.extend(n.values)
 
elif ntype == ast.Num:
 
pass
 
else:
 
raise TypeError("Node type `{}` not accounted for."
 
.format(ntype))
 
nodes.pop(nodes.index(n))
 
return cause
 
该类可以通过以下方式使用：首先导入python包并传递给构造函数，然后调用build方法，如下所示：
 
^{pr2}$
 
它将打印出一个字典，其中包含一组表示函数名称的键，以及表示函数中使用的函数和/或变量的值。不是每一种ast类型都能解释，但这对我来说已经足够好了。在
 
实现递归地将节点分解为更简单的类型，直到到达ast.Name之后，它才能提取目标函数中使用的变量、函数或方法的名称。在