python查漏补缺一

1.换行终止符
python使用换行符作为语句终止符，但是在圆括号、方括号、花括号、三引号内包含的字符串则是例外，他们的终止符是括号及三引号的另一边；如可以在三引号中直接按键盘的enter换行，而在单引号中需要格式化处理’sd\ndds’,不然报错；
2.关于原义字符r”与正则表达式
import re
pa1 = r’\b[a-z]+\b’
pa2 = ‘\b[a-z]+\b’
string1 = ‘life is short’
string2 = ‘life \bis\bshort’

re.findall(pa1, string1)==>[‘life’, ‘is’, ‘short’]
re.findall(pa2, string1)==>[]
re.findall(pa1, string2)==>[‘life’, ‘is’, ‘short’]
re.findall(pa2, string2)==>[‘\x08is\x08’]

注意：
（1）正则表达式：r’\b[a-z]+\b’是原义字符串，里面的\b不解析(即不转义)，所以是两个字符(反斜杠和字母b)，而这两个字符在正则表达式中是‘单词边界分隔符’的意思， re.findall(pa1, string1)、 re.findall(pa1, string2)的意思是在string1、string2字符串中搜索单词边界，string1中刚好有三个单词所以结果是[‘life’, ‘is’, ‘short’]，而在字符串2中，由于串2是普通字符串所以\b一个字符（转义字符，是退格字符，也属于空白字符，同空格一样也为单词边界）所以，结果同为[‘life’, ‘is’, ‘short’].
（2）正则表达式：’\b[a-z]+\b’是普通字符串，那么里面的’\b’将会被解析成’退格符号’而不是’单词分割符号’； re.findall(pa2, string1)、 re.findall(pa2, string2)的意思是在stirng1、string2中查找符合规则：“退格符+单词+退格符”的字符串，string1中明显没有退格符，所以结果为空，而string2中\bis\b就是两个退格符之间有个单词is，所以可以符合规则，结果中的’\x08’就是’\b’退格符的意思.

3.关于Python3中字符串的编解码问题
s=’我爱python’
字符串s有一个方法encode,帮助文档如下：

可见，encode函数有两个参数，第一个是编码，第二个是错误，我们这里主要看一下第一个参数，这是一个默认参数类型，默认是utf-8,所以，s.encode()==s.encode(‘utf-8’)==s.encode(encoding=’utf-8’)建议以后都用第一种方法。
s_gbk=s.encode(‘gbk’) ===》b’\xce\xd2\xb0\xaepython’
s_utf8=s.encode(‘utf-8’) ===》b’\xe6\x88\x91\xe7\x88\xb1python’
可见，他们都是将字符串编码成bytes，但是对中文的编码不一样，所以在解码的时候也要指定类型，不然会出现乱码（注意，不指定类型默认是utf-8解码）：
s.encode(‘gbk’).decode(‘gbk’) ==> ‘我爱python’
s.encode(‘utf-8’).decode(‘utf-8’) ==> ‘我爱python’
s.encode().decode() ==> ‘我爱python’
s.encode(‘utf-8’).decode() ==> ‘我爱python’
s.encode().decode(‘utf-8’) ==> ‘我爱python’

s.encode().decode(‘gbk’) ==> ‘鎴戠埍python’
s.encode().decode(‘gbk’) ==> UnicodeDecodeError: ‘utf-8’ codec can’t decode byte 0xce in position 0: invalid continuation byte

综上所述：encode、decode的参数要匹配且最好都显式指定出来（不要用默认），注意，print(s_utf8)和print(s_gbk)这些bytes显示的还是他们本身，如果想要显示中文就必须将其解码成相应的字符串类型print才可以。

4.python中string.casefold和string.lower区别
python 3.3　引入了string.casefold 方法，其效果和 string.lower 非常类似，都可以把字符串变成小写,lower() 只对 ASCII 也就是 ‘A-Z’有效,对 Unicode 的时候用 casefold;
如德语中’ß’的小写是’ss’：
s = ‘ß’
s.lower() # ‘ß’
s.casefold() # ‘ss’

5.del删除对象的引用及变量，而不是删除变量标识的对象；对象由Python的自动垃圾回收机制删除；
为了简化内存管理，Python通过引用计数机制实现自动垃圾回收功能，Python中的每个对象都有一个引用计数，用来计数该对象在不同场所分别被引用了多少次。每当引用一次Python对象，相应的引用计数就增1，每当消毁一次Python对象，则相应的引用就减1，只有当引用计数为零时，才真正从内存中删除Python对象。
a = [1, “two”, 3, “four”]
del a[0] #删除列表a中，下标为0的元素
a ==》 [‘two’, 3, ‘four’]
a.append(“five”)
a.append(6)
a ==》[‘two’, 3, ‘four’, ‘five’, 6]
del a[2:4] #删除a从下标为2到4的元素，含头不含尾
a ==》[‘two’, 3, 6]
del a #删除列表a
a ==》Traceback (most recent call last):
File “”, line 1, in
NameError: name ‘a’ is not defined

另一个例子：
x = [‘Hello’,’world’]
y = x
y ==》[‘Hello’, ‘world’]
x ==》[‘Hello’, ‘world’]
del x
x ==》Traceback (most recent call last):
File “pyshell#12>”, line 1, in
x NameError: name ‘x’ is not defined
y ==》[‘Hello’, ‘world’]
可以看到x和y指向同一个列表，但是删除x后，y并没有受到影响
The reason for this is that you only delete the name,not the list itself,In fact ,there is no way to delete values in python(and you don’t really need to because the python interpreter does it by itself whenever you don’t use the value anymore)

举个例子，一个数据（比如例子中的列表），就是一个盒子，我们把它赋给一个变量x，就是好像把一个标签x贴到了盒子上，然后又贴上了y，用它们来代表这个数据，但是用del删除这个变量x就像是把标有x的标签给撕了，剩下了y的标签。

6.列表一共下面11个方法：
（1）L.append(iterable_object) -> None – append object to end
等价于：L += iteiterable_objec（只有一个元素的可迭代对象时）,但是不等价于L = L + iteiterable_objec
前两种方法都是操作L，后面是L 的浅拷贝，新建的变量L，这时id(L)是变化的
（2）L.clear() -> None – remove all items from L

（3）L.extend(iterable) -> None – extend list by appending elements from the iterable
等价于：L += iteiterable_objec,但是不等价于L = L + iteiterable_objec
前两种方法都是操作L，后面是L 的浅拷贝，新建的变量L，这时id(L)是变化的
（4）L.index(value, [start, [stop]]) -> integer – return first index of value.
Raises ValueError if the value is not present.
（5）L.insert(index, object) – insert object before index
（6）L.pop([index]) -> item – remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
注意：这里是删除指定索引处的值，默认index=-1
（7）L.remove(value) -> None – remove first occurrence of value.
Raises ValueError if the value is not present.
注意：这里是删除L中从左起第一个值为value的值，不是索引
（8）L.copy() -> list – a shallow copy of L
返回L的浅拷贝（只是值一样，其实是两个列表对象，地址也不一样，是新建了一个对象值也是L）
（9） L.count(value) -> integer – return number of occurrences of value
这里要注意，list、tuple的count都是只有一个参数的，但是字符串的count函数可以有开始和结束参数,且统计的可以是字符串子元素的切片：
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
（10）L.sort(key=None, reverse=False) -> None – stable sort IN PLACE
这个sort是列表独有的方法，且如果列表中同时存在字符串和数字会报错，但是纯的字符串或者数字列表是可以的，字符串、元组、字典都没有这个方法，
但是有一个内置函数sorted是所有可迭代数据类型都可以用的排序函数，且更为强大,可以按照key函数指定排序算法
sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
（11）L.reverse() – reverse IN PLACE
翻转列表，也是列表独有的方法。但是同样有一个内置函数
reversed(self, /, *args, **kwargs)
reversed(sequence) -> reverse iterator over values of the sequence

7.字典的方法
（1）d.clear()
移除字典的所有项
（2）d.copy()
返回字典的浅拷贝
（3）d.fromkeys(iterable, value=None, /)
Returns a new dict with keys from iterable and values equal to value.
注意：这里的方法与字典d没有啥关系，可以直接写dict.fromkeys(iterable,value)意思是返回一个字典，以可迭代对象iterable的元素为键，value为值（所有key的值均为value，默认为None）
（4）D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None
（5）D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D与get类似如果k存在就返回d[k],如果k不存在，就设置d[k]=d
（6）d.items()无参数，list(d.items())返回的是,以字典键值对为元素的列表，如下：d={‘a’:1,’b’:2}
list(d.items()) ==> [(‘a’,1),(‘b’,2)]
（7）d.keys() ==> dict_keys([‘a’,’b’]) ; list(d.keys()) ==>[‘a’,’b’]
（8）d.values() ==>dict_values([1,2]); tuple(d.values()) ==>(1,2)
（9）d.pop(k[,v]) ==>D.pop(k[,d]) -> v, remove specified key and return the corresponding value.If key is not found, d is returned if given, otherwise KeyError is raised
（10）D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty.随机返回字典中的键值对（元组），若为空则KeyError
（11）D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]
d={1:2,3:4,5:6}
e1={1:’a’,6:7,8:9}
e2=[(1,’a’),(6,7),(8,9)]

d.update(e1)==d.update(e2) ==>d == {1: ‘a’, 3: 4, 5: 6, 6: 7, 8: 9}
d.update(**{‘d’:’e’,’e’:’f’}) ===> d == {1: 2, 3: 4, 5: 6, ‘d’: ‘e’, ‘e’: ‘f’}
d.update(**{‘d’:’e’,’e’:’g’}) ===> d == {1: 2, 3: 4, 5: 6, ‘d’: ‘e’, ‘e’: ‘g’}

d1={‘1’:’a’,6:7,8:9}
d1.update({‘1’:’b’,’2’:4},**{‘1’:’c’,’h’:’j’}) ==> d1 == {‘1’: ‘c’, 6: 7, 8: 9, ‘2’: 4, ‘h’: ‘j’}

8.关于lamada函数及应用sort、sorted
1)f = parameters:expression中
prameters为函数f的参数，多个参数用逗号分隔，如f = lambda x,y:x+y
也可以为默认参数，关键字参数、可变参数等:key=lambda x,y=0,*z,**w:[x,y+1,z,w]==>key(1,2,3,4,5,a=9) == [1, 3, (3, 4, 5), {‘a’: 9}]
注意：返回数据要用（）[]括起来，不然报错

2)f为函数名，f(parameters)调用

3)expression可以为条件表达式但不能包含多分支或循环，也不能包含return，yield语句，整个expression表达式的值就是f函数的返回值，如果expression为列表函数返回值就是列表（格式、形式）
s = lambda x: “bad” if x>10 else “good”
s(5) ==> “bad”
s(11) ==>”good”

4)改变sort,sorted的默认排序函数
l=[(2, 4, ‘Be’), (1, 3, ‘Li’), (2, 12, ‘Li’), (1, 11, ‘Na’)]
l.sort(key=lambda e:(e[2],e[0]))
sorted(l,key=lambda a:[a[2].lower(), a[0]]) ==> [(2, 4, ‘Be’), (1, 3, ‘Li’), (2, 12, ‘Li’), (1, 11, ‘Na’)]

按照l中元素的子元素排序

9.断言：assert x,y
断言就是assert x,y判断x若为False，产生AssertError异常（可捕获处理之），且异常后面的提示文字为y，若x为True无任何返回

10.用户输入密码隐藏之getpass的使用
getpass 模块
getpass 模块提供了平台无关的在命令行下输入密码的方法.
getpass(prompt) 会显示提示字符串, 关闭键盘的屏幕反馈, 然后读取密码.
如果提示参数省略, 那么它将打印出 “Password:”.
getuser() 获得当前用户名, 如果可能的话.
getpass.getpass(prompt=’Password: ‘, stream=None)

In [8]: import getpass
In [9]: passwd = getpass.getpass()
Password:
In [10]: passwd
Out[10]: ‘xunlei’

这种方法不会显示你输入的密码，也不能显示*

getpass.getuser()

返回当前用户名。这个函数会按顺序检查环境变量LOGNAME, USER, LNAME和USERNAME。返回第一个非空的值。如果检查不到非空的值，模块会尝试导入pwd模块，如果系统支持pwd模块，会返回通过pwd模块获取的用户名，否则报错。
In [3]: getpass.getuser()
Out[3]: ‘yangbingpeng’