python 函数作用域和内置函数

函数作用域
name = 'alex'

def foo():
    name = 'linhaifeng'
    def bar():
        name = 'wupeiqi'
        print(name)
    return bar
a = foo()
a()

def test1():
    print('in the test1')
def test():
    print('in the test')
    return test1
print(test)

res = test()
print(res)

name = 'alex'
def foo():
    name = 'lhf'
    def bar():
        name = 'wupeiqi'
        def tt():
            print(name)
        return tt
    return bar

bar = foo()
tt = bar()
tt()
foo()()()

匿名函数

lambda x:x+1

def calc(x):
    return x + 1


a = calc(10)
print(a)

x = lambda x:x+1

print(x(10))


name = 'alex'

def change_name(name):
    return '%s _sb' %name

a = change_name(name)
print(a)

s = lambda name:name+'_sb'

print(s(name))

v = lambda x, y, z: x + y + z
print(v(1, 2, 3))

v = lambda x, y, z: (x + 1, y + 1, z + 1)
print(v(1, 2, 3))

函数式编程
编程的方法论

面向过程
1、搜索目标
2、表白
3、恋爱
4、见家长
5、结婚

函数式 = 编程语言定义的函数 + 数学意义的函数
1、数学模型  y  = 2 * x + 1
2、难懂
3、特性：不可变，不用变量保存状态，不修改变量


高阶函数
1、函数作为参数传给函数
def foo(n):
    print(n)

def bar(x):
    print(x)

foo(bar(1))

2、返回值中包含函数
def bar():
    print('from bar')

def foo():
    print('from foo')
    return bar

ar = foo()
ar()

def handle():
    print('from handle')
    return handle()

h = handle()
h()

def test1():
    print('test1')
def test2():
    print('test2')
    return test1()

尾调用优化  最后一步进入递归
尾调用
def bar(n):
    return n
def foo(x):
    return bar(x)

不是尾调用
def bar(n):
    return n
def foo(x):
    return bar(x) + 1

面向对象


map 函数

num_1 = [1, 2, 23, 78, 22]

add_one = lambda x: x + 1
ress_one = lambda x: x - 1
ff_w = lambda x: x ** 2


def map_test(func, array):
    res = []
    for i in array:
        res.append(func(i))
    return res


print(map_test(add_one, num_1))

map(函数,可迭代对象)
v1 = map(lambda x: x + 1, num_1)

yy = []

for i in v1:
    yy.append(i)
    print(i)
print(yy)

print(v1)

filter() 函数
movie = ['sb_alex', 'wupeisbqi', 'yuanhao_sb', 'sb', 'lihaifeng']


def filter_test(func, array):
    goout = []
    for i in movie:
        if not func(i):
            goout.append(i)
    return goout


print(filter_test(lambda x: x.endswith('sb'), movie))

print(list(filter(lambda x: not x.endswith('sb'), movie)))

reduce()

numl = [1, 2, 3, 4, 5]


def reduce_test(func, numl, init=None):
    if init is None:
        res = numl.pop(0)
    else:
        res = init
    for num in numl:
        res = func(num, res)
    return res


print(reduce_test(lambda x, y: x * y, numl, 100))

from functools import reduce

r = reduce(lambda x, y: x * y, numl)

print(r)

总结

map()  序列中每个元素得到的结果是一个 '列表'，该 '列表'元素个数及位置与原来一样


filter() 遍历序列中的每一个元素，判断每个元素得到布尔值，如果是True 则留下来。

people = [
    {
        'name': 'alex1',
        'age': 1000,
    },
    {
        'name': 'alex2',
        'age': 10000,
    },
    {
        'name': 'alex3',
        'age': 9000,
    },
    {
        'name': 'alex4',
        'age': 18,
    }
]

a = list(filter(lambda x: x['age'] <= 18, people))
print(a)

reduce() 处理一个序列，然后对序列进行合并操作

内置函数

绝对值
print(abs(-222))

序列中的每一个元素布尔值  一个为假就是假  如果可迭代函数为空  则为True
print(all([1, 2, 3, 4, 55, '222', '']))  False
print(all([])) True

any()  有一个真即为真
print(any([1, 2, 3, 4, 55, '222', ''])) True

bin() 10进制转2进制
print(bin(20))

判断bool 假的值 0 None ''
print(bool(''))

字符串转成字节  用什么编码用什么解码
v = '000'

print(bytes(v, encoding='utf-8'))

print(bytes(v, encoding='utf-8').decode('utf-8'))

print(bytes(v, encoding='gbk'))

print(bytes(v, encoding='ascii'))

chr()  对应ascii 码存储的
print(chr(97))

打印某一个对象都有什么方法
print(dir(all))

取余数
print(divmod(10, 3))

提取字符串中的数据结构  字符串中的数学运算
dic = {'name': 'alex'}
dic_str = str(dic)
print(eval(dic_str))

express = '1+2*(3*3)'
print(eval(express))

hash()  可hash的数据类型即不可变的数据类型，不可hash数据类型是可变数据类型
print(hash('12sdasdasdasdasdasdasdasdasd3'))

help()

isinstance() 判断数据类型
print(isinstance(1, int))

查看全局变量  查看局部变量
name = 'sd'
print(globals())
print(locals())

max() min()
name = [1, 23, 33, 2]

zip()  两个 序列  元祖  列表 字符串
print(list(zip(('a', 'b', 'c'), (1, 2, 3))))
print(list(zip(('a', 'b', 'c'), (1, 2, 3, 4))))
print(list(zip(('a', 'b', 'c', 'd'), (1, 2, 3))))

p = {'name': 'alex', 'age': 18}

print(list(zip(p.keys(), p.values())))

print(list(zip(['a', 'b'], '123456')))

age_dic = {'age1': 18, 'age2': 20, 'age3': 67}

print(max(age_dic.values()))
print(min(age_dic.values()))

默认比较字典的key
print(max(age_dic))

print(list(max(zip(age_dic.values(),age_dic.keys()))))


ll = ['a10', 'b12', 'c10', 100]  #不同类型不能进行比较
ll = ['a10', 'b12', 'c10']
print('----->', list(max(ll)))

min()  max() 高级用法
1、简单数据直接比较
2、复杂比较
people = [
    {
        'name': 'alex1',
        'age': 1000,
    },
    {
        'name': 'alex2',
        'age': 10000,
    },
    {
        'name': 'alex3',
        'age': 9000,
    },
    {
        'name': 'alex4',
        'age': 18,
    }
]

print(max(people, key=lambda dic: dic['age']))

十进制转8进制
print(oct(10))

显示对应ascii 码表对应的字符
print(ord('a'))

3**3%2
print(pow(3, 3, 2))

reversed() 翻转
lii = [1, 23, 4]
print(list(reversed(lii)))

四舍五入
print(round(3.5))

l = 'hello'
print(l[3:5])

s1 = slice(3,5)  还可设置步长  s1 = slice(1,4,2)
print(l[s1])

排序
l = [3, 2, 1, 5, 6, 18, 'a']   #本质就是比较大小，不同类型不能排序
print(sorted(l))
people = [
    {
        'name': 'alex1',
        'age': 1000,
    },
    {
        'name': 'alex2',
        'age': 10000,
    },
    {
        'name': 'alex3',
        'age': 9000,
    },
    {
        'name': 'alex4',
        'age': 18,
    }
]
print(sorted(people, key=lambda dic: dic['age']))

dic = {
    'aoop': 100,
    'ooi': 300,
    'iuy': 500
}

print(sorted(dic, key=lambda key: dic[key]))

print(sorted(dic, key=lambda key: dic[key]))

print(sorted(list(zip(dic.values(),dic.keys()))))

数据类型
sss = 'sss'
print(type(sss))

求和
print(sum(range(5)))

类型判断  type()

vars()  如果没有参数和locals一样   如果有参数

def test():
    msg = 'sdada0'
    print(locals())

print(vars(int))

test()


import 不能导入字符串
__import__ 导入字符串