学习Python(8)Python函数 中
函数的特殊用法
函数名也是指向函数的变量
def my_abs(n):
if n < 0:
return -n
return n
print(my_abs(-1)) # 1
f = my_abs # 函数名就是变量,可以赋值
print(f(-2)) # 2
函数可以当成参数
def fn(x, f):
x = 10 + x
return f(x, 20)
def f1(x, y):
return x * y
def f2(x, y):
return x + y
s = fn(1, f2)
print(s)
函数作用域
作用域
变量起作用的范围(区域)
局部作用域
全局作用域
局部变量: 函数内部的变量
特点:
1.内存会被自动释放(调用后会自动回收内存,退出函数就不可以使用)
2.不会被污染(不会被函数外部修改)
全局变量: 整个文件都可以使用的变量
特点:
1.内存不会释放(消耗内存,但是可以一直使用),
2.容易被污染(可能被其他地方修改)
函数: 有作用域
def fn():
a = 10 # 局部变量
print('a =', a)
print('b =', b)
fn()
# 在函数内部定义的变量,在函数外不可以使用
# print('a =', a) # 报错
# 内建作用域: B(Built-in)
# Python中提供的内置函数,内置变量,内置类等.
c = 1 # 全局作用域: G(Global)
def f1():
d = 2 # 函数作用域: E(Enclosing)
def f2():
e = 3 # 局部作用域:L(Local)
print()
global关键字
k = 10
def f3():
# 声明使用的是全局变量k, 一般用于修改全局变量
global k
k = k + 20
print("k =", k)
f3()
print(k)
print()
nonlocal关键字
p = 1
def f4():
p = 2
def f5():
# global p # 使用全局变量p=1
nonlocal p # 使用局部变量p=2
p += 3
print('p =', p) # p = 5
f5()
f4()
print(p)
函数嵌套和闭包
函数嵌套
def f1():
print('f1')
def f2():
print('f2')
return f2
# f = f1() # f=f2
# f() # f2()
# f1()() # 根上面等价
带参数的函数嵌套
def f3(x):
print('f3')
def f4(y):
print('f4', x, y)
return f4
# f3(11)(22)
f = f3(11)
f(22)
闭包:
外部函数 嵌套 内部函数, 且返回内部函数, 则外部函数的参数或变量不会被释放
特点:
1. 变量不会被回收
2. 变量不会被污染
def outer():
n = 10
def inner():
nonlocal n
n += 1
print('n =', n)
return inner
f = outer() # f=inner
f() # 11
f() # 12
f() # 13
列表生成式和生成器
生成列表
l = [1,2,3,4,5] # 第一种
l = list(range(1,6)) # 第二种
l = [] # 第三种
for i in range(1,6):
l.append(i)
列表生成式/列表推导式
l = [i for i in range(1,6)] # [1, 2, 3, 4, 5]
l = [i*i for i in range(1,6)] # [1, 4, 9, 16, 25]
l = [i for i in range(1,6) if i%2] # [1, 3, 5]
l = [i for i in range(1,6) if i%2 and i>2] # [3, 5]
l = [i for i in range(1,6) if i%2 if i<5] # [1, 3]
l = [i+j for i in "123" for j in "abc"]
# => ['1a', '1b', '1c', '2a', '2b', '2c', '3a', '3b', '3c']
# for i in "123":
# for j in "abc":
# i+j
print(l)
l1 = [1,2,3,4,5]
l2 = [i*10 for i in l1]
print(l2) # [10, 20, 30, 40, 50]
字典生成式
d = {i:i*i for i in range(5)}
print(d) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
集合生成式
s = {i*i for i in range(5)}
print(s) # {0, 1, 4, 9, 16}
生成器:generator
一般用于:超多的数或无穷多的数
g = (i for i in range(1,6))
# print(g) # 生成器对象
# <generator object <genexpr> at 0x000001C11A444570>
# 需要使用next()来调用生成器
print(next(g)) # 1
print(next(g)) # 2
print(next(g)) # 3
print(next(g)) # 4
print(next(g)) # 5
# # print(next(g)) # 报错了, StopIteration
# 使用for-in来调用生成器, 不会报错
for i in g:
print('i =', i)
print()
生成器函数:
有yield关键字的函数
yield特点:
1. 写在函数中,会让函数变成生成器函数
2. 每次使用next调用,会在yield暂停
3. 类似return,可以返回值,但是不会结束函数.
def fg():
print("111")
yield 100
print('222')
yield 200
print('333')
g = fg()
# print(g) # 生成器对象
print(next(g)) # 100
print(next(g)) # 200
print(next(g))
可迭代对象和迭代器
可迭代对象
可以使用for-in遍历的就是可迭代对象
有: list,tuple,dict,set,str
type() : 获取数据类型
print(type(10)) # <class 'int'>
isinstance(): 判断某个对象是否属于某个(或多个)类
print(isinstance(10, int)) # True
print(isinstance('abc', (int, float, str))) # True
print(isinstance([], Iterable)) # True
print(isinstance((), Iterable)) # True
print(isinstance({}, Iterable)) # True
print(isinstance({1}, Iterable)) # True
print(isinstance("abc", Iterable)) # True
print(isinstance((i for i in range(2)), Iterable)) # True
print(isinstance(10, Iterable)) # False
迭代器: 既可以使用for-in循环,也可以使用next()调用
print(isinstance([], Iterator)) # False
print(isinstance((), Iterator)) # False
print(isinstance({}, Iterator)) # False
print(isinstance({1}, Iterator)) # False
print(isinstance("abc", Iterator)) # False
print(isinstance((i for i in range(2)), Iterator)) # True
print(isinstance(10, Iterator)) # False
iter() : 将可迭代对象=>迭代器
list() : 迭代器=>可迭代对象(列表)
l = [1,2,3]
t = iter(l)
# print(list(t)) # [1,2,3]
# 可以使用for-in循环
for i in t:
print(i)
# 也可以使用next调用
# print(next(t)) # 1
# print(next(t)) # 2
# print(next(t)) # 3
偏函数
偏函数
print(int('1010')) # 1010
print(int('1010', base=2)) # 10
print(int('1010', base=8)) # 520
import functools
int2 = functools.partial(int, base=2)
print(int2('1010')) # 10
# 转成十六进制 0x开头
print(hex(10)) # 0xa
# 转成八进制 0o开头
print(oct(10)) # 0o12
# 转成二进制 0b开头
print(bin(10)) # 0b1010
print('-' * 100)