python学习-第7课

原创 2018年04月16日 16:52:55

一、函数(补充)

1.1.函数定义

你可以定义一个由自己想要功能的函数,以下是简单的规则:
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
使用 def 关键字,一般格式如下:
def 函数名(参数列表):
    函数体
示例:
def add(x, y):
    print("x+y={0}".format(x + y))
    return x + y
add(34, 40)
返回结果:
x+y=74

1.2.函数关键字

def :定义函数
return:返回值
pass:略过
exit(1):直接退出
示例1:
#字符遇到e就pass,遇到t就返回
str = "appletestletappendeverythingfinished"
def check(s):
    for i in s:
        if i == "e":
            pass
            print("遇到e了,直接pass")
        elif i=="t":
            print("字母t的下标为:{0}".format(i))
            return s.index("t")
        print("当前字母为:{0}".format(i))
if __name__=="__main__":
    check(str)

示例2:
def test():
    while 1:
        n = input("请输入字符串:")
        if n=="quit":
            print("输入了quit,程序直接退出")
            exit(1)
        for i in range(0,len(n)):
            print(n[i])

if __name__=="__main__":
    test()

1.3.函数参数

函数可以是字符串,还可以是以下两种类型参数
def(*args, **kwargs)
其中:
*args:元组类型参数 tuple(1,)

**kwargs:字典类型参数,dict{"k":"v"}
示例:
def fun(*args1,**args2):

    print("*args1元组参数为:{0}".format(args1))
    print("**args2字典参数为:{0}".format(args2))

if __name__=="__main__":
    fun(1,2,3,4,5,a="test1",b="test2")
结果
*args1元组参数为:(1, 2, 3, 4, 5)
**args2字典参数为:{'a': 'test1', 'b': 'test2'}

1.4.匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式,函数体比 def 简单很多。
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
如:
lambda x,y:x+y
相当于
def add(x,y):
     return x+y
示例
#求两个数的和
sums=lambda x,y:x+y
print("和为:{0}".format(sums(20,30)))
结果
和为:50

1.5.高阶函数

1.5.1.map

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
不常用

语法
map(function, iterable)
参数
function -- 函数,有两个参数
iterable -- 一个或多个序列
返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器。
示例
#求两个列表对应位置的数据之和
print("两个列表相应位置元素之和为:{0}".format(list(map(lambda x,y:x+y,[1,2,3,4,5],[11,12,13,14,15]))))

1.5.2.reduce

reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给reduce中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。
不常用
语法
reduce(function, iterable[, initializer])
参数
function -- 函数,有两个参数
iterable -- 可迭代对象
initializer -- 可选,初始参数
返回值
返回函数计算结果。
示例
from functools import reduce
def add(x,y):
    return x+y
print(reduce(add,[1,2,3,4,5]))

1.5.3.filter

filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
语法
filter(function, iterable)
参数
function -- 判断函数。
iterable -- 可迭代对象。
返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器。
示例
def grok(n):
    return n%2==1
newlist=filter(grok,[12,13,15,16,18,1,7,19,22,25,31,34])
print(list(newlist))

1.5.4.sorted排序

sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作
语法
sorted(iterable, key=None, reverse=False)  
参数
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
返回值
返回重新排序的列表。
m = dict(a=1,c=10,b=20,d=15)
print(m)
print(sorted(m.items(),reverse=True))  #默认以第一列值进行排序,即以key进行排序
print(dict(sorted(m.items(),key=lambda x:x[1])))  #以value值进行排序,x[0]指的是key,x[1]指的是value
结果
{'a': 1, 'c': 10, 'b': 20, 'd': 15}
[('d', 15), ('c', 10), ('b', 20), ('a', 1)]
{'a': 1, 'c': 10, 'd': 15, 'b': 20}

二、生成式和生成器

2.1.生成式

列表生成式格式
[exp for val in collection if condition]
示例:
#九宫格
def jgg():
    count = 1
    number = list()
    for i in range(1, 10):
        number.append(i)
    for A in [x for x in range(1, 10)]:
        for B in [x for x in range(1, 10) if x != A]:
            for C in [x for x in range(1, 10) if x != A and x != B]:
                for D in [x for x in range(1, 10) if x != A and x != B and x != C]:
                    for E in [x for x in range(1, 10) if x != A and x != B and x != C and x != D]:
                        for F in [x for x in range(1, 10) if x != A and x != B and x != C and x != D and x != E]:
                            for G in [x for x in range(1, 10) if
                                      x != A and x != B and x != C and x != D and x != E and x != F]:
                                for H in [x for x in range(1, 10) if
                                          x != A and x != B and x != C and x != D and x != E and x != F and x != G]:
                                    for I in [x for x in range(1, 10) if
                                              x != A and x != B and x != C and x != D and x != E and x != F and x != G and x != H]:
                                        if ( A + B + C == D + E + F == G + H + I == A + D + G == B + E + H == C + F + I == A + E + I == G + E + C == 15):
                                            print('''
                                            第{9}种排序
                                            -------
                                            |{0}|{1}|{2}|
                                            |{3}|{4}|{5}|
                                            |{6}|{7}|{8}|
                                            -------
                                            '''.format(A, B, C, D, E, F, G, H, I, count))
                                            count += 1

jgg()


结果
                                          第1种排序
                                            -------
                                            |2|7|6|
                                            |9|5|1|
                                            |4|3|8|
                                            -------
                                            


                                            第2种排序
                                            -------
                                            |2|9|4|
                                            |7|5|3|
                                            |6|1|8|
                                            -------
                                            


                                            第3种排序
                                            -------
                                            |4|3|8|
                                            |9|5|1|
                                            |2|7|6|
                                            -------
                                            


                                            第4种排序
                                            -------
                                            |4|9|2|
                                            |3|5|7|
                                            |8|1|6|
                                            -------
                                            


                                            第5种排序
                                            -------
                                            |6|1|8|
                                            |7|5|3|
                                            |2|9|4|
                                            -------
                                            


                                            第6种排序
                                            -------
                                            |6|7|2|
                                            |1|5|9|
                                            |8|3|4|
                                            -------
                                            


                                            第7种排序
                                            -------
                                            |8|1|6|
                                            |3|5|7|
                                            |4|9|2|
                                            -------
                                            


                                            第8种排序
                                            -------
                                            |8|3|4|
                                            |1|5|9|
                                            |6|7|2|
                                            -------


2.2.生成器(generator)

方法一:
#列表生成式为[],生成器为()
(exp for val in collection if condition)

方法二:
使用yield关键字,包含yield语句的函数会被特地编译成生成器
跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器(iter和next)。
在调用生成器运行的过程中,yield可以理解成return,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数,返回的是一个迭代器对象。
示例
def test():
    for i in range(1,10):
        yield i


print("=====" * 10)
m = test()  #生成了一个迭代器
print(m)
for i in iter(m):
    print(i)

结果
==================================================
<generator object test at 0x00000000026F7570>
1
2
3
4
5
6
7
8
9

什么情况下需要使用 yield?
一个函数 f,f 返回一个迭代器,这个迭代器是动态计算出来的(不管是数学上的计算还是逻辑上的读取格式化),并且这个迭代器会很大(无论是固定很大还是随着输入参数的增大而增大),这个时候,我们希望每次调用这个函数并使用迭代器进行循环的时候一个一个的得到每个元素来节省内存,这个时候 yield 就很有用。





版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/biankm_gz/article/details/79956418

Python学习手册(第4版) pdf

下载地址:网盘下载  内容简介  · · · · · ·Google和YouTube由于Python的高可适应性、易于维护以及适合于快速开发而采用它。如果你想要编写高质量、高效的并且易于与其他语言和工...
  • cf406061841
  • cf406061841
  • 2018年02月28日 09:49
  • 290

第7课

//Stack.h #ifndef STACK_H #define STACK_H typedef struct Stack{ void* elems; int logical_le...
  • pltc325
  • pltc325
  • 2011年04月13日 21:28
  • 194

Nehe的OpenGL的第6,7课的笔记

OpenGL纹理坐标: 左下角为原点, 向右为正X, 向上为正Y.OpenGL世界坐标: 向右为正X, 向下为正Y.DirectX纹理坐标:  向右为正X, 向下为正Y.使用光源时, 必须设置法线au...
  • ltttklyzy
  • ltttklyzy
  • 2011年04月29日 11:19
  • 258

第七课 策略模式

第七课 策略模式        今天来看看策略模式吧。首先,策略模式定义:       策略模式定义了算法家族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化不会影响到使用算法的客户。   ...
  • lanwilliam
  • lanwilliam
  • 2008年10月24日 14:50
  • 852

《python学习手册》阅读笔记5.1-5.14

不知不觉这么久没写了,两周时间,看完了字符串,列表与字典,元组与文件,整个第二部分啃完了,第三部分是语句,再往后好像就是平时写的时候没接触过的比较深的东西了,到时候应该会写详细点。...
  • zhu_free
  • zhu_free
  • 2015年05月14日 11:24
  • 1140

Python学习手册(第4版) PDF

1.Python学习手册(第4版) 2.需要电子版(非免费),请联系qq:2328726563
  • qq_41662347
  • qq_41662347
  • 2018年02月21日 19:04
  • 87

《零基础入门学习Python》学习笔记1

第一讲 我和Python的第一次亲密接触 Python输出语句:print("i love python")注意后面没有分号; Python可以直接进行加法乘法等运算,没有变量类型的限制,比如...
  • weixin_39673207
  • weixin_39673207
  • 2017年11月13日 19:50
  • 53

Python快速学习第五天

第五天:抽象 1、    函数 检测函数是否可调用:callable >>> import math >>> y=math.sqrt >>> callable(y) True >>>...
  • tanggao1314
  • tanggao1314
  • 2016年08月14日 22:21
  • 1483

Python3第7课-----面向对象

初识类 class Person: name='' age=0 def __init__(self,name,age): #构造函数 self.name=...
  • ccnuacmhdu
  • ccnuacmhdu
  • 2018年04月05日 12:43
  • 1

第7课 面向对象的基本概念

面向对象的基本概念 (1)类和对象是面向对象中的两个基本概念 (2)“类”指的是一类事物,是一个抽象的概念 (3)“对象”指的是属于某个类的一个实体,是一个具体存在的事物 ——类是一种模板,可...
  • qq_27522735
  • qq_27522735
  • 2017年06月27日 22:58
  • 106
收藏助手
不良信息举报
您举报文章:python学习-第7课
举报原因:
原因补充:

(最多只允许输入30个字)