函数，lambda函数，递归函数，内置函数（map，filter），装饰器

1. 集合

主要作用:

1. 去重
2. 关系测试， 交集＼差集＼并集＼反向(对称)差集

2. 元组　　

只读列表，只有count, index 2 个方法

作用：如果一些数据不想被人修改， 可以存成元组，比如身份证列表

3. 字典

key-value对

1. 特性：
2. 无顺序
3. 去重
4. 查询速度快，比列表快多了
5. 比list占用内存多

 

为什么会查询速度会快呢？因为他是hash类型的，那什么是hash呢？

　　哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法

dict会把所有的key变成hash 表，然后将这个表进行排序，这样，你通过data[key]去查data字典中一个key的时候，python会先把这个key hash成一个数字，然后拿这个数字到hash表中看没有这个数字， 如果有，拿到这个key在hash表中的索引，拿到这个索引去与此key对应的value的内存地址那取值就可以了。

函数和过程

#函数
def func1():
    """testing1"""
    print('in the func1')
    return 0

#过程  即没有返回值的函数
def func2():
    """testing2"""
    print('in the func2')

x=func1()
y=func2()

print('from func1 return is %s'%x)
print('from func2 return is %s'%y)

以上代码运行结果

in the func1
in the func2
from func1 return is 0
from func2 return is None

函数调用

函数传参数传的引用，没有再创建一个参数。

函数传的参数，一旦遇到等号，参数就不在引用，而是将参数赋值，与之前引用的无关。

def func1(arg):
    if len(arg) > 2:
        del arg[2:]

def func2(arg):
    arg = 123

li = [11,22,33]
func1(li)
print(li)
func2(li)
print(li)

以上代码执行结果

[11, 22]
[11, 22]

例一：

def test(x,y):
    print('x=%d'%x)
    print('y=%d'%y)

test(y=2,x=1)#指定参数调用，与形参顺序无关

以上代码运行结果

x=1
y=2

例二：

def test(x,y):
    print('x=%d'%x)
    print('y=%d'%y)

test(1,2)   #普通参数调用，实参与形参位置一一对应

以上代码运行结果

x=1
y=2

例三：

def test(x,y,z):
    print('x=%d'%x)
    print('y=%d'%y)

test(3,z=2,y=6)#指定参数要放在普通参数的后面

以上代码运行结果：

x=3
y=6

返回值

# -*- coding: utf-8 -*-

def test1():
    print('in the test1')
    # return 0

def test2():
    print('in the test2')
    return 0
def test3():
    print('in the test3')
    return 1,'hello',['a','b','c'],{'name':'alex'},test2

x=test1()
y=test2()
z=test3()

print(x)
print(y)
print(z)

以上代码运行结果

in the test1
in the test2
in the test3
None
0
(1, 'hello', ['a', 'b', 'c'], {'name': 'alex'}, <function test2 at 0x00000160332DF268>)

返回值
1.  一旦你的函数经过调用并开始执行，那你的函数外部的程序，就没有办法再控制函数的执行过程了
    此时外部程序只能安静的等待函数的执行结果，为啥要等待函数结果，因为外部函数要根据函数的执行结果来决定
    下一步怎么走，这个执行结果就是以return的形式返回给外部程序
2.  return代表着一个函数的结束
3.  return可以返回任何数据类型
4.  对于用户角度，函数可以返回任意数量的值，但对于py本身来讲，函数只能返回一个值。

默认参数

默认参数特点：调用函数的时候，默认参数非必须传递,当函数里有默认参数和普通参数时，默认参数放在最后面。
用途：1.默认值

def test(x,y=2):
    print(x)
    print(y)

test(1,3)

以上代码运行结果

1
3

动态参数

形参：*args，实参：*列表

形参：**kwargs，实参：**字典

*args：接受N个普通参数，转换成元组的形式

def func(*args):
    print(args)

li = [11,22,33]

func(li)
func(*li)

以上代码运行结果

([11, 22, 33],)
(11, 22, 33)

**kwargs：接受N个指定参数，转换成字典的方式
例一：

def func(**kwargs):
    print(kwargs)

dic = {'k1':11}

func(k1=dic)
func(**dic)

以上代码运行结果

{'k1': {'k1': 11}}
{'k1': 11}

例二：

def test4(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)

test4('alex',sex='m',hobby='tesla',age=23)

以上代码运行结果

alex
23
{'hobby': 'tesla', 'sex': 'm'}

例三：

万能参数，*args,*kwargs

*args,**kwargs必须在最后面

def test4(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)

test4('alex',32,'fds','hh',sex='m',hobby='tesla')

以上代码运行结果

alex
32
('fds', 'hh')
{'sex': 'm', 'hobby': 'tesla'}

局部变量&全局变量

PERSON = 'zhou'
def func1():
    a = 123
    global PERSON
    PERSON = 'zzm'
    print(a)

def func2():
    a = 456
    print(PERSON)
    print(a)

func1()
func2()

以上代码执行结果

123
zzm
456

lambda匿名函数

冒号左边传参数，右边传return值

def f1():
    return 123

f2 = lambda : 123

def f3(a1,a2):
    return a1 + a2

f4 = lambda a1,a2 : a1 + a2

print(f1(),f2())
print(f3(1,2),f4(1,2))

以上代码执行结果：

123 123
3 3

实例：

lambda结合三元运算

data = map(lambda n: n*2 if n>5 else n ,range(10))
print(list(data))

以上代码运行结果

[0, 1, 2, 3, 4, 5, 12, 14, 16, 18]

函数名作参数

def f1():
    return "F1"

def f2(arg):
    print(arg())
    return 'F2'

f2(f1)

f1 = f1函数

f2 = f2函数

以上代码执行结果

F1

嵌套函数

name = 'Alex'
def changeName():
    name = 'Jack'
    print(name)
    def changeName2():
        name = "Rain"
        print("name2",name)
    changeName2()

changeName()

以上代码运行结果

Jack
name2 Rain

二分查找

data = range(0,1000000)
# data.sort()
print(data)
def binary_search(datasets,find_num):
    if len(datasets)>0:
        middle_pos = int(len(datasets)/2)
        if datasets[middle_pos] == find_num:
            print("Find num:",datasets[middle_pos])
        elif datasets[middle_pos] > find_num:
            print("going to left side",datasets[middle_pos])
            binary_search(datasets[0:middle_pos],find_num)
        else:
            print("going to right side",datasets[middle_pos])
            binary_search(datasets[middle_pos+1:],find_num)
    else:
        print("cannot find %d",find_num)
binary_search(data,5100)

以上代码运行结果

range(0, 1000000)
going to left side 500000
going to left side 250000
going to left side 125000
going to left side 62500
going to left side 31250
going to left side 15625
going to left side 7812
going to right side 3906
going to left side 5859
going to right side 4883
going to left side 5371
going to left side 5127
going to right side 5005
going to right side 5066
going to right side 5097
going to left side 5112
going to left side 5105
going to left side 5101
going to right side 5099
Find num: 5100

递归

利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

def fib(a1,a2,a3):
    if a3 == 10:
        return a1
    r = fib(a2,a1+a2,a3+1)
    return r
print(fib(0,1,1))

以上代码运行结果

34

总结递归调用：

1、进入下一次递归时，问题的规模必须降低

2、递归调用必须有一个明确的结束条件

3、在python中没有尾递归优化，递归调用的效率就不高。

高阶函数

def add(x,y,f):
    return f(x) + f(y)

def calc(n):
    return n+1

res = add(3,-6,calc)
print(res)

以上代码运行结果

-1

内置参数

abs()，绝对值

#绝对值
i = abs(-123)
print(i)

以上代码执行结果：

123

真：每个元素都为True

假：0，None，''，[]，()

all()，循环参数，如果每个元素都为真，那么all的返回值为真。

any()，只要有一个为真，则为真。

ascii()，到对象的类中找__repr__，获取其返回值。

class Foo:
    def __repr__(self):
        return 'hello'

ret = ascii(Foo())
print(ret)

以上代码执行结果：

hello

十进制转其它进制

# bin()   二进制
r = bin(11)
print(r)

# oct()   八进制
r = oct(8)
print(r)

# int()   十进制
r = int(10)
print(r)

# hex()   十六进制
r = hex(10)
print(r)

以上代码执行结果

0b1011
0o10
10
0xa

其它进制转十进制

i = int('0b11',base=2)
print(i)

i = int('0o11',base=8)
print(i)

i = int('0x11',base=16)
print(i)

以上代码执行结果

3
9
17

bool()，判断真假，把一个对象转换成布尔值。

bytes()

# 字符串转字节
b = bytes('zbc',encoding='utf8')
print(b)
# 字节转字符串
b=b.decode(encoding='utf8')
print(b)

以上代码执行结果：

b'zbc'
zbc

chr(),ord()

# chr把0-255数字转换成ascii里对应的字符
c =chr(67)
print(c)
# ord把字符转换成ascii里对应的0-255数字
b = ord('C')
print(b)

以上代码运行结果：

C
67

随机验证码

import random
c=''
for a in range(4):
    num = random.randrange(0,4)
    if num == 1 or num == 3 :
        k = str(random.randrange(0,10))
        c = c + k
    else:
        j = random.randrange(65, 91)
        c = c + chr(j)

print(c)

divmod()，计算商和余数

r = divmod(102,10)
print(r)

以上代码执行结果

(10, 2)　　

eval()，可以执行一个字符串形式的表达式

a = "1+3"
print(eval(a))
print(eval('a + 60',{'a':99}))

以上代码执行结果

4
159

exec，执行py代码

exec('for i in range(10):print(i)')

以上代码执行结果

0
1
2
3
4
5
6
7
8
9

comple，编译

filter(函数名,可迭代的对象)

Return an iterator yielding those items of iterable for which function(item)
is true. If function is None, return the items that are true.

将符合条件的值过滤出来。

ret = filter(lambda arg:arg>22,[11,22,33])
for i in ret:
    print(i)

以上代码执行结果

33

map(函数名,可迭代的对象)

ret = map(lambda arg:arg*2,[11,22,33])
for i in ret:
    print(i)

以上代码执行结果

22
44
66

locals()局部变量，globals()全局变量

def f1():
    name = 123
    print(locals())
    print(globals())

f1()

以上代码执行结果

{'name': 123}
{'__file__': 'E:/python/day1/s5.py', '__doc__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000023922166D30>, 'Foo': <class '__main__.Foo'>, '__cached__': None, '__name__': '__main__', '__builtins__': <module 'builtins' (built-in)>, '__package__': None, 'f1': <function f1 at 0x0000023922067F28>, '__spec__': None}

hash()

字典的key做hash，存在内存里节约空间，并且做了索引，可以快速找到，可以说是key的优化

dic = {
    'dsfdgfdgdfgads23gthgf':1,
}
i = hash('dsfdgfdgdfgads23gthgf')
print(i)

isinstance()

li = [11,22]
# 判断某个对象是否是某个类创建的
r = isinstance(li,list)
print(r)

以上代码执行结果

True

iter()迭代器，next()取可迭代对象里的值

obj = iter([11,22,33])
print(obj)
r1 = next(obj)
print(r1)

以上代码执行结果

<list_iterator object at 0x0000026A1AB5DD68>
11

round()，四舍五入

r = round(3.6)
print(r)

以上代码执行结果

4 

zip()

l1 = [1,2,3,4]
l2 = ['a','b','c']
r = zip(l1,l2)
print(r)
for i in r:
    print(i)

以上代码执行结果

<zip object at 0x0000019083649CC8>
(1, 'a')
(2, 'b')
(3, 'c')

sorted()，字符串和数字不能放在一起排序

li = ['','gbb','','','','','ds']
print(sorted(li))

以上代码执行结果

['', '', '', '', '', 'ds', 'gbb']