标签：index return 函数 func print def
函数
"""
先定义后调用(函数名+括号)
函数名的命名规则跟变量名一样
函数在定义的时候只检测函数体语法,不执行函数体代码
函数名遇到括号会立即执行函数体代码
"""
# 定义:
# 1.空函数
def func():
pass
# 2.无参函数
def func():
print('hello world')
# 3.有参函数
def func(x, y, *args, **kwargs):
print('hello world')
def index():
pass # 第一种顶替方式(推荐使用pass)
... # 第二种顶替方式
函数返回值 return
"""
函数内要想返回值给调用者,必须用关键字return,函数体遇到return直接结束整个函数的运行
所有的函数都有返回值,不写默认返回None
光写return或return None并不是为了考虑返回值,而是为了结束函数的运行
"""
def func():
l = ['jason', 'egon', 'tank']
while True:
for i in l:
if i == 'egon':
return # 当i为egon时,直接结束函数运行
print('abcdefg') # 这一行代码永远都不会运行
print(i)
# 不写return: 函数默认返回None
# 只写return: 返回None
# 写return返回None: 跟只写return一样
# 写return返回一个值: 这个值可以是python任意数据类型
# 写return返回多个值: 将多个值以元组的形式返回给调用者
def func1():
return 1, 2, 3, 4
print(func()) # (1, 2, 3, 4)
def func2():
return 'a', 'b', 'c'
print(func2()) # ('a', 'b', 'c')
def func3():
return [1, 2], [1, 3], [2, 3]
print(func3()) # ([1, 2], [1, 3], [2, 3])
def func4():
return {'name': 'jason'}, {'age': '18'}
print(func4()) # ({'name': 'jason'}, {'age': '18'})
# 写return返回多个值: 不想返回元组类型,可以加上你想返回的数据类型符号
def func5():
return [[1, 2], [1, 3], [2, 3]]
print(func5()) # [[1, 2], [1, 3], [2, 3]]
函数参数
"""
函数参数的两大类型:
形参: 在函数的定义阶段,括号内写的变量名,叫做该函数的形式参数,简称形参
实参: 在函数的调用阶段,括号内实际传入的值,叫做实际参数,简称实参
形参与实参的关系:
形参就相当于变量名,而实参就相当于变量的值
函数调用传参的过程,就是给形参赋值的过程
注意: 形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除,只在函数内部有效,函数外部无任何影响
函数的简易结构:
def 函数名(形参1,形参2...):
'''函数的注释,用来描述该函数的作用以及各个形参的类型和return返回值'''
函数体代码1
函数体代码2
...
return 函数的返回值
"""
def func(x, y):
"""
该函数的作用
: param x: 对形参x的解释
: param y: 对形参y的解释
: return: 对函数返回值的解释
"""
print('hahaha')
return 'heihei'
print(help(func)) # 查看函数注释
位置参数
"""
位置形参: 在函数定义阶段按照位置从左往右依次书写的变量名,位置形参在调用的时候,必须为其传值,有几个传几个
位置实参: 在函数的调用阶段
位置传参: 直接按照位置传,一一对应
关键字传参: 指名道姓的传
注意: 在函数的调用阶段,位置传参和关键字传参可以混合使用,但是必须保证
1.位置传参必须在关键字传参的前面
2.同一个形参不能被多次赋值
"""
# 比较两个数的大小,返回大的那个
def my_max(x,y): # 位置形参
print(x,y)
if x > y:
return x
else:
return y
# 位置传参
print(my_max(1,3))
print(my_max(1)) # 在调用函数时,少一个实参不行
print(my_max(1,2,3)) # 在调用函数时,多一个实参也不行
# 关键字传参
print(my_max(y=20,x=10))
# 位置传参和关键字传参混合使用
print(my_max(10,y=20))
默认值参数
"""
默认值参数: 在函数的定义阶段,形参(变量名)就已经被赋值了
在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
在调用的时候如果给默认值形参传值,那么就使用你传的值
在定义阶段,默认值形参必须放在位置形参的后面
函数在定义阶段,内部所使用的变量都已经初始化完毕了,不会因为调用位置变化,而影响到内部的值(暂时可忽略)
函数无论在什么地方被调用,都会跑到函数定义阶段去执行代码,形参中用到的值都是往函数定义阶段代码之上找
"""
def my_max(x,y=100):
if x > y:
return x
return y
print(my_max(200)) # y使用默认值参数
print(my_max(200,1000)) # y使用传的值
# 默认值参数问题
def info(username,hobby,l=[]):
l.append(hobby)
print('%s 的爱好是 %s'%(username,l))
info('jason','read') # jason 的爱好是 ['read']
info('tank','study') # tank 的爱好是 ['read', 'study']
# 解决方法1: 不使用默认的自己传参
info('jason','read',[]) # jason 的爱好是 ['read']
info('tank','study',[]) # tank 的爱好是 ['study']
# 解决方法2:
def info(username,hobby,l=None):
if l == None:
l = []
l.append(hobby)
print('%s 的爱好是 %s'%(username,l))
info('jason','read') # jason 的爱好是 ['read']
info('tank','study') # tank 的爱好是 ['study']
可变长参数
"""
用*和**来接收多余的(溢出的)位置参数和关键字参数
*在形参中能够接受多余的位置参数,组织成一个元祖赋值给*后面的变量名
**在形参中能够接受多余的关键字参数,组织成一个字典赋值给**后面的变量名
*在实参中能够将、列表、元祖、集合打散成位置实参的形式传递给函数,*就看成是for循环取值
**在实参中能够将字典打散成key=value的形式按照关键字参数传递给函数
"""
# 站在形参的角度,看 *
# 形参中的*会将多余的(溢出的)位置实参,统一用元组的形式处理,传递给*后面的形参名
# *在形参中只能接收多余的位置实参,不能接收关键字实参
def func(x,y,*z):
print(x,y,z)
func(1,2,3,4,5,6) # 1 2 (3, 4, 5, 6)
# 站在实参的角度,看 *
# *只能将字符串、列表、元组、集合打散成位置实参一一传入,*的内部看成是for循环
def func(x,y,z):
print(x,y,z)
func(*[1,2,3]) # *会将列表打散成位置实参一一传入,等价于func(1,2,3)
def func(x,*z):
print(x,z)
func(1,*{1,2,3}) # 1 (1, 2, 3)
# 站在形参的角度,看 **
# **会接收所有多余的关键字参数,并将关键字参数转换成字典形式,字典的key为关键字的名字,字典的value为关键字的名字指向的值,将字典交给**后面的变量名
def func(x,y,**z):
print(x,y,z)
func(1,2,a=1,b=2,c=3) # 1 2 {'a': 1, 'b': 2, 'c': 3}
func(x=1,y=2,a=1,b=2,c=3) # 1 2 {'a': 1, 'b': 2, 'c': 3}
# 站在实参的角度,看 **
# **会将字典拆封成key=value的形式
def func(x,y,z):
print(x,y,z)
func(**{'x': 1,'y': 2,'z': 3}) # 等价于func(x=1,y=2,z=3)
# 需求: 你写的函数,调用者按照正确传参方式无论怎么传,你的函数都能够正常执行
def func1(*x,**y):
print(x,y)
func1(1,2,x=1,y=2,z=3) # (1, 2) {'x': 1, 'y': 2, 'z': 3}
# python推荐形参中*和**通用写法
def func2(*args,**kwargs):
print(args,kwargs)
命名关键字参数
# 在函数定义阶段,写在*与**可变长参数之间的形参
# 在给命名关键字参数传值的时候,只能用关键字为其传值
# 在定义阶段,感觉好像是z是默认值参数放在了m这个位置参数的前面了,应该报错,其实z和m都是命名关键字参数,不是默认值参数和位置参数
def func(x,y=1,*args,z=3,m,**kwargs):
print(x,y) # 1 2
print(args) # (1, 2, 3)
print(z,m) # 69 999
print(kwargs) #{'o': 666999, 'l': 999666}
func(1,2,1,2,3,z=69,m=999,o=666999,l=999666)
函数对象
# 函数是第一类对象: 函数名指向的值可以被当做参数传递
# 1.函数名可以被传递
def func():
print('from func')
print(func) # <function func at 0x0000028D0566F1F0>
f = func
print(f) # <function func at 0x0000028D0566F1F0>
# 2.函数名可以被当做参数传递给其他函数
def func():
print('from func')
def index(args):
print(args)
args()
index(func) # <function func at 0x000001C8B572E160> from func
# 3.函数名可以被当做函数的返回值
def index():
print('index')
def func():
return index
res = func()
print(res) # <function index at 0x0000021D260FE160>
res() # index
# 4.函数名可以被当做容器类型的参数
def func():
return 'func'
l = [1,2,func,func()]
print(l) # [1, 2, <function func at 0x0000024DEBFEE160>, 'func']
# 示例: 循环打印项目功能提示信息,供用户选择,用户选择谁就执行谁
def register():
print('register ...')
def login():
print('login ...')
def transfer():
print('transfer ...')
msg = """
1 注册
2 登陆
3 转账
"""
func_dict = {
'1': register,
'2': login,
'3': transfer,
}
while True:
print(msg)
choice = input('请输入你想执行的功能>>>: ').strip()
if choice in func_dict:
func_dict.get(choice)() # 函数名()
else:
print('输入错误')
函数的嵌套调用
# 在函数内部调用其他函数,可以将复杂的逻辑简单化
def index():
print('index')
def func():
index()
func() # index
def my_max(x,y):
if x > y:
return x
return y
def my_max4(a,b,c,d):
res1 = my_max(a,b)
res2 = my_max(res1,c)
res3 = my_max(res2,d)
return res3
print(my_max4(1,2,10,4)) # 10
函数的嵌套定义
def outer():
x = 1
print('outer')
def inner():
print('inner')
outer() # outer
print(x) # NameError: name 'x' is not defined 外层不能访问函数体内部代码
print(inner) # NameError: name 'inner' is not defined
def outer():
x = 1
print('outer')
def inner():
print('inner')
inner()
outer() # outer inner 函数体内部可以访问函数体内部代码
def outer():
x = 1
print('outer')
def inner():
print('inner')
return inner
res = outer() # outer
print(res) # <function outer.<locals>.inner at 0x0000029F26891D30>
res() # inner
# 示例: 写一个函数,该函数用户可以通过传参的不同控制函数执行不同的功能
def all_funx(type):
def register():
print('register')
def login():
print('login')
def shopping():
print('shopping')
if type == '1':
register()
elif type == '2':
login()
elif type == '3':
shopping()
all_funx('1')
闭包函数
# 闭: 定义在函数内部的函数
# 包: 内部函数引用了外部函数作用域的名字
def outter():
x = 111
def inner():
print(x)
return inner
res = outter() # res就是inner函数的内存地址
x = 222
res() # 111
def func():
x = 333
res()
func() # 111
# 给函数体传值的两种方式
# 第一种方式: 传参
def index(name):
print(name)
# 第二种方式: 闭包
def outter(x,y):
def my_max():
if x > y:
return x
return y
return my_max
res1 = outter(1,40) # res1就是my_max函数的内存地址
print(res1()) # 40
# 示例:
import requests
# 传参
def my_get(url):
response = requests.get(url)
if response.status_code == 200:
print(response.text)
my_get('https: //www.baidu.com')
# 闭包
def outter(url):
def my_get():
response = requests.get(url)
if response.status_code == 200:
print(response.text)
return my_get
my_jd = outter('https: //www.jd.com')
my_jd()
装饰器
装饰器
"""
装饰器: 给被装饰对象添加新的功能的工具
开放封闭原则:
开放: 对扩展开放
封闭: 对修改封闭
装饰器必须遵循的两个原则:
1.不改变被装饰对象源代码
2.不改变被装饰对象调用方式
"""
# 示例: 统计index函数执行的时间
# 简单版
import time
def index():
time.sleep(3)
print('结束啦')
def outter(func): # func为最原始的index函数的内存地址
def get_time():
start = time.time()
func() # func为最原始的index函数的内存地址,直接调用
end = time.time()
print('index run time: %s'%(end-start))
return get_time
index = outter(index) # outter(最原始的index函数内存地址),index指向get_time函数的内存地址
index() # 结束啦 index run time: 3.0007338523864746
# 升级版
"""
函数参数的问题:
无参函数和有参函数都可以直接调用
函数可以接收任意数量的参数
能返回之前函数的返回值
"""
import time
def index():
time.sleep(3)
print('结束啦')
return 'index'
def login(name):
time.sleep(1)
print('%s is sb'%name)
return 'login'
def outter(func):
def get_time(*args, **kwargs): # args = ('egon',) kwargs = {}
start = time.time()
res = func(*args, **kwargs) # 最原始的login函数的内存地址(),直接调用,login('egon')
end = time.time()
print('func run time: %s'%(end-start))
return res
return get_time
login = outter(login)
res = login('egon') # egon is sb func run time: 1.006035327911377
print(res) # login
index = outter(index)
res1 = index() # 结束啦 func run time: 3.004805326461792
print(res1) # index
装饰器语法糖
# 语法糖写时应该与被装饰对象紧挨着,两者之间不要有空行
import time
def outter(func):
def get_time(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
end = time.time()
print('func run time: %s'%(end-start))
return res
return get_time
@outter # index = outter(index),index = outter(最原始的index函数的内存地址),这个就是装饰器语法糖
def index():
time.sleep(3)
print('结束啦')
return 'index'
@outter # login = outter(login)
def login(name):
time.sleep(1)
print('%s is sb'%name)
return 'login'
@outter # home = outter(home)
def home(*args,**kwargs):
time.sleep(1)
return 'home'
index()
login('egon')
home()
# 示例: 认证装饰器,执行函数index之前判断用户登入状态,已登入则执行,未登入则需登入,用户名密码正确才能执行,修改用户登入状态,否则提示用户输入错误,结束程序
import time
user_dic = {'is_login': None}
def login_auth(func):
def inner(*args,**kwargs):
if user_dic['is_login']:
res = func(*args, **kwargs)
return res
else:
username = input('please input your username>>>: ').strip()
password = input('please input your password>>>: ').strip()
if username == 'jason' and password == '123':
user_dic['is_login'] = True
res = func(*args,**kwargs)
return res
else:
print('username or password error')
return inner
@login_auth
def index(name):
time.sleep(1)
print('%s is dsb'%name)
return 666
index('egon')
多层装饰器
# 双层装饰器
import time
user_dic = {'is_login': None}
def outter(func):
def get_time(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
end = time.time()
print('func run time: %s'%(end-start))
return res
return get_time
def login_auth(func):
def inner(*args,**kwargs):
if user_dic['is_login']:
res = func(*args, **kwargs)
return res
else:
username = input('please input your username>>>: ').strip()
password = input('please input your password>>>: ').strip()
if username == 'jason' and password == '123':
user_dic['is_login'] = True
res = func(*args,**kwargs)
return res
else:
print('username or password error')
return inner
# 装饰器语法糖嵌套,装饰的时候从下往上执行
@login_auth # index = login_auth(get_time),index = inner函数的内存地址
@outter # get_time = outter(index),index是最原始的index
def index():
time.sleep(1)
print('from index')
return 'index'
print(index())
#有参装饰器,三层装饰器
import time
user_dic = {'is_login': None}
def outter(func):
def get_time(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
end = time.time()
print('func run time: %s'%(end-start))
return res
return get_time
def login_auth2(data_source,x,y):
# data_source = 'file'
def login_auth(func):
# func = index
def inner(*args,**kwargs):
if user_dic['is_login']:
res = func(*args, **kwargs)
return res
else:
if data_source == 'file':
username = input('please input your username>>>: ').strip()
password = input('please input your password>>>: ').strip()
if username == 'jason' and password == '123':
user_dic['is_login'] = True
res = func(*args,**kwargs)
return res
else:
print('username or password error')
elif data_source == 'MySQL':
print('from MySQL')
elif data_source == 'LDAP':
print('from LDAP')
else:
print('暂无该数据来源')
return inner
return login_auth
@login_auth2('MySQL',1,2) # @login_auth2('file',1,2) => @login_auth,并且带参 data_source='file'、x=1、y=2
@outter
def index():
time.sleep(1)
print('from index')
return 'index'
index()
装饰器修复技术
"""
若没有用装饰器修复技术,则看被装饰器函数的内存地址、函数名和注释为装饰器内部函数的函数名和注释
装饰器修容技术可以解决:
用户查看被装饰函数的内存地址时就是被装饰函数的内存地址
用户查看被装饰函数的函数名时就是被装饰函数的函数名
用户查看被装饰函数的注释时就是被装饰函数的注释
"""
from functools import wraps
def outter(func):
@wraps(func) # 装饰器修复技术
def inner(*args,**kwargs):
"""
我是inner函数
: param args:
: param kwargs:
: return:
"""
print('执行被装饰函数之前 你可以执行的操作')
res = func(*args,**kwargs)
print('执行被装饰函数之后 你可以执行的操作')
return res
return inner
@outter # index = outter(最原始的index函数的内存地址)
def index():
"""
我是index函数
: return:
"""
pass
print(index) # index函数的内存地址
print(help(index)) # index函数的注释
print(index.__name__) # index函数的函数名,FUNC__name__: 查看函数名
装饰器模板
# 1.无参装饰器
from functools import wraps
def outter(func):
@wraps(func)
def inner(*args,**kwargs): # * **在形参中使用
print('执行被装饰函数之前你可以做的操作')
res = func(*args,**kwargs) # * **在实参中使用
print('执行被装饰函数之后你可以做到操作')
return res
return inner
@outter
def index(name,*args,**kwargs):
"""index注释"""
pass
# 2.有参装饰器(最复杂就三层)
def wrappers(data):
def outter(func):
def inner(*args,**kwargs):
if data == 'file':
print('执行被装饰函数之前你可以做的操作')
res = func(*args,**kwargs) # * **在实参中使用
print('执行被装饰函数之后你可以做到操作')
return res
return inner
return outter
@wrappers('file')
def index(name,*args,**kwargs):
"""index注释"""
pass
递归函数
"""
函数在调用阶段直接或间接的又调用自身
递归分为两个阶段:
1.回溯: 就是一次次重复的过程,这个重复的过程必须建立在每一次重复问题的复杂度下降,直到最终的结束条件
2.递推: 一次次往回推导的过程
"""
# 函数递归深度限制
import sys
print(sys.getrecursionlimit()) # 1000 获取函数递归深度限制,不是很精确
sys.setrecursionlimit(1000) # 设置函数递归深度限制
def func(n):
print('from func',n)
func(n+1)
func(1) # 函数递归深度限制,大概997、998
# 示例1:
"""
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18
age(n) = age(n-1) + 2 # n > 1
age(1) = 18 # n = 1
"""
def age(n):
if n == 1: # 必须要有结束条件
return 18
return age(n-1) + 2
print(age(5)) # 26
# 示例2: 将列表中的数字依次打印出来
l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,]]]]]]]]]]
def get_num(list):
for i in list:
if type(i) is int:
print(i)
else:
get_num(i)
get_num(l)
# 示例3: 二分法,容器类型里面的数字必须有大小顺序
l = [1,3,5,12,57,89,101,123,146,167,179,189,345]
num = 666
def get_num(list,target_num):
if not list:
print('列表不存在')
return
print(list)
# 获取列表中间的索引
middle_index = len(list) // 2
# 比较target_num和middle_index大小
if target_num > list[middle_index]:
# 切取列表右半部分
num_right = list[middle_index + 1: ]
# 再递归调用get_num函数
get_num(num_right,target_num)
elif target_num < list[middle_index]:
# 切取列表左半部分
num_left = list[0: middle_index]
# 再递归调用get_num函数
get_num(num_left, target_num)
else:
print('find it',target_num)
get_num(l,num)
匿名函数
"""
没有名字的函数,临时存在用完就没了
lambda x,y: x+y
: 左边相当于函数的形参
: 右边相当于函数的返回值
匿名函数通常不会单独使用,而是配合内置函数一起使用
"""
res = (lambda x,y: x+y)(1,2)
print(res) # 3
# 给匿名函数命名
func = lambda x,y: x+y
print(func) # <function <lambda> at 0x0000027ED663F160>
print(func(1,2)) # 3
常用的内置函数
# 1. max() min()
l = [1,2,3,4,5]
print(max(l)) # 5
d = {
'egon': 30000,
'jason': 88888,
'nick': 3000,
'tank': 1000
}
print(max(d)) # tank max内部是基于for循环的,字典里比的是索引的第一个字母在ASCII码中对应的大小
"""
ASCII码
A-Z 65-90
a-z 97-122
"""
def index(name):
return d[name]
print(max(d,key=index)) # jason max字典比较,如果传了key,则会把for循环拿到的key作为参数传给后面的index函数执行,最后比较的是函数执行的结果,返回的还是for循环的key
print(max(d,key=lambda name: d[name])) # jason 使用匿名函数
print(min(d,key=lambda name: d[name])) # tank min和max一样
# 2. map() 映射,基于for循环
l = [1,2,3,4,5]
print(list(map(lambda x: x+1,l))) # [2, 3, 4, 5, 6]
# 3. zip() 拉链,基于for循环
l1 = [1,2,3,4]
l2 = ['jason','egon','tank']
l3 = ['a','b',]
print(list(zip(l1,l2))) # [(1, 'jason'), (2, 'egon'), (3, 'tank')]
print(list(zip(l1,l2,l3))) # [(1, 'jason', 'a'), (2, 'egon', 'b')]
# 4. filter() 过滤,基于for循环
l = [1,2,3,4,5]
print(list(filter(lambda x: x != 3,l))) # [1, 2, 4, 5]
# 5. sorted() 对序列（列表、元组、字典、集合、字符串）进行排序
# 语法: list = sorted(iterable, key=None, reverse=False) # iterable 表示指定的序列，key参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted()函数会返回一个排好序的列表
l1 = ['jason','egon','nick','tank']
l2 = [32,12,55,3,656,30]
print(sorted(l1)) # ['egon', 'jason', 'nick', 'tank'] 按首字母排序
print(sorted(l1,reverse=True)) # ['tank', 'nick', 'jason', 'egon'] reverse=True降序
print(sorted(l2)) # [3, 12, 30, 32, 55, 656]
print(sorted(l2,reverse=True)) # [656, 55, 32, 30, 12, 3]
#另外在调用sorted()函数时，还可传入一个key参数，它可以接受一个函数，该函数的功能是指定sorted()函数按照什么标准进行排序。例如：
chars=['http://c.biancheng.net',\
'http://c.biancheng.net/python/',\
'http://c.biancheng.net/shell/',\
'http://c.biancheng.net/java/',\
'http://c.biancheng.net/golang/']
print(sorted(chars,key=lambda x:len(x))) # 自定义按照字符串长度排序
# 6. reduce() 将多个值变成一个值,变的过程依据你传入的函数
from functools import reduce
l = [1,2,3,4,5]
print(reduce(lambda x,y: x+y,l)) # 15 1+2->+3->+4->+5,第一次先获取两个元素相加,之后每次获取一个元素与上一次相加的结果再相加
print(reduce(lambda x,y: x+y,l,18)) # 33 18为初始值,18 >+1->+2->+3->+4->+5
# 7. abs() 求绝对值
print(abs(-11.11)) # 11.11
# 8. all() any()
print(all([0,1,2])) # False 传入可迭代对象,只要有一个值为False就返回False
print(any([0,1,2])) # True 传入可迭代对象,只要有一个值为True就返回True
# 9. bool() 转化为布尔值
print(bool(1)) # True
print(bool(0)) # False
# 10. callable() 判断是否可调用
l = [1,2,3]
def index():
pass
print(callable(l)) # False
print(callable(index)) # True
# 11. chr() ord()
print(chr(97)) # a 将数字转换成ascii码对应的字符
print(ord('a')) # 97 将字符转换成ascii码对应的数字
# 12. dir() 获取当前对象所在的名称空间里的所有名字,返回的是列表
l = [1,2,3]
print(dir(l))
# 13. divmod() 分页器
print(divmod(101,10)) # (10, 1) 101除以10等于10余1
# 14. eval() exec()
# 识别字符串里的代码自动执行返回结果,eval不支持逻辑代码（赋值、for循环等）,只支持简单的代码；exec支持逻辑代码
s = """
print('hello baby~')
x = 1
y = 2
print(x + y)
"""
eval(s)
exec(s)
# 15. globals() locals()
# globals() 字典的形式访问全局变量
# locals() 字典的形式访问局部变量,返回的是当前局部变量的深拷贝,修改locals()中变量值对原变量没有影响
b = 5
def index():
a = 1
locals()['a'] = 2
globals()['b'] = 6
print(locals()) # {'a': 1}
print(globals()) # {'b': 6,...}
index()
# 16. help() 查看注释
def login():
"""
登入
: return:
"""
print(help(login))
# 17. isinstance() 判断对象是否属于某一类型
print(isinstance(1,list)) # False
# 18. pow()
print(pow(2,3)) # 8 计算2的三次方
# 19. round()
print(round(3.5)) # 4 四舍五入取整数
标签：index,
return,
函数,
func,
print,
def
From： https://www.cnblogs.com/jlllog/p/17028457.html