五、Python函数之基础

全局变量与局部变量

顶头，没有任何缩进就是全局变量
函数里的变量是局部变量
如果在函数里使用 global全局变量，则可以改变全局变量。
如果没有global全局变量，调用全局变量的时候，只能读取，无法重新赋值
nonlocal 取上一级变量
书写规范
全局变量大写
局部变量小写

递归函数

归函数特性
一个函数调用自己
1.必须有一个明确的结束条件
2.每进入更深层次递归时，问题规模相比上一次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出。

person_list = ['alex','wupeiqi','linhaifeng','zsc']

def ask_way(person_list):
    print('-'*60)
    if len(person_list) == 0:
        return '根本没人知道'
    person = person_list.pop(0)

    if person == 'linhaifeng':
        return '%s说:我知道，老男孩就在....' % person

    print('hi 你好[%s],敢问路在何方'%person)
    print('%s回答道：我不知道，但念你慧眼识猪，你等着，我帮你问问%s...'%(person,person_list))

    res = ask_way(person_list)
    print('%s问的结果是：%s'%(person,res))
    return res
res = ask_way(person_list)
print(res)
#>>>
------------------------------------------------------------
hi 你好[alex],敢问路在何方
alex回答道：我不知道，但念你慧眼识猪，你等着，我帮你问问['wupeiqi', 'linhaifeng', 'zsc']...
------------------------------------------------------------
hi 你好[wupeiqi],敢问路在何方
wupeiqi回答道：我不知道，但念你慧眼识猪，你等着，我帮你问问['linhaifeng', 'zsc']...
------------------------------------------------------------
wupeiqi问的结果是：linhaifeng说:我知道，老男孩就在....
alex问的结果是：linhaifeng说:我知道，老男孩就在....
linhaifeng说:我知道，老男孩就在....

函数作用域

name = 'alex'

def foo():
    name = 'hg'
    def bar():
        name = 'lg'
        def tt():
            return name
        return tt
    return bar

foo = foo()()()    #foo()执行第一个函数，返回bar == foo(),然后foo()() == bar(),接着执行bar().....
print(foo)

匿名函数lambda

lambda x:x+1       #  函数形式  lambda 形参 : 返回值
a = lambda x:x+1
print(a(10)) #11
name  = 'lghg'
def change_name(x):
    return name+'_nb'
res = change_name(name)
print(res) #>>>lghg_nb

f = lambda x:name+'_nb'
res = f(name)
print(res)#>>>lghg_nb
# print((lambda x:name+'_nb')(name))  #更加简洁

f = lambda x,y,z:x+y+z
res = f(1,2,3)
print(res) #>>>6

函数式编程

函数式 = 编程语言定义的函数+数学意义的函数
高阶函数：1.函数接收的参数是一个函数名 2。返回值中包含函数

#非函数式
a = 1
def text():
    global a
    a += 2
    return a


#函数式
n = 1
def func(n):
    return n+1


# 高阶函数：1.函数接收的参数是一个函数名 2。返回值中包含函数
def foo(n):
    print(n)
def bar(name):
    print(name)
foo(bar("hg"))

内置函数

map函数：重点
map函数表达式：map(func,可迭代对象)，功能：把可迭代对象用for循环的方式进行功能函数处理,得到的结果是一个列表地址，位置以及个数与原来一样

点击查看代码

num1 = [1,2,3,4,5,6,7,8,9]
#执行每个数加1
def add_1(x):
    return x+1
lambda x:x+1

def reduce_1(x): #执行每个数减1
    return x-1

lambda x:x-1
def mab_text(func,array): #使用func（i）是为了不把函数写死，这样这个函数就可以调用其他功能函数
    res=[]
    for i in array:
        ret=func(i) #add_1(i)/(lambda x:x+1)(i)/reduce_1(i)/(lambda x:x-1)(i)
        res.append(ret)
    return res
print(mab_text(add_1,num1))
print(mab_text(lambda x:x+1,num1))
print(mab_text(reduce_1,num1))
print(mab_text(lambda x:x-1,num1))

#map函数可以使上面的功能更加简洁
#map函数  map(func,可迭代对象) 功能：把可迭代对象用for循环的方式进行功能函数处理,得到的结果是一个列表地址，位置以及个数与原来一样
res = map(lambda x:x+1,num1)
print("内置函数map,处理结果",res) #<map object at 0x0000018981841750> 地址
print(list(res)) #[2, 3, 4, 5, 6, 7, 8, 9, 10]

print(list(map(reduce_1,num1)))#[0, 1, 2, 3, 4, 5, 6, 7, 8]

lh = 'hjgjkcgj' #全部转换成大写
print(list(map(lambda x:x.upper(),lh))) #['H', 'J', 'G', 'J', 'K', 'C', 'G', 'J']

filter函数：重点
filter函数把迭代对象在功能函数进行for循环，判断为True则输出，判断为False则过滤，删除

点击查看代码

movie_people = ['sb_jhj','sb_kk','sb_jj','hg','lg','sb_jhj']

"""
滤除不要的人
"""
res = []
for person in movie_people:            #不用函数
    if  not person.startswith('sb'):
        res.append(person)
print(res) #['hg', 'lg']

def filter_movie(array): #用函数
    ret = []
    for i in array:
        if not i.startswith('sb'):
            ret.append(i)
    return ret
print(filter_movie(movie_people)) #['hg', 'lg']

def sb_show(n):
    return n.startswith('sb')

def filter_movie(func,array):
    ret = []
    for i in array:
        if not func(i): #使用func（i）是为了不把函数写死，这样这个函数就可以调用其他功能函数
            ret.append(i)
    return ret
print(filter_movie(sb_show,movie_people)) #['hg', 'lg']

#终极版本
res = filter_movie(lambda x:x.startswith("sb"),movie_people)
print(res) #['hg', 'lg']

#filter函数  把迭代对象在功能函数进行for循环，判断为True则输出，判断为False则过滤，删除
movie_people = ['sb_jhj','sb_kk','sb_jj','hg','lg','sb_jhj']
print(filter(lambda x:x.startswith("sb"),movie_people)) #<filter object at 0x000001B1D28A1FF0> 内存地址
print(list(filter(lambda x:x.startswith("sb"),movie_people)))#['sb_jhj', 'sb_kk', 'sb_jj', 'sb_jhj'] #如果是以sb开头则为真，即输出
print(list(filter(lambda x:not x.startswith("sb"),movie_people)))#['hg', 'lg']
print(list(map(lambda x:not x.startswith("sb"),movie_people)))#[False, False, False, True, True, False]

**reduce函数** reduce 函数把整个迭代对象压缩为一个值

from functools import reduce #必须要有
print(reduce(lambda x,y:x*y,num_1)) #362880

zip函数

#zip #一一对应，形成元组，再组成列表
print(list(zip(('a','b','c'),(1,2,3))))#[('a', 1), ('b', 2), ('c', 3)] 
print(list(zip(('a','b','c'),(1,2,3,4)))) #[('a', 1), ('b', 2), ('c', 3)]
print(list(zip(('a','b','c','d'),(1,2,3,4))))#[('a', 1), ('b', 2), ('c', 3)]

p = {'name':'hg','age':23,'hoppy':'mv'}
print(list(zip(p.keys(),p.values()))) #[('name', 'hg'), ('age', 23), ('hoppy', 'mv')]

max、min函数及高级使用
max 取最大值 min取最小值

高级使用：
1.max函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意，不同类型之间不能进行比较
2.每个元素进行比较，是从每个元素的第一个位置依次比较，如果这一位置区分出大小，后面的都不需要比较了，直接得出这两个元素的大小

age_dic = {'age1':18,'age2':19,'age3':20}
print(max(age_dic.values()))
print(max((zip(age_dic.values(),age_dic.keys())))) #(20, 'age3')

people = [
    {'name':'hg','age':23},
    {'name':'lg','age':18},
    {'name':'mv','age':19}
]

print(max(people, key = lambda dic:dic['age']))#>>>{'name': 'hg', 'age': 23}

sorted函数
sorted排序本质比较大小，只有同类型才能比较

L = [2,8,6,7,3]
print(sorted(L)) #[2, 3, 6, 7, 8]

people = [
    {'name':'hg','age':23},
    {'name':'lg','age':18},
    {'name':'mv','age':19}
]
print(sorted(people, key = lambda dic:dic['age'])) #[{'name': 'lg', 'age': 18}, {'name': 'mv', 'age': 19}, {'name': 'hg', 'age': 23}]

name = {
    'lg':2000,
    'mv':300,
    'hg':1000
}
print(sorted(name))#['hg', 'lg', 'mv'] 按照keys值直接进行比较
print(sorted(name,key = lambda x:name[x]))#['mv', 'hg', 'lg']
print(sorted(zip(name.values(),name.keys())))#[(300, 'mv'), (1000, 'hg'), (2000, 'lg')]

其他函数

点击查看代码

name = '你好'
print(bytes(name,'utf-8')) #b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(bytes(name,'utf-8').decode('utf-8')) #解码你好
print(bytes(name,'gbk').decode('gbk')) #你好

#===divmod
print(divmod(7,2)) #取商，余数>>>(3, 1)

#eval
dic = {"name":'hg'}
dic_str = str(dic)
print(dic_str) #{'name': 'hg'}字符串
print(eval(dic_str))#{'name': 'hg'} 字典     #把字符串中的数据结构提取出来
a = eval(dic_str) #字符串变为字典
print(a['name']) #hg

express = '1+1+23*2'
print(eval(express)) #48 把字符串中的表达式进行运算

#hash 可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
name = 'hg'     #可以用hash判断所定义的变量，有没有被修改
print(hash(name))#8023437410973310514
print(hash(name))#8023437410973310514
name = 'lg'
print(hash(name)) #-2793483496824705473

#isinstance 判断数据类型
print(isinstance('hg',str))#True
print(isinstance(123,int))#True

#ord
print(chr(97)) #a
print(ord('a'))#97
#pow
print(pow(2,3))# 2**3
print(pow(2,3,3))#2**3%3

#round 四舍五入
print(round(3.5)) #4

#切片slice
L = 'lghgkk'
print(L[3:5]) #gk
a = slice(3,5)
print(L[a]) #gk

#sum求和

#type
a= '123'
if type(a) == str:
    a = int(a)
    a +=1
    print(a) #124

#var 用处不大

def test():
    msg = "hello world"
    print(locals())
test() #>>>{'msg': 'hello world'}

def test():
    msg = "hello world"
    print(vars())            #没有参数和locals（）一样，有参数的时候把对象打印成字典的形式

test() #>>>{'msg': 'hello world'}

posted @ 2024-07-16 00:14 很难通透阅读(21) 评论(0) 收藏举报

刷新页面返回顶部

huanggai

五、Python函数之基础

全局变量与局部变量

递归函数

函数作用域

匿名函数lambda

函数式编程

内置函数

公告