python 返回上一级的上一级路径

• 一、数学定义的函数和python定义的函数
• 二、为何使用函数
• 三、背景提要
• 四、函数和过程
• 五、局部变量和全局变量
• 六、前向引用之‘函数变量’
• 七、递归调用
• 八、嵌套函数和作用域
• 九、匿名函数
• 十、函数式编程
• 十一、高阶函数
• 十二、内置函数

一、数学定义的函数和python定义的函数

初中数学函数定义：一般的，在一个变化过程中，如果有两个变量x和y，并且对于x的每一个确定的值，y都有唯一确定的值与其对应，那么我们就把x称为自变量，把y称为因变量，y是x的函数。自变量x的取值范围叫做这个函数的定义域

例如y=2*x

python中函数的定义：函数是逻辑结构化和过程化的一种编程方法（作用：完成一种特定功能）

1 python中函数定义方法：
 2  
 3 def test(x):
 4     "The function definitions"
 5     x+=1
 6     return x
 7      
 8 def:定义函数的关键字
 9 test：函数名
10 （）：内可定义形参
11 "":文档描述（非必要，但是强烈建议为你的函数添加描述信息）
12 x+=1：泛指代码块或程序处理逻辑
13 return：定义返回值

   调用运行：可以带参数也可以不带

函数名()

补充：

1.编程语言中的函数与数学意义的函数是截然不同的俩个概念，编程语言中的函数是通过一个函数名封装好一串用来完成某一特定功能的逻辑，数学定义的函数就是一个等式，等式在传入因变量值x不同会得到一个结果y，这一点与编程语言中类似（也是传入一个参数，得到一个返回值），不同的是数学意义的函数，传入值相同，得到的结果必然相同且没有任何变量的修改(不修改状态)，而编程语言中的函数传入的参数相同返回值可不一定相同且可以修改其他的全局变量值（因为一个函数a的执行可能依赖于另外一个函数b的结果，b可能得到不同结果，那即便是你给a传入相同的参数，那么a得到的结果也肯定不同）

2.函数式编程就是：先定义一个数学函数(数学建模)，然后按照这个数学模型用编程语言去实现它。至于具体如何实现和这么做的好处，且看后续的函数式编程。

二、为何使用函数

    背景：

     现在老板让你写一个监控程序，监控服务器的系统状况，当cpu＼memory＼disk等指标的使用量超过阀值时即发邮件报警，你掏空了所有的知识量，写出了以下代码：

1 while True：
 2     if cpu利用率 > 90%:
 3         #发送邮件提醒
 4         连接邮箱服务器
 5         发送邮件
 6         关闭连接
 7      
 8     if 硬盘使用空间 > 90%:
 9         #发送邮件提醒
10         连接邮箱服务器
11         发送邮件
12         关闭连接
13      
14     if 内存占用 > 80%:
15         #发送邮件提醒
16         连接邮箱服务器
17         发送邮件
18         关闭连接

上面的代码实现了需求，但是重复的代码太多，每次报警都得重新写一段发送邮件代码，low：

1. 代码重复过多，一个劲的copy and paste不符合高端程序员的气质
2. 如果日后需要修改发邮件的这段代码，比如加入群发功能，那你就需要在所有用到这段代码的地方都修改一遍

针对上面两点，只要把重复的代码提取出来，放在一个公共的地方，起个名字，以后谁想用这段代码，只用通过名字调用就可以了，所以您又修改成如下代码：

1 def 发送邮件(内容)
 2     #发送邮件提醒
 3     连接邮箱服务器
 4     发送邮件
 5     关闭连接
 6      
 7 while True：
 8      
 9     if cpu利用率 > 90%:
10         发送邮件('CPU报警')
11      
12     if 硬盘使用空间 > 90%:
13         发送邮件('硬盘报警')
14      
15     if 内存占用 > 80%:
16         发送邮件('内存报警')

这样写代码就很优雅了，使用函数的优点：

       1、避免代码重用

       2、保持一致性，容易维护

       3、可扩展性

三、函数和过程

     过程定义：没有返回值的函数（过程也是函数）  

1 def test01():
 2     msg='hello The little green frog'
 3     print msg   #没有返回值
 4  
 5 def test02():
 6     msg='hello WuDaLang'
 7     print msg
 8     return msg
 9  
10  
11 t1=test01()
12  
13 t2=test02()
14  
15  
16 print(t1)   #None 有返回值  none
18 print(t2)   #hello WuDaLang

总结：当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，

所以在python中即便是过程也可以算作函数。

1 # _*_ encoding:utf-8 _*_
 2 __author__ = 'listen'
 3 __date__ = '2018/11/11 8:32'
 4 
 5 def test01():
 6     pass
 7 
 8 def test02():
 9     return 55
10 
11 def test03():
12     return 0,1,[2,3,4,5],{'name':'alex','age':17}
13 
14 t1=test01()
15 t2=test02()
16 t3=test03()
17 print(t1,t2,t3)
18 
19 #result: None   55     (0, 1, [2, 3, 4, 5], {'name': 'alex', 'age': 17})

总结：

    返回值个数=0，返回None

    返回值个数=1，返回object

    返回值个数>1, 返回tuple

四、函数参数

1、形参：形参变量只有在被调用的时候才会分配内存单元，在调用结束时，即刻释放所分配的内存单元，因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能使用该形参变量

2、实参：实参可以是常量、变量、表达式、函数等，无论实参是任何类型的量，在进行函数调用时，它们都必须有明确的值，以便把这些参数传给形参。因此应预先用赋值，输入等方法使参数获得确定值。

1 def  add(x,y):   #x  y  是形参
2      return x+y
3 
4 
5 a=add(1,2)  #1  2   是实参
6 print(a)

3、位置参数和关键字（标准调用：位置参数必须形参和实参一一对应；关键字调用：位置无须固定）    ----混搭调用，必须位置参数全放左边，而且不能重复调用

1 def add(x,y):
 2     return x+y
 3 # t=add(1,2)  #位置参数 一一对应
 4 # print(t)  #3
 5 
 6 # t=add(y=1,x=2)
 7 # print(t)  #3   关键字参数
 8 
 9 # t=add(1,y=2)
10 # print(t)  #3   混搭  位置参数在左  关键字参数在右

4、默认参数

1 def test(x,y=1):
2     return x+y
3 
4 # t=test(1)  #默认参数y为1
5 # print(t)  #2
6 
7 t=test(1,3)
8 print(t)  #4  指定参数

5、参数组（可变长）

1 # def test(x,*args):  #*args想到列表
 2 # # # #     return x,args
 3 # # # # t=test(1,2,3,4,5)  #把第一个参数后面的所有的参数放到元组的容器中
 4 # # # # print(t)  #(1, (2, 3, 4, 5))
 5 
 6 
 7 # def test1(x,*args):
 8 #     return x,args
 9 # # t=test1(1,*[2,3,4,5])  #传入list得加一个*
10 # # print(t)  #(1, (2, 3, 4, 5))
11 #
12 # t=test1(1,[2,3,4])
13 # print(t)  #(1, ([2, 3, 4],))#元祖的第一个元素
14 
15 # def test2(x,**kwargs):  #**kwargs想到和字典有关
16 #     print(x)
17 #     print(kwargs)
18 
19 # t=test2(2,name='alex',age=18)  #2   {'name': 'alex', 'age': 18}
20 # t=test2(2,{'name':'alex','age':18})  #报错
21 # t=test2(2,**{'name':'alex','age':18})  #2   {'name': 'alex', 'age': 18}
22 
23 # def test3(x,*args,**kwargs): #任意类型参数都可以，任意长度
24 #     print(x)
25 #     print(args)
26 #     print(kwargs)
27 
28 # test3(1,2,3,4,5,['a','b'],name='alex',age=18)
29 #1     (2, 3, 4, 5, ['a', 'b'])   {'name': 'alex', 'age': 18}
30 # test3(2,*[1,2,3,4,5],**{'name':'alex','age':18,'hobby':'baskeball'})
31 #2    (1, 2, 3, 4, 5)      {'name': 'alex', 'age': 18, 'hobby': 'baskeball'}

 五、局部变量和全局变量

局部变量：在子程序定义的变量称为局部变量

          局部变量的作用域是定义该变量的子程序

全局变量：在程序一开始定义的变量为全局变量

          在全局变量作用域是整个程序

当全局变量和局部变量为同名:

          在定义局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用。

1 # _*_ encoding:utf-8 _*_
 2 __author__ = 'listen'
 3 __date__ = '2018/11/11 12:57'
 4 # name='alex'  #全局变量   所有的都可以拿到
 5 # def change_name():
 6 #     print('名字:',name)
 7 # change_name()   #名字: alex  先从内部找name，自己内部没有定义，往上一层一层寻找，知道知道为止
 8 
 9 # def chage_name():
10 #     name='Jenny'   #局部变量  在内部定义，供内部使用（只有自己可以拿到）
11 #     print('名字:',name)
12 # chage_name()   #名字: Jenny
13 # print(name)   #alex  不改变全局变量
14 
15 # def change_name():
16 #     global name     #不是内部定义，引用的全局变量（虚拟）
17 #     name='Jenny'
18 #     print('名字:',name)
19 # change_name()  #名字: Jenny
20 # print(name)  #Jenny  也变为Jenny  全局变量发生改变
21 
22 
23 #全局变量要大写，局部变量要小写
24 #如果函数中无global关键字，优先读取局部变量，没有局部变量会读取全局变量，但是无法对全局变量重新赋值
25     #但是对于可变类型（dict，list），可以对全局变量内部元素进行操作
26 #如果函数中有global关键字，变量本质上就是全局变量，可读取、可赋值
27 
28 
29 #无global
30     # name='alex'
31     # def change_name():
32     #     # name='Danny'  ##若无局部变量，会取到全局变量   名字: alex
33     #     print('名字:',name)
34     # change_name()   #名字: Danny    优先取局部变量
35 
36     # name=['alex','listen']
37     # def change_name():
38     #     name.append('lili')
39     #     print('名字:',name)
40     # change_name()   #名字: ['alex', 'listen', 'lili']
41 
42 #有global
43     # name='alex'
44     # def change_name():
45     #     global name
46     #     name='Danny'
47     #     print('名字',name)
48     # change_name()   #名字 Danny  把全局变量修改了，再读取全局变量都为Danny
49     
50 # name='alex'
51 # def change_name():
52 #     name = 'Danny'
53 #     global name
54 #     print('名字',name)  #不知道用哪个变量，报错   错误写法
55 # change_name()

 应用进阶：

 函数调用的时候才运行，不调用的时候只编译不运行，如下所示：

1 # _*_ encoding:utf-8 _*_
 2 name='alex'              #1
 3 def change_name():      
 4     name='nahao'        #4
 5     def change_name1():
 6         global name     #6
 7         name='hi'        #7  全局变量改为hi
 8     change_name1()       #5  
 9     print(name)   #nihao    #8   局部变量 nihao
10 print(name)   #alex          #2   alex
11 change_name()  #调用               #3
12 print(name)  #hi            #9   hi
13 #result:     alex   nihao   hi

规定：全局变量要大写，局部变量要小写

1 NAME='微风'      #1
 2 def flowers():
 3     name='百合'   #3
 4     print(name)    #4   百合
 5     def grass():
 6         name='芦荟'  #6
 7         print(name)  #7 芦荟
 8         def zoo():
 9             name='麋鹿'  #10
10             print(name)   #11  麋鹿
11         print(name)  #8  芦荟
12         zoo()    #9
13     grass()    #5
14     print(name)  #12  百合
15 flowers()     #2

关键字：global（全局变量） 和 nonlocal（返回上一级变量）

1 name='alex'
 2 def change_name():
 3     name='listen'
 4     def change_name1():
 5         nonlocal name    #使用上一级的变量，不使用全局变量，若没有关键字nonlocal，则默认上一级name，若为global name,则为全局变量,
 6         # name='hi'
 7         print(name)  #listen
 8     change_name1()
 9     print(name)   #listen
10 print(name)  #alex
11 change_name()
12 print(name)   #alex

 六、前向引用之‘函数即变量’

可以把一个函数看做为一个变量，函数名即为变量的地址（门牌号），函数体即为变量，定义一个开辟一个内存，用的时候直接调用。

ep：

1 # _*_ encoding:utf-8 _*_
 2 __author__ = 'listen'
 3 __date__ = '2018/11/12 21:47'
 4 # def nihao():
 5 #     print('how are you!')
 6 #     hi()   # 运行报错hi()没有被定义
 7 # nihao()
 8 #---------------------------------------------------------------------
 9 #先开辟了两块内存 把变量放进去    正常运行
10 # def hi():
11 #     print('nice to meet you!')
12 # def nihao():
13 #     print('how are you!')
14 #     hi()  #调用函数hi()
15 # nihao()  #调用函数nihao()
16 
17 
18 # def nihao():
19 #     print('how are you!')
20 #     hi()
21 # def hi():
22 #     print('nice to meet you!')
23 # nihao()

 七、递归调用

在函数内部，可以调用其他函数，如果在调用一个函数的过程中直接或间接的调用本身称为递归调用（自己调自己）。

1 #_*_ encoding;utf-8 _*_
 2 
 3 # def calc(n):
 4 #     print(n)               #10  5  2  1
 5 #     if int(n/2) ==0:
 6 #         return n     #返回一个1，并没有打印   print是不返回，不结束，只打印
 7 #     return calc(int(n/2))   #calc(5)  calc(2)   calc(1)   类似于上一节的嵌套函数（分尸理论）
 8 # calc(10)
 9 
10 
11 #典型递归（自己调用自己）------问路      得设置结束条件return，要不成了死循环了
12 person_list=['alex','peiqi','haifeng','listen']
13 import time
14 def ask_way(person_list):
15     
16     if len(person_list)==0:
17         return '没人知道路'
18     person = person_list.pop(0)
19     if person=='haifeng':
20         print('%s说:我知道，坐八号线可以到达，地铁上有这一站' % person)
21         return '%s说:我知道，坐八号线可以到达，地铁上有这一站'%person
22     print('hi %s,请问一下奥森怎么走啊?'%person)
23     print('%s回答道:我也不清楚，稍等，我帮您问一下%s!'%(person,person_list))
24     time.sleep(3)
25     res=ask_way(person_list)
26     print('%s问的结果是:%s'%(person,res))
27 
28     return res
29 res=ask_way(person_list)
30 print(res)

输出：

hi alex,请问一下奥森怎么走啊?
alex回答道:我也不清楚，稍等，我帮您问一下['peiqi', 'haifeng', 'listen']!
hi peiqi,请问一下奥森怎么走啊?
peiqi回答道:我也不清楚，稍等，我帮您问一下['haifeng', 'listen']!
haifeng说:我知道，坐八号线可以到达，地铁上有这一站
peiqi问的结果是:haifeng说:我知道，坐八号线可以到达，地铁上有这一站
alex问的结果是:haifeng说:我知道，坐八号线可以到达，地铁上有这一站
haifeng说:我知道，坐八号线可以到达，地铁上有这一站

一层一层调用，一层一层返回

递归特性：

1、必须有一个明确的结束条件（return）

2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少，比如列表的元素。

3、递归的效率不高，递归层次过多会导致栈溢出（因为每次递归都会等待一个结果，只有return到这个结果，才能结束，在此期间它们都占用内存，所有有可能递归多次就会导致内存溢出）

1 # _*_ encoding:utf-8 _*_
 2 L=[2,5,8,11,33,66,77,88]
 3 num=6
 4 def binary_search(L,num):
 5     if len(L)>1:
 6         mid=len(L)//2
 7         if L[mid]==num:
 8             print '找到结果'
 9         if L[mid]>num:
10             return binary_search(L[:mid],num)
11         else:
12             return binary_search(L[mid:],num)
13             
14     else:
15         if L[0]==num:
16             print '找到数字了'
17         else:
18             print '此结果不在列表中'
19         
20     
21 binary_search(L,num)

用递归实现二分查找

 八、嵌套函数和作用域

作用域在定义函数的时候就已经固定，不会随着调用未知的改变而改变（符合前面嵌套函数的定律）------------参考全局变量和局部变量的例子

1 # _*_ encoding:utf-8 _*_
 2 __author__ = 'listen'
 3 __date__ = '2018/11/13 22:20'
 4 # name='alex'
 5 # def foo():
 6 #     name='listen'
 7 #     def bar():
 8 #         print(name)
 9 #     return bar
10 # foo()
11 # a=foo()
12 # print(a)  #return(bar)的地址
13 # a()  #调用函数bar  打印name
14 
15 name='alex'
16 def foo():
17     name='listem'
18     def bar():
19         name='jia'
20         def haha():
21             print(name)
22         return haha
23     return bar
24 a=foo()   #得到bar()的函数名即地址bar      大箱子套小箱子，所以符合分尸定律，一层一层找变量（全局和局部）
25 a()()  #jia  a+()调用bar()函数 + ()  调用haha()  打印name jia

 九、匿名函数

没有函数名的函数为匿名函数(lambda+参数名:返回值---相当于return后面的)

1 #一个参数
 2 def add(x):
 3     return x+1
 4 a=add(1)
 5 print(a)  #2
 6 fun=lambda x:x+1  #加上函数名  和 普通函数没什么区别，但是匿名函数主要不这么用，主要搭配其他函数使用
 7 b=fun(1)
 8 print(b)  #2
 9 #多个参数也是可以的
10 f=lambda x,y,z:(x+1,y+1,z+1)   #普通函数不需要带括号，因为自动转换为元组形式，但匿名函数需要加上括号
11 c=f(1,2,3)
12 print(c)  #(2, 3, 4)

 十、函数式编程

 函数式=编程语言定义的函数+数学意义的函数

编程方法论（功夫论）：

            1、面向过程（有赋值操作，找到问题的入口，按照一个固定的流程，一步一步实现结果，可读性高）

            2、函数式编程（不同于面向过程，直接定义函数然后返回，没有赋值操作，可读性低），函数式就是用编程语言去实现数学函数，这种函数内对象是永恒不变的，要么参数是函数，要么返回值是函数，没有for和while循环，所有循环都是用递归去实现，无变量的赋值（即不用变量取保存状态），无赋值即不改变。

            3、面向对象

 十一、高阶函数

满足下面两个特性的任意一个为高阶函数：

1、函数传入参数是一个函数名

2、函数的返回值是一个函数名

①map()

map函数接收一个函数f和list，并通过把函数f一次作用到list每个元素上，得到一个新的list，并返回。

 

1 # _*_ encoding:utf-8 _*_
 2 #map()
 3 #匿名函数
 4 # a=[1,2,3,4,5]
 5 # b=map(lambda x:x**2,a)
 6 # print(a)  #[1, 2, 3, 4, 5]
 7 # print(b)   #[1, 4, 9, 16, 25] 返回一个新的list，不是在原来的list上改变
 8 
 9 #普通函数
10 li=[1,2,3,4,5]
11 def cal(x):
12     return x+1
13 ret=map(cal,li)
14 print(ret)
15 #[2, 3, 4, 5, 6]

 

②reduce()

reduce()函数接收的参数和map()类似，一个函数f，一个list，但行为和map不同，reduce()传入的函数f参数必须为两个，reduce()对list的每个元素反复调用函数f，并返回最终结果值（合并值），并且可以赋一个默认初始值init=none，下面的参数可以自定义初始值reduce(f,iterable,初始值)。

1 li=[2,3,4,5,6]
2 def add(x,y):
3     return x+y
4 a=reduce(add,li)
5 print(a)   #20

③filter()

filter()函数接收一个函数f和一个list，这个函数f的作用是对每个元素进行判断，返回True和False,filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件(条件一般为过滤的相反情况)元素组成新的list

1 li=['alex','aden','baner','listen','Adfe']
2 def start(x):
3     x=str(x).lower()
4     return x.startswith('a')
5 ret=filter(start,li)
6 print ret    #['alex', 'aden', 'Adfe']

 详细：

1 # _*_ encoding:utf-8 _*_
  2 __author__ = 'listen'
  3 __date__ = '2018/11/15 22:47'
  4 # L=[1,2,3,4,5]
  5 # ret=[]
  6 # def add(x):
  7 #     return x+1
  8 # def redc(x):
  9 #     return x-1
 10 # def cheng(x):
 11 #     return x**2
 12 # def map_test(fun,array):
 13 #     for i in array:
 14 #         ret.append(fun(i))
 15 #     return ret
 16 # # res=list(map_test(add,L))
 17 # res=list(map_test(lambda i:i+1,L))
 18 # print(res)
 19 L=[1,2,3,4,5]
 20 res=list(map(lambda x:x+1,L))
 21 print(res) 
 22 
 23 #普通的逻辑写出各个元素相乘
 24 # L=[2,3,4,5,100]
 25 # s=[]
 26 # ret=1
 27 # for i in L:
 28 #     ret*=i
 29 # print(ret)
 30 
 31 # L=[1,3,4,5,100]
 32 # def cal(x,y):
 33 #     return x*y
 34 #
 35 # def reduce_test(fun1,array):
 36 #     ret = array.pop(0)
 37 #     for i in array:
 38 #         ret=cal(ret,i)
 39 #     return ret
 40 # res=reduce_test(cal,L)
 41 # print(res)
 42 
 43 #匿名函数
 44 # L=[1,3,4,5,100]
 45 # # def cal(x,y):
 46 # #     return x*y
 47 #
 48 # def reduce_test(fun1,array):
 49 #     ret = array.pop(0)
 50 #     for i in array:
 51 #         ret=fun1(ret,i)
 52 #     return ret
 53 # res=reduce_test(lambda x,y:x*y,L)
 54 # print(res)
 55 
 56 #用reduce函数
 57 # L=[1,3,4,5,100]
 58 # res=reduce(lambda x,y:x*y,L)
 59 # print(res)
 60 
 61 
 62 #filter功能
 63 #用普通函数实现
 64 # L=['alex','asfd','Adef','listen','peiqi','qiaozhi']
 65 # s=[]
 66 # for i in L:
 67 #     i=i.lower()
 68 #     if i[0]=='a':
 69 #         s.append(i)
 70 #
 71 # print(s)
 72 
 73 #用函数实现
 74 # L=['alex','asfd','Adef','listen','peiqi','qiaozhi']
 75 # s=[]
 76 # def test(array):
 77 #     for i in array:
 78 #         i=i.lower()
 79 #         if i[0]=='a':
 80 #             s.append(i)
 81 #     return s
 82 #
 83 # res=test(L)
 84 # print(res)
 85 
 86 
 87 #变为活的，优化
 88 L=['alex','asfd','Adef','listen','peiqi','qiaozhi']
 89 # def f(x):
 90 #     x=str(x).lower()
 91 #     return x.startswith('a')
 92 
 93 
 94 # def test(fun,array):
 95 #     s=[]
 96 #     for i in array:
 97 #         if fun(i):
 98 #             s.append(i)
 99 #
100 #     return s
101 #
102 # res=test(lambda x:str(x).startswith('a'),L)
103 # print(res)
104 
105 #用高阶函数filter
106 res=filter(lambda x:str(x).startswith('a'),L)
107 print(res)

map(),reduce(),filter()高阶函数的由来

 十二、内置函数

1 # _*_ encoding:utf-8 _*_
  2 __author__ = 'listen'
  3 __date__ = '2018/11/17 8:51'
  4 #hash算法   可哈希即不可变数据类型  不可哈希是可变数据类型
  5           #1、不会随着传入参数长度变化，结果长度不会变
  6           #2、不能够根据得到的结果反推出来原来的字符串
  7           #3、安全性，防止被不法人修改程序，导致下载程序不是原来官网的初始程序，这样可以进行前后结果的比对，相同再下载，防止中木马。
  8 # print(hash('123456789'))  #-1948805033569931688
  9 # print(hash('888888888888'))#2317226664654541264
 10 #
 11 #
 12 #
 13 # print(abs(-1))#取绝对值  #1
 14 # print(all([1,2,0]))#参数一定是可迭代类型，可以为空列表、空元祖、空字符串为True，只有可迭代内部有一个为假，则整个为假，全部为真则为真
 15 # print(any([0,1]))#也是可迭代，一个为真则为真
 16 # print(bin(2))#把10进制转为2进制  0b开头为2进制  #0b10
 17 # print(bool(None))  #判断是否为布尔值真假  空的为假
 18 
 19 # #bytes（）把一个字符串变为字节  ascii不能编码中文
 20 # name='你好'
 21 # print(bytes(name,encoding='utf-8'))  #变为16进制的你好  三字节  b'\xe4\xbd\xa0\xe5\xa5\xbd'  编码
 22 # print(bytes(name,encoding='utf-8').decode('utf-8'))  #你好  解码  用什么编码就用什么解码
 23 # print(bytes(name,encoding='utf-8').decode('gbk'))  #浣犲ソ  乱码形式就由于编码和解码不一样所以才乱
 24 # print(bytes(name,encoding='gbk'))   #b'\xc4\xe3\xba\xc3'  双字节
 25 # print(bytes(name,encoding='gbk').decode('gbk'))  #你好
 26 
 27 # print(chr(56))  #8   56十进制数字代表ascii的值为8
 28 # print(ord('8'))  #把ascii中的‘8‘转换为十进制的56
 29 #  print(chr(97))   #a
 30 
 31 # print(dir(dict))  #打印dict的属性和方法  主要目的查看
 32 
 33 # print(divmod(10,3))  #(3, 1) 做除法运算，取商和余数  主要用于分页  第一个参数总共有几条记录，第二个参数每页有几条记录，分几页，整除不了在来一页
 34 
 35 # dic={'name':'alex','age':17}
 36 # print(list(enumerate(dic,1)))  #[(1, 'name'), (2, 'age')]     用于将一个可遍历的对象组合为一个索引序列，同时列出数据和数据下标，一般用于for循环中
 37 
 38 # num='1+2+3+(3*9)/2'
 39 # print(eval（num))  #19.5  直接计算表达式的结果
 40 # st=str(dic)
 41 # print(eval（st))  #转换为最初始的数据类型
 42 
 43 # name1='alex'
 44 # print(globals())  #把全局变量显示出来，自带和自己定义的
 45 # def fun():
 46 #     name='listen'
 47 #     print(locals())
 48 # fun()  #{'name': 'listen'}   只显示局部变量
 49 
 50 # print(help(abs))  #告诉你怎么用   变量怎么使用
 51 
 52 # #ID  显示内存地址
 53 
 54 # print(hex(15)) #10进制对应的16进制
 55 # print(bin(2))  #10进制对应的2进制
 56 # print(oct(8))  #10进制对应的8进制
 57 
 58 # print(isinstance('a',str))  #True ta是ta的子类吗
 59 
 60 # b=list(zip(['alex','listen','haifeng'],[1,2,3]))  #只有里面是两个序列就可以 列表 元组 字符串 字典
 61 # print(b)
 62 #
 63 #
 64 # #max用法   比较同类型的 for比较
 65 # l1=[1,2,3,4]
 66 # print(max(l1))  #4  最简单的
 67 # dic1={'alex':18,'listen':23,'lhf':30}
 68 # print(max(dic1)) #得到listen 比较的是key  我想得到value值
 69 # print(max(dic1.values()))  #30  只得到value的最大值  没有得到相应的key
 70 # print(max(list(zip(dic1.values(),dic1.keys()))))  #(30,'lhf')  #max 是可迭代对象的比较 一个一个遍历比较  比较到大的就停止
 71 # print(max('axc','acf'))  #先比较第一个a  然后x>c   z直接取出axc 不进行后来的比较
 72 #终极玩法：
 73 # salaries=[
 74 #     {'name':'alex','salary':3000},
 75 #     {'name': 'listen', 'salary': 4000},
 76 #     {'name': 'lhf', 'salary': 10000},
 77 # ]
 78 # #字典是不能比较的
 79 # print(max(salaries,key=lambda dic:dic['salary']))  #{'name': 'lhf', 'salary': 10000}  dic是列表中的每一个字典  把每一个dict作为一个变量，返回这个变量对应key的value
 80 
 81 # print(pow(2,2)) #2**2
 82 # print(pow(3,2,2))  #3**2 %2
 83 
 84 # s=['a','c','d','b']
 85 # print(sorted(s))  #['a', 'b', 'c', 'd']  从小到大排序
 86 # salaries=[
 87 #     {'name':'alex','salary':3000},
 88 #     {'name': 'listen', 'salary': 4000},
 89 #     {'name': 'lhf', 'salary': 10000},
 90 # ]
 91 # print(sorted(salaries,key=lambda dic:dic['salary']))  #[{'name': 'alex', 'salary': 3000}, {'name': 'listen', 'salary': 4000}, {'name': 'lhf', 'salary': 10000}]
 92 # salary={
 93 #     'peiqi':1000,
 94 #     'alex':300,
 95 #     'listen':500,
 96 #     'lhf':1200
 97 # }
 98 #按照数字排序
 99 # print(sorted(salary.values()))  #[300, 500, 1000, 1200]
100 # print(sorted(salary,key=lambda k:salary[k])) #['alex', 'listen', 'peiqi', 'lhf']
101 # print(sorted(zip(salary.values(),salary.keys()))) #[(300, 'alex'), (500, 'listen'), (1000, 'peiqi'), (1200, 'lhf')]
102 
103 # print(round(2.6)) #3  四舍五入
104 
105 # tu=(1,2,3,4,5)
106 # s=slice(0,4)
107 # print(tu[s])  #(1, 2, 3, 4)
108 
109 #type用法
110 # num='123'
111 # if type(num) is str:
112 #     num=int(num)
113 #     c=num+1
114 # print(c)  #124
115 
116 # def des():
117 #     name='alex'
118 #     print(locals())
119 #     print(vars(int))
120 # des()  #{'name': 'alex'}  返回的是一个字典  当vars()没有参数时作用相当于locals()  当有参数时，把参数下的所有属性以字典的形式展出来