python初学4
a={1:34,2:45,7:44,-2:345}
print(sorted(a.items(),key=lambda x:x[0]))
print(sorted(a.items(),key=lambda x:x[1]))
eval函数就是实现list、dict、tuple与str之间的转化
str函数把list，dict，tuple转为为字符串
# 字符串转换成列表
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
print(type(a))
b = eval(a)
print(b)
# 字符串转换成字典
a = "{1: 'a', 2: 'b'}"
print(type(a))
b = eval(a)
print(type(b))
print(b)
# 字符串转换成元组
a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
print(type(a))
b=eval(a)
print(type(b))
print(b)
设置pycharm为Eclipse快捷键后使用总结：
|
Ctrl + O 根据name模糊查找当前文件中类、方法
Alt + (向左箭头或者向右箭头) ，回退or前进到到之前查看或者编辑处
Alt + (向上箭头或者向下箭头) ，将当前方法整体往下或者往上移动
Ctrl+Shift+R 根据name模糊查找某个资源文件
Ctrl+Shift+T 根据name模糊查找当前project中某个类
Ctrl+/ 注释，取消注释代码
Ctrl+D 删除当前行代码
Ctrl+ H 整个项目中查找
Ctrl+ S（没作用，pycharm是自动保存）
F3与Ctrl+鼠标左键效果一样：跳转到方法定义处
Shift+Enter 在行中编辑自动跳转到下一行开头处
Ctrl + Alt + L 代码格式化
Ctrl + Shift + ]/[ 选定代码块结束、开始
Ctrl+Shilf+F12 最大最小化当前编辑窗口（相当于Eclipse ctrl+M）
Ctrl + F6 窗口间切换
Ctrl +（-/+） 折叠放开代码
Alt+Shift+R 将当前文件重命名（Eclipse中用F2、当时pycharm被冲突了）
单步调试按钮（F5/F6/F7/F8），自己多用几次就熟悉了，此处不讲。
|
#!/usr/bin/env python3
#Auth Jun Yang
# 1、装饰器：
# 2、定义：本质事函数，（装饰其他函数）就是为其他函数添加附加功能
# 3、原则：1、不能修改被装饰的函数的源代码
# 2、不能修改被装饰的函数的调用方式
#
# 实现装饰器知识储备：
# 1、函数即“变量”
#def bar():
# pass
# def test():
# pass
#
# test（bar）
#test(bar())这两个函数调用的区别
# 2、高阶函数：满足下列条件之一
# a、把一个函数名当做实参传给另外一个函数（在不改变被装饰函数源代码的前提下为其添加功能）
# b、返回值中包含函数名（不修改函数的调用方式）
# 3、嵌套函数
#
# 高阶函数+嵌套函数=》装饰器
login_flag = False
usr_name = "uesta"
usr_pass = "123456"
def login(*args1,**kwargs1):
def outer(func):
def inner(*args,**kwargs):
_usr_name=input("your name")
_usr_pass=input("your passwd")
if len(args1)!=0:
if usr_name == _usr_name and usr_pass == _usr_pass:
print("passwd correct,")
login_flag = True
#return func(*args,**kwargs)
else:
print("wrong passwd or invalid usrname")
exit()
if login_flag == True:
res= func(*args, **kwargs)
return res
else:
exit()
else:
print("no passwd")
return inner
return outer
#America=login(America) 作用其实就是将login中返回的outer函数的地址赋予America变量，其实不是本来的Americia函数，实参是本来America这个函数的
@login()
def America():
print("welcome America!")
@login("qq")
def China():
print("welcome China")
def Japan():
print("welcome japan")
America()
China()
Japan()
生成器只有在依次调用的时候才会生成相应的数据，只有next的方法，无其他方法，只记录当前位置，因为所有的数据都在一个数据的内存依次变化，而不是所有都先生成出来
注意，赋值语句：
|
1
|
a, b = b, a + b |
相当于：
|
1
2
3
|
t = (b, a + b) # t是一个tuplea = t[0]b = t[1] |
但不必显式写出临时变量t就可以赋值。
把fib函数变成generator，只需要把print(b)改为yield b就可以了：
def fib(max):
n,a,b = 0,0,1
while n < max:
#print(b)
yield b
a,b = b,a+b
n += 1
return 'done'
这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：
>>> f = fib(6) >>> f <generator object fib at 0x104feaaa0>
这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
data = fib(10)
print(data)
print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13
在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。
同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：
>>> for n in fib(6): ... print(n) ... 1 1 2 3 5 8
但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>> g = fib(6)>>> while True:... try:... x = next(g)... print('g:', x)... except StopIteration as e:... print('Generator return value:', e.value)... break...g: 1g: 1g: 2g: 3g: 5g: 8Generator return value: done |
关于如何捕获错误，后面的错误处理还会详细讲解。
还可通过yield实现在单线程的情况下实现并发运算的效果
#_*_coding:utf-8_*_
__author__ = 'Alex Li'
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')
c.__next__()
c2.__next__()
print("老子开始准备做包子啦!")
for i in range(10):
time.sleep(1)
print("做了2个包子!")
c.send(i)
c2.send(i)
producer("alex")
import time
def consumer(name):
print("%s 准备吃包子啦!" %name)
while True:
baozi = yield
print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
def producer(name):
c = consumer('A') #由于yield的存在，此时consumer已经不是函数，所以这句话只是把c和c2变为生成器，但实际没有执行，必须要执行next以后才开始执行
c2 = consumer('B')
c.__next__()
c2.__next__()
print("老子开始准备做包子啦!")
for i in range(10):
time.sleep(1)
print("做了2个包子!")
c.send(i)
c2.send(i)
producer("alex")
yield保存当前值并返回 send给yield传值并调用yield 而next只是调用yield但不传值
我们已经知道，可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。（可循环）
可以使用isinstance()判断一个对象是否是Iterable对象：
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
|
1
2
3
4
|
>>> isinstance(iter([]), Iterator)True>>> isinstance(iter('abc'), Iterator)True |
你可能会问，为什么list、dict、str等数据类型不是Iterator？
这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
小结
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的，例如：
|
1
2
|
for x in [1, 2, 3, 4, 5]: pass |
实际上完全等价于：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break
浙公网安备 33010602011771号