python 语法糖【不断更新】

最新推荐文章于 2025-03-15 16:09:26 发布

linzch3

最新推荐文章于 2025-03-15 16:09:26 发布

阅读量2.9k

点赞数 2

分类专栏： python 文章标签： python

本文链接：https://blog.youkuaiyun.com/linzch3/article/details/66475244

版权

python 专栏收录该内容

23 篇文章

订阅专栏

这篇博客介绍了Python的一些语法糖技巧，包括使用列表推导式、itertools、functools.reduce以及内置函数求a和b的最大值、转换1*n的列表、按多个属性排序列表以及使用collection模块计算列表中元素出现的次数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.得到a和b两个数的最大值

solution:

 c = [b,a][a>b]

测试：

>>> a=1
>>> b=2
>>> c=[b,a][a>b]
>>> c
2

2.假设现在给定了一个list:

a = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]

问如何将其转化成：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

其实就是将所有数据都拿出来组成一个1*n的list。

solution 1: 使用列表表达式

>>> a = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
>>> [i for k in a for i in k]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

solution 2: 使用itertools的chain函数

>>> a = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
>>> import itertools
>>> list(itertools.chain(*a))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

solution 3: 使用functools的reduce函数

>>> a = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
>>>from functools import reduce
>>> reduce(lambda x,y:x+y,a)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

关于reduce函数，可参考：

Python中的reduce
python中的reduce内建函数是一个二元操作函数，他用来将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 func()（必须是一个二元操作函数）先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，最后得到一个结果。
如：

    def myadd(x,y):  
        return x+y  
    sum=reduce(myadd,(1,2,3,4,5,6,7))  
    print sum

结果就是输出1+2+3+4+5+6+7的结果即28

当然，也可以用lambda的方法，更为简单：

    sum=reduce(lambda x,y:x+y,(1,2,3,4,5,6,7))  
    print sum

在python 3.0.0.0以后, reduce已经不在built-in function里了, 要用它就得

from functools import reduce.

solution 4: 使用sum函数

>>> a = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
>>> sum(a,[])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

3.先按元素的一个属性排序、再按另一个属性来对一个 list 排序

举例：比如一个学校的人站成一行，需要年级从小到大，并且每个年级里从矮到高。

可以这样：

[P1, P2, P3, ...Pn].sort(key=lambda x: (x.grade, x.height))

把需要排序的属性拿出来作为一个 tuple，主要的放前面，次要的放后面。

因为 Python 在比较 tuple 大小的时候正是按字典序进行的。如果需要对更多属性排序，继续添加进 tuple 即可。

举例：假设有一个list:

lst= [1, -2, 10, -12, -4, -5, 9, 2]

我们希望把正的放前面，负的放后面，并且分别按绝对值从小到大。即输出：

[1, 2, 9, 10, -2, -4, -5, -12]

最简单的方法是：

lst.sort(key=lambda x: (x < 0, abs(x)))

注：该例参考 laike9m的回答

4.计算下面的两个list中各个元素出现的次数：

a = [1,1,1,1,1,2,3,3,3,4,4,4,4,5,6,6,6,7,8]
names = ['alice','bob','bob','candice','candice']

solution ：

>>> a = [1,1,1,1,1,2,3,3,3,4,4,4,4,5,6,6,6,7,8]
>>> from collections import Counter
>>> Counter(a)
Counter({1: 5, 4: 4, 3: 3, 6: 3, 2: 1, 5: 1, 7: 1, 8: 1})
>>> names = ['alice','bob','bob','candice','candice']
>>> Counter(names)
Counter({'bob': 2, 'candice': 2, 'alice': 1})

# -*- coding:utf-8 -*-

'''print 多个相同字符'''
print('#' * 40)

''' 翻转字符串'''
print 'The Zen of Python, by Tim Peters'[::-1]#sreteP miT yb ,nohtyP fo neZ ehT

'''利用元组赋值'''
a=1
b=2
a,b=b,a
print a,b#2 1

'''读字典时避免判断键值是否存在'''
d = { 'key': 'value' }
#if 'key' in d: print d['key']
#else: print 'not find'
print d.get('key', 'not find')   #效果同上

'''实现三元式'''
n=1
#if n >= 0: print 'positive'
#else: print 'negitive'
print (n >= 0) and 'positive' or 'negitive' #效果同上
#说明：这里的'and'和'or'相当于C中的':'和'?'的作用
# 若表达式为真了那么后面的or被短路，取到'positive'；否则，and被短路，取到'negitive'

'''千位分隔符'''
print '{:,}'.format(1234567890)#1,234,567,890

collection

# -*- coding:utf-8 -*-
###################################namedtuple###########################################
from collections import namedtuple

'''namedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。

    这样一来，我们用namedtuple可以很方便地定义一种数据类型，它具备tuple的不变性，又可以根据属性来引用，使用十分方便。

    可以验证创建的Point对象是tuple的一种子类'''

# namedtuple('名称', [属性list]):
Point = namedtuple('Point', ['x', 'y'])
p = Point(1,2)

#用属性而不是索引来引用tuple的某个元素
print( 'Point:', p.x, p.y) #1 2

#如果要用坐标和半径表示一个圆，也可以用namedtuple定义：
Circle = namedtuple('Circle', ['x', 'y', 'r'])

#####################################deque############################################
'''使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

    deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈'''
from collections import deque

q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)
'''deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。'''

#####################################defaultdict############################################
from collections import defaultdict
'''使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：'''

dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
print('dd[\'key1\'] =', dd['key1'])
print('dd[\'key2\'] =', dd['key2'])

''' 注意默认值是调用函数返回的，而函数在创建defaultdict对象时传入。

    除了在Key不存在时返回默认值，defaultdict的其他行为跟dict是完全一样的。'''


#####################################Counter############################################
'''Counter是一个简单的计数器，例如，统计字符出现的个数：'''
from collections import Counter
c = Counter()
for ch in 'programming':
    c[ch] = c[ch] + 1
print(c)
# Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})


######################################OrderedDict############################################
'''使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

    如果要保持Key的顺序，可以用OrderedDict：'''
from collections import OrderedDict

od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print  od # OrderedDict的Key是有序的  #[('a', 1), ('b', 2), ('c', 3)]

#对比
d = dict([('a', 1), ('b', 2), ('c', 3)])
print d #无序 #{'a': 1, 'c': 3, 'b': 2}
#注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序
od = OrderedDict()
od['z'] = 1
od['y'] = 2
od['x'] = 3
list(od.keys()) # 按照插入的Key的顺序返回
#['z', 'y', 'x']

datetime

# -*- coding:utf-8 -*-
from datetime import datetime
'''datetime是模块，datetime模块还包含一个datetime类，通过from datetime import datetime导入的才是datetime这个类。

    如果仅导入import datetime，则必须引用全名datetime.datetime。'''

'''获取当前日期和时间'''
now = datetime.now()  # 获取当前datetime
print(now)

'''获取指定日期和时间'''
dt = datetime(2015, 4, 19, 12, 20,12) # 用指定日期时间创建datetime
print(dt)

'''3.x 版本的python: datetime转换为timestamp'''

'''在计算机中，时间实际上是用数字表示的。我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time，

    记为0（1970年以前的时间timestamp为负数），当前时间就是相对于epoch time的秒数，称为timestamp。'''
dt.timestamp()  # 把datetime转换为timestamp
print(dt)#注意Python的timestamp是一个浮点数。如果有小数位，小数位表示毫秒数。

'''timestamp转换为datetime'''

'''注意到timestamp是一个浮点数，它没有时区的概念，而datetime是有时区的。上述转换是在timestamp和本地时间做转换。

    本地时间是指当前操作系统设定的时区'''
t = 1429417200.0
et=datetime.fromtimestamp(t)# 本地时间
print et
print(datetime.utcfromtimestamp(t)) # UTC时间

'''str转换为datetime'''

'''很多时候，用户输入的日期和时间是字符串，要处理日期和时间，首先必须把str转换为datetime。'''
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')#字符串'%Y-%m-%d %H:%M:%S'规定了日期和时间部分的格式
print(cday)

'''datetime转换为str'''
print(now.strftime('%a, %b %d %H:%M'))

'''datetime加减'''
from datetime import datetime, timedelta
now = datetime.now()

print now + timedelta(hours=10)

print now - timedelta(days=1)

print now + timedelta(days=2, hours=12)

'''本地时间转换为UTC时间'''
'''时区转换'''
#略

itertools

# -*- coding:utf-8 -*-
import itertools
'''itertools模块提供的全部是处理迭代功能的函数，它们的返回值不是list，而是Iterator，只有用for循环迭代的时候才真正计算。'''

'''count()会创建一个无限的迭代器'''
natruals = itertools.count(1)#从1开始的自然数无限序列
for n in natruals:
    print(n)
    if n >= 100:
        break

'''cycle()会把传入的一个序列无限重复下去'''
print 'cycle'
cs = itertools.cycle('ABC')
t = 10
for c in cs:
    print(c)
    t = t - 1
    if t == 0:
        break

'''repeat()负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数'''
print 'repeat'

ns = itertools.repeat('A', 3)
for n in ns:
    print(n)

'''无限序列虽然可以无限迭代下去，但是通常我们会通过takewhile()等函数根据条件判断来截取出一个有限的序列：'''
print 'takewhile'

natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
print list(ns)

'''chain()可以把一组迭代对象串联起来，形成一个更大的迭代器：'''
for c in itertools.chain('ABC', 'XYZ'):
    print(c)## 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'


'''groupby()把迭代器中相邻的重复元素挑出来放在一起：'''
for key, group in itertools.groupby('AAABBBCCAAA'):
    print(key, list(group))
'''
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
'''

'''实际上挑选规则是通过函数完成的，只要作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组的，
    而函数返回值作为组的key。如果我们要忽略大小写分组，就可以让元素'A'和'a'都返回相同的key：'''
for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
    print(key, list(group))
'''
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
'''