python base
运算符:
#在没有（）的情况下，优先级 not>and>or 同一优先级从左到右依次计算
print(2>1 and 3<4 or 4>5 and 2<1)
#两边都是整数：
#x or y ,x为真则为x ，x为假则为y
#and 与or 相反
print(1 or 2)
print(0 or 10)
print(1 and 2 or 3 and 4)
类型转换:
i = 0
print(bool(i))
print(str(i))
print(int(True))
i1 = "100"
print(int(i1))#必须是纯数字
s = input("输入内容")
if s:
print("有内容")
else:
print（"无内容"）
编码:
“中国12he” : GBK：8个字节(一个中文字占两个字节)
“中国12he” ：UTF-8: 10个字节（一个中文字占3个字节）3+3+4
8bit = 1byte
1024byte = 1kb
1024kb = 1mb
1024mb = 1gb
1024bg = 1tb
数据类型：
列表：list [12，“alex”,[1,2,3]] 可以改变
元组：tuple(12,‘ALEX’,[1,2,3]) 不可以改变
字典：dict{“name”: “alex”}
set 交集
切片：
s1 = "python全站1111"
#对字符串进行索引，切片出来的数据都是字符串类型
print(s1[-1])
#1
#-------------------
s2 = s1[:5]
print（s2）
#pytho 骨头不顾尾
#--------------------
s3 = s1[6:]
#全站1111
#--------------------
#取步长
s4 = s1[:5:2]
#pto
#---------倒叙-----
s5 = s1[-1:-5:-1]#倒叙要加步长-1
#1111
#---------全取------
s4 = s1[:]
#----------倒叙全取-----
s5 = s1[::-1]
字符串常用操作方法：
#-----------变大小写------
# upper lower
s = "taibai"
print(s.upper())
print(s.lower())
#----------判断以什么开头结尾-----
#startswith endswith
s1 = "taibai"
print(s1.startswith('t'))
print(s1.startswith('tai'))
#加切片（了解）
print(s1.startswith('b',3,5))
#---------代替------------
#replace
msg = 'alex 很牛逼 ，alex 是初始人人'
print(msg.replace('alex','libing'))
#只替换一个
print(msg.replace('alex','libing',1))
#--------去除空白-------
#strip:空白，空格，\t,\n
s4 = '\n libing \t'
print(s4.strip())
#去除指定字符
s5 = 'libing'
print(s5.strip('lbg'))
#--------split----
#默认按照空格分割，返回一个列表
#str ---> list
s6 = '太白 女神 吴超'
l = s6.split()
print(l)
#指定分隔符：
s6 = '太白:女神:吴超'
l = s6.split(':')
print(l)
#限制分割次数
s6 = '太白:女神:吴超'
l = s6.split(':',1)
print(l)
#----------join---
#前提是列表里的元素必须都是str类型
s1 = 'alex'
s2 = '+'.join(s1)
print(s2)
#----------count-------
s1 = 'agdhabsdhabshdbhabaashbd'
print(s1.count('a'))
#------format格式化输出-----
#第一种用法
msg = '我叫{}今年{}性别{}'.format('雄安',25,'男')
print(msg)
#第二种
msg = '我叫{0}今年{1}性别{2}，依然叫{0}'.format('雄安',25,'男')
print(msg)
#第三种
msg = '我叫{name}今年{age}性别{sex}'.format(name = '雄安',age = 25,sex = '男')
print(msg)
#------is系列------------
name = 'sahbdahs'
print(name.isalnum())#字符串由字母或数字组成
print(name.isalpha())#字符串只由字母组成
print(name.isdecimal())#字符串只由十进制组成
s1 = input('请输入您的金额')
if s1.isdecimal():
print(int(s1))
else:
print('输入有误')
#-------in notin------
s1 = '牛逼冲冲冲'
print('牛逼' in s1)
print('逼牛' not in s1)
for循环:
s1 = '王弼很是厉害auhsdiiquhiuwhdi'
index = 0
while index < len(s1):
print(s1[index])
index += 1
s1 = '王弼很是厉害auhsdiiquhiuwhdi'
for i in s1:
print(i)
if i =='d':
break
列表的增删改查：
#列表创建：
s = [1,2,'lexa',[1,3,'li'],'mr']
##列表的增删改查
#---------增--------：
s.append('xx')
print(s)
#举例
s = [1,2,'lexa',[1,3,'li'],'mr']
while(1):
name = input("请输入员工姓名，按Q或者q退出")
if name.upper() == 'Q':
break
s.append(name)
print(s)
#-------insert-----
s = [1,2,'lexa',[1,3,'li'],'mr']
s.insert(2,'visiter')
print(s)
#------extend-----
s.extend('abcde')
print(s)
s.extend(['alex',1,2])
print(s)
#-----------------删--------
#pop按照索引删除
s = [1,2,'lexa',[1,3,'li'],'mr']
s.pop(-2)
print(s.pop(-2))
print(s)
#remove 指定元素删除
s = [1,2,2,2,'lexa',[1,3,'li'],'mr']
s.remove(2)#同名只删除左边第一个
print(s)
#clear 清空
s = [1,2,2,2,'lexa',[1,3,'li'],'mr']
s.clear()
print(s)
#del 按照索引删除
s = [1,2,2,2,'lexa',[1,3,'li'],'mr']
del s[-1]
print(s)
del s[::2]
print(s)
# --------改--------
#按照索引改
s = [1,2,'lexa',[1,3,'li'],'mr']
s[1] = 3
print(s)
#按照切片改(步长)（了解）
s = [1,2,'lexa',[1,3,'li'],'mr']
s[2:] = 'fasdaad'
print(s)
s = [1,2,'lexa',[1,3,'li'],[1,3,'libt'],3]
s[::2] = 'abc'#长度必须一一对应
print(s)
#————————查————---
#索引，切片
s = [1,2,'lexa',[1,3,'li'],[1,3,'libt'],3]
for i in s:
print(i)
列表的嵌套：
#将第三项改为大写
s = [1,2,'raikasdjannjsan',[1,'alex',['lib',2,'lisd']]]
s[2] = s[2].upper()
print(s)
#给小列表[1,'alex',3]添加'niubi'
s[-1].append('niubi')
#将列表中的'alex'通过字符串拼接成alexsb添加到列表
new_str = s[-1][1]+'sb'
s[-1][1] = new_str
s[-1][1] +='sb'
#将列表的lisd变大写
s[-1][-1][-1] = s[-1][-1][-1].upper()
print(s)
元组（了解）:
tu = (100,'太白',True,[1,2,3])
print(tu[:3])
#查看
for i in tu:
print(i)
print(len(tu))
#元组中的列表可以更改
tu[-1].append('niubi')
print(tu)
#元组的拆包
a,b = (1,2)#多一个少一个都不行 必须一 一对应
print(a,b)
range:
r = range(10)
for i in r:
print(i)
for i in range(1,101):
print(i)
for j in range(2,101,2):
print(j)
for z in range(100,0,-1):
print(z)
#利用for循环，利用range将列表打印\
s = [1,2,3,'lex','li',2]
for i in range(len(s)):
print(s[i])
#----------------range面试题------
s = range(5)
print(s[1:3])
print(s[-1])
for i in range(1,5,-1):
print(i)
字典
dic = {'辉辉': {'name': 'pgone','age':'9'},'python成员': (1,2,3)}
print(dic)
#键必须是不可变的数据类型，int，str 值可以是任意数据类型
#---------字典的创建：面试会考-------
dic = dict((('one',1),('two',2),('three',3)))
print(dic)
dic = dict(one = 1, two = 2)
print(dic)
dic = dict({'one':1,'two':2,'three':3})
print(dic)
#-----字典的增删改查------
#增
dic = {'name': '憨憨'}
dic['name'] = '本本'#改
dic['sex'] = '男'
print(dic)
#setdefault 有则不变 ，没有就添加
dic.setdefault('name','本本')
dic.setdefault('age',18)
print(dic)
#删
dic = {'name': '憨憨'}
print(dic.pop('name'))
#pop设置第二个参数无论字典中有没有此键都不会报错
print(dic.pop('age','没有此键'))
print(dic)
#清空clear
dic = {'name': '憨憨'}
print(dic.clear())
#------改-----
dic = {'name': '憨憨'}
dic['name'] = '笨笨'
print(dic)
#------查-------
#get
dic = {'name': '憨憨','age' :18}
print(dic.get('name'))
#可以设置返回值
print(dic.get('nam','没有此值'))
#三个特殊的
dic = {'name': '憨憨','age' :18}
print(dic.keys(),type(dic.keys()))
#此特殊的数据类型可以转化成列表：
print(list(dic.keys()))
#此特殊的数据类型可以直接遍历他
for key in dic.keys():
print(key)
for key in dic :
print(key)
#valuse
dic = {'name': '憨憨','age' :18}
print(dic.values())
print(list(dic.values()))
for value in dic.values():
print(value)
#iteam
dic = {'name': '憨憨','age' :18}
for i in dic.items():
print(i)
#相当于拆包
for key,values in dic.items():
print(key,values)
#面试题
a =12
b = 16
a,b = b,a
print(a,b)
面试会考的理论知识
#id 身份证
#-----------内存地址-------------------------
i = 100
s = 200
print(id(i))
print(id(s))
#--------- is 判断内存地址是否相等-----------
#id相同 他的值一定相同 值相同id不一定相同
s1 = [1,2]
s2 = [1,2]
print(s1 is s2)
S1 = 'ALEX'
S2 = 'ALEX'
print(S1 is S2)
#--------代码块 ：---------------------------
#我们所有的代码都依赖代码块来执行
#一个文件就是一个代码块
#交互式命令下一行就是一个代码块
#------------两个机制------
#同一个代码块一个机制
#不同代码块内不同机制
#-------同一个代码块里的缓存机制------
#前提条件：同一个代码块内
#机制内容：同一个变量不在新生成 只是取他的地址重新赋值
#适用对象 ： int bool str
#具体细则：所有的 数字，bool，几乎所有的字符串
#优点：提升技能，节省内存#
#--------小数据池------------
集合
#------集合-------
#内部元素不可变 本身可变 集合是无序的
#集合的作用 ：
#列表的去重
#列表的测试 交集 并集 差集
#集合的创建
se = {1,2,'憨憨','笨笨'}
print(se)
#空集合
set1 = set()
print(set1)
#-------集合的有效性测试---
set1 = {1,2,'憨憨','笨笨'}
#增
set1.add('xx')
print(set1)
#remove 按照元素删除
set1.remove('xx')
print(set1)
#pop随机删除
set1.pop()
print(set1)
#集合的交并差
set1 = {1,23,4,5,}
set2 = {1,3.45,6,7}
set3 = {1,
print(set1 & set2)
print(set1 | set2)
print(set1 - set2)
#子集
print(set1>set3)
#列表的去重
s = [1,1,2,2,3,4,5,5]
set1 = set(s)
print(list(set1))
浅copy(面试会考)
#浅copy copy一个外壳 都沿用之前的
s = [1,2,3,[22,33]]
s2 = s.copy()
s[-1].append(666)
s.append(4)
print(s)
print(s2)
#深copy 生成两个完全一样的copy
import copy
s = [1,2,3,[22,33]]
s2 =copy.deepcopy(s)
s[-1].append(666)
s.append(4)
print(s)
print(s2)
字符串补充方法
#首字母变大写
s = 'han han'
print(s.capitalize())
#大小写反转
print(s.swapcase())
#每个单词首字母大写
print(s.title())
#居中
print(s.center(20,'*'))
#找索引
print(s.find('a'))
print(s.index('a'))#找不出报错
元组补充
#元组中如果只有一个元素，并且没有逗号，那么它不是元组，他与该元素数据类型一致
tul = ([1,2])
print(tul,type(tul))
#计数
tul = [1,2,3,4,5,3,3,3]
print(tul.count(3))
#索引
print(tul.index(3))
列表补充
l = [1,2,3,7,8,1,23,5]
#count
#index
print(l.index(2))
#排序
l.sort()
print(l)
#从大到小
l.sort(reverse=True)
print(l)
#相加
l2 = ['憨憨',9,7]
print(l2 + l)
#相乘
print(l*3)
字典的补充
#update
dic1 = {'name':'hanhan','age':18}
dic2 = {'sex':'男'}
dic1.update(dic2)#有则覆盖，没有则添加
print(dic1)
#fromkeys
dic = dic.fromkeys([1,2,3],'hanhan')
print(dic)
#坑 值共用一个
dic2 = dict.fromkeys([1,2,3],[])
dic2[1].append(666)
print(dic2)
编码的进阶
#Ascall码：包含英文字母，数字，特殊字符与01010101对应的关系
#a 01010101字符一个字节表示
#GBk:仅仅包含本国文字（以及英文字母，数字，特殊字符）与0101010对应的关系
#a 01010101 ascall码中的字符 一个字符一个字节码表示
#中 01010101 01010101 中文 一个字符两个字节表示
#unicode 包含所有全世界的文字与二进制010101对应关系
#a 01010101 01010101 01010101 01010101
#b 01010101 01010101 01010101 01010101
#中 01010101 01010101 01010101 01010101
#utf-8 包含全世界所有的文字与二进制01010101的对应关系（最少用8位字节表示一个字符）
# a 01010101
#欧洲文字 01010101 01010101
#中 01010101 01010101 01010101
#不同的密码本是不能够相互识别的
#数据在内存中全部是以Unicode编码，但是当你数据用于网络传输或者存储在硬盘中，必须以Unicode编码（utf-8,gbk等）
'''
英文：
str:'hello'
内存中的编码方式：unicode
表现形式：'hello'
bytes:
内存中的编码方式：非unicode
表现形式：b'hello
中文：
str:'中国'
内存中的编码方式：unicode
表现形式：'中国'
bytes:
内存中的编码方式：非unicode#utf-8
表现形式：b'\xe4\xb8\xad\xe5\x9b\xbd'
'''
#-----------------------------------------------------
#str --->bytes
s = '中国'
b = s.encode('utf-8')#编码
print(b,type(b))
#bytes--->str
b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
s1 = b1.decode('utf-8')#解码
print(s1)
#gbk---->utf-8
b2 = b'\xd6\xd0\xb9\xfa'
s2 = b2.decode('gbk')
print(s2)
print(s2.encode('utf-8'))
文件操作
#-----------文件操作------
#全读
f = open('rea',encoding='gbk')
print(f.read())
f.close()
#按照字符读
print(f.read(4))
f.close()
#按照行读
print(f.readline())
print(f.readline())
f.close()
#按照行全读出来
print(f.readlines())
f.close()
#for 读取
for line in f:
print(line)
f.close()
#--------------rb-----------
# rb:操作的是非文本文件，图片，视频，音频
f = open('1.jpg',mode='rb')
print(f.read())
f.close()
#----------文件的写---------
#如果文件存在先清空在写入
f = open('writ',mode='w')
f.write('憨憨是笨笨的好兄弟')
f.close()
#----------wb 非文本文件-------
f = open('1.jpg',mode='rb')
content = f.read()
f.close()
f1 = open('2.jpg',mode='wb')
f1.write(content)
f1.close()
#---------文件的追加 没有文件创建文件，追加内容-----
f = open('rewrit',mode='a')
f.write('憨憨和笨笨是一对快乐的好伙伴')
f.close()
f = open('rewrit',mode='a')
f.write('憨憨和笨笨一起出去游玩了')
f.close()
#-----------读并且写！！！顺序不能反 必须是先读然后追加！！！-----
f = open('rea',mode='r+')
print(f.read())
f.write('what is up!')
f.close()
#--------------其他功能补充------------
#tell 光标的位置 单位是字节
f = open('rea',encoding='gbk')
print(f.tell())
print(f.read())
print(f.tell())
f.close()
#seek 调整光标的位置
f = open('rea')
print(f.seek(6))
print(f.read())
#print(f.tell())
f.close()
#flush 强制保存 在write()后面要添加flush(),因为别的软件可能不保存 pycharm自动保存
f = open('rea',mode = 'w')
f.write('憨憨和笨笨有一天走失了')
f.flush()
f.close()
#打开文件的另外方式
#优点不用手动关闭句柄
#可以操作多个句柄
with open('rea')as f1:
print(f1.read())
with open('rea')as f1,\#太长了相当于换行符
open('writ',mode='w')as f2:
print(f1.read())
f2.write('憨憨和笨笨每一天天天开心')
#------------文件的修改操作-------
'''
1.以读的模式打开一个源文件
2.以写的模式创建一个新的文件
3.将源文件的内容读出来修改成新内容，写入新文件
4.将原文件删除
5.将新文件重命名成原文件
'''
#1
#2
import os
with open('憨憨自述')as f1,\
open('憨憨自述.bak',mode='w')as f2:
old_content = f1.read()
new_content = old_content.replace('憨憨','笨笨')
f2.write(new_content)
os.remove('憨憨自述')
os.rename('憨憨自述.bak','憨憨自述')
#j进阶版
import os
with open('憨憨自述')as f1,\
open('憨憨自述.bak',mode='w')as f2:
for line in f1:
new_line = line.replace('笨笨','憨憨')
f2.write(new_line)
os.remove('憨憨自述')
os.rename('憨憨自述.bak','憨憨自述')
函数
def comp(a,b):
pass
comp(10,1)
#---------return -----
#一 终止函数，以下语句不再执行 二 返回一个数值 或者多个数值
def meet():
print('hello')
return '憨憨',12,[22,33]
# print(meet())
ret1,ret2,ret3 = meet()
print(ret1,ret2,ret3)
#参数
#按位置
def meet(sex,name,age):
print('筛选：性别:%s,姓名:%s,年龄:%s'%(sex,name,age))
return 0
meet('男','憨憨',18)
#按关键字
def meet(sex,name,age):
print('筛选：性别:%s,姓名:%s,年龄:%s'%(sex,name,age))
return 0
meet(name='憨憨',age=18,sex='男')
#混合传参数 前面一定是位置 后面是关键字
def meet(sex,name,age):
print('筛选：性别:%s,姓名:%s,年龄:%s'%(sex,name,age))
return 0
meet('男',age=118,name='憨憨')
#三元运算符：简单的if else语句
a = 10
b = 20
c = a if a>b else b
print(c)
#**kwargs
def func(**kwargs):
print(kwargs)
func(sex = '男',name = '憨憨',age = 18)
#在函数调用时，*代表被打散
def func(*args):
print(args)
func(*[1,2,3],*[5,6])#相当于func([1,2,3,5,6])
#在函数调用时，*代表被打散 **相当于聚合
def func(*args,**kwargs):
print(args)
print(kwargs)
func(*[1,2,3],*[5,6])#相当于func([1,2,3,5,6])
func(**{'name':'憨憨'},**{'age':18})
#万能参数
def func(*args,**wargs):
print(args)
print(wargs)
func()
#*args的位置:
#args会全收 接受参数
def func(a,b,*args,sex = '男'):
print(a,b)
print(sex)
print(args)
func(1,2,4,5,6,7,sex = '女')
#**wargs 接收关键字参数
def func(a,b,*args,sex = '男',**kwargs):
print(a,b)
print(sex)
print(args)
print(kwargs)
func(1,2,34567,sex = '女',name = '憨憨',age =18)
#形参角度第四个参数：仅限关键字参数并且实参传值方式固定，只能赋值（了解）例如c 放在wargs和args之间
def func(a,b,*args,sex = '男',c,**kwargs):
print(a,b)
print(sex)
print(args)
print(c)
print(kwargs)
func(1,2,34567,name = '憨憨',age =18,c='666')
#------总结--------
#最终的形参角度的顺序：位置参数，*args,默认参数，仅限关键字参数，**kwargs
#------------------
空间
1.内置名称空间（builtins.py）
2.全局名称空间(当前py文件)
3.局部名称空间（函数，函数执行时开辟）
--------------加载顺序-------------
内置名称空间—》全局名称空间—》局部
--------------取值顺序------------
1.就近，局部–》全局–》内置
------------作用域----------------
1.全局作用域：内置名称空间 全局名称空间
2.局部作用域：局部名称空间
1.局部作用域可以引用全局作用域，但是不可以改变，全局不可以引用局部变量
#错误范例 LEGB原则
count = 1
def func():
count += 2
print(count)
func()
#局部作用域不能改变全局作用域的变量，当python解释器读取到局部作用域时，发现了你对#一个变量进行修改的操作，解释器会认为你在及局部已经定义过这个局部变量了，它就从局##部找这个局部变量，报错了
#错误示例2
def func():
count = 1
def inner():
count += 1
print(count)
inner()
func()
#globals 返回的是字典，字典里面的键值对，全局作用域的所有内容
#locals 返回的是字典，字典里面的键值对，当前作用域的所有内容
a = 1
b = 2
def func():
name = '憨憨'
age = 18
print(globals())
print(locals())
func()
函数补充
#补充知识点 陷阱
#陷阱只针对默认参数是可变的数据类型
#如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次这个默认参数，都是同##一个
def func(name,alist=[]):
alist.append(name)
return alist
ret1 = func('憨憨')
print(ret1.id(ret1))
ret2 = func('笨笨')
print(ret2.id(ret2))
def func(a,list[]):
list.append(a)
return list
print(func(10,))#[10,]
print(func(20,[]))#[20,]
print(func(100,))#[10,100]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-90uXQvS9-1615824267123)(C:\Users\24222\Desktop\笔记\1611055574820.png)]
#局部作用域的坑
#在函数中，如果你定义了一个变量，但是在定义这个变量之前对其引用，那么解释器认为，语法问题
#应该在使用之前先定义
c = 1
def func():
print(c)
c =3
func()
#global 在局部声明一个全局变量
def func():
global name
name = '憨憨'
func()#注意要让函数先执行
print(name)
#global 修改一个全局变量
count = 1
def func():
global count
count += 1
print(count)
#nonlocal
'''
1.不能操作全局变量
2.局部作用域：内层函数对外层函数的局部变量进行修改
'''
#错误范例
count = 1
def func():
nonlocal count
count += 1
func()
def warp():
count =1
def inner():
nonlocal count
count += 1
print(count)
inner()
print(count)
warp()
#func()
#1.函数名指向的是函数的内存地址 函数名 + （）就可以执行
#实际上指向的内存地址加（） 可以执行
def func():
print(666)
print(func,type(func))
#2.函数名就是变量
f = func
f1 = f
f2 = f1
f2()
f()
f1()
#3.函数名可以作为容器类数据类型的元素
def func1():
print('func1')
def func2():
print('func2')
def func3():
print('func3')
s = [func1,func2,func3]
for i in s :
i()
#4.函数名可以作为函数的参数
def func():
print('in func')
def func1(x):
x() #函数名＋() 就是执行函数
print('in func1')
func1(func)
格式化输出
name = input("姓名")
age = input("年龄")
job = input("工作")
hobby = input("爱好")
#%占位符 s-> str
msg =''' ----------------info of %s---------
name : %s
age : %s
job : %s
hobby ： %s
---------------end-----------'''%(name,name,age,job,hobby)
print(msg)
#在格式化输出时 %只想做百分号，而不是占位符使用
msg2 = '我叫%s，成绩占年级1%%'%('libing')
print(msg2)
#
#新特性 格式化输出
name = '憨憨'
age = 18
msg = f'我叫{name},今年{age}'
print(msg)
#可以加表达式
dic = {'name':'憨憨','age':18}
msg = f'我叫{dic["name"]},今年{dic["age"]}'
print(msg)
count = 7
print(f'最终结果：{count**2}')
#结合函数符号
def _sum(a,b):
return a+b
msg = f'最终的结果是：{_sum(10,20)}'
print(msg)
#优点：
'''
1.结构更加简化
2.可以结合表达式和函数一起使用
3.效率提升很多
'''
迭代器
#迭代器
'''
内部含有__iter__方法
有带你
'''
#获取检查一个对象的所有方法 dir()
s = 'asda'
print(dir(s))
print('__iter__'in dir(s))
print('__iter__'in dir(range(10)
优点：
1。存储的数据直接显示，比较直观
2.拥有的方法比较多，操作方便
缺点：
1.占用内存
2不能直接for循环，不能直接取值（索引，可以）
s =[1,2,3,4]
for i in s:
print(i)
#迭代器 内部含有__iter__方法并且含有__next__方法的对象就是迭代器
with open('rea',mode = 'w')as f1:
print('__iter__'in dir(f1)and ('__next__')in dir(f1))
#可迭代对象可以转化为迭代器
s = 'dasdada'
ob = iter(s)#s.__iter__()
print(next(ob))#print(ob.__next__())
print(next(ob))#print(ob.__next__())
print(next(ob))#print(ob.__next__())
print(next(ob))#print(ob.__next__())
print(next(ob))#print(ob.__next__())
z = [11,22,33]
ob2 = iter(z)
print(next(ob2))
print(next(ob2))
print(next(ob2))
'''优点：
1.节省内存 ，文件句柄化成迭代器
2.惰性机制，next一次，取一个值
缺点：
1.速度慢
2.不走回头路，永远从上一次结束的地方开始
'''
x = [11,2,3,4,5,6,7,8]
count = 0
for i in range(4):
if count ==4:
break
else:
print(i)
count += 1
count = 0
for i in x:
if count == 6:
break
else:
print(i)
count += 1
'''
可迭代对象和迭代器的对比：
1.可迭代对象是一个操作对象方法比较多，比较直观，存储数据相对较少的一个数据集
2.当你侧重于对于数据可以灵活处理，并且内存空间足够
1.迭代器是一个非常节省内存，可以记录取值位置，可以直接通过循环 +next
方式取值，但是不直观，操作比较单一的数据集
2.当你数据量过大，大到足以撑爆你的内存或者以节省内存为首要因素时，将数据
集设置为迭代器是一个不错的
'''
#将可迭代对象 转化成迭代器
a = [1,2,3,4,5,6,7,8]
w = iter(a)
while 1:
try:
print(next(w))
except StopIteration:
break
生成器函数
#函数
# def func():
# print(1111)
# print(2222)
# return 3
# func()
#生成器函数
#一个next对应一个yield
def func():
print(1111)
print(2222)
yield 3
a = 1
b = 2
c =a+b
print(c)
yield 4
ret = func()
print(next(ret))
print(next(ret))
#对比
'''
return 函数只有一个return结束函数，并且给函数执行者返回值
yield 只要函数中有yield那么他是生成器函数而不是函数来
生成器函数可以有多个yield, 一个yield不会结束生成器函数，一个
yield对应一个next
'''
def gen_func():
for i in range(1,5001):
yield f'{i}号包子'
ret = gen_func()
for i in range(200):
print(next(ret))
# yield from
def func():
s = [1,2,2,3,4,5]
yield from s
#将这个列表变成迭代器返回
ret = func()
print(next(ret))
#列表推导式 简单代码时在用 debug不能用所以不要多用
#循环模式：[变量（加工后的变量）for 变量 in ]
s = [i for i in range(1,10) ]
print(s)
#将100以内所有的偶数写入列表
ret = [i**2 for i in range(1,11)]
print(ret)
#从python1期到python100期写入列表list
print([f'python{i}期'for i in range(1,101)])
内置函数
#匿名函数 一句话函数
#构建匿名函数
#冒号前是形参 冒号后是表达式返回值
func = lambda a,b:a+b
print(func(1,2))
func2 = lambda a,b: a if a>b else b
print(func2(2,4))
#callable 判断一个对象是否可以被调用
print(callable(func2))
#print
print(1,2,3)
print(1,2,3,sep='|')
print(1,2,3,end=' ')
#abs 取绝对值
print(abs(-6))
#sum 求可迭代对象的和
s = [i for i in range(10)]
print(sum(s))
#可以设置初始值
print(sum(s,100))
#min,max
#凡是可以加key的，她会自动的将可迭代对象中的每个元素按照顺序方式
#传入key对应的函数中
s = [-1,2,3,4,-5]
def abss(a):
return abs(a)
print(min(s,key=abss))#key 一定不要加括号
#sorted 加可以key
s = [('憨憨',88),('笨笨',80),('能能',98)]
print(sorted(s,key= lambda x:x[1],reverse=True))
#filter 列表推导式的筛选模式
z = [2,3,4,5,1,1,2]
print([i for i in z if i>3])#返回的是列表
ret = filter(lambda x:x>3,z)#返回的是迭代器
print(ret)
print(list(ret))
#map 列表的推导式的循环模式
z = [2,3,4,5,1,1,2]
print([i**2 for i in range(1,6)])#返回的是列表
ret = map(lambda x:x**2,range(1,6))#返回的是迭代器
print(ret)
print(list(ret))
#reduce 相当于累加效果
from functools import reduce
def func(x,y):
return x+y
'''
第一次 1+2 =3
第二次 3+3
第三次 6+4
'''
print(reduce(func,[1,2,3,4]))
闭包
#封闭的东西 闭包
l = []#全局变量 全局变量数据不安全
def make_average(new_value):
l.append(new_value)
toal = sum(l)
averager = toal/len(l)
return averager
print(make_average(10000))
print(make_average(11000))
print(make_average(12000))
#方案二：闭包
#内层函数对外层函数非全局变量的引用，就会形成闭包
#被引用的非全局变量也称作自由变量，这个自由变量会
#与内层函数产生一个绑定关系
#自由变量不会再内存中消失
#闭包的作用：保证数据安全
#如何判断一个函数是不是闭包 ：
'''
闭包只能存在于嵌套函数中
内层函数对外层函数的非全局变量的引用（使用），就会形成闭包
'''
def make_average():
l = []#l一直存在就是因为闭包
def average(new_value):
l.append(new_value)
toal = sum(l)
return toal/len(l)
return average
avg = make_average()
print(avg(100000))
print(avg(120000))
修饰器
#修饰器
import time
def index():
'''很多代码'''
time.sleep(2)#延迟两秒
print('欢迎登录')
def timmer(f):
def inner():
start_time = time.time()
f()
end_time = time.time()
print(f'测试函数的执行效率{end_time-start_time}')
return inner
ret = timmer(index)
ret()
#标准版的装饰器
def wrapper(f):
def inner(*args,**kwargs):
'''
添加额外的功能，执行被装饰函数之前的操作
'''
ret = f(*args,**kwargs)
'''
添加额外的功能，执行被装饰函数之后的操作
'''
return ret
return inner
#----------------------------------------------
def auth(f):
def inner(*args,**kwargs):
'''函数前'''
ret = f(*args,**kwargs)
'''函数后'''
return ret
return inner
@auth # 相当于 article = auth(article)
def article():
print('你好')
article() #inner()
@auth
def comment():
print('欢迎')
comment()
自定义模块
p82
ge(10000))
print(make_average(11000))
print(make_average(12000))
#方案二：闭包
#内层函数对外层函数非全局变量的引用，就会形成闭包
#被引用的非全局变量也称作自由变量，这个自由变量会
#与内层函数产生一个绑定关系
#自由变量不会再内存中消失
#闭包的作用：保证数据安全
#如何判断一个函数是不是闭包 ：
‘’’
闭包只能存在于嵌套函数中
内层函数对外层函数的非全局变量的引用（使用），就会形成闭包
‘’’
def make_average():
l = []#l一直存在就是因为闭包
def average(new_value):
l.append(new_value)
toal = sum(l)
return toal/len(l)
return average
avg = make_average()
print(avg(100000))
print(avg(120000))
### 修饰器
```python
#修饰器
import time
def index():
'''很多代码'''
time.sleep(2)#延迟两秒
print('欢迎登录')
def timmer(f):
def inner():
start_time = time.time()
f()
end_time = time.time()
print(f'测试函数的执行效率{end_time-start_time}')
return inner
ret = timmer(index)
ret()
#标准版的装饰器
def wrapper(f):
def inner(*args,**kwargs):
'''
添加额外的功能，执行被装饰函数之前的操作
'''
ret = f(*args,**kwargs)
'''
添加额外的功能，执行被装饰函数之后的操作
'''
return ret
return inner
#----------------------------------------------
def auth(f):
def inner(*args,**kwargs):
'''函数前'''
ret = f(*args,**kwargs)
'''函数后'''
return ret
return inner
@auth # 相当于 article = auth(article)
def article():
print('你好')
article() #inner()
@auth
def comment():
print('欢迎')
comment()
```
### 自定义模块
```python
p82
```
1439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
