学习python入门基础——函数

　　1.概念：一段可以被另外一段代码执行的程序，命名：用小驼峰（例如：test01）
　　　　　
　　2.语法：def 函数名(参数)：
　　　　　　　　函数体
　　　　　　　　return 需要的返回值
　　3.调用
　　　　1）函数名(参数)

def test_function():
    print('我是一个测试函数')
print('w ')             #优先执行
test_function()         #函数调用，函数调用后才会执行

　　　　2）在类的内部：self.函数名

def eating(self):
    print(self.Dog.name,'正在吃骨头。。。')
    print('狗颜色',self.color)
    self.sleep()        #self.函数名
def sleep(self):
    print('类私有属性',self.Dog.__dog_color)
    print('类实例私有属性',self.__kind)

　　　　3）在类的外部：类实例/类().函数名

a=Dog()              #实例化
print(a.name)        #类属性访问：类实例.类属性名称
print(a.eating())

　　4.参数
　　　　1）必传参数

• • •  　　　   必须要传对应个数的参数
    • 　　　　参数传递必须以正确的顺序传入，参数的传递位置要与实际期望值一一对应

def test_function(name,age):
    print(name,age)
test_function('老王',20)

　　　　2）关键字参数

def test_function(name,age):
    print(name,age)
test_function(name='老李',age=28)

　　　　3）不定长参数

• • •            　*args：可以传任意多个参数，通过tuple接收【必传参】

def test_function(*args):
    print(args)
test_function('老王',20,9)　　#打印出(老王，20，9)

• • • 　　　　**kwargs：不确定需要传递多少个参数时，使用关键字参数的形式传递【关键字参数】，通过dict接收

def test_function(**kwargs):
    print(kwargs)
test_function(name='老王',age=20,grade=9)　　　　#打印出{'name':'老王','age':'20','grage':'9'}

• • • 　　　　如果*args和**kwargs同时存在时，**kwargs必须在后面，打印时不能带*号

def test01(*args, **kwargs):
    print(args)
    print(kwargs)
test01(1, 2, 3, 4, 5, name='name', age=20)

　　　　4）默认参数
　　　　　　函数定义时给了默认值，如果函数调用时传了参数，就用传的参数，否则就用默认参数

def test01(name='老王', age=20):
    print(name, age)
test01()                 #调用时不传参数，则打印老王，20
test01('老李',25)         #调用时传入参数，则打印老李，25

　　5.函数的返回值：return
　　　　1）如果需要返回值，就写return 返回内容

def test01(name):
    return name
result =test01(name='zhang')
print(result)           #打印zhang

　　　　2）如果不需要返回值，就不需要写，默认返回None

def test01(name):
    return
result =test01(name='zhang')
print(result)           #打印zhang None

　　　　3）return是函数执行结束的标识，函数执行遇到return则结束

def test02():
    for i in range(10):
        print(i)
        if i == 3:
            print('test')
        elif i==4:
            return              #当i=4时，程序就直接结束了，不再进行循环
print('外循环')
test02()

　　　　4）不同分支return的内容尽量保持同一数据类型
　　　　5）return与print区别：

• • • 　return是把变量或者值返回给调用者，不会在控制台展示，属于内存里传递
    • 　print将变量输出到控制台显示

　　6.拆包
　　　　1）*：将可迭代对象拆包成元组形式

def test01(*args):
    print(args)
list01=[1,2,3,4]
test01(*list01)         #相当于test01(1,2,3,4)，输出(1,2,3,4)

　　　　2）**：将可迭代对象拆包成字典形式

def test01(**args):
    print(args)
dict01={'key1':'3','key2':'ddf'}
test01(**dict01)        #相当于test01(key1='3',key2='ddf')，输出{'key1':'3','key2':'ddf'}

　　7.变量作用域
　　　　1）局部变量（定义在函数里面）

def test01():
    name = 'lisi'       #定义在函数里面，叫局部变量
    print(name)
test01()

　　　　2）全局变量（定义在函数外面）

name = "zhangsan"       #定义在函数外面，叫全局变量
def test02():
    print(name)
test02()

　　　　3）global：将局部变量设置成全局变量

　　　　　　　　　global test_str  ：固定写法，只能定义，不能赋值，且赋值内容是不可变的

def test01():
    global test_str
    test_str='test'
def test02():
    test01()                   #需要先调用test01，再使用test_str
    print(test_str)
test02()

　　8.函数分类
　　　　1）内置函数：

　　　　　　print()：打印

　　　　　　input()：输入

　　　　　　type()：获取变量的类型

　　　　　　id()：获取对象的内存地址

　　　　　　len()：获取长度

　　　　　　str()：转换成字符串

　　　　　　float()：转换成浮点

　　　　　　int()：转换成数值

　　　　　　list()：转换成列表
　　　　2）自定义函数
　　　　3）匿名函数（lambda）
　　9.高阶函数
　　　　1）lambda：不需要起名字，简单，一行代码就行

res =lambda x,y:x+y
print(res(1,2))       #打印出3

#相当于：
def test1(x,y):
    return x+y
result=test1(1,2)
print(result)

　　　　2）enumerate：获取函数及函数的索引值，也可以自定义设置

test_list=['a','b','c','d']
print(enumerate(test_list))     #打印<enumerate object at 0x000002BEF9838B80>
print(list(enumerate(test_list)))   #打印[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')],不赋值时默认从索引值0开始
print(list(enumerate(test_list,2)))    #打印[(2, 'a'), (3, 'b'), (4, 'c'), (5, 'd')]，赋值后默认从赋值开始

　　　　3）map：遍历序列，对序列中每个元素进行操作，最终获取新的序列

def test_demo(x,y):
    return x+y
res=map(test_demo,[1,2,3], [1,2,3])
print(list(res))        #输出：[2, 4, 6]

结合lambda函数
print (map(lambda x,y : x + y, range(1,4), range(1,4)))    #输出：[2, 4, 6]

　　　　4）zip

• • • zip 压缩：将多个可迭代对象对应索引的值组成一个元素，以最短的元素为准
    • zip 解压：压缩的反向过程

list2=[1,2,3]
list3=[4,5,6,7]
result=list(zip(list2,list3))
print(result)    　　　　　　　　#输出： [(1, 4), (2, 5), (3, 6)]
print(list(zip(*result)))   　　#输出： [(1, 2, 3), (4, 5, 6)]

　　　　5）filter：‘筛选函数’，filter()把传人的函数依次作用于序列的每个元素，然后根据返回值是 True 还是 false 决定保留还是丢弃该元素，返回符合条件的序列

def test_demo(x):
    return x % 2 == 0           #筛选[1,2,3,4,5,6,7,8,9,11,12,13,14]的偶数
res2=filter(test_demo,[1,2,3,4,5,6,7,8,9,11,12,13,14])
print(list(res2))       #输出：[2, 4, 6, 8,12,14]

结合lambda函数
res3=filter(lambda x : x%2==0,range(1,10))
print(list(res3))       #输出：[2, 4, 6, 8]

　　　　6）reduce：对于序列内所有元素进行累计操作，即是序列中后面的元素与前面的元素做累积计算

from functools import reduce
def test_demo(x,y):
    return x + y            #求和
res=reduce(test_demo,[1,2,3,4,5])   #1到5
print(res)      #输出：15

结合lambda函数
from functools import reduce
print(reduce(lambda x,y:x+y,range(1,6)))        #1到5求和，输出：15

　　10.判断函数类型：isinstance

　　　　　　isinstance(str_1,int)：判断变量str_1是否是int类型，返回布尔值
　　11.获取随机数：random

import random
def test01(num):
    while num<=10:
        num2 = random.randint(1, 10)
        for i in range(1,10):
            num+=num2
            print(num)
test01(0)