1. 函数的返回值
# @Time : 2020/8/11 18:20
# @Author : PanHui
# @File : 函数的返回值.py
# 返回值就是返回函数执行的结果
# 通过return来指定函数的返回值
# 求任意数的和
# def fn(*args):
# r = 0
# for n in args:
# r += n
# print(r)
# return r
# r = fn(1,2,3)
# print(r-3-3)
#可以直接使用函数的返回值，另一种方式通过一个变量来接收函数的返回值
# def fn():
# return后面可以跟任意对象，甚至可以是一个函数
# return 123
# return 'abc'
# return [456]
# return {'a':123}
# def fn2():
# print('hello')
# return fn2
# r = fn()
# r()
#print(fn())
# def fn2():
# print(123)
# return
# r = fn2()
# print(r)
# 在函数中，return后的代码都不会执行，return一旦执行函数自动结束
# def fn3():
# print('abc')
# return
# print('hahaha')
# r = fn3()
# print(r)
def fn4():
for i in range(5):
if i ==3:
# break 用来退出当前循环
# return 函数结束
# continue 用来跳过当成循环
print(i)
print('循环执行完毕')
fn4()
# fn是函数对象 打印fn就是在打印函数对象
# fn()调用函数 打印fn()实际上我就是在打印fn()的返回值
# print是函数对象 print()调用函数
2. 文档字符串
# @File : 文档字符串.py
# '''
#
# '''
# help()内置函数 可以查询python中函数的用法
# 语法 help(函数对象)
# 汉化版 有bug有些模块安装不上
# 没有任何一家公司用汉化
# print(1,2,3)
# help(print)
# 文档字符串
# 在定义函数的时候，可以在函数内部编写文档字符串，文档字符串就是函数的说明
# 当我们编写了文档字符串时，就可以通过help()函数来查看函数说明
def fn(a:bool,b:int,c:str):
'''
这是一个文档字符串的示例
这个函数的作用.......
函数的参数
:param a: 作用 类型 默认值...
:param b: 作用 类型 默认值...
:param c: 作用 类型 默认值...
:return: 需要/不需要
'''
return 123
help(fn)
3. 函数作用域
# @File : 函数的作用域.py
# 作用域(scope) 指的就是变量生效的区域
# 在python当中一共有2种作用域
# 全局作用域
# 全局作用域在程序执行时创建，在程序执行结束时销毁
# 所有函数以外的区域都是全局作用域
# 在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问
# b = 20
# def fn():
# a = 123
# print('函数内部:a =',a)
# print('函数内部:b =',b)
# fn()
# # print('函数外部:a =',a) # NameError: name 'a' is not defined
# print('函数外部:b =',b)
# def fn2():
# a = 30
# def fn3():
# a = 40
# print('fn3中：a =',a)
# fn3()
# fn2()
a = 456
def fn3():
# 在函数内部修改全局变量，需要使用global关键字，来声明局部变量
global a # 声明在函数内部使用的a是全局变量，此时去修改a，就是在修改全局的a
a = 123
print('函数内部a =',a)
fn3()
print('函数外部a =',a)
4. 命名空间
# @File : 命名空间.py
# 命名空间就是一个字典，是一个专门用来保存变量的字典
# locals() 用来获取当前作用域的命名空间 返回一个字典
a = 123
b = 456
# scope = locals()
# print(scope)
# print(a)
# print(scope['a'])
# 向scope里面添加了一个key-value
# scope['c'] = 789
# print(c)
def fn():
a = 1
# scope = locals() # 在函数内部调用locals()会获取函数的命名空间
# scope['c'] = 789
# print(scope)
# print(c)
# globals()函数可以用来获取全局的命名空间
global_scope = globals()
print(global_scope)
fn()
5. 递归函数
# @File : 递归函数.py
# 尝试求10的阶乘(10!)
# 1! = 1
# 2! = 1*2
# 3! = 1*2*3
# 10! = .....*8*9*10
# print(1*2*3*4*5*6*7*8*9*10) # 3628800
# n = 10
# for i in range(1,10):
# # print(i)
# n *= i
#
# print(n) # 3628800
# 定义一个函数来实现任意数的阶乘
# def fn(n):
# 参数n代表要求阶乘的数字
# 定义一个变量来保存结果
# r = n
# for i in range(1,n):
# # print(i)
# r *= i
# return r
# print(fn(30))
# 递归式的函数
# 从前有座山，山里有座庙，庙里有个老和尚在给一个小和尚讲故事，讲什么故事呢？
# 从前有座山，山里有座庙，庙里有个老和尚在给一个小和尚讲故事，讲什么故事呢？
# 从前有座山，山里有座庙，庙里有个老和尚在给一个小和尚讲故事，讲什么故事呢？
# .....
# 递归简单理解就是自己引用自己
# 递归式的函数，在函数中自己调用自己
# def fn1():
# fn1()
# fn1()
# 递归式解决问题的一种思想，它和循环很像
# 它的整体思想是把一个大的问题分解为一个小的问题，直到问题无法分解时，再去解决问题
# 1.基线条件 问题可以被分解为最小的问题，当满足基线条件时，递归就不在执行了
# 2.递归条件 将问题继续分解的条件
# 10! = 10 * 9!
# 9! = 9 * 8!
# 8! = 8 * 7!
# ....
# 1! = 1
# 用递归的思想解决任意数的阶乘问题
def fn2(n):
# 1.基线条件
if n == 1:
return 1
# 2.递归条件 9*8！
return n * fn2(n-1)
print(fn2(10)) # 3628800
**.递归练习**
```cpp
# @File : 递归练习.py
# 定义一个函数 为任意数字做任意的幂运算
# 10 ** 5 = 10 * 10 ** 4
# 10 ** 4 = 10 * 10 ** 3
# 10 ** 3 = 10 * 10 ** 2
# ...
# 10 ** 1 = 10
# def fn(n,i):
# # 参数n代表任意数字 i代表任意数字做任意的幂运算 5 ** 3(n就是5 i就是3)
# # 1.基线条件
# if i == 1:
# # 求1次幂
# return n
# # 2.递归条件 10*10 ** 4 10**5
# return n * fn(n,i-1)
# print(fn(2,3))
# 定义一个函数，用来检测任意的一个字符串是否是回文字符串，如实是True 不是返回False
# 回文字符串 字符串从前往后念从后往前念是一样的 例如 abcba
# abcdefgfedcba
# 如果第一个字符和最后一个字符不一致则该字符串一定不是回文字符串
# abcdefgfedcba是不是回文
# bcdefgfedcb
# cdefgfedc
# ...
# g
def fn2(s):
# 参数S表示要检查的字符串是否是回文字符串
# 1. 基线条件
if len(s) < 2:
return True
elif s[0] != s[-1]:
return False
# 2. 递归条件 cdefgfedc
return fn2(s[1:-1])
print(fn2('abcgcba'))
s = 'abcgcba'
# s = 'bcgcb'
# s = 'cgc'
# # g
print(s[1:-1])
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
