全局变量补充
python自己添加了些全局变量
print(vars())
"""
结果:
{'__name__': '__main__',
'__doc__': None,
'__package__': None,
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00795650>,
'__spec__': None,
'__annotations__': {},
'__builtins__': <module 'builtins' (built-in)>,
'__file__': 'C:/Users/Sullivan/PycharmProjects/q1/day12/global.py',
'__cached__': None}
"""
这些全局变量的作用
#__doc__ 包含py文件的注释,文件的注释在——文件内容的最上面用三引号引起来
print(__doc__) #__file__ 包含当前文件的路径
print(__file__) #__package__ 对于单读文件的package是没有意义的,代表当前的py文件在哪几个文件夹下
print(__package__)#当前文件没有,会返回None
from day2 import homework
print(homework.__package__) #文件夹套文件夹时用点"."区分
#结果:day2 #__cached__ 缓存,对于py文件是可以设置一个缓存的,python2里没有,了解即可
print(__cached__)#当前文件也有,会返回None
from day2 import homework
print(homework.__cached__)
#结果:C:\Users\Sullivan\PycharmProjects\q1\day2\__pycache__\homework.cpython-36.pyc #__name__ 如果当前执行的是当前文件,它的__name__就是__main__,其它的不管是导入还是其它的操作__name__就是文件名
print(__name__)
#结果__main__
from day2 import homework
print(homework.__name__)
#结果:day2.homework #__builtins__ 里边放的就是内置函数 #__loader__和__spec__ 都是p3中新加的
# 因为程序的入口文件就是用户当前执行的文件,所以以后写主程序文件的时候
if __name__ == "__main__":
execute()
#防止其他文件导入该文件时,执行主函数
name的实际应用
#利用sys,os模块和__file__变量,把路径添加到system path中 import os,sys
p1 = os.path.dirname(__file__) #获取当前路径
p2 = "bin"
my_dir = os.path.join(p1,p2) #字符串拼接,拼接出新路径 sys.path.append(my_dir) #添加到system path里面
file的实际应用
Python参数传递
Python参数传递 有引用传递&值传递两种
值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际参数的值。
a1 = 520
a2 = a1
print(a1,a2)
结果:520 520
a2 = a1 + 1
print(a1,a2)
结果:520 521
引用传递:也称地址传递,在方法调用时,实际上是把参数的引用(传的是地址,而不是参数的值)传递给方法中对应的形式参数,在方法执行中,对形式参数的操作实际上就是对实际参数的操作,方法执行中形式参数值的改变将会影响实际参数的值。
a1 = [1,2]
a2 = a1
a2.append(3)
print(a1)
结果:[1, 2, 3]
print(a2)
结果:[1, 2, 3]
在Python中,数字、字符或者元组等不可变对象类型都属于值传递,而字典dict或者列表list等可变对象类型属于引用传递。
如果要想修改新赋值后原对象不变,则需要用到python的copy模块,即对象拷贝。对象拷贝又包含浅拷贝和深拷贝。下面用例子来说明
例一
import copy
l1 = [[1, 2], 3] l2 = copy.copy(l1)
l2.append(4) #因为浅拷贝之拷贝第一层,所以对第一层操作不会影响l1
l2[0].append(5) #因为浅拷贝只拷贝的第一层,所以对第二层的操作还是值传递,所以l1和l2中都有列表的第一个元素都会添加一个5
print(l1)
print(l2)
结果:
[[1, 2, 5], 3]
[[1, 2, 5], 3, 4]
例二
l1 = [[1, 2], 3]
l3 = copy.deepcopy(l1) l3[0].append(6)
print(l1)
print(l3) #深拷贝全部拷贝,所以只是l3的值变了,l1并没有改变
# 结果:
[[1, 2], 3]
[[1, 2, 6], 3]
从上例可以看出,copy.copy属于浅拷贝,拷贝的是第一层list,而copy.deepcopy属于深拷贝,对list所有子元素都进行深拷贝。
字符串格式化
Python的字符串格式化有两种方式: 百分号方式、format方式
百分号的方式相对来说比较老,而format方式则是比较先进的方式,企图替换古老的方式,目前两者并存。
1、百分号方式
%[(name)][flags][width].[precision]typecode
- (name) 可选,用于选择指定的key
- flags 可选,可供选择的值有:
- + 右对齐;正数前加正好,负数前加负号;只有这个会在输出后给整数加上正号(+)
- - 左对齐;正数前无符号,负数前加负号;
- 空格 右对齐;正数前加空格,负数前加负号;
- 0 右对齐;正数前无符号,负数前加负号;用0填充空白处
- width 可选,占有宽度
- .precision 可选,小数点后保留的位数
- typecode 必选
- s,获取传入对象的__str__方法的返回值,并将其格式化到指定位置
- r,获取传入对象的__repr__方法的返回值,并将其格式化到指定位置
- c,整数:将数字转换成其unicode对应的值,10进制范围为 0 <= i <= 1114111(py27则只支持0-255);字符:将字符添加到指定位置
- o,将整数转换成 八 进制表示,并将其格式化到指定位置
- x,将整数转换成十六进制表示,并将其格式化到指定位置
- d,将整数、浮点数转换成 十 进制表示,并将其格式化到指定位置
- e,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(小写e)
- E,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(大写E)
- f, 将整数、浮点数转换成浮点数表示,并将其格式化到指定位置(默认保留小数点后6位)
- F,同上
- g,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是e;)
- G,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是E;)
- %,当字符串中存在格式化标志时,需要用 %%表示一个百分号
注:Python中百分号格式化是不存在自动将整数转换成二进制表示的方式
功能示例:
# %[(name)][flags][width].[precision]typecode s = ["i am %s,age %d" % ('ciri',18)]
# (name)
s = "i am %(n1)s,age %(n2)d" % {"n1":"ciri","n2":16}
s = "i am %(n1)s,age %(n1)s" % {"n1":"ciri"} #也可以两个共用一个值 #flags和width一般放到一起用,一般用不到
#字符
s = "i am %(n1)+10s ellie" % {"n1":"ciri"}
s = "i am %(n1)-10s ellie" % {"n1":"ciri"}
s = "i am %(n1) 10s ellie" % {"n1":"ciri"}
s = "i am %(n1)010s ellie" % {"n1":"ciri"}
#数字
s = "age %(n2)+10d ellie" % {"n2":16}
s = "age %(n2)+10d ellie" % {"n2":-16} s = "age %(n2)-10d ellie" % {"n2":16}
s = "age %(n2)-10d ellie" % {"n2":-16} s = "age %(n2) 10d ellie" % {"n2":16}
s = "age %(n2) 10d ellie" % {"n2":-16} s = "age %(n2)010d ellie" % {"n2":16}
s = "age %(n2)010d ellie" % {"n2":-16} #precision——默认输出6位小数
s = "age %f ellie" % 1.2
s = "age %.2f ellie" % 1.2 #指定小数保留几位
常用格式化:
tpl = "i am %s" % "alex" tpl = "i am %s age %d" % ("alex", 18) tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18} tpl = "percent %.2f" % 99.97623 tpl = "i am %(pp).2f" % {"pp": 123.425556, } tpl = "i am %.2f %%" % {"pp": 123.425556, }
2、Format方式
[[fill]align][sign][#][0][width][,][.precision][type]
都是中括号[],所以参数都可以省略
- fill 【可选】空白处填充的字符
- align 【可选】对齐方式(需配合width使用)
- <,内容左对齐
- >,内容右对齐(默认)
- =,内容右对齐,将符号放置在填充字符的左侧,且只对数字类型有效。 即使:符号+填充物+数字
- ^,内容居中
- sign 【可选】有无符号数字
- +,正号加正,负号加负;
- -,正号不变,负号加负;
- 空格 ,正号空格,负号加负;
- # 【可选】对于二进制、八进制、十六进制,如果加上#,会显示 0b/0o/0x,否则不显示
- , 【可选】为数字添加分隔符,如:1,000,000
- width 【可选】格式化位所占宽度
- .precision 【可选】小数位保留精度
- type 【可选】格式化类型
-
传入” 字符串类型 “的参数
- s,格式化字符串类型数据
- 空白,未指定类型,则默认是None,同s
-
传入“ 整数类型 ”的参数
- b,将10进制整数自动转换成2进制表示然后格式化
- c,将10进制整数自动转换为其对应的unicode字符
- d,十进制整数
- o,将10进制整数自动转换成8进制表示然后格式化;
- x,将10进制整数自动转换成16进制表示然后格式化(小写x)
- X,将10进制整数自动转换成16进制表示然后格式化(大写X)
-
传入“ 浮点型或小数类型 ”的参数
- e, 转换为科学计数法(小写e)表示,然后格式化;
- E, 转换为科学计数法(大写E)表示,然后格式化;
- f , 转换为浮点型(默认小数点后保留6位)表示,然后格式化;
- F, 转换为浮点型(默认小数点后保留6位)表示,然后格式化;
- g, 自动在e和f中切换
- G, 自动在E和F中切换
- %,显示百分比(默认显示小数点后6位)
-
传入” 字符串类型 “的参数
常用格式化:
# [[fill]align][sign][#][0][width][,][.precision][type] tpl = "i am {}, age {}".format("seven", 18)
tpl = "i am {}, age {}".format(*["seven", 18,'ciri']) #传入列表,列表的元素可以比前面的内容所
#可以传索引
tpl = "i am {0}, age {1}".format("seven", 18)
tpl = "i am {0}, age {1}".format(*["seven", 18])
#通过name获取
tpl = "i am {name}, age {age}".format(name="seven", age=18)
tpl = "i am {name}, age {age}".format(**{"name": "seven", "age": 18})#传字典要穿加上**
#第一个0表示拿第几个元素
tpl = "i am {0[0]}, age {0[1]}".format([1, 2, 3], [11, 22, 33])
#分别接收字符串、数字和浮点数
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tpl = "i am {:s}, age {:d}".format(*["seven", 18]) tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18}) tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
生成器——generator
列表生成器
# 先到 for x in range(10) 取元素,再把取出来的元素按照 前面的内容(x,x+1,x*2) 进行操作,然后把结果依次放到列表中
a = [x for x in range(10)]
print(a)
a = [x+1 for x in range(10)]
print(a)
a = [x*2 for x in range(10)]
print(a)
结果:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10
赋值一种方法
t = ('ciri',8)
a,b = t #值和变量的个数要相同,否则会报错 print(a)
print(b)
结果:
ciri
8
如何创建生成器?
方法一:小括号的方式
#把列表生成式的中括号,改成小括号,就变成了一个生成器
s = (x for x in range(10))
print(s) # <generator object <genexpr> at 0x03726360>
#输出的是一个生成器对象,所有的值压根就没有被创建出来(重点)
之前的列表生成式生成了10个值,就相当于10盘菜,已经做出来了,想什么时候成就什么时候吃,想什么时候调动就什么时候调用,想吃第几道就吃第几道。
生成器就相当于,厨师脑子里的10道菜,想吃的时候才做出来,你不吃就不会做出来,只能按顺序吃(0,1...8,9),不能隔着吃,也不能倒着吃
方法二:yield方式
def func():
print('ok')
yield 1
print('ok2')
yield 2 print(func) # <function func at 0x03163540> 可以看出func还是一个函数 func() #不会执行函数,此时func()是一个生成器对象 print(func())
# <generator object func at 0x034764B0> 可以看出 func加上括号() 是一个生成器对象
yield的执行过程
def func():
print('ok')
yield 1
print('ok2')
yield 2 next(func())
next(func())
结果:
ok
ok2 for i in func():
print(i)
结果:
ok
1
ok2
2
如何使用生成器中的对象?
s = (x for x in range(10))
print(s) # 方法一:
print(s.__next__())#内部特殊的方法,不建议用 # 方法二:
#python3中新加的方法
print(next(s)) #以后就用这种方法 # 方法三:
#python2中可以直接调用next方法
print(s.next) # 方法四:
for i in s:
print(i) #for就是内部调用next方法
斐波那契数列
def fib(max):
n,b,a = 0,0,1
while n<max:
print(b) #最开始的值
yield b
b, a = a, b + a #会先把b+a计算出来
n = n + 1 g = fib(8)
next(g)
next(g)
next(g)
next(g)
b, a = a, b + a为什么这个可以,把a的值赋值给b,b+a的值赋值给a b = a
a = b + a 这个不行 #因为b, a = a, b + a会先计算出来b+a的值
补充:b, a = a, b + a为什么这个可以
send方法
send和next的区别就是,send可以给yield前面的变量传值
def bar():
print('ok')
count = yield 1
print(count) #第二次进来,就会直接把send的值,直接传给yield前的参数count
yield 2 b = bar() #b.send('ciri') 会报错,因为第一次进来,执行到到yield就冻结了,出去了,所以第一次不知道给谁赋值,所以就不能用send传参数 ret1 = b.send(None) #用send第一次进入时,只能这么写,等价于next(b)
print(ret1) #结果 1 ret2 = b.send('ciri')
print(ret2) #结果:2
实例:用yield实现伪并发
#做和吃是同时发生的
import time def consumer(name):
print("%s 准备吃包子啦!" % name)
while True:
baozi = yield print("包子[%s]来了,被[%s]吃了!" %(baozi,name)) def producer(name):
c = consumer('A')
c2 = consumer('B')
next(c)
next(c2)
print("老子开始准备做包子了")
for i in range(10):
time.sleep(1)
print("做了2个包子")
c.send(i)
c2.send(i)
producer("ciri")
迭代器——iterator
生成器都是迭代器,迭代器不一定是生成器
如何创建一个迭代器?
#iter方法就做一件事情,返回了一个迭代器对象 li = [1,2,3,4]
d = iter(li)
print(d)
# <list_iterator object at 0x034A4770> iterator迭代器,iterable可迭代对象
什么是迭代器?
满足两个条件:1.有iter方法 2.有next方法
for循环后面加的是什么?
可迭代对象
什么是可迭代对象?
现象上——能进行 for循环的,都是可迭代对象
本质上——内部有iter方法的,就是可迭代对象
执行迭代器
li = [1,2,3,4] d = iter(li) #iter方法就做了一件事情,返回了一个迭代器对象 print(next(d))
print(next(d))
补充:for循环 执行时的内部操作三件事
- 调用可迭代对象的iter方法,返回一个迭代器对象
- 调用迭代器的next方法
- 处理stopiteration异常
实例:操作文件
f = open('abc.txt','r')
for i in f.readlines(): #假如文件很大的话,会全部都放到内存中去
pass
for i in f(): #这里的f就是一个可迭代对象,节省内存空间
pass
练习:使用文件读取,找出文件中最长的行
max(len(x.strip()) for x in open('/hello/abc','r'))
Python的字符串格式化有两种方式: 百分号方式、format方式
百分号的方式相对来说比较老,而format方式则是比较先进的方式,企图替换古老的方式,目前两者并存。