集合set
集合是无序的
作用：1.去重 eg. 把list转成set可自动去重
2.关系测试 eg. 交集、并集、差集等
举个栗子：Python班有个名字列表1，Linux班有个名字列表2，但是现在有人报了两个班，想计算出报名的总人数
——> 可用集合删除重复数据
如果不用集合，用现已知的知识
——> 创建一个空list
for循环(已有的包含重复名的list)
每一次循环元素，就扔到空列表里，但是要先判断元素是否已经在空list里存在
操作操作~~~
基本：
#define set
list_1 = [1,4,5,7,3,6,7,9]
list_1=set(list_1) #大括号，有点像字典，但是不是字典
list_2= set([2,6,0,66,22,8,4])print(list_1,list_2)#intersection交集
print(list_1.intersection(list_2))#union并集
print(list_1.union(list_2))#difference差集
print(list_1.difference(list_2)) #in list 1 but not in list 2
print(list_2.difference(list_1)) #in list 2 but not in list 1
#subset子集
print(list_1.issubset(list_2))#superset 超集
print(list_1.issuperset(list_2))
list_3= set([1,3,7])print(list_3.issubset(list_1))print(list_1.issuperset(list_3))#对称差集
print(list_1.symmetric_difference(list_2)) #互相都没的取出来了
#判断交集
list_4 = set([5,6,8,7])print(list_3.isdisjoint(list_4)) #return True if two sets have a null intersection
View Code
运算符：
#交集
print(list_1 &list_2)#并集
print(list_2 |list_1)#差集
print(list_1 - list_2) #在1中不在2#对称差价
print(list_1 ^ list_2) #互相重复的去掉，取剩下的
View Code
增删：
#增 add 集合没有insert，只有add
list_1.add(99) #add one element
list_1.update([888,777]) #add more elements
#删 remove
list_1.remove(99)#另外两个删除方法：pop & discard
list_1.pop() #remove and return an arbitrary set element
list_1.discard(999) ## remove an element from a set if it is a member, if the element is not in the set, do nothing
#判断 element x 在不在set s 里面
x ins
xnot ins#set s 的长度
len(s)
View Code
浅copy：
list_1.copy()
文件：
文件操作流程：
打开文件，得到文件句柄并赋值给一个变量
通过句柄对文件进行操作
关闭文件(用with可自动关闭文件)
操作操作~~
基本1：
#normal way
f = open("yesterday","a",encoding="utf=8")
data= f.read() #只读
print("---read----",data)
f.close()#关闭文件
#using "with": close file automatically
with open("yesterday","r",encoding = "utf-8") as f: #相当于 f = open("yesterday","r",encoding = "utf-8")
for line inf:print(line)#open multiple files
with open("o1") as obj1,\
open("o2") as obj2:
ps: windows 打开文件，默认是GBK，但是Python默认处理编码是UTF-8，但是UTF-8 不能处理GBK，所以要用UTF-8来打开文件
另外，打开文件的模式：
r ： 只读(如果不写模式，默认是r)
w ： 只写(只可写，如果文件不存在则创建，如果存在就会覆盖原内容)
a ： 追加(可读可写，如果文件不存在则创建，如果存在就追加) ps： 只能追加到最后
升级版模式：
r+ : 读写(可读可写可追加)
w+ ：写读(并没什么卵用)
a+ ： 同a
”U"表示在读取时，可以将 \r \n \r\n自动转换成 \n (与 r 或 r+ 模式同使用)
rU
r+U
处理二进制文件时：(eg.视频文件)
rb
wb
ab
二进制文件不是说文件内容变成0110001这种形式，而是文件是以二进制编码储存的
基本2：
#只读前五行
for i in range(5):print(f.readline())#假如文件内存很大，f.readlines只适合读小文件#可以读一行，但是不存在内存里,内存里只保存一行；就是循坏一行，删掉一行
count = 0 #文件不是列表了，变成了迭代器
for line inf:if count == 9:print("---------我是分割线----------")
count+= 1
continue
print(line)
count+= 1
#tell & seek
print(f.tell()) #tell是按照已读的字符来计数的
f.seek(0) #光标回到第二行,回不去，只能回到0
print(f.tell()) #return 0
f.seek(10) #从第十个字母开始
print(f.flush()) #刷新#以写的模式，打开文件，写完一行就默认写到硬盘上了，但是其实不一定；#刚写完一行，然后突然断电，这一行就可能没写进去#所以现在，每写一行，会暂时存在内存的缓存里，等缓存大小满了，就一次性刷到硬盘上，有可能会好几行一起写到硬盘
#truncate
f = open("yesterday","a",encoding="utf=8")#f.truncate() # 文件清空 在w模式下
f.seek(10) #在这里，移动不好使
f.truncate(20) #从文件开头第20个字母开始截断
View Code
文件修改：
with open("yesterday","r",encoding = "utf-8") as f,\
open("yesterday.bak","w",encoding = "utf-8") as f_new:for line inf:if "肆意的快乐" inline:
line= line.replace("肆意的快乐等我享受","肆意的快乐等alex享受")
f_new.write(line)#输入参数，再替换
importsys
with open("yesterday","r",encoding = "utf-8") as f,\
open("yesterday.bak","w",encoding = "utf-8") as f_new:
find_str= sys.argv[1]
replace_str= sys.argv[2]for line inf:if find_str inline:
line=line.replace(find_str,replace_str)
f_new.write(line)
View Code
字符编码
需知:
1.在python2默认编码是ASCII, python3里默认是unicode
2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本， 不过在文件里存的还是utf-8，因为utf8省空间
3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
转码流程：(其他转码也是通过和unicode的encode/decode来操作)
pyhton2：
如果文件头声明了#_*_coding:utf-8 _*_，就可以写中文了，然后以下代码都是utf-8的格式； 如果不声明，python在处理这段代码时按ASCII，然后会报错。
#_*_coding:utf-8 _*_
s= “你好” #你好这个字符是utf-8格式
s = u"你好” # 你好这个字符就是unicode格式
#utf-8 转成 gbk
s_to_gbk = s.decode("utf-8").encode("gbk")
python3：
默认的文件编码是utf-8,可以直接写中文，也不需要文件头声明编码了。
#utf 转 gbk
s = “你好” #变量默认是unicode编码，不是utf-8，所以转换时不用解码
print(s.encode("gbk")) #直接encode成gbk#但是print出来是没有显示中文的，因为文件编码是utf-8
改一下~~
#_*_ coding: gbk _*_#改的只是文件编码，但是python3里还是默认的unicode
s= "你好" #是个unicode，所以没有s.decode()操作
print(s.encode("gbk"))#现在print出来是gbk了，但是显示也不是中文，是因为显示的是bytes类型
函数
指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
why 函数？
减少重复代码
使程序变的可扩展
使程序变得易维护
1.定义：
#define a function 函数
def func1(): #函数名，空号内可定义参数
"""testing1""" #文档描述，强烈建议写上
print("in the func1") #函数体
return0#define a progress 过程
deffunc2():"""testing2"""
print("in the func2")#调用函数
x = func1() #x 是接收func1的返回值
y = func2() #返回none
带参数定义：
defcalc(x,y):
res= x**yreturn res #返回函数执行结果
c=calc(a,b) ＃结果赋值给c变量print(c)
嵌套式函数：
name = "Alex"
defchange_name():
name= "Alex2"
defchange_name2():
name= "Alex3"
print("第3层打印",name)
change_name2()#调用内层函数
print("第2层打印",name)
change_name()print("最外层打印",name)
View Code
2.参数：
a) 形参和实参：
b)默认参数
默认参数特点： 调用函数的时候，默认参数可有可无(非必须传递)
用途：(比如一键安装)默认安装值
IMPORTANR ! 关键参数必须放在位置参数之后 (关键参数就是默认参数，位置参数如上图xyab)
def test(x,y=2): #默认参数
print(x)print(y)
test(1) #print出来是1 2
test(1,y=3) #print出来是1 3
c) 关键参数(参照b))
d) 非固定参数
函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数
eg.1
def stu_register(name,age,*args): #*args 会把多传入的参数变成一个元组形式
print(name,age,args)
stu_register("Alex",22)#输出#Alex 22 () #后面这个()就是args,只是因为没传值,所以为空
stu_register("Jack",32,"CN","Python")#输出#Jack 32 ('CN', 'Python')
eg.2
#不传递元组，传递字典#**kwargs : 把n个关键字参数，转化成字典的方式
def test2(**kwargs):print(kwargs)
test2(name="alex",age=8,sex="F")#输出#{'name': 'alex', 'age': 8, 'sex': 'F'}
eg.3
def test3(name,age=18,*args,**kwargs): #一个位置参数，一个默认参数
#默认参数一定要放在参数组前面，参数组一定要往后放
print(name)print(age)print(args)print(kwargs)
test3("alex",age = 34, sex ="m",hobby = "tesla")#全给字典了#*args 不能接受关键字，只接受位置参数，所以是空的元组
#输出
alex34()
{'sex': 'm', 'hobby': 'tesla'}
3.局部变量
defchange_name(name):print("before change",name)
name= "Alex Li" #局部变量，只在函数里有效,这个函数就是这个变量的作用域
print("after change",name)
name= "alex"change_name(name)print(name) #还是alex， Alex 只是局部变量
#输出#before change alex#after change Alex Li#alex
View Code
4.全局变量
school = "Oldboy edu." #全局变量
defchange_name(name):
school= "Mage Linux"
print("before change",name,school)
name= "Alex Li"
print("after change",name)print(school)
name= "alex"change_name(name)print(name) #还是alex， Alex 只是局部变量
print(school)#输出#Oldboy edu.#before change alex Mage Linux#after change Alex Li#alex#Oldboy edu.
View Code
5.返回值
要想获取函数的执行结果，就可以用return语句把结果返回
注意:
函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
如果未在函数中指定return,那这个函数的返回值为None
如果return多个值，就全部会包含在元组中
retrun的值可以是个数，也可以是字符串、列表、字典等
6.递归
在函数内部，可以调用其他函数。如果调用的是本身，这个函数就是递归函数。
特点：
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，如果递归调用的次数过多，会导致栈溢出
defcalc(n):print(n)if int(n/2) >0:return calc(int(n/2))print("---->",n)
calc(10)#输入#10#5#2#1#----> 1
View Code
7.匿名函数
#这段代码
defcalc(n):return n**nprint(calc(10))#换成匿名函数
calc = lambda n:n**nprint(calc(10))#匿名函数主要是和其它函数搭配使用的
res = map(lambda x:x**2,[1,5,7,4,8])for i inres:print(i)#输出#1#25#49#16#64
View Code
8.函数式编程
"函数式编程"是一种“编程范式”(programming paradigm)，也就是如何编写程序的方法论。主要思想是把运算过程尽量写成一系列嵌套的函数调用。
9.高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
#普通函数
def add(a,b): #算一个加法
return a+b#高阶函数
defadd(a,b,f):return f(a)+f(b)
res= add(3,-6,abs) #abs 本身就是个函数 absolute
print(res)
附加~~~~~·
简易进度条：
importsys,time#一个一个蹦出来
for i in range(20):
sys.stdout.write("#")
sys.stdout.flush()
time.sleep(0.1)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
