Python入门
内置 迭代函数 和 推导函数
# enumerate
s= 'abcdefg'
slist = [list([i,item]) for i,item in enumerate(s)]
print(slist)
[[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd'], [4, 'e'], [5, 'f'], [6, 'g']]
# sorted
f = [5,58,2,75]
fsort = [i for i in sorted(f)]
print(fsort)
[2, 5, 58, 75]
#reversed
sreversed = [n for n in reversed(s)]
print(sreversed)
['g', 'f', 'e', 'd', 'c', 'b', 'a']
#zip
s1 = ['name','age','addr']
s2 =['tom','33','UK']
szip = dict(zip(s1,s2))
szip_1 = {k:v for k,v in zip(s1,s2)}
print(szip)
print(szip_1)
{'name': 'tom', 'age': '33', 'addr': 'UK'}
{'name': 'tom', 'age': '33', 'addr': 'UK'}
s0 =[i*2 for i in range(10)]
print(s0)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
推导函数进阶
# 推导进阶
s0 = [i**3 for i in range(10) if i % 2 ==0]
print(s0)
[0, 8, 64, 216, 512]
数组，元组，字典，空字符串，非空字符串，0.非零的 True Or False
flag = []
if flag is not None:
print('[] is not none')
else:
print('[] is none')
if flag:
print('[] is True')
else:
print('[] is Flase')
[] is not none
[] is Flase
flag = ()
if flag is not None:
print('() is not none')
else:
print('() is none')
if flag :
print('() is True')
else:
print('() is False')
() is not none
() is False
flag = {}
if flag is not None:
print(r'{} is not none')
else:
print(r'{} is none')
if flag :
print(r'{} is True')
else:
print(r'{} is False')
{} is not none
{} is False
flag = ''
if flag is not None:
print(r' empty string is not none')
else:
print(r' empty string is none')
if flag :
print(r' empty string is True')
else:
print(r' empty string is False')
empty string is not none
empty string is False
flag = 0
if flag is not None:
print(r'0 is not none')
else:
print(r'0 is none')
if flag :
print(r'0 is True')
else:
print(r'0 is False')
0 is not none
0 is False
flag = 1
if flag is not None:
print(r'1 is not none')
else:
print(r'1 is none')
if flag :
print(r'1 is True')
else:
print(r'1 is False')
1 is not none
1 is True
flag = "s"
if flag is not None:
print(r's is not none')
else:
print(r's is none')
if flag :
print(r's is True')
else:
print(r's is False')
s is not none
s is True
flag = None
if flag is not None:
print(r'None is not none')
else:
print(r'None is none')
if flag :
print(r'None is True')
else:
print(r'None is False')
None is none
None is False
字典的另类用法
def fn_A():
print('fn_A called')
def fn_B():
print('fn_B called')
def fn_C():
print('fn_C called')
def fn_D():
print('fn_D called')
dic_config = {}
dic_config["A"] = fn_A
dic_config["B"] = fn_B
dic_config["C"] = fn_C
dic_config["D"] = fn_D
user_choose = 'A'
dic_config[user_choose]()
fn_A called
迭代器 生成器 装饰器
迭代器
任何一个类，如果实现了 __iter__()方法 和 __next__() 方法就是迭代器，或称作可迭代。
__iter__()
返回自身
__next__()
返回下一个元素
如果元素迭代完毕，则需要引发一个 StopIteration 异常
Python 内置了很多 迭代器都在 itertools 中。
import math
class Person:
def __init__(self,**kwargs):
self.Name = kwargs["name"]
self.Age = kwargs["age"]
# 这个迭代器的意义在于，生成了 指定数量的 Person对象，并遍历了他们。如果需要生成100万个样本，用数组无疑会造成内存负担。
class MyIterator:
def __init__(self,**kwargs):
self.data = []
self.max = kwargs["num"] if kwargs["num"] else 1
for i in range(self.max):
self.data.append(Person(name = "%s%d"%(kwargs["name"],i),age = 18 +i))
self.currentIdx = -1
def __iter__(self):
return self
def __next__(self):
if self.currentIdx < self.max-1:
self.currentIdx += 1
return self.data[self.currentIdx]
else:
raise StopIteration
# 调用代码
for p in MyIterator(name ="name",age = 18,num = 10):
print(p.Name,p.Age)
name0 18
name1 19
name2 20
name3 21
name4 22
name5 23
name6 24
name7 25
name8 26
name9 27
生成器
生成器有个关键函数 yield 用于生成序列。也是用一个生成一个。
def myYield(n):
while n > 0:
print('开始生成...')
yield n
print('完成生成...')
n -=1
for i in myYield(3):
print(i)
开始生成...
3
完成生成...
开始生成...
2
完成生成...
开始生成...
1
完成生成...
发现了一个规律，生成器返回之后，我们的调用程序继续运行，我们的调用程序运行之后。再次返回到生成器中。如此循环！
生成器有两个重要函数
\_\_next()\_\_ 生成下一个数
send(num) 重置生成器
如此一来，上面的例子可以写成。
yieldIteration = myYield(3)
print(yieldIteration.__next__())
print(yieldIteration.__next__())
print(yieldIteration.__next__())
print(yieldIteration.__next__()) # 这里报错了。错误是 StopIteration 我们就很好理解了。
开始生成...
3
完成生成...
开始生成...
2
完成生成...
开始生成...
1
完成生成...
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
Input In [76], in <cell line: 5>()
3 print(yieldIteration.__next__())
4 print(yieldIteration.__next__())
----> 5 print(yieldIteration.__next__())
StopIteration:
装饰器——基于方法的
读过设计模式的都知道，装饰器实际上是一种设计模式。python 里面也只是个语法糖。
我的理解是，将重复的操作，需要加到一些已有的函数中去，但又不想改变现有函数的结构和功能，此时可以使用装饰器解决这个问题。
到后面会发现，这玩意儿 跟 js 的闭包很像。
# 这是不带参数的 装饰器
def demo_decorater(fun):
def new_func(*args,**kwargs):
print('准备执行原生方法')
fun(*args,**kwargs)
print('原生方法执行完毕')
return new_func
@demo_decorater
def fun_demo(name,age):
print(f'我是 fun_demo 方法 {name} {age}'.format(name,age) )
fun_demo('tom',23)
print("割----------------------------------------------")
# 这是带参数的装饰器
# 其中，装饰器有返回值，被装饰的方法也有返回值
def demo_decorater_with_args(url):
def demo_wrapper(fun):
def wrapper(*args,**kwargs):
fn_result = fun(*args,**kwargs)
return fn_result,f'url is: {url}'.format(url)
return wrapper
return demo_wrapper
@demo_decorater_with_args("http://www.baidu.com")
def func_demo(**args):
name =args["name"]
print(f"my name is {name}".format(name))
return 'do other thing'
s,f = func_demo(name = "tom")
print(s)
print(f)
准备执行原生方法
我是 fun_demo 方法 tom 23
原生方法执行完毕
割----------------------------------------------
my name is tom
do other thing
url is: http://www.baidu.com
1、 被装饰的方法的返回值，可以在装饰器中获取。
2、 装饰器的返回值，可以在被装饰的方法调用后获取。
3、 在装饰器中，可以处理方法的返回值。重新定义返回值
装饰器——基于类的
在装饰器装饰方法的时候，一般是对方法功能的扩展，也可以修改其返回的信息。
在对类进行装饰的时候，我们可以扩展类的功能，添加方法，也可以修改原有方法的功能，还可以为这个类新增一些字段和属性。
'''
现有 Human 类
class Human:
def __init__(self,name = "tom"):
self.name = name
def info(self):
print('my name is ',self.name)
'''
# 现在有需求，在 Human类上 扩展 学生信息，但又不能影响现有 使用Human类的代码。
def Student(targetClass):
class innerClass:
def __init__(self,name):
self.target = targetClass(name)
# 扩展了新的 属性
self.Grade = 1
# 在原有的方法上加了新的功能
def info(self):
self.target.info()
self.Study()
# 添加了新的功能 study
def Study(self):
print('I\'m a student,I can study')
return innerClass
# 定义一个类
@Student
class Human:
def __init__(self,name):
self.name = name
def info(self):
print('my name is ',self.name)
s = Human("tom")
s.info()
g = s.Grade
print(f'我上 {g} 年级'.format(g))
my name is tom
I'm a student,I can study
我上 1 年级
