python — lambda表达式与内置函数

1 lambda表达式（匿名函数）
2 内置函数
- isinstance
super

1 lambda表达式（匿名函数）

用于表示简单的函数

lambda表达式，为了解决简单函数的情况：

def func(a1,a2):       =====> func = lambda a1,a2:a1+a2  # 函数直接得到返回值，这里隐藏了return

	return a1+a2       简化

# 三元运算，为了解决简单的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

func1 = lambda : 100 

func2 = lambda x1: x1 * 10

func3 = lambda *args,**kwargs: len(args) + len(kwargs)

DATA = 100

func4 = lambda a1: a1 + DATA

v = func4(1)

print(v)

DATA = 100

def func():

    DATA = 1000

    func4 = lambda a1: a1 + DATA

    v = func4(1)

    print(v)

func()

func5 = lambda n1,n2: n1 if n1 > n2 else n2

v = func5(1111,2)

print(v)

lambda表达式只能用一行来表示函数，只能用参数来作为变量。

练习题

# 练习题1

USER_LIST = []

def func0(x):

    v = USER_LIST.append(x)

    return v 

result = func0('alex')

print(result)

# 练习题2

def func0(x):

    v = x.strip()

    return v 

result = func0(' alex ')

print(result)

############## 总结：列表所有方法基本上都是返回None；字符串的所有方法基本上都是返回新值 #################

# 练习题3

USER_LIST = []

func1 = lambda x: USER_LIST.append(x)

v1 = func1('alex')

print(v1)

print(USER_LIST)

# 练习题4

func1 = lambda x: x.split('l')

v1 = func1('alex')

print(v1)

# 练习题5

func_list = [lambda x:x.strip(), lambda y:y+199,lambda x,y:x+y]

v1 = func_list[0]('alex ')

print(v1)

v2 = func_list[1](100)

print(v2)

v3 = func_list[2](1,2)

print(v3)

总结：

列表所有方法基本上都是返回None，字符串的所有方法基本上都是返回新值。

2 内置函数

函数分为：自定义函数和内置函数

目前python的内置函数分为几大类：

1.强制转换

bool() / int() / str() / list() / dict() /tuple() / set()
2.输入输出

print() / input()
3.其他

len() / open() / id() / range() / type()

4.数学相关

abs() 绝对值
```
v = abs(-1)

print(v)   # 1
```

float() 转换成浮点型（小数）

v = 55

v1 = float(v)

print(v1)    # 55.0

max() 找到最大值

v = [1,2,33,5,9]

result = max(v)

print(result)   # 33

min() 找到最小值

v = [1,2,311,11,8]

v2 = min(v)

print(v2)  # 1

sum() 求和

v = [1,2,311,11,9]

v1 = sum(v)

print(v1)  # 334

divmod() 两数相除的商和余数

a,b = divmod(1001,5)

print(a,b)   # 200  1

补充：字符串格式化：'你少妻-%s' %(i,) ------>后面%(i,)如果括号中只有一个变量，可以写成：'你少妻-%s' %i

# 练习题  请通过分页对数据进行展示

"""

要求：

    每页显示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)

7.pow

pow(x,y) 表示x的y次方
```
v = pow(2,3)

print(v)   # 8
```
8.round 保留小数点后几位小数，还会四舍五入。
```
V = round(1.127,1/2)

print(v)   # 1.1 / 1.13
```

5.进制转换相关

bin() 将十进制转换成二进制

num = 13

v1 = bin(num)

print(v1)  # 0b1101

oct() 将十进制转换成八进制

num = 8

v1 = oct(num)

print(v1)  # 0o10

int() 将其他的进制转换成十进制

# 二进制转化成十进制

v1 = '0b1101'

result = int(v1,base=2)

print(result)  # 13

# 八进制转化成十进制

v1 = '0o1101'

result = int(v1,base=8)

print(result)

# 十六进制转化成十进制

v1 = '0x1101'

result = int(v1,base=16)

print(result)

hex() 将十进制转换成十六进制

num = 16

v1 = hex(num)

print(v1)  # 0x10

练习题

# 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

ip = "192.168.12.79"

ip1 = ip.split('.')

lis = []

for i in ip1:

    lis.append(bin(int(i)))

# val = ','.join(lis)

# b = val.replace('0b', '')

# b1 = b.split(',')

b1 = ','.join(lis).replace('0b', '').split(',')

e = []

#f or c in b1:

for c in ','.join(lis).replace('0b', '').split(','):

    if len(c) < 8:

        val = 8 - len(c)

        d = list(c)

        d.insert(0,'0' * val)

        d1 = ''.join(d)

        e.append(d1)

    else:

        e.append(c)

f = ''.join(e)

f1 = int(f,base = 2 )

print(f1)

6.编码相关

chr 将十进制数字转换成Unicode编码中的对应字符串
```
v = chr(65)

print(v)   # A
```
ord 根据字符在Unicode编码中找到其对应的十进制
```
v = ord('中')

print(v)    # 20013
```

应用：

import random

v = random.randint(65,90)

print(v)   # 随机获得65~90之间的数字

import random

data = []

for i in range(6)

	v = random.randint(65,90)

    data.append(chr(v))

print(''.join(data))   # 6位随机字符串验证码

import random

def get_random_code(length=6):

    data = []

    for i in range(length):

        v = random.randint(65,90)

        data.append(chr(v))

    return  ''.join(data)

code = get_random_code()

print(code)    # 6位随机字符串验证码

import random # 导入一个模块 

v = random.randint(起始,终止) # 得到一个随机数

7.高级一点的内置函数

map 循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

V1 = [11,22,33,44]

# map(x,v1) 第一个参数必须是函数，第二个参数必须是可迭代类型（可以被for循环的）

def func(arg):

    print(arg)

# map(func,v1)    # 执行后并不打印arg,这是py3的一个特性，py3现在还不执行以后会执行

result = map(func,v1)  # 然后将函数的返回值添加到一个[]中

# print(result)  py2会直接返回列表

# print(result)  py3不会，会得到一个对象/东西，想返回列表的话需要强制转换成列表

print(list(ruselt))  # result得到的是一个对象<map.objecta……>，需要list()才能打印列表

v1 = [11,22,33,44]

result = map(lambda x:x+100,v1)

print(list(result)) # 特殊

filter

result = filter(函数，参数)

v1 = [11,22,33,'asd',44,'xf']

def func(x):

    if type(x) == int:

        return True

    return False

result = filter(func,v1) # [11,22,33,44]

print(list(result))

result = filter(lambda x: True if type(x) == int else False ,v1)

print(list(result))

result = filter(lambda x: type(x) == int ,v1)

print(list(result))

reduce 累计得到一个结果

reduce现在不在py3的内置函数种了，但py2的内置函数里包含。

import functools

v1 = ['wo','hao','e']

def func(x,y):

    return x+y

result = functools.reduce(func,v1)

print(result)

result = functools.reduce(lambda x,y:x+y,v1)

print(result)

8.类相关的

type，查看类型

class Foo:

    pass

obj = Foo()

if type(obj) == Foo:

    print('obj是Foo类的对象')

issubclass

判断某个类是不是另一个类或其基类的子类。

issubclass(类1，类2) 类1—>子类名，类2—>基类名

class Base:

    pass

class Base1(Base):

    pass

class Foo(Base1):

    pass

class Bar:

    pass

print(issubclass(Bar,Base))

print(issubclass(Foo,Base))

isinstance

判断某个对象是否是某个类或其基类的实例（对象）

class Base(object):

    pass

class Foo(Base):

    pass

obj = Foo()

print(isinstance(obj,Foo))  # 判断obj是否是Foo类或其基类的实例（对象）

print(isinstance(obj,Base)) # 判断obj是否是Foo类或其基类的实例（对象）

super

class Base(object):

    def func(self):

        print('base.func')

        return 123

class Foo(Base):

    def func(self):

        v1 = super().func()

        print('foo.func',v1)

obj = Foo()

obj.func()

# super().func() 去父类中找func方法并执行

class Bar(object):

    def func(self):

        print('bar.func')

        return 123

class Base(Bar):

    pass

class Foo(Base):

    def func(self):

        v1 = super().func()

        print('foo.func',v1)

obj = Foo()

obj.func()

# super().func() 根据类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

class Base(object): # Base -> object

    def func(self):

        super().func()

        print('base.func')

class Bar(object):

    def func(self):

        print('bar.func')

class Foo(Base,Bar): # Foo -> Base -> Bar

    pass

obj = Foo()

obj.func()

# 多继承

# super().func() 根据self对象所属类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

super().要查找的方法

super().func() 根据self对象所属类的继承关系（从左向右依次查找），按照顺序挨个找func方法并执行(找到第一个就不再找了)

super 遵循mro顺序查找上一个类的

supper().func()不是查找父类，而是根据mro顺序，找到自己对应的下一个类