Python之内置函数、匿名函数
一、内置函数(68个)
1. 作用域相关(2)
locals(): 局部作用域中的变量
global(): 全局作用域中的变量
在全局中执行这两个变量,结果相同
def func(): pass func() print(locals()) print(globals())
在局部执行locals()表示函数内的名字,globals()始终不变
def func(): a= 0 b = 1 print(locals()) print(globals()) func()
2. 迭代器和生成器相关(3)
a. iter(): 只接收一个内部含有__iter__()方法的对象统一接口(iter() 和 __iter__()是一样的,在python里尽量少的调用双下方法)
b. next(迭代器): next()和__next__()是一样的
c. range(*****): range生成的是一个可迭代对象,最好循环取结果
*. range(100) 0-99
*. range(0,100)
*. range(0,100,2)可以设置步长
3. 基础数据类型(39)
1. 数字相关(14)
a. 数据类型(4)
bool() # 强转布尔类型(*****) int() # 强转整数类型(*****) float() # 强转浮点类型(*****) complex(实部, 虚部) # 转为复数类型 print(complex(1,2)) # 结果为:(1+2j)
b. 进制转换(3)
bin() # 二进制 oct() # 八进制 hex() # 十六进制
c. 数学运算(7)
*. abs() 绝对值
ret = abs(-99)
print(ret) # 99
*. divmod(被除数,除数) 应用:分页
print(divmod(9,5)) # (1,4)
*. round(小数,留几位小数)
print(round(2.4567432,3)) # 2.456
*. pow(x,y)幂运算 x的y次幂
pow(x,y,z) x的y次幂对z取余,z的默认值是1
print(pow(2, 3)) # 8 print(pow(3, 3, 5)) # 2
*. sum() 求和
sum(iterable,start)
start:开始计算值,默认是0
应用,求本钱加利息sum(利息,本钱)
print(sum(range(5),3))
*. min(iterable,key,default)
ierable:可迭代对象或多个值
key: 判断最小值的条件函数
default:未计算出最小值时返回值
# 什么也不设置的时候: li = [1, -2, 3, -5] print(min(li)) # -5 # 设置key值的时候; li = [1, -2, 3, -5] print(min(li, key=abs)) # 1 # 设置default的时候: li = [] print(min(li, key=abs, default=1)) # 1
*. max(iterable,key,default)
ierable:可迭代对象或多个值
key: 判断最小值的条件函数
default:未计算出最小值时返回值
# 什么也不设置的时候: li = [1, -2, 3, -5] print(max(li)) # 3 # 设置key值的时候; li = [1, -2, 3, -5] print(max(li, key=abs)) # -5 # 设置default的时候: li = [] print(max(li, key=abs, default=1)) # 1
2. 列表、元组(4)
a. list(): 强转为列表类型
b. tuple(): 强转为元组类型
c. reversed(): 反转,针对本身有序的对象,结果是一个反序迭代器(列表,元组,字符串通用)
ret = reversed([1, 2, 3, 4, 5, 6, 7]) ret = reversed("sjkfndjdk") print(list(ret)) ret = reversed("sjkfndjdk") print("".join(list(ret)))
d. slice(start, end, length) 切片操作(列表,元组,字符串通用)
li = [2, 3, 5, 6, 8, 9, 0, 0, 4, 1] my_s = slice(1, 5, 2) print(li[my_s]) # 等价于li[1:5:2]
3. 字符串(10)
a. str():强转为字符串类型
b. format("content", "对齐方式"): 字符串拼接,对齐方式有三种,<左对齐,>右对齐,^居中
print(format("abc", ">20")) print(format("abc", "<20")) print(format("abc", "^20"))
c. bytes(): 强转为字节类型
by = bytes("字符", encoding="utf-8") # 转换成unicode编码 print(by) # 结果:b'\xe5\xad\x97\xe7\xac\xa6'
by = bytes("字符", encoding="utf-8") by = by.decode("utf-8") # 转为string类型 print(by) # 结果:字符
d. bytearray():强转为字节数组类型
ret = bytearray("字符", encoding="utf-8") print(ret) # 结果:bytearray(b'\xe5\xad\x97\xe7\xac\xa6')
e. memoryview(): 内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问,即在不开辟新的内存空间的情况下,展现字符串的一部分。
ret = memoryview(bytes('你好', encoding='utf-8')) print(len(ret)) # 6 print(bytes(ret[:3]).decode('utf-8')) # 你 print(bytes(ret[3:]).decode('utf-8')) # 好
f. ord(): 字符转为数字,根据Unicode转变
g. chr(): 数字转为字母,根据Unicode转变
h. ascii(): 转为ascii码
i. repr(): 将对象转化为供解释器读取的形式,返回对象的字符串格式。用于%r格式化输出
j. basestring(): 判断一个对象是否为 str 或者 unicode 的实例
basestring是 str 和 unicode 的超类(父类),也是抽象类,因此不能被调用和实例化.,isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
4. 字典、集合(3)
a. dict(): 强转成字典
b. set(): 强转成集合
c. frozenset():改为不可变集合
set_test = set('hello') f_set_test = frozenset(set_test) # dic = {set_test:1} 这样直接写会报错,因为集合是可变的,而字典的key值只能是不可变数据类型 dic = {f_set_test: 1} print(dic)
5. 各类数据类型相关的内置函数(8)
a. len(): 求长度
b. enumerate(): 给一个可迭代对象加序号
se = {'computer': 10000, 'umbrella': 200} for num, goods in enumerate(se, 1): print(num, goods, se[goods])
c. all(可迭代对象): 判断bool值是否有Flase的值
print(all([1,"",3,5])) # False
d. any(可迭代对象): 判断bool值是否有True的值
print(any(["",[],3])) # True
e. zip(可迭代对象,可迭代对象.....): 得到的是迭代器,返回的是列表
li = [1, 2, 3, 4, 5, 6] a = "faskdlfj" print(zip(li, a)) ret = zip(li, a) for i in ret: print(i)
f. filter(函数,可迭代对象):过滤,过滤条件是函数。
从可迭代对象里取值,在函数里运行,符合条件时,就放到返回值里,返回值是迭代器。
例一: def func(n): if type(n) is str: return True li = ["af", [1, 2, 3], (3, 4, 5)] ret = filter(func, li) for i in ret: print(i) 例二: def func(n): if n and n.strip(): return True li = ['test', None, '', 'str', ' ', 'END'] ret = filter(func, li) print(list(ret))
g. map(函数,可迭代对象): 返回的是列表
def func(n): return n + n li = [1, 2, 3, 4, 5] ret = map(func, li) for i in ret: print(i)
h. sorted(对象): 排序,默认从小到大 #有返回值
li = [1, 2, 53, 1234, 3, 4, -455] print(sorted(li))
sort(): 排序,没有返回值,只用在list对象上。
li = [1, 2, 53, 1234, 3, 4, -455] li.sort() print(li)
4. 类相关(8)
1. super(): 继承中用来调用父类的方法
super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
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
2. 装饰器(3)
a. classmethod(function):类方法
对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
class A(object): bar = 1 def func1(self): print ('foo') @classmethod def func2(cls): print ('func2') print (cls.bar) cls().func1() # 调用 foo 方法 A.func2() # 不需要实例化
b. staticmethod(function):静态方法
class C(object): @staticmethod def f(): print('runoob'); C.f(); # 静态方法无需实例化 cobj = C() cobj.f() # 也可以实例化后调用
c. property(function):把类中的方法假装成属性
class Book: def __init__(self,name): self.name = name @property def get_name(self): return self.name book = Book("Fluent Python") print(book.name) print(book.get_name) # 这里去调用的时候,就是相当于调用一个属性
3. 类的属性方法(4)
a. setattr() 函数对应函数getattr(),用于设置属性值,该属性不一定是存在的。
b. getattr(object, name[, default]): 返回一个对象属性值。
object -- 对象。
name -- 字符串,属性名。
default -- 默认返回值,如果不提供该参数,在没有对应属性时,将触发 AttributeError。
c. hasattr(object, name): 函数用于判断对象是否包含对应的属性。如果对象有该属性返回 True,否则返回 False。
d. delattr(object, name): 删除属性。
delattr(x, 'foobar') 相等于 del x.foobar。
5. 其他类型(16)
a. 执行字符串中的代码(3)
eval:计算(有返回值)
exec:流程控制(无返回值)
print(eval("1+2+3+4")) # 结果是:10 print(exec("1+2+3+4")) # 结果:None # 这样执行才会有返回值 exec("print('hello,word')")
compile(source,filname,mode): 当需要对某一个字符串类型的python代码多次执行的时候,用compile先编译一下。
source:字符串,或AST(Abstract Syntax Trees)对象,即需要动态执行的代码段
filename:代码文件名称,如果不是从文件读取代码传递一些可辨认的值。当传入了source参数时,filename参数传入空字符串即可
model:指定编译代码的种类,可以指定为,exec,eval,single,三种,
# 示例 # 1. 当source中含有流程语句时,model = exec code = "for i in range(10):print(i)" compile1 = compile(code, "", 'exec') exec(compile1) # 2. 当source中含有一个简单的求值表达式时,model = eval code = "1+2+3+4" compile1 = compile(code, "", 'eval') print(eval(compile1)) # 3. 当source中含有交互式命令语句的时候,model = single code = "name= input('>>>')" # input交互式命令语句 compile1 = compile(code, "", 'single') exec(compile1) print(name)
b. 输入输出函数(2)
input(): 返回字符串类型
print(): 输出
import sys value = "string print" print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) # file: 输出内容到指定文件夹,默认输出到控制台 # sep: 字符串之间的分隔符,默认是空格 # end: 字符串结束符,默认是\n换行符 # flush: 是否立即把内容输出
import time import sys # 实现进度条 for i in range(0, 101, 2): time.sleep(2) char_num = i // 2 # 打印多少个# per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s' % (i, '*' * char_num) print(per_str, end='', file=sys.stdout, flush=True)
c. hash(): 哈希方法,结果是一个数字,同一个对象的哈希值,在python的一次执行中是一样的,但是重新执行程序后就不一样了。
可变的数据类型(列表,字典,集合)是不能被哈希的。
hashlib()计算出来的结果永远不会变
d. id(): 查看对象的内存地址
e. 文件相关(2)
*. open(filename,encoding,mode): 操作文件,生成文件对象
*. execfile(filename):执行一个文件,输出文件内容
f. import module : 导入模块
g. help(): 进入help模式,退出"q"
h. callable(对象): 判断一个对象是否可以调用
i. dir(): 查看内置属性
print(dir(__builtins__)) # 所有内置名字
j. 判断对象类型(3)
type(): 返回该对象的类型
isinstance(object, type): 判断对象是否是该类型数据,或者用来判断继承关系
issubclass(子类,父类/多个父类): 判断两个类是不是父子关系
二、匿名函数
1. 一句话的python
a. 三元运算
b. 推导式,生成器表达式
c. lambda表达式(解决简单问题)
2. lambda表达式
funcname = lambda 参数:返回值
print(funcname(arguments))
func = lambda x,y:x+y print(func(2,5))
规则:
a. 参数可以有多个,用逗号隔开
b. 不管逻辑多复杂,lambda表达式只写一行,且逻辑执行结束后的内容就是返回值
c. 返回值和正常函数一样可以是任何数据类型
# 现有两个元祖(("a"),("b")),(("c"),("d")),请使用python中的函数生成列表[{"a":"c"},{"b":"d"}] print(list(map(lambda t:{t[0]:t[1]},zip((("a"),("b")),(("c"),("d"))))))
d = lambda p:p*2 t = lambda p:p*3 x = 2 x = d(x) x = t(x) x = d(x) print(x)