python22期自动化-Day3

is == id 小知识回顾：
    ==      数值的比较
    is  内存地址比较
    id  测试的是内存地址
    小数据池（只有str和int有这个概念）：节省内存
    int：-5 ~~ 256
    str：
    1、不能含有特殊字符
    2、单个元素*数字，不能超过21

编码：
    ascii   数字，字母，特殊字符
    字节：8位一个字节
    字符：看到的内容的最小组成单位

    unicod： 万国码
    起初： 两个字节表示一个字符
    升级： 4个字节表示一个字符

    utf-8：  最少用8位表示一个字符
    英文: 1个字节
    欧洲： 两个字节
    亚洲： 三个字节

    gbk：    国标
    英文： 1个字节
    中文： 两个字节

    1、不同编码之间的二进制是不能互相识别的。
    2、对于文件的存储，及传输不能是Unicode

    编码转化：
    python3
    str的内部编码方式为Unicode
    bytes唯一一点不同是内部编码方式：可设定的（非Unicode编码）

    bytes类型中文展现形式为字节形式，可读性弱

    encode  编码
    decode  解码
    x = '中国'
    y = x.encode('utf-8')
    print(y)
    x = y.decode('utf-8')
    y = x.encode('gbk')
    print(y)
    x = y.decode('gbk')
    print(x)
    ------------------------------------------------------------------------------
    b'\xe4\xb8\xad\xe5\x9b\xbd'
    b'\xd6\xd0\xb9\xfa'
    中国
    ------------------------------------------------------------------------------

1、要求它里面的元素是不可变的（可哈希），元素不重复，无序
2、集合本身是不可哈希的

set1 = {'alex', 'wusir', 'taibai'}

1、关系测试
    交集
        set1 & set2
        set1.intersection(set2)
    并集
        set1 | set2
        set1.union(set2)
    差集
        set1 - set2
        set1.difference(set2)
    反交集
        set1 ^ set2
        set1.symmetric_difference(set2)
    父子集
        set1 > set2     set1是set2的子集为True
        set1.issubset(set2) set1是set2的子集为True

        set1 < set2     set1是set2的超集为True
        set1.issuperset(set2)set1是set2的子集为True

2、去重

    增
        set1.add('wanliang')
        set1.update('abc') --> 迭代式增加
    删
        set1.pop() --> 随机删除，有返回值
        ste1.remove('alex') --> 按照元素删除，不存在会报错
        set1.clear() --> 清空，set()代表空集合
        del set1 --> 删除整个集合
    查
        只能用for循化去查

    不可改（无序且无索引）

冻集合
    frozenset(set1) 将集合转换为不可变的集合

赋值运算    共用一个内存地址

浅copy   第一层各自独立，从第二层开始，共用一个内存地址
    s2 = sl.copy()

深copy   所有层各自独立
    import copy
    s2 = copy.deepcopy(s1)

f1 = open('file='filename.txt', encoding='utf-8', mode='r')

 含义：
  f1 文件句柄，f,file,file_hander,f_h
        open()调用的内置函数，内置函数调用的系统内部的open，
        一切对文件的操作都是基于文件句柄
    方式：
        读：r rt rb 
            r+模式   读写，
            r模式   read(n) #n对于字符而言
            rb模式         #对于字节而言
            readline      #按行读取
            readlines     #放入列表，每一行相当于一个元素
            for循环

        写：w
            w，没有源文件创建文件，源文件已存在，先清空，再写入。

        追加：a
            a，没有源文件创建文件，源文件存在，内容写到最后。

        其他方法：
             readable()    是否可读
             writeable()       是否可写
             seek()       调整光标,seek(0)光标调整到开头,seek(0,2),调整到末尾.
             tell()       显示光标所在位置
             truncate()    截断数据，按照字节对源文件进行处理,必须在a或者a+模式
             with open     不用主动关闭句柄
     文件的修改：
        1、以读模式打开源文件
        2、以写模式打开新文件
        3、将源文件读出按照要求修改将修改后的内容写入到新文件
        4、删除源文件
        5、将新文件重命名为源文件

     同一个文件句柄可以写多次

定义：
    def 关键字  函数名():
    函数：以功能为导向

return:返回值
    a. 终止函数    return
    b. 给函数的执行者返回值 return 666
    c.
    '''
    return 或者 return None
    return 单个值
    return 多个值 会将多个值放到一个元祖中
    '''

传参：
    def my_len(argv):  # 形式参数，形参
        count = 0
        for i in argv:
            couont += 1
            return count
    s = 'fdsfdsfsdfds'

    print(my_len(s))  # s实际参数，实参

    - 实参角度：
        - 位置参数：一一对应,按照顺序
        def func1(a,b,c):
            print(a,b,c)
        func1(1,2,'anthony')

        - 关键字参数：一一对应
        def func2(a,b):
            print(a,b)
        func2(a=1,b=2)

        - 混合参数：关键字参数必须在位置参数后面
        def func3(a,b,c,d):
            print(a,b,c,d)
        func3(1,3,d=4,c=9)

    - 形参角度:

        - 位置参数:一一对应,按照顺序

        - 默认参数：默认参数在位置参数的后面

        - 动态参数：*args  **kwargs  万能参数（*在函数定义的时候,代表聚合）魔法应用
        args：所有的位置参数，放在一个元祖中
        kwargs:所有的关键字参数，放在一个字典中

        def func3(*args,**kwargs): （*在函数定义的时候,代表聚合）
            print(args)
            print(kwargs)
        func3(*[1,2,3],*(22,33))  (*函数执行的时候,代表打散)

        - 形参的顺序：
        位置参数 --> 默认参数 --> 关键字参数