【python-Day3】

一、set

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

# 创建set集合
s1 = {11, 22, 33}
print(s1,type(s1))
==> {33, 11, 22} <class 'set'>
 
l1 = [2, 3, 4,]
s1 = set(l1)
print(l1,type(l1))
==> [2, 3, 4] <class 'list'>

print(s1,type(s1))
==> {2, 3, 4} <class 'set'>

# 集合中增加元素
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，有交集时返回False
s1 = {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 "<stdin>", line 1, in <module>
    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两个集合的并集，再把他俩的交集删掉。结果赋值给s1
s1 = {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) 去两个集合的并集，将结果赋值给s1
s1 = {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 Xu

old_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不存在的key
remove_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 True

send('hexu',28)

==> hexu 28

# 默认参数
def send(name,age,content='is a person'):
    print(name,age,content)
    return True

send('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 True

send(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,) <class 'tuple'>
==> (11, 22, 'hexu') <class 'tuple'>
==> ([11, 22, 'hexu'], 'liuwei') <class 'tuple'>
==> ('aa', 'bb', 28) <class 'tuple'>
==> ('h', 'e', 'x', 'u') <class 'tuple'>

# 带两个*的,生成的是字典
def f1(**args):
    print(args,type(args))

f1(n1="hexu",n2=28) # 这种键值的组合，会自动生成字典

dic = {'k1':'v1','k2':'v2'}

f1(kk=dic) # kk是key，dic是value
f1(**dic)

==> {'n2': 28, 'n1': 'hexu'} <class 'dict'>
==> {'kk': {'k2': 'v2', 'k1': 'v1'}} <class 'dict'>
==> {'k2': 'v2', 'k1': 'v1'} <class 'dict'>

# 万能参数
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 + a2

def f1(a1,a2):
    return a1 * a2

ret = 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)  # 引用全局变量NAME

def 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 = -1
print(abs(n))

==> 1

# 0,None,'',[],{}
# all() 一个为假，就为假
n = all([1,2,3,None])
print(n)

==> Flase

# any() 一个为真，就为真
n = any([[],0,'',6])
print(n)

==> True

# bin()十进制转换为二进制  0b
print(bin(5))
==> 0b101

# oct() 十进制转换为八进制 0o
print(oct(9))
==>0o11

# hex() 十进制转换为十六进制 0x
print(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|123
liuwei|999

# 以只读形式打开文件
with open('db','r') as fp:
    data = fp.read()
    print(data, type(data))

输出：
hexu|123
liuwei|999 <class 'str'>

# 追加到文件的最后，加b是字节，没有b是字符串
with open('db','ab') as fp:
    data = fp.write(bytes('刘伟',encoding='utf-8'))
    print(data)

输出：
hexu|123
liuwei|999刘伟

# r+ 配合seek使用
f = open('db','r+',encoding='utf-8') # 如果没有b，则read，按照字符读取;如果有b,按照字节读取
data = f.read(1)
print(data)
==> 1

print(f.tell())  # 找到当前指针所在位置 （字节）
f.seek(f.tell())  # 指针跳转到指针位置（字节）
f.write('88')  # 当前指针位置开始向后覆盖
f.close()

输出：
h88u|123
liuwei|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|123
liuwei|999


def 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 False


def 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 + 100
ret = f1(10)
print(ret)
==> 110

f2 = lambda a1,a2:a1 + a2 + 100 # 冒号前面的是参数
ret1 = f2(10,20)
print(ret1)
==> 130