- global与locals
-global 查看全局作用域中的变量
-locals 查看局部作用域中的变量
-异同：在全局作用域中，global与locals结果相同，但在局部作用域中，global还是查看全局作用域中的变量，而locals只查看局部作用域的变量
def func():
x = 1
y = 2
print(locals()) # {'y': 2, 'x': 1}
print(globals()) # {'__name__': '__main__', .........}
- iter与next
- itetr内置函数的作用原理：通过此函数把可迭代对象返回成迭代器
def iter(iterable):
return iterable.__iter__()
- next内置函数的作用原理：通过此函数把迭代器执行next运算
def next(iterator):
return iterator.__next__()
- 注：双下iter与next方法在代码中尽量不要出现，常用iter(),next()
- eval,exec,compile
- eval：eval（) 将字符串类型的代码执行并返回结果，针对字符串中有运算的代码，有运算，有返回值
print(eval（'1+2+3+4')) #10
- exec：exec()将自字符串类型的代码执行，针对字符串中只有执行的代码，无运算，无返回值
exec("print('hello,world')") #hello,world
- complie：当一个文件中字符串形式的代码要反复调用，每次都需要eval或exec翻译就十分费时，即complie就把要转译的代码保存起来，用时调用即可
- complie使用时参数说明：
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
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec') #编译
exec(compile1) #0,1,2,3,4...........
#求值语句使用eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
print(eval（compile2)) # 10
#交互语句使用single
name = 'egon'
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
exec(compile3) #执行时显示交互命令，提示输入
print(name) # 输出了输入的变量，变量不在是egon
注：直接拿来转译后的代码一定要进行检测，否则转译后的代码进入程序后，会引起不可预知的严重错误
注：直接拿来转译后的代码一定要进行检测，否则转译后的代码进入程序后，会引起不可预知的严重错误
注：直接拿来转译后的代码一定要进行检测，否则转译后的代码进入程序后，会引起不可预知的严重错误
- input和print
- input
- print()：中的各参数 print(self, *args, sep=' ', end='\n', file=None)
- sep
print(11232,1234,sep='***') #11232***1234
print(12,34,56,sep='') #123456
- end
print('a','b','c',end=' ')
print('a','b','c',sep='@')
#a b c a@b@c
- file：默认为None，即打印在pycharm中，如果改为文件句柄，则写进文件中
f = open('print_test','a',encoding='utf-8')
print(12146798,file=f) #把打印内容写进文件中
- flush，得到值就写入
import sys
for i in range(10):
time.sleep(0.1)
print(i*'*',end='')
sys.stdout.flush() #若没有sys.stdout.flush()，则循环会一次把数字都显示出来，有则收到几个就显示几个
import time
for i in range(0,101,2):
time.sleep(0.1)
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 可以把光标移动到行首但不换行
- id和hash
- id ：id(o) o是参数，返回一个变量的内存地址
- is 是判断两个变量是否相同，也可判断内存地址是否相同
print(id(1)) #在代码运行后，id（1）内存地址是固定的，但代码重新运行后内存地址改变，
print(id(1)) #内存地址与上边相同，但只是pycharm进行优化后，其实他们不相同
print(id(1) is id(1)) #False
- hash(o)： o是参数，返回一个可hash变量的哈希值，只有字符串，元祖等不可变类型才能hash，数字被hash后还是本身；hash结果是个数字；在python执行过程中，对相同的hash对象hash得到的值相同，但重新运行后，hash值变化
- 用hash值查找，是最方便最快捷的查找方式
#同一次运行状态下
print(hash('dsaklfksgd')) #519732024941737233
print(hash('dsaklfksgd')) #519732024941737233
#把链接转为hash值作为字典的键，再把链接中的内容作为值保存到字典
url = 'http://xhpfmapi.zhongguowangshi.com/share/index.html?docid=2269496&channel=weixin'
from urllib.request import urlopen
content = urlopen(url).read()
dic = {hash(url):content}
- open：open() 打开一个文件，返回一个文件操作符(文件句柄)；操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)；可以用encoding指定编码.
- import：导入一个模块
import time #导入时间模块
- help：在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型；输入q退出；或者直接执行help(o)，o是参数，查看和变量o有关的操作。。。
- callable：callable(o)，o是参数，看这个变量是不是可调用。如果o是一个函数名，就会返回True
def func():pass
print(callable(func)) #参数是函数名，可调用，返回True
print(callable(123)) #参数是数字，不可调用，返回False
- dir() ：查看参数所属类型的所有内置方法；默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
print(dir(list)) #查看列表的内置方法
print(dir(int)) #查看整数的内置方法
dir(__builtins__)
print(dir(__builtins__))
- filter和map
- filter(func,list)：把list中元素一个个的传到func函数中根据func函数中的判断条件，符合条件的返回True的元素添加到新的迭代器中，filter返回一个符合函数条件的迭代器；filter()中的两个参数，一个是函数，一个是可迭代对象
#func，iterable
def func(n):
if n%2 == 0:
return True
lst = [1,2,3,4,5,6,7]
ret = filter(func,lst) #返回一个迭代器
print(list(ret)) #[2, 4, 6]
- map(func,list)：把list中元素一个个的传到func函数中根据func函数中的代码进行运行，返回一个结果，并把结果添加到一个迭代器中，map返回一个被函数运行后的迭代器；filter()中的两个参数，一个是函数，一个是可迭代对象
lst = [1,2,3,4,5,6,7]
def func(item):
return item*item
ret=map(func,lst)
print(list(ret)) #[1, 4, 9, 16, 25, 36, 49]
- enumerate(list,start=0)： 把list里的每一个元素都标记一个序号，序号从0开始，每一个序号与list元素形成一个元祖；start=1即序号从1开始
#如果是字典就把每个键与序号组成一个字典
se = ['a','b','c','d','e','f','g']
for goods in enumerate(se,1):
print(goods) # (1, 'a') (2, 'b')
for num,goods in enumerate(se,1):
print(num,goods) #1 a 2 b
- bool(); int(); float(); complex()
x -- 字符串或数字，base -- 进制数，默认十进制
>>>int() # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)
10
>>> int('10',8)
8
- float(x) x -- 整数或字符串
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123') # 字符串
123.0
- complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
- bin();oct();hex()
- bin(x)： bin() 把一个整数 int 或者长整数 long int 转化成二进制字符串。x -- int 或者 long int 数字。返回值：字符串
- oct(x)：oct() 函数将一个整数转换成8进制字符串。x -- 整数。返回8进制字符串。
- hex(x)：hex() 函数将一个整数转换成16进制字符串。x -- 10进制整数。返回16进制字符串。
- abs()； round() ； pow()
abs() 函数返回数字的绝对值。x -- 数值表达式，可以是整数，浮点数，复数。
- round(x,n)： 返回浮点数x四舍五入n位的值，若没有n则四舍五入取整
round(70.23456) # 70
round(56.659,1)# 56.7
round(80.264, 2) # 80.26
round(100.000056, 3) # 100.0
round(-100.000056, 3) # -100.0
方法返回 xy（x的y次方） 的值，如果z在存在，则再除以z结果进行取余，其结果等效于pow(x,y) %z
pow(100, 2) # 10000
pow(10, -2) # 0.01
pow(2,3,7) # 1
- divmod()： divmod(a,b) 返回一个包含商和余数的元组(a // b, a % b)，a,b: 数字
divmod(7, 2) #(3, 1)
divmod(8, 2) #(4, 0)
- sum()：sum(iterable,start=0) 返回求和结果，iterable -- 可迭代对象，如列表；start -- 指定相加的参数，如果没有设置这个值，默认为0
sum([0,1,2]) #3
sum((2, 3, 4), 1) #10 # 元组计算总和后再加 1
sum([0,1,2,3,4], 2) #12 # 列表计算总和后再加 2
- min()；max() 返回最小值，最大值
-min() ： min(iterable,key) min(*args,key)
-可以接收散列的值，和可迭代的对象
-key是一个函数名，判断的结果根据函数的返回值来确定
-defult 如果可迭代对象为空，设置默认最小值
min(1,2,3,4,-5) #-5
min(1,2,3,4,-5,key=abs) #1
min([1,2,3,4,-5],key=abs) #1
min([1,2,3,4,-5],key=lambda n:abs(n)) #1
- max()： max(iterable,key) max(*args,key) 与min()同理
- reversed() ： reversed(x) 返回一个反转的迭代器，x为要转换的序列，可以是 tuple, string, list 或 range。返回一个反转的迭代器。
a= 'Runoob'
print(list(reversed(a))) #['b', 'o', 'o', 'n', 'u', 'R']
a= ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(a))) #['b', 'o', 'o', 'n', 'u', 'R']
a=range(5, 9)
print(list(reversed(a))) #[8, 7, 6, 5]
a = [1, 2, 4, 3, 5]
print(list(reversed(a)) #[5, 3, 4, 2, 1]
a= 'Runoob'
print(''.join(reversed(a))) #boonuR
- slice()； slice(a,b,c) 函数实现切片对象，主要用在切片操作函数里的参数传递。 a,b为索引值 a-起始值 b-终止值，不包含 c-间距 返回一个切片对象
>>>myslice = slice(5) # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] # 截取 5 个元素
[0, 1, 2, 3, 4]
- format() ：字符串格式化的功能
- bytes()；bytearray()
- bytes()： bytes(s,encoding='utf-8') 把s字符串按编码转化成字节形式，返回一个字节对象
s = 'alex'
by = bytes(s,encoding='utf-8')
print(by) # b'alex'
#解码字节
ret=by.decode('utf-8')
print(ret) # alex
把s字符串按编码一个新字节数组。这个数组里的元素是可变的
s = 'alex'
print(s) #alex
ret = bytearray(s,encoding='utf-8')
print(ret,id(ret)) #bytearray(b'alex') 35633448
ret[0] = 65 #把a换化成大写A
print(ret,id(ret)) #bytearray(b'Alex') 35633448
s = ret.decode('utf-8')
print(s) #Alex
- memoryview()： 返回元组列表
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret)) #6
print(bytes(ret[:3]).decode('utf-8')) #你
print(bytes(ret[3:]).decode('utf-8')) #好
- chr()；ord() 字符按unicode转数字，数字按unicode转字符
print(ord('A')) #65
print(chr(97)) #a
- ascii()，repr()
ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。返回字符串。
- repr() ： 将对象转化为供解释器读取的形式。 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 x可以是元祖，列表，字符串，字典
print(frozenset('adsf')) #frozenset({'d', 'f', 'a', 's'})
print(frozenset([1,2,3,4])) #frozenset({1, 2, 3, 4})
print(frozenset({'k1':1,'k2':2})) #frozenset({'k1', 'k2'})
- all()；any()
判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空，如果是返回 True，否则返回 False。
空元组、空列表，空字典 返回值为True，这里要特别注意。
print(all([1,{},(),None])) # False
print(any([0,1,2,3])) # False
print(any([])) # True
print(any(())) # True
print(any({})) # True
，如果不都为空、0、false，则返回 True。
>>> any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
True
>>> any([0, '', False]) # 列表list,元素全为0,'',false
False
- zip() ： zip(iter1,iter2,iter3...) 把多个迭代器中的元素，一一对应的整合到元祖中，返回一个迭代器，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以打散列表元祖
l1 = (i for i in range(10))
l2 = ('a','b','c','d')
l3 = [9,8,7]
ret = zip(l1,l2,l3)
for i in ret:
print(i,end=' ') # (0, 'a', 9) (1, 'b', 8) (2, 'c', 7)
#解压
l1 = (i for i in range(10))
l2 = ('a','b','c','d')
l3 = [9,8,7]
ret = zip(l1,l2,l3)
for i in zip(*ret):
print(i,end=' ') #(0, 1, 2) ('a', 'b', 'c') (9, 8, 7)
- sorted()： sorted(iterable,key,reverse=False) 可迭代对象按照函数key，进行排序，返回一个新的可迭代对象，不会在原基础上进行操作；reverse = True 降序 ， reverse = False 升序（默认）。
- sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a) # 保留原列表
>>> a
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2]) # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
l = [1,34,3,-5864,5,-1236,7]
print(sorted(l)) #[-5864, -1236, 1, 3, 5, 7, 34]
print(sorted(l,key=abs)) #[1, 3, 5, 7, 34, -1236, -5864]
l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len)) #[(7,), [1, 2, 3], '123', [3, 4, 5, 6]]
##################### 匿名函数 #######################
- 匿名函数： 为了实现简单功能的一句话函数
-一句话代码：匿名函数，三元运算，列表推导式，生成器表达式
- 格式： calc= lambda n : n**n calc为函数名，lambda为匿名函数关键字与def相似，n为参数参数可以是多个， n**n为返回值
函数名 = lambda 参数 ：返回值
#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型
l=[3,2,100,999,213,1111,31121,333]
print(max(l)) #31121
dic={'k1':10,'k2':100,'k3':30}
print(max(dic)) #k3
print(dic[max(dic,key=lambda k:dic[k])]) # 100
- 面试题
以下代码的输出是什么？请给出答案并解释。
def multipliers():
return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
请修改multipliers的定义来产生期望的结果。
#解析
def multipliers():
# new_l = []
# for i in range(4):
# def func(x):
# return x*i
# new_l.append(func)
# return new_l
return [lambda x: i * x for i in range(4)] #6,6,6,6
# i = 0
# [func]
# i = 1
# [func,func]
# i = 2
# [func,func,func]
# i = 3
# [func,func,func,func]
#
# for func in multipliers():
# func(2)
print([m(2) for m in multipliers()]) #[6,6,6,6]
print([m(2) for m in (lambda x:x*i for i in range(4))]) #[0,2,4,6]本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
