day14 内置函数68个
一.内置函数
python提供的, 可以直接拿来用的函数
参考资料(网址)
1.作用域相关(2个 globals() locals())
print(globals()) #以字典形式返回全部全局变量及他们的值
print(locals()) #以字典形式返回locals()函数所在当前作用域里的全部变量及他们的值
2.迭代器和生成器相关(3个 range() iter() next())
lst = ['bajie', 'wukong','datang']
it = lst.__iter__() #方式一
print(it.__next__())
it = iter(lst) #方式二和方式一一样, 内部分别封装了__iter__()和__next__()
print(next(it))
print(type(range(10))) #<class 'range'>
3.输入输出(2个 input() print())
print('bajie') #输出,是一个功能, 没有返回值
name = input('name: ') #输入, 用于用户交互
4.内存相关(2个 id() hash())
print(id('bajie')) #打印对象的内存地址
print(hash('bajie')) #目的是为了存储, 计算之后是一个数字, hash值尽量不要重复(可hash的才能用这个函数)
#{name:'bajie',age:20} 比如把name hash后的数字作为存储的地址, 把value存进去, 查找时, 只需要找一次, 但是比较浪费空间, 所以是一句话: 拿空间换时间
5.文件操作相关(1个 open())
with open('bajie.txt', mode='w', encoding='utf-8') as f: #也可以创建一个新的文件, 要是多次创建, 每次都会清空
pass
6.模块相关(1个 __import__())
import os
__import__("os") #可以动态引入模块, 不常用, 直接用上面那个就好了. (比如当用户输入a时,加载这个模块; 用户加载b时, 引入另外一个模块)
7.帮助(1个 help())
help(str) # 直接打印 '''帮助文档'''
8.调用相关(1个 callable())
def func():
print('bajie')
print(callable(func)) #判断一个对象是否可以被调用执行
9.查看内置属性(1个 dir())
print(dir()) #返回内置属性(可以 . 出来的方法, 先__开头的, 后其他), 返回的是列表
10.基础数据类型相关(38个)
和数字相关: 数据类型(4个 bool() int() float() complex())
a = 4
print(bool(a))
print(int(a))
print(float(a))
print(complex(a)) #复数(实数 + 虚数), (i**2 == -1)此时的i叫做虚数
和数字相关: 进制转换(3个 bin() oct() hex())
print(bin(66)) #0b二进制
print(oct(66)) #0o八进制
print(hex(66)) #0x十六进制
#注册, 实名认证, 银行卡, 风险评估
#(0,1) (0,1) (0,1) (0,1)
# 1111用一列表示上面4列的内容, 认为可以放款(用一个数保存用户多个状态)
和数字相关: 数学运算(7个 abs() divmod() round() pow() sum() min() max())
print(abs(-32)) #求|绝对值|
print(divmod(10,3)) #(3,1)计算商和余数
print(round(34.45)) #四舍五入
print(pow(2,4)) #求次幂 2**4
print(pow(2,4,3)) #先次幂, 再取余
print(sum((1,2,3))) #求和
print(min((1,2,3,4,5))) #求最小值
print(max((1,2,3,4,5))) #求最大值
和数据结构相关: 序列: 列表和与元组(2个 list() tuple())
list('bajie')
tuple('bajie')
和数据结构相关: 序列: 相关的内置函数(2个 reversed() slice())
lst = [1,2,3,4,5,6]
print(reversed(lst)) #返回的是迭代器
print(list(reversed(lst))) #反转之后的结果
print(lst) #源列表不变
s = slice(0,555,2)
print(lst[s]) #切片, 和lst[::]一样
和数据结构相关: 序列: 字符串(9个 str() bytes() bytearray() memoryview() ord() chr() ascii() repr() format())
print(str(66))
s = '八戒'
print(s.encode('utf-8'))
print(bytes(s, encoding='utf-8')) #把字符串转换成bytes类型, 和s.encode()一样
new_s = bytearray(s,encoding='utf-8')
print(new_s[0]) #229 , 元素可变, 每个元素的值的范围是[0, 256]
print(new_s) #返回一个新的字节数组, bytearray(b'\xe5\x85\xab\xe6\x88\x92')
print(s) #源数据不变
print(memoryview(s.encode('utf-8'))) #memory at: 参数是bytes类型, 和id()的作用差不多
print(ord('是')) #找到输入字符的编码的位置
print(chr(97)) #找到输入位置的字符
print(ascii('a')) #如果是ascii码中的字符, 就返回这个字符, 如果不是返回 \u...
print('bajie ai "shuishui"') #字符串嵌套: 1.单引号+双引号
print("bajie ai \"shuishui\"") #字符串嵌套: 2.转义
print('bajie') #bajie 对用户友好的(非正式的字符串)
print(repr("bajie")) #'bajie' 对程序友好的, 程序中内部存储的内容, 给程序员看的(正式的, 官方的字符串)
print('my name is %r' % 'bajie') #my name is 'bajie' 调用的就是repr()
print(r'这个才是原样输出\n\r\c') #最后不能以\结尾
#字符串
s = 'bajie'
print(s.center(20,'#'))
print(format(s, "^20")) #居中
print(format(s, ">20")) #右对齐
print(format(s, "<20")) #左对齐
#数值(整数)
print(format(31, 'b')) #转成二进制, bin()
print(format(97, 'c')) #转换成 unicode字符, chr()
print(format(11, 'd')) #转成十进制
print(format(11, 'n'))
print(format(11))
print(format(11, 'o')) #转成八进制
print(format(11, 'x')) #转成十六进制
print(format(11, 'X'))
#浮点数
print(format(123456789, 'e')) #转成科学计数法, 默认保留6位小数, 1.234568e+08
print(format(123456789, '0.2e')) #保留两位小数
print(format(123456789, '0.2E'))
print(format(1.23456789, 'f')) #浮点数计数法, 默认保留6位小数, 1.234568
print(format(1.23456789, '0.2f')) #保留两位小数
print(format(1.23456789, '0.10f')) #保留10位小数, 1.2345678900
print(format(1.23456789e+10000, 'F')) #INF 代表的是无穷大
和数据结构相关: 数据集合: 字典和集合(3个 dict() set() frozenset())
dict()
set()
frozenset()
和数据结构相关: 相关内置函数(8个 len() sorted() enumerate() zip() filter() map())
len()
sorted() #sorted(iterable, key=None, reverse=False)
lst = [1,98,2,3,44,66,78,6]
print(sorted(lst)) #源不变, 返回一个新的列表
lst = ['bajie','wukong','datang','xixi']
def func(s):
return len(s)
print(sorted(lst, key=func)) #key: 排序方案, sorted函数内部会把可迭代对象的每一个元素拿出来交给后面的key处理
# key返回一个数字, 作为这元素的权重,然后整个函数根据整个权重排序
print(sorted(lst, key=(lambda i:len(i)))) #lambda效果一样
lst = [{'name':'bajie', 'age':'66'},{'name':'wukong', 'age':'56'},{'name':'datang', 'age':'46'}]
def func(el):
return el['age']
print(sorted(lst, key=func))
print(sorted(lst, key=lambda el: el['age'])) #效果和上面一样
enumerate() #返回可迭代元素的(下标,元素)
print(all((True, 1, 1, True))) #and #结果是True
print(any((True, 0, 0, False))) #or #结果是True
lst1 = [1,2,3,4]
lst2 = ['a','b','c','d']
lst3 = ['八','戒','爱','谁','谁']
lst = zip(lst1,lst2,lst3)
print(lst) #<zip object at 0x000001AB8499A288>
print("__iter__" in dir(lst)) #可迭代的
for el in lst:
print(el) #按列组合, 多余的列->走的是水桶效应,
'''
(1, 'a', '八')
(2, 'b', '戒')
(3, 'c', '爱')
(4, 'd', '谁')
'''
filter() #filter(function,iterable)
lst = ['bajie','wukong','datang','wtdi']
def func(el):
if el[0] == 'b':
return False
else:
return True
f = filter(func, lst) #将lst中的每一项作为参数传递给func, 所有的返回True的保留, 返回False的过滤掉
f = filter(lambda el: el[0] != 'b',lst) #和上面一行的作用一样
print('__iter__' in dir(f))
for el in f:
print(el)
lst = [{'name':'bajie', 'age':'66'},{'name':'wukong', 'age':'96'},{'name':'datang', 'age':'46'}]
f = filter(lambda el: int(el['age']) >=60 ,lst) #是可迭代的一个对象
print(list(f)) #还原成列表
map() #分而治之的思想 #映射函数 map(func,iter1)
lst = [1,4,7,2,5,8]
#计算列表中每个数字的平方
print([n*n for n in lst])
def func(el):
return el**2
m = map(func, lst) #可迭代的, 把后面可迭代对象的每个元素传递给前面的func, 结果是func的(处理结果)返回值
m = map(lambda el: el**2, lst)
print(list(m))
#分发思想是这样的,暂时用不到
#map(func1,map(func2,map(func3,lst)))
lst1 = [1,2,3,4,5]
lst2 = [1,2,3,4,5]
print(list(map(lambda x,y:x+y, lst1, lst2))) #func后面可跟多个iterable对象, 每个iterable对应func的一个参数, (也有水桶效应与zip()一样)
11.和字符串格式执行相关(3个 eval() exec() compile())
s = '5+6'
print(eval(s)) #作用1. 执行字符串格式的代码, 侧重点在返回上(求值表达式)
#BS架构, 前台html, 后台python, 涉及到数据交换 "{'name':'bajie', 'age':'60'}" json像字典一样的东西
dic = eval("{'name':'bajie', 'age':'60'}") #作用2. 把字符串还原成字典, 或列表
print(type(dic))
s = "a = 10"
exec(s) #执行代码, 无返回值 #exec() 在windows里是exe, (execute执行), 执行一个相对复杂的代码
print(a)
'''
compile() 将字符串类型的代码编译. 代码能通过exec语句来执行, 或者eval()进行求值
参数说明:
1. resource 要执行的代码, 动态代码片段
2. 文件名, 代码存放的文件名, 当传入了第一个参数的时候, 这个参数就给空就可以了
3. 模式, 取值有3个
1.exec: 一般放一些流程语句的时候
2.eval: resource 中只存放一个求值表达式的时候
3.single:resource存放的代码有交互的时候. mode应为single
应用场景:
编程大赛, 收卷子, 看效率,先编译, 后执行
'''
code = "for i in range(10): print(i)"
c = compile(code, '', 'exec')
exec(c)
code = "5+9"
c = compile(code, '', 'eval')
print(eval(c))
code = "name = input('name: ')"
c = compile(code, '', 'single')
exec(c) #只能用exec执行
print(name)
12.反射相关(4个 hasattr(), getattr(),setattr(), delattr())
hasattr(), getattr()
在模块中找
import handler
while True:
prompt = ''' support function has:
f1
f2
f3
f4
f5
please enter your function: '''
choice = input(prompt) # "f1"
#正确的方法, 映射: 简单的 #可以在模块中寻找
if hasattr(handler,choice): #把字符串映射为函数/方法名等成员名: 判断模块中是否有"字符串"对应的方法/函数等成员
func = getattr(handler, choice) #把字符串映射为函数/方法名等成员名: 把"字符串"映射为函数名/方法名的状态(此处不判断是否有没有,有没有不重要,重点是映射)
#此处可判断下这个成员是函数或者方法, 才去调用
func()
else:
print('no such func or method')
#正确的方式: 复杂的
# if choice == 'f1':
# handler.f1()
# elif choice == 'f2':
# handler.f2()
# elif choice == 'f3':
# handler.f3()
# elif choice == 'f4':
# handler.f4()
# elif choice == 'f5':
# handler.f5()
在类里找, 在对象里找
class Foo:
country = 'china'
def func(self):
print('in func')
v = getattr(Foo, 'country') #可以在类里找
print(v)
v = getattr(Foo, 'func')
print(v)
v(Foo())
obj = Foo()
v = getattr(obj, 'func') #可以在对象中找
print(v)
v()
setattr(), delattr() (这两都是动态的, 都是在内存级别的: 只在内存增加, 和文件没关系)
在模块中设置
import handler
setattr(handler, 'age', 666) #设置个变量
print(getattr(handler, 'age'))
setattr(handler, 'f2', lambda x:x+1) #设置个函数
print(getattr(handler, 'f2')(666))
delattr(handler, 'name')
print(getattr(handler, 'name')) #在内存中删掉
在类中设置
class Foo:
def __init__(self, a1):
self.a1 = a1
self.a2 = None #要是非要用setattr(), 在这里写上a2
obj = Foo(1)
print(getattr(obj, 'a1'))
setattr(obj, 'a2', 2) #千万不要这么做, 你在这设置, 别人看不到,
13.面向对象相关(9个 issubclass(), type(), isinstance())
issubclass() #判断两个类的关系: 是否是子类
class Base:
pass
class Foo(Base):
pass
class Bar(Foo):
pass
print(issubclass(Foo, Base)) #True #检查前面的类是否是后面的类的子类
print(issubclass(Bar, Base)) #True
type() #精准的判断一个对象的类是哪个
class Foo(object):
pass
obj = Foo()
print(obj, type(obj)) #可以获取当前对象是由哪个类创建
if type(obj) == Foo: #type(对象): 还可以用来和类做判断,
print('obj 是 Foo类型')
#type()可以精准的判断一个对象是哪个类创建的
class Foo:
pass
class Bar:
pass
def func(*args):
foo_counter = 0
bar_counter = 0
for item in args:
if type(item) == Foo:
foo_counter += 1
elif type(item) == Bar:
bar_counter += 1
return foo_counter,bar_counter
print(func(Foo(),Foo(),Bar()))
isinstance() #和type()类似, 没有他精准: 父类,父父类也可以也算,
class Base:
pass
class Foo(Base):
pass
obj = Foo()
print(obj, isinstance(obj, Foo)) #检查第一个参数是不是第二个参数的实例
print(obj, isinstance(obj,Base)) #也可以说是父类的实例,