python世界level3

本节内容

1. 函数基本语法及特性

2. 参数与局部变量

3. 返回值

嵌套函数

4.递归

5.匿名函数

6.函数式编程介绍

7.高阶函数

8.内置函数

1. 集合

主要做用: 

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

    1 #!/usr/bin/env python
    2 #Author:Ponke91
    3 
    4 list_1=[1,2,3,4,5,6,6,2,435,224,2,21,3]
    5 list_1=set(list_1)
    6 list_2=set([1,3,423,4,5123,21])
    7 print(list_1)
    8 print(list_1.intersection(list_2))#取交集
    9 print(list_1.union(list_2))#取并集
   10 print(list_1.difference(list_2))#差集
   11 print(list_2.difference(list_1))#子集
   12 print(list_1.issubset(list_2))
   13 print(list_1.issuperset(list_2)) #父级
   14 print(list_2.symmetric_difference(list_1))#对称差集，去掉两个集合中重复得元素
   15 print(list_2.isdisjoint(list_1))#判断两个集合是否有交集 若是没有交集 返回True
   16 print(list_1 & list_2)#交集
   17 print(list_2 | list_1)#并集union
   18 print(list_2 - list_1)#差集
   19 print(list_1 ^ list_2)#对此差集
   20 
   21 #集合增删改查
   22 print(list_2.add(1))#增长 单个添加
   23 print(list_2.update([3,33,66]))#多个增长
   24 print(list_2.remove(3))#移除 若是移除得数不存在 会报错
   25 print(list_2.discard(2))#移除，若是移除的元素不存在，值为假
   26 
   27 print(list_2)

   View Code

    

2. 元组　　

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

做用：若是一些数据不想被人修改， 能够存成元组，好比身份证列表

#!/usr/bin/env python
#Author:Ponke91

Tuple=("ponke",'dd','33141')#元组不可变只有 ，经常使用来做为重要参数不可变
print(Tuple.count("ponke"))#count 统计
print(Tuple.index('dd'))#，index 获取下标

View Code

 

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的内存地址那取值就能够了。

 1 #!/usr/bin/env python
 2 #Author:Ponke91
 3 xiaozi={
 4     'stu001':'001',
 5     'stu002':'003',
 6     'stu004':3,
 7     'stu005':['1','2']
 8 
 9 }
10 print(xiaozi['stu005'])
11 xiaozi['stu002']='奥迪'
12 
13 del xiaozi['stu001']
14 xiaozi.pop("stu004")#删除
15 #xiaozi.popitem()#随机删除
16 print(xiaozi)
17 print(xiaozi.get("stu005"))
18 print("stu006" in xiaozi)
19 xiaozi.values()#全部的值
20 xiaozi.setdefault("台湾",{'www.baidu.com':[1,2]})#使用方式在字典中查找是否存在该值，若是存在不修改直接返回该值，若是不存在则修改
21 xxx={'zhangsan':'lsi','afjals':'111'}
22 xiaozi.update(xxx)#合并两个列表，重复的值使用XXX更新，没有的值进行建立
23 xiaozi.items()
24 print(xiaozi.items())#字典转换成列表
25 t=dict.fromkeys(['1','2','3'],'oooo')#初始化一个字典 内存地址不可变
26 print(t)

View Code

4. 字符编码

 

先说python2

1. py2里默认编码是ascii
2. 文件开头那个编码声明是告诉解释这个代码的程序 以什么编码格式 把这段代码读入到内存，由于到了内存里，这段代码实际上是以bytes二进制格式存的，不过即便是2进制流，也能够按不一样的编码格式转成2进制流，你懂么？
3. 若是在文件头声明了#_*_coding:utf-8*_，就能够写中文了， 不声明的话，python在处理这段代码时按ascii，显然会出错， 加了这个声明后，里面的代码就全是utf-8格式了
4. 在有#_*_coding:utf-8*_的状况下，你在声明变量若是写成name=u"大保健"，那这个字符就是unicode格式，不加这个u,那你声明的字符串就是utf-8格式
5. utf-8 to gbk怎么转，utf8先decode成unicode,再encode成gbk

再说python3

1. py3里默认文件编码就是utf-8,因此能够直接写中文，也不须要文件头声明编码了，干的漂亮
2. 你声明的变量默认是unicode编码，不是utf-8, 由于默认便是unicode了（不像在py2里，你想直接声明成unicode还得在变量前加个u）, 此时你想转成gbk的话，直接your_str.encode("gbk")便可以
3. 但py3里，你在your_str.encode("gbk")时，感受好像还加了一个动做，就是就是encode的数据变成了bytes里，我擦，这是怎么个状况，由于在py3里，str and bytes作了明确的区分，你能够理解为bytes就是2进制流，你会说，我看到的不是010101这样的2进制呀， 那是由于python为了让你能对数据进行操做而在内存级别又帮你作了一层封装，不然让你直接看到一堆2进制，你能看出哪一个字符对应哪段2进制么？什么？本身换算，得了吧，你连超过2位数的数字加减运算都费劲，还仍是省省心吧。　　
4. 那你说，在py2里好像也有bytes呀，是的，不过py2里的bytes只是对str作了个别名(python2里的str就是bytes, py3里的str是unicode)，没有像py3同样给你显示的多出来一层封装，但其实其内部仍是封装了的。 这么讲吧， 不管是2仍是三， 从硬盘到内存，数据格式都是 010101二进制到-->b'\xe4\xbd\xa0\xe5\xa5\xbd' bytes类型－－>按照指定编码转成你能看懂的文字

编码应用比较多的场景应该是爬虫了，互联网上不少网站用的编码格式很杂，虽然总体趋向都变成utf-8，但如今仍是很杂，因此爬网页时就须要你进行各类编码的转换，不过生活正在变美好，期待一个不须要转码的世界。

1 #!/usr/bin/env python
2 #Author:Ponke91
3 #-*- encoding:gbk -*-
4 s='你好'
5 print(s.encode('gbk'))
6 print(s.encode('utf-8'))
7 print(s.encode('utf-8').decode('utf-8').encode('gb2312').decode('gb2312'))

View Code

五 函数

一、函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不一样的，具体区别，咱们后面会讲，编程中的函数在英文中也有不少不一样的叫法。在BASIC中叫作subroutine(子过程或子程序)，在Pascal中叫作procedure(过程)和function，在C中只有function，在Java里面叫作method。

定义: 函数是指将一组语句的集合经过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名便可

特性:

1. 减小重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

二、

函数参数与局部变量　　

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

实参能够是常量、变量、表达式、函数等，不管实参是何种类型的量，在进行函数调用时，它们都必须有肯定的值，以便把这些值传送给形参。所以应预先用赋值，输入等办法使参数得到肯定值

 1 #!/usr/bin/env python
 2 #Author:Ponke91
 3 def func(n):
 4     print(n)
 5     n=n/2
 6     if int(n/2)==0:
 7         print(n)
 8         return
 9     else:
10         func(n)
11 # x=func(10)
12 # print(x)

View Code

 1 #!/usr/bin/env python
 2 #Author:Ponke91
 3 #函数
 4 def fun1():
 5     "text1"
 6     print("in the func 1")
 7     return 0
 8 x=fun1()
 9 print(x,type)
10 #过程
11 def func2():
12     "text2"
13     print('in the func 2')
14 y=func2()
15 print(y,type)

View Code

 1 #!/usr/bin/env python
 2 # Author:Ponke91
 3 import time
 4 
 5 def logi():
 6     current_time = '%Y-%m-%d %X'
 7     time_format = time.strftime(current_time)
 8     with open('a.txt', 'a+') as f:
 9         f.write("%s xiajibashuoeveryday\n" % time_format)
10 
11 
12 def test1():
13     print("in the test1")
14 
15     logi()
16 
17 
18 def test2():
19     print("in the test2")
20     logi()
21 
22 
23 def test3():
24     print("in the test3")
25     logi()
26 test1()
27 test2()
28 test3()

View Code

 1 #!/usr/bin/env python
 2 #Author:Ponke91
 3 def test1():
 4     print('in the test 1')
 5     #return 0
 6     #print('ddd')
 7 #x=test1()#函数体返回的值
 8 #print(x)
 9 def test2():
10     print('in the test 1')
11     return 0
12 def test3():
13     print('in the test 1')
14     return 1,'hello',['alex','ponke91'],{'name':'ponke'}
15 x=test3()
16 print(x.count(1))
17 #不返回值，则为none，返回一个值，object，返回多个值，tuple

View Code

 1 #!/usr/bin/env python
 2 # Author:Ponke91
 3 def test(x, y):
 4     x=float(x)
 5     y=float(y)
 6     x_1 = x - 3 + 1
 7     y_1 = y + 2 + 1
 8     print(x_1, y_1)
 9     return x_1, y_1
10 
11 #标准调用，关键字一一对应，关键字调用，位置无关
12 test(3, 5.2)

View Code

 1 #!/usr/bin/env python
 2 # Author:Ponke91
 3 # def test(x,y=2):#默认参数,若是不赋值就使用默认参数，若是赋值则使用实参。
 4 #     print(x)
 5 #     print(y)
 6 # test(1,3)
 7 # '''def conn(host,prot=3306):
 8 #     pass
 9 # conn(1)'''
10 # def test1(*args):#表明参数数量不固定  接受位置参数转化成元组
11 #     print(args)
12 # test1(123,41341,535,)
13 # # **kwargs 把关键字参数转化成字典
14 # def test3(**kwargs):
15 #     print(kwargs)
16 #     print(kwargs['name'])
17 # #test3(name='ponke',sex='none')
18 # test3(**{'name':'ponke','age':'sando'})
19 def test4(name, age=18, *args, **kwargs):
20     print(name)
21     print(age)
22     print(args)
23     print(kwargs)
24     logger('zhangsan')
25 
26 
27 def logger(source):
28     print("%s in test4" % source)
29 
30 
31 test4('ponker91',28, *[11,'爱好', 123, 111, 'lll'], **{'大约': 12, 'xiaoyu': 'jghg'})

View Code

3.返回值　　

要想获取函数的执行结果，就能够用return语句把结果返回

注意:

1. 函数在执行过程当中只要遇到return语句，就会中止执行并返回结果，so 也能够理解为 return 语句表明着函数的结束
2. 若是未在函数中指定return,那这个函数的返回值为None

4. 递归

在函数内部，能够调用其余函数。若是一个函数在内部调用自身自己，这个函数就是递归函数

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减小

3. 递归效率不高，递归层次过多会致使栈溢出（在计算机中，函数调用是经过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。因为栈的大小不是无限的，因此，递归调用的次数过多，会致使栈溢出）

5. 匿名函数 

匿名函数就是不须要显式的指定函数

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

View Code

也许会说，用上这个东西没感受有毛方便呀， 。。。。呵呵，若是是这么用，确实没毛线改进，不过匿名函数主要是和其它函数搭配使用的呢，以下

1 res = map(lambda x:x**2,[1,5,7,4,8])
2 for i in res:
3     print(i)

View Code

 

 

出

125491664