1.匿名函数

语法：

关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用法

1.把匿名函数赋给一个对象，利用变量来调用该函数：

>>>f = lambda x: x*x
>>>f(5)
25

2.把匿名函数作为返回值返回：

def build(x,y):
    return lambda: x*x+y*y  

2.字典

python2中字典是无序的，python3中字典是有序排列的
##遍历字典的几种方法：

1.遍历key值
for key in a:
    print(key+':'+a[key])

for key in a.keys():
    print(key+':'+a[key])

2.遍历value值
for value in a.values():
    print(value)

3.遍历键值对：
for key,value in a.items():
    print()

注意：Python 3.6 改写了 dict 的内部算法，因此 3.6 的 dict 是有序的，在此版本之前皆是无序

字典的键

字典的键必须具有可hash方法，目前字典，列表，集合以及包含以上容器的元组不能作为字典的键。我们自定义的对象一般都直接或者间接和object有关，都带有hash方法。

3.可哈希

不严谨但易懂的解释：

一个对象在其生命周期内，如果保持不变，就是hashable（可哈希的）。

hashable ≈ imutable 可哈希 ≈ 不可变

在Python中：

list、set和dictionary 都是可改变的，比如可以通过list.append()，set.remove()，dict['key'] = value对其进行修改，所以它们都是不可哈希的；

而tuple和string是不可变的，只可以做复制或者切片等操作，所以它们就是可哈希的。

官方解释：

An object is hashable if it has a hash value which never changes during its lifetime (it needs a hash() method), and can be compared to other objects (it needs an eq() or cmp() method). Hashable objects which compare equal must have the same hash value.

Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.

All of Python’s immutable built-in objects are hashable, while no mutable containers (such as lists or dictionaries) are. Objects which are instances of user-defined classes are hashable by default; they all compare unequal, and their hash value is their id().

大致翻译一下：

如果一个对象在其生命周期内，其哈希值从未改变(这需要一个hash()方法)，并且可以与其他对象进行比较(这需要一个eq()或cmp()方法)，那么这个对象就是可哈希的。哈希对象的相等意味着其哈希值的相等。

哈希性使得对象可以用作dictionary键和set成员，因为这些数据结构在内部使用了哈希值。

Python的所有不可变的内置对象都是可hashable的，但可变容器(如列表或字典)并非如此。对于用户定义的类的实例，默认情况下是可哈希的；它们都是不相等的，并且它们的哈希值都是id()。

4.字符串

1.索引超出字符串

索引左边界超出界限，将返回空字符串
索引右边界超出界限，将返回从左边界到最后一个元素
切片反序，左边界必须大于右边界

字符串函数：

1.s.count(sub,start=0,end =len(string))

参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置
返回值
该方法返回子字符串在字符串中出现的次数。

5.常用函数

1.sorted()

注意事项：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

1.语法
sorted(iterable, cmp=None, key=None, reverse=False)

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

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> 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)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]


>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>

2.bin()

功能：

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

3.yield使用浅析

作用：把一个函数变成一个genereator，带有yield的函数不再是一个普通的函数，python解释器会将其视为一个generator，调用该函数不会执行该函数，而是返回一个可以迭代的对像

filter()

功能：filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新的filter对象，需要用list转换为新的列表。
语法：

filter(function,iterable)
其中function为函数，iterable为序列
序列中的每个参数传递给函数进行判断，返回True或者False，最后将True的元素放到新列表中去。
example：返回奇数：
def odd(num):
    return n%2==1
filter(odd,[1,2,3,4,5,6,7,8,9,10])
#lst1 = [1,3,5,7,9]

6.位操作符

python位操作符：
&:按位与操作
|：按位或操作
~：逐位取反
^：相同取零，相异取1

:右移位操作，2的幂相关
<<:左移位操作，2的幂相关

example

#判断一个整数的二进制补码一的个数：
class Solution:
    def NumberOf1(self,n):

计算机知识补习：

一个整数在计算机中为二进制的补码，可直接进行位操作，不必进行转换。
原码：用
补码：
反码：

7.集合set

1.概念：Python中的集合和数学上的集合是一致的
特点：set中不会存储重复的元素，可以进行交集，并集或者差集运算
缺点：set和dict类似，set相当于值存储了key的集合(是否意味着元素必须为hashable)
本质：无序且无重复元素的集合

创建集合：

注意：set创建没有特殊符号，主要通过list、tuple、dict（set为其键值）进行创建。
s1 = set([1,46,5,445,13,56,7,5])
s2 = set((12,12,54,13))
s3 = set({'hd':20,'e':30})

操作集合：

1.添加：集合中添加集合中没有的元素
##单个元素添加：
s1 = set([1,2,3,4,5])
s1.add(6)
可添加元组
s1.add((7,8,9))

#多个元素的添加update()
s3 = set([1,2,3,4,5])
s3.update([6,7])

#删除元素
s3.remove(),只能用于元素的删除，不能用于索引删除

#交集和并集：&（按位与）和|（按位或）

#4.交集和并集
s4 = set([43,54,5,65])
s5 = set([545,4,65,6,75])
r1 = s4 & s5                  
#交集
print(r1)
r2 = s4 | s5
#并集
print(r2)

8.列表

1.删除列表元素del

list1 = [1,2,3,4]
del list[1]

2.+在列表中用于组合列表，*用于重复列表

[1,2,3]+[4,5,6]
[1]*10

3.python中包含的方法

1.list.count(obj)

统计某个元素出现次数

2.list.extend(seq)

新列表扩展原来列表

3.list.insert(index,obj)

将对象插入列表

4.list.index(obj)

从列表中找出莫i搁置第一个匹配项的索引位置

5.list.remove(obj)

移除列表中某个值的第一个匹配项

6.del list[i]

删除列表指定位置元素

6.list.sort(cmp=none,key=none,reverse=False)

断言

异常捕捉

try...except

#try/except/else/finally语句的完整格式
try:
    Normal execution block
except A:
    Exception A handle
except B:
    Exception B handle
except:
    other exception handle
else:
    if no exception,get here
finally:
    print('finally')

example

try:
     #raise AError
     asdas('123')
except AError:
     print("Get AError")
except:
     print("exception")     
else:
     print("else")
finally:
     print("finally")     
print("hello wolrd")
在上面的代码中，Normal execution block中出现了语法错误，但是由于使用了except语句，该语法错误就被掩盖掉了。因此在使用try/except是最好还是要非常清楚的知道Normal execution block中有可能出现的异常类型以进行针对性的处理。

传入参数

一颗星两颗星

一颗星：表示不限数量的单值参数。
两颗星：表示不限数量的键值对。

case1:

def multi_sum(*args):
    s = 0
    for item in args:
        s+=item
    return s

>>>multi_sum(1,2,3)
6

case2 打包

python 函数允许同时全部或部分使用固定参数、默认参数、单值可变参数、键值对可变参数，使用时必须按照顺序书写。将输入的单值位置参数打包成元组，传递给参数args，将输入的键值对打包成字典传递给kwds。

def do_something(name,age,gender='男'，*args,**kwds):
print('name:%s,age:%d,gender:%s'%(name,age,gender))
print(args)
print(kwds)

#打包
def foo(*args,**kwds):
    for i in args:
        print(i)
    for key,value in kwds.items():
        print(f"key:{key},value:{value}")
foo(1,2,3,4,a=3,b=5,e=6)

>>>1
2
3
4
key:a,value:3
key:b,value:5
key:e,value:6

case3(解包)

此外，一颗星和两颗星还可以用于列表、元组、字典的解包。

a = (1,2,3)
>>>print(*a)
1 2 3
>>>b = [1,2,3]
>>>print(*b)
1 2 3

#当没有拆解时，输入的字典或者元组都被当成是单值输入，*会将元组和字典打包在一起赋给args，同时kwargs将为空字典。
def foo(*args, **kwarg):
    for item in args:
        print(item)
    for k,v in kwarg.items():
        print(k, v)
    print('*' * 50)

if __name__ == '__main__':
    #foo(1, 2, 3, a=4, b=5)
    #foo(2, 3, a=4, b=5, c=1)
    v = (1, 2, 4)
    v2 = [11, 15, 23]
    d = {'a':1, 'b':12}
    foo(v, d) #(1, 2, 4) {'a': 1, 'b': 12}
    foo(*v, **d)
>>># 1
2
4
a 1
b 12

魔法方法