python程序执行完后重头开始做烧饼_Long Way To Go 之 Python 3

集合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)

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值