python有返回结果但是继续执行 返回值 python

一，函数的定义

1，函数mylen叫做函数名

　 #函数名
　 #必须由字母下划线数字组成，不能是关键字，不能是数字开头
　 #函数名还是要有一定的意义能够简单说明函数的功能

2，def是关键字 （define）

3，():必须写

4，函数体内尽量写注释，方便查看代码

5，函数的调用：函数名+括号

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def mylen():  #函数名
 5     '''
 6     计算字符串长度的函数  这里写的是注释，方便查看代码
 7     '''
 8     s = 'hello world'
 9     length = 0
10     for i in s:
11         length += 1
12     return length        #函数的返回值
13 leng = mylen()    #函数的调用
14 print(leng)

二，函数的返回值 return

1，函数返回值可以是任意的数据类型

2，如果有返回值：必须要用变量接收才会有效果

1 #!/usr/bin/env python
2 #_*_coding:utf-8_*_
3 
4 def func():
5     b = [1,2,3]
6     return b   #可以是任何数据类型
7 ret = func()    #有返回值，就需要用变量来接收
8 print(ret)

3，函数可以没有返回值,默认返回给None
      函数的返回值为None有三种情况
      1.不写返回值
      2.只写一个return
      3.return None （几乎不用）

4，return的作用：结束一个函数的执行

5，函数的返回值不为None，有返回值
     返回一个值（一个变量）
     返回多个值(多个变量)，多个值之间用逗号区分
     接收：可以用一个变量接收，以元组的形式返回
     也可以用多个变量接收，返回几个就用几个变量去接收 相当于解压式接收

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def func6():
 5     '''返回一个值'''
 6     a =123
 7     return a
 8 
 9 def func7():
10     '''返回多个值'''
11     a = 123
12     b = 'abc'
13     return a,b
14 
15 ret = func7()
16 print(ret)
17 m,n,k = func7()

 三，函数的参数

实参：函数调用的时候传入的参数

形参：函数定义的时候括号内的参数

参数可以是任意的数据类型，可以传送0个或者多个参数

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def mylen(s):  #参数接收：形式参数，形参
 5     '''
 6     计算字符串长度的函数        ——函数的功能
 7     参数s：接收要计算的字符串   ——参数的信息
 8     return：要计算的字符串长度  ——返回值的信息
 9     '''
10     length = 0
11     for i in s:
12         length += 1
13     return length
14 length = mylen('hello world')  #参数传入：实际参数,实参
15 print(length)

调用时传参数（实参）

实参，遵循 位置参数--关键字参数

*按照位置参数传参：按顺序定义参数

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def my_max(a,b):  #定义：位置参数
 5     '''返回两个值之间的最大值'''
 6     print(a,b)
 7     if a > b:
 8         return a
 9     else:
10         return b
11 print(my_max(10,20))
12 print(my_max(30,20))

*按照关键字参数传参：可以不按顺序传参数

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def my_max(a,b):  #定义：关键字参数
 5     '''返回两个值之间的最大值'''
 6     print(a,b)
 7     if a > b:
 8         return a
 9     else:
10         return b
11 print(my_max(b = 10,a = 20))

定义时候参数（形参）

形参，遵循 位置参数--默认参数

*默认参数

*不要设置可变类型的默认参数

*默认参数可以不传，不传用的是默认值，传参数的话需要用关键字传参，才可以覆盖默认值

*默认值是在定义函数的时候就已经确定了的

1 #!/usr/bin/env python
2 #_*_coding:utf-8_*_
3 
4 def stu_info(name,sex = 'male'):  #默认参数，有一个默认值
5     print('name:%s,sex:%s'%(name,sex))
6 stu_info('alex') #默认参数可以不传值
7 stu_info('egon','female') #如果传值了，覆盖默认值

关于默认参数流程

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 #关于默认参数流程
 5 s = 'male'
 6 def stu_info(name,sex=s):  #默认参数，有一个默认值
 7     print('name:%s,sex:%s'%(name,sex))
 8 s = 'female' #不影响定义时sex的值
 9 print(stu_info("李淑旗"))
10 #打印出来的就是male   因为开始sex=x=male，然后s是新开辟的一个空间存储female

不要这是可变类型数据为默认参数

1 #!/usr/bin/env python
2 #_*_coding:utf-8_*_
3 
4 #不要设置可变数据类型为默认参数
5 b = []
6 def func(a = []):
7     a.append(1)
8     print(a)
9 # func()....打印下去你会发现这个[]列表一直在追加

 

动态参数

*args  接收的是实参，位置参数，将转化成元祖返回

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 #*args  #按位置传参数
 5 def func(a,b,*c):   #*c接收的是5,5,5,5并且输出一个元祖包含这个4个5 *args代表把散列的元素拼成元组
 6     my_sum = a+b
 7     for i in c:
 8         my_sum += i
 9     return my_sum
10 print(func(3,2,5,5,5,5))

*kwargs 接收的是实参，关键字参数，将转化成字典返回

1 #!/usr/bin/env python
2 #_*_coding:utf-8_*_
3 
4 #**kwargs   #按照关键字传参数
5 def fun(a,b,**kwargs):
6     print(a,b,kwargs)
7 fun(a = 10,b = 20,cccc= 30,dddd = 50)

 

行参,位置顺序

1 #!/usr/bin/env python
2 #_*_coding:utf-8_*_
3 
4 #形式参数括号里面的位置顺序
5 def f(a,b,*args,defult=6,**kwargs):
6     #位置参数，*args,默认参数，**kwargs
7     print(a,b,args,defult)
8 #传参数的时候：必须先按照位置传参数，再按照关键字传参数
9 f(1,2,7,8,defult=10)

 

传参时候,有时候是可变得数据类型,下面是2个方法可以将不同类型数据类型打散

1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 #在传参的时候，针对列表，元祖的话，有个*t参数，避免手动传参
 5 def fun2(*args):#*args代表把散列的元素拼成元组
 6     print(args)
 7 t = (1,2,3,4)
 8 l = [1,2,3,4]
 9 # fun2(t[0],t[1],t[2],t[3])
10 fun2(*t)  #*代表把一个元组、列表拆了
11 fun2(*l)  #*代表把一个元组、列表拆了
12 
13 #针对字典有个**d参数，避免手动传参
14 def fun3(**kwargs):#*args代表把按关键字传来的参数拼成字典
15     print(kwargs)
16 fun3(a = 10, b = 20)
17 d = {'a': 10, 'b': 20}
18 fun3(**d)  #*代表把一个字典拆了

传参时候传递的是引用 

# 我们之前学过字符串的format方法
msg = "{0},{1}"
print(msg.format("joker","11"))
print(msg.format(*["joker","11"]))

msg = "{name},{age}"
print(msg.format(name="joker",age="11"))
print(msg.format(**{"name":"joker","age":"11"}))

# 传递数据类型时候，其实传递的是引用
l = [1,2,3,4]
def f1(a1):
    a1.append(999)
f1(l)
print(l) # [1, 2, 3, 4, 999]

# 全局变量，通常全部大写
name = [1,2,3,4]
def f1():
    global name  # 直接修改
    name = [111]
    return
f1()
print(name)  # [111]


name = [1,2,3,4]
def f1():
    name.append(5) # 局部不能给全局重新赋值
    return
f1()
print(name)  # [1, 2, 3, 4, 5]

相同函数名执行过程

# !/usr/bin/env python
# _*_coding:utf-8_*_
# Author:Joker

def f1(a1,a2):   # 1
    return a1 + a2

def f1(a3,a4):   # 2
    return a3 * a4   # 4

ret = f1(8,8)    # 3 #5

print(ret)       # 6

# 开始f1的空间包含指向为a1 + a2，后来变为了a3 * a4，在实参传递的时候，你也会发现给的是a3,a4赋值

通过126发送小邮件程序

# !/usr/bin/env python
# _*_coding:utf-8_*_
# Author:Joker



def sendmail():
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr


    msg = MIMEText('我正在通过PY给你发送邮件，别再睡了。','plain','utf-8') # 创建一个文本类型
    msg['From'] = formataddr(['joker','[e-mail]']) # 二元祖，发件人，发件地址
    msg['Subject'] = "亲爱的POPPY君"

    server = smtplib.SMTP('smtp.126.com',25)
    server.login('[e-mail]','授权登录密码') # SMTP第三方授权登录密码
    server.sendmail('[e-mail]',['对方邮件地址@qq.com',],msg.as_string())
    server.quit()

    return 1

ret = sendmail()
if ret:
    print('email send success!')