Python 函数和内置函数

函数

- 代码的一种组织形式
- 一个函数一般完成一项特定的功能

函数使用

- 函数需要先定义
- 使用函数，俗称调用

定义一个函数

- 只是定义的话不会执行
- def 函数名()
- 函数名自己定义，起名需要遵循命名规则，约定俗成，大驼峰只给类用
- 后面括号和冒号不能省，括号内可以有参数
- 函数内所有代码缩进
def func()
	print("hello python!")

函数的调用

- 定义函数时有参数，调用时也要有参数，定义时没有参数，调用时也没有，收集参数，默认参数除外
- 函数名后面跟括号 
func()

函数的参数和返回值

参数

- 负责给函数传递一些必要的数据或者信息
- 参数分类：普通参数，默认参数，关键字参数，收集参数
	- 普通参数：定义的时候直接定义变量名，调用的时候直接把变量或者值放入指定位置
		def 函数名(参数1,参数2......)
			函数体
		#调用
		函数名(value1,value2......)
	
		#调用的时候，具体值参考的是位置，按位置赋值
		- 形参（形式参数）：在函数定义的时候用到的参数，没有具体值，只是一个占位符号，称为形参（参数1，参数2......）形参定义
		- 实参（实际参数）：在调用的时候输入的值（value1,value2......）实参调用
		def hello(person):
			print("(0)，你好".format(person))
		p = "girl"
		hello(p)  #girl,你好
		- 参数person只是一个符号，代表的是调用时候的某个数据
		- 调用的时候，会用p代替函数中所有的person
	- 默认参数
		- 形参具有默认值
		- 调用的时候如果没有对应的形参赋值，则使用默认值
			def func_name(p1=v1,p2=v2......)
				func_block
			#调用1
			func_name()
			#调用2
			value1 = 100
			value2 = 200
			func_name(value1,value2)
		示例：
		#报名函数，需要知道学生性别
		#学习Python的学生基本都是男生，所以，报名的时候如果没有特别指定，我们认为是男生
		def reg(name,age,gender="male"):
			if gender == "male":
				print("{0} is {1},he is a good student".format(name,age))
			else:
				print("{0} is {1},she is a good student".format(name,age))
		
		reg("xiaoming",21)
		reg("xiaohong",19,"female")  #xiaoming is 21,he is a good student
														xiaohong is 19,she is a good student
	- 关键字参数
		语法：
		def func(p1=v1,p2=v2......)
			func_body
		- 比较麻烦，但有好处：
			- 不容易混淆，一般实参和形参只是按照位置一一对应即可，容易出错
			- 使用关键字参数，可以不考虑参数位置
			def stu_key(name,age,addr):
				print("{} is {},住在{}".format(name,age,addr))
			n = "xiaoming"
			a = 16
			addr = "china"
			stu_key(age=a,name=n,addr=addr)
			#xiaoming is 16,住在china
	- 收集参数
		- 把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构中
		- 语法：
		def func(*args):
			func_body  #可以按照list使用方式访问args得到传入的参数
		#调用
		func(p1,p2......)
	- 参数名args不是必须这么写，但是推荐用args，约定俗成
	- 参数名args前需要星号，表示收集参数
	- 收集参数可以和其他函数并存
	- 示例：
	
	“”“”“”
	函数模拟一个学生进行自我介绍，但具体内容不清楚
	把args看做tuple
	“”“”“”
	def stu(*args):
		print("hello")
		for item in args:
			print(item)
	stu("xiaoming", 22, "heilongjiang")
	stu("xiaohong")
	stu()  #收集参数可以不带任何实参调用，此时收集参数为空tuple
	  #hello
	  	xiaoming
	  	22
	  	heilongjiang
	  	hello
	  	xiaohong
	  	hello
	  	
- 如果使用关键字参数格式调用，会出问题
- 收集参数之关键字收集参数
	- 把关键字参数按字典格式存入收集参数
	- 语法：
	def func(**kwargs):
		func_body
	#调用
	func(p1=v1,p2=v2......)
	- 约定俗成用kwargs
	- 调用的时候，把多余的关键字参数放入kwargs
	- 访问kwargs需要按照字典格式访问
	#案例1：
	def stu(**kwargs):
		print("hello")
		for k,v in kwargs.items():
    		print(k,"---",v)
	stu(name="xiaoming", age=22, addr="heilongjiang")
	stu()
	 #hello
	  	name---xiaoming
	  	age---22
	  	addr---heilongjiang
	  	hello
	 #案例2
	 def func(*args,**kwargs) :
	 	print(args)
	 	print(kwargs)
	 func(1,2,3,a=4,b=5,c=6)	
	 func(*(1,2,3),**{"a":4,"b":5,"c":6})
	 #(1, 2, 3)
		{'a': 4, 'b': 5, 'c': 6}
		(1, 2, 3)
		{'a': 4, 'b': 5, 'c': 6}

返回值

- 函数和过程的区别：有无返回值
- 函数的执行结果
- 使用return关键字，如果没有return，默认返回一个none
- 函数执行后返回值
- 函数一旦执行return语句，则无条件返回，即结束函数的执行
- 推荐写法：不论有没有返回值，都以return结束
案例1：	
def hello(person):
	print("(0)，你好".format(person))
	return "end"
	print("hello")
p = "girl"
rst = hello(p)
print(rst)  #girl,你好
				  end
案例2：
def func1():
	print("func1")
a = func1()
print(a)
print("*"*10)
def func2():
	print("func2")
	return "ok"
b = func2()
print(b)  #func1
				None
			  **********
				func2
				ok		

Python内置函数

Python简单内置函数

- 内置对象查看：dir
- 常见函数：len(求长度),min(求最小值),max(求最大值),sorted(排序),reversed(反向),sum)(求和)
- 进制转换函数：bin(转换为二进制),oct(转换为八进制),hex(转换为十六进制),ord(字符转ASCII码),chr(ASCII码转字符)

dir

- dir():查看当前模块的属性列表
- dir([ ])查看列表的方法，也可以查看字典等基本类型。	
a = "sdfgfd"

常见函数

- 作用于字符串，列表等
a = sdfgfd
- len(a)  #6
- sorted(a)  #['d', 'd', 'f', 'f', 'g', 's']
- reversed(a)  #<reversed at 0x7f254db0f080>
- list(reversed(a))  #['d', 'f', 'g', 'f', 'd', 's']

Python高级内置函数

- enumerate,exec,map,eval,filter,zip

enumerate

- 根据可迭代对象创建枚举对象
seasons = ["spring","summer","fall","winter"]
list(enumerate(seasons)) 
#[(0,spring),(1,summer),(2,fall),(3,winter)]
list(enumerate(seasons,start=1))  #指定起始值
#[(1,spring),(2,summer),(3,fall),(4,winter)]

eval

- 取出字符串中的内容
- 将字符串str当成有效的表达式来求值并返回结果
- 计算指定表达式的值
x = 10
def func():
	y = 20  #局部变量y
	a = eval("x+y")
	print("a:",a)  #x没有就调用全局变量
	b = eval("x+y",{"x":1,"y":2}) #定义局部变量，优先调用
	print("b:",b)
	c = eval("x+y",{"x":1,"y":2},{"y":3,"z":4})
	print("c:",c)
	d = eval("print(x,y)")
	print("d:",d)  #对于变量d，因为print()函数不是一个计算表达式，因此没有返回值
func()
#a:30
  b:3
  c:4
  10 20
  d:None	

exec

-exec可以执行复杂的Python代码，而不像eval函数那样只能计算一个表达式的值，返回值永远为none
x = 10
def func():
	y = 20  
	a = exec("x+y")
	print("a:",a)  
	b = exec("x+y",{"x":1,"y":2})  
	print("b:",b)
	c = exec("x+y",{"x":1,"y":2},{"y":3,"z":4})
	print("c:",c)
	d = exec("print(x,y)")
	print("d:",d)  
func()
#a:None	
  b:None	
  c:None	
  10 20	#为exec("print(x,y)")的结果
  d:None	
示例2：
i = 2
j = 3
exec("ans=i+j")
print("answer is:",ans)  #answer is 5	

map

map会接收一个函数f和一个list，并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回，会根据提供的函数对指定序列做映射
def square(x):
	return x ** 2 
list(map(square,[1,2,3,4,5]))   #计算列表各个元素的平方
#[1,4,9,16,25]
list(map(lambda x,y:x+y,[1,3,5,7]))  #使用lambda匿名函数
#[1,9,25,49]
lambda表达式，通常是在需要一个函数，但是不想去命名一个函数的场合下使用的
add = lambda x,y:x+y
lambda 参数： 表达式

filter

filter函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代对象，如果要转换成列表，可以用list来转换
list(filter(lambda x:x%2==0,range(1,10)))   #[2, 4, 6, 8]

zip

zip函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元素组成的对象，好处是节约内存，可以用list转换输出列表
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
list(zip(a,b))  #[(1,4),(2,5),(3,6)]  #把返回的对象转换成列表
list(zip(a,c))  #[(1,4),(2,5),(3,6)]  #元素个数与最短的一致
zip(*)正好相反用于解压
案例：
a = [1,2,3]
def stu(*args):
	print(args)
	for i in args:
    	print(i)
stu(*a)
#(1, 2, 3)
  1
  2
  3

函数文档

- 函数的文档的作用是对当前函数提供使用相关的参考信息

文档的写法

- 在函数内部开始的第一行使用三引号字符串定义符
- 一般具有特定格式

文档查看

- 使用help函数，形如help(func)
- 使用__doc__
def stu(age,name,*args):
	"""
	hello
	everyone
	"""
	print("这是文档")
help(stu)
print(stu.__doc__)
#  stu(age, name, *args)
    hello
    everyone
    hello
    everyone