一、set 集合
特点：无序、不重复、可嵌套。
1、创建集合的三种方式：
s = set() s1 = set{11,22,} s2 = set([11,22,33])
2、操作集合
注意： 创建空集必须用 set()，如用｛｝是创建字典。 s = set("qweiwt") #把str中的字符拆解开,形成set.特别注意观察有两个w，但集合是不能重复的 print(s) {'t', 'i', 'e', 'q', 'w'} s.add("f") ＃添加set元素,重复的不添加 print(s) {'t', 'i', 'f', 'e', 'q', 'w'} s.remove("q") ＃如果删除的元素没有就报错 print(s) {'t', 'i', 'e', 'w'} s.discard("a") #如果是set中的元素,就删除,如果不是,就什么也不做,常用这个。 print(s) {'e', 'w', 't', 'i'} s.clear() #清除所有元素 print(s) set() ret = s.pop() # 随机移除 print(ret) t a ={11,12,33,} b = s.copy() #浅拷贝 print(b) {33, 11, 22} s1 = {11,22,33,} s2 = {22,33,44,} #提取A中存在B不存在的集合 s3 = s1.difference(s2) #s1中存在s2中不存在 print(s3) {11} #A和B中都不存在的集合 s3 = s1.symmetric_difference(s2) print(s3) {11, 44} #s1中存在s2中不存在的元素覆盖到s1里 s1.difference_update(s2) print(s1) {11} ＃取交集 s3 = s1.intersection(s2) print(s3) {33, 22} ＃取并集 s3 = s1.union(s2) print(s3) {33, 22, 11, 44} #返回到集合中增加了s2中的元素的s1集合 s1 = {11,22,33,} s2 = {22,33,44,} s1.update(s2) #s1 {33, 22, 11, 44} #可以接受被for循环的对象 可迭代的对象 s1 = {11,22,33,} list = [55,66,] s1.update(list) print(s1) {33, 66, 11, 22, 55}
＃集合支持一系列标准操作，包括并集、交集、差集和对称差集，例如： a = t | s # t 和 s的并集 b = t & s # t 和 s的交集 c = t – s # 求差集（项在t中，但不在s中） d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中） len(s) set 的长度 x in s 测试 x 是否是 s 的成员 x not in s 测试 x 是否不是 s 的成员 s.issubset(t) s <= t 测试是否 s 中的每一个元素都在 t 中 s.issuperset(t) s >= t 测试是否 t 中的每一个元素都在 s 中 s.union(t) s | t 返回一个新的 set 包含 s 和 t 中的每一个元素 s.intersection(t) s & t 返回一个新的 set 包含 s 和 t 中的公共元素 s.difference(t) s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素 s.symmetric_difference(t) s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素
s3 = [11,22,33,22,] b = set(s3) print(b) print (type(b)) for i in b: c.append(i) print(c,type(c)) ＃打印结果 {33, 11, 22} <class 'set'> [33, 11, 22] <class 'list'>
二、函数
作用：封装功能
定义函数：
def f1()： # f1是函数名字 pass
1、def关键字，创建函数
2、函数名 （根据函数名找函数）
3、()
4、函数体
5、返回值
注意：函数里有return 赋值给函数 接收值,在函数中，一旦执行return，函数执行过程立即终止。
参数：
1、普通参数 （严格按照顺序，将实际参数赋值给形式参数）
def sendmail(name): #name 是形参 ret = sendmail("QL") #QL 是实际参数
2、默认参数 （必须放在参数列表的最后）
def funcC(a, b=0): # 默认参数必须放到参数列表的最后 print a print b #在函数funcC的定义中，参数b有默认值，是一个可选参数，如果我们调用funcC(100)，b会自动赋值为0
3、指定参数 （将实际参数赋值给形式参数）
def sendmail(name,content) print(name,content) sendmail(content="OK"，name="alex")
4、动态参数
* 默认将传入的参数，全部放置在元组中，f1(*[11,22,33,])
def f1(*args): print(args,type(args)) #args是元组 f1(1, 2, 3) #结果 (1, 2, 3) <class 'tuple'> li = [11,22,33,] f1(li) #整个列表将作为元组里的一个元素 #结果 ([11, 22, 33],) <class 'tuple'> f1(*li) #如果带*，列表里的元素将变成元组的元素 #结果 (11, 22, 33) <class 'tuple'>
** 默认将传入的参数，全部放置在字典中 f1(**{"k1":v1，})
def f1(**args): #传字典 print(args,type(args)) f1(n1="alex",n2=18) #结果 {'n1': 'alex', 'n2': 18} <class 'dict'> #**适用于format格式 s1 ="i am {0}，age {1}".format("alex",18) s = "i am {0},age {1}".format(*["alex",18]) s2 = "i am {name},age {age}".format(name="alex",age="18") dic = {"name":alex,"age":18} s = "i am {name},age {age}".format(**dic) #**就可带入
5、万能参数 （*args,**kwargs）
def f1(*args,**kwargs): #一个*在前面，两个**在后面，顺序不能颠倒 print(args) pirnt(kwargs)
补充:
#f1 先把a1+a1存到内存中，往下走，再把a1*a2存到内存中，a1+a2被覆盖，8,8赋值，f1会执行a1*a2 def f1(a1,a2): return a1 + a2 def f1(a1,a2): return a1*a2 ret = f1(8,8) print(ret) #结果 64 ###################### def f1(a1): a1.append(999) li = [11,22,33] f1(li) #传递参数传递的是引用的li ，不是复制的 print(li) [11,22,33,999] ###################### def f1(): print(123) return "111" print(456) #456将不会执行，在函数中一旦执行return，函数执行过程立即终止 ###################### #全局变量，在所有的作用域里都可读 全局变量都要大写 #对全局变量进行重新赋值，需要global 必须放在函数里的最前面 #特殊：列表字典可修改，不可重新赋值 NAME = "alex" def f1(): global NAME #表示，name是全局变量 NAME ="123" ##只能在自己的作用域调用 不能用在其他函数，优先用自己的变量 print(name)#没有定义global打印出来的是123，对其他函数还是全局变量定义的 NAME.append(999)#对于列表字典可以添加值，但是不能赋值 def f2(): pring(name) #可以调用全局变量，也可以调用自己的局部变量
三、三元运算（三目运算）
###三元运算，三目运算 （写简单的if else） if 1 == 1: name = "QL" else: name = "peter" name = "QL" if 1 == 1 else "peter" #三元运算
四、lambda函数
###lambda表达式 def f1(a1,a2): return a1 +a2+ 100 #只能写一行 f2 = lambda a1,a2=10:a1 +a2+100 # 第一个a1是上面的参数，return隐藏了 ret = f1(10) print(ret) r2 = f2(9)
五、内置函数
abs() 绝对值 n = abs(-1) all()#所有为真才为真 n = all([1,2,3,4]) print(n) # True n = all((0,1,2,)) print(n) #False any()#只要有真就为真 n1 = any([0,None,[],2,]) print(bool(0)) #False 的值 0,none," ",[],(),{} ascii() #自动执行对象的_repr_ 方法 bin() #十进制转二进制 print(bin(5)) 0b oct() #s十进制转八进制 print(oct(9)) 0o hex() #十进制转十六进制 print(hex(0) 0x #utf-8 一个汉字： 三个字节 #gbk 一个汉字： 二个字节 #字符串转换字节类型 bytes(要转换的字符串，按照什么编码) s = "李杰" n = bytes(s,encoding="utf-8") print(n) b'\xe6\x9d\x8e\xe6\x9d\xb0' n = bytes(s,encoding="gbk") print(n) b'\xc0\xee\xbd\xdc'
六、文件操作
#打开文件 f = open("db","a") #追加 f = open("db",'r') #只读 f = open("db",'w') #只写（先清空原文件） f = open("bs",'x') #python3.x 有的功能，如果文件存在，报错，不存在，创建并写内容 #假设 db.txt已经存在 f = open("db",'r',encoding="utf-8") data = f.read() print(data, type(data))#字符串，硬盘底层已二进制保存，Python自动转换成字符串 QL|123 <class 'str'> f = open("db",'rb') #直接读二进制 读字节 #操作文件 f.seek(1)# 指针 在第一个字符后覆盖 按字节的方式找位置 如果是中文，一个汉字的一个字节，会出现乱码 f.write("888") #r+ 读写【可读可写】 #w+ 写读【可读可写】 #x+ 写读【可读可写】 #a+ 写读【可读可写】 #一般用r+(可以指定位置) 不用a+(只在最后追加) w+ (先清空后写入)用的少 ###b,表示以字节的方式操作 rb 或 r+b wb 或 w+b xb 或 x+b ab 或 a+b f = open("db",'ab') #用字节写入 f.write(bytes("hello",encoding='utf-8')) #如果直接写入不转utf8会报错 #注：以b的方式打开，读到的内容是字节，写入时也需要提供字节类型。 #read() #无参数，读全部；有参数有b 按字节 无b 按字符 #tell() 获取当前指针位置（） #seek()指针跳到指定位置（） #write() 写数据，b,字节，无b字符 #fileno() #文件的数字表达方式 文件描述符 #flush() #强刷 #readble() #判断文件是否可读writeable 可写 #readline #仅读取一行 #truncate 截段 #for循环文件对象 f = open() f.open() for line in f: print(line) ####关闭文件 关闭文件 1、f.close() 2、with open("xx") as f: with open('db1') as f1,open("db2") as f2: #我们谈到“文本处理”时，我们通常是指处理的内容。Python 将文本文件的内容读入可以操作的字符串变量非常容易。文件对象提供了三个“读”方法： .read()、.readline() 和 .readlines()。每种方法可以接受一个变量以限制每次读取的数据量，但它们通常不使用变量。 .read() 每次读取整个文件，它通常用于将文件内容放到一个字符串变量中。然而 .read() 生成文件内容最直接的字符串表示，但对于连续的面向行的处理，它却是不必要的，并且如果文件大于可用内存，则不可能实现这种处理。 .readline() 和 .readlines() 非常相似。它们都在类似于以下的结构中使用： Python .readlines() 示例 fh = open( 'c:\\autoexec.bat') for line in fh.readlines(): print line.readline() 和 .readlines()之间的差异是后者一次读取整个文件，象 .read()一样。.readlines()自动将文件内容分析成一个行的列表，该列表可以由 Python 的 for... in ... 结构进行处理。另一方面，.readline()每次只读取一行，通常比 .readlines()慢得多。仅当没有足够内存可以一次读取整个文件时，才应该使用.readline()。 写： writeline()是输出后换行，下次写会在下一行写。write()是输出后光标在行末不会换行，下次写会接着这行写