python学习笔记-Day3

se = {"123","456"}   
se = set()    #创建一个空的集合
se = set([11,22,33,4])  #将其它可迭代的序列转换为集合

# add方法
s = set()
s.add(123)
s.add(123)
s.add(123)
print(s)
#==> {123}   
# set不保存重复的项目，当add存在的项目，则不去添加

# 比较方法
# difference方法
s1 = {11,22,33}
s2 = {22,33,44}
diff = s1.difference(s2)
print(diff)
#==> {11}  
# s1对比s2，输出s1中存在且s2不存在的


# symmetric_difference
s1 = {11,22,33}
s2 = {22,33,44}
s = s1.symmetric_difference(s2)
print(s)
#==> {11, 44}  
# s1与s2对比，输出s1与s2互相不存在的值


# difference_update
s1 = {11,22,33}
s2 = {22,33,44}
s = s1.difference_update(s2)
print(s,s1,s2)
#==>None {11} {33, 44, 22}  
# 此方法并不返回值，所以s值为none，直接将s1中存在s2中不存在值重新赋值给s1


# symmetric_difference_update
s1 = {11,22,33}
s2 = {22,33,44}
s = s1.symmetric_difference_update(s2)
print(s,s1,s2)
#==> None {11, 44} {33, 44, 22} 
# 同样Update方法不返回值，将s1与s2互相不存在的值重新赋值给s1

# 移除方法
# discard 
s1 = {11,22,33}
s1.discard(11)
s1.discard(44)
print(s1)
# ==> {33, 22}
#移除元素方法，移除不存在元素时，不报错


# remove
与discard相同，移除不存在元素，报错
所以建议使用discard


# pop
s1 = {11,22,33}
s =  s1.pop()
print(s)
print(s1)
#==> 33 {11,22}
# 随机移除某个元素，并且获取这个元素


# 交集
# intersection 交集，求两set的交集
s1 = {11,22,33}
s2 = {22,33,44}
s = s1.intersection(s2)
print(s,s1,s2)
#==> {33, 22} {33, 11, 22} {33, 44, 22}


# 并集
# union 并集
s1 = {11,22,33}
s2 = {22,33,44}
s = s1.union(s2)
print(s,s1,s2)
#==> {33, 22, 11, 44} {33, 11, 22} {33, 44, 22}


# set集合可迭代更新
# update方法
s1 = {11,22,33}
s1.update([44,55,66])
print(s1)
# ==> {33, 66, 11, 44, 22, 55}
# Update方法可传入一个可迭代的对象

def 函数名(参数):    # def关键字，创建函数
       
    ...
    函数体
    ...
    返回值

def sendmail():
    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", "邮箱密码")
    server.sendmail(‘wptawy@126.com‘, [‘424662508@qq.com‘,],msg.as_string())
    server.quit()

sendmail()    #执行这个函数

def f1():
    if 1>2:
        return True
    else:
        return False

ret = f1()
print(ret)   #==> False 
# return 后边加了什么就返回给调用该函数什么值
# return 通用可以返回字符串等

def f1():
    if 1>2:
        return True
    else:
        return False
        print(123)
f1() # ==> 什么都不输出

# 在函数中，一旦执行了return，函数的执行过程立即终止

def f1():
    print(123)

ret = f1()
print(ret) #==> None

#如果函数中没有return，函数默认会返回一个值None

# 形式参数与实际参数

# 这里的name并没有实际意义，它只是用来调用此函数时，把实际参数传入，所以这里的name就叫“形式参数”，简称：形参
def func(name):
    print(name)

# ######### 执行函数 ######### 
#  调用此函数时，我们传入将要在函数中执行并去返回一个结果的这个参数，有实际的意义，这里这个"XXOO"就称为“实际参数”，简称：实参
func(‘xxoo‘)

def func(name, age = 18):
    
    print("%s:%s" %(name,age))

# 指定参数
func(‘sss‘, 19)
# 使用默认参数
func(‘www‘)

# 默认参数当传入值时，将按照默认给的值去函数中执行（当调用时）

注：默认参数需要放在参数列表最后，否则会报错

def func(*args):

    print(args)


# 执行方式一
func(11,33,4,4454,5)  
# *号回收集其余的位置参数


# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)
# 如果使用*li(列表等可迭代)，就相当于做了一个for循环，将这个可迭代的每一个值取出来去调用执行函数

def func(**kwargs):

    print(args)


# 执行方式一
func(name＝‘xx‘,age=18)
# **收集多个有‘变量’和‘值’对组成的参数

# 执行方式二
li = {‘name‘:‘yy‘, age:18, ‘gender‘:‘male‘}
func(**li)
# 在调用函数时，可以传入字典方式，传入多个‘变量’和‘值’对

# 函数的参数实例
def f1(a1):
    a1.append(9999)

li = [1,2,3,4]
f1(li)

print(li)   # ==> [1,2,3,4,9999]

#函数在传递实参时，传递的是一个引用而不是一个值，这个引用相当于一个硬链接，所以当传入引用时，在函数中该变这个应用，原值则同样跟着该变

if 1==1:
    name = ‘xxx‘
else:
    name=‘yyy‘

# 将以上判断简写成三元运算：
name = ‘xxx‘ if 1==1 else ‘yyy‘

def f1(a1):
    return a1 + 100

# 将以上函数写为匿名函数：

f2 = lambda a1: a1+100
# 注意这里f2是被直接赋值了，lambda作为匿名函数也不能像函数代码复用，它是一个临时性函数

# all() 接受一个可以被迭代的对象，这个对象中一旦有一个值为假返回假
all([1,2,3,False])  #==>False

# any() 同样接收一个可以被迭代的对象，这个对象中有一个为真，则返回真
any([1,2,3,False])  # ==> True

bin()    #接收十进制，转换为2进制
oct()    #接收十进制，转换为8进制
hex()   #接收十进制，转换为16进制


# bytes()函数，将字符串转换为字节
bytes(要转换字符串， 按照什么编码去转换)
s = ‘中文‘
n = bytes(s, encoding="utf-8")

# str(), 可以将bytes转为字符串
b = bytes(s, encoding="utf-8")
str(b, encoding="utf-8")  # 使用什么编码转换为字节码，转换为字符串时就使用什么编码转换回

# open 函数
open(‘t.txt’, ‘x’)  # x文件存在，报错，不存在，创建并写内容  python3新增
r  # 只读
w  # 只写，先清空文件
a  # 追加

# open 函数打开文件制定编码
open(‘db’,’r’, encoding=’gbk’)   # 如果db文件使用的是gbk编码保存，就需要指定以gbk编码打开

# open  rb、wb…模式
open(‘db’,’rb’)  # 不需要指定encoding
# 文件以字节码打开或写入
f= open(‘db‘,‘r+b‘)
data = f.read()
print(data,type(data))   # 读出文件以bytes读出
f.write(bytes(‘呵呵呵‘,encoding=‘utf-8‘))  #  同样写入时 ，需要手动转为字节码写入
f.close()


# f.seek()  主动的将指针调到某个位置
f=open(xxx…)
f.seek(1)   # 将指针调到1处
f.write(‘555’)  # 覆盖从1开始的3个字符
# seek以字节方式找位置，所以中文被seek后write，很容易出现乱码
f.seek 使用时a+模式 无论seek到哪个位置，都会将指针挪到最后位置
w+模式 会先清空文件，然后seek就是空文件了挪不了指针

# f.tell()  告诉当前指针所在的位置   

f.seek(20)
f.write("888")  # 这里指定位置后，写入会在当前指针处向后覆盖，而不是插入

# 操作文件
read()
# 有b参数，按字节读取
# 无b参数，按字符读取

tell() #获取当前指针（字节）

seek(1) #指针跳转到指定位置（字节）

write() #写数据，b:字节  无b：字符

# f.flush()
强制更新文件，在没有f.close()时，所有write操作都会在缓冲区没有写入文件，使用flush强制写入