目录:

  1. 函数示例
  2. 装饰器
  3. 模块
  4. 内置函数

一、函数示例:

  1、为什么使用函数之模块化程序设计:

    不使用模块程序设计的缺点:
    1、体系结构不清晰,可主读性差;
    2、可扩展性差;
    3、程序冗长;

  2、定义函数:
    def fun(args):
      '描述信息'
      函数体
    return 返回值

  定义函数的三种形式:
    无参函数

  1. def foo():
  2. print('in the foo')
  3.  
  4. foo() 

有参函数:

  1. def bar(x,y):
  2. print('in the bar')
  3.  
  4. bar(1,2)

空函数:

  1. def func():
  2. pass

空函数的应用示例:

  1. def put():
  2. pass
  3.  
  4. def get():
  5. pass
  6.  
  7. def cd():
  8. pass
  9.  
  10. def ls():
  11. pass
  12.  
  13. def auth():
  14. pass

3、调用函数:
三种形式:
语句形式:

  1. def foo():
  2. print('in the foo')
  3.  
  4. foo()

表达式形式:

  1. def my_max(x,y)
  2. if x>y:
  3. return x
  4. else:
  5. return y
  6.  
  7. res = my_max(1,2)
  8. res = 10 * my_max(1,2)
    作为另外一个函数的参数:
    my_max(1,my_max(2,3)): #先比较2与3的最大值,再与1作比较;    

4、函数的返回值三种形式:
不返回函数:

  1. def foo():
  2. print('in the foo')
  3.  
  4. res = foo()
  5. print(res)

返回一个函数:

  1. def foo():
  2. return 1
  3. res = foo()
  4. print(res)

返回多个:

  1. def foo():
  2. return 1,'s',[1,2,3]
  3.  
  4. res = foo()
  5. print(res)

5、函数的参数:

  1. def func(x,y): #形参在调用时才真正占用内存空间,调用结束则释放内存空间;
  2. print(x)
  3. print(y)
  4.  
  5. fund(1,2) #实参真实占用内存空间;
  6.  
  7. def func(x,y):
  8. if type(x) is int and type(y) is int:
  9. return x+y
  10.  
  11. func(1,'a')
  12.  
  13. def func(x,y): #使用文档注释来提醒用户输入参数类型;
  14. '''
  15. '''
  16. return x+y
  17.  
  18. func(1,'a')
  19.  
  20. def func(x:int,y:int)->int: #只是一个提示作用;
  21. pass
  22. print(func.__annotations__)
  23.  
  24. 从实参的角度,
  25. 按位置传值:
  26. def foo(x,y):
  27. print(x,y)
  28. foo(1,2)
  29.  
  30. 按关键字传参:key = value
  31. def foo(x,y):
  32. print(x,y)
  33. foo(y=2,x=1) #优点:不用按位置来输入参数;
  34.  
  35. 针对同一个形参,要么按照位置要么按照关键字为形参传值;关键字参数必须写到位置参数的右边;
  36. 如:foo(1,x=1,y=2) 此方法会报错;
  37.  
  38. 从形参的角度:位置参数,默认参数,可变长参数*args;**kwargs;
  39. 按位置定义的形参:
  40. def foo(x,y,z): #位置参数;也就是必传值参数;
  41. print(x)
  42. print(y)
  43. print(z)
  44.  
  45. foo(1,2,3)
  46. foo(y=2,x=1,z=3)
  47.  
  48. 按默认参数的形参:
  49. def foo(x,y=1): #y就是默认参数;但也可以去赋值;默认参数建议不要使用列表或字典等可变类型;必须放在默认参数之后;
  50. print(x)
  51. print(y)
  52. foo(1)
  53.  
  54. 按可变长参数的形参:
  55. def foo(x,y=1,*args): #可变长参数必须放在位置参数与默认参数的后面;此情况一般不使用位置参数;
  56. print(x)
  57. print(y)
  58. print(args)
  59.  
  60. foo(1,2,3,4,54,6,3,y=2) #错
  61. foo(1,2,3,4,54,y=2,3,5) #错
  62. foo(1,2,3,4,54,6,3) #对
  63.  
  64. def foo(x,y,*args):
  65. print(x)
  66. print(y)
  67. print(*args)
  68.  
  69. l=['a','b']
  70. foo(1,2,*1) #*args的形式就等于1,2,3,4,5 解包;
  71.  
  72. ('a','b')
  73.  
  74. def foo(x,y,z):
  75. print(x)
  76. print(y)
  77. print(z)
  78.  
  79. # foo(1,2,3)
  80. l=[1,2,3]
  81. foo(*l)
  82.  
  83. def foo(x,**kwargs):
  84. print(x)
  85. print(kwargs)
  86.  
  87. foo(1,y=3,z=2)
  88. dic = {'a':1,'b':2}
  89. foo(1,**dic) #foo(1,a=1,b=2)
  90.  
  91. def foo(x,y,z):
  92. print(x,y,z)
  93.  
  94. foo(**{'a':1,'b':2,'c':3}) #foo(a=1,b=2,c=3),要把a,b,c改成x,y,z
  95. foo(**{'x':1,'y':2,'z':3})
  96.  
  97. 注:位置参数 -> 默认参数,*args, **kwargs
  98. 1、*args 相当于展开按照位置的方式去写;
  99. 2、**kwargs 相当于把kwargs按照关键字的方式去写;

6、函数是第一类对象的意思就是函数可以被当作数据来传递;

  1. def func()
  2. print('in the fun')
  3.  
  4. fl = fun
  5. fl()
  6.  
  7. 函数可作为参数:高阶函数:
  8. def foo(x):
  9. x()
  10. foo(func)
  11.  
  12. 返回值可以是函数:
  13. ##########################################
  14.  
  15. 可以作为容器类型的元素:
  16. func_dic={
  17. 'func':func
  18. }
  19.  
  20. func_diuc['func']()

7、函数的嵌套:分为两种:

  1. 嵌套的调用:
  2. def my_max1(a,b,c,d):
  3. res1=my_max(a,b)
  4. res2=my_max(res1,c)
  5. res3=my_max(res2,d)
  6. return res3
  7.  
  8. def my_max(x,y):
  9. if x > y:
  10. return x
  11. else:
  12. return y
  13.  
  14. print(my_max1(100,2,-1,5))
  15. 嵌套的定义: python支持静态的嵌套域;
  16. x=1
  17. def f1():
  18. def f2():
  19. print(x)
  20. #def f3():
  21. # print(x)
  22. #return f3
  23. return f2
  24.  
  25. f2=f1()
  26.  
  27. 闭包函数:
  28. def f1():
  29. x=1
  30. def f2():
  31. print(x)
  32. return f2
  33.  
  34. f = f1()
  35. f()
  36.  
  37. 示例:
  38. from urllib request import urlopen #用来爬网页;
  39. def page(url):
  40. def get():
  41. return urlopen(url).read()
  42. return get
  43.  
  44. baidu = page('http//ww.baidu.com')
  45. python = page('http://www.python.org')
  46. baidu()

二、装饰器

装饰器:在遵循下面的两个原则 的前提下为被修饰者添加新功能;
函数功能的扩展原则:
1、一定不能修改源代码;
2、不能改变函数的调用方式;

装饰器本身是一个函数,被装饰的也是一个函数;

示例:

  1. def index():
  2. print('in the ndex')
  3. index()
  4.  
  5. @timer #表示方法:index = timer(index)
  6. def index():
  7. print('in the ndex')
  8. index()
  9.  
  10. 装饰器的叠加:
  11. @deco3
  12. @deco2
  13. @deco1 #func1 = deco1(index) --> func2=deco2(func1) --> index= deco3(func2)====>index=deco3(deco2(deco1(index)))
  14. def index():
  15. print('in the ndex')
  16. index()
  17.  
  18. 示例:
  19. from urllib request import urlopen #用来爬网页;
  20. import time
  21. def timer(func):
  22. def wrapper():
  23. print('in the wrapper-->start')
  24. start_time=time.time()
  25. func()
  26. print('in the wrapper-->stop')
  27. return wrapper
  28.  
  29. @timer #表示方法:index = timer(index)
  30. def index():
  31. print('in the ndex')
  32. index()
  33.  
  34. from urllib request import urlopen #用来爬网页;
  35. import time
  36. def timer(func):
  37. def wrapper(*args,**kwargs): #一定不要写死;
  38. print('in the wrapper-->start')
  39. start_time=time.time()
  40. res=func(*args,**kwargs) #home('tom',msg='xxxx')-->home(user,msg) *与位置等同
  41. func(msg) #运行最原始的index -> index(msg)
  42. print('in the wrapper-->stop')
  43. return res
  44. return wrapper
  45.  
  46. @timer #表示方法:index = timer(index)
  47. def index(msg):
  48. print('in the ndex',msg)
  49.  
  50. @timer
  51. def home(user,msg):
  52. print('in the home %s %s',%(user,msg)
  53. return 1 #返回值要写在wrapper中
  54.  
  55. index('hello world')
  56. home('tom',msg='xxxx')

三、模块

什么是模块:
模块就是一个包含了python定义和声明的文件;文件名就是模块名字加上.py的后缀;

模块只会被导入一次,第一次会导入到内存中,第二次再导入直接去内存调用

模块的导入:
第一次导入模块三个事件:
1、创建新的作用域;
2、在该作用域内执行顶级代码;
3、得到一个模块名,绑定到该模块内的代码;

  1. 为模块起别名:
  2. import spam as sm
  3. print(sm.money)
  4. from spam import read1 as rea
  5.  
  6. 导入多个模块:
  7. import ms,spam,re
  8. from spam import (read1,change)可写入多行;
  9.  
  10. 导入模块的另外一种形式:
  11. from .. import ..
  12. from spam import read1
  13. read1()

总结:
从那来就从哪执行,与调用的位置无关;

  1. module中所有非下划线开头的名称导入:
  2. from module import *
  3. __all__ = ['money','read1']

注:
模块不支持重载;要加载需要重启程序;

  1. 把文件当做和脚本执行__name__等于'__main__'
  2. print(__name__)
  3. spam.py文件当作模块去使用__name__等于'spam'
  4.  
  5. if __name__ = '__main__':
  6. print('文件被当作脚本执行时触发的代码')
  7.  
  8. 可以控制python代码在不同场景下运行的代码;

模块路径的查找:
import sys
sys.path
路径的查找先找内置的路径,再找其他的路径;
来源:
1、当前目录;
2、python path
3、安装时依赖的一些目录;

sys.path.append(r'/test') #当前目录有效;
r表示对特殊字符的转义;
sys.path.insert(0,r'/test') #从0的位置插入;

导入模块时,先从内建中找相同的模块名,找不到就去sys.path中找;

dir()
不会列举出内建模块的名字;
import builtins
dir(builtins)

包:
包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

无论是import形式还是from...import形式,凡是在导入语句中(而不是在使用时)遇到带点的,都要第一时间提高警觉:这是关于包才有的导入语法

包的本质就是一个包含__init__.py文件的目录。

from ... import ...

需要注意的是from后import导入的模块,必须是明确的一个不能带点,否则会有语法错误,如:from a import b.c是错误语法

__init__.py文件

不管是哪种方式,只要是第一次导入包或者是包的任何其他部分,都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下),这个文件可以为空,但是也可以存放一些初始化包的代码。

from glance.api import *

在讲模块时,我们已经讨论过了从一个模块内导入所有*,此处我们研究从一个包导入所有*。

  1. 此处是想从包api中导入所有,实际上该语句只会导入包api__init__.py文件中定义的名字,我们可以在这个文件中定义__all___:
  2.  
  3. #在__init__.py中定义
  4. x=10
  5.  
  6. def func():
  7. print('from api.__init.py')
  8.  
  9. __all__=['x','func','policy']

此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容(versions仍然不能导入)。

示例:

  1. from glance.api import *
  2. 只会运行api下的__init__.py文件;
  3.  
  4. api\__init__.py中输入:
  5. __all__ = ['policy','versions']
  6.  
  7. import只能导入内建与第三方的模块,否则会出错;

四、内置函数

  1. 内置函数解释:
  2.  
  3. # !/usr/bin/env python
  4. # -*- coding:utf-8 -*-
  5.  
  6. #返回数字的绝对值。 参数可以是整数或浮点数。 如果参数是复数,则返回其大小。
  7. print(abs(-1.11))
  8.  
  9. #传入一个可被循环的元素,如果这个元素中有一个为False则都为假
  10. # 0 空值 False 都为假
  11. print(all([1,2,3]))
  12.  
  13. #与all相反,只有一个为真,则为真;
  14. print(any([0,2,False]))
  15.  
  16. #这个函数跟repr()函数一样,返回一个可打印的对象字符串方式表示。当遇到非ASCII码时
  17. #就会输出\x,\u或\U等字符来表示。与Python 2版本里的repr()是等效的函数。
  18. print(ascii("dsads"),ascii(66),ascii('b\23'))
  19.  
  20. #将十进制转换为二进制;
  21. print(bin(10))
  22.  
  23. #返回布尔值,即True或False之一,如果参数为false或省略,则返回False; 否则返回True。
  24. print(bool(1))
  25.  
  26. #根据传入的参数创建一个新的字节数组
  27. #如果传入字符串必须给出编码
  28. print(bytearray('你好','utf-8'))
  29. #当source参数是一个可迭代对象,那么这个对象中的元素必须符合大于0 小于256
  30. print(bytearray([256,1,2]))
  31.  
  32. #返回一个的“bytes”对象,返回bytes类型
  33. bytes('中文','utf-8')
  34.  
  35. #检查对象是否可以被调用
  36. def func():
  37. pass
  38. print(callable(func))
  39.  
  40. #返回整数所对应的Unicode字符,chr(97)返回字符串'a',而chr(8364)返回字符串'€'。
  41. print(chr(126))
  42.  
  43. #是用来指定一个类的方法为类方法,类方法可以不实例化直接调用
  44. class A:
  45. @classmethod
  46. def B(cls,arg1,):
  47. print(arg1)
  48. A.B(1)
  49. A().B(1)
  50.  
  51. #将源编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
  52. #源可以是正常字符串,字节字符串或AST对象。
  53. expr = "5+5-1"
  54. obj = compile(expr,"","eval")
  55. print(eval(obj))
  56.  
  57. #返回值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。
  58. print(complex(1, 2))
  59. print(complex(1))
  60. print(complex("1+2j"))
  61.  
  62. # 参数是一个对象和一个字符串。 该字符串必须是对象属性之一的名称。
  63. class A:
  64. def a1(self):
  65. print("a1")
  66. def a2(self):
  67. print("a2")
  68.  
  69. obj = A
  70. print(dir(obj))
  71. delattr(obj, "a1")
  72. print(dir(obj))
  73.  
  74. #dir 返回对象中的方法
  75. strs="aaa"
  76. print(dir(strs))
  77.  
  78. #返回两个数值的商和余数
  79. print(divmod(7,3))
  80.  
  81. #用于遍历序列中的元素以及它们的下标
  82. print(enumerate([1,2,3]))#返回的是可迭代的对象
  83. for i,j in enumerate(('A','B','C')):
  84. print(i,j)
  85.  
  86. #将字符串str当成有效的表达式来求值并返回计算结果。
  87. print(eval("1+2+3"))
  88. print(eval("False or True"))
  89.  
  90. #字符串str当成动态语句块执行并返回结果
  91. exec('a=1+2+3')
  92. print(a)
  93.  
  94. #使用指定方法(方法,函数),过滤可迭代对象的元素
  95. def add(arg):
  96. return arg > 3
  97.  
  98. for i in filter(add,[1,2,3,4,5]):
  99. print(i)
  100.  
  101. #浮点型
  102. print(float(11))
  103.  
  104. #格式化显示 更多方法请参考官方说明
  105. print('{:,.2f}'.format(111111))
  106.  
  107. #根据传入的参数创建一个新的不可变集合
  108. a = frozenset([1,2,3,4,5])
  109. print(a)
  110.  
  111. #获取对象的属性值
  112. class A():
  113. def __init__(self,):
  114. self.name = "123"
  115. b = A()
  116. print(getattr(b,'name'))
  117.  
  118. #返回当前作用域内的全局变量和其值组成的字典
  119. print(globals())
  120.  
  121. #检查对象是否含有属性
  122. class A():
  123. def __init__(self,):
  124. self.name = "123"
  125. b = A()
  126. print(hasattr(b,'name'))
  127.  
  128. #哈希值计算
  129. #在当前环境中是唯一的
  130. print(hash('Hello'))
  131.  
  132. #help帮助
  133. def funcs(args):
  134. """
  135. Function description
  136. :param args: args = list
  137. :return:
  138. """
  139. pass
  140. print(help(funcs))
  141.  
  142. #转换16进制
  143. print(hex(44))
  144.  
  145. #显示对象的标识符
  146. print(id("123"))
  147.  
  148. #input标准输入
  149. s = input("user name:")
  150. print(s)
  151.  
  152. #int返回整数
  153. print(int(1.2))
  154. print(int("2"))
  155.  
  156. #判断对象是否是类或者类型元组中任意类元素的实例
  157. print(isinstance("1",int))
  158. print(isinstance(1.1,(int,float)))
  159.  
  160. #判断类是否是另外一个类或者类型元组中任意类元素的子类
  161. print(dir(str))
  162. print(issubclass(bytearray,str))
  163. print(issubclass(bool,int))
  164.  
  165. #根据传入的参数创建一个新的可迭代对象
  166. a = iter('12345')
  167. print(next(a))
  168. print(next(a))
  169.  
  170. #返回对象的长度len
  171. a = [1,2,3,4]
  172.  
  173. #转换列表
  174. print(list("abcd"))
  175.  
  176. #返回当前作用域内的局部变量和其值组成的字典
  177. def A():
  178. print(locals())
  179. s = 1
  180. print(locals())
  181. A()
  182.  
  183. #使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象
  184. def add(x):
  185. return x+100
  186. lists = [1,2,3,4]
  187. for i in map(add,lists):
  188. print(i)
  189.  
  190. #max:返回最大值
  191. print(max(1,2,3))
  192. print(max([1,2,3,4]))
  193.  
  194. #在进行切片并赋值数据时,不需要重新copy原列表数据,可以直接映射原数据内存;
  195. s = memoryview(b'abcd')
  196. print(s[1])
  197.  
  198. #返回最小值
  199. print(min(1,2,3))
  200. print(min([2,3]))
  201.  
  202. #返回可迭代对象中的下一个元素值
  203. a = iter('1234')
  204. print(next(a))
  205.  
  206. #创建一个新的object对象(新式类)
  207. class B(object):
  208. pass
  209.  
  210. #转化成8进制数字符串
  211. print(oct(10))
  212.  
  213. #open文件操作
  214. file = open('test.txt',encoding="utf-8")
  215.  
  216. #ord:返回Unicode字符对应的整数
  217. print(ord("A"))
  218.  
  219. #幂运算
  220.  
  221. print(pow(2,3))
  222.  
  223. #标准输出
  224. print()
  225.  
  226. #property:标示属性的装饰器
  227. #类中使用具体方法请百度,或者等待后续更新
  228. property
  229.  
  230. #range:根据传入的参数创建一个新的range对象
  231. range(10)
  232. range(1,10)
  233.  
  234. """repr()函数得到的字符串通常可以用来重新获得该对象,repr()的输入对python比较友好。
  235. 通常情况下obj==eval(repr(obj))这个等式是成立的。"""
  236. obj='Python'
  237. print(eval(repr(obj)))
  238.  
  239. #翻转序列
  240. a = reversed([1,2,3,4,5])
  241. print(list(a))
  242.  
  243. #round:对浮点数进行四舍五入求值
  244. print(round(1.5))
  245.  
  246. #set 转换成集合
  247. print(set([1,2,3]))
  248.  
  249. #setattr:设置对象的属性值
  250. class A():
  251. def __init__(self,age):
  252. self.age = age
  253. s = A(11)
  254. print(s.age)
  255. setattr(s,'age',22)
  256. print(s.age)
  257.  
  258. #根据传入的参数创建一个新的切片对象
  259. c1 = slice(3)
  260. c2 = slice(2,4)
  261. c3 = slice(0,5,2)
  262. s = [1,2,3,4,5,6]
  263. print(s[c1])
  264. print(s[c2])
  265. print(s[c3])
  266.  
  267. #排序,返回一个新的列表默认按字符ascii码排序
  268. a = [4,3,2,1,7]
  269. print(sorted(a))
  270.  
  271. #标示方法为静态方法的装饰器
  272. class B(object):
  273. def __init__(self,age):
  274. self.age = age
  275.  
  276. @staticmethod
  277. def hello(args):
  278. print(args)
  279.  
  280. B.hello("Hello World")
  281.  
  282. #字符串类型
  283. print(str(123))
  284.  
  285. #求和
  286. print(sum([1,2,3,4]))
  287.  
  288. #根据传入的参数创建一个新的子类和父类关系的代理对象
  289. class A(object):
  290. def __init__(self):
  291. print("我是 A Clase")
  292.  
  293. class B(A):
  294. def __init__(self):
  295. print("我是 B Class")
  296. super().__init__()
  297. b = B()
  298.  
  299. #元祖
  300. tuple([1,2,3,4])
  301.  
  302. #type 返回对象的类型
  303. print(type([1]))
  304. print(type("1"))
  305.  
  306. #返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表
  307. def func():
  308. print(vars())
  309. s = 1
  310. print(vars())
  311. func()
  312.  
  313. #聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器
  314. list1 = [1,2,3]
  315. list2 = ["A","B","C","D"]
  316. print(zip(list1,list2))
  317. for i in zip(list1,list2):
  318. print(i)
  319.  
  320. #__import__:动态导入模块
  321. __import__

  

  

python基础编程: 函数示例、装饰器、模块、内置函数的更多相关文章

  1. python 基础篇 14 程程器表达式 内置函数

    昨日内容回顾    可迭代对象:        内部含有__iter__方法的就是可迭代对象.        可迭代对象不能取值,因为内部不含有__next__方法.     可迭代对象 ---> ...

  2. 万恶之源 - Python装饰器及内置函数

    装饰器 听名字应该知道这是一个装饰的东西,我们今天就来讲解一下装饰器,有的铁子们应该听说,有的没有听说过.没有关系我告诉你们这是一个很神奇的东西 这个有多神奇呢? 我们先来复习一下闭包 def fun ...

  3. Python装饰器、内置函数之金兰契友

    装饰器:装饰器的实质就是一个闭包,而闭包又是嵌套函数的一种.所以也可以理解装饰器是一种特殊的函数.因为程序一般都遵守开放封闭原则,软件在设计初期不可能把所有情况都想到,所以一般软件都支持功能上的扩展, ...

  4. python笔记5:装饰器、内置函数、json

    装饰器 装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象. 先看简单例子: def run(): time.sleep(1 ...

  5. Python装饰器及内置函数

    装饰器 听名字应该知道这是一个装饰的东西,我们今天就来讲解一下装饰器,有的铁子们应该听说,有的没有听说过.没有关系我告诉你们这是一个很神奇的东西 这个有多神奇呢? 我们先来复习一下闭包 def fun ...

  6. 【Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数】

    一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(Firs ...

  7. python 之 面向对象(多态性、装饰器方法 内置函数补充)

    7.6 多态性 1 什么是多态性 多态指的是同一种事物多种形态,在程序中用继承可以表现出多态.多态性:可以在不用考虑对象具体类型的前提下而直接使用对象下的方法 2.为什要用多态 用基类创建一套统一的规 ...

  8. 文成小盆友python-num4 装饰器,内置函数

    一 .python 内置函数补充 chr()  -- 返回所给参数对应的 ASCII 对应的字符,与ord()相反 # -*- coding:utf-8 -*- # Author:wencheng.z ...

  9. Python--函数对象@命名空间与作用域@包函数@装饰器@迭代器@内置函数

    一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(Firs ...

  10. day0318装饰器和内置函数

    一.装饰器 1.装饰器: 解释:装饰器的本事就是一个函数,不改动主代码的情况下,增加新功能.返回值也是一个函数对象. 2.装饰器工作过程 import time def func(): print(' ...

随机推荐

  1. Vue+element 需要用到拖拽组件 vuedraggable

    新需求是要求界面上的14个可以拖拽,点击保存之后保存拖拽之后的顺序. 确定需求之后肯定第一时间是百度,发现有个插件vuedragger拖拽,按照教程就懵懂的开始了. 官方示例:https://davi ...

  2. 自动化运维:(3)写一个简单的Shell脚本(案例)

    一.需求 1.test.sh 脚本执行时候需要添加参数才能执行 参数和功能详情如下: 参数 执行效果 start 启动中... stop 关闭中... restart 重启中... * 脚本帮助信息. ...

  3. 企业证书发布app到七牛云服务

    ---恢复内容开始--- 最近在做企业证书发布app,从申请企业证书,到测试程序发布到七牛云存储.整了几天终于实现了,整理一下资料. 1.首先,申请企业证书. 到苹果开发网站申请企业证书 https: ...

  4. 安装mysql-proxy

    1.下载安装包 wget https://cdn.mysql.com/archives/mysql-proxy/mysql-proxy-0.8.5-linux-glibc2.3-x86-64bit.t ...

  5. matlab作业之m文件的建立与使用运行

    画曲线y=xsin(ex-x),要求编写m文件,qx1.m,要求有标注 实现方法: 打开matlab,点击左上角新建 然后打开编辑器 在编辑器里输入函数语句 ctrl+s保存,这里的名字要命名成××× ...

  6. IDEA 2019.2.2破解激活方法(激活到2089年8月,亲测有效)

    本来笔者这边是有个正版激活码可以使用的,但是,2019.9月3号的时候,一些小伙伴反映这个注册码已经失效了,于是拿着自己的 IDEA, 赶快测试了一下,果不其然,已然是不能用了. 好在,笔者又找到了新 ...

  7. [转帖]PKI系统深入介绍

    PKI系统深入介绍 https://blog.csdn.net/liuhuiyi/article/details/7776825 2012年07月23日 20:17:01 liuhuiyi 阅读数 4 ...

  8. Luogu P4426 [HNOI/AHOI2018]毒瘤

    题目 神仙题. 首先我们可以把题意转化为图的独立集计数.显然这个东西是个NP-Hard的. 然后我们可以注意到\(m\le n+10\),也就是说最多有\(11\)条非树边. 我们现在先考虑一下,树上 ...

  9. paramiko-ssh-sftp实例

    import paramiko transport = paramiko.Transport(('192.168.71.136', 22)) transport.connect(username='r ...

  10. Java 反射理解(二)-- 动态加载类

    Java 反射理解(二)-- 动态加载类 概念 在获得类类型中,有一种方法是 Class.forName("类的全称"),有以下要点: 不仅表示了类的类类型,还代表了动态加载类 编 ...