标签：入门 python name test print test01 def 函数

　　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)

标签：入门,python,name,test,print,test01,def,函数
来源： https://www.cnblogs.com/mango-93/p/16283077.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。