Python学习日记(十)—— 杂货铺(全局变量补充、Python参数传递、字符串格式化、迭代器、生成器)

全局变量补充

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循环 执行时的内部操作三件事

  1. 调用可迭代对象的iter方法,返回一个迭代器对象
  2. 调用迭代器的next方法
  3. 处理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方式则是比较先进的方式,企图替换古老的方式,目前两者并存。

上一篇:Python 学习日记(第二周)


下一篇:Python学习日记(一):拜见小主——Python