玩蛇(Python)笔记之基础Part3

玩蛇(Python)笔记之基础Part1

一.集合

1.set 无序,不重复序列 {}创建,直接写元素

2.set功能 __init__()构造方法,,使用强制转换就会调用此方法

set1 = {'year', 'jiujiujiu'}
print(type(set1))
# 创建集合
s = set()  # 创建空集合
li = [11, 22, 11, 22]
s = set(li)

3.集合的基本操作

# 操作集合
s1 = set()
s1.add(123)  # 添加元素
s1.clear()  # 清空set
s2 = s1.copy()  # 浅拷贝
s1.difference(s2)  # s1中存在s2中不存在的元素
s1.symmetric_difference(s2)  # 对称差集 去掉两个set中相同的元素
s1.difference_update(s2)  # 同difference 不过会更新s1
s1.symmetric_difference_update(s2)  # 同symmetric_difference 不过会更新s1
s1.discard(1111)  # 移除指定元素 不存在不报错
s1.remove(1111)  # 移除指定元素 不存在报错
s1.pop()  # 移除随机元素并且获取此元素
s1.intersection(s2)  # 取交集
s1.intersection_update(s2)  # 取交集并更新
s1.issubset(s2)  # 是否为子序列
s1.issuperset(s2)  # 是否为父序列
s3 = s1.union(s2)  # 取并集
s1.update(s2)  # 接收一个可迭代对象循环调用add()

4.关于对象的内部特殊函数

li = [11, 22, 33]  # list __init__
li()  # list __call__
li[0]  # list __getitem__
li[0] = 123  # list __setitem__
del li[1]  # list __delitem__

5.set 小练习 更新字典

old_dic = {
    '#1': 4,
    '#2': 4,
    '#4': 2,
}
new_dic = {
    '#1': 4,
    '#2': 4,
    '#3': 2,
}
new_set = set(new_dic.keys())
old_set = set(old_dic.keys())

remove_set = old_set.difference(new_set)
add_set = new_set.difference(old_set)
update_set = new_set.intersection(old_set)

#再根据以上集合 来更新字典

二.函数

1.什么是函数

def f1():  # def关键字,创建函数 函数名 ()
    pass  # 函数体 返回值 默认返回值是none

2.来个发送邮件函数

def sendMail():
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr
    try:
        msg = MIMEText('内容', 'plain', 'utf-8')
        msg['From'] = formataddr(["YEAR", 'yearzhou93@gmail.com'])
        msg['To'] = formataddr(["揍你", '243132373@qq.com'])
        msg['Subject'] = "主题"

        server = smtplib.SMTP("smtp.gmail.com", 25)
        server.login("yearzhou92@gmail.com", "year93926")
        server.sendmail('yearzhou92@gmail.com', ['243132373@qq.com', ], msg.as_string())
        server.quit()
    except:
        return False
    else:
        return True


ret = sendMail()
if ret:
    print('OK')
else:
    print('faild')

3.函数变量

　　普通参数(严格按照顺序将实际参数传递给形式参数)

　　默认参数(必须放置到参数列表的最后)

　　指定参数(将实际参数赋值给指定的形式参数)

　　* 动态参数 默认将传入的参数放入一个元组中 f(*[11,22,3,4])每一个元素

　　** 动态参数2 默认将传入的参数放入一个字典中 f(**['1':11,'asdf':123])

　　万能参数 f(*args,**kwargs) *在前**在后

　　函数的参数进行传递的时候是引用还是值 是引用！！！！

　　全局变量 作用域问题 所有作用域都可读!! 重新赋值得加上global关键词 特殊的是列表字典可修改但不能重新赋值因为是引用 全局变量大写约定俗成

def sendMail1(xxoo, content, xx='biubiubiu'):  # 形式参数和默认参数 默认参数必须要放到参数列表最后!!!
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr
    try:
        msg = MIMEText(content, 'plain', 'utf-8')
        msg['From'] = formataddr(["YEAR", 'yearzhou93@gmail.com'])
        msg['To'] = formataddr(["揍你", '243132373@qq.com'])
        msg['Subject'] = "主题"

        server = smtplib.SMTP("smtp.gmail.com", 25)
        server.login("yearzhou92@gmail.com", "year93926")
        server.sendmail('yearzhou92@gmail.com', [xxoo, ], msg.as_string())
        server.quit()
    except:
        return False
    else:
        return True


ret = sendMail1('243132373@qq.com', 'SB')  # 普通参数 默认参数

while True:
    em = input("输入邮箱地址:")
    ret1 = sendMail1(em, 'SB')
    if ret:
        print('ok')
    else:
        print('doubi')

sendMail1(content='jjj', xxoo='jjj')  # 指定参数传参


def f2(*args):  # 将接收的n个参数放到一个元组李里
    print(args)


f2(11, 22, 33, 44, 'asdfasdf')
li = [11, 22, 33, 44, 55, 'asdfasdf']
f2(li)  # 将此列表作为元组的一个元素
f2(*li)  # 将此列表所有元素作为元组的一个元素 *其实是对li做一个循环将每个元素分离出来


def f3(**args):  #
    print(args, type(args))


f3(name='year')  # 传入键值对作为字典
dic = {'name': 'year', 'age': 23}
f3(kk=dic)  # 将dic作为一个元素
f3(**dic)  # **可以循环将dic里的每一个键值对分离出来


def f4(*args, **kwargs):  # 万能参数
    print(args)
    print(kwargs)


# string的format格式化输出
a = 'i am {0},age{1}'.format(*["alex", 234])
b = 'i am {name},age{age}'.format(**{'name': 'year', 'age': 123})


# 函数的参数进行传递的时候是引用还是值  是引用！！！！
def f5(list1):
    list1.append(999)


li = [111, 222, 333, 444]
f5(li)
print(li)

# 全局变量
name = 'year'


def f6():
    # name = 'jiujiujiu'
    global name
    name = 'jiujiujiu'
    # 特殊情况 列表字典
    li.append('adsf')  # 可修改
    global li  # 重新赋值得用global
    # li = 'jiujiujiu'


print(name)

　　4.函数式编程小练习

# -*- coding:utf-8 -*-
# Author:YEAR


def login(user, pwd):
    """
    用于用户登录
    :param user: 用户输入的用户名
    :param pwd: 用户输入的密码
    :return: true表示成功 False表示失败
    """
    f = open("db", 'r')
    for line in f:
        line_list = line.strip().split("|")
        if line_list[0] == user and line_list[1] == pwd:
            return True
    return False


def register(user, pwd):
    """
    用于用户注册
    :param user: 用户名
    :param pwd: 密码
    :return: True注册成功
    """
    f = open("db", 'a')
    temp = user + "|" + pwd
    f.write(temp)
    return True


def main():
    t = input("1:登录;2:注册")
    if t == '1':
        user = input("请输入用户名")
        pwd = input("请输出密码")
        r = login(user, pwd)
        if r:
            print("登录成功")
        else:
            print("登录失败")
    else:
        user = input("请输入用户名")
        pwd = input("请输出密码")
        r = register(user, pwd)


main()

 

三.三元运算lambda表达式内置函数

　　1.三元运算,三目运算 简单的ifelse可以用此方式

　　2.lambada表达式 简单的function可以用此方式

　　3.一些内置函数

name = 'year' if 1 == 1 else 'SB'
# 1.2lambada表达式 简单的function可以用此方式
f2 = lambda a1: a1 + 100
# 2.1内置函数
# abs()绝对值
n = abs(-1)
# all() any()  0,None 负数 空字符串 空列表 空字典 空元组是false
# all接收一个可迭代的对象 有一个是假就是假 所有为真才是真 any为任何一个为真就是真
n = all([11, 22, 33, 44, ''])
n = any([11, 22, 33, 44, 55])


# ascii() #自动执行对象的__repr__方法
class Foo:
    def __repr__(self):
        return "111"


n = ascii(Foo())

# bin() oct() hex() 分别接收十进制转换成2进制8进制16进制
print(bin(5))
print(oct(7))
print(hex(9))
# utf-8编码一个汉字三个字节 gbk一个汉字两个字节
# 字符串转换成字节类型 用bytes()
print(bytes('周', encoding='utf-8'))
# 字节转换成字符串 用str
print(str(bytes('周', encoding='utf-8'), encoding='utf-8'))

 

 四.文件操作

　　

# -*- coding:utf-8 -*-
# Author:YEAR
# 打开文件
f1 = open('db', 'r', encoding='utf-8')  # 只读 encoding参数告诉python转化编码
data = f1.read()
print(data, type(data))  # 读出的为字符串类型,python默认做了编码转换将字节转换成了字符串,,
f1.close()
f1 = open('db', 'rb', encoding='utf-8')  # b表示2进制打开不要python做编码转换,写也一样
data = f1.read()
print(data, type(data))  # 读出的类型为字节类型
f1.close()

f2 = open('db', 'w')  # 只写 先清空源文件
f3 = open('db', 'x')  # 如果文件存在报错,,不存在创建并写内容
f5 = open('db', 'a')  # 追加
# +号 文件以可读可写打开
f1 = open('db', 'r+',
          encoding='utf-8')  # 文件位置指针 打开时在最开始 读完后 指针在最后,,再去写的时候会写在最后 python只要你读指针必会变到最后!! 所以写一般用r+不用a+ 也不用w+ w会清空

data = f1.read()  # read会按模式去读!!!
print(data, type(data))
f1.seek(1)  # seek会强行调整文件位置指针位置, 在其中某个位置写会覆盖其后的内容!!!! 永远是按字节方式找位置
f1.read(1)
f1.tell()  # 获取当前文件指针位置
f1.seek(f1.tell())  # 调整指针到指定位置
f1.write('888')
f1.close()

# 操作文件
f2.read()  # 无参数读全部 如果有参数 b按字节无b按字符
f2.tell()  # 获取当前指针位置
f2.seek(1)  # 跳转指针位置 永远按字节
f2.write('ss')  # 打开方式有关 有b只能写字节 无b写字符串
f2.fileno()  # 文件的数字形式描述符
f2.flush()  # 强刷 将写的内容强制刷新到硬盘上 close()会自动刷新
f2.isatty()  # 是否是tty设备
f2.readable()  # 是否可读
f2.seekable()  # 是否可移动指针
f2.readline()  # 只读一行
f2.truncate()  # 从文件指针位置截断数据 后面的删除

for line in f2:  # 迭代文件 一行一行
    pass
# 关闭文件
f1.close()
with open('db', 'a') as f4:
    pass
with open('db', 'a') as f6, open('db2', 'a') as f7:
    for line1 in f6:
        new_str = line1.replace('alex', 'st')
        f7.write(new_str)
    pass