9月4日课后笔记

9月4日课后笔记

不定长参数

# 定义一个函数 来求任意数的和

# def s(a,b,c):
#
#     print(a + b + c)
#
# s(1,2)
# TypeError: s() takes 2 positional arguments but 3 were given


def s(*a):

    # 定义一个变量来保存结果
    r = 0
    # 遍历元祖，并将元祖中的数进行相加
    for n in a:
        r += n
    print(r)
s(1,2,5)

# def fn(*a):
#
#     print(a,type(a))
#
# fn(1,2,3,4,6)

# def fn2(a,b,*c):
#
#     print('a =',a)
#     print('b =',b)
#     print('c =',c)
#
# fn2(1,2,3,4,5)

# def fn2(a,*b,c):
#     print('a =',a)
#     print('b =',b)
#     print('c =',c)
# fn2(1,2,3,4,c=5)
# 结果：
# a = 1
# b = (2, 3, 4)
# c = 5

# def fn2(*a,*b,c):
#     print('a =',a)
#     print('b =',b)
#     print('c =',c)
# fn2(1,b=2,3,4,c=5)
# 结果：
#  File "F:/python exerciese/258.py", line 25
#    def fn2(*a,*b,c):
#               ^
# SyntaxError: invalid syntax

# import requests
# headers = {}
# requests.get(heaers=headers,'xxxxx',)
# *形参只能接收位置参数，不能接收关键字参数
# def fn3(b,c,**a):
#
#     print('a =',a)
#     print('b =', b)
#     print('c =', c)
#
# fn3(b=1,d=2,c=3,e=20,f=30)
# fn3(1,2,3)

# *a处理的是位置参数 **a是处理的是关键字参数

# 参数的解包
def fn4(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
# t = (10,20,30)
# fn4(*t)
d = {'a':1,'b':2,'c':3}
fn4(**d)

函数的返回值

# 返回值就是函数执行以后返回的结果
# def s(*a):
#
#     # 定义一个变量来保存结果
#     r = 0
#     # 遍历元祖，并将元祖中的数进行相加
#     for n in a:
#         r += n
#     print(r)
# s(1,2,5)
# 可以直接使用函数的返回值 也可以通过一个变量来接收函数的返回值
# return后面可以跟任意的对象，甚至是一个函数
# def fn():
#
#     # return 123
#     # return 'hello'
#     # return {'a':'b'}
#     def fn2():
#         print('python')
#
#     return fn2
# # print(fn())
# r = fn()  # <function fn.<locals>.fn2 at 0x0000021F92F357B8>
# # print(r)
# r()
# 如果仅仅写一个return 或者没有写return 相当于 return None
# def fn2():
#
#     # return
#     a = 10
# r = fn2()
# print(r)

# return一旦执行函数自动结束
# def fn3():
#
#     print('python')
#     return
#     print('abc')
#
# r = fn3()
# print(r)


# def fn4():
#
#     for i in range(5):
#
#         if i == 3:
#             # break
#             return # return可以用来结束函数
#         print(i)
#     print('循环执行完毕')

# r = fn4()
# print(r)
# fn4()


# 返回值就是函数执行以后返回的结果
def s(*a):

    # 定义一个变量来保存结果
    r = 0
    # 遍历元祖，并将元祖中的数进行相加
    for n in a:
        r += n
    # print(r)
    return r
r = s(1,2,5)
print(r + 3)

文档字符串的说明

help()是Python中内置函数，通过help()函数可以查询Python中函数的用法。在定义函数时，可以在函数内部编写文档字符串，文档字符串就是对函数的说明。

函数的作用域

作用域指的是变量生效的区域，在python中一共有二种作用域：
1、全局作用域
全局作用域在程序执行时创建，在程序结束时销毁。所有函数以外的区域都是全局作用域，在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问。
2、函数作用域
函数作用域在函数调用时创建，在调用结束时销毁。函数每调用一次就会产生一个新的函数作用域，在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问。

# a定义在函数内部，所以他的作用域就是函数的内部，函数外部是无法访问的。
b = 20
def fn():
    a = 10
    print('函数内部','a=',a)
    print('函数外部','b=',b)
fn()
# print('函数内部','a=',a) # NameError: name 'a' is not defined
print('函数外部','b=',b)

def fn1():
    #a = 30
    def fn2():
        a = 40
        print('fn2中a=',a)
    print('fn2中a=', a)
    return fn2()
fn1()

内层函数能使用外层函数的变量，外层函数不能使用内层函数的变量

File "F:/python exerciese/63.py", line 36, in fn1
    print('fn2中a=', a)
NameError: name 'a' is not defined

a = 20
def fn():
    # 如果希望在函数内部修改全局变量，则需要使用一个关键字global，来声明变量
    global a
    a = 100
    print('a=',a)
fn()
print('函数外部a=',a)

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/64.py"
a= 100
函数外部a= 100

命名空间

命名空间实际上就是一个字典，是一个专门用来存储变量的字典。locals()用来获取当前作用域的命名空间。如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间。命名空间返回的是一个字典。

a = 20
b = 30
c = locals()
print(c)
print(c['a'])
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/57.py"
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x008EF6B8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/python exerciese/57.py', '__cached__': None, 'a': 20, 'b': 30, 'c': {...}}
20

def fn():
    a = 50
    scope = locals()
    scope['c'] = 1000
    print(scope)
fn()

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/65.py"
{'a': 50, 'c': 1000}

#在函数内部获取全局的命名空间
a = 20
b = 30
def fn():
    c = globals()
    print('c=',c,type(c))
fn()

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/66.py"
c= {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00C2F6B8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/python exerciese/66.py', '__cached__': None, 'a': 20, 'b': 30, 'fn': <function fn at 0x00CBE6E8>} <class 'dict'>

Process finished with exit code 0

a,b,x = 10,20,30
scope = locals()
print(scope)
def fn():
    d = 21
    c = globals()
    print(c)
    print(c['b'])
    print(a)
fn()
print(x)
print(scope['x'])

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/267.py"
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0060B6B8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/python exerciese/267.py', '__cached__': None, 'a': 10, 'b': 20, 'x': 30, 'scope': {...}}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0060B6B8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/python exerciese/267.py', '__cached__': None, 'a': 10, 'b': 20, 'x': 30, 'scope': {...}, 'fn': <function fn at 0x009FD5C8>}
20
10
30
30

递归函数

递归是解决问题的一种方式，它的整体思想，是将一个大问题分解为一个个的小问题，直到问题无法分解时，在去解决问题。递归式函数有2个条件1. 基线条件 问题可以被分解为最小问题，当满足基线条件时，递归就不执行了。2. 递归条件 可以将问题继续分解的条件。

def fn(n):
    # 1.基线条件 判断如果用户让求的数字是1的情况，我们就满足基线条件了，就不再递归了
    if n == 1:
        return 1
    # 2.递归条件
    return n * fn(n-1)
r = fn(10)
print(r)

# 定义一个函数，来为任意数字做幂运算
def fn(a,n):
    if n == 1:
        return a
    return a * fn(a,n-1)
r = fn(2,8)
print('r=',r)

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/67.py"
r= 128

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/67.py"
3628800

作业

定义一个函数，用来检查一个任意的字符串是否是回文字符串，如果是返回True,不是返回False。回文字符串从前往后念和从后往前念是一样的。例如 TNT

def a(b):
    list1 = list(b)
    list2 = list1[:]
    list2.reverse()
    if list1 == list2:
        return b,"是回文字符串"
    else:
        return b, "不是回文字符串"
b = input("输入一个字符串:")
print(a(b))

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/68.py"
输入一个字符串:abcdedcba
('abcdedcba', '是回文字符串')