python字符串反转 高阶函数 @property与sorted(八)

简介: (1)字符串反转1倒序输出s = 'abcde'print(s[::-1])#输出: 'edcba'2 列表reverse()操作s = 'abcde'lt = list(s)lt.

(1)字符串反转

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)+head
res_str('abcd')
#输出: 'dcba'

(2)冒泡排序

采用循环

import numpy as np
def 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 np
def 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)

(3)高阶函数用法

map函数的用法

map : map()函数接收两个参数,一个是函数,一个是Iterablemap将传入的函数依次作用到序列的每个元素,并把结果作为新的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是一个IteratorIterator是惰性序列,因此通过list()函数让它把整个序列都计算出来并返回一个list。

reduce函数的用法

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

如果是完成字符串转数字了,那么就可以采用mapreduce组合

>>> 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过滤函数

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)

sorted函数

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实现反向排序.

(4)@property

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 = 9999
Traceback (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就可获取值

(5) setattr hasattr getattr 动态操作属性

hasattr(object, name)

判断一个对象里面是否有name属性或者name方法,返回BOOL值,有name特性返回True, 否则返回Falsegetattr(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方法,存在就打印出方法的内存地址。
<bound method test.run of <__main__.test instance at 0x0269C878>>
>>> getattr(t, "age")  #获取一个不存在的属性。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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.data
user.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)               
相关文章
|
1月前
|
Python
python sort和sorted的区别
在Python中,sort()和sorted()都是用于排序的函数,但它们之间存在一些关键的区别,这些区别主要体现在它们的应用方式、操作对象以及对原始数据的影响上。
|
1月前
|
Python
python实现字符串反转。
python实现字符串反转。
18 1
|
7月前
|
Python
97 python高级 - 属性property
97 python高级 - 属性property
30 0
|
1月前
|
Python
函数式编程与装饰器:解释什么是高阶函数,并给出几个Python内置的高阶函数示例。编写一个Python装饰器,用于记录函数执行的时间。
函数式编程与装饰器:解释什么是高阶函数,并给出几个Python内置的高阶函数示例。编写一个Python装饰器,用于记录函数执行的时间。
|
1月前
|
Python
Python中如何实现字符串反转?请提供至少两种方法。
Python中如何实现字符串反转?请提供至少两种方法。
37 3
|
5天前
|
Python
高阶函数如`map`, `filter`, `reduce`和`functools.partial`在Python中用于函数操作
【6月更文挑战第20天】高阶函数如`map`, `filter`, `reduce`和`functools.partial`在Python中用于函数操作。装饰器如`@timer`接收或返回函数,用于扩展功能,如记录执行时间。`timer`装饰器通过包裹函数并计算执行间隙展示时间消耗,如`my_function(2)`执行耗时2秒。
13 3
|
1天前
|
Python
在Python中,`map()`, `filter()` 和 `reduce()` 是函数式编程中的三个核心高阶函数。
【6月更文挑战第24天】Python的`map()`应用函数到序列元素,返回新序列;`filter()`筛选满足条件的元素,生成新序列;`reduce()`累计操作序列元素,返回单一结果。
10 3
|
1天前
|
Python
在Python中,高阶函数是指那些可以接受一个或多个函数作为参数,并返回一个新的函数的函数。
【6月更文挑战第24天】Python的高阶函数简化代码,增强可读性。示例:`map()`检查用户名合法性,如`[&quot;Alice&quot;, &quot;Bob123&quot;, &quot;Charlie!&quot;, &quot;David7890&quot;]`;`reduce()`与`lambda`结合计算阶乘,如1到10的阶乘为3628800;`filter()`找出1到100中能被3整除的数,如[3, 6, 9, ..., 99]。
6 3
|
5天前
|
数据安全/隐私保护 Python
Python装饰器是高阶函数,用于在不修改代码的情况下扩展或修改函数行为。它们提供可重用性、模块化和无侵入性的功能增强。
【6月更文挑战第20天】Python装饰器是高阶函数,用于在不修改代码的情况下扩展或修改函数行为。它们提供可重用性、模块化和无侵入性的功能增强。例如,`@simple_decorator` 包装`my_function`,在调用前后添加额外操作。装饰器还能接受参数,如`@logged(&quot;INFO&quot;, &quot;msg&quot;)`,允许动态定制功能。
12 6
|
1月前
|
数据采集 算法 Python
2024年Python最全python基础入门:高阶函数,小米面试编程题
2024年Python最全python基础入门:高阶函数,小米面试编程题