本文共 6257 字，大约阅读时间需要 20 分钟。
1倒序输出
s = 'abcde'print(s[::-1])#输出: 'edcba'
2 列表reverse()操作
s = 'abcde'lt = list(s)lt.reverse()print(''.join(lt))#输出: 'edcba' 3 二分法交换位置
s = 'abcde'lt = list(s)for i in range(len(l) // 2): lt[i], lt[-(i+1)] = lt[-(i+1)], lt[i]print(''.join(lt))#输出: 'edcba' 4 列表生成式
s = 'abcde'print(''.join([s[i-1] for i in range(len(s), 0, -1)]))#输出: 'edcba' 5 栈的思想
s = 'abcde'lt = list(s)res = ''while lt: res += lt.pop()print(res)#输出: 'edcba'
6 递归的思路
def res_str(s): if len(s) == 1: return s head = s[0] tail = s[1:] return res_str(tail)+headres_str('abcd')#输出: 'dcba' 采用循环
import numpy as npdef bubble_sort(arr): for i in range(1,arr.size): for j in range(arr.size-1): if arr[j] > arr[j+1]: arr[j],arr[j+1] = arr[j+1],arr[j] print(arr)arr = np.array([4,7,8,9,3,6,7,9,4,0])bubble_sort(arr)
采用数组中的partition,用递归实现
import numpy as npdef quick_sort(arr): if arr.size == 1: return arr _arr = np.partition(arr,1) #在索引1前面的一定是最小值 return np.append(_arr[:1],quick_sort(_arr[1:]))quick_sort(arr)def quick_sort2(arr): if arr.size < 2: return arr _arr = np.partition(arr,1) #在索引2前面的一定是最小值 return np.append(_arr[:2],quick_sort2(_ar/r[2:]))quick_sort2(arr)
map : map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))['1', '2', '3', '4', '5', '6', '7', '8', '9']
map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场
from functools import reduce>>> def func(x, y):... return x * 10 + y...>>> reduce(func, [1, 3, 5, 7, 9])13579
如果是完成字符串转数字了,那么就可以采用map与reduce组合
>>> from functools import reduce>>> def func(x, y):... return x * 10 + y...>>> def tran(s):... digits = { '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}... return digits[s]...>>> reduce(func, map(tran, '13579'))13579>>>reduce(lambda x,y:10*x+y, map(tran,'13579')) #字符串也是可迭代的13579 对于一般的函数表达式我们建议采用lambda函数实现,下面我们用lambda函数改写
>>>reduce(lambda x,y: x*10+y , [1,3,5,7,9])13579>>>reduce(lambda x,y:10*x+y, map(int,['1','3','5','7','9']))13579>>>reduce(lambda x,y:10*x+y, map(int,['1','3','5','7','9']))13579
filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。
def not_empty(s): return s and s.strip()list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))# 结果: ['A', 'B', 'C']
注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
一般我们也会与lambda函数配合,非常方便的取代if判断效果.
class BookViewModel: self.publisher = book['publisher'] self.author = book['author'] self.price = book['price']def intro(self): intros = filter(lambda x:True if x else False,[self.author,self.publisher,self.price]) return '/'.join(str(s) for s in intros)
lambda x:True if x else False可以实现对x是否为空的判定,X存在返回True,并保留,X不存在返回空并排除.
注意:
join函数组合可迭代对象时,当对象中存在数字与字符串类型不同时,需要转成统一格式再组合.一般采 取的做法是先遍历可迭代对象转统一格式后合并.
'/'.join(str(s) for s in intros)
Python内置的sorted()函数
>>> sorted([36, 5, -12, 9, -21])[-21, -12, 5, 9, 36]
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：
>>> sorted([36, 5, -12, 9, -21], key=abs)[5, 9, -12, -21, 36]
字符串的排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])['Credit', 'Zoo', 'about', 'bob']
默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。
sorted函数中key可以实现用户自定义排序规则,而不仅仅限于简单排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)['Zoo', 'Credit', 'bob', 'about']
key=str.lower 按照统一小写排序, reverse=True实现反向排序.
Python内置的@property装饰器就是负责把一个方法变成属性调用的：
class Student(object): @property def score(self): return self._score @score.setter def score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value 把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值
>>> s = Student()>>> s.score = 60 # OK，实际转化为s.set_score(60)>>> s.score # OK，实际转化为s.get_score()60>>> s.score = 9999Traceback (most recent call last): ...ValueError: score must between 0 ~ 100!
最经典的地方是对于私有变量的存储 , 例如密码
class User(Base): ''' 模型属性设置 ''' id = Column(Integer, primary_key=True) nickname = Column(String(24), nullable=False) _password = Column('password',String(64)) @property def password(self): #加上 @property类似将其变为getattr return self._password @password.setter #负责生成哈希加密 def password(self,raw): self._password = generate_password_hash(raw) @property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值,因此@password.setter负责生成hash密文并设置给私有属性self._password,通过调用 xxx.password就可获取值
hasattr(object, name)
判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。getattr(object, name[,default])
获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。
需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址.setattr(object, name, values)
>>> hasattr(t, "name") #判断对象有name属性True>>> hasattr(t, "run") #判断对象有run方法True>>> class test():... name="xiaohua"... def run(self):... return "HelloWord"...>>> t=test()>>> getattr(t, "name") #获取name属性，存在就打印出来。'xiaohua'>>> getattr(t, "run") #获取run方法，存在就打印出方法的内存地址。>>>> getattr(t, "age") #获取一个不存在的属性。Traceback (most recent call last): File " ", line 1, in AttributeError: test instance has no attribute 'age'>>> getattr(t, "age","18") #若属性不存在，返回一个默认值'18'>>>>>> hasattr(t, "age") #判断属性是否存在False>>> setattr(t, "age", "18") #为属相赋值，并没有返回值>>> hasattr(t, "age") #属性存在了True
例如我们有需求保存用户数据
user = User()user.name = form.name.datauser.phone_number = form.name.data....
实际应用中常常综合用来判断类实例对象是否含有某属性值 , 存在就获取 ,不存在就设置
#attrs_dict以字典的形式存储了用户的信息def set_attrs(self, attrs_dict): for key, value in attrs_dict.items(): #判断用户是否含有该属性 if hasattr(self, key) and key != 'id': #设置属性值 setattr(self, key, value)
转载地址：http://fghga.baihongyu.com/