码迷,mamicode.com
首页 > 编程语言 > 详细

python基础05

时间:2018-05-18 22:17:48      阅读:255      评论:0      收藏:0      [点我收藏+]

标签:参数调用   encoding   理解   多个   spring   icm   形参和实参   数据对象   cab   

Python基础学习05


函数


一、什么是函数

定义:函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可

特性:
1.减少重复代码
2.使程序变的可扩展
3.使程序变得易维护

语法定义:

技术分享图片
1 def test():        #test为函数名
2     print("in the test..")
3 test()        # 用test函数
4 
5 def test_1(x,y): #带参数的函数
6     print(x)
7     print(y)
8 
9 test_1(2,3)   #调用时必须传入参数(实参)
View Code

 二、参数

1、形参实参

形参:形式参数,不是实际存在,是虚拟变量。在定义函数和函数体的时候用形参,目的是在函数调用时接收实参(实参个数,类型应与实参一一对应),形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参:实际参数,调用函数时传给函数的参数,可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使参数获得确定值

区别:形参是虚拟的,不占用内存空间,形参变量只有在被调用时才分配内存单元,实参是一个变量,占用内存空间,数据传送单向,实参传给形参,不能形参传给实参 

技术分享图片
1 def test_1(x,y): #x,y为形参
2     print(x)
3     print(y)
4 test_1(2,3)   #调2,3为实参
View Code

2、位置参数调用与关键字调用

技术分享图片
 1 #位置参数和关键字(标准调用:实参和形参一一对应,关键字调用:位置无需固定)
 2 
 3 def test_1(x,y):
 4     print(x)
 5     print(y)
 6 test_1(2,3)   #这种调用为位置参数调用,形参和实参必须一一对应
 7 
 8 def test_1(x,y):
 9     print(x)
10     print(y)
11 test_1(y=3,x=2)   #这种调用为关键字调用,位置无需固定
12 
13 def test_1(x,y,z):
14     print(x)
15     print(y)
16     print(z)
17 test_1(2,z=4,y=3)   #既有位置参数调用,又有关键字调用时,位置调用参数必须写在关键字调用参数之前
View Code

3、默认参数,可变参数

技术分享图片
 1 #默认参数
 2 def test_1(x,y=3):  #y为默认参数
 3     print(x)
 4     print(y)
 5 test_1(2)         #调用时可以不赋值,如果不赋值则y=3 结果为:2,3
 6 test_1(2,4)       #调用时如果赋值,则y=4(调用时赋的值) 结果为:2,4
 7 #默认参数特点:调用函数的时候,默认参数非必须传值
 8 
 9 #可变参数(参数组)
10 def test_2(*args):     #可以接收多个值
11     print(args)
12 test_2(1,2,3,4,5,6)    #直接传递参数,结果以元组的形式输出:(1, 2, 3, 4, 5, 6)
13 test_2(*[1,2,3,4,5,6])  #或者在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去,结果同上
14 
15 def test_3(x,*args):
16     print(x,args)
17 test_3(1,2,3,4,5,6)   #输出:1 (2, 3, 4, 5, 6)
18 
19 def test_2(**kwargs):     #可以接收多个关键字参数
20     print(kwargs)
21 test_2(name="zz",age="2")  #将关键字参数转换成字典的形式:{‘age‘: ‘2‘, ‘name‘: ‘zz‘}
22 test_2(**{age: 2, name: zz})   #同上
View Code

三、其他特性

1、作用域:局部与全局变量

在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时:在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。

技术分享图片
1 name = "aaa"
2 def change_name(name):
3     print("before change:",name)       #aaa
4     name = "zzz"
5     print("after change", name)        #zzz
6 change_name(name)
7 print("在外面的name",name)             #aaa
View Code

2、返回值

返回值的目的是要想获取函数的执行结果,函数在执行过程中只要遇到return语句,就会停止执行并返回结果,return 语句代表着函数的结束;如果未在函数中指定return,那这个函数的返回值为None 

3、匿名函数

匿名函数就是不需要显式的指定函数,只能处理比较简单的运算例如:三元运算,不能处理判断循环等复杂运算。匿名函数主要是和其它函数搭配使用

技术分享图片
1 #常规函数定义
2 def calc(n):
3     return n**n
4 print(calc(10))
5 
6 #换成匿名函数
7 calc = lambda n:n**n
8 print(calc(10))
View Code

 4、递归

在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。 

递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时,问题规模相比上次递归都应有所减少
3. 递归效率不高,递归层次过多会导致栈溢出(递归上限999次)

技术分享图片
 1 def num(n):
 2     print(n)
 3     if int(n/4) ==0:
 4         return n
 5     return num(int(n/4))
 6 num(20)
 7 ‘‘‘输出:
 8 20
 9 5
10 1
11 ‘‘‘
View Code

四、内置函数

技术分享图片

技术分享图片
  1 #abs() 返回数字的绝对值
  2 print(abs(-32))  #输出:32
  3 
  4 #all() 如果可迭代对象中所有元素都为真则返回真
  5 print(all([1,-1,2]))    #输出:True(非0即真)
  6 print(all([0,-1,2]))    #输出:False
  7 
  8 #any()  如果可迭代对象中任意元素为真则返回真
  9 print(any([0,-1,2]))    #输出:True
 10 print(any([]))           #输出:False
 11 
 12 #ascii() 把一个内存对象变成一个可打印的字符串
 13 print([ascii([1,-1,2])])   #输出:[‘[1, -1, 2]‘]
 14 
 15 #bin() 十进制数字转二进制
 16 print(bin(12))   #输出:0b1100
 17 
 18 #bool  判断真假
 19 print(bool("asd"))    #输出:True(非0即真)
 20 print(bool([]))       #输出:False
 21 
 22 #bytearray  可修改的二进制字节格式(没啥用)
 23 b = bytearray("abcd",encoding="utf-8")
 24 print(b[1])   #输出:98   (ascii码的值)
 25 b[1] = 99     #必须是ascii码的值
 26 print(b)      #输出:bytearray(b‘accd‘)
 27 
 28 #bytes() 返回值为一个新的不可修改字节数组
 29 b = bytes("abcd",encoding="utf-8")
 30 print(b)        #输出:b‘abcd‘
 31 
 32 #callable()  判断是否可以调用
 33 print(callable([1,2]))   #输出:False 列表不可调用,函数可调用
 34 
 35 #chr()  返回数字对应的ascii码表中对应字母
 36 print(chr(100))      #输出:d
 37 
 38 #ord()   返回字母对应的ascii码表中的数字
 39 print(ord("d"))     #输出:100
 40 
 41 #classmethod()  #类方法,修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等
 42 class A(object):
 43     bar = 1
 44     def func1(self):
 45         print (foo)
 46     @classmethod
 47     def func2(cls):
 48         print (func2)
 49         print (cls.bar)
 50         cls().func1()   # 调用 foo 方法
 51 A.func2()               # 不需要实例化
 52 """输出:
 53 func2
 54 1
 55 foo
 56 """
 57 
 58 #compile() #底层的,用于把代码进行编译(用不到)
 59 
 60 #complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数
 61 print(complex(1, 2))    #输出:(1+2j)
 62 # 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
 63 print(complex("1+2j"))  #输出:(1+2j)
 64 
 65 #delattr() 函数用于删除属性(面向对象:delattr()、getattr()、hasattr()、setattr())
 66 class Coordinate:
 67     x = 10
 68     y = -5
 69     z = 0
 70 point1 = Coordinate()
 71 print(x = ,point1.x)
 72 print(y = ,point1.y)
 73 print(z = ,point1.z)
 74 delattr(Coordinate, z)
 75 print(--删除 z 属性后--)
 76 print(x = ,point1.x)
 77 print(y = ,point1.y)
 78 # 触发错误
 79 # print(‘z = ‘,point1.z)  #AttributeError: ‘Coordinate‘ object has no attribute ‘z‘
 80 
 81 #dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。
 82 print(dir()) #输出:[‘A‘, ‘Coordinate‘, ‘__builtins__‘, ‘__cached__‘, ‘__doc__‘, ‘__file__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, ‘b‘, ‘point1‘]
 83 
 84 # divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。
 85 print(divmod(7, 2))  #输出:(3, 1)
 86 
 87 #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
 88 seasons = [Spring, Summer, Fall, Winter]
 89 print(list(enumerate(seasons)))  #输出:[(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fall‘), (3, ‘Winter‘)]
 90 print(list(enumerate(seasons, start=1)) )      # 下标从 1 开始[(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fall‘), (4, ‘Winter‘)]
 91 for i, element in enumerate(seasons):
 92     print (i, seasons[i])
 93 ‘‘‘0 Spring
 94 1 Summer
 95 2 Fall
 96 3 Winter
 97 ‘‘‘
 98 
 99 #eval() 执行一个字符串表达式,并返回表达式的值。
100 print(eval( 3 * 2 ))  #输出:6
101 
102 #exec()  执行一个文件
103 # exec(hello.py)
104 
105 #filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
106 #过滤出1~100中平方根是整数的数:
107 import math
108 def is_sqr(x):
109     return math.sqrt(x) % 1 == 0
110 newlist = filter(is_sqr, range(1, 101))
111 for i in newlist:
112     print(i)   #在py2中为列表,3中为迭代器需要循环打印
113 
114 filter(lambda n:n>5,range(10))  #也可以用匿名函数
115 
116 #float() 将整数和字符串转换成浮点数
117 print(float("123"))  #输出:123.0
118 print(float(123))
119 
120 #format()  格式化输出
121 
122 #frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
123 print(frozenset(range(10))) #frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
124 
125 #getattr() 函数用于返回一个对象属性值。(面向对象)
126 
127 #globals() 以字典类型返回当前位置的全部全局变量。
128 print(globals())
129 
130 #hasattr() 用于判断对象是否包含对应的属性。(面向对象)
131 
132 #hash() 用于获取取一个对象(字符串或者数值等)的哈希值。
133 print(hash("asdf"))  #输出:5704709918237842944
134 
135 #help() 用于查看函数或模块用途的详细说明。
136 help(sys)
137 help(str)
138 a = [1,2,3]
139 help(a)
140 help(a.append)
141 
142 #hex() 函数用于将10进制整数转换成16进制,以字符串形式表示
143 print(hex(100))  #输出:0x64
144 
145 #id() 函数用于获取对象的内存地址。
146 a = "a"
147 print(id(a))  #输出:3231243404264
148 
149 #input() 函数接受一个标准输入数据,返回为 string 类型
150 #int() 函数用于将一个字符串或数字转换为整型。
151 #isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。
152 a = 2
153 print(isinstance (a,int))      #  True
154 print(isinstance (a,str))      #  False
155 print(isinstance (a,(str,int,list)))    # 是元组中的一个返回 True
156 
157 ‘‘‘isinstance() 与 type() 区别:
158 type() 不会认为子类是一种父类类型,不考虑继承关系。
159 isinstance() 会认为子类是一种父类类型,考虑继承关系。
160 如果要判断两个类型是否相同推荐使用 isinstance()。
161 ‘‘‘
162 class A:
163     pass
164 class B(A):
165     pass
166 print(isinstance(A(), A))    #  True
167 print(type(A()) == A  )      #  True
168 print(isinstance(B(), A) )   #  True
169 print(type(B()) == A )       #  False
170 
171 #issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。(面向对象)
172 #iter() 用来生成迭代器
173 lst = [1, 2, 3]
174 for i in iter(lst):
175     print(i)
176 
177 #len() 方法返回对象(字符、列表、元组等)长度或项目个数
178 str = "runoob"
179 print(len(str) )            # 字符串长度:6
180 l = [1,2,3,4,5]
181 print(len(l)  )             # 列表元素个数:5
182 
183 #locals() 函数会以字典类型返回当前位置的全部局部变量。(参考globals)
184 print(locals())
185 
186 #map() 会根据提供的函数对指定序列做映射。
187 #第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
188 def square(x) :            # 计算平方数
189     return x ** 2
190 map(square, [1,2,3,4,5])   # 计算列表各个元素的平方:[1, 4, 9, 16, 25]
191 map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数:[1, 4, 9, 16, 25]
192 # 提供了两个列表,对相同位置的列表数据进行相加
193 map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])  #[3, 7, 11, 15, 19]
194 #py3中结果为迭代器需循环打印
195 
196 #max() 方法返回给定参数的最大值,参数可以为序列。
197 print(max(1,3,4,2,0))   #输出:4
198 #min() 方法返回给定参数的最小值,参数可以为序列。
199 print(min(1,3,4,2,0))   #输出:0
200 
201 #memoryview() 函数返回给定参数的内存查看对象(Momory view)。所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。
202 #next() 返回迭代器的下一个项目。
203 #object() 定义对象
204 #oct() 函数将一个整数转换成8进制字符串。
205 print(oct(100))   #输出:0o144
206 
207 #open() 文件操作
208 #pow() 方法返回 xy(x的y次方) 的值
209 print(pow(3,4))   #输出:81
210 
211 #print() 方法用于打印输出,最常见的一个函数。
212 #property() 函数的作用是在新式类中返回属性值。(面向对象)
213 #range() 函数可创建一个整数列表,一般用在 for 循环中
214 #repr() 函数将对象转化为供解释器读取的形式
215 #reverse() 函数用于反向列表中元素(列表操作中的一样)
216 aList = [123, xyz, zara, abc, xyz]
217 aList.reverse()
218 print("List : ", aList) #输出:List :  [‘xyz‘, ‘abc‘, ‘zara‘, ‘xyz‘, 123]
219 
220 #round() 方法返回浮点数x的四舍五入值。
221 print(round(1.234,2))  #输出:1.23
222 
223 #set() 函数创建一个无序不重复元素集(参考创建集合)
224 #setattr 函数对应函数 getatt(),用于设置属性值,该属性必须存在。(面向对象)
225 #slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。
226 #sorted() 函数对所有可迭代的对象进行排序操作。
227 ‘‘‘
228 sort 与 sorted 区别:
229 sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
230 list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
231 ‘‘‘
232 a = [5,7,6,3,4,1,2]
233 b = sorted(a)       # 保留原列表
234 print(a)            #[5, 7, 6, 3, 4, 1, 2]
235 print(b)            #[1, 2, 3, 4, 5, 6, 7]
236 
237 L=[(b,2),(a,1),(c,3),(d,4)]
238 print(sorted(L, key=lambda x:x[1]) )              #  [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]
239 
240 students = [(john, A, 15), (jane, B, 12), (dave, B, 10)]
241 sorted(students, key=lambda s: s[2])            # 按年龄排序[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
242 sorted(students, key=lambda s: s[2], reverse=True)      # 按降序[(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
243 
244 #staticmethod 返回函数的静态方法(面向对象)
245 #str() 函数将对象转化为适于人阅读的形式
246 #sum() 列表求和计算
247 #super() 函数是用于调用父类(超类)的一个方法(面向对象)
248 #tuple() 将列表转换为元组
249 #type()  所有数据类型的根源
250 #vars() 返回对象object的属性和属性值的字典对象
251 #zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
252 # 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
253 a = [1,2,3]
254 b = [4,5,6]
255 c = [4,5,6,7,8]
256 zipped = zip(a,b)     # 打包为元组的列表[(1, 4), (2, 5), (3, 6)]
257 zip(a,c)              # 元素个数与最短的列表一致[(1, 4), (2, 5), (3, 6)]
258 zip(*zipped)          # 与 zip 相反,可理解为解压,返回二维矩阵式[(1, 2, 3), (4, 5, 6)]
259 #py3中为迭代器,需循环打印
260 
261 #__import__() 函数用于动态加载类和函数 。
262 # 如果一个模块经常变化就可以使用 __import__() 来动态载入。
View Code

 

python基础05

标签:参数调用   encoding   理解   多个   spring   icm   形参和实参   数据对象   cab   

原文地址:https://www.cnblogs.com/hy0822/p/9058025.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!