python函数—未完待续

python函数的定义与调用

1. python定义函数使用def关键字，格式如下：

def 函数名（参数列表）：
	函数体
	return 返回值

eg:

def myFirstFunc():	#定义函数
    print("Hello!")
myFirstFunc()	#调用函数

2. 函数的参数
   可以有0,1或多个
   eg:

#定义接收2个参数的函数
def add2num(a,b):
	c=a+b
	print(c)
#调用带有参数的函数
add2num(11,22)

调用函数时，如果没有传递参数，则会使用默认参数
eg:

def printinfo(name,age = 35):	#定义age的默认值为35，**必须放在必选参数之后**，称为可选参数
	print("Name:",name)
	print("Age:",age)
printinfo(name="miki")	#没有给age传递参数，，故age为默认值35
printinfo(age=9,name="miki")	#顺序可以与定义时的不同，但必须写明“age= , name= ”（可以按照位置传递也可以按照名称传递）

有时可能需要一个函数处理比当初声明时更多的参数，这些参数叫做不定长参数
eg:

def test(a,b,*args):
    print(a)
    print(b)
    print(args)

test(1,2)	#将args默认为元组

运行结果：
1
2
()

def test(a,b,*args):
    print(a)
    print(b)
    print(args)

test(1,2,3,4,5,6)

运行结果：
1
2
(3, 4, 5, 6)

#求10的阶乘再乘以任何数
def fact(n,*b):
    s = 1
    for i in range(1, n+1):
        s = s * i
    for item in b:
        s *= item
    return s

print(fact(10,1,3,5))

3. 函数的返回值是使用return语句来完成，返回函数运算的结果，返回值类型与结果类型一致，遇到return函数即结束 执行
   eg:

def calculateNum(num):
    result = 0
    i = 1
    while i <= num:
        result = result + i
        i+=1
    return result	#如果没有return这一行该程序运行结果为None
result = calculateNum(100)
print("1~100的累积和为:",result)

运行结果：
5050

对比return位置不同时对结果的影响
①

def count_letter(string,char):
    count = 0
    for c in string:
        if c == char:
            count += 1
            return count

c_count = count_letter("abead","a")
print(c_count)

运行结果：
1

②

def count_letter(string,char):
    count = 0
    for c in string:
        if c == char:
            count += 1
    return count

c_count = count_letter("abead","a")
print(c_count)

运行结果：
2

③

def count_letter(string,char):
    count = 0
    for c in string:
        if c == char:
            count += 1
            return count 
    else:
        print("over")

c_count = count_letter("abc","d")
print(c_count)

运行结果：
over
None

④

def count_letter(string,char):
    count = 0
    for c in string:
        if c == char:
            count += 1
        return count
    else:
        print("over")

c_count = count_letter("aacabc","a")
print(c_count)

运行结果：
2

⑤

def count_letter(string,char):
    count = 0
    for c in string:
        if c == char:
            count += 1
        else:
            return count
    else:
        print("over")

c_count = count_letter("aacabc","a")
print(c_count)

运行结果：
2

4. 函数的嵌套调用
   eg:

def testB():
    print("---testB start---")
    print("这里是testB函数执行的代码")
    print("---testB end ---")
def testA():
    print("---testA start---")
    testB()
    print("---testA end ---")
testA()

运行结果：
---testA start---
---testB start---
这里是testB函数执行的代码
---testB end ---
---testA end ---

5. 作用域和命名空间
   eg1:

a = 4	#全局变量
def test1():
    print("test1:",a)
test1()
print("main:",a)

运行结果：
test1: 4
main: 4

eg2:

a = 4
def test1():
    a = 5	#局部变量，只在函数内起作用，函数执行完毕，内部变量将被释放，若全局变量与局部变量重名，则在函数内访问的是       局部变量
    print("test1:",a)
test1()
print("main:",a)

运行结果：
test1: 5
main: 4

在外部引用局部变量会报错

eg3:

a = 4
def test1():
    global a	#将a定义成全局变量，此时函数内部的改变会影响函数外部变量的值
    a = 5
    print("test1:",a)
test1()
print("main:",a)

运行结果：
test1: 5
main: 5

eg4:

a = 3
def text(x):
    print(x)
    x = 5
    print(x)

text(a)	#只传递了a的值，a本身不会被修改
print(a)

运行结果：
3
5
3

eg5：迭代类型可以看作C语言中的指针（例如数组、集合、字典、元组，或称为组合数据类型，且没有在函数内部创建时），这时全局变量的内容会被修改。

a = [3,4,5]
def text(x):
    print("text1:",x)
    x.append(6) #数组加元素用append
    print("text2:",x)

text(a)
print("main:",a)

运行结果：
text1: [3, 4, 5]
text2: [3, 4, 5, 6]
main: [3, 4, 5, 6]

a = {3,4,5}
def text(x):
    print("text1:",x)
    x.add(6) #集合加元素用add
    print("text2:",x)

text(a)
print("main:",a)

运行结果：
text1: {3, 4, 5}
text2: {3, 4, 5, 6}
main: {3, 4, 5, 6}

6. 函数的递归调用
   eg:使用递归，实现阶乘$n!=1\ast 2\ast 3......\ast n$的计算。

def fact(n):
    if n==1:
        return 1
    return n*fact(n-1)

print(fact(5))

7. 匿名函数lambda，能够接受任何数量的变量，但只能返回一个表达式的值。
   <函数名> = lambda <参数列表>:<表达式>
   eg:

print(fact(5))

sum = lambda a,b:a+b	
print(sum(10,20))

运行结果：
30

8. 随机函数（产生伪随机数）

• random.random()生成一个0到1的随机浮点数。
  eg:

import random	#引入random库
print("random():",random.random())

• random.uniforn(a,b)返回a,b之间的随机浮点数，a不一定要比b小。
• random.randint(a,b)返回a,b之间的整数，a,b必须是整数，且a一定要比b小。
• random.randrang(a,b,c)返回a,b区间内以c为步长的整数。
• random.choice(s) s须是一个列表、元组、字符串等，从该序列中随机获取一个元素。
  eg:

import random
x = random.choice([1,3,5,7,9])
print(x)

• random.shuffle(s)，用于将列表中的元素打乱顺序，或称洗牌

import random
x = [1,3,5,7,9]
random.shuffle(x)
print(x)

运行结果：
[5, 9, 3, 1, 7]

• random.sample(s,k)，用于从指定序列中随机获取K个元素作为一个片段返回。sample函数不会修改原有序列
  eg:

import random
x = [1,3,5,7,9]
y = random.sample(x,3)
print("y=",y)
print("x=",x)

运行结果：
y= [9, 5, 7]
x= [1, 3, 5, 7, 9]