Python基础
python 基础
-基础
-基本数据类型
-函数
-面向对象
-基础
-基本数据类型
-函数
-面向对象
开发：
python种类
JPython JAVA开发的
IronPython C#开发的
Cpython
JavaScriptPython
RubyPython
pypy 用CPython开发的Python预先生成好的机器码执行 效率高 第一次执行可能稍慢
IronPython C#开发的
Cpython
JavaScriptPython
RubyPython
pypy 用CPython开发的Python预先生成好的机器码执行 效率高 第一次执行可能稍慢
安装
python安装在os上，具体操作略 安装python3
执行操作：
写一个文件，文件中按照python的规则写，将文件交给python软件，读取文件内容，进行转换和执行，最终得出结果
python软件==》python解释器（内存管理）
下载
python3 继续更新
python2 停止更新维护
window 点点点
配置环境变量 PATH路径
Linux 本身自带2.7 需另外安装一个python3
以下代码在linux下以./*.py执行文件时需要在首行写以保证程序可以找到解释器
#!/usr/bin/env python
python安装在os上，具体操作略 安装python3
执行操作：
写一个文件，文件中按照python的规则写，将文件交给python软件，读取文件内容，进行转换和执行，最终得出结果
python软件==》python解释器（内存管理）
下载
python3 继续更新
python2 停止更新维护
window 点点点
配置环境变量 PATH路径
Linux 本身自带2.7 需另外安装一个python3
以下代码在linux下以./*.py执行文件时需要在首行写以保证程序可以找到解释器
#!/usr/bin/env python
#-*- coding:utf8 -*- 这是保证代码中有中文时可以正常运行的编码
python基本数据类型
数字int
python3 中 int 包含全部的数字 包括长
python2 长整形 long 之类的会被区分出来
int.bit_length()#返回转化为2进制后占据的位数
int() 将字符串'123'转化为数字123
可选参数base =2 转化为2进制
python3 中 int 包含全部的数字 包括长
python2 长整形 long 之类的会被区分出来
int.bit_length()#返回转化为2进制后占据的位数
int() 将字符串'123'转化为数字123
可选参数base =2 转化为2进制
字符串str
str.upper()#字母大写
str.capitalize()#首字母大写
str.lower()#英文字母小写
str.casefold()#更加全面的字符大小写转换 包含许多字符的大小写对应
str.center(width,fillchar=None) #在width个字符长度里剧中显示，用fillchar填充空白位置，限定一个字符
str.count(sub,start=None,end=None) #求sub在str中出现的次数,start end标记起始和结束位置
str.encode()
str.decode()
str.endswith(suffix,start=None,end=None)
#判断str是否是以suffix结尾，返回布尔值
str.startwith()同上以suffix开始
str.find(sub,start=None,end=None)#从开始往后找找到第一个匹配后返回位置,-1代表未找到
str.format(*args,**kwargs)#替换str内{}的值，将字符串中的占位符替换为指定的值
str.format_map({"name":'alex',"a":19})
str.index(sub) #类似find 但是找不到会报错
str.isalnum() #是否只包含数字和字母
str.expandtabs(6)#制表例子如下
>>> test="username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123"
>>> v=test.expandtabs(20)
>>> print(v)
username email password
laiying ying@q.com 123
laiying ying@q.com 123
laiying ying@q.com
str.isalpha() #是否只包含字母
str.isdecimal()#是否是数字十进制
str.isdigit()#是否是数字包含特殊类型①这种
str.isidentifier()#字母，数字，下划线：标识符
str.isnumeric()#支持中文的数字一
str.isprintable()#是否存在不可显示的字符\t制表符 \n换行符
str.isspace()#是否为空格
str.istitle()#是否为标题（首字母大写）This Is A Title
str.title()#转换为title样式this is a title ---> This Is A Title
str.join(sub)#将str重复加入拆解的sub每一个元素中 例子在下面
test = "123"
v="_".join(test)
print(v)
1_2_3
str.isdecimal()#是否是数字十进制
str.isdigit()#是否是数字包含特殊类型①这种
str.isidentifier()#字母，数字，下划线：标识符
str.isnumeric()#支持中文的数字一
str.isprintable()#是否存在不可显示的字符\t制表符 \n换行符
str.isspace()#是否为空格
str.istitle()#是否为标题（首字母大写）This Is A Title
str.title()#转换为title样式this is a title ---> This Is A Title
str.join(sub)#将str重复加入拆解的sub每一个元素中 例子在下面
test = "123"
v="_".join(test)
print(v)
1_2_3
str.ljust(width,fillchar=None)#内容放在左边填充内容
str.rjust#内容放在右边填充内容
str.zfill()#用0填充
str.lstrip()#处理左边空格
str.rstrip()#处理右边空格
str.strip()#处理空格 \t \n 都行 给传参的话可以直接去除传参
str.maketrans("aeiou","12345")#建立对应关系
str.translate(m)#根据之前的关系翻译
str.partition()#根据传参 分割字符串为三份，找到第一个就分
str.rpartition()#分割字符串从右边开始找
str.split()#分割字符串 以字符串为界不保留分割字符串，并且可以指定分割最大次数，默认-1次全找到
str.rsplit()#从左边开始分割
str.splitlines(False)#换行分割True保留换行符
str.swapcase()#转化大小写
len()#在python2 显示的是字节数在python3显示的是字符数
字符串 在内存中一旦创建就不能修改 如果修改就会重新创建
#split join len for list str[]strip
#split join len for list str[]strip
str.replace(a,b,int)#b替换a int次
range(start，end，step)#创建连续的数字#开头；结尾；步长
列表list
中括号括起来，以逗号分割每个元素，列表中的元素可以是数字，字符串，列表..所有的数据类型都能放进去
#集合内部放置任何东西
#支持索引取值 list[1]
#支持切片 切片结果也是list
#支持for while
#由链表实现
#删除方法
del list[i]
#in
#字符串转换list list(str)
默认以每一个字符转化成列表
int不能直接转化为list #list(int)不行
实际转换时应该也调用了类似for循环的方法 因为int不能迭代
list转str 会直接变成字符串输出不改动 list = [1,2,3] str(list) = "[1,2,3]"
list 用join拼接时需要列表中的元素只有字符串
list.append()#添加元素在末尾
list.clear()#清空列表
list.copy()#复制，浅拷贝
list.count()#计算元素出现次数
list.extend(iterable)#传入可迭代对象，循环单个插入，与append将元素当作整体插入不同str="str" list.extend(str) list--> ['s','t','r']
list.index()#寻找值的位置 左边优先
list.insert()#在指定位置插入
list.pop(index=None)#返回并删除一个值，默认最后一个开始
list.remove()#删除一个值 从左边开始查找
list.reverse()#j将当前列表反转 [1,2,3]-->[3,2,1]
list.sort(reverse=True)#排序reverse=True降序
list 是有序的 元素可以被修改
#cmp
#key
#sorted
元祖tuple
创建元祖(,)在圆括号中加,用来与函数调用()区分
list的二次加工
元祖，元素不可被修改，不能被增加或者删除
一般写元祖的时候在最后加一个，逗号，用以区分参数
可以通过索引取值
可以切片，切片结果还是元祖
支持for循环，可迭代
元祖可以和字符串 列表相互转换
元祖是有序的
元祖的一级元素不能修改#例如一级元素是list list不能改成别的 但是list的内容可以修改
元祖内的列表里的内容可以修改
tuple.count()#找到值出现的次数
tuple.index()#找到值对应的位置左边优先，start，end
中括号括起来，以逗号分割每个元素，列表中的元素可以是数字，字符串，列表..所有的数据类型都能放进去
#集合内部放置任何东西
#支持索引取值 list[1]
#支持切片 切片结果也是list
#支持for while
#由链表实现
#删除方法
del list[i]
#in
#字符串转换list list(str)
默认以每一个字符转化成列表
int不能直接转化为list #list(int)不行
实际转换时应该也调用了类似for循环的方法 因为int不能迭代
list转str 会直接变成字符串输出不改动 list = [1,2,3] str(list) = "[1,2,3]"
list 用join拼接时需要列表中的元素只有字符串
list.append()#添加元素在末尾
list.clear()#清空列表
list.copy()#复制，浅拷贝
list.count()#计算元素出现次数
list.extend(iterable)#传入可迭代对象，循环单个插入，与append将元素当作整体插入不同str="str" list.extend(str) list--> ['s','t','r']
list.index()#寻找值的位置 左边优先
list.insert()#在指定位置插入
list.pop(index=None)#返回并删除一个值，默认最后一个开始
list.remove()#删除一个值 从左边开始查找
list.reverse()#j将当前列表反转 [1,2,3]-->[3,2,1]
list.sort(reverse=True)#排序reverse=True降序
list 是有序的 元素可以被修改
#cmp
#key
#sorted
元祖tuple
创建元祖(,)在圆括号中加,用来与函数调用()区分
list的二次加工
元祖，元素不可被修改，不能被增加或者删除
一般写元祖的时候在最后加一个，逗号，用以区分参数
可以通过索引取值
可以切片，切片结果还是元祖
支持for循环，可迭代
元祖可以和字符串 列表相互转换
元祖是有序的
元祖的一级元素不能修改#例如一级元素是list list不能改成别的 但是list的内容可以修改
元祖内的列表里的内容可以修改
tuple.count()#找到值出现的次数
tuple.index()#找到值对应的位置左边优先，start，end
字典dict
创建字典对象
{'k1':'v1',#键值对 键：值
'k2':'v2'}
dict的值可以是任意值类型
列表不可以作为键
元祖可以hashable
字典不能作为键
key值重复只保留一个#bool值True被视作1 False视作0
dict是无序的每次print的结果都会不一样
删除 del dict['k1']
for i in dict:
print(i)#默认输出key
dict.keys()
dict.values()
dict.items()#返回键值对k,v=dict.items()
dict.clear()
dict.copy()#shallow cpoy
dict.fromkeys()#静态方法，生成字典类型，第一个传参作为key（可以是list），第二的传参作为value
dict.get(key,value)#查询是否存在key，不存在时返回value，默认为None
dict.pop(key，value)#删除并返回一个指定键的值，value用来返回默认值
dict.popitem()#随机删一个并返回删除的键值对
dict.setdefult(key,value)#设置一个键值对，返回value，当key已经存在，就返回当前key对应的值
dict.update(key,value)#同时支持dict.update(key=value) 更新键值内容，键不存在则新建
传参中带有**kwargs会自动将key=value转换为字典
keys values items get update dict常用功能
具体的功能在pycharm ctrl+左键查看
总结
常用方法
1.数字int
2.字符串str
replace/find/join/strip/startwith/split/upper/lower/format
3.列表list
append,extend,insert
#索引切片循环
4.元祖tuple
元素不能被修改删除
#索引切片循环
5字典dict
get,update,keys,values,items
#for循环,索引
for循环调用dict默认返回keys
6布尔值bool
bool()
以0和1存在内存中
None "" () [] {} 0==>False
空字符串 空列表 空元祖 空字典 都是False
可变类型 list dict 修改值不会改变指向地址
不可变类型 str int tuple 修改值会改变地址id()
1.数字int
2.字符串str
replace/find/join/strip/startwith/split/upper/lower/format
3.列表list
append,extend,insert
#索引切片循环
4.元祖tuple
元素不能被修改删除
#索引切片循环
5字典dict
get,update,keys,values,items
#for循环,索引
for循环调用dict默认返回keys
6布尔值bool
bool()
以0和1存在内存中
None "" () [] {} 0==>False
空字符串 空列表 空元祖 空字典 都是False
可变类型 list dict 修改值不会改变指向地址
不可变类型 str int tuple 修改值会改变地址id()
访问顺序
直接访问 int
索引访问 str list tuple #加中括号[int]
映射访问 dict 占用内存较list大#加中括号[str]
直接访问 int
索引访问 str list tuple #加中括号[int]
映射访问 dict 占用内存较list大#加中括号[str]
存放元素个数
容器类型 list tuple dict
原子类型 数字 字符串
集合
由不同元素组成 只能放int str tuple
无序排列可hash的值
集合中元素不可变
set 集合有自动去重的功能
set.add()#添加元素
set.clear()#清空集合
s=set.copy()#浅拷贝
set.pop()#随机删除
set.remove(x)#指定删除
set.discard(x)#指定删除，当要删的元素不存在时不会报错
#求交集
print(set1,set2)
print(set1.intersect(set2))
print(set1&set2)
#并集
print(set1.union(set2))
print(set1|set2)
#差集
print(set1-set2)#存在于set1 但是不在set2中的元素
print(set1.difference(set2))
#交叉补集
print(set1.symmetric_difference(set2))
print(set1^set2)
#其他方法
set1=set1.difference_update(set2)#将得到的差集返回set1
set1.isdisjjoint(set2)#当两个集合没交集返回True
set1.issubset(set2)#set2是否包含set1 set1是set2的子集 set2是set1的父集
set1.issuperset(set2)#父集
set1.update(set2)
set是可变集合
frozenset是不可变集合
字符串格式化#
print('my name is %s'%name)
浮点数 ' percent %.2f%99.123124
.2 小数点后取两位
tpl="i am %(name)s age %(age)d"%{"name":"alex","age":18}#取一个叫name的 字符串 再取一个叫age的整形数字
flags - 左对齐
msg='i am %(name)-60s hahah'%{'name':'lhf'}
msg='i am %(name)-60s hahah'%{'name':'lhf'}
print('root','0','x','0',sep=':')#用分隔符拼接字符串
tpl="i am {name:s} age{age:d}".format(**{"name":"oops",age=18})
#两个*代表传入的是字典 一个*代表传入的是列表
#两个*代表传入的是字典 一个*代表传入的是列表
函数
写函数之前先写注释解释一下这个函数是干嘛用的
test(x,y,z)
#位置参数需要一一对应
test(1,2,3)
#位置参数和需要在关键字参数左边
test(1,2,z=3)
写函数之前先写注释解释一下这个函数是干嘛用的
test(x,y,z)
#位置参数需要一一对应
test(1,2,3)
#位置参数和需要在关键字参数左边
test(1,2,z=3)
默认参数
def handle(x,type='None'):
print(x,type)
handle('hello')
handle('hello',type='sqlite')
def handle(x,type='None'):
print(x,type)
handle('hello')
handle('hello',type='sqlite')
参数组 *args可变长参数（传入的是列表形式）
def test(x,*args):
print(x)
print(args)
test(1,2,3,4,5)
def test(x,*args):
print(x)
print(args)
test(1,2,3,4,5)
1
(2,3,4,5)
(2,3,4,5)
test(1,[1,2,3])
test(1,*[1,2,3])#不加*会被视作一个整体传给args
test(1,*[1,2,3])#不加*会被视作一个整体传给args
>>> test(1,[1,2,3])
1
([1, 2, 3],)
>>> test(1,*[1,2,3])
1
(1, 2, 3)
>>>
1
([1, 2, 3],)
>>> test(1,*[1,2,3])
1
(1, 2, 3)
>>>
def test(x,**kwargs):
print(x)
print(kwargs)
test(x=1,y=2,z=3)
1
{'y':2,'z':3}
print(x)
print(kwargs)
test(x=1,y=2,z=3)
1
{'y':2,'z':3}
#等同于
test(x=1,**{'y':2,'z':3})
def test(x,*args,**kwargs):
print(x,args,kwargs)
#这个函数传什么值都行 除了两遍x
#函数使用的好处
代码重用
保持一致性
可拓展性
全局变量
name ='rxl'
name ='rxl'
def test():
global name#在函数内部修改全局变量需要声明
name='rrr'
print(name)
nonlocal找上一级变量
global name#在函数内部修改全局变量需要声明
name='rrr'
print(name)
nonlocal找上一级变量
递归
递归特性：
必须有一个明确的结束条件
每次进入更深一层递归时，问题的规模要减小
递归效率不高，递归次数过多会导致栈溢出
#函数作用域
只和当初声明的时候所调用的变量有关
#匿名函数
lambda x:x+1#返回函数体
func = lambda x:x+1
func(10)
lambda x:x+1#返回函数体
func = lambda x:x+1
func(10)
func=lambda x,y,z:(x+1,y+1,z+1)
#函数式编程
特征
1.不可变数据
不用变量保存状态，不修改变量
2.第一类对象
3.尾调用优化
代码精简 可读性差 python不是严格的函数式编程语言
高阶函数
函数接受的参数是一个函数名
返回值中包含函数
函数接受的参数是一个函数名
返回值中包含函数
内置函数
map方法
map(func,items) 传入一个函数func,遍历处理传入的可迭代对象items返回一个迭代器包含处理结果
结果中元素个数与位置和原来的数据一致
python2中map返回的是list
python3中返回的是map object
map(func,items) 传入一个函数func,遍历处理传入的可迭代对象items返回一个迭代器包含处理结果
结果中元素个数与位置和原来的数据一致
python2中map返回的是list
python3中返回的是map object
filter方法
filter(func,item)
传入一个函数func，遍历判断传入的可迭代对象item，返回符合条件的数据
传入一个函数func，遍历判断传入的可迭代对象item，返回符合条件的数据
python3 返回filter object
from functools import reduce#在python3中需要导入先
reduce(func,item.init=None)
传入一个函数func，将传入的数据item合并处理返回一个最终结果 init指定初始位置
abs()#取绝对值
all()#将所有值用来做bool运算
如果可迭代对象是空返回True
any()#只要有一个为真就返回真
bin()#十进制转化为二进制
bool()#空值 None 0 为False
bytes()#将字符串转换成字节
bytes(str,encoding='utf-8')
bytes(str,encoding='utf-8').decode('utf-8')
chr()#根据ascii码转化
dir()#打印对象内部的方法
divmod(10,3)#(3,1)
enumerate()
eval()#将字符串中的数据结构提取出来，将字符串中的数学运算计算出来
help()#查看使用帮助
reduce(func,item.init=None)
传入一个函数func，将传入的数据item合并处理返回一个最终结果 init指定初始位置
abs()#取绝对值
all()#将所有值用来做bool运算
如果可迭代对象是空返回True
any()#只要有一个为真就返回真
bin()#十进制转化为二进制
bool()#空值 None 0 为False
bytes()#将字符串转换成字节
bytes(str,encoding='utf-8')
bytes(str,encoding='utf-8').decode('utf-8')
chr()#根据ascii码转化
dir()#打印对象内部的方法
divmod(10,3)#(3,1)
enumerate()
eval()#将字符串中的数据结构提取出来，将字符串中的数学运算计算出来
help()#查看使用帮助
hex()#十进制转16进制
oct()#十进制转8进制
isinstance(x,type)#判断x是否为指定数据类型
oct()#十进制转8进制
isinstance(x,type)#判断x是否为指定数据类型
globals()#所有全局变量
locals()#打印当前级别的局部变量
zip(('a','b','c'),(1,2,3))#返回一个zip object 数据一一对应('a',1),('b',2),('c',3)
locals()#打印当前级别的局部变量
zip(('a','b','c'),(1,2,3))#返回一个zip object 数据一一对应('a',1),('b',2),('c',3)
max()#for 循环遍历值
zip()结合max()可以查找dict中对应的键值对
zip()结合max()可以查找dict中对应的键值对
dic={'a':10,'b':11,'c':9}
max(zip(dic.values,dic.keys()))
max(item,key=lambda x:x)#
可以定制判断条件
可以定制判断条件
ord()#与chr作用相反
pow(x,y)#x**y or x**y%z(有三个传参时)
pow(x,y)#x**y or x**y%z(有三个传参时)
repr()#面向对象中类似str的方法
reversed()#反转
reversed()#反转
round()#四舍五入
set()#集合
slice(start,stop,step=1)#切片
sorted()#排序 不同类型的值不能比较
item=[
{'name':'alex','age':18},
{'name':'ljsa','age':100},
{'name':'rhj','age':12}
]
sorted(item,key=lambda dic:dic['age'])#
可以定制判断条件
super()#面向对象继承相关 父类
tuple()#
type()#返回数据类型
vars()#没有参数时和locals()相同 有参数时将该函数所有有方法返回为字典形式
set()#集合
slice(start,stop,step=1)#切片
sorted()#排序 不同类型的值不能比较
item=[
{'name':'alex','age':18},
{'name':'ljsa','age':100},
{'name':'rhj','age':12}
]
sorted(item,key=lambda dic:dic['age'])#
可以定制判断条件
super()#面向对象继承相关 父类
tuple()#
type()#返回数据类型
vars()#没有参数时和locals()相同 有参数时将该函数所有有方法返回为字典形式
#test.py
def say_hi():
print('hello')
__import__()#传入参数可以是str类型的py文件名
module_name='test'
m=__import__(module_name)
m.say_hi
m=__import__(module_name)
m.say_hi
文件处理
1打开文件得到一个文件句柄
open()#函数打开文件会以系统文件编码打开 win下文件为gbk
f=open('xx',encoding='utf-8')
文件打开方式 r只读 w只写 a只追加
f.readable()#是否可读
f.readline(),end=''将最后的换行符设为空#一次读一行
f.readlines()#读取多行返回list
f.readable()#是否可读
f.readline(),end=''将最后的换行符设为空#一次读一行
f.readlines()#读取多行返回list
f.write()#不换行写入 自行+\n
f.writeable()#
f.writelines(lines)#接受一个列表 写的数据必须都是str不能是int
f.writeable()#
f.writelines(lines)#接受一个列表 写的数据必须都是str不能是int
追加r+
会覆盖原内容
f.write()#在光标处写 如果执行读取的话就在光标处读
#不需要写close的方法
with open('a.txt','w') as f:
f.write('xxx')
b模式
以字节方式操作 写入时也只能提供字节不能指定编码
会覆盖原内容
f.write()#在光标处写 如果执行读取的话就在光标处读
#不需要写close的方法
with open('a.txt','w') as f:
f.write('xxx')
b模式
以字节方式操作 写入时也只能提供字节不能指定编码
字符串---》encode编码----》bytes
bytes---》decode解码---》字符串
bytes---》decode解码---》字符串
bytes('心魔',encode='utf-8')
'新民'.encode('utf-8')
'新民'.encode('utf-8')
f.encode#返回以什么编码模式读取
'latin-1' #编码模式支持大多数编码
f.flush()#刷新缓存 保存
f.tell()#光标所在的位置
f.tell()#光标所在的位置
#win下文档的换行是\r\n python读取时会自动变为\n
要取消的话在open时添加newline=''\r\n"
f.seek(0,model)#指定光标位置 按字节指定 需用b模式打开文件
model=0每次指定都从开始位置算
model=1每次指定都采用上一次光标所在的相对位置
model=2每次都从文件最后位置开始
使用负数标识（可以用来读取日志最新的数据）
f.read(4)#按照字符来读
f.truncate(10)#截断
要取消的话在open时添加newline=''\r\n"
f.seek(0,model)#指定光标位置 按字节指定 需用b模式打开文件
model=0每次指定都从开始位置算
model=1每次指定都采用上一次光标所在的相对位置
model=2每次都从文件最后位置开始
使用负数标识（可以用来读取日志最新的数据）
f.read(4)#按照字符来读
f.truncate(10)#截断
for i in f:
print(i)#循环取文件的方式 不会预先全部把文件加入内存
#查看日志文件最后的一行
f=open('1og.txt',rb)
for i in f:
offs=-10#偏移量
while True:
f.seek(offs,2)
data=f.readlines()
if len(data)>1:
print('文件的最后一行是%s'%(data[-1].decode('utf-8')))
break
offs*=2
print(i)#循环取文件的方式 不会预先全部把文件加入内存
#查看日志文件最后的一行
f=open('1og.txt',rb)
for i in f:
offs=-10#偏移量
while True:
f.seek(offs,2)
data=f.readlines()
if len(data)>1:
print('文件的最后一行是%s'%(data[-1].decode('utf-8')))
break
offs*=2
#迭代器
递归 自己调用自己
迭代 每次循环的结果都是依赖上次结果来的
迭代器协议
对象需要提供一个next方法用来返回迭代中的下一项
要么引发一个StopIteration异常以终止迭代
只能往后走不能返回
对象需要提供一个next方法用来返回迭代中的下一项
要么引发一个StopIteration异常以终止迭代
只能往后走不能返回
字符串，列表，元祖，字典，集合，文件对象都不是可迭代对象，在for循环时调用了_iter_方法，将他变成可迭代对象
字典的迭代器返回的对象是key值
字典的迭代器返回的对象是key值
for循环就是一个基于迭代器协议提供了一个统一的遍历所有可迭代对象的方法
1.调用对象的__iter__()方法获得一个可迭代对象
2.循环执行 当捕捉到stopIteration异常自动终止
1.调用对象的__iter__()方法获得一个可迭代对象
2.循环执行 当捕捉到stopIteration异常自动终止
生成器 自动实现了迭代器协议
1生成器函数 使用yield语句替代return语句返回结果，但是yield可以返回多次
2.生成器表达式
#三元表达式
name='a'
res='aa' if name=='a' else 'bb'
#列表解析
l=[]
for i in range(10):
l.append('鸡蛋%s'%i)
print(l)
l=[]
for i in range(10):
l.append('鸡蛋%s'%i)
print(l)
l=['鸡蛋%s' %i for i in range()10]
生成器表达式 #节省内存
laomuj=('鸡蛋%s' %i for i in range()10)
laomuj.__next__()
next(laomuj)
laomuj=('鸡蛋%s' %i for i in range()10)
laomuj.__next__()
next(laomuj)
sum([1,2,3.....,1亿])#这样会占用很多内存来生成迭代器
sum(i for i in range(1亿))#使用生成器计算 这样会占用cpu但是不会占用大量内存
生成器的好处是延迟计算执行的时间，一次返回一个结果
map sum reduce filter #支持生成器的方法
map sum reduce filter #支持生成器的方法
生成器可有效的提高可读性
生成器只可遍历一次
生成生成器
l=[1,3]
l.__iter__()与iter(l)同价
生成器只可遍历一次
生成生成器
l=[1,3]
l.__iter__()与iter(l)同价
#装饰器
本质就是函数，为其他函数添加附加功能
原则
1.不修改被修饰函数的源代码
2.不修改被修饰函数的调用方式
装饰器= 高阶函数+函数嵌套+闭包
装饰器框架
#@timmer 相当于test=timmer(test)
#带参数的装饰器
def timmer(func):
def wrapper(*args,**kwargs):
start_time=time.time()
res=func(*args,**kwargs)
stop_time=time.time()
print('run time%s'%(stop_time-start_time))
return res
return wrapper
@timmer
def test(name,age)
time.sleep(3)
print('namea:%s age:%s'%(name,age))
#解压序列
a,b,c=(1,2,3)
a,*_,b=(1,2,3,4,5)#把其他的值给_舍弃，只取头尾
def test(name,age)
time.sleep(3)
print('namea:%s age:%s'%(name,age))
#解压序列
a,b,c=(1,2,3)
a,*_,b=(1,2,3,4,5)#把其他的值给_舍弃，只取头尾
python的交换功能
f1=1
f2=2
f1,f2=f2,f1
f2=2
f1,f2=f2,f1
