python基础1

*args: 0个或多个可选的参数
**kw: 0个或多个关键字参数
if name == ‘main’:的作用
一个python文件通常有两种使用方法，第一是作为脚本直接执行，第二是 import 到其他的 python 脚本中被调用（模块重用）执行。因此 if name == ‘main’: 的作用就是控制这两种情况执行代码的过程，在 if name == ‘main’: 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而 import 到其他脚本中是不会被执行的。
if name == ‘main’:的运行原理
每个python模块（python文件，也就是此处的 test.py 和 import_test.py）都包含内置的变量 name，当该模块被直接执行的时候，name 等于文件名（包含后缀 .py ）；如果该模块 import 到其他模块中，则该模块的 name 等于模块名称（不包含后缀.py）。

而 “main” 始终指当前执行模块的名称（包含后缀.py）。进而当模块被直接执行时，name == ‘main’ 结果为真。

python类中定义的函数称为方法，init()方法本质也是一个函数。这个函数的作用是初始化实例后的对象。
这里的__init__()方法在类实例化是被自动调用。若类定义了__init__()方法，类的实例化操作会自动调用__init__方法。
init__方法可以有参数，参数通过__init()传递到类的实例化操作上。self代表的是类的实例，而非类。
类的方法和普通函数的区别只有一个，类的方法必须有一个额外的第一个参数名称，按照惯例它的名称是self。

optional：用于函数中指定参数类型并避免报错。
Typing.Optional类
可选类型，作用几乎和带默认值的参数等价，不同的是使用Optional会告诉你的IDE或者框架：这个参数除了给定的默认值外还可以是None，而且使用有些静态检查工具如mypy时，对 a: int =None这样类似的声明可能会提示报错，但使用a :Optional[int] = None不会

set持有一系列元素，并且set元素没有重复，并且无序
for _ in range®] 中_的作用，相当于一个普通变量，只是不取值，只是循环。
在python中二维矩阵的定义：
1、matrix = [[‘’] * col for i in range(row)]
2、matrix = [[‘’ for _ in range(size)] for _ in range(size)]

enumerate()函数
enumerate是枚举、列举的意思
如果对于一个列表，既要遍历索引又要遍历元素时，首先可以这样写
list1 = [“这”, “是”, “一个”, “测试”]
for i in range (len(list1)):
print i ,list1[i]
上述方法有些累赘，利用enumerate()会更加直接和优化：
list1 = [“这”, “是”, “一个”, “测试”]
for index, item in enumerate(list1):
print index, item
0 这
1 是
2 一个
3 测试
enumerate还可以接收第二个参数，用于指定索引起始值，如：
list1 = [“这”, “是”, “一个”, “测试”]
for index, item in enumerate(list1, 1):
print index, item
1 这
2 是
3 一个
4 测试

python常用的数据结构
链表

head = ListNode()
head.next = ListNode(val)
#在链表head前加入哑结点
dump = ListNode(0, head)
1
2
3
4

集合
用于存放不重复的数

sets = set()
sets.add(val1)
sets.remove(val2)
#判断这个数是否在集合中：
s[right + 1] not in sets
1
2
3
4
5

附：也可以用 seen = {1} (需要放入元素)直接创建集合
注意：**在集合中查找元素的效率比列表高很多！**我有一道题将List改成Set之后，时间没有超过限制过了！
字典
又叫哈希表

hashtable = dict()
#直接赋值
hashtable[nums[i]] = i
#查字典
hashtable.get(键)
#遍历完排序！
res =[(x,y) for x,y in hashset.items()]
res.sort()
1
2
3
4
5
6
7
8

当然也有默认字典类，这样不会出现找不到的情况

from collections import defaultdict
res = defaultdict(int/list)
1
2

构造参数决定了缺省值是什么，int就是0，list就是空列表[]
字符串
刷题时会用 [ ] 存储字符串，因为[ ]可以使用append等函数。
如[‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’]
最后用

''.join(a)
1

将序列的元素结合起来，得到一个完整的字符串’ABCDEF’
如果要反向连接，我们使用：

"".join(a[::-1])
1

字符串对应的ASCALL码：

ord(s)
1

矩阵
一个初始化矩阵的方法

mat = [[''] * c for _ in range(r)]
1

遍历矩阵元素的方法

''.join(ch for row in mat for ch in row if ch)
1

如果将矩阵A的值赋值给矩阵B，正确和踩雷的做法是：

matrix_B[:] = matrix_A   #√
matrix_B = matrix_A #×
1
2

反转矩阵的行列值

zip(*matrix)
1

举个例子 原矩阵是[[1,2,3],[4,5,6],[7,8,9]], zip*是反向拆开，结果变为[[1,4,7],[2,5,8],[3,6,9]]
顺带一提，还有另外一种用法：zip(a, b)
需要：

import heapq #载入heap库，heap指的是最小堆
数组转换为堆（堆仍然用 [ … ] 表示）：

1
2
3
4

heap = [1,3,4,2,6,8,9]
heapq.heapify(heap)
# heap = [1,2,4,3,6,8,9]

增加元素/删除元素（最小值）：

heapq.heappush(heap, 2)
heapq.heappop(heap)

1
2
3
4
5
6
7
8
9

栈/队列
栈和队列不需要特地申明。使用[ ]就可以了，然后直接调用append、pop即可。

A = []
A.append(1)
A.pop() #栈！
A.pop(0) #队列！

但也有一种比较标准的用法，采用的是python的collections库，是一个双端队列，可以进行各种操作。

a = collections.deque()
a.append(b)  #右边进（正常）
a.appendleft(c) #左边进
a.pop() #右边出（类似栈）
a.popleft() #左边进（类似队列） 

1
2
3
4
5
6
7
8
9
10
11
12
13

排序函数
以[ ]为例，如果List里存放的是那种不好排序的元素，我们可以用排序函数定义。
假如List存放的是小List，[[1, 2], [3, 8], [2, 6]]

intervals.sort(key=lambda x: x[0])
1
这样排序看的是每个元素的第一个元素，有关lambda的用法还是得熟练一下。
还有一点要注意！使用sort()时不要使用a = a.sort()! **直接a.sort()**就好了！

枚举

for i, num in enumerate(nums)
1

其中i是索引，num是值

排序集合
一个自动由小到大排序的集合，多元组的时候默认先排序第一个，第一个相同再排序第二个

from sortedcontainers import SortedSet
a = SortedSet()
self.cs = defaultdict(SortedSet) 
cs[0].add(1,'tiger')
cs[0].remove(1,'tiger')
1
2
3
4
5

第二步好秀

计数
对某一个数组的数字计数。
假设a = [1, 2, 1, 1, 4]
调用 a.count(a[0]) 得到3
还有一种比较正式的：

from collections import Counter
a = [1, 2, 1, 1, 4]
r = Counter(a)
# 遍历法一：
for cnt in r.values():
	print(cnt)
#遍历法二：
for i, j in r.items():
	print(j)

1
2
3
4
5
6
7
8
9
10

从键盘读数据

import sys
print('Please input a number:')
n = int(sys.stdin.readline().strip('\n')) #strip('\n')表示以\n分隔，否则输出是“字符串+\n”的形式
print('Please input some numbers:')
sn = sys.stdin.readline().strip()#若是多输入，strip()默认是以空格分隔，返回一个包含多个字符串的list。
sn = list(map(int,sn.split())) #如果要强制转换成int等类型，可以调用map()函数。
print(n)
print(sn,'\n')
1
2
3
4
5
6
7
8

你可能会问，为什么map前还要加list()，它本来就是list啊。问题在于python3.x map函数返回的是迭代器，就是得再加一个list。

max
max函数，如果参数是一维列表，返回的是一个数；如果是二维的，则返回一维（行）列表

最大公约数
import math
res = math.gcd(12,3)