break:while循环break是用于永久终止循环。即不执行本次循环中break后面的语句,直接跳出循环。
切片中： find ， rfind，index , rindex
find , index : index找不到会报错 find 返回-1
find，rfind ：find从左到右 ，rfind 右侧查找
s[start:end:step]
判断 ：startswith ，endswith ，isalpha ，isdigit ,isalnum,isspace，isupper,islower,
s.startswith(' '): 判断是否以此开头 true or false
s.isalpha():纯字母判断
s.isalnum():是否字母数字组合
s.isspace():纯空格 一定要有空格
替换：replace（old，new，count）默认全部替换，通过count指定次数，多个情况 正则表达式 for循环用处：违规词汇
s.replace('目标字符串','替换字符串',1):替换一个目标字符串
切割字符串：split（‘分隔符’，maxsplit），rsplit 从右 ，splitlines（），
s.split(' ') :遇到空格切一刀 ，返回一个列表
s.splitlines（）：按行切割,不用分隔符
s.title（）:每个单词首字母都大写
s.upper()
s.lower()
s.capitalize() :一句话的首字母大写
空格处理：strip（），lstrip()只去掉左侧空格 ,rstrip() 删除空格
ljust,rjust,center 添加空格控制字符串的对齐方式
拼接 ：join（列表拼接） ['','','',''].join
s.strip()：去除左右两侧空格
s.center(30) :在30个字符串正中央位置
s.ljust(30):左对齐
s.rjust(30):右对齐
格式化 ：format
'美女{}今年{}岁'.format(name,age)
'美女{0}今年{1}岁,我也是{1}岁'.format(name,age) ：使用数字填充，从0计数
'美女{name}今年{age}岁,我也是{age}岁'.format(name='z',age=19):变量名的形式，format的参数必须是关键字参数
列表拼接：append,extend
- append()添加的时候会把添加的数据当成一个整体进行添加，允许添加任意类型的数据
- extend()添加的时候会把添加的数据迭代进行添加，只允许添加可迭代对象数据
-
删除：pop remove clear
pop(index) 或者 pop():从后往前删除一个
remove('value'):只删除从做左到右第一个元素
删除多个元素：
n=0
while n<len(list1):
if list1[n]=='酸奶':
list1.remove('酸奶')
else:
n+=1n只有不删除动作的时候往后移，删除之后同一下标内容会变化，所以删除时让n不动
第二种做法 将不是1的内容添加到空列表中，不使用删除做法
elem=1
result=[]
for i in li:
if i!=elem:
result.append(i)
li=result
print(li)
第三种做法倒着删除，就不会出错
for i in li[::-1]:
if i =='suannai':
li.remove(i)
s.clear():清空所有元素,空列表
修改：insert插入，不完全修改，类似添加
s.insert(index位置,对象元素）
查找：s.count(元素):返回这个元素出现个数
del list[index] 与pop一样
del list :会直接删除list变量，删除的是变量不是内容 第44节课
交叉赋值：a,b=b,a
冒泡排序：sort 功能
for j range(0,len(nums)-1):
for i range(0,len(nums)-1-j: #选最大的放在最后
if nums[i] > nums[i+1]: #两两比较
a=nums[i]
nums[i]=nums[i+1]
nums[i+1]=a元组：（‘aa’,）一定加逗号，不然就是字符串 ，不能增删改 ，能查
s.index('a',startindex,endindex) :从开始坐标寻找a
s.count(元素）计数
字典 清空：b.clear（）
b.pop( key) ：返回的是value 删除的是键值对
b.popitem():返回最后一个键值对，不需要传参，删除最后一个键值对，如果空的话会异常
del b[key] :类似pop(key)
遍历
book.get(key):得到对应的value
book.get(key,返回值）：如果找不到返回设定的返回值
book[key]:同上，区别：get不会出现异常
book.items() :一对一对放在元组里
for k,v in book.items():
print(k,v)book.setdefault(‘key’，‘value’）：类似添加 少 但不能修改使用
book.update(dict1) :将两个字典合并
book.fromkeys(['a','b'],[10,1]):创建一个新字典
练习：
books=[] #[{},{}] #列表里面是字典
while True:
if len(books)==3:
break
name=input("输入书名")
for book in books:
if name==book.get('name'): #不能value用in
print('书名重复')
break
else：
author=input（“输出作者”）
price=float(input("输入价格”))
books=append({'name':name,'author':author,'price':'price})
集合 ：不成对出现就是集合，集合没有下标，无序
{1，2，3，4}
空集合设置：set() ；c={}是空列表
set.add(value):添加
set.update(set1):添加
set.remove(value)
set.discard(value) 都能删 ，区别：删不存在的可以不会报错
set.pop():随机删除一个元素
c=set2&set3 :交集
set2|set3:并集
set2-set3:差集
sorted（元素）:排序
列表推导式：[返回值 for i in 可迭代]
[返回值 for i in 可迭代 if 条件]
[返回值 if 条件 else for i in 可迭代]
isinstance(x,list) :返回true or false
函数嵌套
闭9包：1嵌套函数，2内部函数引用了外部函数的变量（只能引用，不能修改） 3.返回值是内部函数
装饰器
高阶函数:
list=[(a,25),(b,30)]
max（list,key=lambda x:x[1]）
sorted同理
filter(条件,对象) :filter(lambda x:x[1]>20,list) 扔到list里面就能看到结果
map():map(lambda x:x[1]+1,list)将list 映射出来
reduce : reduce(lambda x,y:x+y,[1,2,3]) 必须有两个参数累加求和
zip():
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]
文件open操作
r:read 读 write 写
rb：b二进制字节 什么文件都可以 纯文本，音乐，电影rb
wb：同
文件上传、文件下载：
stream=open(r'绝对路径') ：默认rt读文本文件读不了doc其他文件。找不到会报错
content=stream.read();print(content)
result=stream.readable():判断是否可读，返回true
while True:
line=stream.readline()
print(line)
if not line:
break
lines=stream.readlines() :保存到列表中
for i in lines:
print(i)
写：stream=open(r'绝对路径','w')：会清除原来的内容
stream.write(字符串)
stream.close()
stream.writelines(内容):不换行，自己加\n
mode='a':不会清空原来的内容
文件复制：只能一个具体文件不能复制文件夹 os模块可以
stream=open(r'路径','rb')
with open(r'路径','rb') as stream: (with 结合open使用，可以帮助我们自动释放资源）
container=stream.read() 读取文件
with open(r'路径','wb') as wstream:
wstream.write(container)
os:相对路径常用从所在文件地址出发同级的 直接输入隔壁文件夹名以及后面的
../返回上级
os.path.dirname(__file__):定位到当前文件所在文件夹的路径
os.path.abspath(相对路径）：通过相对路径找绝对路径
os.path.abspath(__file__):当前文件的绝对路径，得打印出来
os.getwd():当前文件所在文件夹的路径
result=os.path.split(path):将文件夹和文件路径分隔开，放到元组里
result=os.path.splitext(path) :将扩展名分隔开，放在元祖里
os.path.getsize(path):获取文件大小
os.path.join('文件名):拼接成路径
os.listdir(r'文件夹地址'):返回文件夹下所有的文件名字，保存到列表中
os.mkdir(r'地址\文件夹名字)：在地址下创建新的文件夹
os.path.exists(r'地址\文件夹名字):判断这个文件夹是否存在
if not os.path.exists(r'地址\文件夹名字):
r=os.mkdir(r'地址\文件夹名字)
print(r)
os.rmdir(r'地址\文件夹名字):只能删除空的文件夹
os.remove(r'文件绝对路径')：删除文件
path=r'文件夹路径
filelist=os.listdir(path) :获取当前文件夹的所有文件名字，放在列表中
for file in filelist:
path=os.path.join(path.file)
os.remove(path)
else:
os.rmdir(path)
切换目录 os.chdir(r'目录） ：切换到要求的目录
复制文件夹
def copy(src，target):
if os.path.isdir(src) and os.path.isdir(target): 是否是文件夹
filelist=os.listdir(src)
for file in filelist:
path=os.path.join(src,file)
with open(path,'rb') as rstream:
container=rstream.read()
path=os.path.join(target,file)
with open(path,'wb') as wstream:
wstream.write(container)
else:
print('完毕')
copy(scr_path,target_path) :自己定义文件夹地址
try:
pass
except Exception as err:
print(err)
try:
pass
except:
pass
finally:
stream.close() 释放资源无论错没错
抛出异常：主动报错raise Exeption('提示')
列表推导式：[表达式 for 变量 in 旧列表] [表达式 for 变量 in 旧列表 if 条件]
[(x,y) for x in range(5) if x%2==0 for y in range(10) if y%2!==0] 外层循环套用内层循环
[表达式 if 条件 else 另一个表达式 for 变量 in 旧列表 if 条件]
集合推导式：{}返回无重复的集合
字典推导式：{value:key for key,value in dict.items()} 字典键值对交换
生成器：generator
1.通过列表推导式得到生成器
g=(x*3 for x in range(20))
print(g.__next__()) 一个一个得出
print(next(g)) 每调用一次next就会产生一个元素，超过范围会报错用try ,except
只要函数中出现yield关键字，说明就不是函数了是生成器
例子：
def func():
n=0
while True:
n+=1
yield n
g=func()
print(g)
print(next(g))
def g():
i=0
while i<5:
temp=yield i
print('temp:',temp) #return 0 暂停
i+=1
return '没有更多数据'
g=gen()
print(g.send(None)) 第一次必须先空值None 通过send改变temp的值
print(next(g))
n1=g.send('呵呵')
print('n1:',n1)
g.send('haha')进程，线程，协程9
def task1(n):
for i in range(n):
print('正在搬第{}砖'.format(i))
yield None #暂停功能
def task2(n):
for i in range(n):
print('正在听第{}首个'.format(i))
yield None
#做到任务交替
g1=task1(10)
g2=task2(5)
while True:
try:
g1.__next__()
g2.__next__()
except:
break可迭代的对象：isinstance()
from collections import Iterable
list=[1,2,3]
f=isinstance(list1,Iterable)
print(f)可迭代的是否是迭代器？生成器是可迭代的，也是迭代器，list是可迭代的，但不是迭代器
list1=[1,2,3]
list1=iter(list1)
print(next(list1))
print(next(list1)) #借助iter转换可以转换成迭代器面向对象：
class Phone:
brand='huawei'
yp=Phone()
print(yp)
print(yp.brand)
yp.brand='iphone'
print(yp.brand) #先找自己空间的，然后去模型中找
feifei=Phone()
print(feifei)
1.定义类
2.使用类，创建对象
类里面的函数：
class Phone:
brand=''
def call(self):
print('self---')
phone1=Phone()
phone1.call()
self穿的是自身 比如phone1调用时自己
类方法(加入装饰器)不需要self
定义需要依赖装饰器@classmethod
类方法中参数不是一个对象，而是类
类方法中只可以使用类属性
类方法的作用：不依赖对象self才能做到动作
静态方法：很类似类方法
1.需要装饰器@staticmethod
2.静态方法是无需传递参数（cls,self）
3.也只能访问类的属性和方法，对象的是无法访问的
4.加载时机同类方法
正则表达式
match 只从头开始匹配
search 遇到合适的就匹配，只匹配开始的一次
findall 匹配所有的符合要求的
$ 一直到结尾也是符合要求的
{2，5} 正则 次数 2-5个
[ ]字符串范围
\d :[0:9]
\D:[^\d] ^出现在【】里为非 ，在外面表示开始
\s:空白字符
\S:非空白
\w:任意字母数字及下划线
\W：非任意字母数字及下划线
\b:一个单词的边界
*：0
？：=0或者1
+：1
使用贪婪非贪婪在+/*/？后面加？
1065
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
