python算法之使用列表

python算法之使用列表

基本用法

car = ['audi','bmw','benchi','lingzhi']

• 创建数字列表

  numbers = list(range(1,4))
  >>> print(numbers)
  [1, 2, 3]
  

• 访问列表中的值

  car = ['audi','bmw','benchi','lingzhi']
  >>> print(car[0].title())
  Audi
  >>> print(car[2].title())
  Benchi
  

  #title()方法可获取任何列表元素，并将首字母大写

  list1 = ['Google','baidu','1997','2000']
  list2 = [1,2,3,4,5,6,7]
  >>> print("list1[0]:",list1[0])
  list1[0]: Google
  >>> print("list2[0]:",list2[1:5])
  list2[0]: [2, 3, 4, 5]
  

  #索引从0开始，例如索引为0表示第一个，索引为1表示第二个；索引区间一般都是左闭右开，例如[1,5]表示从索引1到索引4，即第二个到第5个。

  
  

删除重复元素并保持顺序不变

如果序列中保存的元素时可散列的（hashable）,那么去重的功能可以用集合和生成器来实现。如下例：

def dedupe(items):
    seen = set()        #创建一个空集合
    for item in items:
		if item not in seen:
            yield item
            seen.add(item)   #像集合中添加元素
            
if __name__ == '__main__':
    a = [5,5,2,1,9,1,5,10]
    print(a)
    print(list(dedupe(a)))
#输出
'''
[5, 5, 2, 1, 9, 1, 5, 10]
[5, 2, 1, 9, 10]
'''

关于yield其实就相当于return，只不过有yield的存在就是一个生成器而不是函数。详细请参考文章传送门

关于集合：集合中的元素不会重复且没有顺序。集合的基本用途有成员测试和消除重复的条目。集合对象还支持并集、 交集、 差和对称差等数学运算。花大括号或 set()函数可以用于创建集合。注意： 若要创建一个空集必须使用set()，而不能用 {}；后者将创建一个空的字典。

关于散列：如果一个对象是可散列的，那么它的生存期内必须是不可变的。在python中整数，浮点数，字符串和元组都是不可变的，即是可散列的。

• 若在不可散列的对象序列中

  在下面的列表a中，元素为字典，是不可散列的。

  思路：将不可散列的转换为可散列的然后再操作。

def buha(items, key=None):
    seen = set()
    for item in items:
        val = item if key is None else key(item)
        if val not in seen:
            yield item
            seen.add(val)
            
if __name__ == '__main__':
    a = [
        {'x':2, 'y':3},
        {'x':1, 'y':4},
        {'x':2, 'y':3},
        {'x':2, 'y':3},
        {'x':10, 'y':15}
    ]
    print(a)
    print(list(buha(a, key=lambda a: (a['x'],a['y']))))
    #lambda函数将{'x':2, 'y':3}转化为(2,3)可散列对象
    #输出
    '''
    [{'x': 2, 'y': 3}, {'x': 1, 'y': 4}, {'x': 2, 'y': 3}, {'x': 2, 'y': 3}, {'x': 10, 'y': 15}]
[{'x': 2, 'y': 3}, {'x': 1, 'y': 4}, {'x': 10, 'y': 15}]
    '''

找出列表中出现次数最多的元素

使用collections模块中的Counter类中的most_common()方法就可实现

from collections import Counter
words = [
   'look','into','my','AAA','look','my','AAA','the','look','AAA','my','into',
    'the'
]
word_counts = Counter(words)  #Counter类统计各元素出现的次数
top_three = word_counts.most_common(3)  #most_common(3)方法返回出现最多的三个元素
print(word_counts)
print(top_three)
#输出
'''
Counter({'look': 3, 'my': 3, 'AAA': 3, 'into': 2, 'the': 2})
[('look', 3), ('my', 3), ('AAA', 3)]
'''

排序类定义的示例

from operator import attrgetter
class User:
    def __init__(self, user_id):
        self.user_id = user_id
    def __repr__(self):
        return 'User({})'.format(self.user_id)
 #原来的顺序
users = [User(19), User(17), User(18)]
print(users)

#根据user_id顺序
print(sorted(users, key=lambda u:u.user_id))  #使用lambda函数
print(sorted(users, key=attrgetter('user_id'))) #使用operator.attrgetter()内置函数

#输出
'''
[User(19), User(17), User(18)]
[User(17), User(18), User(19)]
[User(17), User(18), User(19)]
'''

关于sorted()

sorted(iterable, key=None, reverse=False)  
'''
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
'''

使用列表推导式

列表推导式是一种简化代码的优美方法，能够非常简洁地构造一个新列表，只需要用一个简洁的表达式即可对得到的元素进行转换变形。

语法格式如下：

variable = [out_exp_res for out_exp in input_list if out_exp==2]
'''
out_exp_res: 列表生成元素表达式，可以是有返回值的函数
for out_exp in input_list: 迭代input_list, 将out_exp传入out_exp_res表达式中
if out_exp==2: 判断根据条件可以过滤那些值
'''

示例：创建一个由1到10的平方列表

#传统
squares = []
for x in range(10):
    squares.append(x**2)
print(squares)

#简洁
exmple = [i**2 for i in range(1,11)]
print(exmple)
'''
输出
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
'''

示例：输出30以内能整除3的整数

#传统
squares = []
for x in range(30):
    if x%3==0:
        squares.append(x)
print(squares)

#简洁
exmple = [i for i in range(30) if i%3==0]  #或者i%3 is 0
print(exmple)
'''
输出
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
'''

示例：输出30以内能整除3的整数的平方

#可以使用函数
def squared(x):
    return x*x
multiples = [squared(i) for i in range(30) if i%3 is 0]
print(multiples)

#当然也可以更简洁一点
exmple = [i**2 for i in range(30) if i%3 is 0]
print(exmple)
'''
输出
[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]
'''

• 筛选列表中的数据

  mylist = [1,4,-5,10,-7,2,3,-1]
  #所有正值
  zheng = [n for n in mylist if n>0]
  print(zheng)
  
  #所有负值
  fu = [n for n in mylist if n<0]
  print(fu)
  
  '''
  输出
  [1, 4, 10, 2, 3]
  [-5, -7, -1]
  '''
  

• 如果筛选过程中涉及到异常处理，或其他一些复杂的细节时，可以考虑将代码单独放在一个函数中。

  values = ['1','2','-3','-','4','N/A','5']
  def is_int(val):
      try:
          x = int(val)
          return True
      except ValueError:
          return False
  ivals = list(filter(is_int, values))
  print(ivals)
  '''
  输出
  ['1', '2', '-3', '4', '5']
  '''
  

  #filter函数用于过滤序列。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

  
  

命名切片

使用slice()函数可以实现切片对象，能够在切片操作函数中实现参数传递功能，可以被用在任何允许进行切片操作的地方。

class slice(stop)
class slice(start, stop[,step])
'''
star 起始位置
stop 结束位置
step 步长
'''

示例：

items = [0, 1, 2, 3, 4, 5, 6]
a = slice(2,4)
print(items[2:4])  #[2,3]
print(items[a])      #[2,3]
items[a] = [10, 11]  
print(items)  #[0, 1, 10, 11, 4, 5, 6]
print(a.start)  #2
print(a.stop)  #3
print(a.step)   #None
s = 'HelloWorld'
print(a.indices(len(s)))  #(2, 4, 1)
for i in range(*a.indices(len(s))):  
    # *号的作用是将可迭代序列拆开，作为函数的实参
    #在这里就是将元组(2, 4, 1)拆成2,4,1
	print(s[i])   #l  #l

indices(len)函数其返回值为三个整型数组成的元组；这些数分别为切片的 start 和 stop 索引号以及 step 步长值。当len大于等于stop时返回(start, stop, step)，当len小于stop时返回(start, len, step).

关于python中的*,参考文章传送门