python_Day3[set集合，函数，全局变量之篇]

一、set集合

　　1、Set集合特点：无序、不重复，可嵌套

　　2、set集合创建规则：set = {"123","234"}

　　字典创建规则：dic = {“Key”:"345"}

　　列表创建规则：li = []

　　元组：ages  = (12,33,22,45,67) 或 ages = tuple((21,32,43,54,74))

　　元组转换为列表：list((22,3,4,5,))

　　创建集合方式：

　　1）直接在集合中添加元素：

　　　S1 = {11,33}

　　2) 创建空集合：

　　  S2 = set()     ---->空集合在内存空间调用—_init_方法

　　3）将列表转换至集合：

　　  S3 = set([22,33,4,44,55,])    --->将列表加入新集合，新的集合则循环列表中的元素，如列表中有相同的元素，则只显示一个

　　3、操作集合

　　1）添加元素：add   单个元素添加

　　2）清楚集合中所有元素：clear

set = {22,33,4,4,66}
set.add(99)   #添加元素99至集合
print(set)
set.clear()    #清楚集合中元素
print(set)

　　3）difference用法

S1 = {22,33,44,55.}
S2 = {33,44,55,66}
S3 = S1.difference(S2)   #把S1中存在值，S2中不存在值赋值给S3
print(S3)

　　4）symmetric_difference用法

S1 = {22,33,44,55.}
S2 = {33,44,55,66}
# S3 = S1.difference(S2)   #把S1中存在值，S2中不存在值赋值给S3
# print(S3)
S4 = S1.symmetric_difference(S2)  #对称差值赋值给S4，对称差值即指的是吧S1和S2中不同的值取出来赋值S4
 print(S4)

　　5）difference_update用法

S1 = {22,33,44,55.}
S2 = {33,44,55,66}
# S3 = S1.difference(S2)   #把S1中存在值，S2中不存在值赋值给S3
# print(S3)
# S4 = S1.symmetric_difference(S2)  #对称差值赋值给S4，对称差值即指的是吧S1和S2中不同的值取出来赋值S4
# print(S4)
S1.difference_update(S2)   #把S2中与S1中不同的值，更新至新的S1中，S1中做所有元素值则发生变化，S1
print(S1)

　　6）symmetric_difference_update用法

 S1 = {22,33,44,55.}
 S2 = {33,44,55,66}
 # S3 = S1.difference(S2)   #把S1中存在值，S2中不存在值赋值给S3
 # print(S3)
 # S4 = S1.symmetric_difference(S2)  #对称差值赋值给S4，对称差值即指的是吧S1和S2中不同的值取出来赋值S4
 # print(S4)
 # S1.difference_update(S2)   #把S2中与S1中不同的值，更新至新的S1中，S1中做所有元素值则发生变化，S1
 # print(S1)
 S1.symmetric_difference_update(S2)   #把S1中与S2中不同的值，打印出来，
 print(S1)

　　7）discard：移除指定元素，不存在不报错

S1 = {22,33,44,55,}
S1.discard(33)    #移除S1集合中的33元素
print(S1)
S1.discard(11111)
print(S1)

　　8)remove：移除指定元素，不存在则报错

　　9）pop：随机移除集合中的元素

 S1 = {22,33,44,55,}
 ret = S1.pop()   #把随机移除的元素取出并赋值给ret
 print(S1)
 print(ret)

 

　　10）intersection：取出两个集合交集

 S1 = {22,33,44,55,}
 S2 = {33,44,55,66}
 S3 = S1.intersection(S2)  #取出S1和S2交集并赋值给S3
 print(S3)

　　11）intersection_update：去两个集合交集并赋值给新的集合

　　

　　12）union：集合并集

 S1 = {22,33,44,55,}
 S2 = {33,44,55,66}
 S1.union(S2)   #取出S1和S2中的并集
 print(S1)

　　13）update：把列表中多个元素同时添加至集合中

 S1 = {22,33,44,55,}
 li = [66,77,88,99]  #列表
 S1.update(li)      #将列表中的元素全部加入值集合中
 print(S1)

 S1 = {22,33,44,55,}
 # li = [66,77,88,99]  #列表
 # S1.update(li)      #将列表中的元素全部加入值集合中
 # hh = ("hh","jj","kk",)   #将元组中各个元素同时加入至集合中
 # S1.update(hh)
 li = "hjkdss"
 S1.update(li)
 print(S1)

　　二、函数

　　1）函数编写规范：

　　def：表示创建函数的关键字

　　函数名：即指自己定义的函数名，后续则根据函数名调用函数

　　函数体：指函数中一系列的逻辑计算代码

　　(参数)：为函数体提供数据

　　返回值：当函数执行完后，可以根据调用者返回数据

 def sendmail():
     try:         #try捕捉异常开始
         import smtplib
         from email.mime.text import MIMEText
         from email.utils import formataddr

         msg = MIMEText('邮件内容', 'plain', 'utf-8')
         msg['From'] = formataddr(["武沛齐", 'wptawy@126.com'])
         msg['To'] = formataddr(["走人", '2521235017@qq.com'])
         msg['Subject'] = "主题"
         server = smtplib.SMTP("smtp.126.com", 25)
         server.login("wptawy@126.com", "WW.3945.59")
         server.sendmail('wptawy@126.com', ['2521235017@qq.com', ], msg.as_string())
         server.quit()
     except:
         #发送失败返回False
         return False    #在函数只一旦执行return，则终止整个程序的执行过程
     else:
         #发送成功返回True
         return True   #将发送成功的返回值赋值给sendmail
 ret = sendmail()
 print(ret)
 if ret == True:     #如果返回值为True,表示邮件发送成功
     print("发送成功") ;
 else:                #返回值为False，表示邮件发送失败
     print("发送失败") ;
 # sendmail()    #执行邮箱函数

　　2）函数参会化

　　A：普通参数：即指实参与形参一一对应

　　B：默认参数：即指在形式参数中设置默认的值即可，【必须放在参数列表的最后面】

　　C：动态参数

 def sendmail(qq):  #qq为传递的动态参数
     try:
         import smtplib
         from email.mime.text import MIMEText
         from email.utils import formataddr

         msg = MIMEText('邮件内容', 'plain', 'utf-8')
         msg['From'] = formataddr(["武沛齐", 'wptawy@126.com'])
         msg['To'] = formataddr(["走人", '2521235017@qq.com'])
         msg['Subject'] = "主题"
         server = smtplib.SMTP("smtp.126.com", 25)
         server.login("wptawy@126.com", "WW.3945.59")
         server.sendmail('wptawy@126.com', ['qq', ], msg.as_string())
         server.quit()
     except:
         return ("BB");    #发送成功返回值为BB
     else:                 #发送失败返回值为AA
         return ("AA")
 while True:
     mm = input("请输入邮箱地址：")    #把输入动态参数赋值给mm
     result = sendmail(mm)    #输入动态参数结果值赋值给result
     if result == "CB":    #如果输入动态参数值与返回成功值相等，则邮件发送成功，否则发送失败
         print("发送成功")
     else:
         print("发送失败")
 # sendmail()

 def lcj(name,age = 19):
     print  %(name,age)
 lcj("xiaoluo",21)   #指定传递实参

 def lcj(lit):
     print (lit)
 lit = [24,5,6,7,7,8,'ew','h',3,]  #把列表中每一个元素传递给形参
 lcj(lit)      #将lit实参作为传递参数给形参

* ：默认将传入的参数，全部放值在元组中，处理按照顺序传递的值给形参

 def hh(*lcj):  #形参前加一个*，表示可以讲一个列表中所有元素最为一个元祖传递给形参
     print(lcj,type("lcj"))
 hh(22,3,4,5,6,"ew","er",43,)
 li=[77,99,00,"hh","kk",99]   #列表
 hh(li)

 def hh(*lcj):
     print(lcj,type("lcj"))
 li=[77,99,00,"hh","kk",99]   #列表
 hh(*li)   #将列表中的每一个元素转换至元祖中的每一个元素里面

** ：动态加两个*  传的是字典【key,value】，程序会把dic中的元素赋值给形参

 def F1(**agrs):
     print(agrs,type(agrs))#type打印出agrs数字类型为字典
 F1(n1="lcj",n2="xiaoluo")  #n1和n2为字典中key值，lcj和小罗为字典中传递的value

万能参数：*args,**args[一个*的必须放在前面]

 def F1(*args,**args2):    #一个*的必须放在前面
     print(args,type(args))#type打印出args,args2数字类型
     print(args2,type(args2))
 F1(22,33,4,K1="ww",K2="ee")

　同时传递多个实参：默认情况多个实参与多个形参是一一对应

 def sendmail(qq,context,context02):  #qq为传递的动态参数=形参,context为传递的内容
     try:
         import smtplib
         from email.mime.text import MIMEText
         from email.utils import formataddr

         msg = MIMEText('context','context02', 'plain', 'utf-8')
         msg['From'] = formataddr(["武沛齐", 'wptawy@126.com'])
         msg['To'] = formataddr(["走人", '2521235017@qq.com'])
         msg['Subject'] = "主题"
         server = smtplib.SMTP("smtp.126.com", 25)
         server.login("wptawy@126.com", "WW.3945.59")
         server.sendmail('wptawy@126.com', ['qq', ], msg.as_string())
         server.quit()
     except:
         return ("BB");    #发送成功返回值为BB
     else:                 #发送失败返回值为AA
         return ("AA")
 while True:
     mm = input("请输入邮箱地址：")    #把输入动态参数赋值给mm
     result = sendmail(mm,"SB","hh")    #mm,"SB","hh"传递参数即为实参
     if result == "BB":    #如果输入动态参数值与返回成功值相等，则邮件发送成功，否则发送失败
         print("发送成功")
     else:
         print("发送失败")
 # sendmail()

　　D：指定参数

 def lcj(name,job):
     print(name,job)
     # return True
 lcj("hh","jj")   #默认实参向形参一一传值
 lcj( job ="IT", name ="xiaoluo")  #执行形参

　　F：字符串格式化输出

 S1 = "I am {0},age{1}".format("hh",12)     #0和1为元素占位符，把hh和12分别传递给占位符0和1，常用的占位符%s %d %f
 print(S1)
 S2 = "I am {name},age{age}".format(name="lcj",age=21)  #指定占位符位置
 print(S2)
 dic= {"name":"kk","age":23}
 S3 = "I am {name},age{age}".format(**dic)  #添加两个**，表示把字典中的所有元素赋值给S3
 print(S3)

　　G：Python传递值是引用

 def kk(a2):
     a2.append(99)   #append扩展，一般在元素末尾进行扩展
 li = [22,33,44,55,]
 kk(li)     #把列表的元素赋值给函数KK
 print(li)

二、全局变量

　　1、函数作用域

 def lcj():      #lcj为函数名
     name="lcj"      #函数作用域
     print(name)
 lcj()     #调用函数

　　2、全局变量：所有的作用域里面都可以调用全局变量，潜规则：所有定义的全局变量必须是大写

　　3、局部变量：在局部不变量中，优先使用自己定义的局部变量，如自己局部变量中没元素，可调用全局变量元素

　　4、在局部变量中引用全局变量，需用关键元素“global”

 #全局变量，多有作用域都可读
 #对全局变量进行重新赋值[增删改]，需要用global
 #特殊：列表、字典、可修改，不可重新赋值
 #定义全局变量都是大写
 name = "lcj"     #全局变量
 name = [22,3,4,5,]
 def f1():
     age = 12
     name = "hh"    #局部变量name
     print(name,age)
 f1()
 def f2():
     age = 18
     global name  #对全局变量进行重新赋值
     name = ""
     print(name,age)
 f2()

 　　三、登入

　　  1、登入

　　  2、注册

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# lcj

def login(user, pwd):
    """
     用户登入
     :param user: 用户名
     :param pwd: 密码
     :return: true：表示登入成功，False：登入失败
     """
    f = open("db", 'r')
    for line in f:  # 表示一行行读元素
        list_line = line.split("|")  # 用户名和密码用| 分开
        if list_line[0] == user and list_line[1] == pwd:  # 如果用户名和密码与文件中的用户名和密码项目则返回True
            return True
    return False  # 用户名和密码不相等，返回False

def register(user, pwd):
    """
    用户注册
    :param user: 用户名
    :param pwd: 密码
    :return: 默认None
   """
    f = open("db", 'a')  # a：表示添加
    temp = "\n" + user + "|" + pwd  # \n：换行符
    f.write(temp)
    f.close()  # 关闭文件

def main():
    t = input("1:登入;2:注册")
    if t == "1":
        user = input("请输入用户名：")
        pwd = input("请输入密码：")
    r = login(user, pwd)  # 吧输入的用户和密码传递给login，那么login需要接受用户名和密码两个参数
    if r:
        print("登入成功")
    else:
        print("登入失败")
    elif t == "2":

    user = input("请输入用户名：")
    pwd = input("请输入密码：")
    register(user, pwd)  # 注册文件中用户名和密码
main()  # 调用main函数，让用户选择登入或者注册

　　

 　　四，三元运算

　　三元运算又称三目运算，是对简单的条件语句的缩写

　　书写格式：

　　result = 值1 if 条件 else 值2

　　#如果条件成立，那么值1赋值给result值，否则，将“值2”赋值给result变量

　　

　　五，lambda表达式

　　只能对简单的赋值进行操作

 #简单函数表达式
 # def f1(a1):    #a1属于形参，
 #     return a1+100
 # ret = f1(10)  #10属于实参，把实参传递给形参a1，返回值f1为a1+100
 # print(ret)
 #lambda表达式运算如上函数
 def f1(a1):    #a1属于形参
     return a1+100
 f2 = lambda a1,a2: a1 + a2 + 100  #lamdba表达式，a1,a2
 # ret = f1(10)    #10实参，实参传递给形参a1,返回值f1为a1+100
 # print(ret)
 ret = f2(12,1)  #给f2传递两个实参，
 print(ret)
 #给a2定义一个默认值
 def f1(a1):    #a1属于形参
     return a1+100
 f2 = lambda a1,a2=9: a1 + a2 + 100  #lamdba表达式，给形参a2定义常量
 ret = f1(10)    #10实参，实参传递给形参a1,返回值f1为a1+100
 print(ret)
 ret = f2(9)  #给f2传递
 print(ret)