03_函数

Posted 2020-07-13

函数

创建函数

def 函数名(参数):
    ...
    函数体
    ...
    返回值

# 1.def关键字，创建函数
# 2.函数名
# 3.()
# 4.函数体
# 5.返回值

函数示例：发邮件

# 定义函数
def sendmail():
    try: #如果发送成功，执行except内容；如果发送失败，执行except
        import smtplib
        from email.mime.text import MIMEText
        from email.utils import formataddr

        msg = MIMEText(‘邮件内容,测试‘, ‘plain‘, ‘utf-8‘)
        msg[‘From‘] = formataddr(["武沛齐",‘[email protected]‘])
        msg[‘To‘] = formataddr(["走人",‘[email protected]‘])
        msg[‘Subject‘] = "主题"

        server = smtplib.SMTP("smtp.126.com", 25)
        server.login("[email protected]", "password")
        server.sendmail(‘[email protected]‘, [‘[email protected]‘,], msg.as_string())
        server.quit()
    except:
        #发送失败
        return False
    else:
        #发送成功
        return True

# 执行函数
sendmail()

 

函数小结
1.return值，返回给调用者一个结果
2.在函数中，一旦执行return，函数执行过程立即终止
3.如果未设置return值，python默认return返回值为None

 

函数参数

形式参数

def sendmail(xxoo):  #xxoo为形式参数
    # xxoo = alex
    try:
        import smtplib
        from email.mime.text import MIMEText
        from email.utils import formataddr


        msg = MIMEText(‘邮件内容,测试‘, ‘plain‘, ‘utf-8‘)
        msg[‘From‘] = formataddr(["武沛齐",‘[email protected]‘])
        msg[‘To‘] = formataddr(["走人",‘[email protected]‘])
        msg[‘Subject‘] = "主题"

        server = smtplib.SMTP("smtp.126.com", 25)
        server.login("[email protected]", "WW.3945.59")
        server.sendmail(‘[email protected]‘, [xxoo], msg.as_string())
        server.quit()
    except:
        #发送失败
        return False
    else:
        #发送成功
        return True

ret = sendmail("kandaoge")  #实际参数

实际参数

# 接上文环境
# ret = sendmail("alex")
# ret = sendmail("eric")
while True:
    em = input("请输入邮箱地址：")
    result = sendmail(em,"NB","OK")
    if result == True:
        print("发送成功")
    else:
        print("发送失败")

1.普通参数

def send(xxoo,content,xx):
    return True
while True:
    em = input("请输入邮件地址：")
    result = send(em,"NB","OK")
    if result == True:
        print("发送成功")
    else:
        print("发送失败")

2.默认参数，默认参数必须要放置在参数列表的后面

def sendmail(xxoo,nontent,xx="OK"):
    sendmail("alex","nb")
    sendmail("alex","nb",xx="nb")

3.指定参数

def send(xxoo,content):
    send("alex","NB")
send(content="alex",xxoo="nb")

4.动态参数 * 

默认将传入的参数，全部放置在元组中,f1(*[11,22,33,44])

def f1(*args):
    # print(args,type(args))

f1(11,22,"alex","hhh")  #所有参数
# 输出结果,全部参数分别被放置在元组，每个参数值都为一个元素
# (11, 22, ‘alex‘, ‘hhh‘) <class ‘tuple‘>

li = [11,22,"alex","hhh"]
f1(li,‘12‘)
# 输出结果，整个列表值为一个元组中的元素
# ([11, 22, ‘alex‘, ‘hhh‘], ‘12‘) <class ‘tuple‘>

f1(*li)
# *输出结果，每个列表内的元素转换成元组中的单个元素
# (11, 22, ‘alex‘, ‘hhh‘) <class ‘tuple‘>

li = "alex"
f1(*li)
# 输出结果，字符串里的每个字符都为元组的一个元素
# (‘a‘, ‘l‘, ‘e‘, ‘x‘) <class ‘tuple‘>

5.动态参数 **

默认将传入的参数，全部放置在字典中,f1(**{‘k1‘:"v1",‘k2‘:"v2"})

def f1(**args):
    print(args,type(args))
f1(n1="alex",n2=18)   #必须用指定参数方式传参
dic = {‘k1‘:"v1",‘k2‘:"v2"}
f1(kk=dic)
f1(**dic)

#输出结果
{‘n1‘: ‘alex‘, ‘n2‘: 18} <class ‘dict‘>
{‘kk‘: {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}} <class ‘dict‘>
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘} <class ‘dict‘>

6.万能参数，一个*在前面，两个**在后面

def f1(*args,**kwargs): #注意*，**的位置
    print(args)
    print(kwargs)
f1(11,22,33,44,k1="v1",k2="v2")

# 输出结果
(11, 22, 33, 44)
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}

 字符串格式化

# "%s %d"
# str.format()
# str format格式化输出
s1 = "I am {0},age {1}".format("alex",18)   #点位符
print(s1)
s2 = "I am {0},age {1}".format(*["alex",18])
print(s2)
s3 = "I am {name},age {age}".format(name="alex",age=18)
print(s3)
dic = {‘name‘:‘alex‘,‘age‘:‘18‘}
s4 = "I am {name},age {age}".format(**dic)
print(s4)

# 输出结果
I am alex,age 18
I am alex,age 18
I am alex,age 18
I am alex,age 18

　　

补充知识

1.Python是从上到下的读取、执行方式

def f1(a1,a2):
    return  a1+a2
def f1(a1,a2):
    return a1*a2
ret = f1(8,8)
print(ret)
# 输出结果
# 64

# 原理同
name = "alex"
name = "eric"
print(name)
# 输出结果
# eric

2.函数传递的参数是引用值

def f1(a1):
    a1.append(999)
li = [11,22,33,44]
f1(li)
print(li)

# 输出结果
[11, 22, 33, 44, 999]

3.全局变量

• 没有写到函数里的就是全局变量
• 全局变量所有的作用域都可读
• 优先读取自己的变量，如果没有，再读取全局变量
• 对全局变量进行重新赋值，需要global
• 特殊：列表、字典，可修改(增加，减少)，不可重新赋值
• 潜规则：全局变量全部是大写，没有写到函数里的就是全局变量
• 函数不能读取其他函数内的变量

# 列表重新赋值举例，ID变了
LIST = [11,22,33]  #全局变量
def f1():
    LIST.append(44)
    print(id(LIST))
    print(LIST)
    # 输出结果
    # 831520812744
    # [11, 22, 33, 44]
    global LIST    # 系统提示：SyntaxWarning: name ‘LIST‘ is used prior to global declaration
    LIST = [55,66]  #重新赋值
    print(id(LIST))
    print(LIST)
    # 输出结果
    # 831520847624  # ID变了
    # [55, 66]
f1()

 

示例：函数不能读取其他函数内的变量

def f1():
    name = "alex"
    print(name)
f1()
# 输出结果
alex


def f2():
    print(name)
f2()
# 输出结果：错误信息
NameError: name ‘name‘ is not defined

潜规则

NAME = "alex" #没有写到函数里的就是全局变量，全局变量全部是大写（潜规则）


def f1():
    age = 18
    print(age,NAME)


def f2():
    age = 19
    print(age,NAME)


def f3():
    age = 20
    global NAME  #重新赋值name,且name是全局变量,加global
    NAME = "eric"
    print(age,NAME)


f1()
f2()
f3()

# 输出结果
18 alex
19 alex
20 eric

 

登录注册函数实现案例

潜规则：函数和函数之间两行空行

def login(username, password):
    """    #说明
    用于用户登录
    :param username:用户输入的用户名
    :param password:用户输入的密码
    :return True：表示登录成功
    """
    f = open("db",‘r‘)
    for line in f:
        line_list = line.split("|")
        if line_list[0] == username and line_list[1] == password:
            return True
    return False


def register(username, password):
    """
    用于用户注册
    :param username:用户名
    :param password: 密码
    :return:：默认None
    """
    f = open("db", ‘a‘)
    temp = "\n" + username + "|" + password
    f.write(temp)
    f.close()


def main():
    """
    登录，注册选择
    1为用户登录
    2为用户注册
    :return: 默认None
    """
    t = input("1:登录：2：注册")
    if t == "1":
        user = input("请输入用户名：")
        pwd = input("请输入密码：")
        r = login(user, pwd)
        if r:
            print("登录成功")
        else:
            print("登录失败")
    elif t == "2":
        user = input("请输入用户名：")
        pwd = input("请输入密码：")
        register(user, pwd)


main()

三元运算/三目运算

简单的if,else语句的简写

if 1 == 1:
    name = "alex"
else:
    name = "NB"
print(name)
# 输出结果
alex

name = "alex" if 1==1 else "eric"
print(name)
# 输出结果
alex

# 文字解释
# 如果1==1 成立
# nam = "alex"
# 否则
# name = "eric"

name = "alex" if 1==2 else "eric"
print(name)
# 输出结果
eric

lambda

简单的函数表达式

def f1(a1):
    return a1 + 100
ret = f1(10)
print(ret)
# 输出结果
110


f2 = lambda a1: a1 + 100
r2 = f2(10)
print(r2)
# 输出结果
110

f3 = lambda a1, a2, a3, : a1 + a2 + a3 + 100    #所有的变量只能写在一行
r3 = f3(9, 19, 29, )
print(r3)
# 输出结果
157

 

内置函数

• abs绝对值
• all()
• any()
• ascii()
• bin() 二进制
• oct() 八进制
• hex() 16进制
• bytes

abs绝对值

n = abs(-1)
print(n)
# 输出结果
1

all,所有为真，才为真

n = all([1,2,3,4])
print(n)
n = all([1,2,3,0])
print(n)
# 输出结果
True
False

any,只要有真，就为真

n = any([1,2,3,0])
print(n)
# 输出结果
True

ascii() #自动执行对象的__repr__方式

class Foo:
def __repr__(self):
return "444"
n = ascii(Foo())
print(n)
# 输出结果
444

进制转换

print(bin(2))
print(oct(8))
print(hex(16))
#输出结果
0b10
0o10
0x10

bytes

utf-8 一个汉字：三个字节
gbk   一个汉字：二个字节

# s = "李杰" # 一个字节8位，一个汉字三个字节
# 字符串转换字节类型
# bytes(需要要转换的字符串，按照什么编号格式)

n= bytes(s,encoding="utf-8")
print(n)
# 输出结果
# b‘\xe6\x9d\x8e\xe6\x9d\xb0‘

n= bytes(s,encoding="gbk")
print(n)

# 输出结果
# b‘\xc0\xee\xbd\xdc‘

补充点：字节转化成字符串

s = "大龙" # 一个字节8位，一个汉字三个字节
name = str(bytes(s,encoding="utf-8"),encoding="utf-8")
print(name)
name = str(b‘\xe6\x9d\x8e\xe6\x9d\xb0‘,encoding="utf-8")
print(name)