Python学习（函数）

一、函数

对程序而言，函数就是对程序逻辑进行结构化或者过程化的一种编程方法

built-in functio（BIF）内置函数

1.1 函数的定义

声明函数的一般形式：

def function_name(arg1,arg2,...,argn):
    '''statements'''
    func_statements
    return Value

1.2 函数文档说明

说明如下：
1.函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()。

2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

3.函数的第一行语句可以选择性地使用文档字符串----用于存放函数说明。

4.函数内容以冒号起始，并且缩进。

5.return [表达式] 结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回 None。

其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。
对于return后没有返回值的和没有return语句的函数都会返回None值
有些函数可能既不需要传递参数,也没有返回值。
没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。

1.3 函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

1.4 函数参数

• 不传参函数
• 传参函数
  • 顺序：位置参数，默认参数，*args，**kwargs

1.5 函数返回值

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None

1.6函数参数种类

形参和实参

• 形参

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

• 实参

  实参是一个确定的值，能够传递给形参，作为位置参数或者关键词参数传递

def usr_manage(name, age, job, hobby):
    print("用户管理系统".center(16, "-"))
    print("\tName:\t", name)
    print("\tAge:\t", age)
    print("\tJob:\t", job)
    print("\tHobby:\t", hobby)
    print("用户管理系统".center(16, "-"))

usr_manage("Tom",20,"IT","Coding")
usr_manage("Jim",21,"Student","Reading")

默认值参数

def usr_manage(name, age, job, hobby="Trip"):
    print("用户管理系统".center(16, "-"))
    print("\tName:\t", name)
    print("\tAge:\t", age)
    print("\tJob:\t", job)
    print("\tHobby:\t", hobby)
    print("用户管理系统".center(16, "-"))

usr_manage("Jack",20,"IT")

只传递实参，位置一一对应

使用位置参数时和函数头对应的形参在顺序，个数以及类型上匹配

关键字参数

def usr_manage(name, age, job="IT", hobby="Trip"):
    print("用户管理系统".center(16, "-"))
    print("\tName:\t", name)
    print("\tAge:\t", age)
    print("\tJob:\t", job)
    print("\tHobby:\t", hobby)
    print("用户管理系统".center(16, "-"))

usr_manage("Jack",20,"IT",hobby="Coding")

默认值参数，关键词参数，必须放置在位置参数之后

不定参数

在Python中不定参数主要是指*args 和 **kwargs两个变量

主要用于函数定义，可以将不定数量的参数传递给一个函数

• *args 用来接收任意非键值对的任意数量的参数列表给函数
• *kwargs用来接收任意不定长度的键值对列表给函数

def uncertain_para(para,*args):
    print("普通位置参数：",para)
    print("不定参数：",args)
    print(type(args))
uncertain_para(1,2,3,4,5,"a","b")
'''
普通位置参数： 1
不定参数： (2, 3, 4, 5, 'a', 'b')
<class 'tuple'>
'''

def un_para_key(**kwargs):
    print(kwargs)
    print(type(kwargs))
un_para_key(a=1,b=2,c=3)
'''
{'a': 1, 'b': 2, 'c': 3}
<class 'dict'>
'''

def un_para_key(x,y,*z,**kwargs):
    print(x,y,z)
    print(kwargs)
un_para_key(1,2,3,4,5,'a','b',a=1,b=2,c=3)
'''
1 2 (3, 4, 5, 'a', 'b')
{'a': 1, 'b': 2, 'c': 3}
'''

1.7 函数属性

函数属性是Python中另外一个使用了句点属性标识并拥有名字空间的领域

def foo():
    'foo() --- Properly created doc string.'

def bar():
    pass

bar.__doc__ = "Oops,forget thr doc str above"
bar.version = 0.1

#foo.py
def x():
    return 'foo'

#bar.py
def x():
    return 'bar'

import foo,bar
print(foo.x()+bar.x())      #foobar

可以获得每个 pyhon 模块，类，和函数中任意的名字空间。你可以在模块 foo 和 bar 里都有名为 x 的一个变量,，但是在将这两个模块导入你的程序后，仍然可以使用这两个变量。所以，即使在两个模块中使用了相同的变量名字，这也是安全的，因为句点属性标识对于两个模块意味了不同的命名空间，比如说，在这段代码中没有名字冲突

1.8 内嵌函数

def foo():
    def bar():
        print("bar() called.")
    print("foo() called.")
    bar()

foo()

作用域

bar()整个函数都处于外部foo()函数的作用域里（foo()是我们可以从外部访问的一个对象区域）。除了在foo()内部，其他地方无法对bar()进行调用

1.9 变量作用域

作用域的产生

就作用域而言，python和C用很大差别，只有当变量在module，Class，函数中定义的时候

def foo():
    a = "foo"
    print(a)
foo()
print(a)        #NameError: name 'a' is not defined

在作用域中定义的变量，一般只在作用域中有效。需要注意的是，在if-elif-else，for-else，while-else，try-except（else-finally）等关键词的语句块中不会产生作用域

作用域的类型

python中，使用一个变量时并不要求预先声明，但在真正使用的时候，他必须绑定到某个内存对象（被定义，赋值）。这种变量名的绑定将在当前作用域引入新的变量，同时，屏蔽外层作用域中的同名变量

• 局部作用域（local—L)
  • 局部变量：包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个 栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。
  • 注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。
• 嵌套作用域（enclosing—E）
  • E 也包含在del 关键词中，E和L是相对的，E相当于跟上层的函数而言也是L。与L的区别在与，对于一个函数而言，L是定义在此函数的内部的局部作用域
  • 主要为了实现Python的闭包，而增加的实现
• 全局作用域（globe—G）
  • 即在模块层次中定义的变量。模块顶层声明的变量具有全局作用域。从外部来看，模块的全局变量就是一个模块对象的属性
• 内置作用域（built-in—B）
  • 系统固定模块中定义的变量

搜素变量名的优先级：局部>嵌套>全局>内置

1.10 全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

gbl_str = "foo"
def foo():
    loc_str = "bar"
    return gbl_str+loc_str

print(foo())        #foobar
print(gbl_str)      #foo
print(loc_str)      #NameError: name 'loc_str' is not defined

a = 6688
def foo():
    print("foo(),修改前a：",a)		#UnboundLocalError: local variable 'a' referenced before assignment
    a = 888
    print("foo(),修改后a：",a)

#global
a=6688
def foo():
    a= 666
    def inner_foo():
        global a
        print(a)        #6688
        a= 888
        print(a)        #888
    inner_foo()
    print(a)            #666

foo()

#nonlocal
a=6688
def foo():
    a= 666
    def inner_foo():
        nonlocal a
        print(a)        #666
        a= 888
        print(a)        #888
    inner_foo()
    print(a)            #888

foo()

1.11 可变类型和不可变类型

a = 1
def foo():
    a += 1
    print(a)        #UnboundLocalError: local variable 'a' referenced before assignment

foo()

li = []
def foo():
    li.append('c')
    print(li)        #['c']

foo()

二、常见的函数

2.1 随机函数

导入这个模块

import random

random模块的常见功能

1.random.random()

• 用来生成一个0~1的随机浮点数[0,1)

a = random.random()
print(a)

2.random.uniform(a,b)

• 用来生成指定范围内的浮点数[a,b]

a = random.uniform(6,10)
print(a)

3.random.randint(a,b)

• 用来生成指定范围内的整数[a,b]

a = random.randint(6,10)
print(a)

4.random.randrange([start],stop,[step])

• 从指定范围内，按指定基数递增或递减的集合中，随机获取一个整数

a = random.randrange(1,10,3) #从1,4,7中随机取
print(a)

5.random.choice(sequence)

• 从序列中随机获取一个元素，sequence可以为列表、字符串或者元组

a = random.choice(range(1,10,3))
print(a)

6.random.shuffle(x,[random])

• 用来将一个列表的元素打乱，即将列表的元素随机排列

list1 = ['C','C++','JAVA','VB']
random.shuffle(list1)
print(list1)

7.random.sample(sequence,k)

• 用来从指定序列中随机获取指定长度的片段并随机排列。但不会修改原来序列

list1 = ['C','C++','JAVA','VB']
print(random.sample(list1,2))

2.2 递归函数

在一个函数体的内部，调用函数本身，就被称为递归函数

#斐波那契数列
def fib1(n):
    if n == 1:
        return 1
    if n == 2:
        return 1
    else:
        return fib1(n - 1) + fib1(n - 2)

print(fib1(5))

2.3 匿名函数（lambda）

格式：

lambda para1,para2,...,paran:expression using paras

如：

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

2.4 高阶函数

把一个函数名以实参的形式传递给这个函数的形参，这个函数就称为高阶函数

def add(a, b, func):
    return func(a) + func(b)

a_value = add(-9,1,abs)
print(a_value)

2.5 filter函数

功能：

过滤掉序列中不符合函数条件的元素。当序列中需要保留的元素可以用某些函数描述时，就应该想到调用filter函数

调用格式：

filter(function,sequence)

function：可以是自定义的函数，也可以是匿名函数

sequence：列表、元组、字符串

如：

li = ['Zhengjiang', 'University', 'City', 'College']
f1 = filter(lambda sr: not sr.endswith('ty'),li)
print(list(f1))

2.6 map映射函数

功能：

求一个序列或者多个序列进行函数映射后的值（用list()强转）

格式：

map(function,iterable1,iterable2)

function的参数可以不止一个

iterable1，iterable2就是传入function的参数

如：

li = [1, 2, 3, 4, 5]
res = map(lambda x: x + 1, li)
print(list(res))        #[2, 3, 4, 5, 6]

x = [1, 2, 3, 4, 5]
y = [2, 3, 4, 5, 6]
res = map(lambda x, y: x * y + 2, x, y)
print(list(res))        #[4, 8, 14, 22, 32]

2.7 reduce函数

功能：

对一个序列进行压缩运算，得到一个value。

from functools import reduce
reduce(function,iterable,[initia])

function：必须要传入两个参数

iterable：列表、元组

在python2中，reduce( )是内置函数

在python3中，被移植到了functools模块中，使用from functools import reduce调用

from functools import reduce

y = [2, 3, 4, 5, 6]
z = reduce(lambda x, y: x + y, y)
print(z)

z = reduce(lambda x, y: x + y, y, 100)
print(z)

2.8 apply函数

功能：

pandas中，应用对象是pandas中的DataFrame或者Series。直接对DataFrame或者Series应用函数，对pandas中groupby之后的聚合对象应用apply

import numpy as np
import pandas as pd

a = np.random.randint(low=0, high=4, size=(2, 4))
print(a)
'''
[[0 2 3 0]
 [3 0 1 3]]
 '''
data = pd.DataFrame(a)
print(data)
'''
   0  1  2  3
0  0  2  3  0
1  3  0  1  3
'''
data.apply(lambda x:x*10)
print(data)
'''
   0  1  2  3
0  0  2  3  0
1  3  0  1  3
'''

2.9 zip函数

功能：

将一个可迭代对象作为参数，将对象中对应的元素打包成一个个元组，返回由这些元组构成的对象。长度不一样的时候，以长度短的为准

注：

利用 * 号操作符，与zip相反，进行解压

格式：

zip(iterable1,iterable2,...)

iterable：两个或者多个可迭代对象（字符串，列表，元组，字典）

py2，由元组组成的列表

py3:，返回的是一个对象，如果要得到一个列表要强转

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

ziptest1 = zip(a, b, c)
print(list(ziptest1))   #[(1, 4, 4), (2, 5, 5), (3, 6, 6)]

三、练习

求1-15的和；求23-36的和；求55-68的和

def sum_Of_num(num1,num2):
    result = 0
    for i in range(num1,num2+1):
        result += i
    return result

print(sum_Of_num(1,15))		#120
print(sum_Of_num(23,36))	#413
print(sum_Of_num(55,68))	#861

求不定个数的数的平均值

def avg(*args):
    sum = 0
    for i in args:
        sum += i
    return sum/len(args)

print(avg(1,2,3,4,5))
print(avg(1,10,100,1000,10000))

写一个函数，计算传入字符中的数字，字母，空格以及其他字符的个数

def count(p):
    digit = 0
    alpha = 0
    space = 0
    others = 0
    for i in p:
        if i.isdigit():
            digit += 1
        elif i.isalpha():
            alpha += 1
        elif i.isspace():
            space += 1
        else:
            others += 1
    return (digit,alpha,space,others)

print(count('ahaodh===o 019209 a'))