从入门到自闭之Python内置函数

内置函数一

eval：执行字符串类型的代码
exac：执行字符串社类型的代码

eval与exac 禁止使用

hash（）作用就是区分可变数据类型与不可变数据类型

# print(hash("123"))

# print(hash(12))

# print(hash(-1))

# print(hash(-10))

# print(hash((2,1)))

# dic = {[1,2,3]:2}

# print(hash([1,2,3]))

help（）：查看帮助信息

callable（）：查看对象是否可以调用，

# def func():

#     print(1)

# lst = [1,23,4,]

# print(callable(lst))   # 查看对象是否可调用

int（）：将字符串或数字转换成整型
float（）：转换成浮点数
complex（）：复数
bin（）：十进制转二进制
oct（）：十进制转八进制
hex（）：十进制转十六进制
divmod（）：计算除数与被除数结果，包含一个商和余数的元祖
round（）：保留浮点数的小数位数，可以设定保留位数，默认保留整数
pow（）：求x ** y次幂（三个参数的时候为x ** y的结果对第三个参数取余）
bytes（）：用于不同编码之间的转换，建议使用encode
ord（）：通过元素获取当前表位编码位置
chr（）：通过表位序号查找对应的元素
repr（）：查看数据的原生态（给程序员使用的）
all（）：判断容器汇总的元素是否都为真，返回true
any（）：判断容器中的元素有一个为真，就是True

匿名函数：一行函数lambda（必背）

def func（）：

	print（123）

func（）

语法：

函数名 = lambda 参数：返回值
匿名函数的名字叫做lambda
lambda是定义函数的关键字，相当于函数的def

只可以返回一个数据类型，

面试题：

print ([lambda : i for i in range(5)])

（返回5个内存地址）

print(lst[0]())---结果是4--因为循环最后一次输出是4，调用的全局最后一个就是4

不加后面的小括号就是调用内存地址

加了括号就是调用函数

lst = [lambda X : X+1 for i in range(5)]

print(lst[0](5))

输出结果为：6，返回值是x+1

tu = (lambda : i for i in range(3))

print(tu[0])	#输出错误，不能索引

print（tu）#输出内存地址

print(next(tu))		#一个函数地址

print(next(tu)())		#输出0

print(next(tu)())		#输出1

lst = [lambda : i for i in range(3)]

print(lst[0]())

tu = (lambda : i for i in range(3))

print(next(tu)())

输出结果：

2

0

函数体中存放的是代码

生成器中存放的也是代码

--原因：yield导致函数和生成器的执行结果不一致

lst = [lambd x:x+5  for i in range(2)]

print([i(2) for i in lst])

解开顺序：

lst = []

for i in range (2):

    lst.append(lambda x :x+5)

new_list

for i in lst:

    print(i)		#两个函数的内存地址

    new_list.append(i(2))

print(new_list)		#输出列表【7，7】

输出结果：【7，7】

lst = (lambda x:x+5  for i in range(2))

print([i(2) for i in lst])

输出结果：【7，7】

lst = （lambda x:x*i  for i in range(2)）

print([i(2) for i in lst])		#【0，2】

lambda == def == 关键字
1. lambfa x: x
  - x:是普通函数的形参（位置，默认），可以写任意多个，也可以不写
  - ：后边是普通函数的返回值,必须写，没有默认，必须要有返回值，只能写一个数据类型

内置函数二（全记住）

内置函数

两个字典合并成一个：
1. update--- dic2.update(dic1)
2. 打散：-- print(dict( ** dic1, ** dic2))
3. print(dict([(1,2),(3,3)]))---括号里面的数字多一个少一个都不行，列表进行迭代，元祖也可以
4. dict( ** dict1, ** dict2)
set（）：将可迭代对象转换成元祖
sep() : 每一个元素之间的分割的方法
```
print(1,2,3,sep = "|")

输出结果：1|2|3
```

end：print执行完后的结束语句，默认\n

print(1,2,3,end = "")

print()

输出结果：全部在一行

print():屏幕输出
- flush -- 刷新

file：文件句柄，默认显示到屏幕

print (1,2,3,4,5,file = open ("test","w",encoding="utf-8"))

sum() -- 求和，必须是可迭代对象，对象中的元素必须为整型，字符串类型不能使用

print (sum ([1,2,3,1]))

print (sum ([1,2,3,1],100)		#100是起始值，就是从100开始进行取和，指定开始位置的值

abs() : 返回绝对值--转换成正数，不管你是不是负数
dir() : 查看当前对象具有什么方法

zip()：拉链，当可迭代对象的长度不一致时，选择最短的进行合并，可以是多个

面试题：

list1 =[1,2,3,4]

lst2 = ["alex","wusir","meet"]

print(list(zip(lst1,lst2)))

输出结果：[(1,"alex"),(2,"wusir"),(3,"meet")]

print(dict(zip(lst1,lst2)))	#返回一个字典

输出结果：{1:"alex",2:"wusir",3:"meet"}

format(): 格式转换

对齐方式

print(format("alex",">20"))	#右对齐

print(format("alex","<20"))	#左对齐

print(format("alex","^20"))	#居中

进制转换

print(format(10,"b"))		#十进制转二进制

print(format(10,"08b"))		#不够就补0

print (format(10,"08o"))		#oct,八进制

print (format(10,"08x"))		#hex，十六进制

print(format(0b1010,"d"))	#二进制转十进制

reversed() : 将一个序列进行翻转，返回翻转序列的迭代器

l = reversed('你好')  # l 获取到的是一个生成器

print(list(l))

ret = reversed([1, 4, 3, 7, 9])

print(list(ret))  # [9, 7, 3, 4, 1]

巴特西

从入门到自闭之Python内置函数

内置函数一

匿名函数：一行函数lambda（必背）

内置函数二（全记住）

内置函数

最新文章

热门文章