匿名函数，内置函数

Ⅰ 匿名函数

匿名函数的意思就是没有函数名 
	需要结合其他函数一起使用

【1】函数分类

# 【1】有名函数
def login():
    ...
login()

# 【2】匿名函数(无名函数)
# 语法：lambda 参数: 表达式
# lambda ： 匿名函数的关键字
# 参数可以放位置参数关键自残术 ...
# 表达式 ： 其实本质上是返回值

【2】定义匿名函数

lambda x: x+2  # (不能单独使用)
'''
lambda 形参:返回值

如果用普通函数来表示
def index(x)
	return x + 2
'''

# max:统计最大值
l1 = [11,22,41,21,24,23,15,16,18,57,41,22]
print(max(l1)) # 57 # 直接获取数据集中最大的元素值

【3】匿名函数介绍

info = {
    'Ason': 55555555,
    'joc': 123,
    'zark': 1000,
    'berk': 22
}
# 求薪资最高的人的姓名
print(max(info))  # zark
'''
max底层可以看成是for循环依次比较，针对字典默认只能取到key
获取到key之后如果是字符串的英文字母  则会按照ASCII码表转成数字比较
        A~Z:65-90
        a~z:97-122
'''


def index(k):
    return info[k]


print(max(info, key=index))  # Ason
# key对应的函数返回什么，max就以什么作为比较依据 比较的是v 返回的是k

# 上述代码可以简写 因为函数功能很单一
print(max(info, key=lambda k: info[k]))

# def add(x):
#     return x + x

# add = lambda x: x + x
#
# print([i + i for i in range(10)])
# print([add(i) for i in range(10)])

# def lll(x):
#     if x % 2 == 1:
#         return x

# 配合高阶函数使用
# def add(x):
#     if x % 2 == 0:
#         return x + x

# filter 过滤后面的参数 如果范湖IDE结果为True 保留 否则删掉
# templist = filter(lambda x: x % 2 == 1, [1, 2, 3, 4, 5, 6, 7, 8, 9])
# templist = filter(add, [1, 2, 3, 4, 5, 6, 7, 8, 9])
# templist = filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])
# print(list(templist))  # [1, 3, 5, 7, 9]

Ⅱ 内置函数

# 内置函数就是python开发者当时开发Python解释器的时候内置的函数

【1】数据类型强制转换 （8）

# 【1】str() str() 将数据转化成字符串 print(str(123)+'456')  #123456
# 【2】int() int : 整型(整数) 
# 【3】float()  float : 浮点型(小数) 
# 【4】list()  list() 将一个可迭代对象转换成列表
# 【5】tuple()  tuple() 将一个可迭代对象转换成元组
# 【6】bool()  bool: 布尔类型(True / False)
# 【7】set()   set() 函数用于创建一个集合，自动去除重复元素。
# 【8】dict()  dict() 函数可接受可迭代对象，用键值对初始化字典。

【2】进制 (3)

# 【1】bin 十进制转二进制  bin() 将给的参数转换成二进制
print(bin(999)) # 0b 1111100111
# 【2】oct 十进制转八进制
print(oct(999)) # 0o 1747
# 【3】hex 十进制转十六进制
print(hex(999)) # 0x 3e7

【3】数学运算 (8)

# 【1】获取绝对值 (abs)
print(abs(-9))
# 9
# 【2】商和余数 (divmod)
# divmod(被除数,除数)
print(divmod(9, 2))
# (4, 1)
print(divmod(2, 9))
# (0, 2)
# 【3】四舍五入 (round)
# 四舍五入的时候如果后面的数字大于5进1
print(round(4.60))  # 5
# 四舍五入的时候如果后面的数字小于5不进1
print(round(4.40))  # 4
# 四舍五入的时候如果后面的数字等于5 5后面的数字如果大于0 进1
print(round(4.51))  # 5
# 四舍五入的时候如果后面的数字等于5 5后面的数字如果不大于0 不进1
print(round(4.50))  # 4

# 控制小数点的位数 ---> 不管是 0 / 1 都能进
# 四舍五入的时候如果后面的数字大于5进1
# 这一次我们在 round() 函数中加入了可选的第二个参数。
# 这里我们把  作为第一个参数，把 1 作为第二个参数。
# 我们可以看到，对 4.051 的值为 4.1
print(round(4.051, 1))
# 我们可以看到，对 4.050 的值为 4.0
print(round(4.050, 1))
# 我们可以看到，对 4.049 的值为 4.0
print(round(4.049, 1))

# 【4】幂次方 (pow)
# 两个参数的是获取到当前的幂次方
print(pow(2, 4))  # 16  等价 2*2*2*2 = 16
#  三个参数的时候获取到的是当前幂次方的余数
# 16 / 5 = 3 .. 1
print(pow(2, 4, 5))  # 1  等价 2*2*2*2%5 = 16 % 5 = 1
'''
参数介绍：
    x — 数值表达式(整数或者浮点数)；
    y — 数值表达式(整数或者浮点数)；
    z — 数值表达式(整数或者浮点数)，默认不设置z值；
返回值：返回 xy(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) % z；
'''
# 【5】求和 (sum)
# 参数是可迭代类型
num_list = [i for i in range(10)]
print(sum(num_list))  # 45
print(sum(tuple(num_list)))  # 45

# 【6】最小值 (min)
num_list = [0,1,2,3,4,5,6,7,8,9]
print(min(num_list))  # 0
# 【7】最大值 (max)
num_list = [0,1,2,3,4,5,6,7,8,9]
print(max(num_list))  # 9

# 【8】复数转换(complex)
start = complex(3, 4)
print(start)  # (3+4j)
end = complex(5, 6)
print(end)  # (5+6j)

print(start + end)  # (8+10j)
print(start - end)  # (-2-2j)
print(start * end)  # (-9+38j)

【4】数据结构相关 (5)

# （1）翻转 (reversed)
import random

list_num = [i for i in range(10)]
random.shuffle(list_num)
print(list_num)  # [8, 2, 9, 6, 0, 3, 4, 5, 7, 1]
# list_num.reverse()
print(list(reversed(list_num)))  # [1, 7, 5, 4, 3, 0, 6, 9, 2, 8]
print(list_num)  # [8, 2, 9, 6, 0, 3, 4, 5, 7, 1]

# （2）切片 (slice)
import random

list_num = [i for i in range(10)]
random.shuffle(list_num)
print(list_num[1:5:2])  # [2, 6]
print(slice(1, 5, 2))  # slice(1, 5, 2)
print(list_num[slice(1, 5, 2)])  # [2, 6]

# （3）计算长度 (len)
import random

list_num = [i for i in range(10)]
random.shuffle(list_num)
print(len(list_num))  # 10

# （4）排序(sorted)
# 语法：sorted(Iterable, key=函数(排序规则), reverse=False)
# Iterable: 可迭代对象,key: 排序规则(排序函数),reverse: 是否是倒叙. True: 倒叙, False: 正序
list_num.sort() 
print(sorted(list_num)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# key : A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.

lst = [5, 7, 6, 12, 1, 13, 9, 18, 5]

# sort是list里面的一个方法, sort 方法没有返回值
lst.sort()
print(lst)
# [1, 5, 5, 6, 7, 9, 12, 13, 18]

# 内置函数. 返回给你一个新列表  新列表是被排序的
ll = sorted(lst)
print(ll)
# [1, 5, 5, 6, 7, 9, 12, 13, 18]

# 倒序
l2 = sorted(lst, reverse=True)
print(l2)
# [18, 13, 12, 9, 7, 6, 5, 5, 1]

# 根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']

def f(s):
    return len(s)

print(sorted(lst))  # ['five', 'four', 'one', 'six', 'three', 'two']
# 按照字符串的长度排序
l1 = sorted(lst, key=f)
print(l1)  # ['one', 'two', 'six', 'four', 'five', 'three']
l1 = sorted(lst, key=lambda s: len(s))
print(l1)  # ['one', 'two', 'six', 'four', 'five', 'three']

user_data = {
    'username': "silence",
    "age": '18',
    "gender": "male",
    "hobby": "listen"
}
print(sorted(user_data))  # ['age', 'gender', 'hobby', 'username']


def aaa(item):
    return len(item[1])


print(sorted(user_data.items(), key=aaa))  # ['age', 'gender', 'hobby', 'username']
print(sorted(user_data.items(), key=lambda item: len(item[1])))  # ['age', 'gender', 'hobby', 'username']

# （5）枚举函数(enumerate)
list_num_list = [i for i in range(10, 20)]
# 把索引和元素一起获取,索引默认从0开始. 可以更改
# 下面更改默认索引从 0 开始

for index, data in enumerate(list_num_list):
    print(f"这是第 {index} 个人 :>>>> {data}")

for index, data in enumerate(list_num_list, start=1):
    print(f"这是第 {index} 个人 :>>>> {data}")

【5】字符串相关 (4)

# （1）格式化输出(format)
# 居中对齐
s = 'hello world'
print(format(s, '^20'))
# 左对齐
print(format(s, '<20'))
# 右对齐
print(format(s, '>20'))

# 进制转换
print(format(3, 'b'))  # 二进制:11
print(format(97, 'c'))  # 转换成unicode字符:a
print(format(11, 'd'))  # ⼗进制:11
print(format(11, 'o'))  # 八进制:13
print(format(11, 'x'))  # 十六进制(⼩写字母):b
print(format(11, 'X'))  # 十六进制(大写字母):B
print(format(11, 'n'))  # 和d⼀样:11
print(format(11))  # 和d⼀样:11

print(format(123456789, 'e'))  # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e'))  # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E'))  # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f'))  # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f'))  # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F'))  # 小数点计数法. 很大的时候输出INF:1234.567890

# （2）字符串转bytes(bytes)
print(bytes('hello world', 'utf-8'))  # b'hello world'
print(bytes('你好', 'utf-8'))  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

# （3）获取字节数组(bytearray)
ret = bytearray("silence", encoding='utf-8')
print(ret[0])
# 115

print(ret)
# bytearray(b'silence')

ret[0] = 65
# 把65的位置A赋值给ret[0]  bytearray(b'Ailence')

print(str(ret))
# bytearray(b'silence')

# （4）返回对象的字符串格式(repr)
word = "今天\n吃了%s顿\t饭" % 3
print(word)
# 今天
# 吃了3顿	饭

# 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
print(repr(word))
# '今天\n吃了3顿\t饭'

【6】字符编码相关 (3)

# 【1】根据字符编码找数字 ---> 去ASCII码表中查数据
print(ord('a'))
# 字母a在编码表中的码位:97

print(ord('中'))
# '中'字在编码表中的位置:20013
# 【2】根据数字找字符编码 ---> 去ASCII码表中查数据
print(chr(65))
# 已知码位,求字符是什么:A

print(chr(19999))
# 丟

# 【3】ascii() 是ascii码中的返回该值 不是就返回u
for i in range(65536):  #打印出0到65535的字符
    print(chr(i), end=" ")

print(ascii("@"))  #'@'

【7】输入输出函数

input()
print()
input() : 获取用户输出的内容
print("hello", "world", sep="*", end="@") 
# sep:打印出的内容用什么连接
# end:以什么为结尾
# hello*world@

【8】算法

# 获取到对象的哈希值(int, str, bool, tuple).
# hash : 不可变数据类型
print(hash('silence')) # -1123303696807410989

# 哈希的目的就是为了唯一性
# 字典的内部原理 --> 字典的键的内部原理就是哈希

【9】文件操作

open() 用于打开一个文件, 创建一个文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()

【10】导入模块

import()
# 让用户输入一个要导入的模块
name = input("请输入你要导入的模块:")
json = __import__(name)
# 可以动态导入模块
print(json.dumps({"name": "silence"}))

# {"name": "silence"}

【11】帮助函数

help() : 函数用于查看函数或模块用途的详细说明
# 查看字符串的用途
print(help(dict))

【12】调度函数

# 判断当前变量名是否可以被调用
# callable() : 用于检查一个对象是否是可调用的
# 如果返回True, object有可能调用失败
# 但如果返回False. 那调用绝对不会成功
a = 10
# 变量a不能被调用
print(callable(a))
# False  

def f():
    print("hello")
# 函数是可以被调用的
print(callable(f))
# True

name = 'silence'
def ad():
    print('ad')

class A():

# 能被 () 直接调用的就是True
print(callable(name))  # False
print(callable(ad))  # True
print(callable(A))  # True

【13】dir方法

# 查看变量名的属性
# 访问的是对象中的 __dir__() 方法
print(dir(ad))
ad.__call__() # ad() == ad.__call__()
print(ad.__name__) # ad 获取当前函数的名字

【14】获取当前变量的内存地址

print(id('silence'))

【15】异步迭代函数(aiter) 废弃

【16】next异步变体(anext) 废弃

【17】调试器(breakpoint)

#调用sys.breakpointhook()，直接传递args和kws
# 语法
breakpoint(*args, **kws)
参数介绍：
*args, **kws---不定长参数
返回值：
# 示例

# 以前
foo()
import pdb; pdb.set_trace()
bar()

# 现在
foo()
breakpoint()
bar()

# *args, **kws --- 不定长参数区别
def f(arg,*args,**kwargs):
    print(arg,args,kwargs)
f(1,2,4,5,a=1,b=2)

# 1 (2, 4, 5) {'a': 1, 'b': 2}