函数
函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
优点:
- 代码重用
- 保持一致性
- 可拓展性
函数的定义主要有如下要点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：完成函数的具体功能
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。
创建一个函数：
def hello():#函数名 pass #函数体 return ('Hello !') #返回值 hello()#调用函数
返回值
要想获取函数的执行结果，就可以用return语句把结果返回
注意:
- 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
- 如果未在函数中指定return,那这个函数的返回值为None
参数：写在def语句中函数名后面的变量通常就做函数的形参，而调用函数的时候提供的值是实参
我们在定义函数的时候根据需求的不同会用到各种类型的参数，有关键字参数、位置参数、默认参数、可变参数等。
def test(x,y,z): print(x) print(y) print(z) test(1,2,3)#位置参数 test(x=2,y=3,z=4)#关键字参数 test(5,6,z=8)#位置参数与关键字参数混用，但关键字参数必须放在位置参数后面 #默认参数 def test1(x,y,z=8): print(x+y+z) test1(5,7) test1(5,8,9) #可变参数 # *args 会把多传入的参数变成一个元组形式, #*将一组可变数量的位置参数集合成参数值的元组 def test2(*args): print(args)#集合成元组的形式 print(args[0]) print(*args)# 去掉元组形式 test2([1,2,3,5],'man','woman') test2(*('boy',1,4,)) # **kwargs 会把多传入的n多个关键字参数变成一个dict形式 #**可以将关键字参数收集到一个字典当中 def test3(**kwargs): print( kwargs)#集合成字典的形式 print( *kwargs)#all the keys print( kwargs['age']) test3(name='Mike',age='22',sex='male') test3(**{'name':'Jack','age':30,'sex':'male'}) def test4(args1,args2): return args1 ,args2 #return以元组的形式返回 res=test4(2,5) print(res)
全局与局部变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
num=66 #全局变量 def func(): num=88 #局部变量 这个变量的作用域就是该函数 print(num) func() >>>88 #除了字符串、数字外，其他像列表、字典、集合、类等这些复杂的数据类型都可以在局部里修改全局变量 name='Li' name_list=['Mike','Jack','Mar'] def change_name(): name="chen" name_list[0]='二师兄' change_name() print(name) print(name_list) >>>Li >>>['二师兄', 'Jack', 'Mar']
嵌套函数
Python的函数是可以嵌套的，也就是说可以将一个函数放在另一个里面。
def func(): def hello(): print("hello!") hello() func()
递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身，这个函数就是递归函数
#阶乘 def factorial(n): n=int(n) if n == 1: return 1
else: return n * factorial(n-1) print(factorial(3))
递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）（递归的最高调用层数为999层）
匿名函数（lambda表达式）
power=lambda x:x*x print(power(2)) #是不是感觉用lambda也方便不了多少？不过匿名函数主要是和其它函数搭配使用的呢，如下： result = map(lambda x:x**2,[1,5,7,4,8]) for i in result: print(i)
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
def add(a,b ,f): return f(a)+f(b) add(2,3,int)
内置函数 戳：https://docs.python.org/2/library/functions.html
sorted()对一个集合进行排序 ：
#!/usr/bin/env/ python # -*-coding:utf-8 -*- a={ 1:'chen',10:'alex',5:'li' } print(sorted(a))#把key排序后输出 print(sorted(a.items()))#按key排序 print(sorted(a.items(),key=lambda x:x[1]))#按value排序 [1, 5, 10] [(1, 'chen'), (5, 'li'), (10, 'alex')] [(10, 'alex'), (1, 'chen'), (5, 'li')]
zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。
a=[1,2,3,4,5,6] b=['a','b','c','d','e'] print(zip(a,b)) for i in zip(a,b): print(i) for i in zip(*zip(a,b)): print(i) (1, 'a') (2, 'b') (3, 'c') (4, 'd') (5, 'e') (1, 2, 3, 4, 5) ('a', 'b', 'c', 'd', 'e')
eval()函数十分强大,官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。so，结合math当成一个计算器很好用。
其他用法，可以把list,tuple,dict和string相互转化。见下例子：
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]" b = eval(a) print(b) print(type(b)) a = "{1: 'a', 2: 'b'}" b = eval(a) print(b) print(type(b)) a = "([1,2], [3,4], [5,6], [7,8], (9,0))" b = eval(a) print(b) print(type(b)) [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]] <class 'list'> {1: 'a', 2: 'b'} <class 'dict'> ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0)) <class 'tuple'> # 不可谓不强大！ # ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。 # 想一想这种使用环境：需要用户输入一个表达式，并求值。 # 如果用户恶意输入，例如： # __import__('os').system('dir') # 那么eval()之后，你会发现，当前目录文件都会展现在用户前面。 # 那么继续输入： # open('文件名').read() # 代码都给人看了。获取完毕，一条删除命令，文件消失。哭吧！ # 怎么避免安全问题？ # １、自行写检查函数； # ２、使用ast.literal_eval： 自行查看DOCUMENT #3、eval带来的潜在风险http://python.jobbole.com/82770/
数学相关
- abs(a) : 求取绝对值。abs(-1)
- max(list) : 求取list最大值。max([1,2,3])
- min(list) : 求取list最小值。min([1,2,3])
- sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
- sorted(list) : 排序，返回排序后的list。
- len(list) : list长度,len([1,2,3])
- divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
- pow(a,b) : 获取乘方数。pow(2,3) >>> 8
- round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
- range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]
逻辑判断
all: 遍历一个迭代器，如果都为空，或者每个迭代元素都会true，则返回ture
any：与all函数作用相反，如果任何迭代的一个元素为ture，或者为空，则返回false
类型转换
- int(str) : 转换为int型。int('1') >>> 1
- float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
- str(int) : 转换为字符型。str(1) >>> '1'
- bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
- bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'xe7x88xacxe8x99xab'
- list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
- iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
- dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
- enumerate(iterable) : 返回一个枚举对象。
- tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
- set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
- hex(int) : 转换为16进制。hex(1024) >>> '0x400'
- oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
- bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
- chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
- ord(str) : 转换ASCI字符为相应的数字。 ord('A') >>> 65
相关操作
- eval() : 执行一个表达式，或字符串作为运算。 eval('1+1') >>> 2
- exec() : 支持python代码的动态执行 。 exec('print("Python")') >>> Python
- filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
- map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
- zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
- type()：返回一个对象的类型。
- id()： 返回一个对象的唯一标识值。
- hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
- help()：调用系统内置的帮助系统。
- isinstance()：判断一个对象是否为该类的一个实例。
- issubclass()：判断一个类是否为另一个类的子类。
- globals() : 返回当前全局变量的字典。
- next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
- reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']