python09

第九天

• 三元运算
• 函数
• 考试题

三元运算

# 简单的if条件赋值时使用
v = 前值 if 条件 else 后值
#例1 输入值，如果是整数，转换成整数，否则为None
data = input('>>>')
v = int(data) if data.isdecimal() else None
print(v)

函数

1. 面向过程编程

• 可读性差
• 重用性差

# 发邮件功能
def send_qq_email(to_name, email, to_subject,to_content):
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr

    my_name = ''    # 发件人名称
    my_email = ''   # 发件人邮箱
    my_pass_word = ''  # pop3授权码
    to_email = '%s@qq.com' % (email,)   # 收件人邮箱，此处特指qq邮箱

    msg = MIMEText(to_content, 'plain', 'utf-8')  # 写入邮件内容
    msg['From'] = formataddr([my_name, my_email])  # 发件人
    msg['To'] = formataddr([to_name, to_email])  # 收件人
    msg['Subject'] = to_subject  # 主题

    server = smtplib.SMTP('smtp.qq.com', 25)  # 邮箱服务器
    server.login(my_email, my_pass_word)  # 登录自己邮箱，密码为pop3授权码
    server.sendmail(my_email, [to_email, ], msg.as_string())  # 发送邮件
    server.quit()  # 退出


send_qq_email()

2. 函数式编程
   def send_email()

• 重复调用
• 分步分项，代码分割
• 函数不被调用，内部代码不执行

# 函数的定义
def 函数名():
    函数内容
# 函数的调用
函数名()

• 练习题

# 计算指定列表中所有元素的和
info = [11, 22, 33, 44, 55]


def sum_list(li):
    s = 0
    for item in li:
        item = int(item)
        s += item
    print(s)


sum_list(info)
# 拼接两个列表并打印
info_1 = [11, 55]
info_2 = [77, 88]


def con_li(li_1, li_2):
    li = []
    li.extend(li_1)
    li.extend(li_2)
    print(li)


con_li(info_1, info_2)
# 自己制作len()
a = 'asdf'


def my_len(arg):
    count = 0
    for item in arg:
        count += 1
    print(count)


my_len(a)

3. 返回值

• return值，不写值，返回none
• 函数执行到return，跳出函数

# 用户输入一段字符串，计算字符串中'A'的个数，写入a.txt
def get_char_count(data):
    sum_a = 0
    for item in data:
        if item == 'A':
            sum_a += 1
    sum_a = str(sum_a)
    file_object = open('a.txt', mode='w', encoding='utf-8')
    file_object.write(sum_a)
    file_object.close()
    return sum_a


a = get_char_count('ASDFA FSDFASDFASDF')
print(a)

4. 练习题

# 函数检测列表中数字的个数
lis = [11, 'd', 33]


def li_num(li):
    count = 0
    for item in li:
        if type(item) == int:
            count += 1
    return count


a = li_num(lis)
print('这个列表中有%s个数字' % (a,))
# 列表偶数位置取出成另一个列表
lis = [11, 'd', 33, 44, 55, 66, 99]


def li_index_even(li):
    list_1 = []
    list_1 = li[0::2]
    return list_1


print(li_index_even(lis))
# 读取文件内容并构造成指定格式的数据并返回
a.log
alex|123|18
eric|uiuf|19

# 形式一['alex|123|18', 'eric|uiuf|19']
def get_list(file_name):
    with open(file_name, mode='r', encoding='utf-8') as file_object:
        content = file_object.read()
        content = content.strip()
        content = content.split('\n')
    return content


print(get_list('a.log'))

# 形式二[['alex', '123', '18'], ['eric', 'uiuf', '19']]
def get_list(file_name):
    with open(file_name, mode='r', encoding='utf-8') as file_object:
        content = file_object.read()
        lis = []
        content = content.strip()
        content = content.split('\n')
        for item in content:
            item = item.split('|')
            lis.append(item)
    return lis


print(get_list('a.log'))

# 形式三[{'name': 'alex', 'pwd': '123', 'age': '18'}, {'name': 'eric', 'pwd': 'uiuf', 'age': '19'}]
def get_list_dic(file_name):
    with open(file_name, mode='r', encoding='utf-8') as file_object:
        content = file_object.read()
        lis = []
        lis_1 = []
        dic = {}
        content = content.strip()
        content = content.split('\n')
        for item in content:
            item = item.split('|')
            lis.append(item)
        for element in lis:
            dic = {'name': element[0], 'pwd': element[1], 'age': element[2]}
            lis_1.append(dic)
    return lis_1


print(get_list_dic('a.log'))

作业

1. 将函数部分知识点，整理到自己笔记中。（搞明白课上讲的案例。）
2. 写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回。

a = [1, 2, 3, 4, 5, 67, 6]
b = (1, 2, 3, 4, 5, 6, 7, 8, 9)


def get_odd_number_index_list(arg):
    arg = list(arg)
    li = arg[1::2]
    return li


print(get_odd_number_index_list(a))

3. 写函数，判断用户传入的一个对象（字符串或列表或元组任意）长度是否大于5，并返回真假。

s = 'fasdfa'


def get_len(arg):
    lenth = len(arg)
    a = False
    if lenth > 5:
        a = True
    return a


print(get_len(s))
# 三元运算
s = 'fasdfa'


def get_len(arg):
    return True if len(arg) > 5 else False


print(get_len(s))

4. 写函数，接收两个数字参数，返回比较大的那个数字。

a = 6
b = 8


def bigger(arg_1, arg_2):
    result = arg_1
    if arg_1 < arg_2:
        result = arg_2
    return result


print(bigger(a, b))
# 三元运算
a = 6
b = 8


def bigger(arg_1, arg_2):
    return arg_1 if arg_1 > arg_2 else arg_2


print(bigger(a, b))

5. 写函数，函数接收四个参数分别是：姓名，性别，年龄，学历。用户通过输入这四个内容，然后将这四个内容传入到函数中，此函数接收到这四个内容，将内容根据"*"拼接起来并追加到一个student_msg文件中。

def append_txt(name, gender, age, education):
    li = [name, gender, age, education]
    content = '*'.join(li)
    with open('student_msg.txt', mode='a', encoding='utf-8') as file_object:
        file_object.write(content + '\n')


append_txt('dong', '男', '18', '本科')

6. 写函数，在函数内部生成如下规则的列表 [1,1,2,3,5,8,13,21,34,55…]（斐波那契数列），并返回。 注意：函数可接收一个参数用于指定列表中元素最大不可以超过的范围。

def Fibonacci_sequence(arg):
    a = 1
    b = 1
    li = [1, 1]
    while a + b < arg:
        s = a + b
        li.append(s)
        a = b
        b = s
    return li


print(Fibonacci_sequence(100))
# 简便写法
def Fibonacci_sequence(arg):
    li = [1, 1]
    while li[-1] + li[-2] < arg:
        li.append(li[-1] + li[-2])
    return li


print(Fibonacci_sequence(100))

7. 写函数，验证用户名在文件 data.txt 中是否存在，如果存在则返回True，否则返回False。（函数有一个参数，用于接收用户输入的用户名）

data.txt文件格式如下：

# 1|alex|123123
# 2|eric|rwerwe
# 3|wupeiqi|pppp

def get_list_dic(arg):
    with open('data.txt', mode='r', encoding='utf-8') as file_object:
        content = file_object.read()
        lis = []
        lis_1 = []
        content = content.strip()
        content = content.split('\n')
        for item in content:
            item = item.split('|')
            lis.append(item)
        for element in lis:
            dic = {'number': element[0], 'name': element[1], 'pwd': element[2]}
            lis_1.append(dic)
        result = False
        for di in lis_1:
            if di['name'] == arg:
                result = True
    return result


print(get_list_dic('dfadf'))	# False