二.python面对对象 ------4函数参数和局部变量
函数
1.函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
高度复用 低频率耦合的代码段
一.定义函数
1.定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。
不带表达式的return相当于返回 None。
2、函数特征：
代码重复利用
可扩展性
保持一致性
def 函数名（参数列表）:
函数体
return XXX
可以返回多个值，返回的多个值组成一个元组，返回值加上一对中括号，则返回一个列表
函数分为定义和调用
=====================================================
练习：定义一个函数，实现两个数字的加、减、乘、除
def yuansuan(numA,numB,fu):
if '+'.__eq__(fu):
return numA+numB
elif '-'.__eq__(fu):
return numA+numB
elif '*'.__eq__(fu):
return numA+numB
elif '/'.__eq__(fu):
return numA+numB
jg=yuansuan(6,6,'+')
print(jg)
def getrange(num):
# for i in range(num):
return 1,2,3,4
rang=getrange(5)
print(type(rang))
print(rang)
二.可更改(mutable)与不可更改(immutable)对象 有参函数和无参函数：
# 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，
而 list,dict 等则是可以修改的对象。
# 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个
int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
# 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将
list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
1。不可变类型：
值传递(复制副本)，如 整数、字符串、元组。如fun（a），
传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，
只是修改另一个复制的对象，不会影响 a 本身。
2.可变类型：
引用传递，值传递传递的数据类型是 可变类型
用值传递传递方式（复制内存地址的副本）去传递 可变类型-可改变内容
不可改变原地址
如 列表，字典。如 fun（la），则是将 la 真正的传过去，
修改后fun外部的la的内容也会受影响
不可变 #可变
def fun(num): #def fun(num):
num=num+6 # num[0]=num[0]+6
a=6 # a=[6]
fun(a) #fun(a)
print(a) # print(a)
=======================================================
三.以下是调用函数时可使用的正式参数类型：
函数下第一个''' 文档内容 doc 函数名.__doc__
在Python中定义函数，可以用必选参数、默认参数、
可变参数、关键字参数和命名关键字参数，
这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。
但是请注意，参数定义的顺序必须是：必选参数、
默认参数、可变参数/命名关键字参数和关键字参数。
1. 必选参数
def show(name,age):
print('姓名:{0}周岁{1}虚岁{2}'.format(name,age,age+1))
show(16,'张三')
形参和实参一一对应(个数，数据类型，顺序)
2.形参:定义方法时的参数
3.实参：调用方法时的参数
4.默认参数:(缺省参数)缺省参数必须写在后面,可以不指定参数名，
但是顺序要保证，否则要指定参数名
5.命名关键字参数
def showDef(age,name='张三',sex='男'):
print('姓名:{0}周岁{1}虚岁{2}性别{3}'.format(name,age,age+1,sex))
showDef(20,name='李四',sex='女')
关键字参数：关键字参数允许你传入0个或任意个含参数名的参数，
些关键字参数在函数内部自动组装为一个dict
例：# 关键字参数:**kw
def show(name,age,**key):
print('type(key):',type(key))
print('name:{} age:{} other:{}'.format(name,age,key))
dictl={'sex':'女','zhong':80}
show('李四',20,**dictl)
show('李四',20,sex='女',zhong=80)
6. 不定长参数(可变参数): 可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
def cala(*nums):
print(type(nums))
sum = 0
for n in nums:
sum += n
return sum
ns=(2,3,4,5)
print(cala(*ns))
但是调用的时候，需要先组装出一个list或tuple：
print(cala(*ns)) #自动解析 通用性
print(cala(2,3,4,5,)) #自动解析 通用性
9. 组合参数:
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
t=(1,2,3,4,5)
f2(*t,d=4)
f1(*t)
10. 传参数：*args 会逐个分割args 逐个对应形参列表
**kw 只能对应到形参列表的 **kw
如下：
kw={'a':1,'b':2,'d':3}
'h1':1,'h2':2,'h3':3 传参数的原则 name=value
name=value 如果 **kw 实参前没有赋相应的实参
a=1,b=2,d=3
f2(**kw)
小结：
Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和 **kw 关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
=========================================
局部变量
一 。变量作用域： 全局变量和局部变量
全局变量与局部变量的作用域不同 位置起关键作用
生命周期不同
1.全局变量:
g_a=10
def testl():
a=20
global g_a g_a #告诉程序这里是一个全局变量
g_a=(g_a+a)
print(a)
testl()
print(g_a)
2.匿名函数：
python 使用 lambda 来创建匿名函数
语法：lambda [arg1 [,arg2,.....argn]]:expression
语法：lambda [参数列表]:函数体内部代码
lam=lambda:print('this is a lambda')
lam()
he= lambda x,y:x+y
print(he(6,5))
调用sum函数
def YouFun(x,y,fun):
print(fun(x,y))
def myfun(x,y):
return x+y
YouFun(10,20,lambda x,y:x+y)
案例：
对于简单的函数，也存在一种简便的表示方式，即：lambda表达式
wu=lambda x:[print(i) for i in range(x)]
wu(9)
三个重要的大数据用到的函数：
1.python map()
map()函数接收两个参数，一个是函数，一个是序列，map将序列的每个元素传入函数中执行，
并把结果作为新的list返回。
举例说明，比如我们有一个函数f(x)=x%2，
要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现
new_list=list(map(lambda x:x+1,range(9)))
print(type(new_list))
print(new_list)
2. python filter():
对于序列中的元素进行筛选，最终获取符合条件的序列
li = [11, 22, 33]
new_list = filter(lambda arg: arg > 22, li)
课上练习1:
要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，
要编写一个判断奇数的函数：
list2=[1,4,6,7,9,12,17]
filter1=list(filter(lambda x:x%2==0,list2))
print(type(filter1))
print(filter1)
利用filter()，可以完成很多有用的功能.
例如:删除 None 或者空字符串：
strs=[None,'','','df','不睡觉','不打盹']
def isNone(s):
return s or len(s.strip())>0
strs1=list(filter(lambda s:s and len(s.strip())))
print(strs1)
课练习2.：
请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
import math,functools as f # as 起别名
print(math.sqrt(9)%1==0)
nums=list(filter(lambda x:math.sqrt(x)%1==0,range(1,100)))
print(nums)
结果：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
在Python 3里，reduce()函数已经被从全局名字空间里移除了，
它现在被放置在fucntools模块里
3.求和
python reduce():对于序列内所有元素进行累计操作
li = [11, 22, 33]
result = reduce(lambda arg1, arg2: arg1 + arg2, li)
python中的reduce内建函数是一个二元操作函数，
他用来将一个数据集合（链表，元组等）中的所有数据进行下列操作：
用传给reduce中的函数 func()（必须是一个二元操作函数）
先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，
最后得到一个结果。
如：
li=[11,22,33,44,55]
reduce=f.reduce(lambda x,y:x+y,li)
print(type(reduce))
print(reduce)
reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，
一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，
reduce()对list的每个元素反复调用函数f，并返回最终结果值。
4 .python中自定义排序函数: 复制数据 不改变元组数据
Python内置的 sorted()函数可对list进行排序：
new_list= list(map(lambda x:x+1,range(9)))
print(type(new_list))
print(new_list)
# python filter():对于序列中的元素进行筛选，最终获取符合条件的序列
list2=[1,4,6,7,9,12,17]
filter1=list(filter(lambda x:x%2==0,list2))
print(type(filter))
print(filter
=======================================================
二 .sort()排序方法
shus.sort()对原有列表进行排序，改变原来列表的顺序，无返回值
print(shus)就是改变后的列表
sorted()排序函数
排序时不影响原数据，产生新的排序数据
print(sorted(shus))排序后的结果
print(shus)还是原结果
练习：
对字符串排序时，有时候忽略大小写排序更符合习惯。
请利用sorted()高阶函数，实现忽略大小写排序的算法。
输入：['bob', 'about', 'Zoo', 'Credit']
>>> a = ['bob', 'about', 'Zoo', 'Credit']
>>> print(sorted(a, key=str.lower))
结果：
['about', 'bob', 'Credit', 'Zoo']