编程语言
首页 > 编程语言> > python世界level3

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

五 函数

1、函数是什么?

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

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

特性:

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

2、

函数参数与局部变量  

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

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

 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

 

 

1
25
49
16
64

标签:函数,python,世界,list,xiaozi,level3,print,def
来源: https://www.cnblogs.com/ponke91/p/11601424.html