python学习一周总结 5.12

"""

# ##列表的相关操作

#(1)列表的拼接

listvar1=[1,2,3]

listvar2=[4,5,6]

list1=listvar1+listvar2

print(list1)

#(2)列表的重复

print(list1*5)

#(3)列表的切片(同元组)

'''语法:

列表[::]完整的格式[开始索引:结束索引:间隔值]

listvar=["开心","高兴","伤心",1,2,3,4,5,[888,1000]]'''

#(1)[开始索引:]

listvar=["开心","高兴","伤心",1,2,3,4,5,[888,1000]]

print(listvar[3:])

#[:结束索引]

print(listvar[:6])

#[开始索引:结束索引]

print(listvar[3:6:])

#[:],[::]截取所有的列表

#列表的修改

listvar[1]="修改"

listvar[:3]=["修改",'切片',"去除"]

print(listvar)

listvar=[1,2,3,4,5,6,7,8]

listvar[0:7:2]=range(4)

print(listvar)

#列表的删除

del listvar[0]

print(listvar)

# ###列表的相关函数(增删改查)

#append在末尾添加元素

listvar.append("天才")

print(listvar)

#insert在索引前面添加元素

listvar.insert(1,"烦")

print(listvar)

#使用extend批量添加,后面必须接可迭代性的数据类型

listvar.extend(range(3))

print(listvar)

#删除操作,pop,删除当前索引的元素,如果没有数字,默认移除最后一个

print(listvar)

res=listvar.pop()

print(listvar)

print(res)

#remove().删除括号里的值,如果多个元素,默认删除第一个,如果没有就报错

listvar.remove("天才")

print(listvar)

#clear清空列表

listvar.clear()

print(listvar)

#index索引某个位置

'''列表.index(值,start,end)

返回值,找到返回索引,找不到报错'''

listvar=[1,2,3,4,5,6,"x",'y']

res=listvar.index("x")

print(res)

print(listvar)

#count计算列表中某个元素出现的次数

listvar=[1,2,1,3,5,1,5,1,3,5,8]

res=listvar.count(1)

print(res)

#sort列表元素从小到大排列,默认reverse=False

listvar=[0,1,5,88,6,101,99,-54]

listvar.sort(reverse=True)

print(listvar)

#reverse列表反转

listvar=[0,1,5,88,6,101,99,-54]

res=listvar.reverse()

print(listvar)

#深拷贝,浅拷贝

#浅拷贝三种

listvar=[0,1,5,88,6,101,99,-54]

listvar2=listvar.copy()

listvar.pop()

print(listvar2)

import copy

listvar=[0,1,5,88,6,101,99,-54]

listvar2=copy.copy(listvar)

listvar.pop()

print(listvar2)

print(listvar)

listvar=[0,1,5,88,6,101,99,-54]

listvar2=listvar[:]

listvar.remove(99)

print(listvar)

print(listvar2)

#深拷贝

listvar=[0,1,5,88,6,101,99,[-54,99]]

listvar2=copy.deepcopy(listvar)

listvar[-1][0]="天才"

print(listvar)

print(listvar2)

#字典相关函数(增删改查)

#(1)增

dictvar={}

dictvar[1]="天才"

dictvar[2]="白痴"

dictvar[3]="智障"

print(dictvar)

#fromkeys()使用一组键和默认值创建字典

listvar=["天才","智障"]

dictvar1={}

dic2=dictvar1.fromkeys(listvar,None)

print(dic2)

#删除 pop  返回值为对应的值  如果没有报错,可以设置返回字符以防止报错

print(dictvar)

res=dictvar.pop(8,"找不到该值")

print(dictvar)

print(res)

#删除最后一个键值对 popitem

print(dictvar)

res=dictvar.popitem()

# print(res)

# res=dictvar.popitem()

# print(res)

# res=dictvar.popitem()

# print(res)

#clear清空字典

#update()批量更新,有键就更新,没键就添加

print(dictvar)

dictvar1={1:1,3:3,4:4}

dictvar.update(dictvar1)

print(dictvar)

#查找字典, get  如果查不着返回None

res=dictvar.get(0)

print(res)

#keys将字典内所有的键组合成新的可迭代数据

print(dictvar)

res=dictvar.keys()

print(res,type(res))

#values将字典内所有的值组合成新的可迭代数据

print(dictvar)

res=dictvar.values()

print(res)

#items将字典内的键值对组合成元组,并放在一个新的可迭代数据里

res=dictvar.items()

print(res)

#  ###集合的相关操作

set1={"周杰伦","徐敬雄","刘德华"}

set2={"周润发","周星星","徐敬雄"}

#交集

res=set1.intersection(set2)

print(res)

res=set1 & set2

print(res)

#并集

res=set1.union(set2)

print(res)

res=set1 | set2

print(res)

#差集

res=set1.difference(set2)

print(res)

res=set1-set2

print(res)

#对称差集

res=set1.symmetric_difference(set2)

print(res)

res=set1^set2

print(res)

# ###add在集合中添加一个元素

set1.add("天才")

print(set1)

####pop随机删除一个元素

set1.pop()

print(set1)

# ###remove删除特定的值,如果没有报错

# set1.remove("天才")

# print(set1)

#discard 删除特定的值,如果没有不删除

set1.discard("tianc")

print(set1)

#是否是子集  issubset

print(set1.issubset(set2))

#是否是父集

print(set1.issuperset(set2))

#是否不想交isdisjoint

print(set1.isdisjoint(set2))

#update()迭代着增加

set1.update("abv")

print(set1)

# ###冰冻集合 frozenset可强转数据类型为冰冻集合

#冰冻集合一旦创建,不能进行任何修改,只能做交叉并不

strvar=(1,2,3,4)

res=frozenset(strvar)

print(res)

#声明一个空的冰冻集合

fz=frozenset

# ###文件的操作

'''

fp=open("文件名",mode="采用的模式",encoding="使用什么编码集")

fp这个变量会接受到open的返回值 是一个Io对象(文件句柄)'''

fp=open("homework.txt",mode="r+",encoding="utf-8")

print(fp.read())

fp.close

#字符串和字节流进行相互转换(参数携程转化的字符编码格式)

strvar="我是周末复习的添加"

fp=open("homework0b.txt",mode="ab+")

res=strvar.encode()

fp.write(res)

fp.seek(0)

res1=fp.read()

print(res1.decode())

#uft-8模式下 默认一个中文三个字节  unicon默认一个中文字符四个字节

#read()功能  读取字符的个数

#seek()功能  移动光标的位置

#tell()功能  计算当前光标左侧左右字节数

#把光标移动到行首

fp.seek(0)

#移动到行尾

fp.seek(0,2)

#r+可读可写,先读后写,如果先写入的话,默认会从行首进行覆盖

#w+可读可写,但每次运行都会清空原文件

#a+可读可写,写入的时候无论光标在哪,强制将光标移动到最后写入

#注意中文的情况,有可能光标能够移动,tell能够读取,但是read不行,因为有可能是光标移动到汉字的中部

#with语法,不用写fp.close

with open("homework.txt",mode="a+",encoding="utf-8") as fp:

fp.write("别别别")

fp.seek(0)

print(fp.read())

#flush  刷新缓冲区

#当文件关闭的时候自动刷新缓冲区

#当整个程序运行结束的是偶自动刷新

#当缓冲区满了自动刷新缓冲区

#手动刷新缓冲区

#(2)文件对象具有可迭代性

print("<==============================>")

with open("homework.txt",mode="a+",encoding="utf-8") as fp:

fp.write("轻轻的我走了\n,正如我轻轻的来\n,我挥一挥衣袖\n不带走一片云彩")

fp.seek(0)

for i in fp:

print(i)

#(3)文件的相关函数

#readlines() 读取一行文件内容

#readlines() 将文件的内容按照换行读取到列表中

fp.seek(0)

res=fp.readlines()

listvar=[]

for i in res:

listvar.append(i.strip())

print(listvar)

#writelines()  功能  将内容是字符串的可迭代性数据写入文件中,参数内容是字符串的可迭代性数据

#必须是可迭代的数据,同时元素必须是字符串

#truncate()把要的字符提取出来,然后清空内容重新写入,注意是字节数

# ###函数:满足一个方法,满足一个功能

#功能:包裹一部分代码,实现某个功能,达到某种目的

#特点:可以反复使用,提高代码的使用效率,便于维护管理

#函数的基本格式

def func():

pass

#函数的调用

func()

#函数的命名 同变量的命名

#驼峰命名法

#大驼峰命名法:MyWorldCase 用于类的命名

#小驼峰命名法:myWorldCase  用于函数的命名

#常用的是下划线my_func_c

#函数的定义处

# ###函数的参数

'''参数:形参+实参

形参:形式参数  在函数的定义处

实参:实际参数  在函数的调用处

形式参数:普通形参,默认形参,普通收集参数,命名关键字参数,关键字收集参数

实参:普通实参,关键字实参'''

#(1)带有参数的函数

#函数的定义处 hang lie 叫做普通形参 或者位置形参

# def star(hang,lie):

# i=0

# while i

# j=0

# while j

# print("*",end="")

# j+=1

# print()

# i+=1

def star(hang,lie):

for i in range(hang+1):

for j in range(lie+1):

print("*",end="")

print()

star(10,10)

#(2)默认形参

def star(hang,lie=2):

'''功能:打印小星星

参数:hang代表行,lie代表列

返回值:None'''

for i in range(hang+1):

for j in range(lie+1):

print("*",end="")

print()

star(10,2)

# help(star)

# print(star.__doc__)

#(3)普通形参+默认形参

#普通形参必须放在默认形参前面

#(4)关键字实参

'''

(1)如果使用了关键字实参,则顺序随意

(2)如果定义时为普通形参,但调用的时候使用了关键字实参,则这个参数后面的所有参数都必须使用

关键字实参'''

def star(hang,b,c,d,lie=2):

for i in range(hang+1):

for j in range(lie+1):

print("*",end="")

print()

star(2,3,c=10,d=7)

#默认形参与关键字实参的区别

#函数的定义处叫做默认形参

#函数逇调用出 叫做关键字实参

# ###收集参数

'''

收集参数:

普通收集参数,关键字收集参数'''

#普通收集参数

#语法: def func(*参数):

# pass

#参数前面加一个*就是普通收集参数

#专门用于收集多余的,没人要的普通实参,形成一个元组

def func(*args):

total=0

for i in args:

total+=i

print(total)

func(1,2,3,4,5,76)

#关键字收集参数

'''

语法

def func(**kwargs):

pass

参数前面加上**就是关键字收集参数

用于收集多余的关键字实参

'''

def func(a,b,c,**kwargs):

print(a,b,c)

print(kwargs)

listvar=[1,2,3]

func(*listvar,d =10,h=11,g=101)

#打印任意长度的字符

#班长:小鸡

# 班花:小鸭

# 吃瓜群众:其他

# func(monitor="小鸡",class_flower="小鸭",people1="黄熊大",people2="黄将用")

dictvar = {"monitor": "班长", "class_flower": "班花"}

def func(**kwargs):

strvar1=""

strvar2 = ""

for i in kwargs.items():

if i[0] in dictvar:

strvar1+=dictvar[i[0]]+":"+i[1]+"\n"

else:

strvar2+="吃瓜群众"+":"+i[1]+"\n"

print(strvar1)

print(strvar2)

func(monitor="小鸡",class_flower="小鸭",people1="黄熊大",people2="黄将用")

###函数的返回值

'''

return:自定义返回值  返回到函数的调用处

1,retrun 后面可以跟上六大标准数据类型,还可以跟上类函数对象,如果不写return 默认返回None

2,return如果执行了,意味着return后面的所有代码都不执行,函数中止了'''

# ###函数名的使用

'''

python特有,python中函数可以像变量一样,动态创建,销毁,当参数传递,作为返回值,叫做第一类对象'''

def func():

print(4)

func2=func

func2()

#1函数名是个特殊的变量,可以当做变量赋值

#动态销毁变量

del func2

func()

#2函数名可以作为容器类型数据的元素

def func():

print(1)

def func1():

print(2)

def func2():

print(3)

listvar=[func,func1,func2]

for i in listvar:

i()

#函数名可以作为函数

def func(a):

return a

def func():

return bin()

#doc 或 hlep查看文档

#自定义函数文档

def baotang(zhucai):

'''

功能

参数

返回值

'''

pass

# ###局部变量和全局变量

'''

局部变量:在函数内部声明的变量

全局变量:在函数外部或者在内部使用global关键字声明的变量

作用域:作用的范围

局部变量:作用域在函数内部

全局变量:作用域在整个文件'''

#(1)局部变量的获取或修改

def func():

a=1

print(a)

a=2

print(b)

#(2)全局变量获取或修改

c=10

#获取

print(c)

def func():

c=20

print(c)

print(c)

def func():

global c

c=40

print(c)

func()

#()在函数内部通过global定义全局变量

def func():

global ff

ff=990

func()

print(ff)

'''

python特有,如果存在该全局变量,利用global可以在函数内部修改全局变量

如果没有,可以利用global定义一个全局变量

一般在函数的第一行'''

# ###locals和globals

#locals获取当前作用域的所有变量

'''

locals如果在函数外,则获取打印前的所有内容

locals如果在函数内部,则获取调用前的所有内容

'''

a=10

b=20

res=locals()

c=30

print(res)

d=40

def func():

a=10

b=20

res=locals()

c=30

print(res)

d=40

func()

# ##globals 只获取全局变量(无论在函数内部还是外部都只获取全局变量)

#gloabals如果在函数外面,获取globals()打印前的所有内容

#如果在函数里面,获取globals调用前的所有内容

"""

a=10

b=20

res=globals()

c=30

print(res)

d=40

z1=50

z2=60

def func():

global c

a = 10

b = 20

res = globals()

c = 30

print(res)

d = 40

z3 = 70

z4 = 80

func()

z3=70

z4=80

def func():

a=10

b=20

res=locals()

c=30

print(res)

d=40

func()

# #gloabl动态创建局部变量

#gloabl返回的是系统的 全局命名空间的字典,在空间里面放的是全局变量

dic=globals()

print(dic,type(dic))

dic["tiancai"]='wo'

print(tiancai)

##函数的嵌套

#嵌套在外层,称为外函数

#嵌套在里层,称为内函数

def outer():

def inner():

print("我是inner函数")

inner()

outer()

'''

函数内部不可以直接在函数外部调用

调用外部函数后,内部函数不可以在函数外部调用

内部函数可以在函数内部调用

无论在函数内还是函数外,定义都在调用前'''

'''

LEGB原则

变量就近原则,先找local,再找嵌套作用域,再找global,最后再看内建作用域bultin'''

#额外注意点

#3.6版本中,如果先前局部变量存在a,删除后在获取就获取不到,如果先前不存在,默认向上查找

a=10

def func():

a=20

del a

# print(a)

func()

###nonlocal 专门用于修改局部变量

'''

自动寻找上一层空间的局部变量用于修改

如果上一级没找到,不停向上寻找

如果再找不到,直接报错

如果变量在全局,不能查找'''

#nolocal符合legb原则

def outer():

a=15

def inner():

nonlocal a

a+=3

print(a)

inner()

print(a)

outer()

print("<===========================================================>")

#nonlocal修改的是局部变量,不是全局变量

a=16

def outer():

a=10

def inner():

nonlocal a

a=7

def smaller():

nonlocal a

a=5

print(a)

smaller()

print(a)

print(a)

inner()

outer()

#(3)不适用nonlocal修改局部变量

def outer():

listvar=[1,2,3,4,5]

def smaller():

listvar[2]+=5

smaller()

print(listvar)

outer()

#闭包函数:

'''内函数使用了外函数的变量,且外函数将内函数返回出来的过程叫做闭包

这个内函数叫做闭包函数'''

#(1)基本语法

def outer():

a=5

b=6

def inner():

print(a,b)

return inner

res=outer()

print(res)

res()

#获取闭包函数使用的变量  __closure__ cell_contents

typ=res.__closure__

print(typ)

res1=typ[0].cell_contents

print(res1)

#闭包的特点

'''内函数使用了外函数的局部变量,外函数的局部变量和内函数发生了绑定,延长了变量的生命周期'''

def fam():

a="xjx"

b="yx"

money=2000

def a_kai():

nonlocal money

money+=1000

print("还剩余%d"%(money))

def b_kai():

nonlocal money

money-=500

print("还剩余%d"%(money))

return a_kai

res=fam()

tup=res.__closure__

print(tup)

asw=tup[0].cell_contents

print(asw)

#闭包的意义

'''闭包可以优先使用外函数的变量,并对闭包的值起到了封装保护的作用,外部无法访问'''

def click_num():

num=0

def func():

nonlocal num

num+=1

print(num)

return func

click_num = click_num()

click_num()

click_num()

# ##匿名函数

'''用一句话来表达只有返回值的函数,叫做匿名函数

语法:

lambda 参数:返回值'''

#不带有参数的lambda表达式

func=lambda :"哈哈哈哈"

print(func())

#带有参数的lambda表达式

func=lambda n:n*3

print(func(10))

#带有条件分支的lambda表达式

'''

三目运算符:

语法:

真值 if 表达式 else 假值

如果条件为真,返回真值

如果条件是假,返回假值'''

res= 10 if 5>3 else 9

print(res)

func=lambda n:n if n%2==1 else "滚"

print(func(10))

# ###迭代器

'''能够被next调用,且不断返回下一个值的对象,叫做迭代器

迭代器的特征:惰性序列,通过计算把值依次返回,一遍循环一遍计算,而不是一次性获得

优先:需要数据的时候,一个一个提取,节约空间

总结:

惰性序列,节约空间

使用next提取,方向不可逆

迭代器可以存储无限大的数据'''

#可迭代对象 iter

strvar="开心高兴每一天"

print("__iter__" in dir(strvar))

print("__next__" in dir(strvar))

# it=iter(strvar)

# print("__iter__" in dir(it))

# print("__iter__" in dir(it))

it=strvar.__iter__()

print("__iter__" in dir(it))

print("__iter__" in dir(it))

for i in it:

print(i)

# next(it)

# 如果调用时,超出了正常的数据范围,会越界报错

#判断是否是迭代器

from collections import Iterable,Iterator

print(isinstance(it,Iterable))

print(isinstance(it,Iterator))

# 高阶函数  能够把函数当做参数传递就是高阶函数

#map

'''map(func,iterable)

功能:把iterable中的数据一个一个拿出来放到func函数中进行处理

最后把处理结果返回给迭代器'''

# 1. ["1","2","3","4"]  => [1,2,3,4]

listvar= ["1","2","3","4"]

res=map(int,listvar)

print(list(res))

#(2)#2,[1,2,3,4,5]  => [1,4,9,16,25]

listvar=[1,2,3,4,5]

def func(n):

return n**2

res=map(func,listvar)

print(list(res))

# 3.  {"c","a","b"} => [99,97,98]

def func(n):

dictvar={97: "a", 98: "b", 99: 'c', 100: 'd', 101: "e"}

dict1={}

for x,y in dictvar.items():

dict1[y]=x

return dict1[n]

dict2=["c","a","b"]

res=map(func,dict2)

print(list(res))

# ###reduec

'''reduce(func,iterable)

功能:计算

先把iterable中的前两个数据拿出来,扔到func中进行计算,再把计算结果和iterable中的第三个

数据拿出来,扔到func中进行计算,直到iterable的数据全部拿出来位置'''

# [5,4,8,8] => 5488

listvar=[5,4,8,8]

def func(x,y):

return x*10+y

from functools import reduce

print(reduce(func,listvar))

##"987" => 987 (不让使用int类型强转)

def func(n):

dic={"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}

return dic[n]

res=map(func,"789")

def func2(x,y):

return x*10+y

print(reduce(func2,res))

# ###sorted

'''功能:排序

sorted(iterable,reverse,key=func)

revers=False从小到大排序

返回值:排序后的结果'''

#(1)从小到大的排序

listvar = [-99,13,24,0]

res=sorted(listvar)

print(res)

#(2)从大到小的排序

res=sorted(listvar,reverse=True)

print(res)

#(3)利用内置函数进行排序

res=sorted(listvar,key=abs)

print(res)

#(4)使用自定义函数进行排序

def func(n):

return n%11

listvar = [91,23,44,19]

res=sorted(listvar,key=func)

print(res)

'''sort和sorted的用法一样,只是sort在原函数上改,sorted重新产生新的副本,新的数据'''

# ###filter

'''

filter(func,iterable)

功能:过滤

如果func中,return True 保留数据,False 舍弃数据

返回值:迭代器'''

#保留奇数,不要偶数

def func(n):

if n%2==1:

return True

else:

return False

listvar=[1,22,34,213,45]

res=filter(func,listvar)

print(list(res))

#简写

func=lambda n:True if n%2==1 else False

res=filter(func,listvar)

print(list(res))

#递归函数:有去有回是递归

#(1)最简单的递归函数

def digui(n):

print(n)

if n>0:

digui(n-1)

print(n)

digui(5)

#栈帧空间,负责运行函数而开辟的空间

#1,递归函数整体过程:调用一层函数就是开辟一层栈帧空间,结束一层函数,就是释放一层栈帧空间

#递归函数实际上就是一个调用和释放栈帧空间的过程

#递归函数回的过程:如果函数走到最后一层结束了,要回到上一层空间函数调用处,继续向下执行,直到所有代码执行完毕

#递归函数要注意加中止条件,否则会发生内存溢出,最多1000ceng,998报错,在大的阶层上最多6层

#(1)计算任意数N的阶层

'''

递归函数通过两个条件触发回的过程

(1)当函数彻底执行完毕的时候,触发回的过程,回到上一层函数调用出

(2)当函数遇到return返回值时,触发回的过程'''

def func(n):

if n<=1:

return 1

else:

return n*func(n-1)

print(func(10))

#(2)尾递归:只返回递归函数本身且非表达式(没有运算符)

'''

只开辟一个栈帧空间完成递归函数(因为最终的返回值就是第一层空间的返回值,故只需要一层栈帧空间)

cpython不支持,但如果支持,推荐使用'''

def func(n,val)

if n<1:

return val

return func(n-1,n*val)

def func1(n):

return func(n,1)

#外壳函数,帮助用户输入

#(3)斐波那契数列

# 1,1,2,3,5,8,13,21,34,55

def fib(n):

if n==1 or n==2:

return 1

return fib(n-1)+fib(n-2)

print(fib(5))