python day three

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

第二种：

li = [11,22,33]

s2 = set(li)

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

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 #批量添加元素，接收一个可迭代的对象，例如：列表、元祖、字符串

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‘}

2.函数名

3.写个（）

4.函数体（具体内容）

5.返回值

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

例如：

def aa():

函数体

def aa():

try :

函数体

except:

return False #失败返回False

else:

return True #成功返回True

注意：

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

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

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

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

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

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）

功能：实现格式化输出方法(同万能参数功能,都是通过*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

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]

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

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

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

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

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

例如：

常规的写法：

if 1 == 1:

name = ‘aaa‘

else:

name = ‘bbb‘

三元运算写法：

name = ‘aaa‘ if 1 == 1 else ‘bbb‘

例如：

def f1(a):

return a+100

lambda写法：

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

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() #把字符串转成字节类型，放到一个列表里。

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)