python基础

1.enumerate函数

用于返回(i, value)元组序列，可以跟踪当前项的序号。

1
2
for (i,value) in enumerate(tup):
    print(str(i)+":"+value)

2.sorted函数

1
2
3
4
5
In : sorted([7, 1, 2, 6, 0, 3, 2])
Out: [0, 1, 2, 2, 3, 6, 7]

In : sorted('horse race')#对字符串进行排序
Out: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']

sorted()函数与sort()函数不同，会返回一个排序列表，而不改变原有序列

1
2
3
4
5
6
7
8
9
10
11
in :tup1=[2,6,8,1]
    tup1.sort()
    print(tup1)
out:[1, 2, 6, 8]

in :tup1=[2,6,8,1]
    tup2=sorted(tup1)
    print(tup2)
    print(tup1)
out:[1, 2, 6, 8]
    [2, 6, 8, 1]

sort（）可以接受两个参数sort（key,reverse）

key接受的函数返回值，表示此元素的权值，sort将按照权值大小进行排序

1
2
3
4
5
6
7
in: x=[8,9,0,7,4,5,1,2,3,6]
    def size(a):
        x=10-int(a)
        return x
    x.sort(key=size)
    print(x)
out:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

reverse接受的是一个bool类型的值 (Ture or False),表示是否颠倒排列顺序,一般默认的是False

1
2
3
4
in :x=[8,9,0,7,4,5,1,2,3,6]
    x.sort(reverse=True)
    print(x)
out:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

sort根据关键字排序

1
2
3
4
in :l = [[1,2,3],[2,2,1],[2,1,3]]
    l.sort(key = lambda x: (x[0],-x[1]))
    print(l)
out:[[1, 2, 3], [2, 2, 1], [2, 1, 3]]

注：其中key表示按第几个关键字排序，lambda x:后()中的元素表示了关键字的优先级（由高至低），x[0]表示按第一个关键词的升序排列，-x[1]表示按第二个关键词的降序排列

3.zip函数

zip可以将多个列表、元组或其它序列成对组合成一个元组列表：

1
2
3
4
5
In :tup1=1,2,3
    tup2='a','b','c'
    ziped=zip(tup1,tup2)
    list(ziped)
out:[(1, 'a'), (2, 'b'), (3, 'c')]

处理任意多的序列，元素的个数取决于最短的序列

1
2
3
4
5
6
In :tup1=1,2,3
    tup2='a','b','c'
    tup3=False,True
    ziped=zip(tup1,tup2,tup3)
    list(ziped)
out:[(1, 'a', False), (2, 'b', True)]

（1）zip函数的常见用法：同时迭代多个序列

1
2
3
4
5
6
7
in :tup1=1,2,3
    tup2='a','b','c'
    for i,(value1,value2) in enumerate(zip(tup1,tup2)):
         print('{0}:{1},{2}'.format(i,value1,value2))
out:0:1,a
    1:2,b
    2:3,c

（2）zip函数的常见用法:解压序列

1
2
3
4
5
6
in :pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),('Schilling', 'Curt')]
    first_names, last_names = zip(*pitchers)
    print(first_names)
    print(last_names)
out:('Nolan', 'Roger', 'Schilling')
    ('Ryan', 'Clemens', 'Curt')

4.reversed函数

用于从后向前迭代序列

1
2
3
4
in :tup = tuple('string')
    for (i,value) in enumerate(reversed(tup)):#从后向前迭代元组
        print(str(i)+":"+value,end=' ')
out:0:g 1:n 2:i 3:r 4:t 5:s

5.匿名（lambda）函数

由单条语句组成，该语句的结果就是返回值。

1
2
3
4
5
6
7
8
9
10
11
in :def apply_to_list(some_list, f):
        return [f(x) for x in some_list]

    ints = [4, 0, 1, 5, 6]
    apply_to_list(ints, lambda x: x * 2)#':'前为参数,':'后为运算表达式
out:[8, 0, 2, 10, 12]

in :strings = ['foo', 'card', 'bar', 'aaaa', 'abab']
    strings.sort(key=lambda x: len(set(list(x))))#根据不同字母的数量，对strings排序
    print(strings)
out:['aaaa', 'foo', 'abab', 'bar', 'card']

6.迭代器

可迭代对象:可迭代的对象要有_iter_()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#常见的可迭代对象
iterables=[
    "123",#字符串
    [1,2,3],#列表
    (1,2,3),#元组
    {1:'a',2:'b'},#字典
    {1,2,3},#集合
]
for iterable in iterables:
    print(type(iterable))
    for x in iterable:
        print(x,end=',')
    print('')

out:
<class 'str'>
1,2,3,
<class 'list'>
1,2,3,
<class 'tuple'>
1,2,3,
<class 'dict'>
1,2,
<class 'set'>
1,2,3,

迭代器：有_next()方法的可迭代对象，即迭代器既有_iter\()方法，又有_next_()方法。

1
2
3
4
5
6
7
#列表不是迭代器
from collections.abc import Iterator
lst=[1,2,3]
isinstance(lst,Iterator)

out:
False
1
2
3
4
5
6
#iter(lst)是迭代器
x=iter(lst)
isinstance(x,Iterator)

out:
True
1
2
3
4
5
6
7
8
in: x.__next__()
out:1

in: x.__next__()
out:2

in: next(x)
out:3

自定义迭代器：为类添加_iter_()方法和_next_()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#定义一个将字符串反序输出的迭代器
class ReverseIterator:
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index <= 0:
            raise StopIteration
        self.index -= 1
        return self.data[self.index]

r=ReverseIterator('abc')
for i in r:
    print(i)

out:
c
b
a

7.生成器

生成器：一种特殊的迭代器,通过函数的方式来定义，使用关键字yield来返回值，而不是使用return。当生成器函数被调用时，它并不会立即执行函数体，而是返回一个生成器对象，该对象可以用于逐步迭代产生值。

1
2
3
4
5
6
7
8
9
10
11
def countdown(n):
    while n > 0:
        yield n
        n -= 1

# 使用生成器进行迭代
for num in countdown(5):
    print(num, end=" ")
   
out:
5 4 3 2 1

注：yield语句右边的对象作为next()的返回值，生成器在yield所在的位置暂停，当再次使用next()时继续从该位置继续运行。

8.collections.Counter

collections.Counter:是Python标准库中的一个类，用于计数可哈希对象（通常是元素或元素组成的集合）的出现次数。

collections.Counter是一个字典的子类，提供了方便的计数功能，可以用于各种计数和统计场景

8.1 创建计数器

可以通过传入可迭代对象（如列表、元组、字符串等）或字典来创建计数器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from collections import Counter

# 通过列表创建计数器
a= Counter(['apple', 'orange', 'apple', 'banana', 'apple'])

# 通过字符串创建计数器
b = Counter('hello')

# 通过字典创建计数器
c = Counter({'apple': 3, 'orange': 2, 'banana': 1})
a,b,c

out:
(Counter({'apple': 3, 'orange': 1, 'banana': 1}),
 Counter({'h': 1, 'e': 1, 'l': 2, 'o': 1}),
 Counter({'apple': 3, 'orange': 2, 'banana': 1}))

8.2 计数元素的出现次数

可以使用elements()方法获取计数器中所有元素的迭代器，也可以使用普通的字典语法或get()方法获取指定元素的出现次数。

1
2
3
4
5
6
7
c = Counter('abracadabra')
print(c)  # Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

print(c['a'])  # 5
print(c.get('b'))  # 2

elements = list(c.elements())  # ['a', 'a', 'a', 'a', 'a', 'b', 'b', 'r', 'r', 'c', 'd']

8.3 获取最常见的元素

可以使用most_common()方法获取计数器中出现频率最高的元素。该方法返回一个列表，其中每个元素是一个元组，包含元素和对应的计数。

1
2
3
4
5
c = Counter('abracadabra')
print(c.most_common(2))

out:
[('a', 5), ('b', 2)]

8.4 更新计数器

可以使用update()方法将另一个计数器、可迭代对象或字典的元素合并到当前计数器中。

1
2
3
4
5
c1 = Counter('abracadabra')
c2 = Counter('alakazam')

c1.update(c2)  # 合并c2中的计数到c1中
print(c1)  # Counter({'a': 8, 'b': 2, 'r': 2, 'l': 1, 'k': 1, 'z': 1, 'm': 1})