python—函数

函数

1. python中函数定义方法：

def  test(x):
        '''注释，解释函数用途'''
        x=x+1
        return x

def:定义函数的关键字
test:函数名
():括号内可定义形参
x=x+1:泛指代码块或者程序处理逻辑
return:定义返回值

过程：过程就是简单特殊没有返回值的函数（没有返回值返回none）

2. 函数参数：

1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元，因此，形参只有在函数内部才有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
2.实参变量可以是常量，变量，表达式，函数等，无论函数是何种类型的量，在进行函数调用时，它们必须有确定的值，以便把这些值传递给形参。因此应用预先赋值，输入等办法使参数获得确定值。
def  calc(x,y):
        res=x**y
        return res
a=calc(2,3)
print(a)
#运行结果：8

位置变量：(位置参数，一 一对应，缺一不可)
def  test(x,y,z):
        print(x)
        print(y)
        print(z)
test(1,2,3)

def  test(x,y,z):   (关键字参数，无须一一对应，缺一不行多一不行)
        print(x)
        print(y)
        print(z)
test(x=1,z=3,y=2)

  3.全局变量与局部变量

name="zhouyuan"      #全局变量，全局作用域
def  change_name():
    name="zhoutao"    #局部变量，局部作用域
    print(name)
change_name()
print(name)
#运行结果:zhoutao
#       zhouyuan

    #如果想要在局部作用域内定义全局变量，使用关键字global

name="zy"
def a():
    global name
    print(name)
def b():
    name="zt"
    print(name)
a()
b()
# 运行结果：zy
#         zt

   #如果函数的内容无global关键字，优先读取局部变量。对于全局变量只能读取，不能重新赋值

   #如果函数中有global关键字变量本质上就是全局的那个变量，可读取可赋值

name="zy"
def a():
    global name
    name="zz"        #现在zz是全局的
    print(name)
def b():
    print(name)
a()       
b()
#运行结果：zz
#          zz        （因为a()先执行，a()已经将全局变量变成name=“zz”）

name="zy"
def a():
    global name
    name="zz"        #现在zz是全局的
    print(name)
def b():
    print(name)     
b()         （先执行b()未执行到global）
a()
#运行结果：zy
#        zz

  #全局变量还可以是列表等类型，并且可以在函数内部对列表进行操作

name=["蔡徐坤","朱正廷"]
def zy():
    name.append("范丞丞")
    print(name)
zy()
#运行结果：['蔡徐坤', '朱正廷', '范丞丞']

 #函数内套函数

name="蔡徐坤"

def zy():
    name="范丞丞"
    def zt():
        global name
        name="农农"
    zt()
    print(name)

print(name)
zy()
print(name)

#运行结果：蔡徐坤
#        范丞丞
#        农农

  #nonlocal关键字修改上一层变量

name="蔡徐坤"

def zy():
    name="范丞丞"
    def zt():
        nonlocal name
        name="农农"
    zt()
    print(name)

print(name)
zy()
print(name)

 #运行结果：蔡徐坤
#         农农
#         蔡徐坤 

  4.函数递归

递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用

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

def calc(n):
    print(n)
    if int(n/2)==0:
        return n
    return calc(int(n/2))
calc(10)
#运行结果：10,5，2,1

 5.函数作用域

def test1():
    print("in the test1")
def test():
    print("in the test")
    return test1
res=test()
print(res())
#运行结果：in the test
#        in the test1
#        None    （test1没有返回值默认返回None）

  

  6.匿名函数 lambda

def calc(x):
    return x+1

res=calc(10)
print(res)
#运行结果：11

使用lambda匿名函数：
res=lambda x:x+1    【lambda匿名函数后面x是形参，x+1相当于return x+1】
print(res(1))
#运行结果：2

  #修改字符串

name="zy"
f=lambda x:x+"_sb"
res=f(name)
print(res)
#运行结果：zy_sb

 

 7.三个重要函数 map() filter() reduce()

   【1】map函数 （处理列表中的每个元素，得到结果是一个‘列表’，该‘列表’元素个数及位置与原来一样）

#map(处理方法，可迭代对象)
num_1=[1,2,3,4,5,6]

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

print(map_test(lambda x:x+1,num_1))

res=map(lambda x:x+1,num_1)
print(list(res))

#运行结果：[2, 3, 4, 5, 6, 7]
#        [2, 3, 4, 5, 6, 7]

   【2】filter 函数  （遍历序列中每个元素，判断每个元素，得到布尔值，如果是True则留下来）

movie_people=['sb_alex','sb_zt','zy','sb_wu']

def filter_test(array):
    ret=[]
    for i in array:
        if not i.startswith('sb'):
            ret.append(i)
    return ret

print(filter_test(movie_people))
#运行结果：['zy']

#终极版本
movie_people=['alex_sb','zt_sb','zy','wu_sb']

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

res=filter_test(lambda n:n.endswith('sb'),movie_people)
print(res)

 #使用filter()函数

movie_people=['alex_sb','zt_sb','zy','wu_sb']

res=list(filter(lambda n:not n.endswith('sb'),movie_people))
print(res)
#运行结果：['zy']

filter()函数后面是可迭代对象，进行for循环，每个元素进行前面的操作，满足操作输出，没有list输出内存地址。list()就是将其转换成列表输出。

  【3】reduce 函数

#计算列表元素之积
num_1=[1,2,3,100]

def reduce_test(func,array):
    res=1
    for num in array:
        res=func(res,num)
    return res

print(reduce_test(lambda x,y:x*y,num_1))
#运行结果：600

#reduce函数（将一个列表进行函数计算最终得一个结果）
from functools import reduce     #使用reduce函数python3中必须导入这个模块
num_1=[1,2,3,100]
print(reduce(lambda x,y:x+y,num_1,0))  
#reduce第一个参数是函数，第二个参数是被执行的列表，第三个参数是初始值
#运行结果：106

 8.内置函数

#python中常用的内置函数
【1】abs()   取绝对值
 print(abs(-1))
#结果：1

【2】all()  判断True False 只要有一个为False就为False  #0,空,None是False，其它为True
 print(all([1,2,'3']))
 print(all([1,2,'3','']))
#结果：True False

 【3】any() 有一个为真就是True
 print(any([0,'']))
 print(any([0,'',1]))
#结果：False True

 【4】bin() 十进制转换为二进制
 print(bin(3))
#结果：0b11

 【5】bool()   布尔值  #0,空,None是False，其它为True
 print(bool(''))
 print(bool(None))
 print(bool(0))
#结果：False False False

 【6】bytes()  字节编码
 name='你好'
 print(bytes(name,encoding='utf-8'))
#结果：b'xe4xbdxa0xe5xa5xbd'
 print(bytes(name,encoding='utf-8').decode('utf-8'))
#结果：你好
#用什么编码就用什么解码， decode()解码，次例是utf-8编码，所以是utf-8解码
#gbk,utf-8都可以解码，对于ascii码不能编码中文。
 
 【7】chr()  数字对应的ascii值
 print(chr(97))
#结果：a

 【8】dir() 打印方法里的属性
 print(dir(dict))
#结果：['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

 【9】divmod()  两数相除返回得数与余数
 print(divmod(10,3))
#结果：(3,1)

 【10】eval()  计算字符串中表达式的结果；
 express='1+2*(5*1)'
 print(eval(express)) 
#结果：11

 【11】hash() #可hash数据类型就是不可变数据类型；不可根据hash值来反推原值
 print(hash('1525'))    
#结果：6370411092133961450
#所有字符串或者值对于hash值是一样的，所以对于某个软件字符串hash是一样的，可用来判断软件是否被篡改。

 【12】help()  查看方法如何使用
print(help(all))

 【13】hex()  十进制转化为十六进制
 print(hex(12))
#结果：0xc

 【14】oct()  十进制转化为八进制
 print(oct(12))
#结果：0o14

 【15】isinstance()  判断数据类型，返回True False
 print(isinstance(1,int))
#结果：True

 【16】max()  min() 取最大最小

 【17】ord()  显示字符对应的数字
  print(ord(a))
#结果：97

 【18】pow()  次方
 print(pow(2,4))   #2**4
 print(pow(2,4,3))   #（2**4）%3
#结果：16 1

 【19】reversed()  反转
 li=[1,2,3,4]
 print(list(reversed(li)))
#结果：[4,3,2,1]

 【20】round()   四舍五入
 print(round(3.5))
#结果：4

 【21】slice()  切片操作
 li='hello'
 s1=slice(3,5)
 s2=slice(1,4,2)
 print(li[s1])
 print(li[s2])
#结果：lo el

 【22】sorted()  排序
 li=[5,1,8,3]
 print(sorted(li))
#结果：[1,3,5,8]
 li=[{'age':18},{'age':22},{'age':20}]
 print(sorted(li,key=lambda dic:dic['age']))
#结果：[{'age': 18}, {'age': 20}, {'age': 22}]

 【23】zip()  取key和values的组合值
  people={'蔡徐坤age':18,
                '农农age':19,
                '范丞丞age':20}
  print(sorted(zip(people.values(),people.keys())))
#结果：[(18, '蔡徐坤age'), (19, '农农age'), (20, '范丞丞age')]

 【24】str() 任意类型转化成字符串

 【25】sum()  求和

 【26】type() 判断数据类型

 9.zip方法

zip方法
print(list(zip(('a','b','c'),(1,2,3))))
#结果：[('a', 1), ('b', 2), ('c', 3)]  （类似拉链，左右对应）

p={'name':'alex','age':'18'}
print(list(zip(p.keys(),p.values())))
print(list(p.keys()))
print(list(p.values()))
#结果：[('age', '18'), ('name', 'alex')]
#     ['age', 'name']
#     ['18', 'alex']

10.max与min的高级用法

 #【只要是可迭代对象都可以用max与min，原理就是for循环】
li=[1,3,51,6]
print(max(li))
print(min(li))
#结果：51  1

age_dic={'age1':18,'age2':20,'age3':100}
print(max(age_dic.values()))
print(max(age_dic))      #默认是取key的值
#结果：100  age3    

li=[(5,'a'),(1,'b'),(3,'e'),(4,'d')]
print(list(max(li)))
#结果：[5, 'a']

li=['a10','b12','c10']      #不同类型之间不能进行比较['a10','b12','c10'，100]不行  
print(list(max(li)))
#结果：['c', '1', '0']

终极：
people=[{'name':'alex','age':100},
            {'name':'zy','age':18},
            {'name':'zt','age':12}]
print(max(people,key=lambda dic:dic['age']))
#结果：{'name': 'alex', 'age': 100}