python中的函数

1.什么是函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。
2.定义一个函数
1.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4.函数内容以冒号起始，并且缩进。
5.return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

3.实例：
def hello():
print('hello')
print('python')

通过函数名来调用函数

hello()

4.#函数里面嵌套函数
def westos():
print('is westos')
def python():
print('is python')
python()
westos()

5.参数
参数分为形参和实参
定义函数的时候的变量，叫形参(形参可以任意起名)
def welcome(a):
print('hello',a)

调用函数的时候，真实的数据信息，调用函数的时候传递的参数叫实参
welcome('tom')
welcome('lily')

形参：位置参数 默认参数 可变参数 关键字参数
1.位置参数 （位置参数:形参和实参必须保持一致）
def getInfo(name,age):# 按照位置传参数
print(name,age)
getInfo('westos',11)
getInfo(11,'westos')
getInfo(age=11,name='westos')

2.默认参数

def mypow(x,y=2): 定义函数，其中第二个形参的默认值为2
print(x**y)
mypow(2,3) 当调用函数的时候，传入两个实参，则使用传入的值进行运算
mypow(4) 当只传入一个值的时候，另一个使用默认参数值进行运算

3.可变参数
当参数的个数不确定的时候，可以使用可变参数，来表示该函数可以接收任意个参数
在使用可变参数的时候：
其中a 表示对参数进行解包，将序列中的元素一个一个的拿出来。
a的对象类型是一个元组。
def mysum(a): # 定义函数的形参数是任意个
print(a)
print(a)
sum = 0
for item in a:
sum += item
print(sum)
nums = [1,2,3,4]
nums1 = (1,2,3,4)
nums2 = {1,2,3,4}
mysum(nums)
mysum(nums1)
mysum(nums2)
#当实参是一个列表的时候，返回值
1 2 3 4 # 解包列表的得到的数据
(1, 2, 3, 4) # a的对象类型为一个元组
10 # 最后的返回值

#当实参是一个元组的时候，返回值
1 2 3 4 # 解包元组的得到的数据
(1, 2, 3, 4) # a的对象类型为一个元组
10 # 最后的返回值

#当实参是一个集合的时候，返回值
1 2 3 4 # 解包集合的得到的数据
(1, 2, 3, 4) # a的对象类型为一个元组
10 # 最后的返回值

4 关键字参数
*k:是一个字典，可以传递任意多的key-value
def getStuInfo(name,age,*k):
print(name)
print(age)
print(k)
#如果要对字典进行解包，一个星号，获取所有的key值
#print(d)
getStuInfo('westos',11,a=1,b=2)

6.参数的返回值

返回值：函数运算的结果，还需要进一步操作，给函数一个返回值
return用来返回函数执行的结果，如果函数没有返回值，默认返回None
一旦遇到return 函数执行结束，后面的代码不会执行
多个返回值的时候，python会帮我们封装成一个元组类型

def getStuInfo(name,age):
print(name)
print(age)
a = getStuInfo('toto',16)
print(a)

#显示结果：
toto
16
None # 函数没有返回值，函数执行的结果默认返回None

def getStuInfo(name,age):
print(name)
if name == 'toto' :
return 'name is toto' # 函数的返回值
print(age)
a = getStuInfo('toto',16)
print(a)

#输出结果：
toto
name is toto # 存在返回值，并且成功返回该返回值，之后的代码将不会再执行

6 、变量的作用域
个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量
局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量：在函数内部定义的变量，只在函数内部起作用，函数
执行结束后，变量会自动删除

a = 1 这是一个全局变量
print('outside:',id(a))

def fun():
global a #声明a为全局变量
a = 5
print('inside:',id(a))
fun()
print(a)
print(id(a))

结果
outside: 9462560 外面定义的a的ID为 9462560
inside: 9462688 在函数内定义a为全局变量 a的指向5他的ID发生改变
5
9462688

案例1.
编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所有数.

def cacluate(*x):
sum = 0
for i in x :
sum += i
average = sum/len(x)
li = []
for k in x :
if k > average :
li.append(k)
return (average,li)

#调用函数，测试效果
a = cacluate(2,6,8,9,2,5,7)
print(a)

案例2.
编写一个函数, 接收字符串参数, 返回一个元组,‘ehllo WROLD’
元组的第一个值为大写字母的个数, 第二个值为小写字母个数.

编写一个名为collatz()的函数,它有一个名为number的参数。
如果参数是偶数,那么collatz()就打印出number//2,并返回
该值。如果number是奇数,collatz()就打印并返回3*number+1。
然后编写一个程序,让用户输入一个整数,并不断对这个数
调用collatz(),直到函数返回值1(令人惊奇的是,这个序列
对于任何整数都有效,利用这个序列,你迟早会得到1!既使数学
家也不能确定为什么。你的程序在研究所谓的“Collatz序列”,
它有时候被称为“最简单的、不可能的数学问题”)。

• 输入:
  3
• 输出:
  10
  5
  16
  8
  4
  2
  1

def collatz(number):
if number == 1:
exit()
elif number % 2 == 0:
return number // 2
else:
return 3 * number + 1

num = int(input('Num:'))
while True:
num = collatz(num)
print(num)