内置函数

内置函数
```python

#pop()列表删除元素 按索引删除

#remove()列表删除元素 按值删除

#abs 取绝对值
print(abs(152.25))
print(abs(-147))
print(abs(0))

#all判断所有元素，全为真则为真
print(all([1,3,4]))
print(all("asdf"))
print(all(""))
print(all([]))
print(all([1,0,"adsf"]))

#any 判断所有元素，至少一个真则为真
print(any([1,3,4,54]))
print(any([0,""]))

#bin 将十进制数转换为二进制
print(bin(3)) #0b11

#hex 将十进制转换成16进制
print(hex(15)) #0xf

#oct 转成8进制
print(oct(9)) #0o11

print(bool(0)) #值的真假
print(bool("a"))

#bytes字节 将结果转为二进制，要注明编码方式
print(bytes("你好",encoding="utf-8"))

#将一个数字转成ASC码对应的值 数字有范围限制
print(chr(97))
print(chr(1111))

#跟cha作用相反
print(ord(" "))

classmethod() 类方法
class Foo:
#@classmethod
def test(cls):
print("aaa")
f1=Foo()
f1.test()
# 没有@classmethod时，test被实例调用，f1.test()
#会自动把f1传给self
Foo.test()
#在有了@classmethod后，Foo调用类方法，也会自动把Foo传给self

print(dir()) #查看函数有的方法

print(divmod(11,5)) #将10除以3，取商和余(2,1)
print(divmod(11,5))

enumerate() #枚举
list=['admin','teacher','student']
for index,item in enumerate(list,1)
print(index,item)
1 'admin'
2 'teacher'
3 'student'

#把字符串内容 转成 对应类型内容
print(eval("{'k1':'v1'}"))
#能把字符串的数学表达式计算出来
print(eval("1+1"))

float() #转换成浮点型

#格式化内容 "{0}---{1}".format("x","y")
#用"x"填补{0}处，用"y"填补{1}处
print("{0}aaa{1}".format("bbb","ccc"))
#>>>bbbaaaccc

#format的四种玩法（python推荐使用format做格式化输出）
# 第一种 按位置占位 跟%s原理一致
str1 = 'my name is {}, my age is {}'.format(18,'age')
print(str1)
# 第二种 按索引占位
str1 = 'my name is {1}, my age is {0}'.format('egon',18)
print(str1)
# 第三种 指名道姓占位（关键字传参）
str1 = 'my name is {name}, my age is {age}'.format(name='egon',age=18)
print(str1)
#第四种 format简写,两个变量进行拼接时用
name='egon'
age=18
str1 = f'my name is {name}, my age is {age}'
print(str1)

globals() #打印全局变量，打印的是列表
locals() #打印局部变量

#生成hash值
print(hash("asdfasdf"))

id("aa") #查看对象的内存地址

#传一个对象,类 返回 对象是否为该类的实例
print(isinstance(1,str))
#传类a,类A 返回 类a是否基于类A
print(issubclass(ValueError,object))

iter() #将对象变成迭代器

len() #求长度

max() #求最大值
mix() #求最小值

#pow如果跟两个值，则是2^3
print(pow(2,3)) #8
#pow如果跟三个值，则是2^3对2取余
print(pow(2,3,3)) #2

#1到9
print(range(1,9))

reversed() #翻转

#小数点保留几位 并四舍五入
print(round(1.54528,3))

#zip一一对应
zip()
li = [11,22,33,44]
l1 = ['a','b','c','d']
r = zip(li,l1)
print(list(r)) # 结果：[(11, 'a'), (22, 'b'), (33, 'c'), (44, 'd')]

#sort排序，同种类型
li = [1,211,22,3,4]
print(li )
li.sort()
print(li)
new_li = sorted(li)
print(new_li)

staticmethod #静态方法

property #静态方法

#
class Foo:
pass
class Bar(Foo):
pass
#调用父类的方法
super(Bar)

#iter(object, sentinel)
#只写一个参数：把第一个变成迭代器
#加第二个参数：sentinel,迭代到sentinel内容立即停下

#偏函数：固定函数的第一个参数
from functools import partial
def add(x,y):
return x+y
#指定add函数，把1传给add第一个参数
func=partial(add,1)
print(func(1)) #2
print(func(1)) #3
```
复杂点的内置函数
```python
#三元运算 对简单的条件语句的缩写
result = 值1 if 条件 else 值2
# 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量
name = "nick" if 1==1 else "jenny"
print(name)

a = 1
result = "xiaoming" if a == 1 else "xiaogang"
print(result) #"xiaoming"

#lambda 表达式
def func(arg):
return arg + 1
print(func(2))
func = lambda *args : print(args)
print(func(1,2,3))

#map 遍历可迭代对象，对象中每个元素进行操作，得到新序列
li = [1,2,3,4,5]
def func(s):
return s + 1
ret = map(func,li)
ret生成的是一个迭代器
print(next(ret))
print(list(ret))这个才是[2,3,4,5,6]

print(list(map(lambda li : li + 1 ,li)))

#filter 过滤

li = [22,33,44,55]

def func(s):
if s > 33:
return s
ret = filter(func,li)
print(list(ret))

print(list(filter(lambda s : s >33 ,li)))

#reduce python3需要导入
from functools import reduce
# 传两个参数，两个参数之间的做什么处理
li = ["a","l","e","x"]
def func(a,b):
return a+b
ret = reduce(func,li)
print(ret)
此处的ret不是对象，而是运算结果
li = [1,2,3,4,5]
print(reduce(lambda a,b : a +b ,li))

isdigit() 方法检测字符串是否只由数字组成
s1='123'
s1.isdigit()
>True

istitle()
字符串中所有的单词拼写首字母是否为大写，并且其他字母为小写，是则返回 True，否则返回 False

```