Python知识点积累

1 解析式

基本语法

[expression for iter_val in iterable]
[expression for iter_val in iterable if cond_expr]

列表解析式

将 1-10 每个数乘以 2 放入一个列表：

>>> li = [i*2 for i in range(1, 11)]
>>> print(li)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

列表解析式还支持添加筛选条件，例如筛选出 i*2>10 的数：

>>> li = [i*2 for i in range(1, 11) if i*2 > 10]
>>> print(li)
[12, 14, 16, 18, 20]

嵌套循环也可以转换成列表解析式

>>> li1 = ['A', 'B', 'C']
>>> li2 = ['1', '2', '3']
>>> li3 = [(m,n) for m in li1 for n in li2]
>>> print(li3)
[('A', '1'), ('A', '2'), ('A', '3'), ('B', '1'), ('B', '2'), ('B', '3'), ('C', '1'), ('C', '2'), ('C', '3')]

字典解析式

>>> a = {'language1':'python', 'language2':'java','language3':'c'}
>>> b = {key: value for key, value in a.items() if key == 'language1'}
>>> print(b)
{'language1': 'python'}

集合解析式

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> b = {i for i in a if i > 5}
>>> print(b)
{6, 7, 8, 9, 10}

2 [{} for i in range(9)]和[{}] * 9的区别

rows = [{}] * 9
columns = [{} for i in range(9)]

初始化都是：[{}, {}, {}, {}, {}, {}, {}, {}, {}]，但是在取单个字典赋值的时候发现竟然不一样，前一个 * 9 是把{}这个对象复制了9次，更改值的时候，每个被复制的对象也会跟随更改

 # 两种不同的方式，在list中初始化多个字典
rows = [{}] * 9  # [{}, {}, {}, {}, {}, {}, {}, {}, {}]
columns = [{} for i in range(9)]  # [{}, {}, {}, {}, {}, {}, {}, {}, {}]
print(rows)
print(columns)
# 造成这样的结果是因为两者的初始化不一样
rows[0][0] = 1  # 每一个字典都加入了
columns[0][0] = 1  # 只是一个字典中加入了，
print(rows)  # [{0: 1}, {0: 1}, {0: 1}, {0: 1}, {0: 1}, {0: 1}, {0: 1}, {0: 1}, {0: 1}]
print(columns)  # [{0: 1}, {}, {}, {}, {}, {}, {}, {}, {}]

3 range() 函数用法

函数语法

range(start, stop[, step])

参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
>>>x = 'runoob'
>>> for i in range(len(x)) :
...     print(x[i])
... 
r
u
n
o
o
b

4 字典(Dictionary) get()方法

Python 字典(Dictionary) get() 函数返回指定键的值。

get()方法语法

dict.get(key, default=None)

参数
key – 字典中要查找的键。
default – 如果指定键的值不存在时，返回该默认值。
返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。

>>>dict = {'Name': 'Runoob', 'Age': 27}
>>>print "Value : %s" %  dict.get('Age')
Value : 27
>>>print "Value : %s" %  dict.get('Sex', "Not Available")
Value : Not Available

5 取余问题(%)详解

python的的余数是按照整除向下取整（//）得到的商来计算的。取余问题主要分为 ：正数与正数，负数与负数，正数与负数 ，0，负数与正数。

取余的公式：余数=被除数-除数×商

正数/正数

大数/小数： 整除向下取整得商是1，所以余数为 9-(7×1)=2

>>> print(9/7)
1.2857142857142858
>>> print(9%7)
2

小数/大数: 整除向下取整得商是0，只要正数与正数是小数/大数 的，商都是0 ，所以余数是他本身

>>> print(7/9)
0.7777777777777778
>>> print(7%9)
7

负数/负数

大数/小数： 因为负负得正，所以整除得出的就是 9//7的值为1，所以余数为 -9-(-7)=-2

>>> print(-9//-7)
1
>>> print(-9%-7)
-2

大数/小数： 只要在负数与负数相除中是大数/小数 的，商都是0 ，所以余数是他本身

>>> print(-7//-9)
0
>>> print(-7%-9)
-7

由于0不能做被除数，所以无论0除以任何数(0除外)的商和余数都为0

>>> print(0//9)
0
>>> print(0%9)
0

负数/正数

因为-7/9=-0.77… ，向下取整，所以整除的值为-1，而python中取余是按照整除的商计算的，所以余数为 -7-9×(-1)=2

>>> print(-7//9)
-1
>>> print(-7%9)
2

同样的 -9/7=-1.285… 所以整除的值为-2，余数 -9-7×(-2)=5

>>> print(-9//7)
-2
>>> print(-9%7)
5

正数/负数

因为 7/-9=-0.77… 所以整除的值为-1，余数 7-[-9×(-1)]=-2

>>> print(7//-9)
-1
>>> print(7%-9)
-2

同样的 9/-7=-1.285… 所以整除的值为-2，余数 9-[-7×(-2)]=-5

>>> print(9//-7)
-2
>>> print(9%-7)
-5

注意：单斜杠（/）除法是精确除法，不会向下取整，被除数和除数有负数，结果就为负，负负为正

>>> print(7/9)
0.7777777777777778
>>> print(-7/9)
-0.7777777777777778
>>> print(7/-9)
-0.7777777777777778
>>> print(-7/-9)
0.7777777777777778

>>> print(9/7)
1.2857142857142858
>>> print(-9/7)
-1.2857142857142858
>>> print(9/-7)
-1.2857142857142858
>>> print(-9/-7)
1.2857142857142858

6 divmod() 函数

python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)

函数语法

divmod(a, b)

参数说明：
a – 数字
b – 数字

>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

7 collections模块的Counter类

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）

Counter类创建

>>> collections.Counter()   # 创建一个空的Counter类
Counter()
>>> collections.Counter('gallahad')   # 从一个可iterable对象（list、tuple、dict、字符串等）创建
Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1})
>>> collections.Counter({'a': 4, 'b': 2})  # 从一个字典对象创建
Counter({'a': 4, 'b': 2})
>>> collections.Counter(a=4, b=2)  # 从一组键值对创建
Counter({'a': 4, 'b': 2})

计数值的访问与缺失的键

当所访问的键不存在时，返回0，而不是KeyError；否则返回它的计数

>>> c = Counter("abcdefgab")
>>> c["a"]
2
>>> c["c"]
1
>>> c["h"]
0

计数器的更新（update和subtract）

可以使用一个iterable对象或者另一个Counter对象来更新键值

>>> c = Counter('which')
>>> c.update('witch') # 使用另一个iterable对象更新
>>> c['h']
3
>>> d = Counter('watch')
>>> c.update(d) # 使用另一个Counter对象更新
>>> c['h']
4 

>>> c = Counter('which')
>>> c.subtract('witch') # 使用另一个iterable对象更新
>>> c['h']
1
>>> d = Counter('watch')
>>> c.subtract(d) # 使用另一个Counter对象更新
>>> c['a']
-1 

键的删除

当计数值为0时，并不意味着元素被删除，删除元素应当使用del

>>> c = Counter("abcdcba")
>>> c
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
>>> c["b"] = 0
>>> c
Counter({'a': 2, 'c': 2, 'd': 1, 'b': 0})
>>> del c["a"]
>>> c
Counter({'c': 2, 'b': 2, 'd': 1})

elements()

返回一个迭代器。元素被重复了多少次，在该迭代器中就包含多少个该元素。所有元素按照字母序排序，个数小于1的元素不被包含。

>>> c = collections.Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

most_common(n)

返回一个TopN列表。如果n没有被指定，则返回所有元素。当多个元素计数值相同时，按照字母序排列

>>> c = Counter('abracadabra')
>>> c.most_common()
[('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)]
>>> c.most_common(3)
[('a', 5), ('r', 2), ('b', 2)]

算术和集合操作

+、-、&、|操作也可以用于Counter。其中&和|操作分别返回两个Counter对象各元素的最小值和最大值。需要注意的是，得到的Counter对象将删除小于1的元素

>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d # c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d # subtract（只保留正数计数的元素）
Counter({'a': 2})
>>> c & d # 交集: min(c[x], d[x])
Counter({'a': 1, 'b': 1})
>>> c | d # 并集: max(c[x], d[x])
Counter({'a': 3, 'b': 2})

常用操作

sum(c.values()) # 所有计数的总数
c.clear() # 重置Counter对象，注意不是删除
list(c) # 将c中的键转为列表
set(c) # 将c中的键转为set
dict(c) # 将c中的键值对转为字典
c.items() # 转为(elem, cnt)格式的列表
Counter(dict(list_of_pairs)) # 从(elem, cnt)格式的列表转换为Counter类对象
c.most_common()[:-n:-1] # 取出计数最少的n个元素
c += Counter() # 移除0和负值

8 enumerate() 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

语法

enumerate(sequence, [start=0])

参数
sequence – 一个序列、迭代器或其他支持迭代对象。
start – 下标起始位置

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for 循环使用 enumerate

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three

9 dict() 函数

>>>dict()   # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}

10 lower()方法

Python lower() 方法转换字符串中所有大写字符为小写，返回将字符串中所有大写字符转换为小写后生成的字符串

语法

str.lower()

>>> str = "This Is String Example....Wow!!!"
>>> print(str.lower())
this is string example....wow!!!

11 isalnum()方法

Python isalnum() 方法检测字符串是否由字母和数字组成，如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

语法

str.isalnum()

>>> str = "this2009"   # 字符中没有空格
>>> print(str.isalnum())
True
>>> str = "this is string example....wow!!!"
>>> print(str.isalnum())
False

12 join()方法

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串，返回通过指定字符连接序列中元素后生成的新字符串

语法

str.join(sequence)

参数
sequence – 要连接的元素序列

>>> str = "-";
>>> seq = ("a", "b", "c"); # 字符串序列
>>> print(str.join( seq ))
a-b-c

13 lstrip()方法

Python lstrip() 方法用于截掉字符串左边的空格或指定字符，返回截掉字符串左边的空格或指定字符后生成的新字符串

语法

str.lstrip([chars])

参数
chars --指定截取的字符

>>> str = "     this is string example....wow!!!     "
>>> print(str.lstrip())
this is string example....wow!!!
>>> str = "88888888this is string example....wow!!!8888888"
>>> print(str.lstrip('8'))
this is string example....wow!!!8888888