python 基础 day3

一、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()是输出后光标在行末不会换行，下次写会接着这行写