1.内置参数
Built-in Functions | ||||
abs() | dict() | help() | min() | setattr() |
all() | dir() | hex() | next() | slice() |
any() | divmod() | id() | object() | sorted() |
ascii() | enumerate() | input() | oct() | staticmethod() |
bin() | eval() | int() | open() | str() |
bool() | exec() | isinstance() | ord() | sum() |
bytrarray() | filter() | issubclass() | pow() | super() |
bytes() | float() | iter() | print() | tuple() |
callable() | format() | len() | property() | type() |
chr() | frozenset() | list() | range() | vars() |
classmethod() | getattr() | locals() | repr() | zip() |
compile() | globals() | map() | reversed() | __import__() |
complex() | hasattr() | max() | round() | |
delattr() | hash() | memoryview() | set() |
内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii
2.迭代器&生成器
列表生成式,是Python内置的一种极其强大的生成list的表达式。
如果要生成一个list [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9] 可以用 range(1 , 10):
1
2
|
#print(list(range(1,10))) [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
|
如果要生成[1x1, 2x2, 3x3, ..., 10x10]
怎么做?
1
2
3
4
5
6
|
l = []
for i in range ( 1 , 10 ):
l.append(i * i)
print (l)
####打印输出#### #[1, 4, 9, 16, 25, 36, 49, 64, 81] |
而列表生成式则可以用一行语句代替循环生成上面的list:
1
2
|
>>> print ([x * x for x in range ( 1 , 10 )])
[ 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64 , 81 ]
|
for循环后面还可以加上if判断,这样我们就可以筛选出仅偶数的平方:
1
2
|
>>> print ([x * x for x in range ( 1 , 10 ) if x % 2 = = 0 ])
[ 4 , 16 , 36 , 64 ]
|
>>>[ i*2 for i in range(10)]
[0,1,4,6,8,10,12,14,16,18]
等于
>>>a=[]
>>>for i in range(10):
. . . a.append(i*2)
>>>a
[0,1,4,6,8,10,12,14,16,18]
小程序
str1 = ""
for i in iter(input,""): # 循环接收 input输入的内容
str1 += i print(str1)
生成器
通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。
所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]
改成()
,就创建了一个generator:
>>>l = [x*x for x in range(10)]
>>>l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>g = (x*x for x in range(10))
>>>g
<generator object <genexpr> at 0x1022ef630>
创建L
和g
的区别仅在于最外层的[]
和()
,L
是一个list,而g
是一个generator。
我们可以直接打印出list的每一个元素,但我们怎么打印出generator的每一个元素呢?
如果要一个一个打印出来,可以通过next()
函数获得generator的下一个返回值:
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
所以,我们创建了一个generator后,基本上永远不会调用next()
,而是通过for
循环来迭代它,并且不需要关心StopIteration
的错误。
generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for
循环无法实现的时候,还可以用函数来实现。
比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
def fib(max):
n,a,b=0,0,1
while n < max:
print(b)
a,b=b,a+b
n = n+1
return 'done'
上面的函数可以输出斐波那契数列的前N个数:
>>>fib(10)
1
1
2
3
5
8
13
21
34
55
done
生成器的特点:
1)生成器只有在调用时才会生成相应的数据;
2)只记录当前位置;
3)只有一个__next__()方法;
还可通过yield实现在单线程的情况下实现并发运算的效果:
import time
def consumer(name):
print("%s 准备吃包子!" %name)
while True:
baozi = yield
print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
c = consumer("ChenRonghua")
c.__next__() def produceer(name):
c = consumer("a")
c2 = consumer("b")
c.__next__()
c2.__next__()
print("老子开始准备做包子啦!")
for i in range(10):
time.sleep(1)
print("做了1个包子,分两半!")
c.send(i)
c2.send(i)
produceer("alex")
迭代器
我们已经知道,可以直接作用于for
循环的数据类型有以下几种:
一类是集合数据类型,如list
、tuple
、dict
、set
、str
等;
一类是generator
,包括生成器和带yield
的generator function。
这些可以直接作用于for
循环的对象统称为可迭代对象:Iterable
。
可以使用isinstance()
判断一个对象是否是Iterable
对象:
>>>from collections import Iterable
>>>isinstance([],Iterable)
True
>>>isinstance({},Iterable)
True
>>>isinstance('abc',Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
凡是可作用于for
循环的对象都是Iterable
类型;
凡是可作用于next()
函数的对象都是Iterator
类型,它们表示一个惰性计算的序列;
集合数据类型如list
、dict
、str
等是Iterable
但不是Iterator
,不过可以通过iter()
函数获得一个Iterator
对象。
Python的for
循环本质上就是通过不断调用next()
函数实现的,例如:
for x in [1,2,3,4,5]:
pass
实际上完全等价于:
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break
3.Json&pickle数据序列化
用于序列化的两个模块
- json,用于字符串 和 python数据类型间进行转换
- pickle,用于python特有的类型 和 python的数据类型间进行转换
Json模块提供了四个功能:dumps、dump、loads、load
pickle模块提供了四个功能:dumps、dump、loads、load
info = {
"name":"alex",
"age":22
}
f = open("test.txt","w")
f.write(info)
f.close()
json序列化
f = open("test.txt","r") data = eval(f.read())
f.close()
print(data['age'])
json反序列化
json能处理简单的数据类型,字典,列表,字符串。
json是所有语言通用的,json的作用是不同语言之间进行数据交互。
#json序列化
import json
info = {
"name":"alex",
"age":22
}
f = open("test.txt","w")
#print(json.dumps(info))
f.write(json.dumps(info))
f.close()
#json反序列化
import json
f = open("test.txt","r") data = json.loads(f.read())
f.close()
print(data['age'])
json序列化,反序列化
import pickle
def sayhi(name):
print("hello,",name)
info = {
"name":"alex",
"age":22,
"func":sayhi
}
f = open("test.txt","wb") f.write(pickle.dumps(info))
f.close()
pickle序列化
import pickle
def sayhi(name):
print("hello,",name)
f = open("test.txt","rb")
data = pickle.loads(f.read()) print(data['func']("Alex"))
pickle反序列化
4.装饰器
定义:
本质上是个函数,功能是装饰其他函数—就是为其他函数添加附加功能
装饰器原则:
1) 不能修改被装饰函数的源代码;
2) 不能修改被装饰函数的调用方式;
实现装饰器知识储备:
函数即“变量”
定义一个函数相当于把函数体赋值给了函数名
1.函数调用顺序:其他高级语言类似,python不允许在函数未声明之前,对其进行引用或者调用
错误示范:
def foo():
print('in the foo')
bar()
foo() 报错:
in the foo
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
foo()
File "<pyshell#12>", line 3, in foo
bar()
NameError: global name 'bar' is not defined def foo():
print('foo')
bar()
foo()
def bar()
print('bar')
报错:NameError: global name 'bar' is not defined
正确示范:(注意,python为解释执行,函数foo在调用前已经声明了bar和foo,所以bar和foo无顺序之分)
def foo()
print('in the foo')
bar()
def bar():
print('in the bar')
foo() def bar():
print('in the bar')
def foo():
print('in the foo')
bar()
foo()
2.高阶函数
满足下列条件之一就可成函数为高阶函数
1.某一函数当做参数传入另一个函数中
2.函数的返回值包含n个函数,n>0
高阶函数示范:
def bar():
print('in the bar')
def foo(func):
res=func()
return res
foo(bar)
高阶函数的牛逼之处:
def foo(func):
return func
print('function body is %s' %(foo(bar)))
print('function name is %s' %(foo(bar).func_name))
foo(bar)()
#foo(bar)() 等同于bar=foo(bar)然后bar()
bar = foo(bar)
bar()
3.内嵌函数和变量作用域
定义:在一个函数体内创建另一个函数,这种函数就叫内嵌函数
嵌套函数:
def foo():
def bar():
print('in the bar')
bar()
foo()
局部作用域和全局做用域的访问顺序
x = 0
def grandpa():
def dad():
x = 2
def son():
x=3
print(x)
son()
dad()
grandpa()
4.高阶函数+内嵌函数=》装饰器
函数参数固定
def decorartor(func):
def wrapper(n):
print('starting')
func(n)
print('stopping')
return wrapper def test(n):
print('in the test arg is %s' %n)
decorartor(test)('alex')
函数参数不固定
def decorartor(func):
def wrapper(*args,**kwargs):
print('starting')
func(*args,**kwargs)
print('stopping')
return wrapper def test(n,x=1):
print('in the test arg is %s' %n)
decorartor(test)('alex',x=2222)
1.无参装饰器
import time
def decorator(func):
def wrapper(*args,**kwargs):
start_time=time.time()
func(*args,**kwargs)
stop_time=time.time()
print("%s" %(stop_time-start_time))
return wrapper @decorator
def test(list_test):
for i in list_test:
time.sleep(0.1)
print('-'*20,i) #decorator(test)(range(10))
test(range(10))
2.有参装饰器
import time
def timer(timeout=0):
def decorator(func):
def wrapper(*args,**kwargs):
start=time.time()
func(*args,**kwargs)
stop=time.time()
print('run time is %s ' %(stop-start))
print(timeout)
return wrapper
return decorator
@timer(2)
def test(list_test):
for i in list_test:
time.sleep(0.1)
print ('-'*20,i) #timer(timeout=10)(test)(range(10))
test(range(10))
3.终极装饰器
user,passwd = 'alex','abc123'
def auth(auth_type):
print('auth func:',auth_type)
def outer_wrapper(func):
def wrapper(*args,**kwargs):
print("wrapper func args:",*args,**kwargs)
if auth_type=="local":
username = input("Username:").strip()
password = input("Password:").strip()
if user == username and passwd == password:
res = func(*args,**kwargs)
print("---after authentication")
return res
else:
exit("\033[31;1mInvalid username or password\033[0m")
elif auth_type == "ldap":
print('搞毛线ldap,不会......') return wrapper
return outer_wrapper def index():
print("welcome to index page")
@auth(auth_type="local") #home = wrapper()
def home():
print("welcome to home page")
return "from home"
@auth(auth_type="ldap")
def bbs():
print("welcome to bbs page") index()
print(home())#wrapper()
bbs()