函数Ⅲ(内置函数&lambda表达式)

# 1.函数小高级

函数可以当做变量来使用:

def func():
	print(123)
func_list = [func, func, func]
# func_list[0]()
# func_list[1]()
# func_list[2]()
for item in func_list:
	v = item()
	print(v)

1
2
3
4
5
6
7
8
9

函数可以当做参数进行传递,谁调用的函数返回值就给谁.

def func(arg):
	print(arg)
func(1)
func([1,2,3,4])
def show():
	return 999
func(show)

1
2
3
4
5
6
7

子作用域只能读取或修改父级的值，不能重新赋值。

#经典例题 ---------------企业面试题--------

def func():
    print('花费查询')
def bar():
    print('语音沟通')
def base():
    print('xxx')
def show():
    print('xxx')
def test():
    print('xxx')
info = {
    'f1': func,
    'f2': bar,
    'f3':base,
    'f4':show,
    'f5':test
}
choice = input('请选择要选择功能：')
function_name = info.get(choice)
if function_name:
    function_name()
else:
    print('输入错误')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 2.lambda表达式

# 三元运算，为了解决简单的if else的情况，如：
if 1 == 1:
    a = 123
else:
    a = 456

a =  123  if 1 == 1 else 456		#经典格式

# lambda表达式，为了解决简单函数的情况，如：
def func(a1,a2):
    return a1 + 100 

func = lambda a1,a2: a1+100			#经典格式

1
2
3
4
5
6
7
8
9
10
11
12
13

列表所有方法返回值基本都是None,出了pop会返回要删除的元素

字符串所有方法返回值基本都是新值

# 练习题
USER_LIST = []
func1 = lambda x: USER_LIST.append(x)

v1 = func1('alex')
print(v1)
print(USER_LIST)

# 练习题
func1 = lambda x: x.split('l')

v1 = func1('alex')
print(v1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 3.内置函数

自定义函数

内置函数:

内置函数	含义
len,open,range,id,type print,input,强制转换命令	...
abs()	绝对值
float()	浮点型
max()	最大值
min()	最小值
sum()	求和
divmod()	两数相除的商和余数(页面选择)
pow()	指数运算pow(2,3)= 2**3=8
bin()	十进制转化为二进制
oct()	十进制转化为八进制
int()	其他进制转化为十进制
hex()	十进制转化为十六进制
chr()	十进制数字转换成unicode编码中的对应字符串
ord()	根据字符在unicode编码中找到其对应的十进制

len,open,range,id,type
print,input
强制转换

数学相关

abs，绝对值
```
v = abs(-1)
print(v)
```
1
2
float，转换成浮点型（小数）
```
v = 55
v1 = float(55)
print(v1)
```
1
2
3

max，找到最大值

v = [1,2,311,21,3,]
result = max(v)
print(result)

1
2
3

min，找最小值

v = [1,2,311,21,3,]
result = min(v)
print(result)

1
2
3

sum，求和

v = [1,2,311,21,3,]
result = sum(v)
print(result)

1
2
3

divmod，两数相除的商和余数

a,b = divmod(1001,5)
print(a,b)

1
2

# 经典______________练习题  请通过分页对数据进行展示
"""
要求：
    每页显示10条数据
    让用户输入要查看的页面：页码
"""

USER_LIST = []
for i in range(1,836):
    temp = {'name':'你少妻-%s' %i,'email':'123%s@qq.com' %i }
    USER_LIST.append(temp)

# 数据总条数
total_count = len(USER_LIST)

# 每页显示10条
per_page_count= 10

# 总页码数
max_page_num,a = divmod(total_count,per_page_count)
if a>0:
    max_page_num += 1

while True:
    pager = int(input('要查看第几页：'))
    if pager < 1 or pager > max_page_num:
        print('页码不合法，必须是 1 ~ %s' %max_page_num )
    else:
        """
        # 第1页：USER_LIST[0:10] -> 0123456789
        # 第2页：USER_LIST[10:20]
        # 第3页：USER_LIST[20:30]
        ...
        """
        start = (pager-1) * per_page_count
        end = pager * per_page_count
        data = USER_LIST[start:end]
        for item in data:
            print(item)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

进制转换:
十进制数转化为其他进制时十进制数必须是整型.

其他进制转化为十进制时其他进制数必须是字符串,并在字符串后注明多少进制.

bin，将十进制转化成二进制
```
num = 13
v1 = bin(num)
print(v1)
```
1
2
3
oct，将十进制转换成八进制,
```
num = 8
v1 = oct(num)
print(v1)
```
1
2
3

int，将其他进制转化成十进制

# 二进制转化成十进制
v1 = '0b1101'
result = int(v1,base=2)
print(result)

# 八进制转化成十进制
v1 = '0o1101'
result = int(v1,base=8)
print(result)

# 十六进制转化成十进制
v1 = '0x1101'
result = int(v1,base=16)
print(result)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

hex，将十进制转换成十六进制
```
num = 16
v1 = hex(num)
print(v1)
```
1
2
3

----企业面试题------

# 1字节等于8位
# IP: 192.168.12.79  ->  001010010 . 001010010 . 001010010 . 001010010

# 1. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串。
ip = "192.168.12.79"
ip_list = ip.split('.') # ['192','168','12','79']
result = []
for item in ip_list:
    result.append(bin(int(item)))
print(','.join(result))


# 2. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制: 
#          0010100100001010010001010010001010010 -> 十进制的值。

# 3232238671

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 小结

函数当作是一个变量：参数传值 / 当元素嵌套到字典列表中。 5*
lambda 表达式 3*
内置函数 3*

#Python #

上次更新: 2023/04/16, 18:35:33

← 函数Ⅱ(参数&作用域) 函数Ⅳ(闭包&内置模块)→