一.基本概念:
1.定义:逻辑结构化和过程化的一种编程方法;一个程序由多个任务构成,一个函数就代表一个任务/功能
2.函数是代码复用的通用机制
3.函数就是1个类型为function的变量:
python中函数定义方法：
def test(x):
'''The function definitions'''
x+=1/y=x+1
return x/y
def:定义函数的关键字
test：函数
（）：内可定义形参（自变量），数量可以为任意个
"":文档描述，函数功能（非必要，但强烈建议为你的函数添加描述信息）
x+=1：泛指代码块或程序处理逻辑（函数）
return：定义返回值
print(test)会返回函数的内存地址
调用运行函数:test(x1)（定义时有几个参数就写几个）
4.利用函数名是变量这一点取代多分枝
def foo():
print('foo')
def bar():
print('bar')
dic={'foo':foo,'bar':bar,}
while True:
choice=input('>>: ').strip()
if choice in dic:
dic[choice]()
5.发生一个return,函数整体就结束(无法返回多个值)
def calc(x,y): #x,y为形参
res=x**y
return x
print(res) #报错
6.函数可嵌套
7.分类:
1.内置函数:可直接使用
2.:通过import导入库,然后使用其中定义的函数
3.第三方库函数:下载安装第三方库,通过import导入,然后使用其中定义的函数
4.用户自定义函数:用户根据需求自定义
二.函数和过程
1.过程:过程就是简单特殊没有返回值的函数
def test01():
msg='hello The little green frog'
print(msg)
def test02():
msg='hello'
print(msg)
return msg
t1=test01()
t2=test02()
print('from test01 return is [%s]' %t1) #结果为from test01 return is [None]
print('from test02 return is [%s]' %t2) #结果为from test02 return is [hello]
2.返回none:当一个函数/过程没有使用return显示的定义返回值时,python解释器会隐式的返回None,所以在python中即便是过程也可以算作函数
def test01():
pass
def test02():
return 0
def test03():
return 0,10,'hello',['alex','lb'],{'WuDaLang':'lb'}
t1=test01()
t2=test02()
t3=test03()
print('from test01 return is [%s]: ' %type(t1),t1)
#结果为from test01 return is [<class 'NoneType'>]: None
print('from test02 return is [%s]: ' %type(t2),t2)
#结果为[<class 'int'>]: 0
print('from test03 return is [%s]: ' %type(t3),t3)
#结果为[<class 'tuple'>]: (0, 10, 'hello', ['alex', 'lb'], {'WuDaLang': 'lb'})
返回值数=0:返回None
返回值数=1:返回object
返回值数>1:返回tuple
三.函数参数
1.形参就是形式上的参数，可以理解为数学的X，没有实际的值，通过别人赋值后才有意义。相当于变量。形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
2.实参就是实际意义上的参数，是一个实际存在的参数，可以是字符串、数字等。实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值、输入等办法使参数获得确定值
def calc(x,y): #x,y为形参
res=x**y
return res
c=calc(a,b) #a,b为实参
print(c)
3.位置参数和关键字
标准调用：实参与形参位置一一对应
def calc(x,y):
res=x**y
return res
c=calc(1,2)
print(c)
关键字调用：位置无需固定
def calc(x,y):
res=x**y
return res
c=calc(y=2,x=1)
print(c)
位置参数必须在关键字参数左边
4.默认参数：定义时赋值的参数（调用时可再次赋值覆盖原值）
- 注意：每次调用使用默认参数都是内存中的同1个对象
>>> def func(arg,li=[]):
... li.append(arg)
... return li
...
>>> l1=func(1)
>>> l2=func(2,[])
>>> l3=func(3)
>>> l4=func(4)
>>> print(l1,l2,l3,l4)
[1, 3, 4] [2] [1, 3, 4] [1, 3, 4]
#因为每次调用函数,使用的默认参数都是同1个列表(即定义在func()中的li);只有第2次使用的是传入的列表
5.参数组:可变长度的参数
**表示字典(一般用kwargs)，*表示列表/元组(一般用args)
def test(x,*args):
print(x)
print(args)
print(args[2])
test(1,2,3,4,5,6) #运行结果为1 (2,3,4,5,6) 4
def test(x,*args):
print(x)
print(args)
test=(1,["x","y"]) #运行结果为1 (["x","y"])
def test(x,*args):
print(x)
print(args)
test=(1,星号["x","y"]) #运行结果为1 ("x","y")
def test(x,**kwargs):
print(x)
print(kwargs)
test=(1,y=2,z=3) #运行结果为1 {"y":2,"z":3}
*args必须在[星号][星号]kwargs左边（否则位置参数会出现在关键字参数右边）
*args只接受位置参数/列表
**kwargs只接受关键字参数/字典
四.名称空间与作用域
1.名称空间:存放名字的地方(x=1,1存放于内存中,那变量名x存放在哪里呢?名称空间正是存放变量名x与1的绑定关系的地方)
2.名称空间的加载顺序:
python test.py
#1.python解释器先启动，因而首先加载的是：内置名称空间
#2.执行test.py文件，然后以文件为基础，加载全局名称空间
#3.在执行文件的过程中如果调用函数，则临时产生局部名称空间
3.名字查找顺序:局部名称空间–>全局名称空间–>内置名称空间
LEGB代表查找顺序:locals -> enclosing function -> globals -> __builtins__
locals是函数内的名字空间,包括局部变量和形参
enclosing:外部嵌套函数的名字空间(闭包中常见)
globals:全局变量,函数定义所在模块的名字空间
builtins:内置模块的名字空间
#注意:
1.在全局无法查看局部的,但在局部可以查看全局的:
max=1
def f1():
max=2
def f2():
max=3
print(max)
f2()
f1()#结果:3
print(max)#结果:1
def f3():
max=2
def f4():
print(max)
f4()
f3()#结果:2
2.作用域在函数执行之前(具体来说,是编译时)就已经被创建:
#也就是说:函数的作用域不取决于函数在哪里执行,而取决于函数在哪里被定义
v=123
def foo():
v=456
def inner():
print(v)
return inner
result=foo()
result()#结果:456
五.局部变量与全局变量
1.作用域:作用域即范围
–全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
–局部范围（局部名称空间属于该范围）：临时存活，局部有效
2.局部变量：在子程序中定义的变量称为局部变量，作用域是定义该变量的子程序
3.全局变量：在程序的一开始定义的变量称为全局变量，作用域是整个程序
4.当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用
name='lhf' #全局变量
def change_name():
print('我的名字',name) #结果为：我的名字 lhf
def change_name():
name='帅了一笔' #局部变量
print('我的名字',name) #结果为：我的名字 帅了一笔
change_name()
print(name) #结果为：lhf
def change_name():
global name
name='帅了一笔' #全局变量
print('我的名字',name) #结果为：我的名字 帅了一笔
change_name()
print(name) #结果为：帅了一笔
5.查看作用域:globals()/locals()
6.global
无global不可对全局变量重新赋值，但对（全局变量）可变对象可以对内部元素进行操作。优先读取局部变量
有global可给全局变量（最外层）赋值，之后使用/定义的为全局变量（一个指针，引用全局中真实的值，子程序中只有一个地址）
有nonlocal可给上一层变量赋值，之后使用/定义的为上一级变量
规范：全局变量大写，局部变量小写
name="a"
def wh():
name="b"
def wwh():
global name
name="c"
wwh()
print(name)
print(name)
wh()
print(name) #结果为a b c
作用域在定义函数时就已经固定，不随调用位置的改变而改变：
#coding=gbk
name = "Alex"
def change_name():
name = "Alex2"
def change_name2():
name = "Alex3"
print("第3层打印",name)
change_name2() #调用内层函数
print("第2层打印",name)
def foo():
name='lhf'
def bar():
print(name)
return bar
func=foo()
func() #结果为lhf
name='alex'
def foo():
name='lhf'
def bar():
name='wupeiqi'
def tt():
print(name)
return tt
return bar
func=foo()
func()() #结果为wupeiqi
六.前向引用之’函数即变量’：所有函数必须在调用之前定义
def action():
print('in the action')
logger()
action() #报错NameError: global name 'logger' is not defined
def logger():
print('in the logger')
def action():
print('in the action')
logger()
action() #不报错，结果为in the logger in th action
def action():
print('in the action')
logger()
def logger():
print('in the logger')
action() #不报错，结果为in the logger in th action
def action():
print('in the action')
logger()
action()
def logger():
print('in the logger') #报错NameError: global name 'logger' is not defined
七.递归调用
1.递归函数：如果一个函数在内部直接或间接调用自身本身，这个函数就是递归函数
def calc(n):
print(n)
calc(n) #calc(n)即为一个递归函数
def calc(n):
print(n)
if int(n/2) ==0:
return n
return calc(int(n/2))
calc(10)
print(calc(10)) #结果为10 5 2 1 10 5 2 1 1
import time
person_list=['alex','wupeiqi','yuanhao','linhaifeng']
def ask_way(person_list):
print('-'*60)
if len(person_list) == 0:
return '没人知道'
person=person_list.pop(0)
if person == 'linhaifeng':
return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person
print('hi 美男[%s],敢问路在何方' %person)
print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))
time.sleep(3)
res=ask_way(person_list)
# print('%s问的结果是: %res' %(person,res))
return res
res=ask_way(person_list)
print(res)
2.特性：
必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，当进入一个函数调用，栈会加一层栈帧；当函数返回，栈会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多会导致栈溢出）
堆栈扫盲:cnblogs.com/lln7777/archive/2012/03/14/2396164.html
尾递归优化:http://egon09.blog.51cto.com/9161406/1842475
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
def binary_search(dataset,find_num):
print(dataset)
if len(dataset) >1:
mid = int(len(dataset)/2)
if dataset[mid] == find_num: #find it
print("找到数字",dataset[mid])
elif dataset[mid] > find_num :# 找的数在mid左面
print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
return binary_search(dataset[0:mid], find_num)
else:# 找的数在mid右面
print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
return binary_search(dataset[mid+1:],find_num)
else:
if dataset[0] == find_num: #find it
print("找到数字啦",dataset[0])
else:
print("没的分了,要找的数字[%s]不在列表里" % find_num)
binary_search(data,66)
八.匿名函数(lambda)
1.定义：
lambda 形参:返回值
lambda x:x+1 = def calc(x):
return x+1
func=lambda x:x+1
func(10)(调用)
print(func(10))
f=lambda x,y,z:(x+1,y+1,z+1) #必须加()
2.注意：
如果不赋给一个函数名(一般不做)，使用过一次后立即从内存中释放
无法有if之类的复杂逻辑，只能一行结束；":"后一定是return的结果
匿名函数主要是和其它函数搭配使用
l=[3,2,100,999,213,1111,31121,333]
print(max(l))
dic={'k1':10,'k2':100,'k3':30}
print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
print(i) #结果为1 25 49 16 64
九.函数式编程：
1.把程序的执行当做一串首尾相连的函数，一个函数输出的结果输入给另外一个函数，不断进行（一种编程风格）
2.函数式=编程语言定义的函数+数学意义的函数
函数式就是用编程语言去实现数学函数
特点：参数/返回值是函数（第一类对象）；无for/while循环，所有循环由递归实现；无变量的赋值（即不用变量去保持状态）（不可变数据，函数内无赋值操作），无赋值即不改变；尾调用优化(尾递归)
3.尾调用：在函数的最后一步(不一定是最后一行)调用另外一个函数
return f 表示调用函数；return f() 表示调用函数并返回f()的return值
def bar(n):
return n
def foo(x):
return bar(x)+1 #bar在foo内不为尾调用
def bar1(n) :
return n
def bar2(n):
return n+1
def foo(x):
if type(x) is str:
return bar1(x)
elif type(x) is int:
return bar2(x) #bar1,bar2在foo内均为尾调用
def bar(n):
return n
def foo(x):
y=bar(x)
return y #bar在foo内不为尾调用
尾调用优化：尾调用是函数的最后一步操作，无需保留外层函数调用记录，因调用位置、内部变量等信息不会再使用，只要直接用内层函数调用记录取代外层函数调用记录即可
4.高阶函数
满足两个特性之一：
函数的传入参数是一个函数名
函数的返回值是一个函数名
5.map函数：对每个元素进行指定运算
array=[1,3,4,71,2]
ret=[]
for i in array:
ret.append(i**2)
print(ret)
#如果我们有一万个列表,那么你只能把上面的逻辑定义成函数
def map_test(array):
ret=[]
for i in array:
ret.append(i**2)
return ret
print(map_test(array))
#如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么可以这样
def add_num(x):
return x+1
def map_test(func,array):
ret=[]
for i in array:
ret.append(func(i))
return ret
print(map_test(add_num,array))
#可以使用匿名函数
print(map_test(lambda x:x-1,array))
#上面就是map函数的功能,map得到的结果是可迭代对象（显示其内存地址）（迭代器，只等迭代一次）
print(map(lambda x:x-1,range(5)))
6.reduce函数：把序列按指定方式进行合并操作
from functools import reduce
#合并,得一个合并的结果
array_test=[1,2,3,4,5,6,7]
array=range(100)
#报错,res没有指定初始值
def reduce_test(func,array):
l=list(array)
for i in l:
res=func(res,i)
return res
#print(reduce_test(lambda x,y,array))
#可以从列表左边弹出第一个值
def reduce_test(func,array):
l=list(array)
res=l.pop(0)
for i in l:
res=func(res,i)
return res
print(reduce_test(lambda x,y:x+y,array))
#我们应该支持用户自己传入初始值
def reduce_test(func,array,init=None):
l=list(array)
if init is None:
res=l.pop(0)
else:
res=init
for i in l:
res=func(res,i)
return res
print(reduce_test(lambda x,y:x+y,array))
print(reduce_test(lambda x,y:x+y,array,50))
reduce在python3的内建函数被移除了，放入了functools模块
7.filter函数：遍历序列中每个元素，判断每个元素得到的布尔值，如果是True就留下
#电影院聚集了一群看电影bb的傻逼,让我们找出他们
movie_people=['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao']
def tell_sb(x):
return x.startswith('sb')
def filter_test(func,array):
ret=[]
for i in array:
if func(i):
ret.append(i)
return ret
print(filter_test(tell_sb,movie_people))
#函数filter,返回可迭代对象
print(filter(lambda x:x.startswith('sb'),movie_people))
#当然了,map,filter,reduce,可以处理所有数据类型
name_dic=[
{'name':'alex','age':1000},
{'name':'wupeiqi','age':10000},
{'name':'yuanhao','age':9000},
{'name':'linhaifeng','age':18},
]
#利用filter过滤掉千年王八,万年龟,还有一个九千岁
def func(x):
age_list=[1000,10000,9000]
return x['age'] not in age_list
res=filter(func,name_dic)
for i in res:
print(i)
res=filter(lambda x:x['age'] == 18,name_dic)
for i in res:
print(i)
#reduce用来计算1到100的和
from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))
#用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao']
res=map(lambda x:x+'_sb',name)
for i in res:
print(i)
十.内置函数：https://www.runoob.com/python/python-built-in-functions.html
1.abs(num):取绝对值
2.all(str/list/tuple/dict/set):判断给定的可迭代参数 iterable 中的所有元素是否都为 True(空元组/列表/集合返回值为True;str/dict总为True)
3.any(str/list/tuple/dict/set):每个元素进行布尔运算，是否有True(空~为False;dict/str只要不为空，均为True)
4.ascii(str/list/tuple/dict/set/num):返回一个表示对象的str,
- 类似 repr() 函数,但是对非ASCII字符则返回通过repr()函数使用\x,\u,\U编码的字符
- 生成字符串类似 Python2 版本中 repr() 函数的返回值
5.basestring():str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为 str 或者 unicode 的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))
isinstance("Hello world", str)
True
isinstance("Hello world", basestring)
True
6.bin(int):将10进制转成2进制
7.bool():进行布尔运算，判断为True/False
8.bytearray([source[, encoding[, errors]]]):返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
参数：
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素
9.bytes(str,encoding=“编码方式”):返回输入的字符串按照选定的方式编码出的二进制数（不可使用unicode）
可加.decode(“解码方式”):解码出信息(有默认方式，python3为uft-8)
10.callable(object):用于检查一个对象是否是可调用的
如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功
11.chr(int):返回ASCII表该参数位置的字符
12.classmethod:修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等
#!/usr/bin/python
#coding=utf-8
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 调用 foo 方法
A.func2() # 不需要实例化
#结果为fun2 1 foo
13.cmp(x,y):函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
14.compile(source, filename, mode[, flags[, dont_inherit]]):将一个字符串编译为字节代码
参数：
source – 字符串或者AST（Abstract Syntax Trees）对象。。
filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode – 指定编译代码的种类。可以指定为 exec, eval, single。
flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志
str = "for i in range(0,10): print(i)"
c = compile(str,'','exec') # 编译为字节代码对象
c
<code object <module> at 0x10141e0b0, file "", line 1>
exec(c)
0
1
2
3
4
5
6
7
8
9
str = "3 * 4 + 5"
a = compile(str,'','eval')
eval(a)
17
15.complex([real[, imag]]):用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
complex(1, 2)
(1 + 2j)
complex(1) # 数字
(1 + 0j)
complex("1") # 当做字符串处理
(1 + 0j)
#"+"两侧不得有空格。否则报错
complex("1+2j")
(1 + 2j)
16.delattr(x,y):删除对象x中的y属性
delattr(x,y)相当于del x.y
17.dict(**kwarg/mapping, **kwarg/iterable, **kwarg):转换成字典
参数说明：
**kwargs – 关键字
mapping – 元素的容器。
iterable – 可迭代对象
dict() # 创建空字典
{}
dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
18.dir( /object):不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息
19.divmod(x,y):以元组形式显示x/y的商和余数
在 python 2.3 版本之前不允许处理复数
分页功能
20.enumerate(sequence, [start=0]):用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
Python 2.3. 以上版本可用，2.6 添加 start 参数
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1)) # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
... print i, element
...
0 one
1 two
2 three
21.eval(str, globals, locals):执行一个字符串表达式，并返回表达式的值(提取字符串中字典/进行字符串中的数学运算)(不支持函数变量/类变量)
参数说明：
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象
22.exec(str/file):执行储存在str/file中的Python语句,比之eval()可以执行更复杂的 Python 代码
Python2中exec是一个内置语句(statement)而非函数,但Python2有一个execfile()函数。可理解为Python3把exec这个statement和execfile()函数整合到了一个新的exec()函数中
#单行语句字符串
exec('print("hello world")')
#Hello World
#多行语句字符串
exec('for i in range(5):print("iter time: %d" % i)')
#iter time: 0
#iter time: 1
#iter time: 2
#iter time: 3
#iter time: 4
#内外两层引号不得相同,必须一个只包含单引号,一个只包含双引号
23.execfile(filename[, globals[, locals]]):用来执行一个文件
文件hello.py，内容如下：
print('runoob')
execfile('hello.py')
runoob
24.file(name,mode,buffering):用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数
参数说明:以str的形式传递
name – 文件名
mode – 打开模式
buffering – 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小
文件 test.txt，内容如下：
RUNOOB1
RUNOOB2
f = file('test.txt')
f.read()
'RUNOOB1\nRUNOOB2\n'
25.filter(function, iterable):用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中
26.float(int/str):转换成浮点数
27.format():格式化字符串，详情参见字符串部分
Python2.6 开始增加
format 函数可以接受不限个参数，位置可以不按顺序
28.frozenset(iterable):返回一个冻结的集合，冻结后集合不能再添加或删除任何元素（如果不提供任何参数，默认会生成空集合）
29.getattr(object,name,default=None):获得object中name字符串对应的方法的地址/数据属性的值
不存在时返回default参数,默认为None时直接报错
所有参数均为位置参数
getattr(x,‘y’)相当于x.y
30.globals():以字典类型返回所有全局变量
31.hasattr(object,name):判断object中是否有name字符串对应的方法/属性(实际为是否能调用name方法/属性)
32.hash(num/str/tuple):进行哈希运算，返回哈希值
hashable的类型即不可变类型
哈希值长度固定；无法根据哈希值反推输入的信息具体是什么；同一次执行，同意输入得到相同哈希值；不同次执行，同样输入哈希值不一定相同
可用于判断信息是否被篡改
33.help(object):查看帮助
34.hex(int):10进制转16进制，以字符串形式表示
35.id(object):获取对象的唯一标识符(1个int)
- CPython中id()用于获取对象的内存地址
36.input(prompt):Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。
raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）；raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError
参数说明：prompt: 提示信息
37.int(str/num,base=10):将指定进制的str/num转换成10进制整型
不传入参数时，得到结果0；如果是带参数base的话，要以字符串的形式进行输入num
38.isinstance(object,classinfo):判断是否是指定类型
会认为子类是一种父类类型，考虑继承关系
与type()区别:
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
参数说明：classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组
39.insubclass(class, classinfo):判断参数 class 是否是类型参数 classinfo 的子类
40.iter(object,sentinel):生成迭代器
参数说明：
object–支持迭代的集合对象
sentinel–如果传递了第二个参数,则object必须是一个可调用的对象(如函数);此时iter创建了一个迭代器对象,每次调用该迭代器对象的__next__()方法时,都会调用object;直到返回结果为sentinel时raise StopIteration
lst = [1, 2, 3]
for i in iter(lst):
... print(i)
...
1
2
3
41.len():返回长度/项目个数
42.list():转换成列表
43.locals():以字典形式返回所有当前级别局部变量
对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True
44.long(x, base=10):将数字或字符串转换为一个长整型
只适用于python2
45.map(function, iterable):根据函数对指定序列做映射
function以每个参数序列中的每个对应元素调用function,返回包含每次function函数返回值的新列表(python2)/迭代器(python3)
map(function,iterable1,iterable2...)
#参数说明：
#function:函数
#iterable:序列(list,tuple,str...)
def square(x) :
... return x ** 2
map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
#提供了两个列表，对相同位置的列表数据进行加和
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
def a(a1,a2,a3):
a1*=2
return a1,a2,a3
list(map(a,('a','aa','aaa'),'aa','aaa'))
#结果:[('aa', 'a', 'a'),('aaaa','a','a')]
#参数3,4被作为序列使用
46.max(x,y…,key=none):按照指定的方法key比较大小,返回给定参数的最大值
- 参数可为序列(依靠for循环)
- 对int/float/bool,比较大小;对字符串,逐个字符比较,规则来自ASCII码表(b>a);complex无法比较;对tuple/list,逐个比较其中元素,如对应元素均相同,元素多的较大;dict无法比较;set也可比较;对键值对,比较的是key
- 只能同类比较
>>> a=[-1,0]
>>> b=[-2,0,-1]
>>> max(a,b)
[-1, 0]
>>> b=[-1,0,-2]
>>> max(a,b)
[-1, 0, -2]
>>> a=[0,1]
>>> b=[1,-10]
>>> max(a,b)
[1, -10]
47.memoryview(object):返回给定参数的内存查看对象(Momory view,返回给定参数的内存查看对象(Momory view))
python2:
v = memoryview('abcefg')
v[1]
'b'
v[-1]
'g'
v[1:4]
<memory at 0x77ab28>
v[1:4].tobytes()
'bce'
python3:
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
98
print(v[-1])
103
print(v[1:4])
<memory at 0x10f543a08>
print(v[1:4].tobytes())
b'bce'
48.min(x,y…):返回给定参数的最小值，参数可以为序列
49.next(iterator[, default]):返回迭代器的下一个项目(调用_next_())
参数说明：
iterator – 可迭代对象
default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常
#!/usr/bin/python
#coding=UTF-8
#首先获得Iterator对象
it = iter([1, 2, 3, 4, 5])
#循环：
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break #结果为1 2 3 4 5
50.object():？
51.oct(int):10进制转8进制
52.open(“name”, “mode”, buffering,encoding=" "):打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写
参数说明：
name:一个包含文件名的字符串值(绝对/相对路径)
mode:打开文件的模式,只读,写入,追加等;所有可取值见如下的列表;可选,默认为只读®
buffering:即输入多少数据时写入;如果为0,就没有寄存;如果取1,访问文件时会寄存行;如果设为大于1的整数,表明寄存区缓冲大小;如果取负值,寄存区缓冲大小为系统默认
encoding:编码方式,默认使用当前系统的编码方式解码
x:只写模式，不可读，不存在则创建，存在则报错
x+:可读写的x模式
xb:以二进制格式打开的x模式
b模式不进行解码，不指定编码方式
53.ord(str): chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常
54.pow():返回 x**y的值
语法：
math 模块 pow() 方法的语法:
import math
math.pow( x, y )
内置的 pow() 方法：
pow(x, y[, z]) #等效于pow(x,y) %z
内置方法会把参数作为整型，而 math 模块则会把参数转换为 float
55.print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False):用于打印输出
参数说明：
objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file – 要写入的文件对象。
flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新，仅python3。
print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字
56.property([fget[, fset[, fdel[, doc]]]]):在新式类中返回属性值
参数说明：
fget – 获取属性值的函数
fset – 设置属性值的函数
fdel – 删除属性值函数
doc – 属性描述信息
定义一个可控属性值x:
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
将 property 函数用作装饰器可以很方便的创建只读属性：
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
property 的 getter,setter 和 deleter 方法同样可以用作装饰器：
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
这个代码和第一个例子完全相同，但要注意这些额外函数的名字和 property 下的一样，例如这里的 x
57.raw_input(prompt):获取控制台的输入
58.reduce(function, iterable[, initializer]):对参数序列中元素进行累积（用传给 reduce 中的函数 function（有两个参数）对集合中的元素依次进行操作）
参数说明：
initializer：初始参数
print(reduce(lambda x, y: x+y, [1,2,3,4,5]))
#15
59.reload(module):重新载入之前载入的模块
60.repr(object):将对象转化为供解释器读取的形式
61.reversed():反向列表中元素,返回迭代器对象
a=reversed(li)
a=[1,4,532,2]
b=reversed(a)
print(b)
#结果:
<list_reverseiterator object at 0x000001E4AF66CF08>
62.round( x [, n]):返回浮点数x的四舍五入值
参数说明：n:保留的小数点后位数(如为负数，指小数点前位数，但仍显示到小数点后一位)
63.set(iterable):创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
x=set("google")={"g","o","l","e"}
64.setattr(x,y,v):给对象x增加一个y=v的属性/将对象x的y属性的值修改为v
class a:
def __init__(self,name):
self.name=name
a1=a('qaz')
setattr(a,'func',lambda self:self.name+'ed')
print(a.func(a1)) #qazed
65.slice(start=0, stop, step=1):实现切片对象，主要用在切片操作函数里的参数传递
s=slice(3,5)
print("hello"[s])
66.sorted(iterable, cmp=None, key=None, reverse=False):对所有可迭代的对象进行排序操作
sort与sorted区别：sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
参数说明：
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
不同类型不能排序
67.staticmethod(function):返回函数的静态方法(不强制要求传递参数)
68.str(object):转换为字符串
69.sum(iterable, start=0):对系列进行求和计算
参数说明：start:额外指定的相加的参数
70.super(type[, object-or-type]):用于调用父类(超类)的一个方法。super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
参数说明：
type – 类。
object-or-type – 类，一般是 self
Python 3 可直接使用 super().xxx 代替 super(Class, self).xxx; python2不可
python3实例：
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3
python2实例：
#!/usr/bin/python
#coding=UTF-8
class A(object): # Python2.x 记得继承 object
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super(B, self).add(x)
b = B()
b.add(2) # 3
71.tuple(seq):将序列转换成元组
72.type(name, bases, dict):如果只有第一个参数则返回对象的类型(是哪个类的实例)，三个参数返回新的类型对象
参数说明：
name – 类的名称
bases – 基类的元组
dict – 字典，类内定义的命名空间变量
不会认为子类是一种父类类型，不考虑继承关系
class foo:
pass
class bar(foo):
pass
b1=bar()
print(type(b1)) #<class '__main__.bar'>
print(type('X', (object,), dict(a=1)))
#<class '__main__.X'>
#相当于:
#class X(object):
# a=1
与isinstance()区别:
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
73.unichr(i):和 chr()函数功能基本一样， 但返回 unicode 的字符
参数说明:i–可以是10进制也可以是16进制的形式的数字
74.unicode():？
75.vars(object=none):无参数，等于locals();有参数，以字典形式返回对象object的属性和属性值的字典对象
76.xrange(start=0,stop,step=1):用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器
77.zip(iterable1,interable2):将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表
- 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同(多余的元素直接忽略)
- 利用*号操作符,可以返回传入的可迭代对象构成的列表(不论传入何种,列表中元素均为元组;可理解为解压)
- 在 Python 3.x 中为了减少内存,zip() 返回的是一个对象;如需展示列表,需手动 list() 转换
zip(iterable1,iterable2...)#最少有一个可迭代对象
>>> list(zip(('a','b','c')))
[('a',), ('b',), ('c',)]
>>>list(zip(("a","b","c"),(1,2,3))
[("a",1),("b",2),("c",3)]
>>>dict={"name":"Alex","age":18,"gender":"male"}
>>>list(zip(dict.keys(),dict.values()))
[("gender","male"),("name","Alex"),("age",18)]
>>> zipped=list(zip([1,2,3],['2','d',3]))
>>> zipped
[(1, '2'), (2, 'd'), (3, 3)]
>>> list(zip(*zipped))
[(1, 2, 3), ('2', 'd', 3)]
使用zip()并行迭代:通过zip()对多个序列进行并行迭代
- zip()在最短的序列用完时就停止
name=('a','b','c','d'),age=(20,30,17,23),job=('老师','研究员','程序员')
for name,age,job in zip(name,age,job):
print('{0}-{1}-{2}'.format(name,age,job))
#结果:
a-20-老师
b-30-研究员
c-17-程序员
78._ import_(name[, globals[, locals[, fromlist[, level]]]]):用于动态加载类和函数(如果一个模块经常变化就可以使用 _ import_() 来动态载入)
- 导入字符串类型模块名
79.import:导入模块
import 文件名（无后缀）
文件名.其中要调用的功能 #调用
as:指代
import time as T
#之后可使用T指代time模块
80.字典的运算：最小值，最大值，排序
salaries={'egon':3000,'alex':100000000,'wupeiqi':10000,'yuanhao':2000}
迭代字典，取得是key，因而比较的是key的最大和最小值
max(salaries)
'yuanhao'
min(salaries)
'alex'
可以取values，来比较
max(salaries.values())
min(salaries.values())
但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键
max(salaries,key=lambda k:salary[k])
'alex'
min(salaries,key=lambda k:salary[k])
'yuanhao'
也可以通过zip的方式实现
salaries_and_names=zip(salaries.values(),salaries.keys())
先比较值，值相同则比较键
max(salaries_and_names)
(100000000, 'alex')
salaries_and_names是迭代器，因而只能访问一次
min(salaries_and_names)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: min() arg is an empty sequence
560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
