Python学习笔记（4）

5 自定义功能单元

前面介绍的内建函数不少，如输入、输出、zip()、range（）等

5.1 使用函数

必须先申明，然后才能调用

按照定义的形式，向函数传递必须的参数

5.1.1 声明函数

def <函数名> (参数列表):

<函数语句>

return <返回值>

In [2]:

def hello():
    print('Python')
hello()

Python

5.1.2 调用函数

In [5]:

def tpl_sum(z):
    result = 0
    for i in z:
        result += i
    return result

print(tpl_sum([1,2,3,4]))

10

5.2 深入函数

5.2.1 默认值参数

In [9]:

def hello(name='python'):  #定义了一个默认的参数
    print(name)
hello()
hello('beautiful')
hello(1)

python
beautiful
1

In [13]:

def hello(name='python',test='beauti'):
    print('%s,%s' % (name,test))
hello(1)
hello('kankan')
hello(1,'kankan') #第一个参数是必须有的，没有就会报错

1,beauti
kankan,beauti
1,kankan

5.2.2 参数传递

In [19]:

def hello(name='python',test='beauti',test2='xxxxx'):
    print('%s,%s,%s' % (name,test,test2))
hello(name='1')
hello(1,test='ddddd',test2='wwwww')
hello(1,test2='22222222',test='ddddd') #返回的参数位置并没有发生变化
hello(1,test2='kankan') #后面的参数可以按照参数名来传递数值

1,beauti,xxxxx
1,ddddd,wwwww
1,ddddd,22222222
1,beauti,kankan

5.2.3 可变数量参数传递

In [21]:

def hello(*tpl):  #参数名前加*，便是该参数就是一个可变长参数，元组，可参考下面字典的方式
    print(type(tpl))
    print(tpl)
    
hello(1)
hello(1,2,3)
hello(1,'abcd',(1,2,3))

<class 'tuple'>
(1,)
<class 'tuple'>
(1, 2, 3)
<class 'tuple'>
(1, 'abcd', (1, 2, 3))

In [27]:

def cube(name,**z):  #在不清楚参数有多少的情况下，可以用**并加all_nature以字典的方式收集参数
    all_nature = {'x':1,
                 'y':1,
                 'z':1,
                 'color':'white',
                 'weight':1}
    all_nature.update(z)
    print(name,"立方体的属性：")
    print('体积：',all_nature['x']*all_nature['y']*all_nature['z'])
    print('颜色：',all_nature['color'])
    print('体重：',all_nature['weight'])
    print('-----------------------------------')
    
cube('first')
cube('second',y=3,color='red')
cube('third',z=2,color='green',weight=10)

first 立方体的属性：
体积： 1
颜色： white
体重： 1
-----------------------------------
second 立方体的属性：
体积： 3
颜色： red
体重： 1
-----------------------------------
third 立方体的属性：
体积： 2
颜色： green
体重： 10
-----------------------------------

5.2.4 拆解序列的函数调用

In [28]:

def mysum(a,b):
    return a+b

print(mysum(*(3,4))) #用*来拆解元组
print(mysum(**{'a':3,'b':4})) #用**来拆解字典

7
7

5.2.5 函数调用时参数的传递方法

Python中的元素有可变和不可变之分，不可变的有整数、浮点数、字符串、元组等，可变的有列表和字典

在函数调用时，若提供的是不可变参数，那么在函数内部对其修改时，在函数外部其值是不可变的；若提供可变参数，则在函数内部对它修改时，在函数外部其值也会改变。

In [31]:

def change(aint,alst):
    aint = 0
    alst[0] = 0
    alst.append(4)
    print('aint:',aint)
    print('alst:',alst)
    
aint = 3
alst = [1,2,3]
print('qianaint:',aint)
print('qianalst:',alst)
change(aint,alst)
print('houaint:',aint) #change并没有对这里产生影响，再看一例
print('houalst:',alst)

qianaint: 3
qianalst: [1, 2, 3]
aint: 0
alst: [0, 2, 3, 4]
houaint: 3
houalst: [0, 2, 3, 4]

In [34]:

def myfun(lst=[]):
    lst.append('abc')
    print(lst)
    
myfun()
myfun()
myfun() #空列表被传入了数值，这时再看上面的列子，list作为参数时，不想被添加返回值的时候
        #一定要进行给一个默认值，例如：lst=None

['abc']
['abc', 'abc']
['abc', 'abc', 'abc']

In [36]:

def myfun(lst=None):
    lst = [] if lst is None else lst  #必须定义空值，不能为None
    lst.append('abc')
    print(lst)
    
myfun()
myfun()
myfun()

['abc']
['abc']
['abc']

5.3 变量的作用域

内置作用域:Python预先定义的

全局作用域：整个程序

全局作用域：某个函数内部

In [37]:

def myfun():  #可以看出并不互相影响，如果要影响怎么处理？看下例
    a=0
    a+=3
    print('nei:',a)
    
a = 'wai'

print('quanju:',a)
myfun()
print('quanju:',a)

quanju: wai
nei: 3
quanju: wai

In [39]:

def myfun():
    global a     #增加该语句，使a变成了全局变量
    a=0
    a+=3
    print('nei:',a)
    
a = 'wai'

print('quanju:',a)
myfun()
print('quanju:',a) #打印出来看出这里发生了变化

quanju: wai
nei: 3
quanju: 3

5.4 使用匿名函数 lambda

5.5 常用内建函数

help(obj)  显示对象的帮助信息

bin(aint)  十进制数转换为二进制数的字符串形式

hex(aint)  十进制数转换为十六进制数的字符串形式

oct(aint)  十进制数转换为八进制数的字符串形式

callable(obj)  测试对象是否可调用

chr(aint)  ascii码转为字符

ord(char)  将字符转为ascii码

filter(seq)  对序列中的数据用函数过滤

map(seq)  对序列中的数据逐个变换

isinstance(obj,typerstr)  测试对象是否为某类型

In [40]:

help(abs)

Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the argument.

In [41]:

bin(20)

Out[41]:

'0b10100'

In [42]:

hex(20)

Out[42]:

'0x14'

In [43]:

oct(20)

Out[43]:

'0o24'

In [44]:

callable(abs)

Out[44]:

True

In [45]:

aa=3
callable(aa)

Out[45]:

False

In [47]:

chr(97)

Out[47]:

'a'

In [48]:

ord('a')

Out[48]:

97

In [50]:

alst = [0,1,2,3,4]
list(filter(lambda x:x % 2,alst))

Out[50]:

[1, 3]

In [53]:

alst = [0,1,2,3,4]
list(map(lambda x:2*x,alst)) #用lambda定义一个匿名函数，并通过map函数，将其应用到列表中

Out[53]:

[0, 2, 4, 6, 8]

In [52]:

isinstance('abc',str)

Out[52]:

True

转载于:https://my.oschina.net/zhackj/blog/1632701