短词用法

.deepcopy（）深copy

continuet          跳过再继续下一个

.strip()              去掉字符串左右两边的空格 

.lstrip（）         只去掉前面空格

.rstrip（）         只去掉后面空格和符号 

.split()                切分，例如split(:,2)就是以：为切分 分割2次

.split(':',1)           正向以：为段落切成列表 不写默认以空格为切割符

.rsplit（）           反向以：为段落切成字符

lower（）           全小写

upper（）           全大写

.startswith（）    判断是不是以、、、、、为开头

.endswith（）      判断是不是以、、、、、为结尾

.format（）          可以将变量插入到字符串中

.join                      把列表拼成字符串

.replace()             将指定字符串改成指定字符串   例如：xx.replace('y','Y',1)把第一个y改成Y 1的地方可以不指定

.isdigit()               判断字符串是否由全数字组成

len(L)//2              找中间值（除以2）

 

列表：

insert(0,'aaa')      在[0]的位置插入值aaa

.append()            入队  追加在末尾

.pop()                 出队 删除 默认删最后一个也可指定某一个  例如 .pop[0]

.remove()           指定删除（）内的内容

.count()              查找（）内的值出现的次数

.index()              ()内的值出现在第几位        

.clear()                清空

.reverse()           倒叙

.sort                   升序，列表内同类型进行排序 默认从小到大

.extend()           加列表

.clear()             清空元素

.sort(reverse=True)    从大到小设置为降序

队列：先进先出FIFO

堆栈：后进先出LIFO

.sort()  按照从小到大排序

sorted()排序

 

集合set 无顺序 必须为不可变类型 没有重复

取交集：&或者.intersection()

取并集：l或者.union()

取差集：——或者.difference()

对称差集即各自独有的：^或者.symmetric

父子集：>或者.xx.issubset(xxx)、<、=

 

len()            长度

.discard()    丢弃 元素不存在就什么都不做

.remove()    去除元素 不存在则报错

.update()     更新、改变、增加

.pop()          删除

.add()          增加

.insert()       按照索引插入一个元素

 

元组tuple 用（）特点：不可改、只读、不可添加、只有一个值的话要加逗号，例如：t=(1,)

 

字典dict：k值不可变且不能重复  {key:valuses}

.clear         清空字典

.update()   更新老字典内  没有就加进去 有的就更新

.setdefault() 有则不动  没有就加

.get()         不报错 返回none 容错性好

 

 编码解码：

内存固定使用的是 unicode

可以改变的是存入硬盘的采用格式：英+汉——>unicode——>gbk

                                                         英+日——>unicode——>shift—jis

                                                         万国字符——>unicode——>utf-8

文件取乱：文件以xx格式存 就以xx格式读入内存

文件存乱：编码格式应该设置成支持文件内字符串的格式

python3默认utf-8     python2默认ASCII

Linux                系统没有指定encoding的编码就默认 ——> utf-8

windows gbk    系统没有指定encoding的编码就默认 ——>gbk

指定文件头默认的编码：再文件首行写：#coding:文件存入硬盘时的编码格式

.encode()      编码 括号里写格式

.decode()     解码 括号里写格式

 

文件  with open()

用于应用程序操作硬盘 永久保存数据   或者从硬盘读数据

\n是换行符 如果遇到地址中含有\的话在地址前加r或者把\换成/即可

 res=f.read()    发读请求

f.close()          关闭文件

.read()             读前面的

.write()             写进去

with自动删除操作系统打开的此文件

with open('a.txt',mode='rt',encoding='utf-8')as f:

 

文本 t

r只读 文件不存在不会报错 存在时指针跳到最开始的位置 有局限性内容不能过多

r+ 文件必须存在否则报错 写的话追加在文件内容末尾

rb以二进制方式读取文件该文件必须已经存在

w只写 关键性文件不要用此打开 文件不存在会创建 存在会清空 不是覆盖是清空

wb以二进制方式打开，只能写不存在文件则创建  文件存在则删除

a可读可写 文件存在指针调到最末尾 文件不存在则创建

例题：

src_file=input('原文件路径》：').strip()

dst_file=input('新文件路径》：').strip()

with open(r'{}',format(src_file),mode='rt',encoding='utf-8')as f\open('r{}',format(dst_file)):

res=f.read

f1.write(res)

 

函数  def  func():

 

函数对象：可以把函数当成变量去用

 

ATM银行案例：

func dic={

'1':login,    #登录

'2':transfer,   #转账

'3':check_balance    #查询余额

}

def login():

　　print('登录成功')

def transfer():

　　print('转账功能')

def check_banlance():

　　print('查询余额')

while Ture:

　　print("""

　　0   退出

　　1   登录

　　2   转账

　　3   查询余额

""")

choice=input("请输入命令编号：").strip()

if not choice.isdigit():

　　print('必须输入编号数字')

　　contiue

if choice=='0':

　　break

 

 

def max2(x,y):

　　if x>y:

　　　　retuen x

　　else:

　　　　return y

 

例题：比较a,b,c,d 

def max4(a,b,c,d):

　　res1=max2(a,b)

　　res2=max2(res1,c)　　

　　res3=(res2,d)

　　return res3

res=max4(a,b,c,d)

print(res)

 

例题：圆形周长面积

def circle():   #先放容器 圆

　　def circle(redius,action=0): #圆    半径

　　　　from math import pi  #数  

　　def preimter(radius):      #周长

　　　　return 2*pi*radius  #周长格式

　　def area(radius):  #面积

　　　　return pi*(radius**2)#面积格式

　　if action==0:

　　　　return 2*pi*radius

　　elif action==1:

　　　　return area(radius)

circle(33,action=0)

 

嵌套一层试炼：

def circle():

　　def circle(redius,action=0):

　　　　from math import pi

　　　　preimter=2*pi*radius

　　　　area=radius**2

　　　　if action==0:

　　　　　　return 2*pi*radius

　　　　elif action==1:

　　　　　　return area(radius)

circle(33,action=0)

 

传参方案一：

def get(url):  # 函数的v值或者requests发起请求的地址       url:资源定位符用于定位互联网上某个资源的网址

　　response:requests.get(url)   #浏览器发送信息给该网址所在的浏览器这个过程     requests.get（）获取网页 对应HTTP的GET方法

　　print(len(response,text)

get('htts://www.baidu.com')

get(htts://www.cnblogs.com/名字)

get('htts://www.zhuanlan.zhihu.com/p ')

 

传参方案二：

def  outter(url):

　　def get():

　　　　response=requests.get(url) 

　　　　print(len(response.text))

　　return get

baidu=outter('htts://www.baidu.com') #outter 修改

baidu()

cnblogs=outter(htts://www.cnblogs.com/名字)

coblogs()

zhihu=ouuter('htts://www.zhuanlan.zhihu.com/p ')

zhihu()

 

 

装饰器：定义一个函数 该函数是用来为其他函数添加额外的功能  拓展功能开放  对修改源代码是关闭的

 

写模板：

def outter(func):   

　　def wrapper(*args,**kwargs)  :#1.调用原函数  2.为其增加新功能

　　　　res=func(*args,**kwargs)

　　　　return res

　　return wrapper      #wrapper 装饰器

用：

def outter(func):   

　　@wraps(func)

　　def wrapper(*args,**kwargs)  :

 

 

time.sleep(3) 让睡三秒

help()  查看这个函数的帮助信息

__doc__    看文档注释

__name__  看函数名

例题：   不懂

print(index._name__)

print(index._doc__)

from func(tools import wraps)   #用来将原函数func的属性赋值给wrapper函数 包含__doc__、__name__等

 

有参装饰器：

模板：

def 有参装饰器(x,y,z):　　

　　def outter(func):

　　　　def wrapper(*args,**kwargs) :

　　　　　　res=func((*args,**kwargs)

　　　　　　return res

　　　　return wrapper

　　return outter

@有参装饰器(1,y=2,z=3)

def 被装饰器对象():

　　pass

 

 

迭代器  

 

 

迭代器对象通常包含两个方法：__iter__() 和 __next__()。

__iter__() 方法返回迭代器对象本身，而 __next__() 方法返回下一个元素。

当 __next__() 方法被调用时，如果容器中还有下一个元素，

则返回该元素并更新迭代器指向下一个元素；如果容器已经没有下一个元素，则抛出 StopIteration 异常。

可迭代对象：但凡内置有__iter__方法的都称之为  可迭代的对象

可迭代对象有：字符串、列表、元组、字典、集合、文件对象

 

迭代器对象.__next__():得到迭代器的下一个值   ：文件对象

调用可迭代对象下的__iter__方法会将其转换成   迭代器对象

迭代器对象.__iter__:得到迭代器本身 调了跟没调一个样子

 

①d.__iter__()得到一个迭代器对象

②迭代器对象.__next__()拿到一个返回值 然后将该返回值赋值给K

③循环步骤② 直到抛出来异常for循环会捕捉异常然后结束循环

 

d={'a':1,'b':2,'c':3}

d_iterator=d.__iter__()

print(d_iterator)

print(d_iterator.__next__())

print(d_iterator.__next__())

print(d_iterator.__next__())------>结果:a,b,c

最后再加的话会抛出异常  atopiteration 

若想把异常停止或不报异常：

while True:

　　try:<----加个这个

　　　　print(d_iterator__next__())

　　except stopiteration:

　　　　break#结束中止

再一个迭代器取值取干净的情况下 再对其取值取不到

 

                                                         

生成器：自定义的迭代器

如何得到自定义的迭代器：

在函数内一旦存在yirld关键字，调用函数并不会执行，函数体代码会返回一个生成器对象

yirld可以一次返回一个值，2次返回2值，可以将函数暂定住

　　def func():

　　　　print('第一次')

　　　　yirld 1

　　　　print('第二次')

　　　　yield 2

 

叠加装饰器：

@deco1

@deco2

@deco3

运行顺序从上到下  加载顺序从下到上

最上面一个运行中  调用第二个函数 第二个函数运行调用第三个函数

第三个才是调用原函数 再返回第三个返回第二个返回第一个结束

 

g.send()     #为yield赋值 

 next(g)等同于 .send(none)

传值之前必须写：g.send(none) 先准备一下

g.close()   关闭传值一旦关闭无法传值不然会报错

例如：

def  dog(name):

　　print('猪猪%s吃东西'%name)

　　while True:

　　　　x=yield none

　　　　print('道哥%s吃了%(name,x)')

g=dog('齐老师')

g.send(none)  #要先写个这个准备一下

g.send('一根鸭脖')

 

结果：猪猪齐老师吃东西

猪猪齐老师吃了一根鸭脖

yield有两种功能：①控制返回值②可以接受send过来的值，然后给一个变量

 

 

三元表达式格式：

res=值1  if   条件  else 值2

例如：x=1   y=2

res=1111   if  x=y   else   2222

print(res)

 

生成式：列表生成式、字典生成式、集合生成式、生成表达式

 

生成器不是一次给值 此时g内部一个值都没有 需要next一次运行一次 for循环

列表生成式：i=[表达式 for x in 可迭代对象  ]   if 条件

                     g=(表达式 for x in 可迭代对象 if 条件)  next g

例题：L=['a_bb','b_bb','c_bb']

用列表格式显示含有bb 的值

new_L=[name for name  in L ]

　　if  nem.endswith('bb')

把小写变成大写：

new_L=[name.upper()  for name  in L ]

把所有名字去掉后缀——bb

new_L=[neme.replace('_bb','') for neme  in L ]

 

字典生成式例题：

keys=['name','age','gender']

dic={key:none  for   key in keys}

例题2：求不要最后一个

items=[('name','egon'),('age',18),('gender','male')]

res={k:v for k,v in items if k!='gender'}

 

集合生成式：

keys=['name','age','gender']

set1={key for key in keys}

print(set1,typs(set1))

 

生成表达式：

g=(i for i in rang()10)

if i>3

print(next(g))

生成器不是一次给值 此时g内部一个值都没有 需要next一次运行一次 for循环

 

函数递归 是一种函数嵌套循环

调用的特殊形式，具体是指，再调用一个函数的过程中 直接或间接的调用到函数本身，

递归调用不应该无限地调用下去，必须在满足某种条件下结束递归调用

def f1(n)

　　if n==10:

　　　　return

　　print(n)

　　n+=1

　　f1(n)

f1(0)

递归的2个阶段：

回溯：一层一层调用下去

递推：满足某种结束条件，结束递归调用，然后一层一层返回

例题：L=[1,[2,[3,4]5],6]

取出数字

def  f1(list1):

　　for x in list1:

　　　　if type(x) is list:

　　　　　　f1(x)

　　　　else:

　　　　　　print(x)

 

有名函数 匿名函数

 有名函数：

def func(x,y):   #def后必须有函数名

　　return x+y

 匿名函数：

lambda x,y:x+y   #后面不写函数但是需要写值 要写到一行

默认带一个return合到一起功能 接收x和y 然后函数体代码运行

x+y将结果当作返回值返回

 

max、min、匿名函数lambda应用

max会迭代出来一个最大的值

题目：salaries={

'sirg':3000

'tan':7000

'lili':10000

'jack':2000

}

找出薪资最高的人：

res=max(salaries,key=lambda  k:salaries[k])

print(res)

找出薪资最低的人：

res=min(salaries,key=lambda k:salaeies[k])

 

sorted()排序：会迭代字典 取出一个值 没有说明按照什么排序就会从左到右从小到大 例如：

salaries={

'siry':3000

'tan':7000

'lili':10000

'jack':2000

}

res=sorted(salaries,key=lanbda k:salaries[k])

print(res)

 

 

 

 模块是一系列功能的集合体，分为3类：①内置②第三方的模块③自定义：一个python文件本身就是一个模块，文件名用m.py模块叫m

模块的4种形式：①使用python编写的.py文件

②已被编译为共享库或DLL的c或者c++扩展

③把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py的文件，该文件称之为包）

④使用c语言编写的并链接到python解释器的内置模块

导入模块：import  foo#导入某某模块

若模块名字较长可以用import、、、、as、、、、

例如：import  foooooooooooo as f

 f.get() 这样去调用

Python文件有2种用途：一是当作程序运行，二是被当做模块导入

从文件导入模块：from、、、、import、、、、、

from foo improt  x

从文件导入模块也发生了三件事情：产生一个模块的名称空间。运行foo.py将运行过程中产生的名字，都丢到模块的名称空间去。

再当前名称空间拿到一个名字，该名字与模块名称空间的某一个内存地址

 

查找模块的优先级：

无论是import还是from、、、improt、、、、、在导入模块时都涉及查找问题：

优先级：内存（内置模块）、从硬盘找（按照sys.path环境变量中放的文件的顺序依次查找要导入的模块==>print(sys.path)）

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

)