14 函数

def 函数名(参数…):  
	...
	函数体
	...
	返回值

def f(a,b,c):
    print(a,b,c)

f(1,2,3)          #位置参数，顺序匹配。精确地传递和函数头部参数名一样多的参数
f(b=2,c=3,a=1)    #关键字参数，允许通过变量名进行匹配，而不是通过位置，所以位置可乱序\。精确地传递和函数头部参数名一样多的参数
f(1,c=3,b=2)      #位置参数+关键字参数：位置参数必须位于关键字参数之前

def f(a,b,c=5,d=6):     #默认参数：在所有的参数匹配之后，没有被匹配的参数将使用默认值。所以默认参数要在普通参数之后
    print(a,b,c,d)

f(1,2,3,4)      #1 2 3 4
f(1,2)          #1 2 5 6
f(1,d=4,b=2)    #1 2 5 4
f(b=2,a=1)      #1 2 5 6
f(c=3,b=2,a=1)  #1 2 3 6

def f(*args):   #在函数定义中使用，将收集不匹配的位置参数定义在一个元组中
    print(args)

f()         #()
f(1)        #(1,)
f(1,2,3,4)  #(1, 2, 3, 4)

def f(**kwargs):    #收集不匹配的关键字参数，将这些关键字参数传递给一个新的字典，例如本例的字典kwargs。在函数中可以对改字典进行调用
    print(kwargs)
    kwargs['a']=2   #对字典kwargs中的建'a'进行调用（赋值）

f()             #{}
f(a=1,b=2)      #{'a': 1, 'b': 2}

def f(a,*args,**kwargs):      #一般参数(普通参数+默认字参数) + *参数 + **参数。注意顺序
    print(a,args,kwargs)

f(1,2,3,4)          #1 (2, 3, 4) {}
f(1,2,3,b=4,c=5)    #1 (2, 3) {'b': 4, 'c': 5}
f(1,2,3,a=4,b=5,c=6)    #TypeError: f() got multiple values for argument 'a'。a=1之后又赋值a=4导致错误

def f(a,d=5,*args,**kwargs):     #在一般参数（包括普通参数和默认参数）匹配之后，将剩余的参数赋值给*args和**kwargs
    print(a,args,kwargs,d)

f(1)                #1 () {} 5
f(1,2,3,4)          #1 (3, 4) {} 2
f(1,2,3,b=4,c=5)    #1 (3,) {'b': 4, 'c': 5} 2

def f(a,b,c,d):
    print(a,b,c,d)

args=[1,2,3,4]
error_args=[1,2,3,4,5]
kwargs={'a':1,'b':2,'c':3,'d':4}
f(*args)        #1 2 3 4   ==>注意args元素个数要与函数的参数个数相同
f(**kwargs)     #1 2 3 4
f(*error_args)  #TypeError: f() takes 4 positional arguments but 5 were given
f(*(1,2),**{'c':3,'d':4})       #1 2 3 4
f(1,*(1,2),**{'d':4})           #1 1 2 4
f(1,*(2,3),d=4)                 #1 2 3 4
f(1,d=4,*(2,),**{'c':3})        #1 2 3 4
f(1,*(2,),d=4,**{'c':3})        #1 2 3 4 ==> 匹配顺序：位置参数>关键字参数>任意参数（*参数+**参数）

# 一个实用的例子：
def tracer(function, *pargs, **kargs):
    print('calling:', function.__name__)
    return function(*pargs, **kargs)

def func(a, b, c, d):
    return a + b + c + d

print(tracer(func, 1, 2, c=3, d=4))
# calling: func
# 10

def f(a,b,c,d):
    print a,b,c,d

f(2,3,4,a=1)  #TypeError: f() got multiple values for keyword argument 'a'
# 这个例子说明了，先将2，3，4分别赋值给了a，b，c；然后再将a=1赋值给了a，所以a参数赋了两个值。

def f(a, *b, **d, c=6):        #SyntaxError: invalid syntax
def f(a, *b, c=6, **d): 

def kwonly(a, *b, c):
def kwonly(a, *, b, c): 
def kwonly(a, *, b='spam', c='ham'):

def kwonly(a, *b, c):
    print(a, b, c)

kwonly(1, 2, c=3)   #1 (2,) 3
kwonly(a=1, c=3)    #1 () 3
kwonly(1, 2, 3)     #TypeError: kwonly() missing 1 required keyword-only argument: 'c'，c参数必须通过关键字方式赋值

def kwonly(a, *, b='spam', c='ham'):       #具有默认值的 Keyword-Only参数
    print(a, b, c)

kwonly(1)               #1 spam ham
kwonly(1,b=2)           #1 2 ham
kwonly(b=2,c=3,a=1)     #1 2 3
kwonly(1,2,3)  					#TypeError: kwonly() takes 1 positional argument but 3 were given

lambda arg1,… : 返回值表达式

函数名 = lambda arg1,… : 返回值表达式

sum2 = lambda a1,a2 : a1 + a2
a=sum2(5,6)
print(a)

abs()  #绝对值

all(iter，…)		#循环iter的元素，如果所有元素都为真，则返回True。如果iter为空，也返回True。如：all([11,22,33,44,0]) ；	all([])返回True
any(iter，…)		#循环参数，只要其中一个元素为真，则返回True。

ascii(obj)	#去对象obj的类中找__repr__方法，获取返回值。ascii()函数返回一个可打印的对象的字符串方式表示。当遇到非ASCII码时，就会输出\x，\u或\U等unicode码来表示。
repr(obj)		#执行对象的__repr__方法    【representation描述】

>>> ascii('123abc李聚章def&')
"'123abc\\u674e\\u805a\\u7ae0def&'"
>>> repr('123abc李聚章def&')
"'123abc李聚章def&'"

bin(integer)    #将10进制数字转换为2进制字符串		binary的缩写
oct(integer)		#将10进制数字转换为8进制字符串		octal的缩写，['ɒktl]
hex(integer)		#将10进制数字转换为16进制字符串	hexadecimal的缩写，[ˌheksəˈdesɪml]

>>> bin(3)
'0b11'
>>> oct(9)
'0o11'
>>> hex(17)
'0x11'

int('integer')		将10进制字符串或数字转换为10进制数字
int('xxx',base=x)	将x进制的数字字符串转换为10进制数字，默认base=10

>>> int('11',base=2)		#将二进制的"111"转换为10进制
3
>>> int('0o11',base=8) #将八进制的"111"转换为10进制(前缀0o可以省略)
9
>>> int('11',base=16)  #将十六进制的"111"转换为10进制
17

#字符串转换为字节
bytes(str, encoding=None)		#函数返回一个新的bytes对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。如果第一个参数为字符串str时，encoding参数也必须提供，函数将字符串使用str.encode方法转换成不可变的字节数组（字节是一种二进制的字符串，Python2中不区分bytes和str类型）
bytearray() 	#方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

#字节转字符串
str(bytes, encoding=None)	#将字节转换为encoding编码的字符串
str(obj)			#将对象转换为字符串（只有字符和字符串、文件才有编码？？对象没有）

>>> bytes('中国',encoding="utf-8")  #将utf-8编码的“中国”转为字节
b'\xe4\xb8\xad\xe5\x9b\xbd'
>>> str(b'\xe4\xb8\xad\xe5\x9b\xbd',encoding="utf-8")  #将字节转换为utf-8编码的字符串
'中国'

>>> bytearray(3)
bytearray(b'\x00\x00\x00')
>>> str([1,2,3])
'[1, 2, 3]'

#bytes()用法总结（bytearray()类似）：
#1、如果 source 为整数，则返回一个长度为 source 的初始化数组；
>>> bytes(3)		
b'\x00\x00\x00'
#2、如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
>>> bytes('中国',encoding="utf-8") 
b'\xe4\xb8\xad\xe5\x9b\xbd'
#3、如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
>>> bytes([1,2,3])	
b'\x01\x02\x03'
#4、如果没有输入任何参数，默认就是初始化数组为0个元素。
>>> bytes()		
b''

chr(int)		#将整数int转换为ASCII对应的字符character，如chr(65)对应A
ord(char)		#将单字符char转换为ASCII对应的整数，如ord('A')对应65 . ord是ordinal的缩写,序数

示例：利用随机数产生由大写字母和数字组合的4位验证码
import random
veri_code=''
for i in range(4):
    m=random.randint(0,4) # random.randint(0,4)产生0-4之间的随机整数，包括0和4。
    if m ==0 or m==3:
        rand_num = random.randint(0, 9)
        veri_code+=str(rand_num)
    else:
        rand_char = random.randint(65, 90)
        veri_code=veri_code+chr(rand_char)
print(veri_code)

bool()  				#判断真假，将一个对象转换成布尔值
callable(obj)		#判断对象obj是否可被调用，如果可以被调用，返回True。

delattr()  #等同于del object.attr
getattr()  #通过name字符串来，获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选，缺省时为None。
hasattr()  #判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。
setattr()  #给对象的属性赋值，若属性不存在，先创建再赋值。等同于object.name = value

dir()		#获取对象的属性
help()	#获取帮助

divmod(a,b)  					#得到a/b的商c和余数d组成的元祖(c,d)。一般用于分页操作。
enumerate(iterable)  	#对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。返回enumerate对象。

>>> list1 = ["这", "是", "一个", "测试"]
>>> for index, item in enumerate(list1):
...   print(index,item)
...
0 这
1 是
2 一个
3 测试

eval()	#执行字符串形式的表达式，有返回值。例如eval("3+4")
exec()	#将字符串作为python代码执行，无返回值。例如exec("for i in range(5):print(i)")

filter(func,iter)	#对元素进行过滤：将迭代对象的每个元素传递给函数，如果函数返回值为True，则filter返回iter的此元素。
map(func,iter)		#元素映射：将迭代对象的每个元素传递给函数，函数返回值作为map对象的元素。

globals()		#获取所有的全局变量（代码执行到当前位置的全部全局变量）
locals()		#获取所有的局部变量

hash()		#获取对象的hash值，经常用于将字典的key进行hash
id()			#内存地址
input(“tips:”)	#用户输入，返回对象类型为字符串

isinstance(obj,class)		#判断对象类型。如果obj为class实例化而来，返回Ture，否则返回False。例如：isinstance(“hello”，str)返回True。
issubclass(subcls,parcls)    #判断subcls是不是parcls的子类。返回值True/False

iter(obj)	#迭代器对象，使用next()获取下一个元素。iter([11,22,33])
next()

max()		#最大值。max([11,22,33,44])
min()		#最小值
sum()		#求和

open()	#打开文件
pow()		#求幂 pow(2,10)，2的10次方。     power的缩写
reversed()		#反转
round()	#四舍五入
slice()	#切片，基本不用
sorted()	#排序（重点）
#同一种类型排序，不同类不能一起进行排序。
#数字排序：按大小顺序
#字符串排序：按照字符顺序按位比较，先比较第一个字符，当第一个字符相同时，再比较第二个，直到分出大小。单个字符排序时：数字形式的字符（数字大小）<纯字母（ASCII顺序）<汉字。

zip()	#zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表（python3返回zip对象，可以使用list()转换为列表）。如果元素长度不一致会被砍到一样长。

>>>a = [1,2,3] 
>>> b = [4,5,6] 
>>> c = [4,5,6,7,8] 
>>> zipped = zip(a,b) # 打包为元组的列表 
[(1, 4), (2, 5), (3, 6)] 
>>> zip(a,c) # 元素个数与最短的列表一致 
[(1, 4), (2, 5), (3, 6)] 
>>> zip(*zipped) # 与 zip 相反，可理解为解压，返回二维矩阵式 
[(1, 2, 3), (4, 5, 6)]

__import__		#导入模块，并可以对导入的模块做别名。


imp = __import__(random)
imp.randint(0,5)
类似：
import random
random.randint(0,5)