一、set

1. set集合，无序、不重复的元素集合

# 创建set集合s1 = {11, 22, 33}print(s1,type(s1))==> {
    33, 11, 22} 
     
       l1 = [2, 3, 4,]s1 = set(l1)print(l1,type(l1))==> [2, 3, 4] 
      
        print(s1,type(s1))==> {
    2, 3, 4} 
       
        # 集合中增加元素s1 = {11, 22, 33}s1.add(44)print(s1)==> {
    33, 11, 44, 22}# 清空集合中元素s1 = {11, 22, 33}print(s1)==> {
    33, 11, 22} s1.clear()print(s1)==> set()# 找到在s1中有，s2中没有的元素，并保存到一个新的集合s1 = {11,22,33,}s2 = {22,33,44,}s3 = s1.difference(s2)print("%s \n%s \n%s" % (s1,s2,s3))==> {
    33, 11, 22} ==> {
    33, 44, 22}==> {
    11}# 找到在s1中有，s2中没有的元素，把结果更新到s1中s1 = {11,22,33,}s2 = {22,33,44,}s1.difference_update(s2)print("%s \n%s" % (s1,s2))==> {
    11}==> {
    33, 44, 22}# 找到即在集合s1中，又在集合s2中的元素，并把结果保存到一个新的集合里s1 = {11,22,33,}s2 = {22,33,44,}s3 = s1.intersection(s2)print("%s \n%s \n%s" % (s1,s2,s3))==> {
    33, 11, 22} ==> {
    33, 44, 22}==> {
    33, 22}# 找到即在集合s1中，又在集合s2中的元素，并把结果更新到s1中s1 = {11,22,33,}s2 = {22,33,44,}s1.intersection_update(s2)print("%s \n%s" % (s1,s2))==> {
    33, 22}==> {
    33, 44, 22}# 判断两个集合是否有交集，没有交集时返回True，有交集时返回Falses1 = {11,22,33,}s2 = {22,33,44,}s3 = {1,2,3,}s1.isdisjoint(s2)==> False s1.isdisjoint(s3)==> True# 判断s1是不是s2的子集s1 = {11,22,}s2 = {11,22,33,44,}s3 = {22,33,}s1.issubset(s2)==> True s1.issubset(s3)==> False# 判断s1是不是s2的父集s1 = {11,22,33,44,55}s1 = {11,22,33,44,55,}s2 = {22,33,55,}s3 = {44,33,66,}s1.issuperset(s2)==> True s1.issuperset(s3)==> False# 任意删除并返回一个元素s1 = {11,22,33,44,55,}s1.pop()==> 33# 删除指定的一个元素，这个元素必须在集合中，否则报错。区别于discard()s1 = {11,22,33,}s1.remove(11)print(s1)==> {
    33, 22} s1.remove(44)==> Traceback (most recent call last):    File "
        
         ", line 1, in 
         
              KeyError: 44# 删除指定的一个元素，如果元素不存在不报错。可以起到判断元素是否在集合中时，代码不报错的作用s1 = {11,22,33,}s1.discard(11)print(s1)==> {
    33, 22} s1.discard(44)   # 44 不在s1中，操作时不报错print(s1)==> {
    33, 22}# 相当于取两个集合的并集，再把他俩的交集删掉。返回这个新集合s1 = {11,22,33,44,}s2 = {22,44,55,66}s3 = s1.symmetric_difference(s2)print("%s \n%s \n%s" % (s1,s2,s3))==> {
    33, 11, 44, 22} ==> {
    66, 44, 22, 55} ==> {
    33, 66, 11, 55}# 取s1，s2两个集合的并集，再把他俩的交集删掉。结果赋值给s1s1 = {11,22,33,44,}s2 = {22,44,55,66}s1.symmetric_difference_update(s2)print("%s \n%s" % (s1,s2))==> {
    33, 66, 11, 55} ==> {
    66, 44, 22, 55}# 取两个集合的并集，结果返回到一个新集合中s1 = {11,22,33,44,}s2 = {22,44,55,66}s3 = s1.union(s2)print("%s \n%s \n%s" % (s1,s2,s3))==> {
    33, 11, 44, 22} ==> {
    66, 44, 22, 55}==> {
    33, 66, 11, 44, 22, 55}# s1.update(s2) 去两个集合的并集，将结果赋值给s1s1 = {11,22,33,44,}s2 = {22,44,55,66}s1.update(s2)print("%s \n%s" % (s1,s2))==> {
    33, 66, 11, 44, 22, 55}==> {
    66, 44, 22, 55}
         
        
       
      
     

 2. set需求练习

#!/usr/bin/env python# -*- coding:utf-8 -*- # Author He Xuold_dict = {    "#1":8,    "#2":4,    "#4":2,}new_dict = {    "#1":4,    "#2":4,    "#3":2,}# 需求：将插槽4的内存放到插槽3，将插槽1的内存改为4G# 因为是字典new_set = set(new_dict.keys())old_set = set(old_dict.keys())# 应该删除槽位4: old存在，new不存在的keyremove_set = old_set.difference(new_set)print(remove_set)==> {
   '#4'}# 应该增加槽位3: new存在，old不存在的add_set = new_set.difference(old_set)print(add_set)==> {
   '#3'}# 应该更新槽位1: 两个都有的,取交集update_set = old_set.intersection(new_set)print(update_set)==> {
   '#2', '#1'}

 

二、 函数

1. 函数类型：自定义函数、内置函数

2. 特性：面向过程编程，往往是有重复性的复制、粘贴动作，这样会造成代码庞大，可读性差。而面向函数式编程，可以增加代码的重用性。

3. 函数格式

1. def关键字，代表创建函数 2. 函数名 3. ()  # 参数    #可加形式参数，等于就是一个变量，后面具体传的值叫实际参数；形式参数可加多个，对应的实际参数也要按顺序一一对应    #普通参数，按顺序传参    #默认参数，必须放到参数列表的末尾    #指定参数，不用按顺序了    #  * ，可以接收n个实际参数，默认将传入的参数，全部放在元组中    #  ** ，可以接收n个实际参数，默认将传入的参数，全部放在字典中    # 万能参数，*在前，**在后 4. 函数体：是不被执行的，调用的时候才执行 5. 返回值 6. 执行函数 注意： 在函数中，一旦出现return，不会再执行后面的代码 如果没定义return，python会自动return成'None'

4. 邮件发送函数代码（示例）

def sendmail():    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(["走人", '424662508@qq.com'])        msg['Subject'] = "主题"        server = smtplib.SMTP("smtp.126.com", 25)        server.login("wptawy@126.com", "WW.3945.59")        server.sendmail('wptawy@126.com', ['664076968@qq.com', ], msg.as_string())        server.quit()    except:        # 发送失败传给sendmail()        return  False # return值可以是字符串    else:        # 发送成功传给sendmail()        return True   # return值可以是字符串ret = sendmail()print(ret)# 后面还可以加if判断

 

5. 函数中的参数

# 普通参数，按顺序传参def send(name,age):    print(name,age)    return Truesend('hexu',28)==> hexu 28# 默认参数def send(name,age,content='is a person'):    print(name,age,content)    return Truesend('Hexu',28)  # 默认参数：如果没指定参数，就会把默认参数打出来send('Xuelu',26,"is a god") # 指定一个参数，就会打指定的参数==> Hexu 28 is a person==> Xuelu 26 is a god# 指定参数:将实际参数复制给指定的形式参数def send(name,age):    print(name,age)    return Truesend(age=28,name='hexu')==> hexu 28# 带*的，可以接收动态参数def f1(*args):    print(args,type(args))f1(11)  # 一个参数f1(11,22,'hexu')  # 多个参数f1([11,22,'hexu'],'liuwei') # 参数也可以是列表f1(*['aa','bb',28]) # 实际参数前面带*，会将列表中的每一个元素当做元组中的一个元素f1(*'hexu')  # 实际参数前面带*，会将字符串中的每一个元素当做元组中的一个元素==> (11,) 
     
      ==> (11, 22, 'hexu') 
      
       ==> ([11, 22, 'hexu'], 'liuwei') 
       
        ==> ('aa', 'bb', 28) 
        
         ==> ('h', 'e', 'x', 'u') 
         
          # 带两个*的,生成的是字典def f1(**args):    print(args,type(args))f1(n1="hexu",n2=28) # 这种键值的组合，会自动生成字典dic = {
   'k1':'v1','k2':'v2'}f1(kk=dic) # kk是key，dic是valuef1(**dic)==> {
   'n2': 28, 'n1': 'hexu'} 
          
           ==> { 'kk': { 'k2': 'v2', 'k1': 'v1'}} 
           
            ==> { 'k2': 'v2', 'k1': 'v1'} 
            
             # 万能参数def f1(*args,**kwargs): print(args) print(kwargs)f1(11,22,33,k1='hexu',k2='liuwei')==> (11, 22, 33)==> { 'k2': 'liuwei', 'k1': 'hexu'}# 引出字符串的格式化s1 = 'i am {0},age {1}'.format('hexu',28)print(s1)s2 = 'i am {0},age {1}'.format(*['hexu',28])print(s2)==> i am hexu,age 28==> i am hexu,age 28# 必须指定s3 = 'i am {name},age {age}'.format(name='hexu',age=28)print(s3)dic = { 'name':'hexu','age':28}s4 = 'i am {name},age {age}'.format(**dic)print(s4)==> i am hexu,age 28==> i am hexu,age 28
            
           
          
         
        
       
      
     

7. 全局变量

# 函数执行顺序，自上到下,按最新的函数显示执行结果def f1(a1,a2):    return a1 + a2def f1(a1,a2):    return a1 * a2ret = f1(8,8)print(ret)==> 64# 函数传参，传递的是引用，不是再复制一份def f1(a1):    a1.append(999) li = [1,2,3,4,]  # li是全局变量，从这个例子中可以看出，函数的局部作用域可以对全局变量的进行修改。f1(li) print(li) # 最终li中增加了999这个元素# 定义全局变量，要大写！NAME = 'hexu'def f1():    age = 20    print(age,NAME)  # 引用全局变量NAMEdef f2():    age = 18    global NAME    # 修改全局变量要用global    NAME = 'liuwei' # 重新赋值    print(age,NAME)f1()f2()==> 20 hexu==> 18 liuwei# 特殊情况：不用global的情况下: 列表字典，可修改，不可赋值LI = [1,2]def f1():    LI.append(3)f1()print(LI)def f2():    LI = [4,5]f2()print(LI)==> [1, 2, 3]==> [1, 2, 3]

8. 内置函数

# abs() 绝对值n = -1print(abs(n))==> 1# 0,None,'',[],{}# all() 一个为假，就为假n = all([1,2,3,None])print(n)==> Flase# any() 一个为真，就为真n = any([[],0,'',6])print(n)==> True# bin()十进制转换为二进制  0bprint(bin(5))==> 0b101# oct() 十进制转换为八进制 0oprint(oct(9))==>0o11# hex() 十进制转换为十六进制 0xprint(hex(15))==> 0xf# ut8-f 一个汉字是3个字节# gbk 一个汉字是2个字节# 字符串转换成字节# bytes()  只能转换字符换，按照什么编码，默认转换成16进制，非常重要！！n = bytes('贺旭',encoding='utf-8')print(n)==> b'\xe8\xb4\xba\xe6\x97\xad'n = bytes('贺旭',encoding='gbk')print(n)==> b'\xba\xd8\xd0\xf1'# 字节转换成字符串,编码一定要一致n = str(bytes('贺旭',encoding='utf-8'),encoding='utf-8')print(n)==> 贺旭

9. 内置函数中的open文件操作

# db文件原始内容如下hexu|123liuwei|999# 以只读形式打开文件with open('db','r') as fp:    data = fp.read()    print(data, type(data))输出：hexu|123liuwei|999 
     
      # 追加到文件的最后，加b是字节，没有b是字符串with open('db','ab') as fp:    data = fp.write(bytes('刘伟',encoding='utf-8'))    print(data)输出：hexu|123liuwei|999刘伟# r+ 配合seek使用f = open('db','r+',encoding='utf-8') # 如果没有b，则read，按照字符读取;如果有b,按照字节读取data = f.read(1)print(data)==> 1print(f.tell())  # 找到当前指针所在位置 （字节）f.seek(f.tell())  # 指针跳转到指针位置（字节）f.write('88')  # 当前指针位置开始向后覆盖f.close()输出：h88u|123liuwei|999# 同时打开多个文件with open("db", "r") as file01, open("db.bak", "x") as file02:    for i in file01: # 读取db文件的每一行，写入到db.bak文件，如果db.bak文件存在，报错，不做操作        file02.write(i)       with open("db.bak", "r") as f:    res = f.read()print(res)
     

10. 利用函数做一个用户登录程序

# db原始文件内容hexu|123liuwei|999def login(username,password):    '''    用于用户登录    :param username: 用户输入的用户名    :param password: 用户输入的密码    :return: True，表示登录成功；False，表示登录失败    '''    with open('db','r') as fp:        for line in fp:            line_list = line.strip().split('|')            if line_list[0] == username and line_list[1] == password:                return True        return Falsedef register(username,password):    '''    用于用户注册,注意判断输入的用户名是否在db里已经有了    :param username: 用户输入的用户名    :param password: 用户输入的密码    :return: 默认None    '''    with open('db','a') as fp:        tmp = '\n' + username + '|' + password        fp.write(tmp)def main():    choose = input('1:登录  2:注册')    if choose == '1': # 这里的1是字符串        user = input('请输入用户名：')        pwd = input('请输入密码：')        r = login(user,pwd)  # 引用login函数,将用户输入的用户名、密码传进去        if r:            print('登录成功')        else:            print('登录失败')    elif choose == '2':        user = input('请输入用户名：')        pwd = input('请输入密码：')        register(user,pwd)main()

 

三、三元运算

# 传统模式a = input("请输入1")if a == "1":    name = "hexu"else:   name = "liuwei"print(name)# 三元运算 对if else 的简写a = input("请输入1")name = "hexu" if a == "1" else "liuwei"print(name)

四、lambda表达式

# 传统方式def f1(a1):    return a1 + 100ret = f1(10)print(ret)==> 110f2 = lambda a1,a2:a1 + a2 + 100 # 冒号前面的是参数ret1 = f2(10,20)print(ret1)==> 130