内置函数和匿名函数

 

内置函数:python自带的函数

作用域相关

 

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

 

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

 

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

 

 

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='\n', file=None):
    """
    print(value, ..., sep=' ', end='\n', 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 = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)
#\r 可以把光标移动到行首但不换行

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))