摘要:本文主要向大家介绍了Python语言学习之Python高阶,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助。
本文主要向大家介绍了Python语言学习之Python高阶,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助。
包(lib)、模块(module)
在Python中,存在包和模块两个常见概念。
模块:编写Python代码的py文件
包:用来分门别类存放模块代码的文件夹,【一般存在一个__init__.py文件】
模块的几种导入方式:
__init__.py文件:
__all__变量的使用:
__init__.py文件中导入其他模块文件,推荐使用
from . import xxx
可以使用别名来简化导入的模块名称【as的使用】。
注意:
1、当一个普通文件夹充当包的时候,导入模块时,一定要指定模块名称,因为普通文件夹不是包(包是可以直接导入的)。
2、当导入的包路径太长的时候,可以使用as关键字取别名来解决
3、包与普通文件夹的区别
发布模块:
在文件的主目录创建setup.py文件,编辑如下:
from distutils.core import setup
setup(name=”ljh”,version=”1.0”,description=”描述”,author=”作者”,author_email=”作者邮箱”,py_modules=[“xx.xx.xx.py”,”xx.xx.xxx.py”])
如下图所示:
执行构建命令:
python setup.py build
执行打包命令:
python setup.py sdist
之后项目中结构如下:
执行安装命令:
python setup.py install
就会将我们打包后的压缩包安装到Python对应的第三方模块下:
python36\Lib\site-packages
我们在代码中就可以导入使用这个模块了。
1.2==,is的使用
-5~256
总结
is是比较两个引用是否指向了同一个对象(地址引用比较)。
==是比较两个对象是否相等。(比较的数值)
1.3 深拷贝、浅拷贝
1.3.1 赋值
将一个变量赋值给另一个变量,这个过程叫做赋值。赋值会导致多个变量同时指向一块内存,所以此时不管是==或者is都返回True
所以当一个发送变量,另一个也随之发送变化。
1.3.2 浅拷贝(copy)
浅拷贝是对于一个对象的顶层拷贝
通俗的理解是:拷贝了引用,并没有拷贝内容
但是,当a发送变化时,b不会变化:
1.3.3 深拷贝
深拷贝是对于一个对象所有层次的拷贝(递归)
1.3.4拷贝的其他方
注意常量类型的深浅拷贝问题(如字符串、小整形数值型、元组)
1.4属性property
面试题:
1、你对面向对象的理解
2、 面向对象的特征是什么
封装、继承、多态
3、对封装的理解?
封装,类本身就是一个封装,封装了属性和方法。方法也是封装,对一些业务逻辑的封装。私有也是封装,将一些方法和属性私有化,对外提供可访问的接口。
4、对继承的理解
将共性的内容放在父类中,子类只需要关注自己特有的内容,共性的继承过来就行了。
这样简化开发,符合逻辑习惯,利于扩展。
5、多态的理解
多态,一个对象在不同的情况下显示不同的形态。在python中因为是弱类型语言,对类型没有限定,所有python中不完全支持多态,但是多态的思想呢,python也是能体现的。
限制属性,即属性不可变动
property是属于类的,不能写到方法中,写类里,property是一个方法,可以传递属性property(getName,setName)是值传递引用传递,不是调用,把函数传递里面,不是返回值,name = property(getName,setName)
1.4.1私有属性添加getter和setter方法
class Money(object):
def __init__(self):
self.__money = 0
def getMoney(self):
return self.__money
def setMoney(self, value):
if isinstance(value, int):
self.__money = value
else:
print("error:不是整型数字")
1.4.2 使用property升级getter和setter方法
class Money(object):
def __init__(self):
self.__money = 0
def getMoney(self):
return self.__money
def setMoney(self, value):
if isinstance(value, int):
self.__money = value
else:
print("error:不是整型数字")
money = property(getMoney, setMoney)
运行结果:
In [1]: from get_set import Money
In [2]:
In [2]: a = Money()
In [3]:
In [3]: a.money
Out[3]: 0
In [4]: a.money = 100
In [5]: a.money
Out[5]: 100
In [6]: a.getMoney()
Out[6]: 100
1.4.3使用property取代getter和setter方法
@property成为属性函数,可以对属性赋值时做必要的检查,并保证代码的清晰短小,主要有2个作用
将方法转换为只读
重新实现一个属性的设置和读取方法,可做边界判定
class Money(object):
def __init__(self):
self.__money = 0
@property
def money(self):
return self.__money
@money.setter
def money(self, value):
if isinstance(value, int):
self.__money = value
else:
print("error:不是整型数字")
运行结果
In [3]: a = Money()
In [4]:
In [4]:
In [4]: a.money
Out[4]: 0
In [5]: a.money = 100
In [6]: a.money
Out[6]: 100
1.5 生成器
[if !supportLists]1.5.1 [endif]什么是生成器
通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
[if !supportLists]1.5.2 [endif]创建生成器方法1
要创建一个生成器,有很多种方法。第一种方法很简单,只要把一个列表生成式的[ ]改成 ( )
In [15]: L = [ x*2 for x in range(5)]
In [16]: L
Out[16]: [0, 2, 4, 6, 8]
In [17]: G = ( x*2 for x in range(5))
In [18]: G
Out[18]: at 0x7f626c132db0>
In [19]:
创建L和 G 的区别仅在于最外层的 [ ] 和 ( ) , L 是一个列表,而 G 是一个生成器。我们可以直接打印出L的每一个元素,但我们怎么打印出G的每一个元素呢?如果要一个一个打印出来,可以通过next()函数获得生成器的下一个返回值:
In [19]: next(G)
Out[19]: 0
In [20]: next(G)
Out[20]: 2
In [21]: next(G)
Out[21]: 4
In [22]: next(G)
Out[22]: 6
In [23]: next(G)
Out[23]: 8
In [24]: next(G)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
in ()
----> 1 next(G)
StopIteration:
In [25]:
In [26]: G = ( x*2 for x in range(5))
In [27]: for x in G:
....: print(x)
....:
0
2
4
6
8
In [28]:
生成器保存的是算法,每次调用next(G),就计算出 G 的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出 StopIteration 的异常。当然,这种不断调用 next() 实在是太变态了,正确的方法是使用 for 循环,因为生成器也是可迭代对象。所以,我们创建了一个生成器后,基本上永远不会调用 next() ,而是通过 for 循环来迭代它,并且不需要关心 StopIteration 异常。
[if !supportLists]1.5.3 [endif]创建生成器方法2
generator非常强大。如果推算的算法比较复杂,用类似列表生成式的 for 循环无法实现的时候,还可以用函数来实现。
比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易:
In [28]: def fib(times):
....: n = 0
....: a,b = 0,1
....: while n
....: print(b)
....: a,b = b,a+b
....: n+=1
....: return 'done'
....:
In [29]: fib(5)
1
1
2
3
5
Out[29]: 'done'
仔细观察,可以看出,fib函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。
也就是说,上面的函数和generator仅一步之遥。要把fib函数变成generator,只需要把print(b)改为yield b就可以了:
In [30]: def fib(times):
....: n = 0
....: a,b = 0,1
....: while n
....: yield b
....: a,b = b,a+b
....: n+=1
....: return 'done'
....:
In [31]: F = fib(5)
In [32]: next(F)
Out[32]: 1
In [33]: next(F)
Out[33]: 1
In [34]: next(F)
Out[34]: 2
In [35]: next(F)
Out[35]: 3
In [36]: next(F)
Out[36]: 5
In [37]: next(F)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
in ()
----> 1 next(F)
StopIteration: done
在上面fib的例子,我们在循环过程中不断调用 yield ,就会不断中断。当然要给循环设置一个条件来退出循环,不然就会产生一个无限数列出来。同样的,把函数改成generator后,我们基本上从来不会用 next() 来获取下一个返回值,而是直接使用 for 循环来迭代:
In [38]: for n in fib(5):
....: print(n)
....:
1
1
2
3
5
In [39]:
但是用for循环调用generator时,发现拿不到generator的return语句的返回值。如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的value中:
In [39]: g = fib(5)
In [40]: while True:
....: try:
....: x = next(g)
....: print("value:%d"%x)
....: except StopIteration as e:
....: print("生成器返回值:%s"%e.value)
....: break
....:
value:1
value:1
value:2
value:3
value:5
生成器返回值:done
In [41]:
[if !supportLists]1.5.4 [endif]send
例子:执行到yield时,gen函数作用暂时保存,返回i的值;temp接收下次c.send("python"),send发送过来的值,c.next()等价c.send(None)
In [10]:def gen():
....: i = 0
....: while i<5:
....: temp = yield i
....: print(temp)
....: i+=1
....:
使用next函数
In [11]: f = gen()
In [12]: next(f)
Out[12]: 0
In [13]: next(f)
None
Out[13]: 1
In [14]: next(f)
None
Out[14]: 2
In [15]: next(f)
None
Out[15]: 3
In [16]: next(f)
None
Out[16]: 4
In [17]: next(f)
None
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
in ()
----> 1 next(f)
StopIteration:
使用__next__()方法
In [18]: f = gen()
In [19]: f.__next__()
Out[19]: 0
In [20]: f.__next__()
None
Out[20]: 1
In [21]: f.__next__()
None
Out[21]: 2
In [22]: f.__next__()
None
Out[22]: 3
In [23]: f.__next__()
None
Out[23]: 4
In [24]: f.__next__()
None
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
in ()
----> 1 f.__next__()
StopIteration:
使用send
In [43]: f = gen()
In [44]: f.__next__()
Out[44]: 0
In [45]: f.send('haha')
haha
Out[45]: 1
In [46]: f.__next__()
None
Out[46]: 2
In [47]: f.send('haha')
haha
Out[47]: 3
In [48]:
[if !supportLists]1.5.5 [endif]实现多任务
模拟多任务(进程,线程,协程)实现方式之一:协程
def test1():
while True:
print("--1--")
yield None
def test2():
while True:
print("--2--")
yield None
t1 = test1()
t2 = test2()
while True:
t1.__next__()
t2.__next__()
总结
生成器是这样一个函数,它记住上一次返回时在函数体中的位置。对生成器函数的第二次(或第n次)调用跳转至该函数中间,而上次调用的所有局部变量都保持不变。
生成器不仅“记住”了它数据状态;生成器还“记住”了它在流控制构造(在命令式编程中,这种构造不只是数据值)中的位置。
生成器的特点:
[if !supportLists]1. [endif]节约内存
[if !supportLists]2. [endif]迭代到下一次的调用时,所使用的参数都是第一次所保留下的,即是说,在整个所有函数调用的参数都是第一次所调用时保留的,而不是新创建的
[if !supportLists]1.6 [endif]迭代器
迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。
[if !supportLists]1.6.1 [endif]可迭代对象
以直接作用于for循环的数据类型有以下几种:
一类是集合数据类型,如list、 tuple 、 dict 、 set 、 str 等;
一类是generator,包括生成器和带 yield 的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象: Iterable 。
[if !supportLists]1.6.2 [endif]判断是否可以迭代
可以使用isinstance()判断一个对象是否是 Iterable 对象:
In [50]: from collections import Iterable
In [51]: isinstance([], Iterable)
Out[51]: True
In [52]: isinstance({}, Iterable)
Out[52]: True
In [53]: isinstance('abc', Iterable)
Out[53]: True
In [54]: isinstance((x for x in range(10)), Iterable)
Out[54]: True
In [55]: isinstance(100, Iterable)
Out[55]: False
而生成器不但可以作用于for循环,还可以被 next() 函数不断调用并返回下一个值,直到最后抛出 StopIteration 错误表示无法继续返回下一个值了。
[if !supportLists]1.6.3 [endif]迭代器
可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。
可以使用isinstance()判断一个对象是否是 Iterator 对象:
In [56]: from collections import Iterator
In [57]: isinstance((x for x in range(10)), Iterator)
Out[57]: True
In [58]: isinstance([], Iterator)
Out[58]: False
In [59]: isinstance({}, Iterator)
Out[59]: False
In [60]: isinstance('abc', Iterator)
Out[60]: False
In [61]: isinstance(100, Iterator)
Out[61]: False
[if !supportLists]1.6.4 [endif]iter()函数
生成器都是Iterator对象,但 list 、 dict 、 str 虽然是 Iterable ,却不是 Iterator 。
把list、 dict 、 str 等 Iterable 变成 Iterator 可以使用 iter() 函数:
In [62]: isinstance(iter([]), Iterator)
Out[62]: True
In [63]: isinstance(iter('abc'), Iterator)
Out[63]: True
总结
[if !supportLists]· [endif]凡是可作用于for循环的对象都是 Iterable 类型;
[if !supportLists]· [endif]凡是可作用于next()函数的对象都是 Iterator 类型
[if !supportLists]· [endif]集合数据类型如list、 dict 、 str 等是 Iterable 但不是 Iterator ,不过可以通过 iter() 函数获得一个 Iterator 对象。
[if !supportLists]· [endif]目的是在使用迭代器的时候,减少内存的占用。
[if !supportLists]1.7 [endif]函数
递归、函数变量赋值、参数中的函数、匿名函数、闭包、偏函数
递归:
函数的递归,就是让在函数的内部调用函数自身的情况,这个函数就是递归函数。
注意:递归一定要有结束条件,否则就会成为一个死循环。
函数变量赋值:
我们可以将一个函数赋值给一个变量(注意,不是调用哦),这个这个变量也会指向该函数。
参数中的函数:
函数作为一个对象,我们同样可以将函数当成一个实际参数传递给另一个函数进行处理,这个是动态语言才用的特性,也使得动态语言变得相当的灵活和好用哦~~~
匿名函数:
例如:前面我们使用的在一个函数中,参数是另外一个函数。常规方式当我们调用的时候,需要创建一个函数,昨晚调用函数的参数。但是我们也可以使用匿名函数来完成。
匿名函数的格式如下:
lambda [参数列表]://代码【返回值不需要写return】
这样写的好处就是,代码简化,坏处就是降低了阅读性。
偏函数:
常规函数操作中,我们在函数的参数中可以添加参数的默认值来简化函数的操作,偏函数也可以做到这一点,偏函数可以在一定程度上更加方便的管理我们的函数操作
偏函数通过内置模块functools的partial函数进行定义和处理。
# functools.partial()函数语法结构
新函数名称= functools.partial(函数名称, 默认赋值参数)
# 原始的2进制数据转换 int("111", base=2)
~执行结果:7
# 引入我们需要的模块functools import functools
# 通过偏函数扩展一个新的函数int2
int2 = functools.partial(int, base=2)
# 使用新的函数,新的函数等价于上面的
int("111", base=2)
int2("111")
~执行结果:7
闭包(closure):
javascript也是解释型语言,也有闭包的概念
[if !supportLists]1.7.1 [endif]函数引用
def test1():
print("--- in test1 func----")
#调用函数
test1()
#引用函数
ret = test1
print(id(ret))
print(id(test1))
#通过引用调用函数
ret()
运行结果:
--- in test1 func----
140212571149040
140212571149040
--- in test1 func----
[if !supportLists]1.7.2 [endif]什么是闭包
#定义一个函数
def test(number):
#在函数内部再定义一个函数,并且这个函数用到了外边函数的变量,那么将这个函数以及用到的一些变量称之为闭包
def test_in(number_in):
print("in test_in函数, number_in is %d"%number_in)
return number+number_in
#其实这里返回的就是闭包的结果
return test_in
#给test函数赋值,这个20就是给参数number
ret = test(20)
#注意这里的100其实给参数number_in
print(ret(100))
#注意这里的200其实给参数number_in
print(ret(200))
运行结果:
intest_in函数, number_in is 100
120
intest_in函数, number_in is 200
220
[if !supportLists]1.7.3 [endif]看一个闭包的实际例子:
def line_conf(a, b):
def line(x):
return a*x + b
return line
line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5))
print(line2(5))
这个例子中,函数line与变量a,b构成闭包。在创建闭包的时候,我们通过line_conf的参数a,b说明了这两个变量的取值,这样,我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b,就可以获得不同的直线表达函数。由此,我们可以看到,闭包也具有提高代码可复用性的作用。
如果没有闭包,我们需要每次创建直线函数的时候同时说明a,b,x。这样,我们就需要更多的参数传递,也减少了代码的可移植性。
闭包思考:
1.闭包似优化了变量,原来需要类对象完成的工作,闭包也可以完成
2.由于闭包引用了外部函数的局部变量,则外部函数的局部变量没有及时释放,消耗内存
[if !supportLists]1.8 [endif]装饰器
装饰器是程序开发中经常会用到的一个功能,用好了装饰器,开发效率如虎添翼,所以这也是Python面试中必问的问题,但对于好多初次接触这个知识的人来讲,这个功能有点绕,自学时直接绕过去了,然后面试问到了就挂了,因为装饰器是程序开发的基础知识,这个都不会,别跟人家说你会Python, 看了下面的文章,保证你学会装饰器。
装饰器,功能就是在运行原来功能基础上,加上一些其它功能,比如权限的验证,比如日志的记录等等。不修改原来的代码,进行功能的扩展。
比如java中的动态代理,python的注解装饰器
其实python的装饰器,是修改了代码。
[if !supportLists]1.8.1 [endif]装饰器的理解
1、先明白这段代码
####第一波 ####
def foo():
print('foo')
foo #表示是函数
foo() #表示执行foo函数
####第二波 ####
def foo():
print('foo')
foo = lambda x: x + 1
foo() #执行下面的lambda表达式,而不再是原来的foo函数,因为foo这个名字被重新指向了另外一个匿名函数
2、需求来了
初创公司有N个业务部门,1个基础平台部门,基础平台负责提供底层的功能,如:数据库操作、redis调用、监控API等功能。业务部门使用基础功能时,只需调用基础平台提供的功能即可。如下:
###############基础平台提供的功能如下 ###############
def f1():
print('f1')
def f2():
print('f2')
def f3():
print('f3')
def f4():
print('f4')
###############业务部门A 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
###############业务部门B 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
目前公司有条不紊的进行着,但是,以前基础平台的开发人员在写代码时候没有关注验证相关的问题,即:基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构,为平台提供的所有功能添加验证机制,即:执行功能前,先进行验证。
老大把工作交给Low B,他是这么做的:
跟每个业务部门交涉,每个业务部门自己写代码,调用基础平台的功能之前先验证。诶,这样一来基础平台就不需要做任何修改了。太棒了,有充足的时间泡妹子...
当天Low B被开除了…
老大把工作交给Low BB,他是这么做的:
###############基础平台提供的功能如下 ###############
def f1():
#验证1
#验证2
#验证3
print('f1')
def f2():
#验证1
#验证2
#验证3
print('f2')
def f3():
#验证1
#验证2
#验证3
print('f3')
def f4():
#验证1
#验证2
#验证3
print('f4')
###############业务部门不变 ###############
###业务部门A 调用基础平台提供的功能###
f1()
f2()
f3()
f4()
###业务部门B 调用基础平台提供的功能 ###
f1()
f2()
f3()
f4()
过了一周Low BB被开除了…
老大把工作交给Low BBB,他是这么做的
本文由职坐标整理并发布,希望对同学们学习Python有所帮助,更多内容请关注职坐标编程语言Python频道!
您输入的评论内容中包含违禁敏感词
我知道了
请输入正确的手机号码
请输入正确的验证码
您今天的短信下发次数太多了,明天再试试吧!
我们会在第一时间安排职业规划师联系您!
您也可以联系我们的职业规划师咨询:
版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com,All Rights Reserved.
沪公网安备 31011502005948号