函数部分

5.1 三元运算（三目运算）

5.1.1 定义和格式

  • 一行写出一个简单的条件判断语句

v = 1 if v == y else 2 
​
if v == y:
    v = 1
else:
    v = 2         # 基本格式

5.2 函数的基本内容

5.2.1 函数的格式

  • 有时因为实际情况需要重复不止一遍写相同的代码，导致整个代码在读起来一是可读性差，二是可重用性差

  • 将重复使用的代码打包，在合适的时候调用

def list():    # 设置函数
    pass
​
list()         #调用函数

5.2.2 参数

def get_list_first_data(aaa): # v = [11,22,33,44]print(v[aaa])  aaa为形式参数
    
get_list_first_data(1) # 1/2/3/0为实际参数
get_list_first_data(2)
get_list_first_data(3)
get_list_first_data(0)
5.2.2.1位置参数

  • 依据变量的前后位置，逐个进行赋值的叫位置参数。

def func(a,b,c,d):
    print(a,b,c,d)
a (90,80,'zl','qaz')  #1对1对应， 对号入座
5.2.2.2关键字参数

  • 使用等号对变量直接进行赋值

def func(a,b,c,d):
	print(a,b,c,d)
func(a=90,d=60,b=80,c=70)  #对变量直接赋值，可以不遵循对号入座，顺序没有要求（前提是只有关键字参数）
5.2.2.3 参数混用

  • 关键字和位置参数的混用，为了避免python混乱，位置参数必须在关键字参数前面

  • 如果形参里有关键字参数，实际参数重新赋值，以实参为准

def func(a,b,c,d):
	print(a,b,c,d)
func(90,'qaz',b=80,c=70)  

def func(a1,a2,a3=9,a4=10)
    print(a1,a2,a3,a4)
func(11,22)		#(11,22,9,10)            
func(11,22,10)		#(11,22,10,10)  
func(11,22,10,100)		#(11,22,10,100)  
func(11,22,10,a4=100)		#(11,22,10,100)  a4可以重新赋值
func(11,22,a3=10,a4=100)		#(11,22,10,100)  
func(11,a2=22,a3=10,a4=100)			#(11,22,10,100)				
func(a1=11,a2=22,a3=10,a4=100)			#(11,22,10,100)
5.2.2.4 万能参数

  1. *args 将实际参数的所有值打包发给 *args 可以是任何值，打包类型默认为元组。 只能使用位置参数

    def func(*args):
    print(args)
func(11,22,33,44)  

    def func(*args):
    print(args)
func(*(11,22,33,44)) #(11,22,33,44)
func((11,22,33,44))   #((11,22,33,44),)
func(*[11,22,33,44])  #(11,22,33,44)

  2. **kwargs 将实际参数的所有值打包发给形参，只能使用关键字传参，打包类型默认为字典

    def func(**kwargs):
    print(*kwargs)
func('k1'=11,'k2'=22,'k3'=33,'k4'=44)  #返回**kwargs为  {'k1':1,'k2':2,'k3':3,'k4':4}

  3. *args 和 **kwargs可以混用

    def func(*args,**kwargs):
    print(args,kwargs)
func(111222,*[123,66],k11='alex',**{'k1':1,'k2':3}) #(111222, 123,66) {'k11': 'alex', 'k1': 1, 'k2': 3}

5.2.3 返回值

  • 返回值有且仅有一个数， 可以是元组 、字典、布尔、整型等等，充分利用返回值执行条件判断

  • return和print不同, **对于一个函数func, func只是使用内存地址，func()代表立即执行。

def func(v1):
    return v1 * 2

def bar(arg):
    msg = "%s 是什么玩意？" %(arg,)
    print(msg)

val = func('你')
data = bar(val)
print(data)     #data 没有值， bar并没有return 函数只会调用 输出结果，不会返回值     

def list():
	pass
	return True    #返回值，函数在执行到这一步 之后的均不再执行

content = list()
print(content)     #获取返回值，可以根据返回值判别条件

5.2.4 作用域

  • 函数的作用域的含义指的是函数的每个作用范围。

  • 函数的作用域的查找规则,，如果子级作用域没有需要的变量，就去上一级寻找,上一级如果没有,接着往上寻找，直到全局变量，如果还没有,便会直接报错。

  • 全局或者上一级的变量在子级无法被修改，尤其是变量赋值是不可变量的情况下，如字符串,整型,元组(元组里可能存在嵌套不符合这个情况)。例外的情况：

    • 变量赋值是字符串等可变类型的情况下，子级作用域可以修改父级作用域。

    COUNT = [11,22,33,44]  #当元组是（11，22，[33,44]）也可以修改，子级元素的修改
def sun():
    COUNT.append(55)    #追加可以执行
    print(COUNT) 
sun()            #[11,22,33,44，55] 
print(COUNT)     #[11,22,33,44，55] append是加在全局变量里的

    • 使用global/nonlocal可以强制在子级作用域修改父级或者全局变量，#不常用

    COUNT = '12345'
def sun():
    global COUNT      #global可以强制改变， global是命令，本身不改变，下面不赋值，global不生效
    COUNT = '78910'
    print(COUNT)   
sun()              #'78910'
print(COUNT)       #'78910' 已改变全局变量

    Count = '12345'
def sun():
    count = '66'
    def grand_sun():
        nonlocal count
        count = '88'
        print(count)
    grand_sun()   #'88'  
    print(count)     
sun()             #'88'  #父级已因为子级 变量已更改，注意要在调用参数后 修改才起变化，类比下面
print(count)      #'12345'  #全局不受影响，因为孙级改变的是子级

    Count = '12345'
def sun():
    count = '66'
    print(count)
    def grand_sun():
        nonlocal count
        count = '88'
        print(count)
    grand_sun()   #'88'    
sun()             #'66'    #父级在子级还未调用执行时，就已经输出了结果
print(count)      #'12345'

5.2.5 函数的嵌套

  • 函数可以如if和while等语句进行嵌套，嵌套时应该注意上述笔记所写的，子级与父级及全局变量的等级关系。

  • 嵌套时书写要求：全局变量记得大写，增加代码可阅读性

5.3函数的变法使用

5.3.1 函数作为变量

def func():
	pass
func()    #这是调用函数，如果函数有输出，则直接输出函数的结果
a = [func,func,func]   #这是func内没有括号，只是用了func的内存地址
for i in a：
	i()                #可以通过这种方式对函数进行循环调用，  即 函数可在列表a里做变量

func_list1 = [func,func,func]          #这个结果不会是None,而是输出内存地址
func_list2 = [func(),func(),func()]

5.3.2 函数作为参数

  • 函数可以进行参数传递，方便来回调用

def func():
	print(11)
def show(a):
    a()
show(func)     #调用show函数，show函数里调用 func()  最后输出func()的结果

def func(arg):
    v1 = arg()
    print(v1)
def show():
    print(666)
func(show)     #调用func函数，func()函数里调用show()函数，输出结果666， 但是没有返回值 所以func输出none

5.3.3 函数作为返回值

  • 函数除了上述外，还可以作为返回值，返回时一般储存的也是函数的内存地址。（返回func 储存地址 返回func()立即执行结果,如果此时func没有返回值，则结果是None）

def func():
    print(123)
def bar():
    return func
v = bar()  #返回的func的内存地址赋值给v 
v()        #执行v() 相当于func() 执行
5.3.3.1 闭包

  • 闭包的含义：将函数的功能保存到一块区域（类似一个包裹），以便需要的时候调用

  • 一个闭包就是调用一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。

def func(name):
    def inner():
        print(name)
    return inner
v1 = func('alex')
v1()
v2 = func('eric')
v2()

#经典面试题
func_list = []
for i in range(10):
    func_list.append(lambda x:x+i)
for i in range(0,len(func_list)):
    result = func_list[i](i)   #执行func_list[0](0)时，执行第一个lambda,x+i=i+i 这时i=0 结果为0
    print(result)
0 2 4 6 8 10 12 14 16 18

5.4 高阶函数

  • 把函数当作参数

  • 函数做变量

  • 函数做返回值

以上均为高阶函数

5.5 内置函数

  • 输入输出 input print

  • 数学相关 max min divmod（商，余数)） abs（绝对值） round（四舍五入）

  • 其他 len type range id open

  • 格式相关 int str bool list dict tuple set oct bin hex ord chr

    a = chr(68)
    print(a)   #chr  把十进制的数字转化成unicode中对应的字符串
    a = ord('亏')
    print(a)   #ord 把unicode中收录的所有的信息转化成十进制的数字，注意不能批量转换

5.5.1 高阶内置函数

5.5.1.1 map

  • 共有两个参数，循环第二个参数中的所有数，并执行参数一 里面的功能（一般是函数，尤其是lambda)，执行完会生成新的列表返回，注意用list

    a = [1,2,3,4]
    v = map(lambda b:b+100,a)
    print(list(v)) 
    #map 和filter的第二个参数只要是可迭代对象就可以
5.5.1.2 filter

  • 共有两个参数，跟map用法类似，区别是map的目的是将一组数字或者多个元素进行加工，输入输出相同，而filter主要是筛选的功能

    a = [1,2,'qaz',3,'血亏',4]
v = filter(lambda b:str(b).isdecimal(),a)    #str(b).idecimal 返回值是True或者是False,用于筛选
print(list(v)

    a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
newlist = list(filter(lambda x:x%2==0, a))
print(newlist)
5.5.1.3 reduce

  • 与map和filter不同，reduce在最新的py3版本中移出了内置函数，需要执行调用，另外输入是两个值，作用是输入一堆元素，输出一个值

  • 用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

    import functools
a = [1,2,3,4]
v = functools.reduce(lambda a,b:a+b,a)
print(v)
5.5.1.4 type

  • 判断对象是否是类的实例

    class Foo:
    pass

obj = Foo()

if type(obj) == Foo:
    print('obj是Foo类的对象')
5.5.1.5 issubclass

  • 判断派生类和基类的从属关系

    class Base:
    pass

class Base1(Base):
    pass

class Foo(Base1):
    pass

class Bar:
    pass

print(issubclass(Bar,Base))  #如果是，则返回True,否则返回False
print(issubclass(Foo,Base))
5.5.1.6 isinstance

  • 判断对象是否是类或基类的实例 #没有type严谨

    class Base(object):
    pass

class Foo(Base):
    pass

obj = Foo()

print(isinstance(obj,Foo))  # 判断obj是否是Foo类或其基类的实例（对象）
print(isinstance(obj,Base)) # 判断obj是否是Foo类或其基类的实例（对象）
5.5.1.7 super

  • 按照self对象所属类的继承关系，按照顺序挨个找func方法并执行（只找第一个）

  • 即super()是根据第二个参数(obj)来计算MRO，根据顺序查找第一个参数(类)之后的类的方法

    class Base(object): # Base -> object
    def func(self):
        super().func()
        print('base.func')

class Bar(object):
    def func(self):
        print('bar.func')

class Foo(Base,Bar): # Foo -> Base -> Bar
    pass

obj = Foo()
obj.func()
5.5.1.8 zip

  • 拉链方法 一一对应

    val = zip(('a','b','c'),(1,2,3))
print(list(val))
#---> [('a',1),('b',2),('c',3)]

5.6 匿名函数

  • lambda匿名函数

  • 定义：不需要def来命名，一句话声明一个函数，执行有返回值

lambda的基本表示式： template = lambda a,b:a**b   #匿名函数收到a,b的命令， 并返回a+b的运算结果
template() #跟别的函数一样，也需要执行

def func(a):
    return a*3
print(func(2))  # 6
#即等于
fu = lambda a:a*3
print(fu(2))

NUM = 100
def func()
    num = 100
    template = lambda a: a+num
    b = template(1)
    print(b)
func()          #lambda依然遵循子级找不到 逐级上找的要求

5.7 进制

  • 任何进制的转换都必须经过十进制， 即int

  • 十进制转换为二进制：bin

    a = 105
    b = bin(a)
    print(b)

  • 十进制转换为八进制：oct

    a = 105
    b = oct(a)
    print(b)

  • 十进制转换为十六进制：hex

    a = 105
    b = hex(a)
    print(b)

  • 其他进制转换为十进制：

    a = 10011000
    b = int(a,base = 2)  #base 如果不输入默认为10，int本身也是整型的意思，几进制输入几
posted @ 2019-11-02 17:00  Kn19ht  阅读(77)  评论(0)    收藏  举报