内置函数和匿名函数

内置函数和匿名函数

 内置函数的思维导图https://www.processon.com/view/5bdbfba6e4b0e452133837a3#map

内置函数:python自带的函数

作用域相关

基于字典的形式获取局部变量和全局变量

globals()——获取全局变量的字典

• any()　

如果所有元素中有一个值非0、''或False，那么结果就为True，当iterable所有的值都是0、''或False时，那么结果为False

•  ascii()　　

调用对象的__repr__()方法，获得该方法的返回值.

• bool()　　

测试一个对象是True还是False.

•  bytes()　　

将一个字符串转换成字节类型

• callable(object)

callable()函数用于测试对象是否可调用，如果可以则返回1(真)；否则返回0(假)。可调用对象包括函数、方法、代码对象、类和已经定义了 调用 方法的类实例。

• chr(i)

chr()函数返回ASCII码对应的字符串。

• complex(real[,imaginary])

complex()函数可把字符串或数字转换为复数。

• delattr()　　

删除对象的属性

• dict()　　

创建数据字典

• dir()　　

不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表

• divmod(x,y)

divmod(x,y)函数完成除法运算，返回商和余数。

• enumerate()　　

返回一个可以枚举的对象，该对象的next()方法将返回一个元组

• eval()　　

将字符串str当成有效的表达式来求值并返回计算结果

s = "1 + 3 +5"
print(eval(s))　　#9

• exec()　　

执行字符串或complie方法编译过的字符串，没有返回值

• float(x)

float()函数把一个数字或字符串转换成浮点数。

print(float("12"))　　#12.0

• format()　　

格式化输出字符串

print("i am {0},age{1}".format("tom",18))

i am tom,age18

• frozenset()　　

创建一个不可修改的集合

       set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set，

       一般来说使用fronzet的地方都可以使用set。

       参数iterable：可迭代对象。

• hex(x)

hex()函数可把整数转换成十六进制数。

locals()——获取执行本方法所在命名空间内的局部变量的字典

def func():
    a = 1
    b = 2
    print(locals())　　　　 
    print(globals())　　　　#始终不变
　　func(){'b': 2, 'a': 1}

　　{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 　　　　　　0x00　　000　　226639E59E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__ 　　'_　　_cac　　hed__': No　　ne, 'func': <function func at 0x0000022663AB89D8>}

其他

eval() 将字符串类型的代码执行并返回结果

print(eval('1+2+3+4'))　　　　#10

 

 s.upper()全大写，全小写s.lower()全小写

s.swapcase()大小写翻转

s.title()每个隔开(特殊字符或者数字)的单词首字母大写
s.center(20,'~')居中

s6 = s.expandtabs()空白填充

以什么开头s.startswith('alex')startswith('e',2,5)结尾endswith

strip 默认删除前后空格

split   str ---->list  s.split('a)以a分割符

find 通过元素找索引，找不到返回-1 s = 'alexWUsir' s.find('A')
index通过元素找索引，找不到报错

增加 append insert
元祖 只读列表，可循环查询，可切片。
儿子不能改，孙子可能可以改。
list.reverse()
反向列表中元素

数据类型划分：可变数据类型，不可变数据类型
不可变数据类型：元组，bool int str 可哈希
可变数据类型：list，dict set 不可哈希
dict key 必须是不可变数据类型，可哈希，
value：任意数据类型。
dict 优点：二分查找去查询
存储大量的关系型数据
特点：无序的

# 操作文件
# 读
# read 一次性读
# readlines 一次性读
# readline 一行一行读
#不知道在哪儿结束
#视频 图片 rb bytes 按照字节读
# for循环 —— 最好！！！
# 写
# write
# 光标 —— 文件指针
#seek _ 指定光标移动到某个位置
#tell _ 获取光标当前的位置
#truncate _ 截取文件
# 关闭文件
#close
rename()方法需要两个参数，当前的文件名和新文件名。
remove()方法删除文件，需要提供要删除的文件名作为参数

exec()将自字符串类型的代码执行

print(exec("1+2+3+4"))　　　　#没有返回值，结果None
exec("print('hello,world')")　　#hello,world

compile  将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

参数说明：　　　

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　

2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。　　

3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。

exec("print('12345')")　　#12345
eval("print('12345')")　　#12345
print(exec('1+2+3-4'))　　#None
print(eval('1+2+3-4'))　　#2

code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec(compile1)        #0 1 2 3 4 5 6 7 8 9

#简单求值表达式用eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
print(eval(compile2))

code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
# # name #执行前name变量不存在
exec(compile3)
print(name)　　　　#name在pycharm里飘红，但是可以执行please input your name:

range#可迭代对象，可以for循环，惰性运算

# range(100)  #[0,100)
# range(5,100) #[5,100)
# range(1,100,2)
#可迭代对象，可以for循环，惰性运算
# def iter():    #定义迭代器
#     return range(100).__iter__()

iterator = iter(range(100))  #拿到一个迭代器
print(iterator.__next__())　　　#0　　　　
print(next(iterator))　　　　　　#1

for i in range(100):
    print(i)　　　　　　　　#for循环迭代每一个元素

dir查看参数所属类型的所有内置方法

dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量

print(dir(list))  #查看列表的内置方法
print(dir(int))  #查看整数的内置方法

callable

和调用相关

callable(o)，o是参数，看这个变量是不是可调用。

如果o是一个函数名，就会返回True

a = 1
def func():pass
print(callable(a))      #不可以调用
print(callable(print))  #可以调用
print(callable(func))   #可以调用

查看关键字用法

ctrl + 左键单击 ：pycharm
help：包含所有方法名以及他的使用方法 —— 不知道用法的情况下

在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入quit退出

或者直接执行help(o)，o是参数，查看和变量o有关的操作

dir：只包含方法名 —— 想查看某方法是否在这个数据类型中

import 引用模块

import time   #时间
import os     #操作系统

open()  打开一个文件，返回一个文件操作符

操作文件的模式有r,w,a,rb,wb,ab

可以用encoding指定编码.utf-8，gbk

f = open('文件名','w',encoding='utf-8')

input输入，输入内容是字符串

s = input("请输入内容 ： ") 
print(s)  

print输出打印

print(self, *args, sep=' ', end='
', file=None):
    """
    print(value, ..., sep=' ', end='
', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """

f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)

##打印进度条
import time
for i in range(0,101,2):  
     time.sleep(0.2)
     char_num = i//2      #打印多少个'*'
     per_str = '
%s%% : %s
' % (i, '*' * char_num) if i == 100 else '
%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)
#
 可以把光标移动到行首但不换行

type(o)返回变量o的数据类型


id(o)返回变量o的内存地址
hash(o)返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错

数字相关

数字——数据类型相关：bool(布尔型)，int(整型)，float(浮点型)，complex(复数)，一般用于强转类型

　　　　进制转换相关：bin(二进制)，oct八进制()，hex(十六进制)，一般用于强转类型

　　　　数学运算：abs(绝对值)，divmod(取商和余)，min(最小值)，max(最大值)，sum(求和)，round(取几位小数)，pow(幂运算)

abs 取绝对值

print(abs(-5))　　#5

divmod 取商余

ret = divmod(10,2)　　
print(ret)　　#(5, 0)

ret = divmod(3,2) 
print(ret)　　#(1, 1)

ret = divmod(7,2) 
print(ret)　　#(3,1)

round 取几位小数

print(round(3.14159,2))　　#取小数位数，后面的2表示去几位小数，结果为3.14

pow 幂运算

print(pow(2,3.5))  #可以是小数，结果11.313708498984761
print(pow(3,2))　　#9print(pow(2,3,3))  #x**y%z结果2

sum 求和，接收一个可迭代对象

print(sum([1,2,3,4,5,6],-2))　　#后面的-2同样和前面的相加，结果为19　　
print(sum(range(100)))　　#4950

min 最小值

print(min([1,-4,0,9,6]))　　#-4
print(min([],default=0))　　#取默认值0
print(min([-9,1,23,5],key=abs))　　#匿名函数，序列里先经过后面的函数运算再比较，结果为1
print(min({'z':1,'a':2}))　　#比较字典键的大小，结果为a

max 最大值

t = (-25,1,3,6,8)
print(max(t))　　#8
print(max(t,key = abs))　　#-25
print(max((),default=100))　　#100

数据结构相关

序列：list，tuple，str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr

ret = bytearray('alex',encoding='utf-8')  #对比较长的字符串做修改的时候，指定某一处进行修改，不会改变这个bytearry的内存地址
print(id(ret))　　#2235695791048
print(ret[0])　　#97，a的asii码
ret[0] = 65
print(ret)　　　#bytearray(b'Alex')，小写a变大写A
print(id(ret))　　#2235695791048，内存不变

ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))　　#6
print(bytes(ret[:3]).decode('utf-8'))　　#你
print(bytes(ret[3:]).decode('utf-8'))　　#好

reversed反转

l = [3,4,2,5,7,1,5]       
ret = reversed(l)
print(ret)　　# <list_reverseiterator object at 0x000001EFDFF27BA8>
print(list(ret))　　#[5, 1, 7, 5, 2, 4, 3]
l.reverse()
print(l)　　#[5, 1, 7, 5, 2, 4, 3]

slice 实现了切片的函数

l = (1,2,23,213,5612,342,43)
sli = slice(1,5,2)   #实现了切片的函数
print(l[sli])　　#(2, 213)

#l[1:5:2]  语法糖

format

print(format('test', '<20'))#20个字符，test左对齐
print(format('test', '>20'))#20个字符，test右对齐
print(format('test', '^20'))#20个字符，test居中

结果：

test               
                test
        test

bytes

#网络编程的时候：能在网络上传递的必须是字节
ret = bytes('你好，哈哈哈，再见',encoding='utf-8')
#中间是网络传输的过程
print(ret.decode(encoding='utf-8'))　　#你好，哈哈哈，再见

ord

print(ord('a'))　　#97

chr

print(chr(97))　　#a

ascii

print(ascii(97))　　#97
print(ascii('a')　　#'a',原内容输出字符，a带引号

repr

print(repr(1))　　#1
print(repr('1'))　　#'1'
print(repr('name : %r'%('金老板')))　　#'name : '金老板'',整体带引号

enumerate枚举

l = ['笔记本','phone','apple','banana']
for i,j in enumerate(l,1):
    print(i,j)
输出

1 笔记本
2 phone
3 apple
4 banana

all只要有一个布尔值为False的内容，结果就为False，否则为True

any只要有一个布尔值为True的内容，结果就为True,否则为False

print(all([1,2,3,4,0]))　　#F
print(all([1,2,3,4]))　　#T
print(all([1,2,3,None]))　　#F
print(all([1,2,3,'']))　　#F

print(any([1,None,False]))　　#T
print(any([False,None,False]))　　#F

zip 拉链函数

print(list(zip([0,1,2,3,4],[5,6,7,8],['a','b'])))

结果[(0, 5, 'a'), (1, 6, 'b')]

filter过滤函数

def is_odd(x):
    if x>10:
        return True
ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
print(list(ret))　　#[12, 17]

#filter就是有一个可迭代对象，想要一个新的内容集，是从原可迭代对象中筛选出来的
def func(x):
    #return x.strip()    #‘   ’.strip() ==> '' ==> return False
                         # 'test'.strip() ==> 'test'
    return x and x.strip() #None  False and
#去掉所有的空内容和字符串中的空格
l = ['test', None, '', 'str', '  ', 'END']
ret = filter(func,l)
print(list(ret))
#新内容少于等于原内容的时候，才能用到filter

map

ret = map(abs,[-1,-5,6,-7])   #abs(-1) = 1   abs(-5) = 5
print(list(ret))　　#[1, 5, 6, 7]

filter和map
参数很相近：都是一个函数名+可迭代对象
且返回值很相近：都是返回可迭代对象
区别：
filter是做筛选的，结果还是原来就在可迭代对象中的项
map是对可迭代对象中的每一项做操作的，结果不一定是原来就在可迭代对象中的项

有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理

def func(x):
    return x*x
ret = map(func,[1,2,3,4,5,6,7,8])
print(list(ret))　　#[1, 4, 9, 16, 25, 36, 49, 64]

sorted排序

对List、Dict进行排序，Python提供了两个方法
对给定的List L进行排序，
方法1.用List的成员函数sort进行排序，直接修改原列表顺序，节省内存
方法2.用内置函数sorted进行排序，生成新列表，原列表不变

print(sorted([-5,3,-4,2,-1],reverse=True))　　#[3, 2, -1, -4, -5]，reverse=True默认从大打小排序
print(sorted([-5,3,-4,2,-1],key=abs))　　#[-1, 2, 3, -4, -5]，按绝对值大小排序(原列表元素不变)

l2 = ['ajkhs',(1,2),'a',[1,2,3,4]]　　
print(sorted(l2,key=len,reverse=True))　　#['ajkhs', [1, 2, 3, 4], (1, 2), 'a']，按元素长度排序

匿名函数

lambda表达式

def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

dic={'k1':10,'k2':100,'k3':30}
print(max(dic.values()))　　#找出字典中最大的值
print(max(dic))　　#找出字典中最大的键
print(max(dic,key=lambda k:dic[k]))　　#找出字典中值最大的键
结果：

　　100
　　k3
　　k2

#找出序列中大于10的数
ret = filter(lambda num:num>10,[1,4,6,823,67,23])
print(list(ret))　　
#也可以下面这样写
ret = filter(lambda num:True if num>10 else False,[1,4,6,823,67,23])
print(list(ret))

内置函数总结

一、数学运算类

1，abs(x)求绝对值参数可以是整型，也可以是复数

2，divmod(a, b)分别取商和余数,整型、浮点型都可以

3，pow(x, y)x的y次幂

4，round(x, n)小数四舍五入

5，sum(iterable)求和

6，int转为int类型

7，bool转为bool类型

8，float转为float类型

二、序列操作

1，enumerate返回一个可枚举的对象,该对象的next()方法将返回一个tuple

2，max(iterable[args][key])返回最大值

3，min(iterable[args][key])返回最小值

4，sorted(iterable,key,reverse)对序列排序

5，reversed反转

三，判断类

1，all集合中的元素都为真的时候为真

2，any集合中的元素有一个为真的时候为真

3，callable检查对象是否可调用

4，dir返回方法或者参数的属性

四，字符串类

1，bytes

2，eval将字符串类型的代码执行并返回结果

3，exec将自字符串类型的代码执行

4，compile将字符串类型的代码编译

5，len返回集合长度

五，函数类

1，filter过滤函数

2，map遍历每个元素，执行function操作

3，zip拉链函数

4，repr用于%r格式化输出

5，range(start, stop, step]) 产生一个可跌代对象，默认从0开始

六，其他

1，input输入

2，print输出

3，hash返回一个可哈希值

4，open打开文件

5，import引用模块

带key值的函数,key=func

min()

max()

sorted()