python点点滴滴

Python学习汇总，持续更新

1、汇总Python常用函数

• input()  ----输入函数，获取键盘输入的所有数据，以字符串形式返回。可以通过input（"请输入："）这种形式让界面更友好
• print()  ----输出函数，print(values, sep=" ", end="\n")，三个参数分别是输出的数据、数据间分隔符（默认是空格）、输出后的结束符（默认是换行）
• map()，reduce()，filter()  ----将序列中每个元素经过一个函数处理后返回，下方有详解
• iter()，next()，yield  ----分别iter()是生成迭代器、next()返回迭代器的下一个项目、yield不是函数也不是生成器，是函数内使用了它之后就变成生成器。下方有详解
• reverse() ----翻转
• sort() ----排序
• len()  ----计算长度
• any(a)  ----当a中任何元素为true就返回true
• all(a)  ----当a中所有元素都是true才返回true
• abs(a)  ----绝对值
• int(a)  ----整型、也是十进制。下面有详解。
• bin(a)  ----二进制
• hex(a)  ----十六进制
• round(a)  ----四舍五入。a=5.12345  round(a,3)  输出5.123。
• num ** (1/2)  ----平方根
• append()、extend()  ----添加。一个将列表1嵌套进列表2，一个将列表1内的每个元素的值添加到列表2。（都只用于列表，不能用于字符串）下方有详解
• split()、join()  ----切割和拼接，下方有详解
• str.title()  ----把每个单词的第一个字母转化为大写，其他小写
• str.caitalize()  ----把第一个字母转为大写，其他小写
• remove()、del()、pop()  ----删除，下方有详解
• format()  ----输出替换，下方有详解
• ord(a)、  ord(str)  ----查询字符串a的ASCII码、输出字符对应的ASCII码。
• chr(int)  ----输出数字对应的字符，小写字母的ASCII比对应大写字母大32

ord('A') = 65
ord('B') = 66
......
ord('a') = 97
ord('b') = 98

chr(65) = A
chr(66) = B
......
chr(97) = 'a'
chr(98) = 'b'

• index()   --检测字符串（列表）中是否包含子字符串（元素），包含则返回索引，下方有详解
• enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。下方有详解
• encode、decode  ----分别是编码（把你认识的转为机器认识的）、解码（把机器认识的解释为人能读懂）。所以字符串不能应用decode()函数
• zip()  ----将多个可迭代对象（列表，字符串，元祖等）作为参数，将他们的对应元素打包成元祖，也可以用*号实现逆操作，将一个元祖列表解压为多个元祖。下方有详解。
• count() ----数元素数量。string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
• sum() ----对一个可迭代对象求和。sum(iterable,start=0)。iterable是可迭代对象，start是函数初始值
• divmod() ----输入两个参数，返回这两个数的商和余数组成的元祖。divmod(a,b)相当于返回（a//b,a%b）
• mode() ----返回一组数据中出现频率最高的元素。元素可以是任何类型。如果有多个出现频率相同的元素，则返回其中一个
•        

2、汇总一些python小总结

2.1、四舍五入成整数

print(int(f+0.5))  将浮点型转化为整型使用的是去尾，所以+0.5后再去尾即得到四舍五入的值

2.2、几个函数的返回类型

• input().strip()返回的是str
• input().split()返回的是列表    
• input()返回的也是str
• a.replace()替换后返回的是str
• str没有remove，列表才有  
• 排序sorted(input())返回的是列表

2.3、列表去重的方法：

set()转为集合后自动去重，再转回列表就行。注意：集合是无序的。转成集合再转回去顺序就不一样了

2.4、在python中else可以与for同用

                

2.5、字符串比大小

在Python里字符串是可以比较的，按照ascII值排，举例abb， aba，abac，最大为abb，最小为aba。所以如果要找多个字符串的公共前缀这种题，只需要比较最大最小的公共前缀就是整个数组的公共前缀

2.6、python的调用

•   不可变对象（str,int,tuple等）按值调用，不可变：list,dict,set
•   可变对象(list等)通过引用调用， 可变：int,float,bool,string,tuple

2.7、字符串拼接

•   用 + 可以拼接，用 * 可以将自身连接多次
•   列表的 + * 也一样

2.8、pass、continue、break

• pass什么都不做
• continue跳过这次循环进入下一次
• break直接跳出整个循环

2.9、for循环代码块的简写

#如下代码块可构造一个由数字1组成的金字塔（第一行1个，第二行2个....）
res = []
for i in range(5):
    res1 = []
    for j in range(i + 1):
        res1.append(1)
    res.append(res1)

#上面代码块可简写成如下一行
res = [[1 for j in range(i + 1)] for i in range(5)]

#构造杨辉三角的代码同样可以简写成
res = [a+b for a,b in zip([0]+res,res+[0])] 

2.10、Python表示正无穷和负无穷

• float('inf') 表示正无穷
• float('-inf') 或 -float('inf') 表示负无穷
• math.isinf() 用来判断一个值是不是无穷数

3、列表list和元祖tuple的区别：

•  列表可变，元祖不可变。  如果a=100,200,300  则a也是一个元祖，圆括号可省略。
•  列表表示顺序，是同一类型，元祖表示结构。

3.1、列表和数组的区别

•   列表存在于python标准库中，数组由Numpy定义；
•   列表的算术运算是添加删除元素，数组的算术运算按照线性代数方式工作
•   列表的连接用+*，数组的连接用Numpy的concatenate

4、字典

字典是键值对的数据结构

# 空字典
dic = {} 

# 添加了一个键值对，此时 dic == {'1':'a'}
dic['1'] = 'a'

# 字典中的键和值可存储混合类型,但是要尽量使键使用有意义的名称
dic = {1:'asd','D':np.inf}   

#字典元素的访问
dic = {'1':'a','2':'b','3':'c'}
n = dic.keys()            # n为['1', '2', '3']
m = dic.values()          # n为['a', 'b', 'c']
l = dic.items()           # n为[('1', 'a'), ('2', 'b'), ('3', 'c')]

#用for遍历
dic = {'1':'a','2':'b','3':'c'}
for k in dic.keys():     # k的值遍历了'1', '2', '3'
for v in dic.values():   # v的值遍历了'a', 'b', 'c'
for k,v in dic.items():  # k,v的值分别遍历了'1', '2', '3'和'a', 'b', 'c'
for i in dic:            # 特别的是，for循环遍历字典后面不带keys、values、items的时候，遍历的是keys，此时k的值遍历了'1', '2', '3'

#不能用数字索引访问字典项，要用键访问对应的值
dic = {'1':'a','2':'b','3':'c'}
dic[0]   #  这是错的
dic['1']   # 他的值是'a'
dic['3']   # 他的值是'c'

#用del和pop删除字典元素
dic = {'1':'a','2':'b','3':'c'}
del dic['2']    # 此时 dic == {'1':'a','3':'c'}
dic.pop('1')    # 此时 dic == {'3':'c'}


#用update可以合并多个字典
dic1 = {1:'a'}
dic2 = {2:'b'}
dic1.update(dic2)  #此时dic1 == {'1':'a','2':'b'}

5、 is 和 == 的区别

•   is用来检查对象的标识（id），==用来检查值是否相等。
•   可以用id(a)打印出来检查

         例如 a=[1,2,3]  b=[1,2,3]  c=a，那么a==b是true，a is b是false，a is c是true。

         如果有a=c，那么a和c不仅值相等，而且是同一个id。a is c是true，修改了a，c也会跟着变。下题答案是[3,2] [3,2]

numbers = [1,2] 
values = numbers 
values[0] = 3 
print(numbers, values)

        下题的答案，那是因为items[0] is item，所以items[0]改了，则所有item都改了。

6、列表、字符串、range的切片

切片原则：
1、索引：正索引从左往右，从0开始，负索引从右往左，从-1开始
2、list[start:stop:step]
	start：起始索引，不填则默认为第一个元素，step为正则是左边第一个，step为负则是右边第一个。左闭，取其值。
	stop： 结束索引，不填则默认为最后一个元素，step为正则是最右边的，step为负则是最左边的。右开，不取其值。
	step:  步长，不填则默认为1，代表从左往右步长1取值。为正表示从左往右取值，为负表示从右往左取值。绝对值决定了切片的步长。

其他同样适用切片方法的：
1、字符串和列表完全一样，适用所有规则。列表切片是列表内元素，字符串切片是子字符。 （int不可以，它都不是可迭代对象）
2、函数range可创建整数列表，一般用于for循环。range(,,)的切片原则与列表切片完全一样，只不过它的start和stop不是索引，就是数字。不用冒号用逗号

列表切片的赋值：
result = [1, 2, 3, 4, 5]
切片赋值相当于替换，例如result[1:3] = 'abc'替换后结果是 [1, 'a', 'b', 'c', 4, 5]
空切片赋值相当于插入，例如result[1:1] = 'abc'，则结果是 [1, 'a', 'b', 'c', 2, 3, 4, 5]
   （字符串本身也是一种序列，所以不是’abc’，而是'a', 'b', 'c'）

常见应用：
取单个元素：
只看索引值确定是哪个元素。list[2]表示从左往右第3个元素，list[-2]表示从右往左第2个元素。list[-1]取最后一个元素。
倒置：
list[::-1]  (从又往左，从第一个到最后一个，所以相当于倒置)
取奇取偶：
list= [1,2,3,4,5,6,7,8,9,10]
list[::2]  (得到[1,3,5,7,9])    list[1::2] (得到[2,4,6,8,10])
多层列表切片：
	li[:9][3:7][-1:]  第2次切片是对第1次切片的结果进行操作，所以只要上一次切片结果不为空，理论上可以无限次多层切片。


举例：
list= [1,2,3,4,5,6,7,8,9,10]
list[:5:-1] 分析：step-1表示从右往左步长1。start为空表示默认第一个即最右边的元素10，stop为5表示索引为5的元素6。左闭右开，最终结果[10,9,8,7]
list[1:-7:-1] 分析：step-1表示从右往左步长1。起始位置是索引为1的元素2，结束位置是倒数第7个元素4。2在4的左边与步长为负矛盾，得到空列表。


错误列表：
	list[0:0]  是空列表
	list[8:2]，步长为正表示从左往右，但索引却是从右往左，得到空列表。
	list[1:5:-1]同理也是空列表
	list[-1:-7]，步长默认为1表示从左往右，但-1到-7是从右往左，矛盾，得到空列表。
	list[1:-7:-1]，他表示从右往左，从索引1到索引-7（即正数第2到倒数第7），所以这个切片是否正确要看列表的长度。

7、三个函数map，reduce，filter。用法都是传递一个函数和一个序列

•   map表示将序列中的元素（str有元素，list有元素，int没有）经过函数处理后返回一个列表

        python2返回列表，python3返回迭代器，例如  n, m = map(int, input().split(' '))

         这个序列必须是 str或list，int不行。因为int不是可迭代对象，不能转成list，必须先转str才行。

•   reduce表示将序列中的元素经过函数处理后再迭代处理，最终返回一个值
•   filter表示将序列中每个元素经过函数处理，返回是true的元素则过滤输出，false的丢弃

7.1、next()函数

next() 返回迭代器的下一个项目。
next() 函数要和生成迭代器的 iter() 函数一起使用。

语法：
next(iterable[, default])
参数：
iterable -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

迭代器有两个基本的方法：iter() 和 next()
字符串，列表或元组对象都可用于创建迭代器：
list=[1,2,3,4]
it=iter(list)
print(next(it))  #1
print(next(it))  #2

v=[1,2,3,4]
y = (x * x for x in v)    #它返回的正是一个迭代器
print(next(y), next(y))
输出 1 4

7.2、生成器yield

使用了 yield 的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数。生成器是一种特殊的迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

yield不是函数，不是生成器。是函数内使用了它之后就变成生成器。

def func(x): 
    x = yield x 
    x = yield x 
m = func(3) 
for x in m: 
    print(x, end=' ')
输出  3 None
解析：
1、我们调用生成器的时候比如上面的调用fun()的语句，生成器就开始运行，他会运行到yield函数的地方停住，然后等待下一次迭代，下一次迭代的时候也是运行到yield的时候停住，就这样运行下去，这个yield语句是任何一个，没有要求是同一个。
2、yield所在的函数是返回一个生成器对象的，但yield语句返回的是None。
3、生成器对象一旦生成，只能运行一个循环。
m = func(3), m就是一个生成器对象，这个生成器对象是有func(3)来构造的，这个时候x=3，for 循环去迭代生成器对象，第一次遇到yield是yield x (此时x是3)，所以输出是3，然后x又被赋值了yield的返回值，前面介绍了yield的返回值是None，所以此时x=None，因此迭代之后第二次遇到yield x，输出是None。
蒋雅娜补充另外一个知识点：
end=‘  ’，作为print()的一个参数，会使该函数关闭“在输出中自动包含换行”的默认行为。其原理是：为end传递一个空字符串，这样print函数不会在字符串末尾添加一个换行符，而是添加一个空字符串。

7.3、iter()迭代器

l = [1, 3, 5] 
li = iter(l) 
print(3 in li) 
print(3 in li)
输出 True, False

iter()生成一个迭代器对象，迭代器是一个可以记住遍历的位置的对象，第一个元素开始访问，直到所有的元素被访问完结束。
迭代器只能往前不会后退。
第一次查找到3会停止，第二次会从前一次停止位开始查找

iter(object[, sentinel])，迭代器方法，后面带第二个参数时，表示当返回值等于第二个参数时，终止迭代。相等的这个迭代终止，不会输出。
object -- 支持迭代的集合对象。
sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

迭代器一定是可迭代的对象，但可迭代对象不一定是迭代器。
可迭代对象和迭代器的区别：
可迭代对象需要实现__iter__方法
迭代器不仅要实现__iter__方法，还需要实现__next__方法。__iter__方法用于返回迭代器本身，而__next__用于返回下一个元素。
列表、元组、集合、字符串这些可迭代对象可以很简单的转化成迭代器。先是用iter()函数把把可迭代对象转化为迭代器，然后用next()来获取下一个元素。

8、reverse函数翻转和sort函数排序

•   list.reverse没有返回值，只会反向排序。它是将原列表翻转。
•   sorted排序的用法sorted(iterable, cmp=None, key=None, reverse=False)   reverse = True表示降序排列
•   list.sort()函数对原列表进行排序，没有返回值。而sorted(list) 函数对列表等可迭代的对象进行排序操作。返回一个新的list
•   sort排序对于字符与整型的排列是不一样的。整型就是排数字大小，字符就是对其ASC码排序。所以对一串数字列表排序的时候一定要先转成int型。（如果全是个位数，则两种顺序一样）
• 对于一个集合set1，他不可以用sort。例如set1.sort()是错误的，因为集合没有顺序。但是可以用sorted。例如s = sorted(set1)是正确的。因为它处理的是可迭代对象，并返回一个列表。

9、深拷贝与浅拷贝

•   浅拷贝可以使用列表自带的copy()函数(如list.copy()),或者使用copy模块的copy()函数。深拷贝只能使用copy模块的deepcopy(),所以使用前要导入:from copy ...
•   深拷贝：创建一个新对象，两个对象完全独立，一个改变不影响另一个
•   浅拷贝：创建一个新对象，但是依然保存的是引用，所以对新对象里的引用里的值进行修改，依然会改变原对象里的列表的值
• list2 = list1，这样相当于浅拷贝，是把list1所指的对象绑到名字list2上，没有产生新list，只是增加了一个引用。修改list1，则list2也会改变。
• list2 = list1[:]，这样相当于深拷贝。是把list1切片得到的新list绑定到list2上，产生了新list，修改一个，另一个不受影响。
• 如果要“原地修改”一个列表，则需要list1[:] = list2，它表示获取原列表的切片进行原地修改。list1 = list2则表示生成另一个list1,修改后绑定为list1，而不是原地修改。

10、各类运算符

• 算术运算符：加+  减-  乘*  除/  向下取整//  求余数%  幂运算**
  • （5.0//2.0结果是2.0，5.0/2.0结果是2.5，但5//2和5/2都是2，因为是整型）
  • 函数divmod(a,b)返回的值就是元祖（a//b,a%b）
• 比较运算符（返回布尔值）：等于==  不等于!=  大于>  小于<  大于等于>=  小于等于<=
• 赋值运算符：赋值==  自增+=  自减-=  其他类似(/=  *=  %=  **=  //=)
• 逻辑运算符：and   or   not
• 成员运算符：in   not in
• 身份运算符：is   is not
• eval() 函数把字符串表达式当运算式并返回值。print(eval ('2+4'))输出6

10.1、位运算符 (二进制按位运算)

• &(与：有0得0)，二进制安位与
• |(或：有1得1)，
• ^(异或：不同为1，相同为0)，
• ~(取反：0变1,1变0)，
• <<(左移：各二进位全部左移若干位，高位丢弃，低位补0)，
• >>(右移：各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0)

与运算（AND）&：
任何数和0做与运算，结果是0，即 x & 0 = 0。例如，5（101） & 0 = 0。
任何数和其自身做与运算，结果是自身，即 x & x = x。例如，5（101） & 5（101） = 5（101）。

或运算（OR）|：
任何数和0做或运算，结果是自身，即 x | 0 = x。例如，5（101） | 0 = 5（101）。
任何数和其自身做或运算，结果是自身，即 x | x = x。例如，5（101） | 5（101） = 5（101）。

异或运算（XOR）^：
任何数和0做异或运算，结果是自身，即 x ^ 0 = x。例如，5（101） ^ 0 = 5（101）。
任何数和其自身做异或运算，结果是0，即 x ^ x = 0。例如，5（101） ^ 5（101） = 0。
异或运算满足交换律和结合律，即 a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c。例如，5（101） ^ 3（011） ^ 4（100） = 5 ^ (3 ^ 4) = (5 ^ 3) ^ 4。
举例：5 ^ 3 ^ 4 ^ 3 ^ 4答案一定是5，因为有2个3合成0，两个4合成0.


非运算（NOT）：
非运算会反转操作数的所有位。例如，~5（101） = 2（010）。

左移运算（SHL）<<：
左移n位等于乘以2的n次方，即 x << n = x * 2^n。例如，5（101） << 2 = 20（10100）。
左移运算不改变操作数的符号位。

逻辑右移运算（SHR）>>：
右移n位等于除以2的n次方，即 x >> n = x / 2^n。例如，20（10100） >> 2 = 5（101）。
逻辑右移运算会用0填充移位后产生的空位。

算术右移运算（SAR）：
算术右移运算会用符号位填充移位后产生的空位，因此它可以保持负数的符号。例如，对于负数-5（1011） >>> 2 = -2（1110）。

10.2、集合的与或非减

10.3、运算符优先级

     算术优先级>位运算符>比较运算符>赋值运算符>身份运算符>逻辑运算符

1. 算术运算符：**优先级最高， *、/、//、%的优先级一样，从左到右开始执行。
2. 位运算符：&（与），|（或），^（异或）优先级是&>^>|。
3. 身份运算符：is，not is，判断是否来自同一个对象。
4. 逻辑运算符：‘and’、‘or’和‘not’的优先级是not>and>or。

11、字典和JSON的区别

  dict是数据类型，JSON只是字符串

12、函数append和extend

•    append将列表1嵌套进列表2，
•    extend将列表1内的每个元素的值添加到列表2
•    注意他们只改变原列表，都没有返回值

13、split的用法：

• str.split()默认通过空格切割，返回剩余元素列表，空格不限长度会全部切掉。
• str.split(' ')引号中有一个空格，则通过一个空格切割，返回剩余元素列表。如果有连续空格，首尾的会全部返回，中间的会切掉一个返回。
• 举例：

  str = "   fly me   to   the moon  "
  print(str.split(' '))
  ['', '', '', 'fly', 'me', '', '', 'to', '', '', 'the', 'moon', '', '']
  print(str.split())
  ['fly', 'me', 'to', 'the', 'moon']

13.1、如何删除字符串中的所有空白

• 可以用split通过空格切割，再用join来拼接     ''.join(s.split())
•   列表转字符串：''.join(list) ，用这个方法，要求list内的元素必须全是str才行（可通过map(str,list)将列表的元素全部转换成str）
•  print("+".join(map(str, list)))  #用join输出+号链接的标准格式

14、a.upper()与a.isupper()的区别

•   str.upper()：将字符转为大写返回大写
•   str.isupper()的区别：判断字符是否都为大写，返回True/False
•    注意二者都不可直接print，先赋值给变量再打印变量
•     类似的还有title与istitle，lower与islower等

 14.1、各种字符类型判断函数--is开头的，返回True/False

15、remove、del、pop的区别

• remove删除第一个匹配的值，
• del按索引删除元素，
• pop按索引删除并返回该元素，如果不带索引则默认是最后一个元素。
• 删除列表中的数据，只有remove()是按照数据的值来删除的，pop()、del都是按照index来删除的。
• remove、pop是处理列表的，replace是处理字符串的

下面这段函数，答案是[2,4]。

因为遍历时，elem根据index来遍历，remove时，列表按照值来删除。每次remove后列表都变了，所以会出现这种错误。(所以在遍历列表然后remove元素的时候要注意从后往前遍历)

data = [1, 2, 3, 4, 5] 
for elem in data: 
    data.remove(elem) 
print(data)

• index = 0，elem = 1，data = [2,3,4,5]

• index = 1 , elem = 3, data = [2,4,5]

• index = 2 , elem = 5, data = [2,4]

16、python中如何处理异常

  用try、except、finally

  三者的执行顺序：finally一定执行，finally里的return优先于另外二者的return

• 1、无论是在try还是在except中，遇到return时，只要设定了finally语句，就会中断当前的return语句，跳转到finally中执行，如果finally中遇到return语句，就直接返回，不再跳转回try/excpet中被中断的return语句
• 2、在except和try中遇到return时，会锁定return的值，然后跳转到finally中，如果finally中没有return语句，则finally执行完毕之后仍返回原return点，将之前锁定的值返回(即finally中的动作不影响返回值)，如果finally中有return语句，则执行finally中的return语句。
• 3、在一个循环中，最终要跳出循环之前，会先转到finally执行，执行完毕之后才开始下一轮循环

17、打印的输出替换方法

共三种方法：

#方法一
print('I am %d years old. And I am %s' %(age,name)) 
#方法二
print('my name is {1},age is {0}'.format(age,name))     #注意顺序，可以通过0,1下标选择值
#方法三
print(f'my name is {name[0]},my first list is {list1[0]},my dict is {dict1}')


#其中方法二format详解：
format()函数用来收集其后的位置参数和关键字段参数，并用他们的值填充字符串中的占位符。通常格式如下：
'{pos or key : fill, align, sign, 0, width, .precision, type}'.format(para1...)
整个花括号是一个占位符，冒号前的位置或者关键字用来定位format函数的参数，冒号后面用来将该参数格式化，其中每一个都是可选项
1.fill用来指定填充字符，默认为空格
2.align指定对齐方式：>为右对齐，<为左对齐，^为居中对齐
3.sign指定是否保留正负号：+为保留正负号，-为仅保留负号
4.宽度前面如果加0则表示用0填充
5.width指定宽度
6.precision指定精确度
7.type指定类型，如b为二进制，x为十六进制


#使用位置进行填充
print(
    'Hello,{0}. My name is {1}. How\'s it going?'.format('Hialry','Vergil')
    #Hello,Hialry. My name is Vergil. How's it going?
)
#若格式中未指定填充位置，将会按序填充
print(
    '{}--{}--{}--{}--{}--{}--{}'.format(1,2,3,4,5,6,7)
    #1--2--3--4--5--6--7
)
  
#使用关键字段进行填充
print(
    'I\'m {name1}, and I miss u so much, {name2}.'.format(name1='vergil',name2='hilary')
    #I'm vergil, and I miss u so much, hilary.
)
  
#使用下标填充
names=['hilary','vergil','nero']
places=['chengdu','shijiazhuang','tokyo']
print(
    'Hi, {names[0]}. I am {names[1]} and this is {names[2]}.'.format(names=names)
    #Hi, hilary. I am vergil and this is nero.
)
print(
    'Three people:{0[0]}, {0[1]}, {0[2]} from three places:{1[0]}, {1[1]}, {1[2]}.'.format(names,places)
    #Three people:hilary, vergil, nero from three places:chengdu, shijiazhuang, tokyo.
)
  
#进制转换
print(
    '{0:b}, {0:o}, {1:d}, {1:x}'.format(256,512)
    #100000000, 400, 512, 200
)
#逗号分隔
print(
    '{:,}'.format(12345678)
    #12,345,678
)
#浮点数格式
print(
    '{:+12.3f}'.format(3.14159265358979)
    #      +3.142
)
#对齐与填充
print(
    '{:>010}'.format(12), #右对齐，宽度10，填充0
    '{:0<+12.3f}'.format(-12.34567),#填充0，左对齐，保留正负号，宽度12，保留3位小数
    '|{:^10}|'.format(3) #，默认填充空格，居中对齐，宽度10
    #0000000012 -12.34600000 |    3     |
)

format函数

Python format函数详谈_python_脚本之家

  

18、只有十进制数字才是int

1. 整型int只能是十进制数字，所以int()永远只返回10进制数。如果用bin()将数字转成二进制，那返回的就变成str了
2. 函数int()有参数base，默认值为10，表示将字符看做十进制转成整型。如果改为16，则表示将str默认为16进制然后返回整型。
3. 举例： i = int(‘10’, base=2) （i的值是2）

19、函数index的使用

Python index() 方法检测字符串（列表）中是否包含子字符串（元素） str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内。如果包含子字符串返回索引值，否则抛出异常。如果列表中该元素有多个，则返回第一个值的索引。

str1.index(str2, beg=0, end=len(string))

20、文件的读写--IO

r 表示只读的
w 表示是可写的，使用w来写入文件时，如果文件不存在会创建文件，如果文件存在则会截断文件，截断文件指删除原来文件中的所有内容
a 表示追加内容，如果文件不存在会创建文件，如果文件存在则会向文件中追加内容
x 用来新建文件，如果文件不存在则创建，存在则报错
+ 为操作符增加功能
r+ 即可读又可写，文件不存在会报错
w+

'rb'是二进制读取

read()每一次读取都是从上次读取到位置开始读取的
语法如下：
fileObject.read([size]); 
size -- 从文件中读取的字符数（文本模式）或字节数（二进制模式），默认为 -1，表示读取整个文件。



例：
with open('temp.txt', 'rb') as fr: 
    print(fr.read(5)) 
    print(fr.read())
输出结果：
b'hello' 
b'world'

21、全局变量、局部变量（内层与外层）

详细举例讲解 python 的 global 和 nonlocal 的区别_python nonlocal_HappyRocking的博客-CSDN博客

• 当函数内外有同名的变量：

1. 如果函数内不定义变量，则就是外层变量。
2. 如果函数内定义变量，则是局部变量，它和外层变量是两个东西。
3. 如果函数内用global声明变量，则它是全局变量。（在所有函数外面定义的变量）
4. 如果函数内用nonlocal声明变量，则它和外层变量是同一个，和全局变量不是同一个。
5. （所以一旦外层变量是全局变量，则只能用 global）
6. 如果函数内先使用再定义变量，会报错。
7. （除非变量声明了全局或外层，而且全局或外层已经定义了变量）
8. global 表示将变量声明为全局变量
9. nonlocal 表示将变量声明为外层非全局变量（外层函数的局部变量，而且不能是全局变量）
10. 所有变量都必须先定义（a=1）再使用（print(a)）。
11. 在使用 nonlocal a 之前，必须保证外层的确已经定义过 a 了，但是在 global a 的时候，可以允许全局变量中还没有定义过a，可以留在后面定义。

• 22、代码换行

• python中怎么代码换行-Python教程-PHP中文网

1. 在需要换行的代码末尾加上续行符“ \”（即空格+\）；
2. 加上括号，“()”、“{}”、“[]”中不需要特别加换行符，Python会将圆括号、中括号和花括号中的行隐式连接起来
3. 如下题，BCD都是对的，A不对

22.1、单引号双引号和三引号

https://blog.csdn.net/Jerry_1126/article/details/80685639

• 1.单双引号基本无区别，注意转义即可
• 2.三引号内的单双引号无需转义
• 3.三引号的内容未赋值则相当于多行注释
• 4.三引号在多行引号时，所见即所得。引号内什么样，输出就什么样，直观。

23、lambda解析

[lambda x: x*i for i in range(4)] 详细解析+LEGB规则 闭包原理_Miss_Audrey的博客-CSDN博客

fun = [lambda x: x*i for i in range(4)]
for item in fun:
    print(item(1))
上面三行等价于：
def func():
    fun_lambda_list = []
    for i in range(4):
        def lambda_(x):
            return x*i
        fun_lambda_list.append(lambda_)
    return fun_lambda_list
#输出结果3,3,3,3
#因为i在外层作用域
#lambda x: x*i 为内层（嵌）函数，他的命名空间中只有 {'x': 1} 没有 i 
#所以运行时会向外层函数（这儿是列表解析式函数 [ ]）的命名空间中请求 i 
#而当列表解析式运行时，列表解析式命名空间中的 i 经过循环依次变化为 0->1->2->3 最后固定为 3 ，
#所以当 lambda x: x*i 内层函数运行时，去外层函数取 i 每次都只能取到 3
因为函数定义在循环内部，虽然每一次看起来好像 i 分别为 0、1、2、3，实际上因为函数是没有办法去保存这个变化的i 的，也就是说，i，是在函数外面发生变化的，函数里面的i会一直随着i的变化而变化，直到最终这个i不变化了，那函数里面的i是多少就是多少了。
总结起来就一句话：循环体内定义的函数是无法保存循环执行过程中的不停变化的外部变量的，即普通函数无法保存运行环境！



fun = [lambda x, i=i: x*i for i in range(4)]
for item in fun:
    print(item(1))
上面三行等价于：
def func():
    fun_lambda_list = []
    for i in range(4):
        def lambda_(x, i= i):
            print('Lambda函数中 i {} 命名空间为：{}:'.format(i, locals()))
            return x*i
        fun_lambda_list.append(lambda_)
    return fun_lambda_list
#输出结果0,1,2,3
#因为变闭包作用域为局部作用域
#给内层函数 lambda x: x*i 增加参数，命名空间中有了用来存储每次的 i ,
#这样每一次，内部循环生成一个lambda 函数时，都会把 --i--作为默认参数传入lambda的命名空间

作用域：

只有函数、类、模块会产生作用域，代码块不会产生作用域。作用域按照变量的定义位置可以划分为4类：python解释器查找变量时，会按照顺序依次查找局部作用域—>嵌套作用域—>全局作用域—>内建作用域，在任意一个作用域中找到变量则停止查找，所有作用域查找完成没有找到对应的变量，则抛出 NameError: name ‘xxxx’ is not defined的异常。

Local(函数内部)局部作用域

Enclosing（嵌套函数的外层函数内部）嵌套作用域（闭包）

Global（模块全局）全局作用域

Built-in（内建）内建作用域

24、装饰器

Python 函数装饰器 | 菜鸟教程

• 一切皆对象
• 函数内可以定义函数
• 函数可以return函数
• 函数后面带()和不带()都可以进行传递。带了()这个函数就会执行，传递的是函数return的结果；不带()就是传递这个函数本身，并且可赋值给别的变量而不执行。
• 函数可作为参数传给另一个函数
• 装饰器让你在一个函数的前后去执行代码。
• @wraps的作用：接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让我们在装饰器里面访问在装饰之前的函数的属性。
• 装饰器常用场景有授权、日志、带参数的装饰器、装饰器类

装饰器的两种写法：

写法一：
@a_new_decorator
def a_old_decoration():

写法二：
a_old_decoration = a_new_decorator(a_old_decoration)

功能就是把old函数当成参数传递给new函数，再把new函数return的结果传递给old函数


两重装饰：
@deco_a 
@deco_b 
def test(): 
第一次，一重装饰@deco_a，效果相当于 test = deco_a(test)
第二次，两重装饰@deco_a@deco_b，效果相当于 test = deco_a(deco_b(test))

25、*args, **kwargs

在定义函数时，常看到参数写成*args, **kwargs，比如：

比如：
def receive_args(*args, **kwargs):

用法：
当不确定传入参数的数量或形式，不关心传入参数的数量或形式时，就可以使用他们。他们组合可以覆盖所有的参数形式。

args本质是一个元祖，args的格式是常规的参数 val1[,val2,val3....]
kwargs本质是一个字典，kwargs的参数格式是 key1=value1,[key2=value2,key3=value3,....]
*args 可以理解成解包一堆参数，**kwargs 可以理解为接受一堆K:V键值对参数
两个加一起就是你传啥参数都行。根据你传的参数的格式来检查哪个是args，哪个是kwargs
一个星号和两个星号表示解包，意思是：
用“一个星号”操作符把实参从列表或元组解包出来
字典可以用“两个星号”操作符传递关键字参数

例如：
def foo(*args, **kwargs):
    print 'args = ', args
    print 'kwargs = ', kwargs
foo(1,2,3,4, a=1,b=2,c=3)
args = (1, 2, 3, 4)
kwargs = {'a': 1, 'c': 3, 'b': 2}

注意：
重点不在于args和kwargs，这两个只是一个通俗的命名约定，可以换成任何字符。
重点在于*和**

**kwargs还有一个功能就是转换参数为字典
def kw_dict(**kwargs):
    return kwargs
print kw_dict(a=1,b=2,c=3)
{'a': 1, 'c': 3, 'b': 2}

使用顺序：
func(fargs, *args, **kwargs)  #必须是常规形参最前面，**必须最后

 26、类，对象，模块，包

class Bigdog() :

class Dog():     --类，Python中首字母大写的名称指的是类
    def __init__(self, name, age):   --__init__()是一个特殊的方法，接受形参并存储。self必须有且必须第一个
        self.name = name   --初始化属性name,以self为前缀的变量可供类中所有方法使用
        self.age = age     --初始化属性age
        self.color = 'yellow' --类中每个属性都必须有初始值。__init__()内设置默认值就不用提供形参
    def update_name(self,new_name):    --方法
        self.name = new_name
    def sit(self):      --方法
        print('he is sitting')

my_dog = Dog('lucky'，6)   --创建实例，父类的__init__在这一步执行，__init__()会创建一个实例并返回给my_dog。每创建一个实例就执行一次__init__
my_dog.name   --访问实例的属性
my_dog.sit()       --调用方法
my_dog.name = 'happy'   --直接修改属性值
my_dog.update_name('good')   --通过方法修改属性值

class Yourdog(Dog):   --子类继承父类，获得父类的属性和方法
    def __init__(self, name, age):
        super().__init__(self, name, age)     --初始化父类属性,super()是特殊函数，把父类子类关联起来。使用形式：Super().方法名
        self.master = 'you'   --定义子类的属性，子类特有父类没有的
    def describe_yourdog(self):  --定义子类方法
        print('he love you')
    def sit(self):   --重写父类方法，与父类方法同名就可以在子类覆盖原方法
        print('he is sitting now')
        self.bigdog  = Bigdog()       --实例用作属性

#多重继承
class GrantParent:
class Parent(GrantParent): 
class Child(Parent, GrantParent):  --多重继承中，子类需要在父类之前，Parent必须在GrantParent前面，反过来会报错

Python是一门面向对象的解释型语言。

1、 关于python类和对象的基本概念

类：将具有相似属性和方法的对象总结抽象为类，类能减少代码的重复率；

对象：通过类定义的数据结构实例；

实例方法：类的实例能够使用的方法，可以调用类对象和实例对象。实例方法的第一个参数默认为self代表实例本身；

类方法：类方法是将类本身作为对象进行操作的方法。类方法使用@classmethod装饰器定义，其第一个参数是类，约定写为cls。类对象和实例都可以调用类方法；

静态方法：静态方法是一种普通函数，就位于类定义的命名空间中，它不会对任何实例类型进行操作。使用装饰器@staticmethod定义静态方法。类对象和实例都可以调用静态方法；

类变量：类里面，方法外面定义的变量为类变量；

实例变量：实例变量则是以为self.开头；

私有变量和方法：以“__”（双下横杠）开头的的变量或者方法为私有变量或者私有方法。

实例方法、类方法和静态方法的区别：Python 实例方法、类方法和静态方法-CSDN博客

• 实例方法：调用时会把实例作为第一个参数传递给self参数。接受self参数，并且与类的特定实例相关。
• 类方法：调用时会把类作为第一个参数传递给cls参数。接受cls参数，并且可以修改类本身。使用@classmethod装饰器。
• 静态方法：调用时并不需要传递类或者实例。与特定实例无关，并且是自包含的（不能修改类或实例的属性）。使用@staticmethod装饰器。

2、 类

2.1、   类的定义

        语法格式如下：

        class ClassName:

                <statement-1>

                <statement-N>

2.2、   方法和属性的调用

方法和属性通过，调用对象.方法名或者属性名的方式来调用

3、 Python类的三大特性

3.1、   封装

类把所需要的数据（类的属性）和对数据的操作（类的行为）全部都封装在类中，分别称为类的成员变量和方法（或成员函数）。这种把成员变量和成员函数封装在一起的编程特性称为封装。

3.2、   多态

一类事物有多种形态叫做多态，不同的对象相同的属性

3.3、   继承

子类在继承的时候，在定义类时，小括号()中为父类的名字父类的属性、方法，会被继承给子类，私有属性（私有类属性）和私有方法不被继承。

Python中是可以多继承的父类中的方法、属性，子类会继承.

类名.__mro__方法的作用打印多重继承的继承方法顺序

 重写父类方法：子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

super调用父类属性super并不是一个函数，是一个类名.。Super().方法名，可以调用父类的方法（不用传参，作用是调用父类的方法，传的是子类实例的值）super是类名。也可以用父类的类名直接调用：类名.方法名（self）

例：
class People():
   # 公共类变量
   total = 0
   # 私有类变量
   __p = 0
  
   # 初始化方法
   def __init__(self, name, age, sex):     
          self.name = name
          People.total += 1        

   # 实例方法
   def whoAmI(self):
          print("I am {}".format(self.name))

   # 类方法
   @classmethod
   def printTotal(cls):
          print("----{}----".format(cls.total))

   # 静态方法
   @staticmethod
   def work():
          print("do some thing")

class Man(People):
   def __init__(self, name, age, sex, height):
          super(Man, self).__init__(name, age, sex)
          self.height = height

   # 静态方法
   @staticmethod
   def work():
          print("play basketball")

c = Man("mcx", 18, 'M', 185)

# 继承
c.whoAmI()
# 重写
c.work()

print(Man.total) # 打印输出 1
print(Man.__p) # 报错， 子类不能继承私有属性

4、 魔方方法

__new__：对象实例化调用的第一个函数。实例化类的时候，先执行__new__创建实例，然后才会去执行__init__初始化实例。

__init__ : 构造器，在生成对象时调用

__del__ : 析构器，释放对象时使用

__repr__ : 打印，转换

__setitem__ : 按照索引赋值

__getitem__: 按照索引获取值

__len__: 获得长度

__cmp__: 比较运算

__call__: 函数调用

__add__: 加运算

__sub__: 减运算

__mul__: 乘运算

__truediv__: 除运算

__mod__: 求余运算

__pow__: 乘方

__iter__：定义迭代器中元素的行为

__eq__：可以让一个类实例化出来的两个对象完全相同。https://www.cnblogs.com/geeksongs/p/13053987.html

__str__：修改对象print打印出来的值。https://www.cnblogs.com/geeksongs/p/13053987.html

__slots__：__slots__用来限制class实例能添加的属性，只有在slots里添加了的属性，才能执行 实例.属性= xxx

5、例

27、函数enumerate

enumerate的作用是将一个可遍历的数据对象（如列表，元祖或字符串），组合为一个索引序列，同时列出数据和数据下标，常用于for循环中。

enumerate(sequence, [start=0])

#start -- 下标起始位置

#sequence -- 一个序列、迭代器或其他支持迭代对象

例如：

s=['s','d','t']
for i in enumerate(s):
    print i
    
(0, 's')
(1, 'd')
(2, 't')


for k,v in enumerate(s):
    print(k,v)
    
(0, 's')
(1, 'd')
(2, 't')

28、函数zip

zip可以将多个可迭代对象（列表，字符串，元祖等）作为参数，将他们的对应元素打包成元祖，返回这些元祖组成的列表或对象，实现将多个序列合并成一个新的序列，也可以用*号实现逆操作，将一个元祖列表解压为多个元祖。

Python2返回列表。Python3返回对象，需要说动用list()装换

zip(对象1，对象2，对象3.....)、     zip(*对象)

list1 = [1,2,3]
list2 = [7,8,9]

list3 = zip(list1,list2)
print(list3)
[(1, 7), (2, 8), (3, 9)]

list4 = zip(*list3)
print(list4)
[(1, 2, 3), (7, 8, 9)]

a,b = zip(*list3)
print a 
(1, 2, 3)
print b
(7, 8, 9)

常见用法：矩阵转置、键值互换等

#矩阵转置
m = [[1,2,3],[4,5,6],[7,8,9]]
print(zip(*m))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

#键值互换
dict = {1:'a',2:'b',3:'c'}
print(zip(dict.values(),dict.keys()))
[('a', 1), ('b', 2), ('c', 3)]

29、对象的bool

例如一个列表，如果它为空，那么它的bool值就是False，有元素就是True

list = []
print(bool(list))
False
print(list)
[]
print(not list)
True


list = [1,1,2]
print(bool(list))
True
print(list)
[1, 1, 2]
print(not list)
False


##所以，当我们需要通过对象是否为空来返回true或false的时候，可以简化

if len(list) == 0:
    return True
else:
    return False
#上面几行可以简化为
return（not list）

30、函数replace

• replace()用于将字符串中的指定子串用其他字符替代，只能替换字符串，不能替换列表
• 列表元素的替代直接赋值就可以，字符串子串的替换要用replace()

使用replace后要返回，原字符串是不变的
str = 'abbaaaabbb'
s = str.replace('a','b')
print(str)     #原字符串没变，还是'abbaaaabbb'
print(s)       #s的值是替换后的'bbbbbbbbbb'

默认是全部替换，也可指定最大替换数
str = 'abbaaaabbb'
s = str.replace('a','b')       #全部替换，值是'bbbbbbbbbb'
s = str.replace('a','b'，2)     #最多只替换2个，值是'abbaaaabbb'

可以多次replace替换多个子串
str = 'abcbdacdaacacbdbbd'
s = str.replace('a','d').replace('b','d').replace('c','d')  #值是'dddddddddddddddddd'

如果替换的旧子串在原字符串中没有，也不会报错
str = 'abbaaaabbb'
str.replace('c','a')   #不会报错，相当于没变化

用空字符串当新子串可用来删除
str = '1a11aa1a1a1a1a1a1aa1aa1'
s = str.replace('1','')   #相当于删掉了其中的‘1’,值为'aaaaaaaaaaaa'

列表赋值是根据下标索引去赋值，但
replace()是根据实际的值去替换的，不能根据下标索引位置去替换
str = '12341'   #想要将字符串最后一位改成5，即得到'12345'
str.replace(str(4),'5')  #实际得到了'52345'，因为它不是通过下标索引去改，而是通过值去改

31、处理字符串的相关函数总结

• string.capitalize() 把字符串的第一个字符大写
• string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
• string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
• string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
• string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
• string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
• string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
• string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
• string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
• string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
• string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
• string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
• string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
• string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
• string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
• string.lower() 转换 string 中所有大写字符为小写.
• string.lstrip() 截掉 string 左边的空格
• max(str) 返回字符串 str 中最大的字母。
• min(str) 返回字符串 str 中最小的字母。
• string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
• string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串
• string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
• string.strip([obj]) 在 string 上执行 lstrip()和 rstrip()
• string.swapcase() 翻转 string 中的大小写
• string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
• string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
• string.upper() 转换 string 中的小写字母为大写