python学习之路---函数：定义def、调用、返回值return、参数说明、参数陷阱

 

1. #函数

2. #可读性强，复用性强

3. #函数定义：定义了之后，可以在任何需要的地方调用

4. #格式： def 函数名()： 例子：def mylen():

5. # 没有返回长度，只能单纯的打印

6. # return 返回值的重要性 定义了一个函数，建议都带一个返回值,不然无法进行赋值

7. #完整例子：def 函数名():

8. #            函数体

9. #            return 返回值

10.  

11. # #定义函数后，无返回值

12. # s = '杰瑞你好啊'

13. # def mylen():

14. #     n = 0

15. #     for i in s :

16. #         n += 1

17. #     print(n)

18. # mylen()

19. # len1 = mylen()

20. # print(len1)

21. #

22. # #定义函数后，有返回值

23. # s = '杰瑞你好啊'

24. # def mylen():

25. #     n = 0

26. #     for i in s :

27. #         n += 1

28. #     print(n)

29. #     return n

30. #

31. # len1 = mylen()

32. # print(len1)

33.  

34. #返回值

35. #返回值的三种情况

36.     # 没有返回值 ---当没有返回值的时候默认返回None

37.         # 不写return

38.         # 直接写return 不加值,结束一个函数的继续，即return后面的都不执行了

39.         # return None  --- 不常用

40.     # 返回1个值

41.         # 可以返回任意一种数据类型

42.         # 只要返回就可以接受到

43.         # 如果在一个程序种有多个retrun，那么只执行第一个

44.     # 返回多个值

45.         # 多个返回值用多个变量接收，有多少返回值就用多少变量接收。

46.         # 用一个变量接受：得到的是一元组，元组为不可以变数据类型

47.  

48. # 没有返回值

49. # def test():

50. #     l = ['jerry','tom']

51. #     for i in l:

52. #         print(i)

53. #         #return

54. #         #retrun None

55. # test()

56.  

57. #返回一个值

58. # def test():

59. #     l = ['jerry','tom']

60. #     a = {}

61. #     for i in l:

62. #         a.setdefault(i)

63. #     return a

64. #

65. # test = test()

66. # print(test)

67.  

68. #返回多个值

69. # def test():

70. #     l = ['jerry','tom']

71. #     a = {}

72. #     for i in l:

73. #         a.setdefault(i)

74. #     return a,l

75. #

76. # test = test()

77. # print(test)

78.  

79. # 小知识点：传递参数

80. # 定义一个函数并赋予参数

81. # 没定义参数时，只能计算指定的变量名

82. # 定义参数后，可以计算任意的值

83. # 没定义参数

84. # s = '你好啊'

85. # def my_len():

86. #     i = 0

87. #     for k in s:

88. #         i+=1

89. #     return i

90. #

91. # ret = my_len()

92. # print(ret)

93.  

94. #定义参数

95. # s1 = '你好哈'

96. # def my_len1(a):  # 自定义参数只需要0个参数，接受参数，形式参数：形参

97. #     i = 0

98. #     for k in a:  # a 必须和形参是一致的

99. #         i += 1

100. #     return i

101. #

102. # ret1 = my_len1(s1)  # 传递参数：传参，实际参数：实参

103. # ret2 = my_len1('你是谁啊')  # 传递参数

104. # print(ret1,ret2)

105.  

106. #参数的语法---写在括号内的值

107.  

108. #参数

109.     # 没有参数

110.         # 定义函数和调用函数时括号里都不写内容

111.     # 有一个参数

112.         # 传什么就是什么

113.     # 有多个参数

114.         # 位置参数

115. # 站在实参的角度上：

116.     # 按照位置传参

117.     # 按照关键字传参

118.     # 混着用也可以，但是必须先按照位置传参，再按照关键字传参，不能同时给一个变量传多个值

119.  

120. #典型传输多个参数：典型的位置参数

121. # def my_sum(a,b):

122. #     c = a + b

123. #     return c

124. #

125. # ret = my_sum(1,2)  # 位置传参

126. # ret2 = my_sum(a=2,b=1)  # 关键字传参

127. # print(ret,ret2)

128.  

129. # def classmate(name,sex='men'):  # 默认参数 sex = 'men'

130. #     print('%s : %s'%(name,sex))

131. #

132. # classmate('jerry')

133. # classmate('jerry')

134. # classmate('Amy','woman')  # 若有参数，则修改默认参数

135. # classmate('jerry')

136.  

137. # 站再形参的角度上：

138.     # 位置参数：必须传，且不能多传以及少传

139.     # 默认参数：可以不传，如果不写则使用默认参数，若写了就用设置的参数替换默认参数

140.  

141. # 只有调用函数的时候

142.     # 按照位置传：直接写参数的值

143.     # 按照关键字传： 关键字 = 值 如 open( file, encoding = 'utf-8')

144.  

145. # 定义函数的时候：

146.     # 位置参数：直接定义参数

147.     # 默认参数： 关键字参数: 参数名 = ‘默认值’

148.     # 动态参数： 可以接受任意多个参数

149.         # 在定义参数的时候 前面加多个*  例子：def my_len(*aaaa)

150.         # 约定俗成 都是以 *args 为动态参数

151.     # 顺序：先定义位置参数，*args，再设置默认参数，最后**kwargs

152. # 动态参数有两种

153.     # *args: 接收的是按照位置传参的值，组成一个元组

154.     # **kwargs:接收的是关键字传参的值，组曾一个字典

155.  

156. # 按照位置传参

157. # def classmate(*args):  # 默认参数 sex = 'men'

158. #     n = 0

159. #     for i in args:

160. #         n += i

161. #     return n

162. #

163. # print(classmate(1,2))

164. # print(classmate(1,2,3))

165. # print(classmate(1,2,3,4))

166.  

167. # 按照关键字传参

168. # def func(**kwargs):

169. #     print(kwargs)

170. #

171. # func(a = 1,b=2,c=3)

172. # func(b=2,c=3)

173. # func(c=3)

174.  

175. # 动态参数的另一种传参方式

176. # def func(*args):  # 站在形参的角度上，给变量加上*，就是组合所有传来的值

177. #     print(args)

178. #

179. # func(1,2,3,4,5,6)

180. # l = [2,1,3,6,5,2]

181. # func(*l)  # 站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散

182.  

183. # def func(**kwargs):

184. #     print(kwargs)

185. #

186. # func(a=1,b=2)

187. # d = {'a':1,'b':2}

188. # func(**d)

189.  

190. #函数的注释

191. def func():

192.     '''

193.     这个函数实现了什么功能

194.     参数1：

195.     参数2：

196.     :return:

197.     '''

198.     pass

199.  

200. #默认参数的陷阱

201. #如果默认参数的的值是一个可变数据类型，那么每次调用函数时，如果不传值就公用这个 数据类型的资源

202. def test(l= []):

203. l.append(1)

204. print(l)

205.  

206. test()

207. test()

208. test()

209. test([])

210. test()

211.  

212. def test1(dic = {}):

213. dic['k'] = 'v'

214. print(dic)

215.  

216. test1()

217. test1()

218. test1()

219. test1()

220.  

221. def test1(k,dic = {}):

222. dic[k] = 'v'

223. print(dic)

224.  

225. test1(1)

226. test1(2)

227. test1(3)

228. test1(4)