一、SET集合

    set集合是无序的，不重复的。

    1.创建

第一种：

s1 = {"123","456"}     #集合用大括号包起来，字符串用逗号隔开

第二种：

li = [11,22,33]

s2 = set(li)

#当执行set（）的时候，实际上是调用set的__init__来对li里边的元素做一个for循环，然后转成set。

    2.功能

1.s1.add（） #增加元素

2.s1.clear() #清空集合内容

3.s1.copy（）#浅复制

4.s1.difference  #a中存在，b中不存在

5.s1.symmetric_difference #a中存在，b中不存在拿出来 和 b中存在，a中不存在拿出来（也称对称差级）

6.s1.difference_update #a中存在，b中不存在拿出来，然后重新赋值给左边的变量s1

7.s1.symmetric_difference_update #a中存在，b中不存在拿出来 和 b中存在，a中不存在拿出来，然后重新赋值给左边的变量s1

8.s1.discard #移除特定元素，如果没有元素不报错

9.s1.remove #移动特定元素，如果没有会报错

10.s1.pop #随机移除，把移除的值赋给变量

11.s1.intersection #取两个变量的交集（就是两个变量里边相同的元素）

12.s1.inteersection_update #取两个变量的交集，然后赋值给左边的变量s1

13.s1.isdisjoint #如果有交集，返回True，否则返回False

14.s1.issubset #一个变量是否是另一个变量的子序列

15.s1.union #并集，就是把两个变量的元素联合起来

16.s1.update #批量添加元素，接收一个可迭代的对象，例如：列表、元祖、字符串

    3.集合练习题

        有两个字典，现在要把新的字典里边的内容添加到旧的字典里，找出

        1.应该删除的项

        2.应该添加的项

        3.应该更新的项

        需求分析:

            1.首先确定可以用set功能来实现

            2.需要把字典的keys读取出来转成set集合

            3.找出旧字典应该删除、添加、更新的项


#旧字典

old_dict = {

    '#1':8,

    '#2':4,

    '#4':2,

}

#新字典

new_dict = {

    '#1':4,

    '#2':4,

    '#3':2,

}

old_set = set(old_dict.keys())  #把旧字典keys转换成集合

new_set = set(new_dict.keys())  #把新字典keys转换成集合


remove_set = old_set.difference(new_set)    #找出应该删除的

add_set = new_set.difference(old_set)       #找出应该添加的

update_set = old_set.intersection(new_set)  #找出应该更新的


print(remove_set,add_set,update_set)        #打印找出的删除、添加、更新


输出：

{'#4'} {'#3'} {'#1', '#2'}

二、函数

    函数分为自定义函数和内置函数

    1、定义函数

1.函数关键字def

2.函数名

3.写个（）

4.函数体（具体内容）

5.返回值

6.自定义的函数自己不被执行

例如：

def aa():

    函数体
在PyCharm中可以点击代码左端空白处，可以打断点执行代码，查看代码执行流程。

    2、执行函数返回值

函数利用try retrun来实现返回值。

def aa():

    try :

        函数体

    except:

        return False #失败返回False

    else:

        return True #成功返回True

注意：

1.在函数中一旦执行了return，函数的执行过程立即终止，不会再往下走！

2.函数中如果没有指定return，默认python返回一个return值为None

    3、函数的基本参数

1.普通参数 #一一对应，严格按照顺序执行，将实际参数赋值给行为参数；

2.默认参数 #当函数执行的时候没有给变量赋值的时候，使用默认参数；设置默认参数的行为参数要放到最后，可以连着多个；

3.指定参数 #给指定的参数赋值

（函数冒号左边括号里边的叫做行为参数；执行函数的时候，括号里边的参数叫做实际参数。）

    4、函数的动态参数

1.行为参数之前加一个* 就可以接受多个实际参数（接收迭代参数列表、元组、字符串，不接收字典）输出格式为元祖，按顺序处理。

      def f1(*args):

          print ("abc","123")

      例一：当实际参数前不加*时，函数会把迭代参数整体作为一个元素放到元祖里。

          def f1(*args):

              print (args)

          li = [11,22]

          f1(li)

          输出：([11,22])

      例二：当实际参数前也加一个*时，函数会对迭代参数里边的所有元做一个for循环，然后赋值到元祖里；

          def f1(*args):

              print (args)

          li = [11,22]

          f1(*li)

          输出：(11,22)

2.行为参数之前加两个* 就可以接受字典参数，输出格式为字典，处理key、values键值对

      def f1(**args):

          print (args)

      f1('n1'='aaa','n2'='ddd')

      输出：{'n1':'aaa','n2':'ddd'}

3.万能参数（就是*args和**kwargs一起使用,它会自动识别是列表还是字典，然后赋值给*args和**kwargs）

    5、利用动态函数实现format功能

格式：str.format

功能：实现格式化输出方法(同万能参数功能,都是通过*args和**kwargs)

例如：s = "i am {0},age{}".format('abc','123')  （括号里边的abc和123也可以写成一个列表）

      s = "i am {0},age{}".format(*['abc','123'])

输出：i am abc,age 123

    6、函数内容补充

例一：

def f1(a1,a2):

    return a1+a2

def f1(a1,a2):          #当运行到这里的时候f1已经重新赋值，内存段也不一样了，

    return a1*a2

result = f1(8*8)

print (result)          #所以结果是64      

例二：

python函数中，当传递参数的时候，python默认为引用参数，不是重新复制参数赋值。

def f1(a1):

    a1.append(111)

li= [11,22]

f1(li)             #这里的li为引用，不是重新赋值

print (li)         #结果为[11,22,999]

    7、全局变量

1.作用域内的变量只能作用域内使用；

2.全局变量所有作用域都可以读取，但不能修改；

3.局部变量优先于全局变量；

4.作用域要修改变量，需要在作用域中加global+变量名；

5.如果全局变量是列表或者字典时，作用域不加global可直接添加元素，但不能重新赋值；如果重新赋值，要加global+变量名；


（注意：所有全局变量名要都用大写，方便区分）

    8、函数式编程实现登录和注册

三、三元运算（也称三目运算，if else的简写）

用来简单的if else的运用；

例如：

常规的写法：

    if 1 == 1:

        name = 'aaa'

    else:

        name = 'bbb'

三元运算写法：

    name = 'aaa' if 1 == 1 else 'bbb'

四、lambda表达式

用作简单函数的简写，对简单的函数赋值做操作，只能写一行。

例如：

    def f1(a):

        return a+100

lambda写法：

    f1 = lambda 1: a+100    #return默认隐含了

五、内置函数

1. .abs()  #取绝对值

2. .all()  #接收可以被迭代的对象。当括号里所有为真时，为真；括号里只有一个为假时，就为假。

3. .any()  #括号里只要有真，就为真。

4. .ascii()  #自动执行某对象的的__str__方式

5. .bin()  #接收十进制，然后转成二进制 0b代表二进制

6. .oct()  #接收十进制，然后转成八进制 0o代表八进制

7. .nex()  #接收十进制，然后转成十六进制 0x代表十六进制

8. .bool() #真或假、True或False

9. .bytes()     #把字符串转成字节类型 例如：bytes(s,encoding"utf-8")

10. .bytearry() #把字符串转成字节类型，放到一个列表里。

五、文件操作

1.打开文件

    f = open ('文件名字','什么方式')

    打开文件的方式有：

        1.r 只读

        2.w 只写（清空之后再写）

        3.x （如果文件存在，就报错；如果不存在，就创建再写内容）

        4.a 追加  永远是追加到光标所在位置的最后

        5.r+  读写

        6.w+  先清空再写读

        7.a+  读写，但是永远是追加到最后

        8.x+  读写

        9.b 以二进制的方式读写

        10.b+  

2.操作文件（文件操作功能）

        1.read()

        2.tell()

        3.seek()

        4.write()

        5.close()

        6.flush()

        7.readable()

        8.seekable()

        9.readline()

        10.readlines()

        11.truncate()

        12.for循环文件对象

           例如;

               f = open("aaa.txt",'r=')

                   for line in f:   #会把f里边的一行一行读取出来赋值给line

                       print (line) 

3.with 同时打开多个文件

        with open("db1",'r',encoding="utf-8") as f1 ,open('db2','w',encoding="utf-8")as f2:

  例一：同时打开两个文件，读取第一个文件，同时写入第二个文件，当写到10行时退出；

        with open("db1",'r',encoding="utf-8") as f1 ,open('db2','w',encoding="utf-8")as f2:

           times = 0

           for line in f1:

               times += 1

               if times <= 10:

                   f2.write(line)

               else:

                   break

 例二：当有个文件，把文件里边的aaa改成bbb

       with open("db1",'r',encoding="utf-8") as f1 ,open('db2','w',encoding="utf-8")as f2:

           for line in f1:

               new_str = line.replace('aaa','bbb')

               f2.write(new_str)