学习作业笔记

林夕讲解

#x + y = 35

# 2x + 4y = 94

'''

for i in range(36):

y = 35 - i

if 2i+4y == 94:

print(f"鸡仔有{i}只，兔子有{y}只")

'''

def isZhi(a):

if a == 1:

print("1既不是质数，也不是合数")

for i in range(2,a):

if a % i == 0:

return False

else:

return True

a = isZhi(5)

print(a)

函数中的变量的作用域

# 全局变量、局部变量

'''

全局变量：声明在函数外边的变量

'''

a = 100

def test_01():

a = 0

b = 110

print(a)

print(b)

# test_01()

# print(a)

# print(b)

def test_02():

print(a)

# 局部变量的作用范围仅限于函数内部

# test_02()

def test_03():

# 函数内部可以使用全局变量但是无法修改全局变量,如果要进行修改，使用globle关键字

global a

a += 100

print(a)

test_03()

函数注释

# def 函数名():

# 代码

def sum_01(a,b):

'''

a:int

b:int

:return 两数之和

'''

return a+b

sum_01(1,2)

round()

值传递和引用传递

# def test01(x, y):

# x += 10

# y += 20

# print(x, y)

#

#

# a = 10

# b = 20

# test01(a, b)

# print(a)

# print(b)

# 值传递：在传递参数时，仅仅是把值拷贝一份传递给参数的函数，变量的值不发生变化

def test02(nums):

print(id(nums))

nums.append(10)

nums.append(100)

print(nums)

list1 = [1, 2, 3]

print(id(list1))

test02(list1)

# print(list1)

# 引用传递：

# 在传递参数的时候，传地址，函数形参获取的值，也是同一块内存

匿名函数

# let a = function(){}

# python中，如果要将函数作为参数传到另外一个函数里边去

# python中函数参数的数据类型：只要是对象就可以

# python ：函数本身就是一个对象

# def compute(a,b):

# return a+b

def test01(fn):

a = fn(1,2)

print(a)

# test01(compute)

test01(lambda a, b: a + b)

# python中，存在函数作为参数传递给函数，并且不想被外界访问，而且参数函数足够简单，即可以定义为匿名函数(lambda 表达式)

'''

lambda [a,b]:代码块

'''

偏函数

# def int2(x,base=2):

# return int(x,base)

#

#

# a = int2("10010")

# print(a)

# 偏函数：

import functools

int2 = functools.partial(int,base=2)

print(int2('10010'))

# 我们有时候需要调用某个函数，如果想将该函数中的某个参数设置一个固定的值，那么就可以使用偏函数

新特性

# 声明函数参数类型

# def fun(a,b,c):

# public static void fn(int a,double b,String c){

#

# }

def add(x: int, y: float) -> float:

print(x + y)

return x + y

add(1, 1)

# add("1","1")

函数的嵌套

def fun1():

b = 20

def fun2(): #fun2 = def(){}

print(b)

print("222222222")

return fun2

a = fun1()

a()

闭包

'''

综上：函数可以作为返回值进行返回

函数可以作为参数进行传递

函数名本质上就是变量名，指向函数所在的内存地址

闭包：一个函数嵌套另一个函数，内层函数用到外层函数的局部变量，内层函数即为闭包

'''

def outer():

a = 10

def inner():

nonlocal a

a += 100

return inner

a = outer()

'''

1、可以让一个变量常驻在内存中

2、可以避免全局变量被修改

'''

装饰器

# def guanjia(fn):

# print("开挂")

# fn()

# print("关闭外挂")

'''

装饰器本质上就是一个闭包，作用：不改变原有函数的前提下，为函数添加新的功能，但是源代码没改变

运用：用户登录、日志

'''

def guanjia(fn):

def inner():

print("开挂")

fn()

print("关闭外挂")

return inner

@guanjia #play_dnf = guanjia(play_dnf)

def play_dnf():

print("你好啊，我是赛利亚，今天又是美好的一天")

@guanjia

def play_wz():

print("来和妲己玩耍吧")

play_dnf()

play_wz()

# new_playwz = guanjia(play_wz)

# new_playwz()

# print("开挂")

# play_dnf()

# print("关闭外挂")

#

# print("开挂")

# play_wz()

# print("关闭外挂")

# guanjia(play_wz)

# guanjia(play_dnf)

'''

装饰器雏形：

def wrapper(目标函数)：

def inner():

之前添加的事情

目标函数原函数执行

之后添加的事情

return inner

@wrapper # 目标函数 = wrapper（目标函数）

'''