正文
python返回函数知乎 python的函数返回值
小程序:扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序
【扫一扫了解最新限行尾号】
复制小程序
python中,@和-> 代表什么?
-常常出现在python函数定义的函数名后面python返回函数知乎,为函数添加元数据,描述函数的返回类型,从而方便开发人员使用。比如python返回函数知乎:
通常的写法是:
def attrs(self) - _Attrs:
pass
这种写法通常是写在函数的函数名后面
def add(x, y) - int:
return x+y
这里面,元数据表明了函数的返回值为int类型。
至于楼主问题中的,- _Attr则表明函数返回的是一个外部可访问的类的私有变量。
为什么python内置的sort比自己写的快速排序快100倍?
主要原因,内置函数用C写的。在Python语言内无论如何造不出内置函数的轮子。这也是通常C跟C++语言用户更喜欢造基础算法的轮了的原因。因为C/C++用户真有条件写出匹敌标准库的算法,但很多高级语言不行,不是程序员技术差,是客观条件就根本做不到。
你比如说Java语言没人造字符串的轮子,C++光一个字符串类就有无数多的实现。是因为C+用户更喜欢写字符串类吗?显然不是,一方面是因为Java语言内没法造出匹敌Java内置标准库算法的轮子,而C++真的可以,另外一个比较惨的原因是C++标准库的字符串功能太弱了,大多数高级语言的字符串类功能都比C+标准库字符串类功能更强。
写C++的时候一大错觉就是我觉着我能比标准库还快,同样的道理放在Python里面也同样适用,不管是Python各种常用package或内建函数,基本上都针对实用场景作了优化,自己手写的算法一般是比不上内建算法效率的,这也是为什么用Python时不鼓励自己造轮子的原因。
回到这个问题,Python内建的sort本质上为C实现的函数,本身执行效率就会比Python快很多,并且会根据不同的数据规模采用不同的排序算法,故效率一般都会优于自己在Python里面手写的排序更何况题主写的是基于递归的quicksort9,额外时间开销大。
因为python内置的sort是用c语言写的,如果你用c语言或者c++写的话肯定是可以做到一样快的至于为什么python计算效率比c语言能慢100倍这个具体的原理我不清楚,不过鉴于知乎上已经有很多大佬解释过这个问题,我就不在这里班门弄斧了
还有底下扯timsort的,快排序是所有比较排序算法里平均性能最优的一族算法,像C++和rust里的unstable_sort都是用的快排序。可能在一些情况下,比如数组几乎有序时,timsort会比快排序快。但是你随便给一个数组,比如像题主那样随机一个一百万大小的数然后排序,timsort是绝对不可能比快排序快的。绝对不可能。快的这100倍和timsort屁关系都没有。
我是C/C++程序员,我可以很负责的告诉你,在用天下现有所有高级语言进行排序的问题上,C要是认了第二,则没人敢认第一。所以,我猜,Python以及好多其他高级语言,都会时不时直接上C语言写的静态库和动态库。我自己也造了不少轮子,有部分是因为刚刚起步,对系统API和函数库不熟悉,找不到适合的,所以自己造轮子,后来发现了有更好的,我把我写的抛弃了。但这里也不排除有一部分是因为我个人觉得还有优化的空间,所以自己用C语言重新造了一个轮子,这样效率比现成的更优。
所以说,要论高级语言的鼻祖,还真非C莫属,从执行效率上讲,别说python,JAVA,C#,VB,甚至C的亲儿子C++,在同一个程序员手中,都没法与C抗衡,所以说,这些语言都是排着队等着被C吊打的,也正因为如此,所以,像python这类高级语言,有自带函数可用的,最好别想着自己重新造轮子,因为你不可能造出比自带函数更快的轮子。
内置库函数都是用C实现的,肯定要比手写的Python程序执行效率更高,此外内置排序Timsort相比本科课程上学的时间复杂度为Onlogn的排序算法做了很多常数优化,所以对于普通人而言,不要希望纯手写出来的东西效率能和标准库相当了。另外,题主写的排序是过不了LeetCode上的裸排序题目的,随机选取pivot对于快速排序是最基本的优化虽然题主排的是随机数,现在这么选肯定不是效率低的主要原因。
所以说了,py几乎得把自己的循环体拆了,这就是py和c/c++的性能差距,必须尽量用内置函数和numpy来处理数据,一旦手写循环体。,那你就得知道这可能得慢百倍,像用opency的py版时你不小心写个双循环来处理数据,那酸爽,而cppc#搞opencv就能随意用指针来写循环,这也是为啥他们其实不需要numpy这种组件,自身就有足够的性能和灵活度来处理这个。
Cpp内置的排序是快排和堆排的结合,最坏时间复杂度为nlogn,而快排最坏是n2。至于python内部的排序,我认为是一个道理,不会简简单单是一个快排,举个简单例子,当你数据已经是有序的时候,再传入快排肯定就不合适。那你设置排序函数的时候,是不是预先将他打乱,再进行快排会更好呢。当然具体不会这么简单,只是我认为官方给的接口都是很精妙的,很值得学习。
一方面Python中sort函数是用C语言写的,C++内部的sort是由快排,直接插入和堆排序混合的,当数据量比较大的时候先用的快排,当数据量小的时候用直接插入,因为当数据量变小时,快排中的每个部分基本有序,接近直接插入的最好情况的时间复杂度O(n),就比快排要好一点了。
另外一方面这个的底层实现就是归并排序。,只是使用了Python无法编写的底层实现,从而避免了Python本身附加的大量开销,速度比我们自己写的归并排序要快很多,所以说我们一般排序都尽量使用sorted和sort。
如何理解Python装饰器
作者:zhijun liu
链接:
来源:知乎
著作权归作者所有,转载请联系作者获得授权。
先来个形象比方
内裤可以用来遮羞,但是到了冬天它没法为我们防风御寒,聪明的人们发明了长裤,有了长裤后宝宝再也不冷了,装饰器就像我们这里说的长裤,在不影响内裤作用的前提下,给我们的身子提供了保暖的功效。
再回到我们的主题
装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。
先来看一个简单例子:
def foo():
print('i am foo')
现在有一个新的需求,希望可以记录下函数的执行日志,于是在代码中添加日志代码:
def foo():
print('i am foo')
logging.info("foo is running")
bar()、bar2()也有类似的需求,怎么做?再写一个logging在bar函数里?这样就造成大量雷同的代码,为了减少重复写代码,我们可以这样做,重新定义一个函数:专门处理日志 ,日志处理完之后再执行真正的业务代码
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()
def bar():
print('i am bar')
use_logging(bar)
逻辑上不难理解, 但是这样的话,我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构,之前执行业务逻辑时,执行运行bar(),但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢?当然有,答案就是装饰器。
简单装饰器
def use_logging(func):
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper
def bar():
print('i am bar')
bar = use_logging(bar)
bar()
函数use_logging就是装饰器,它把执行真正业务方法的func包裹在函数里面,看起来像bar被use_logging装饰了。在这个例子中,函数进入和退出时 ,被称为一个横切面(Aspect),这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖,在定义函数的时候使用,避免再一次赋值操作
def use_logging(func):
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper
@use_logging
def foo():
print("i am foo")
@use_logging
def bar():
print("i am bar")
bar()
如上所示,这样我们就可以省去bar = use_logging(bar)这一句了,直接调用bar()即可得到想要的结果。如果我们有其他的类似函数,我们可以继续调用装饰器来修饰函数,而不用重复修改函数或者增加新的封装。这样,我们就提高了程序的可重复利用性,并增加了程序的可读性。
装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数,可以被赋值给其他变量,可以作为返回值,可以被定义在另外一个函数内。
带参数的装饰器
装饰器还有更大的灵活性,例如带参数的装饰器:在上面的装饰器调用中,比如@use_logging,该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时,提供其它参数,比如@decorator(a)。这样,就为装饰器的编写和使用提供了更大的灵活性。
def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper
return decorator
@use_logging(level="warn")
def foo(name='foo'):
print("i am %s" % name)
foo()
上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装,并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候,Python能够发现这一层的封装,并把参数传递到装饰器的环境中。
类装饰器
再来看看类装饰器,相比函数装饰器,类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法,当使用 @ 形式将装饰器附加到函数上时,就会调用此方法。
class Foo(object):
def __init__(self, func):
self._func = func
def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')
@Foo
def bar():
print ('bar')
bar()
functools.wraps
使用装饰器极大地复用了代码,但是他有一个缺点就是原函数的元信息不见了,比如函数的docstring、__name__、参数列表,先看例子:
装饰器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging
函数
@logged
def f(x):
"""does some math"""
return x + x * x
该函数完成等价于:
def f(x):
"""does some math"""
return x + x * x
f = logged(f)
不难发现,函数f被with_logging取代了,当然它的docstring,__name__就是变成了with_logging函数的信息了。
print f.__name__ # prints 'with_logging'
print f.__doc__ # prints None
这个问题就比较严重的,好在我们有functools.wraps,wraps本身也是一个装饰器,它能把原函数的元信息拷贝到装饰器函数中,这使得装饰器函数也有和原函数一样的元信息了。
from functools import wraps
def logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging
@logged
def f(x):
"""does some math"""
return x + x * x
print f.__name__ # prints 'f'
print f.__doc__ # prints 'does some math'
内置装饰器
@staticmathod、@classmethod、@property
装饰器的顺序
@a
@b
@c
def f ():
等效于
f = a(b(c(f)))
编辑于 2016-08-09
8 条评论
感谢
分享
收藏
•
没有帮助
•
举报
•
作者保留权利
收起
4
赞同
反对,不会显示你的姓名
许多人选择编程是因为他们喜欢把时间花在…
4 人赞同
先理解一下闭包的概念吧,之前回答过一个有关闭包和装饰器的问题,可以参考一下:Python 里函数里返回一个函数内部定义的函数? - 知乎用户的回答
显示全部
先理解一下闭包的概念吧,之前回答过一个有关闭包和装饰器的问题,可以参考一下:
Python 里函数里返回一个函数内部定义的函数? - 知乎用户的回答
发布于 2014-12-09
2 条评论
感谢
分享
收藏
•
没有帮助
•
举报
•
作者保留权利
1
赞同
反对,不会显示你的姓名
罗伊后端工程师
1 人赞同
内置语法糖 格式优美 逼格较高在代码中使用洽到好处的装饰器瞬间让代码优美很多 写起来也很简单 无参的装饰器参数是要装饰的函数 有参装饰器参数是需要的参数 最后返回的是内部函数 参考
显示全部
内置语法糖 格式优美 逼格较高
在代码中使用洽到好处的装饰器瞬间让代码优美很多
写起来也很简单 无参的装饰器参数是要装饰的函数 有参装饰器参数是需要的参数 最后返回的是内部函数 参考
发布于 2014-12-06
添加评论
感谢
分享
收藏
•
没有帮助
•
举报
•
作者保留权利
Chasing Stars.
12 人赞同
之前给出一个链接, 现在尝试用自己方式梳理一下 # 有时爱用蹩脚的英文注释, 唔.# 先从函数说起def foo1():
print('this is a function')
foo1() # print ... in console.'这是一种最为简单的函数-- 不涉及到任何变量, 参数 只是做了一件不以为然的事儿'…
显示全部
之前给出一个链接, 现在尝试用自己方式梳理一下 # 有时爱用蹩脚的英文注释, 唔.
# 先从函数说起
def foo1():
print('this is a function')
foo1() # print ... in console.
'这是一种最为简单的函数-- 不涉及到任何变量, 参数 只是做了一件不以为然的事儿'
# 函数的域 作用范围 以及一个局部变量
global_string = 'this is a global string, my name is global_string'
def foo2():
# lets see its locals variable
# local variable in foo2
x = 3
print('foo2 locals:', locals())
foo2() # foo2 locals: {'x': 3}
print('-'*40)
# check global variable # gets a dictionary, and global_string inside.
# print('globals:' , globals())
# 一个变量的生存的周期
def foo3():
x = 3
print("x value:" , x)
foo3()
'try to run x += 3'
# x += 5, uncomment when you run.
# get NameError -- x is not defined = x is dead.
# 下面来看带有参数的函数
def foo4(s):
print('i am foo4, i can print', s)
foo4('foobar')
## 或者可以多个参数, 甚至是默认的
def foo5(s, repeat= 3):
print('i am foo5, i can print over and over', s*repeat)
foo5('foobar')
'if call a function with un-matched arguments, error comes'
# foo5(1,2,3) # TypeError: foo5() takes from 1 to 2 positional arguments but 3 were given
'foo5 能接收1-2个参数, 大哥你给了3个. typeerror'
# 嵌套函数
def outer():
x = 71
def inner():
print('hello, i am inner')
print('outer variable x ',x)
inner()
outer()
'可以看到 内部函数能够访问外部函数的变量'
# 把函数当作一个对象
'查看类的属性 __class__ built-in function'
i = 3
print(i.__class__) # class 'int'
print(outer.__class__) # class 'function'
'''
# == 所以 既然 一个整数i 可以当作某函数的参数,
那么 这里的 函数 outer 当然也可以作为某个函数的参数!
'''
def applyfunc(func,args,repeat=3):
i = 0
repeat = 3 if repeat = 1 else repeat
while i repeat:
func(args)
i += 1
def test(s):
print('a test function', s)
applyfunc(test, 'love is important', repeat=3)
'可以看到 通过调用一个函数 applyfunc -- 让一个简单函数运行至少3次'
# Closures 不想翻译成闭包
def outer2():
x = 127
def inner2():
print(x)
return inner2
foobar = outer2()
foobar # print nothing
print(foobar.__closure__) # (cell at 0x00706230: int object at 0x5C3EC7F0,)
'可以看到 foobar中封存了一个整数对象 int object at 0x......'
foobar() # print
'x 是outer2中的局部变量, 只有当outer2运行时 x才开始出现.'
## Closures-2
def outer(x):
def inner():
print('inner just print x:', x)
return inner
print1 = outer(1)
print2 = outer(2)
print(print1.__closure__) # int object at 0x5C3EC010
print(print2.__closure__) # int object at 0x5C3EC020,
print1()
print2()
#== closure 是Python中一种机制, 对enclosing variables 的一个'储藏柜'
# Decorators 终于到了装饰器
def outer(somefunc):
def inner():
print('have not run ', somefunc.__name__, end='\n')
result = somefunc()
print(result + ' finished' )
return inner
def foo6():
return 'i am foo6'
decorator = outer(foo6)
decorator()
'上例演示了decorator 基本作用 - 以函数作参数, 并且输出一个装饰后的新函数'
'就字面理解下, 原来的函数是个毛坯房 只有一床板凑合睡, 找2装修小工后,爽了.'
# decorator - 2 , look like more useful
class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return 'I am a {name}, my attributes: {dict}'.format(name = self.__class__.__name__, dict=self.__dict__)
## definition calculation
def add(a, b):
return Point(a.x + b.x, a.y+b.y)
p1 = Point(500, 10)
print(p1)
p2 = Point(30, -100)
print(add(p1,p2))
'Now we want to do some value-check, to make sure the x, y validation'
'比如我们现在只想要点运算时 作数值的检查: 要求点是 100*100这个范围的 (0-100 这个正方形内) ,对于异常作边界处理'
def wrapper(func):
def checker(a, b):
a. x = max(0, a.x) ; a. y = max(0, a.y)
a. x = min(100, a.x);a. y = min(100, a.y)
b. x = max(0, b.x) ; b. y = max(0, b.y)
b. x = min(100, b.x);b. y = min(100, b.y)
result = Point(a.x +b.x, a.y+b.y)
return result
return checker
add_decorator = wrapper(add)
p1 = Point(500, 10)
p2 = Point(30, -100)
# print(add(p1,p2))
print('decorator !')
print(add_decorator(p1, p2))
#= after check, it becomes 100+30, 10+0
# 最后 @ 符号
'因为装饰会经常使用, 为了避免上述麻烦的装饰方法 就想到一个简写'
@wrapper
def add_checked(a, b):
return Point(a.x +b.x, a.y+b.y)
print('skilled decorator using @')
print(add_checked(p1, p2))
evernote 文字版, 习惯用这个存了.
'一步步理解Python中的Decorator'
原文参考:
# 'refer: simeonfranklin.com'
推荐阅读:
Python Cookbook chapter 9 - Metaprogramming, 9.1 9.2 ...
Python爬取知乎与我所理解的爬虫与反爬虫
关于知乎验证码登陆python返回函数知乎的问题,用到python返回函数知乎了Python上一个重要的图片处理库PIL,如果不行,就把图片存到本地,手动输入。
通过对知乎登陆是的抓包,可以发现登陆知乎,需要post三个参数,一个是账号,一个是密码,一个是xrsf。
这个xrsf隐藏在表单里面,每次登陆的时候,应该是服务器随机产生一个字符串。所有,要模拟登陆的时候,必须要拿到xrsf。
用chrome (或者火狐 httpfox 抓包分析)的结果python返回函数知乎:
所以,必须要拿到xsrf的数值,注意这是一个动态变化的参数,每次都不一样。
拿到xsrf,下面就可以模拟登陆了。
使用requests库的session对象,建立一个会话的好处是,可以把同一个用户的不同请求联系起来,直到会话结束都会自动处理cookies。
注意:cookies 是当前目录的一个文件,这个文件保存了知乎的cookie,如果是第一个登陆,那么当然是没有这个文件的,不能通过cookie文件来登陆。必须要输入密码。
这是登陆的函数,通过login函数来登陆,post 自己的账号,密码和xrsf 到知乎登陆认证的页面上去,然后得到cookie,将cookie保存到当前目录下的文件里面。下次登陆的时候,直接读取这个cookie文件。
这是cookie文件的内容
以下是源码:
运行结果:
反爬虫最基本的策略:
爬虫策略:
这两个都是在http协议的报文段的检查,同样爬虫端可以很方便的设置这些字段的值,来欺骗服务器。
反爬虫进阶策略:
1.像知乎一样,在登录的表单里面放入一个隐藏字段,里面会有一个随机数,每次都不一样,这样除非你的爬虫脚本能够解析这个随机数,否则下次爬的时候就不行了。
2.记录访问的ip,统计访问次数,如果次数太高,可以认为这个ip有问题。
爬虫进阶策略:
1.像这篇文章提到的,爬虫也可以先解析一下隐藏字段的值,然后再进行模拟登录。
2.爬虫可以使用ip代理池的方式,来避免被发现。同时,也可以爬一会休息一会的方式来降低频率。另外,服务器根据ip访问次数来进行反爬,再ipv6没有全面普及的时代,这个策略会很容易造成误伤。(这个是我个人的理解)。
通过Cookie限制进行反爬虫:
和Headers校验的反爬虫机制类似,当用户向目标网站发送请求时,会再请求数据中携带Cookie,网站通过校验请求信息是否存在Cookie,以及校验Cookie的值来判定发起访问请求的到底是真实的用户还是爬虫,第一次打开网页会生成一个随机cookie,如果再次打开网页这个Cookie不存在,那么再次设置,第三次打开仍然不存在,这就非常有可能是爬虫在工作了。
反爬虫进进阶策略:
1.数据投毒,服务器在自己的页面上放置很多隐藏的url,这些url存在于html文件文件里面,但是通过css或者js使他们不会被显示在用户看到的页面上面。(确保用户点击不到)。那么,爬虫在爬取网页的时候,很用可能取访问这个url,服务器可以100%的认为这是爬虫干的,然后可以返回给他一些错误的数据,或者是拒绝响应。
爬虫进进阶策略:
1.各个网站虽然需要反爬虫,但是不能够把百度,谷歌这样的搜索引擎的爬虫给干了(干了的话,你的网站在百度都说搜不到python返回函数知乎!)。这样爬虫应该就可以冒充是百度的爬虫去爬。(但是ip也许可能被识破,因为你的ip并不是百度的ip)
反爬虫进进进阶策略:
给个验证码,让你输入以后才能登录,登录之后,才能访问。
爬虫进进进阶策略:
图像识别,机器学习,识别验证码。不过这个应该比较难,或者说成本比较高。
参考资料:
廖雪峰的python教程
静觅的python教程
requests库官方文档
segmentfault上面有一个人的关于知乎爬虫的博客,找不到链接了
python返回函数知乎的介绍就聊到这里吧,感谢你花时间阅读本站内容,更多关于python的函数返回值、python返回函数知乎的信息别忘了在本站进行查找喔。