python之路-Day4

本节内容

1. 函数基本语法及特性

2. 参数与局部变量

3. 返回值

嵌套函数

4.递归

5.匿名函数

6.函数式编程介绍

7.高阶函数

8.内置函数

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

def  函数名（）：         括号是用来传参的,灵活应用
函数名（）     #调用

形参:变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参:可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

def sayhi(name,age,nationality='CN'):        -----name、age是形参   ，有的默认参数都放在非默认参数（位置参数）的右边
    print('i am %s,' %name,age,nationality)   -----如果不调用，就安默认打印，
sayhi('haha',22)           ------haha、22是实参
sayhi('haha',22,US)        ------如果传参的话就打印传入的内容
sayhi(name = '',22)      ------指定参数传参，也的放在位置参数后面     关键参数,如果给其中一个写定，并且不按顺序写，其他的都的写定。

关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。

?

1	stu_register(age=22,name='alex',course="python",)

　　

非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数。

def sayhi(name,age,nationality='CN',*args):   *args以元组的形式存在，如果写单个元素就是元组。

def sayhi(name,age,nationality='CN',**kwargs)   **kwargs以字典的形式存在，如果写name = 'lwq',就写入字典中。

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

login_status = False    #全局变量         虽然与局部变量名字相同，但是在内存中的地址不一样
def auth(username,password):
    #get date from db
    _username = 'alex'
    _password = 'alex3714'
    if username == _username and password == _password:
        print('ok')
        #global login_status    #改全局变量，要用global，并且将原来的全局变量写上
        login_status = True   #局部变量，只在函数中生效
        print('--->',login_status)
def home():
    if login_status ==True:
        print('welcome')
    else:
        auth()
def pay():
    if login_status == True:
        print('welcome')
    else:
        auth()

username = input('username:').strip()
password = input('password:').strip()
auth()

返回值：

1.一旦你的函数经过调用并开始执行，那你的函数外部的程序就没有办法再控制函数的执行的过程了，此时外部程序只能等待函数的执行结果，因为外部程序要根据外部函数的执行结果来决定下一步如何走，
执行结果就是以return的形式返回给外部程序。
2.return代表着一个函数的结束。
3.return可以返回python中的任何数据类型，一次能返回多个值，以元组的形式返回。
4.对于用户角度，函数可以返回任意数量的值，但对于py本身来讲，函数只能返回一个。

def auth():
    username = input('username:').strip()
    password = input('password:').strip()
    #get date from db
    _username = 'alex'
    _password = 'alex3714'
    if username == _username and password == _password:
        print('ok')

        return True
    else:
        return False
def home():
    if login_status ==True:
        print('welcome')
    else:
        auth()
def pay():
    if login_status == True:
        print('welcome')
    else:
        auth()

login_status = auth()
home()
pay()

嵌套函数

name = 'alex'

def changeName():
    name = 'jack'
    print(name)

    def changeName2():
        name = 'rain'
        print('name2', name)

    changeName2()

changeName()

递归函数
特性：
1.必须有一个明确的结束条件
2.每进入更深一层递归时，问题规模相比上次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过stack这种数据结构实现的）
每当进入一个函数，栈就会加一层栈帧，每当函数减少一层，栈帧就减少一层。

递归函数的典型事例：二分查找

#data = [3,5,10,1,12,14,17,11,19,20,19]
#date = [1,3,5,10,11,12,14,17,19,19,20]
date = range(0,10000,3)    #range 出来就是列表
def binary_search(datasets,find_num):
    if len(datasets) > 0:
        middle_pos = int(len(datasets)/2)
        if date[middle_pos] == find_num:
            print('Find num:',datasets[middle_pos])
        elif date[middle_pos] > find_num:
            print('go to left side',datasets[0:middle_pos],datasets[middle_pos])
            binary_search(datasets[0:middle_pos],find_num)
        else:
            print('go to righ side',datasets[middle_pos+1:],datasets[middle_pos])
            binary_search(datasets[middle_pos+1:],find_num)
    else:
        print('cannot not find num')
binary_search(date,15)

匿名函数：

匿名函数就是不需要显式的指定函数

正常定义函数：

def calc(n):
    return n*n
print(cacl)

def calc(n,j):
    return n*j

print(cacl)

匿名函数：

calc2 = lambda x:x*x
print(cacl2)

calc2 = lambda x,y:x*x
calc(8)

与map函数搭配使用
data = map(lambda n:n*2 if n>5 else n,range(10))
data = map(lambda n:n*2 if n>5 else calc(n),range(10))

def cal(n):
    return -n
data = map(lambda n:n**n if n>5 else cal(n),range(10))
for i in data:
    print(i)

三元运算

a =4
b= 5
c = if a >10 else b
上面的匿名函数与map搭配使用中就用到了三元运算。

函数式编程介绍　　

 

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

一、定义

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：

　　(1 + 2) * 3 - 4

传统的过程式编程，可能这样写：

　　var a = 1 + 2;

　　var b = a * 3;

　　var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

　　var result = subtract(multiply(add(1,2), 3), 4);

这段代码再演进以下，可以变成这样

add(1,2).multiply(3).subtract(4)

这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：

merge([1,2],[3,4]).sort().search("2")

因此，函数式编程的代码更容易理解。

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

abs求绝对值
def add(x,y,f):
    return f(x) + f(y)
def calc(n):
    return n+1
res = add(3,-6,cacl)
print(res)

编程范式：
1.面向过程
2.面向对象
3.函数式编程

内置函数
python自带

a = [1,2,3]
all(a)
#判断是否为真
any()   #列表任意一个为真就返回真
ascii() #显示成ascii表的东西
bin()   #将数字转成二进制
print(bin(10))
bool #判断是否为true
bytes  #0-255之间的数字，ascii表
bytearray  #改bytes值
callable()  #判断对象是否可以被调用
chr()  #把数字转换成二进制
print(chr(97))    #打印ascii表的对应关系
print(ord('b'))   #将字符对应成ascii表中的数字

f = open('递归.py',encoding='utf-8')
code = compile(f.readline(),'','exec')
print(code)
exec(code)    #执行这段代码，这段代码是字符串
eval()         #数字运算
complex         #复数
complex(4,5)
print(dir(f))    #dir返回文件的方法
divmod()         #地板除,放回商和余数
divmod(10,2)
filter    #过滤
for i in filter(lambda x:x>5,range(10)):
    print(i)
format()  #字符串格式化
frozenset({1,4,5,5,6})    #把集合变成只读
print(a)
#就没有add方法

globals()
print(globals())   #把当前程序所在内存中所有的数据都以字典的形式打印出来
locals()    #只打印局部

hex()   #十六进制
print(hex(8))

max()    #返回列表汇总最大值
print(max())
min()   #返回最小值
oct()   #八进制0o8
print(pow(4,9))    #4**9

#分隔符
msg = "又回到最初的起点"
f = open("tofile","w")
print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)

data = [1,2,3,5,8]
data = reversed(data)     #反转（字符串、列表）
for i in data:
    print(i)

round()  #五舍六入
print(round(10.25,1))

data = [10,2,4]
print(set(data))    #将列表变成集合
#切片　　
a = range(20)
pattern = slice(3,8,1)
for i in a[pattern]:
    print(i)

a= 'alex'
a= sorted(a)   #按ascii码排序
print(a)        以列表的形式打印,字符窜、集合、列表(并且其中只能由一种数据类型)

data = [10,2,3,45,56,3]
print(sum(data))    #相加  列表、集合、元组都可相加。
print(vars())   #打印当前程序在内存中的所有数据

zip  # 类似拉链效应，如果对应不上，就按少的来
a = [1,3,5,7]
b = [2,4,6,8]
for i in zip(a,b):
    print(i)