内置函数

1、函数参数，引用
2、lambda表达式
3、python内置函数
4、递归
5、作业

1、lambda表达式

def f1():
return 123

print(f1())

f2 = lambda : 123
r = f2()
print(r)

def f3(a1, a2):
return a1 + a2

r3 = f3()
print(r3)

f4 = lambda a1,a2: a1 + a2
r4 = f4()
print(r4)

 

2、内置函数

abs(123) #取绝对值
print(all([0,1,2])) #循环参数，如果每个元素都为真，返回真，否则false
# 如何判断元素是否为真
# 假：0,none,"",[],(),{}----->>:0,none,空值为假
print(bool(0))
print(bool(-1))
print(bool(1))
print(bool([]))
print(bool(()))
print(bool({}))

print(any([{}, (), 0, None, 1])) # 循环参数，只要一个为真即为真
li = []
r = ascii(li) # 返回对应参数的类的__repr__方法的返回值
print(r)
# #
print(bin(10)) # 十进制数10转成二进制
print(hex(10)) # 十进制数14转换成十六进制
print(oct(8)) # 十进制数8转换成八进制
print(int(10)) # 十进制数10转换成十进制

# 进制之间转换
i = int('0b11', base=2) # 二进制0b11转换成十进制
print(i)

i = int('0o11', base=8) # 八进制0o11转换成十进制
print(i)

i = int('0xe', base=16) # 十六进制11转换成十进制
print(i)

i = chr(66) # 接收一个数字，返回对应的ASCII码中的对应值
print(i)

i = ord('t')
print(i)

r = callable('s') # 如果传入的参数可以被执行，返回True，否则False。比如函数加括号可以被执行
print(r)

# compile() #用来编译代码
dir([]) # 查看传入的对象有什么方法
# help([]) # 帮助
r = divmod(10, 3) # 返回两个参数的商和余数的元组，在分页中用
print(r)

ret = eval('1 + 3') # 将字符串转换成表达式，并返回结果。即eval可以执行一个字符串形式的表达式
ret1 = eval("a + 60", {'a': 99})
print(ret)
print(ret1)

exec("for i in range(10):print(i)") # 把参数当代码执行，但没有返回值

filter(函数， 可迭代对象) # 循环可迭代对象，将迭代对象的元素当做参数，传到函数中，如果函数返回true，则把该元素当做列表的元素返回#
def f1(x):
# if x > 22:
# return True
# else:
# return False
return x > 22


# ret = filter(f1, [11, 22, 33, 44])
# for i in ret:
# print(i)
ret = filter(lambda x: x > 22, [11, 22, 33, 44])
for i in ret:
print(i)


map(函数，可迭代对象) 循环迭代对象的每个元素传入函数中，并返回每个元素的返回值

def f2(x):
return x + 100

ret = map(f2, [1,2,3,4,5])
ret = map(lambda x: x + 100, [1,2,3,4,5])
print(ret)
print(type(ret))
for i in ret:
print(i)

# isinstance() # 判断对象是否由某个类创建的
li = []
i = isinstance(li, list)
print(i)

i = pow(2, 10) # 2的10次方
print(i)

r = round(3.33) # 四舍五入
print(r)

 

3、随机验证码

 

import random
temp = ''
for x in range(6):
xx = random.randrange(0, 4) # 生成0-3的随机数
if xx == 1 or xx == 3: # 如果等于1或者3，就生成数字，否则生成字母
i = random.randrange(0, 10)
temp += str(i)
else:
i = random.randrange(65, 91)
rad = chr(i)
temp += rad
print(temp)

 4、作业

# 三目运算、三元运算
if 1 == 1：
    name = 'alex'
else:
    name = 'eric'
    
name = 值1 if 条件 else 值2

#2、函数
#    定义函数
#    def 函数名(形参):
#        函数体
#        return 返回值
#    执行函数调用
#    函数名(实参)
#    
#、如果实参没有关键字，则按默认顺序
#
#、形参默认值，默认参数需要放在后面
#
#、动态参数
#    *args，元组，元组的元素
#    **kwargs，字典类型
def f1(a, *args, **kwargs):
    print(a, type(a))
    print(args, type(args))
    print(kwargs, type(kwargs))

f1('aa', 'adf', 'afa', [11,3,4], k1 = 'adf', k2 = '333')

#局部变量全局变量
#    全局变量：
#        大写
#        修改global
#    局部变量：
#        小写，仅在代码块中能用
#
#5、深浅拷贝
#    1、数字和字符串
#    对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。
#    2、其他基本数据类型
#    对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。
#        
#        
#1、简述普通参数、指定参数、默认参数、动态参数的区别
#    普通参数：按顺序获取参数值
#    指定参数：按照关键字参数一一对应，不一定是按照位置参数
#    默认参数：在参数的末尾
#    动态参数：可以接受多个参数，*args：可以接受多个参数，**kwargs：键值对形式传参
#
#2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def fun_num(p):
    isdigit_num = 0
    isalnum_num = 0
    isspace_num = 0
    others_num = 0
    for i in p:
        if i.isdigit():
            isdigit_num += 1
        elif i.isalnum():
            isalnum_num += 1
        elif i.isspace():
            isspace_num += 1
        else:
            others_num += 1
    return (isdigit_num, isalnum_num, isspace_num, others_num)
    
ret = fun_num('sdfa123afaa,.09()')
print(ret)

#3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
def fun_objectnum(p):
    if isinstance(p, str) or isinstance(p, list) or isinstance(p, tuple)    # isinstance()判断对象是否由某类创建的
    if len(p) > 5:
        return True
    else:
        return False

li = [1,23,1,1,123,2]
ret = fun_objectnum(li)
print(ret)

#4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
def check_space(s):
    for i in s:
        if i.isspace:
            print('空格啦。。。')
            return True    # 只要有空格就停止
        else:
            return False

            
ret = check_space('ahfi add 23')
print(ret)

def check_space(arg):
    ret = true
    for c in arg:
        if c.isspace:
            ret = False
            break
    return ret

#5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
def check_len(s):
    print(len(s))
    if len(s) > 2:
        return s[0:2]
    else:
        print("{0} is too short with len {1}".format(s, len(s)))
s = [1,3]
ret = check_len(s)
print(ret)

#6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
def check_index(p):
    li = []
    for i in range(len(p)):
        print(i)
        if i % 2 == 1:
            print(i)
            li.append(p[i])
        else:
            pass
    return li
s = [1,23,13,4,123,123,1,5,2356]
ret = check_index(s)
print(ret)

def check_index(p):
    li = []
    for index, i in enumerate(p):
        print(index)
        if index % 2 ==1:
            li.append(p[index])
        else:
            pass
    return li
s = [1,23,13,4,123,123,1,5,2356]
ret = check_index(s)
print(ret)

#7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表

def check_value(arg):
    ret = {} 
    for key, value in arg.items:
        if len(value) > 2:
            ret[key] = value[0:2]
        else:
            ret[key] = value
    return ret

dic = {"k1":"v1v1", "k2":[11,22,33,44], 'k3':'12'}
ret = check_value(dic)    
print(ret)
#8、写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。