算法学习-以刷题为导向开始学习的Python知识

参考文献：

Python编程基础
Python菜鸟教程
全网最详细的Python入门基础教程
Python入门教程

笔者在学习的过程中，发现很多大佬都喜欢用Python刷题，因为Python高效的书写形式可以很方便地把我们的代码表现出来，为了能够看懂题解，我也决定汇总整理一些刷题常用需要掌握的Python知识，帮助我这种小白快速入门。

数据类型

True和False

参考Python true(真) 和 false(假)判断

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断它们不一样。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

强制类型转换

参考python怎么强制转换类型

# 整型和浮点的转换
>>> a = 1  #定义整型a
>>> b = float(a)  #将a强制转换成浮点型赋给b
>>> print(b)  
1.0
>>> print(type(b))  
<class 'float'>

# 列表和元组、集合的转换
>>> a = [1, 2, 3]  #定义列表a
>>> b = tuple(a)  #将a强制转换为元组，赋给b
>>> print(b)  
(1, 2, 3)
>>> c = set(a)  #将a强制转换为集合，赋给c
>>> d = set(b)  #将b强制转换为集合，赋给d
>>> print(c,d)
{1, 2, 3} {1, 2, 3}

# 整型、浮点型与字符串型之间的转换
>>> a = '12'  #定义字符串型a
>>> b = int(a)  #将a强制转换为整型，赋给b
>>> print(b)  
12
>>> print(type(b)) 
<class 'int'>
>>> c = float(a)  #将a强制转换为浮点型，赋给c
>>> print(c)  #打印c
12.0
>>> a = 123  #定义整型a
>>> b = str(a)  #将a强制转换为字符串型，赋给b
>>> print(b,type(b))  #打印b和b的类型
123 <class 'str'>

类型检查

参考Python isinstance()函数

# isinstance(object, classinfo)
# classinfo可以是 int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple
arg=123
isinstance(arg, int)    #输出True
isinstance(arg, str)    #输出False
isinstance(arg, string) #报错

运算符

参考Python3运算符
逻辑运算符：

x and y	# 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	(a and b) 返回 20。
x or y	# 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not x	# 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

编程语句

条件控制语句

if语句：

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

# 常用三元语句，类似于cpp中的 ？：
res1 if ... else res2

if嵌套：

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

循环语句

while循环：

n = 100
 
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))

while 循环使用 else 语句:

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

for语句：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

#enumerate遍历一维list，序号从1开始
for i, s in enumerate(list,start=1):
#enumerate遍历二维list,i代表行索引，row代表每行的值
for i, row in enumerate(list):

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 开始到 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 10
[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)
[]

函数

函数定义的格式：

def 函数名（参数列表）:
    函数体

常规的函数定义和调用：

def hello() :
    print("Hello World!")

hello()

可以在函数里面嵌套定义函数，并且外层函数内定义的局部变量，相当于内层函数的全局变量

def outer():
    l=[1,2,3,4,5]
    ans=[]
    def dfs(i):
        if i==3:
            ans.append(i)
            return
        dfs(i+1)
    # 内部调用
    dfs(0)
    print(ans)
 
outer() #[3]

lambda表达式

Python中的lambda 表达式，又称匿名函数，常用来表示内部仅包含 1 行表达式的函数。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。这不同于Java中的lambda表达式用于表示函数式接口实现类的匿名对象。
其语法格式如下：

方法名 = lambda 参数列表 : 表达式

例子如：

def add(x, y):
    return x+ y
add = lambda x,y : x+y
print(add(1,2))

序列类型

列表list

使用[ ]创建列表，列表的数据项不需要具有相同的类型。

列表支持sname[index]的索引访问：


列表支持切片，格式如下：

sname[start : end : step]
参数说明：
sname：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），可以不指定默认为0.
end：表示切片的结束索引位置（不包括该位置），可以不指定默认为序列的长度；
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，可以不指定默认为1。如果不指定，则第二个冒号就可以省略。

脚本操作：

内置函数：

基本操作：

#末尾添加元素
list.append(a)
#末尾添加单个或多个元素
list += [1]
list += [1,2,3]
#末尾删除元素
list.pop()
---- 正是由于上面的操作，可以将list当作栈来使用
#在原来索引为i的地方加上x
list.insert(i,x)
#删除索引为i的元素
list.pop(i)
#统计某个元素在列表中出现的次数
list.count(a)
#移除list中第一个等于a的元素
list.remove(a)
# 清空列表
list.clear()
# 判断元素s是否在list中
if s in list:
# 删除特定索引上的数字
del list[i,j]
# 在list结尾加上一段序列
list.append([i:j])
# 反转列表
list.reverse() #改变原来的序列
newlist=reversed(list) # 返回一个新的list_reverseiterator
# 从列表中找出某个值第一个匹配项的索引位置
features = [1,2,3,4,5]
featureIndex=features.index(4)
print(featureIndex) //3
# 列表复制
list2=list.copy()
list2=list[:]

#enumerate遍历一维list，序号从1开始
for i, s in enumerate(list,start=1):
#enumerate遍历二维list,i代表行索引，row代表每行的值
for i, row in enumerate(list):

# 倒序遍历
for i in a[::-1]
for i in range(len(a)-1,-1,-1)
for i in reversed(a)

# 列表推导式
#[表达式 for 变量 in 列表]
# [表达式 for 变量 in 列表 if 条件]
[x**2 for x in li]
[x**2 for x in li if x>5]
[x*y for x in [1,2,3] for y in  [1,2,3]]

#二维列表定义
#固定行数，未固定每行列数
g=[[]for _ in range(k)]
#固定行列数
g=[[0 for i in range(k)] for j in range(k)]

# 索引操作
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
list[::-1] # 倒序遍历 
list[1]:  Runoob
list[-1]: Wiki
list[-2]: Taobao
list[1:-2]:  ['Runoob', 'Zhihu']
list[3:]: ["Taobao", "Wiki"]

# 直接进行切片比较
list[1:2]==list[3:4]

元组tuple

元组和列表的操作类似，只不过元组使用小括号 ( )创建，列表使用方括号 [ ]创建。

列表与元组的区别：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。有点类似于Java中的String类型，不能修改其中的值，但是可以改变变量的指向。

元组基本操作：

//创建空元组
tup1 = ()

//元组的索引访问与截取：
>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')

元组内置函数：

字典dict

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号:分割，每个对之间用逗号,分割，整个字典包括在花括号 { } 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

可以使用{ }和dict()来创建空字典。

常用操作：

# 空字典加入
dic1={}
dic2=dict()
dic1['one']=1
dic2['two']=2
# 直接声明字典
dic3={'one':1,'two':2}
pos={x:i for i,x in numerate(col)}
# 传入关键字
dic4=dict(a='a', b='b', t='t')
# 映射函数方式来构造字典
dic5=dict(zip(['one', 'two', 'three'], [1, 2, 3]))
# 可迭代对象方式来构造字典
dic6=dict([('one', 1), ('two', 2), ('three', 3)])
dic7=dict((['one',1],['two',2]))

# 默认字典定义
# dict =defaultdict( factory_function),这个factory_function可以是list、set、str等等，作用是当key不存在时，返回的是工厂函数的默认值，比如list对应[ ]，str对应的是空字符串，set对应set( )，int对应0
from collections import defaultdict
dict1 = defaultdict(int)
dict2 = defaultdict(set)
dict3 = defaultdict(str)
dict4 = defaultdict(list)
dict1[2] ='two'
print(dict1[1])
print(dict2[1])
print(dict3[1])
print(dict4[1])

输出：
0
set()

[]

# 根据键获取值
dict.get(key[, value])  # value可选，如果指定键的值不存在时，返回该默认值。

# 添加键值对
a = {'数学':95}
a['语文'] = 89 #直接写
print(a)
输出：
{'数学': 95, '语文': 89}

# 修改键值对
a = {'数学': 95, '语文': 89, '英语': 90}
a['语文'] = 100
print(a)
输出：
{'数学': 95, '语文': 100, '英语': 90}

#删除键值对
a = {'数学': 95, '语文': 89, '英语': 90}
del a['语文']
del a['数学']
print(a)
输出：
{'英语': 90}

#判断是否存在键值对，主要是判断键key
a = {'数学': 95, '语文': 89, '英语': 90}
print('数学' in a) # True
print('物理' in a) # False

#遍历键值对
for key, value in student.items():

#遍历所有键
for key in student.keys():

#遍历所有值
for value in student.values():

字典基本操作参考：Python dict字典基本操作（包括添加、修改、删除键值对）

集合Set

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合
注意：创建一个空集合必须用 set() 而不是 { }，因为{ }是用来创建一个空字典。

常用操作：

# 创建集合
set1 =set()
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

#set集合的生成：
#从list、tuple转换而来，但会去掉重复元素，同时还会进行排序
>>> list = [1,1,2,3,4,5,3,1,4,6,5]
>>> s=set(list)
>>> print(s)
{1, 2, 3, 4, 5, 6}
>>> tuple = (2,3,5,6,3,5,2,5)
>>> s=set(tuple)
>>> print(s)
{2, 3, 5, 6}

#添加元素：
s.add(x)
s.update(x)
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}

#删除元素：
s.remove(x) #元素不存在会报错
s.discard(x) #元素不存在不会报错
s.pop() #对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除，效果看起来像是随机删除

#计算集合中的元素：
len(s)

#清空集合：
s.clear()

#判断元素是否在集合中存在：
x in s:
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True

# 集合运算
# 方式1
a = {1,2,3,4,5,6}
b = {3,4,5,6}
print(a & b) #交集(取相同元素)
print(a | b) #并集(取所有元素并去重)
print(a - b) #补集(把b里面存在的元素从a里面删除)
print(a ^ b) #对称补集(把a,b不重复的元素合并在一起)
print(a > b) #超集(a全包含b的话,打印T,反之打印F)
print(a < b) #子集(a被b全包含的话,打印T,反之打印F)
print(a == b) #判断元素是否相等,等于就打印T,反之打印F
print(a != b) #判断元素是否不全相等,不等打印T,反之打印F
#方式2
print(a.union(b)) #并集
print(a.intersection(b)) #交集
print(a.difference(b)) #补集
print(a.symmetric_difference(b)) #对称补集
print(a.issuperset(b)) #超集

集合基本操作参考：菜鸟教程-集合

字符和字符串

我们可以使用引号' '或 " "来创建字符串。

字符串同样支持str[index]的索引访问：

但是要注意的是，字符串只能用索引访问，而不能直接用索引对特定元素进行修改，如果要修改形成新的字符串，可以尝试用：

 listword[i]=newchar
 nextword=''.join(listword)

基本操作：

# 内容和地址比较
s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# 比较字符串的内容
print(s1 == s2, s2 == s3)    # True True
# 比较字符串的内存地址
print(s1 is s2, s2 is s3)    # False True

# 拼接和重复
s1 = 'hello' + ' ' + 'world'
print(s1)    # hello world
s2 = '!' * 3
print(s2)    # !!!
s1 += s2     # s1 = s1 + s2
print(s1)    # hello world!!!
s1 *= 2      # s1 = s1 * 2
print(s1)    # hello world!!!hello world!!

# 大小写操作
s1 = 'hello, world!'
# 使用capitalize方法获得字符串首字母大写后的字符串
print(s1.capitalize())   # Hello, world!
# 使用title方法获得字符串每个单词首字母大写后的字符串
print(s1.title())        # Hello, World!
# 使用upper方法获得字符串大写后的字符串
print(s1.upper())        # HELLO, WORLD!

s2 = 'GOODBYE'
# 使用lower方法获得字符串小写后的字符串
print(s2.lower())        # goodbye

# 成员运算
s1 = 'hello, world'
print('wo' in s1)    # True
s2 = 'goodbye'
print(s2 in s1)      # False

#查找操作
s1 = 'hello, world!'
# find方法从字符串中查找另一个字符串所在的位置
# 找到了返回字符串中另一个字符串首字符的索引
print(s1.find('or'))        # 8
# 找不到返回-1
print(s1.find('shit'))      # -1
# index方法与find方法类似
# 找到了返回字符串中另一个字符串首字符的索引
print(s1.index('or'))       # 8
# 找不到引发异常
print(s1.index('shit'))     # ValueError: substring not found

# 性质判断
s1 = 'hello, world!'
# startwith方法检查字符串是否以指定的字符串开头返回布尔值
print(s1.startswith('He'))    # False
print(s1.startswith('hel'))   # True
# endswith方法检查字符串是否以指定的字符串结尾返回布尔值
print(s1.endswith('!'))       # True

s2 = 'abc123456'
# isdigit方法检查字符串是否由数字构成返回布尔值
print(s2.isdigit())    # False
# isalpha方法检查字符串是否以字母构成返回布尔值
print(s2.isalpha())    # False
# isalnum方法检查字符串是否以数字和字母构成返回布尔值
print(s2.isalnum())    # True

# 一般遍历
for c in s1:
# enumerate可以用于遍历
for i, s in enumerate(str):

# 字符的ASCII码
ord('a') //97
# ASCII码转字符
chr(97) //‘a’

# 字符串长度
len(str)

# 将序列seq中的元素以指定的分隔符s1形成一个新的字符串
s1 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
s1.join（seq） 

# 判断字符串中是否包含c
if c in str:

#.count(c)
num=str.count('1') #返回字符‘1’在str中出现的次数

## .strip(str)  移除字符串头尾的str，默认为所有空字符
s=str.strip()

## .replace(‘a’,'b')
s=str.replace('a','b') 将str中的'a'都替换成'b' 

# 字符串转换为其他序列类型
# 字符串转换为列表
s=str.split() #.split(str,num) str为分隔符，默认为所有空字符，包括空格、换行\n、制表\t,num为分割次数，默认-1分割所有
str1 = "123456"
print(list(str1)) # ['1', '2', '3', '4', '5', '6']
str3 = "1 2 3 4 5 6"
print(list(str3)) # ['1', ' ', '2', ' ', '3', ' ', '4', ' ', '5', ' ', '6']

# 字符串转换为集合
str2 = "11123456"
print(set(str2)) # {'1', '3', '6', '2', '5', '4'}

字符串操作参考：Python3 字符串

输入输出

输入

input([prompt])接受一个标准输入数据，读取该行到按下回车，返回为 string 类型。

//直接将输入转换为int
n = int(input())

Python中一行输入多个字符，
例如：

2 6 8
a,b,c = map(int,input().split())
或者 a,b,c=list(map(int,input().split()))
#这种方式输入了3个int型的数字，split()代表以空格隔开。
print(a,b,c)
2 6 8


1 2 3 4 5 6 7 8 9
index = list(map(int,input().split()))
#这种方式可以输入任意个int型的数字，在这里采用列表来存储。
print(index)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

其中map(function, iterable, ...)对序列iterable中的每一个元素调用function函数，最终返回操作过后新的迭代器。

输出

直接运用print函数，但是由于我们常常需要输出一个由空格分开的序列，采用下面方法：

在print的函数调用中，* 能够将元组或者列表解包成不同的参数

>>> args = (1, 2, 3, 4)
>>> print(*args)
1 2 3 4

>>> args = [1, 2, 3, 4]
>>> print(*args)
1 2 3 4

//否则输出为
>>>args = [1, 2, 3, 4]
>>>print(args)
[1, 2, 3, 4]

更多和*和**的打包和解包的用法，参考python3教程：*和**的打包和解包的用法。

return还有一种特殊用法，其中真假的判断可以参考数据类型里的True和False：

return a and b
等价于
return b if a else a 
# 一定会先做a的判断，如果在a一定不为假的情况下，返回b

格式化输出

# 1.#
num1 = 20
num2 = 30
print('num1=%d, num=%d' %(num1, num2)) # num1=20, num=30
num = 3.141526
print('%0.2f' %num)      # 保留两位小数.     # 3.14
print('%10.1f' %num)     # 占10个空格, 右对齐.    #3.
print('%-10.2f' %num)    # 占10个空格, 左对齐 3.14

# 2. format
num1 = 20
num2 = 30
print('num1={}, num2={}'.format(num1, num2)) # num1=20, num=30

print('十进制:{0:d},十六进制：{0:x},八进制：{0:o},二进制：{0:b}'.format(31)) #十进制:31,十六进制：1f,八进制：37,二进制：11111
#  带'#'有进制前缀
print('十六进制：{0:#x},八进制：{0:#o},二进制：{0:#b}'.format(31)) #十六进制：0x1f,八进制：0o37,二进制：0b11111

# 转化为百分比并保留两位小数
print('百分比：{:.2%}'.format(0.555555)) #百分比：55.56%
# 保留两位小数
print('保留两位小数：{:.2}'.format(0.555555)) #保留两位小数：0.56

# 3. f{}
name = "jxz"
age = 20
print(f'我叫{name}，今年{age}岁了。') 

num = 3.141526
print(F'保留两位小数：{num:.2f}') # 保留两位小数：3.14

collections模块

参考Python collections模块

deque()

类似于list的容器，可以快速的在队列头部和尾部添加、删除元素

# 声明双端队列
que=collections.deque()

# 初始化双端队列
st = "abcd"
list1 = [0, 1, 2, 3]
dst = deque(st) #字符串初始化
dlist1 = deque(list1) # 队列初始化
dst.append(4)
dlist1.append("k")
print(dst)
print(dlist1)
#结果：
#deque(['a', 'b', 'c', 'd', 4])
#deque([0, 1, 2, 3, 'k'])

# 获取首尾元素
que[-1]
que[0]

# 右端添加元素，不特别说明appendleft()，和列表操作一致
que.append(a)
# 左端添加元素
que.appendleft(a)

# 右端移除，不特别说明popleft()，和列表操作一致
que.pop()
# 左端移除
que.popleft()

# 获取队列长度
len(que)

Counter()

dict的子类，计算可hash的对象

from collections import Counter

list1 = ["a", "a", "a", "b", "c", "c", "f", "g", "g", "g", "f"]
dic = Counter(list1)
print(dic)
#结果:次数是从高到低的，输出类型是Counter({})
#Counter({'a': 3, 'g': 3, 'c': 2, 'f': 2, 'b': 1})

dic1=dict(dic)
print(dic1)
#结果:按字母顺序排序的，输出类型是{}字典
#{'a': 3, 'b': 1, 'c': 2, 'f': 2, 'g': 3}

print(dic.items()) #dic.items()获取字典的key和value
#结果:按字母顺序排序的
#dict_items([('a', 3), ('b', 1), ('c', 2), ('f', 2), ('g', 3)])

print(dic.keys())
#结果:
#dict_keys(['a', 'b', 'c', 'f', 'g'])

print(dic.values())
#结果：
#dict_values([3, 1, 2, 2, 3])

print(sorted(dic.items(), key=lambda s: (-s[1])))
#结果:按统计次数降序排序
#[('a', 3), ('g', 3), ('c', 2), ('f', 2), ('b', 1)]

for i, v in dic.items():
    if v == 1:
        print(i)
#结果:
#b

常用内置函数

# ord()返回对应的 ASCII 数值
>>>ord('a')
97

# bin() 返回返回一个整数 int 或者长整数 long int 的二进制表示字符串
>>>bin(10)
'0b1010'
由于字符串前面包含'0b'两个字符，所以我们通常配合bin(num)[2:]使用

# range(start, stop[, step])创建一个整数列表
>>>range(10)        # 从 0 开始到 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 10
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]

# divmod()把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
>>>divmod(7, 2)
(3, 1)

# zip也用于对二维数组的列操作中，相当于对所有二维数组的行进行解压缩，将对应列的元素放一块
matrix = [[1,2,3],[4,5,6],[7,8,9]]
print(zip(*matrix))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

cols_sum = [sum(col) for col in zip(*mat)]

# pairwise从对象中获取连续的重叠对
from itertools import pairwise
a = pairwise('12345') 
# 输出的a应为是 12 23 34 45

zip函数

zip函数将迭代器对象中对应的元素打包成元组，并返回元组列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

利用 * 号操作符，可以将元组解压为列表。

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 加了*为解压，与 zip 相反，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

l1=[2,3,1]
l2=[11,22,33]
l3=[111,222,333,444]
list(zip(l1,l2,l3)) # [(2, 11, 111), (3, 22, 222), (1, 33, 333)]

排序函数

参考这篇文章和官方文档，讲得很详细。

sort 与 sorted 区别：

• sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

• sort 直接修改原列表，并返回None；sorted返回一个新列表。

sorted 语法：

sorted(iterable, cmp=None, key=None, reverse=False)
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

# sort使用，改变原列表
a = [5, 2, 3, 1, 4]
a.sort()
a
[1, 2, 3, 4, 5]

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # sorted保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]

L=[('b',2),('a',1),('c',3),('d',4)]
# 利用key关键字，默认升序排列
L'=sorted(L, key=lambda x:x[1])   # 按值排序
  =[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

Operator模块函数

operator 模块提供了一套与Python的内置运算符对应的高效率函数。例如, operator.add(x, y) 与表达式 x+y 相同。operator 模块还定义了一些用于常规属性和条目查找的工具，如itemgetter() 、 attrgetter()，这些工具适合用来编写快速字段提取器作为 map(), sorted(), itertools.groupby() 或其他需要相应函数参数的函数的参数。参考官方文档.

inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
getcount = itemgetter(1)
list(map(getcount, inventory))
[3, 2, 5, 1]
sorted(inventory, key=getcount)
[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]

from operator import itemgetter, attrgetter
sorted(student_tuples, key=itemgetter(2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

sum函数

sum(iterable[, start])
# iterable – 可迭代对象，如：列表(list)、元组(tuple)、集合(set)、字典(dictionary)还有生成器（generator）。
# start – 指定相加的参数，如果没有设置这个值，默认为0。
#sum()最后求得的值 = 可迭代对象里面的数加起来的总和(字典:key值相加) + start的值(如果没写start的值，则默认为0) 
print(sum([1,2,3])) 
输出：6
print(sum([1,2,3],5))
输出：11
print(sum({1:5,2:6,3:7}))
输出：6
还可以统计可迭代对象iterable中True出现的次数：
print(sum([True,True,False,False]))
输出：2

模块和包

详细参考Python模块化编程和Python包两节内容。

• 模板就是.py程序，一个模块程序中可以定义各种成员（包括变量、函数、类等）。
• 包就是一个包含“_ _init _ _.py”文件的文件夹，文件夹的名称就是新建包的包名。包中可以放入模块，也可以放入包，包的本质也是模块。

为了区分上面，可以重点辨析包、模块、成员三个名词概念。

模块导入和调用

import 模块名1 [as 别名1], 模块名2 [as 别名2]，…
#会导入指定模块中的所有成员（包括变量、函数、类等）；
#当需要使用模块中的成员时，需用该模块名（或别名）作为前缀。

from 模块名 import 成员名1 [as 别名1]，成员名2 [as 别名2]，…
#只会导入模块中指定的成员；
#使用该成员时，无需附加任何前缀，直接使用成员名（或别名）即可。

自定义模块的时候，import demo会运行整个模块。

# 定义demo.py模块
name = "蒋大招"
add = "牛逼"
print(name,add)

def say():
    print("Python全网最详细教程")

# 类
class JXZBlog:
    def __init__(self,name,add):
        self.name = name
        self.add = add
    def say(self):
        print(self.name,self.add)

# 模块中调用函数   
say()
blog = JXZBlog("只要学不死","就往死里学")
blog.say()

# 定义test.py测试程序调用demo模块
import demo

输出：

蒋大招 牛逼 #print输出
Python全网最详细教程 #调用的say()
只要学不死 就往死里学 #实例类方法blog.say()

可以借助 Python 内置的 _ _name _ _ 变量。当直接运行一个模块时，name 变量的值为 _ _main _ _；而当模块被导入其他程序中并被运行时，处于模块中的 _ _name _ _ 变量的值就变成了模块名。因此，如果希望模块中的有些函数只有当前直接运行模块文件时才执行，而不是被import就无条件执行，则可在模块的这些函数上增加判断，即只有当 _ _name _ _ == _ _main _ _时才调用函数。

# 定义demo.py模块
name = "蒋大招"
add = "牛逼"
print(name,add)

def say():
    print("Python全网最详细教程")

class JXZBlog:
    def __init__(self,name,add):
        self.name = name
        self.add = add
    def say(self):
        print(self.name,self.add)

#修改此处   
if __name__ == '__main__':
    say()
    blog = JXZBlog("只要学不死","就往死里学")
    blog.say()

# 定义test.py测试程序调用demo模块
import demo

输出：

蒋大招 牛逼  # 只有print输出

包的导入和调用

import 包名[.模块名 [as 别名]]
# 导入包中的指定模块;
# 使用该模块中的成员（变量、函数、类）时，需添加“包名.模块名”(或别名)为前缀
# 直接“import 包名”，并不会将包中所有模块全部导入到程序中，它的作用仅仅是导入并执行包下的 __init__.py 文件

from 包名 import 模块名 [as 别名]
# 导入包中的指定模块;
# 使用该模块成员时不需要带包名前缀，但需要带“模板名.”（或别名）前缀
# from 包名 import * 这种写法，它和 “import 包名” 的作用一样，都只是将该包的 __init__.py 文件导入并执行

from 包名.模块名 import 成员名 [as 别名]
#向程序中导入“包.模块”中的指定成员（变量、函数或类）
# 使用时可以直接使用变量名（函数名、类名）（或别名）调用

generator生成器

参考python generator详解
generator遵循迭代器（iterator）协议，因此可以使用迭代器相关的内置函数（比如sum）.

# generator与list的区别:
gen = (x * x for x in range(5))
print (gen)
输出：<generator object Solution.checkOnesSegment.<locals>.<genexpr> at 0x7f4deba33b50>

gen = [x * x for x in range(5)]
print (gen)
直接输出列表：[0, 1, 4, 9, 16]

文件和文件夹操作

文件操作
open()

str = input("请输入：")   # 1234
print("你输入的内容是: ", str) # 1234

# 创建并打开文件
fo = open("foo.txt", "w")
print("文件名: ", fo.name)
print("是否已关闭 : ", fo.closed) # False
print("访问模式 : ", fo.mode) # w


# 打开一个文件
fo = open("foo.txt", "w+") # 清洗掉原来的内容并覆盖
# 往文件中写内容
fo.write("jxznb\n")
# 关闭打开的文件
fo.close()

Path()操作文件

from pathlib import Path
test_json='test test test'
# 找到文件
f = Path("./test.txt")
# 写入文件
f.write_text(test_json)

文件夹

import os
open("test1.txt","w+")
os.rename( "test1.txt", "test2.txt" )
os.remove("test2.txt")

#当前路径下创建新目录test
os.mkdir("test")
# 给出当前的目录
print
os.getcwd()
# 删除新建的”./test”目录
os.rmdir("./test")

面向对象

参考Python3面向对象以及Python面向对象.

类的方法：
使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数。

单下划线、双下划线、头尾双下划线说明：

1. _ _ foo _ _: 定义特殊方法，一般是系统定义名字 ，比如类构造函数 _ _ init _ _() 。
2. _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于其他访问，如 from module import *
3. _ _foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

• 比如私有方法：
  _ _privateMethod：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用采用 self. _ _privateMethods。
• 私有属性：
  _ _privateAttrs：两个下划线开头，声明该属性为私有属性，不能在类的外部被使用或直接访问。在类内部的方法中使用时采用 self.__privateAttrs。

实例属性、类属性的定义和访问：

class Employee:
   # 类属性
   empCount = 0
   
   #构造方法
   def __init__(self, na, sa):
   	  # 直接自定义实例属性
      self.name = na
      self.salary = sa
      # 访问类属性，全体实例对象共用
      Employee.empCount += 1
   
   #访问类属性 className.attr
   def displayCount(self):
     print ("Total Employee {0}".format(Employee.empCount))
     
   # 访问实例属性 self.attr
   def displayEmployee(self):
      print ("Name : {0}, Salary: {1}".format(self.name,self.salary))
 
# 创建 Employee 类的第一个对象
emp1 = Employee("Zara", 2000)
# 创建 Employee 类的第二个对象
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
# 打印最终修改完的类属性
print ("Total Employee {0}".format(Employee.empCount))

运行结果：

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

实例属性和私有类属性辨析：

class People:
    name = 'nnnnnn'  # 类属性
    age = 20  # 类属性
    __weight = 21  # 私有类属性

    # 定义构造方法，没有修改weight
    def __init__(self, name, age, weight):
        self.name = name  # 实例属性，与类属性没有关联
        self.age = age  # 实例属性，与类属性没有关联
        self.__weight = weight  # self.attr实例私有属性，与类属性没有关系
        # People.__weight = weight # className.attr类私有属性

    # 打印self类实例属性
    def speakInstance(self):
        print("实例属性，name= {0}，age= {1} 岁，__weight={2}".format(self.name, self.age, self.__weight))

    # 打印类私有属性
    def speakClassPrivate(self):
        print("私有类属性, __weight = {0}".format(People.__weight))


if __name__ == '__main__':
    p1 = People('张三', 10, 60)
    # 打印类实例属性
    p1.speakInstance()
    # 打印类的私有属性
    p1.speakClassPrivate()
    # 打印类属性
    print("类属性：name={0}, age={1}".format(People.name, People.age))

    p2 = People('李四', 12, 69)
    # 打印类实例属性
    p2.speakInstance()
    # 打印类的私有属性
    p2.speakClassPrivate()
    # 打印类属性
    print("类属性：name={0}, age={1}".format(People.name, People.age))

运行结果：

实例属性，name= 张三，age= 10 岁，__weight=60
私有类属性, __weight = 21
类属性：name=nnnnnn, age=20
实例属性，name= 李四，age= 12 岁，__weight=69
私有类属性, __weight = 21
类属性：name=nnnnnn, age=20