python之三 函数

内容

•  函数基本语法及特性
• 参数与局部变量
• 返回值
• 递归
• 匿名函数
• 函数式编程
• 高阶函数
• 内置函数

　　1. 函数基本语法及特性

面向对象：类--->> cleass
面向过程：过程---->> def
函数式编程：函数---->> def

def test(): #def 定义方式 test 函数名 （）可以写各种各样的参数 :写子函数
   “the function ”
    x +=1
    return x
"" 文档的描述
x +=1 代码块或程序处理逻辑
return 定义返回值

函数
def func1():
    """test"""
    print('in the func1')
    return 0

过程 没有返回值的函数 在python当中
def func2():
    """test2"""
    print('in the func2')
x = func1()
y = func2()

　　什么是函数

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

　　特性

　　　　代码重用

　　　　保持一致性提高代码的可扩展性

 　　 返回值

def test():
    print('in the test')
    return 0
x = test()
print(x)

 

def test1():
    print('in the test1')

def test2():
    print('in the test2')
    return 0

def test3():
    print('in the test3')
    return 1,"hello"
x = test1()
y = test2()
z = test3()
print(x)
print(y)
print(z)

打印结果
in the test1
in the test2
in the test3
None
0
(1, 'hello')

 

 总结：

　　返回值数=0 返回none

　　返回值=1：返回object

　　返回值>1: 返回tuple

问题：

　　为什么要有返回值

　　　　因为想要整个函数的执行结果是什么，因为后面的程序可能根据执行结果来执行下面的操作。

　　　2. 参数与局部变量

　　　　形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

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

位置参数与关键参数

def test(x,y):
    print(x)
    print(Y)
test(y=2,x=1)#与形参顺序无关   关键参数
test(1,2) #与形参一一对应    位置参数

　　关键参数

　　　　正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。

 　　默认参数

def test(x,y=2)
    print(x)
    print(y)
test(1)

打印结果
1
2
#默认参数特点：调用函数的时候，默认参数可有可无
#用途：默认安装
      # 2.链接数据库端口号 mysql

　　参数组

　　　　两个参数*args,*kwargs

 

# #参数组 *args *后面的参数可以任意写
def test(*aggs):
    print(aggs)
test(1,2,3,4,5,6)
test(*[1,2,3,4,5,6]) #arggs=tuple([1,2,3,4,5,6])

打印结果

(1, 2, 3, 4, 5, 6)
(1, 2, 3, 4, 5, 6)

#*args打印元组 接受n个位置参数，转换成元组参数

#**kwargs 接受n个关键字参数，转换成字典的方式
def test2(**kwargs): #**kwargs 接受n个关键字参数，转换成字典的方式
    print(kwargs)
test2(name='zhang san',age=8,sex='n')

打印结果
{'age': 8, 'name': 'zhang san', 'sex': 'n'}

def test4(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)
#
test4('zhang san ',age=34,sex='m',hobby='tesla')

打印结果

zhang san 
34
{'sex': 'm', 'hobby': 'tesla'}

 局部变量a全局变量 #没有搞明白

　　递归

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

def calc(n):
    print(n)
    if int(n/2) >0:
        return calc(int(n/2))
    print("-->",n)

calc(100)

打印结果
100
50
25
12
6
3
1
--> 1

 递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

 

7. 高阶函数

 　　变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

 

def add(a,b,f):
    return f(a)+f(b)
res = add(3,-6,abs)
print(res)

应用场景尚且不明

    内置函数

 

>>> n = abs(-1)   #取绝对值
>>> print(n)
1

>>> print(bool(0))   #布尔值，0，None，“”，[],() 这些就是false
False
>>> print(bool(1))
True

>>> n = all([1,2,3])   #  全部为真才是真 否则，就为假
>>> print(n)
True
>>> n = all([1,2,3,None])
>>> print(n)
False

>>> n = any([[],0,1])  只要有一个为真就是真
>>> print(n)
True

 ascii()#自动执行对象的_str_方法  现在不用太关心 

# bin() #接受十进制 会把值转成二进制
# oct()#接受十进制 会把值转成八进制
# hex()#接受十进制 会把值转成十六进制
print(bin(5))
print(oct(9))
print(hex(15))
打印结果

0b101
0o11
0xf

字符串想转换字节类型就必须要用bytes
#bytes(只要转换的字符串，按照什么编码

字节转换字符串
使用str() 接受一个字节
str(bytes(“张三“，encoding="utf-8),encoding="utf-8")

# 一个汉字utf-8 是三个字节   gbk是两个字节
#utf-8
s = "张三" #一个字节8位，一个汉字三个字节 也就是说 一个汉字 24位
# 010000000 010000000  010000000     010000000    010000000  010000000
#    23       23          23              23          23        23
#     2f      2a          2c              2c           2e      2f
n = bytes(s,encoding="utf-8") # 字节类型
print(n)
n1 = bytes(s,encoding="gbk")
print(n1)

打印结果
b'\xe5\xbc\xa0\xe4\xb8\x89'
b'\xd5\xc5\xc8\xfd'

def f1():#callable()检查是否会调用
    pass
f2 = 123
print(callable(f1))
print(callable(f2))
打印结果
True
False

# 对应表的关系
#chr()
#ord()
r = chr(65)
print(r)
n = ord("B")
print(n)

打印结果
A
66

# 可以做一个随机验证码
import random
# i = random.randrange(65,91)
# c = chr(i)
# print(c)
li = []
for i in range(6):
    temp = random.randrange(65, 91)
    c = chr(temp)
    li.append(c)

ret = "".join(li)
print(ret)
#打印结果
PKZUMC

#没有数字

#完整的随机生成数
import random
li = []

for i in range(6):
    r = random.randrange(0,10)
    if r ==2 or r == 4 or r ==5:
        num = random.randrange(0,10)
        li.append(str(num))
    else:
        temp = random.randrange(65, 91)
        c = chr(temp)
        li.append(c)

ret = "".join(li)
print(ret)

目前不用太了解

# compile()  就是将字符串编译成一个python代码
# eval()
# exec()
# python s1.py
# 1. 读取文件内容open， str到内存
# 2. python，内部 把字符串 --> 编译成一个特殊的代码
# 3. 执行代码


s = "print(123)"
#编译single,单行的python程序 eval, exec#编译成跟python代码一模一样的东西
r = compile(s,"<string>","exec")
print(r)
打印结果
<code object <module> at 0x000001AAFA415C00, file "<string>", line 1>
123

#执行
exec(r) 执行python代码，或字符串 没有返回值

evel # 用来处理表达式 有返回值

s ="8*8"
ret = eval(s)
print(ret)
打印
64

# print(dir(dict)) #快速查看一个对象提供了那些功能
# help(list)#ide 用不着
#共97， 每页10 条 ，需要多少页
r = divmod(97,10)
print(r[0])
print(r[1])


s = "abc"
r = isinstance(s,str)  用来判断对象是否是某个类的实列
print(r)


# filter(函数，可迭代对象)  把大于22 的数给打印出来
def f2(a):
    if a >22:
        return  True
li = [11,22,33,44,55]
ret = filter(f2,li)
print(list(ret))

打印结果
[33, 44, 55]


#filter 循环第二个参数，让每个循环元素执行 函数， 如果函数返回值True，表示元素合法

li = [11,22,33,44,55]
result = filter(lambda a:a >33,li)
print(list(result))

打印结果
[44, 55]

#map     函数返回True，将元素添加到结果中
#filter  将函数返回值添加到结果中
# li = [11,22,33,44,55]
# def f1(args):
#     ret = []
#     for i in args:
#         ret.append(100+i)
#     return
# map(函数，可迭代的对象（可以for循环的东西)
li = [11,22,33,44,55]
# def f2(a):
#     return a + 100
result = map(lambda a:a + 100,li)
print(list(result))

NAME = "world"
def show():
    a = 123
    c = 123
    print(locals())
    print(globals())
show()

s = "hhhsadfasdfsadfasdfd"
print(hash(s))

s = "你好"
print(len(s)) #3.用字符来计算 2.用字节来计算
打印结果
2

a = max([11,22,33,44])
b = min([11,22,33,44])
c = sum([11,22,33,44])
print(a,b,c)
打印结果
44 11 110

r = pow(2,10) #求次方
print(r)
打印结果

1024

d = round(1.8)  四舍五入
print(d)

li = [11,22,1,1]  一样
li.sort()
sorted(li)



# zip
l1 = ["scott",11,22,33]
l2 = ["is",11,22,33]
l3 = ["good",11,22,33]
r = zip(l1,l2,l3)
# print(list(r))
temp = list(r)[0]
ret = " ".join(temp)
print(ret)
打印结果
scott is good

 要会的内置函数

abs()
all()
any
bin()
bool()
bytes()
chr()

 

dict()
dir()
divmod()
enumerate()
eval()
exec()
filter()
float()

 

help()
hex()
id()
input()
int()
isinstance()

en()
list()
locals()
map()
max()

min()
oct()
open()
ord()
pow()
print()
range()
round()
set()

str()
sum()
tuple()
type()
zip()