序列操作函数：

all()用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE，如果是，返回True，否则返回False元素，除了0、空、FALSE外都算TRUE

序列对象：str 元组、list

函数等价于：

def all(iterable):

      for element in iterable:

           if not element:

                return False

       return False

语法：all(iterable)

参数：iterable -- 元组或列表

返回值：如果iterable的所有元素不为0、‘’、False或者iterable为空，all(iterable返回TRUE，否则返回FALSE

注意：空元祖、空列表返回值为True,这里要特别注意

案例：

li = [1, 2, 3]

all(li)

True

li = [1, 2, 3, 0]

all(li)

False

any()

函数用于判断给定的可迭代参数iterable是否全部为FALSE，则返回False, 如果有一个为True, 则返回True

元素除了是0、空、False外都算TRUE

函数等价于：

def any(iterable):

      for element in iterable:

           if element:

                return True

      return False

语法：any(iterable)

参数：iterable -- 元组或列表

返回值：如果都为空、0、False，则返回False, 如果不都为空、0、False, 则返回True

案例：

li = [1, 2, 3, 0]

any(li)

True 

安逸result： bool类似于逻辑运算符or的判断，只要有一个元素为TRUE结果就为True

sorted()

reverse()

zip()

enumrate 

类型转换

int()

hex()将10进制转换成16进制（0x开头）

bin()把10进制转换成二进制

chr()数字转字符

bool()

list():将元组转换为列表

tuple()将序列转换为元组

bytes()转为字节数组

描述：bytes()方法返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围：0<= x < 256

语法：class bytearray(source[, encoding[, errors]]])

参数

source为整数，则返回一个长度为source的初始化数组

source为字符串，则按照指定的encoding将字符串转换为字节序列；

source为可迭代类型，则元素必须为[0,255]中的整数；

source为与buffer接口一致的对象，这次对象也可以被用于初始化bytes

如果没有输入任何参数，默认就是初始化数组为0个元素

返回值：返回新字节数组

什么是内置函数：

所谓内置函数就是python安装后就自带有的函数，如同人一生下来就有手脚，会吃喝一样，具备基本的能力，随着成长和学习，我们学会了说话、学会了工作，学会了技能等，而这些能力就如同我们Python的扩展函数或扩展库。

常用数学运算函数

abs() 求绝对值

round()对浮点数取近似值，保留几位小数点

语法round(x[, n])

参数：

*  x--数值表达式

*  n--数值表达式

返回值：返回浮点数x的近似值

注意：这里不完全是按照传统的四舍五入或者四舍六入五成双来去值得，取值和python的版本有关，还和浮点数精度有关

pow()

divmod()求商和余数

max()求最大值

返回给定参数的最大值，参数可以为序列；

语法max(x, y, z, ……）

参数：

x, y, z: 数值表达式

sum():对系列进行求和计算

语法：sum(iterable[, start])

参数：iterable - 可迭代对象，如：列表、元组、集合。

start -- 指定相加的参数，如果没有设置这个值，默认为0

返回值：返回计算结果

min()

eval()执行字符串表达式

描述：eval()函数用来执行一个字符串表达式，并返回表达式的值

语法：eval(expression[, global[s, locals]])

参数：

expression - 表达式

globals - 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象

locals - 变量作用域，局部命名空间，如果被提供，可以是任何映射对象

返回值： 返回表达式计算结果

任何一门编程语言的核心操作都是操作内存中的数据，但内存中的数据优势通过编程语言的API来实现，所谓API，就是系统提供给我们的函数，有一种函数是系统预先定义的函数，也就是我们安装python就自带的函数，我们把这种函数称为内置函数，也叫内嵌函数。

递归函数的优缺点：

优点：

1、递归使代码看起来更加整洁、优雅

2、可以用递归将复杂任务分解成更简单的子问题

3、试用递归比试用一些嵌套迭代更容易

缺点：

1、递归逻辑很难调试，递归条件处理不好容易造成程序无法结束，直到达到最大递归错误

2、递归占用大量内存，耗费计算机资源

递归函数

递归函数：如果一个函数在内部不调用其他函数，而是调用自己本身的话，这个函数就是递归函数

求阶乘：

5! = 5*4*3*2*1

def factorial(n):

     if n == 1

         return 1

    return n * factorial(n-1)

递归函数的条件：递归函数必须有一个结束条件，否则递归无法结束，会一直递归下去，直到到达最大递归深度报错。

优点：逻辑清晰简单，定义简单

缺点：容易导致栈溢出，内存资源紧张，内存泄漏；

案例：模拟实现树形结构的遍历

import os #引入文件操作模块

def findFile(file_Path):

      listRs=os.listdir(file_path)#得到该路径下的所有文件夹

      for fileItem in listRs:

           full_path=os.path.join(file_Path, fileItem) #获取完成的文件路径

           if os.path.isdir(full_path)# 判断是否是文件夹

               file_Path(full_path)#如果是一个文件夹 在次去递归

           else:

                print(fileItem)

                pass

           pass

       else:

             return

      pass

匿名函数：

Python中使用lambda关键字创建匿名函数，所谓匿名函数，即这个函数没有名字，不用def关键字创建标准的函数。

使用lambda 关键字去创建函数

没有名字的函数

匿名函数 冒号 后面的表达式有且只有一个

lambda参数1， 参数2， 参数3……，冒号 执行表达式

匿名函数自带return，而这个return的结果就是表达式的结果

如：使用lambda表达式计算两个数和：

test = lambda x, y: x+ y

test(1,3)

test(4,5)

换成普通函数其实就是这样的：

def test(x, y)

return x + y

def computer(x, y):

      return x + y

      pass

对应的匿名函数

M = lambda x, y :x + y

可以通过调用变量M，调用lambda函数

lambda与三元函数：

如下语句：

if a:

    b

else:

    c

能够由以下等效的表达式来模拟

b if a else c

结果 一般条件 一般条件之外的结果

这样的表达式（三元运算）能够放在lambda中，他们能够在lambda函数中来实现选择逻辑

greater = (lambda x, y: x if x > y else y)

greater(3, 5)

greater(6, 2) 

如：

age = 15

print('可以参军‘ if age > 18 else '继续上学')

匿名函数 lambda的缺点：

lambda只能是单个表达式，不是一个代码块，它的设计就是为了满足简单函数的场景，仅能封装有限的逻辑，复杂逻辑实现不了，必须使用def来处理

引用：

在Python中，值是靠引用来传递的，可以用id()查看对象的引用是否相同，id是值保存在内存中那块内存地址的标识

1、对于python来讲，在python当中，所有的东西都是对象（变量、函数、字典……），在函数调用的时候，实参传递的是对象的引用。

2、了解了原理之后，就可以更好的去把控在函数内部处理是否会影响到函数外部的数据变化。

3、参数传递是通过对象引用来完成的

4、对于可变对象来说（列表、字典、字符串），在函数内部对对象进行加工，可以改变对象。

1、局部变量，就是在函数内部定义的变量[作用于仅仅局限在函数内部]

2、不同的函数，可以定义相同的局部变量

pro='计算机信息管理'

name='吴老师'

def printinfo():

      name='peter'

      print('{}.{}'.format(name, pro))

      pass

def TestMethod():

      name='刘德华'

      prin(name,pro)

      pass

3、局部变量的作用，为了临时的保存数据，需要在函数中定义，来进行存储。

4、如果在函数的内部要相对全局变量进行修改，必须要用到global关键字进行声明

def changeglobal():

      global pro

      pro='市场营销’

      pass

------------------------------------

全局变量：

1、可作用于当前文件的所有函数中；

2、当全局变量和局部变量出现重复定义时，系统优先使用局部变量（函数内部定义的变量），强龙不压地头蛇。

输出：

1. 占位符：%，%号后加变量类型

%s：字符串

%d：有符号的十进制整数

%E：索引符号（大写）

%e：索引符号（小写）

%f：浮点实数

%g：%f和%e的结合

print('我的名字是%s：今年【%s】岁'%(strName,strClass))

有多少个占位符后面就有多少个引用

2.换行：\n

3.格式输出：.format()

输入：input('提示语')

转换数据类型为整型：int()

赋值运算符：

赋值：=

加法赋值：+=

a+=c 相当于 a=a+c

幂等赋值：**=

a**=c 相当于 a=a的c次方

逻辑运算符，运算结果是布尔值：

and、or、not

优先级：

not > and > or

从左到右 

算数运算符

加法：+

减法：-

乘法：*

除法：/

求余数：%

求指数：**

相除取整（地板除）：//

比较运算符：

等于：==

不等于：!=

大于：>

小于：<

大于等于：>=

小于等于：<=

按顺序赋值：

a,b=10,5

b=() #元组类型

b=[] #列表类型

b={}#字典类型

变量的命名规则：

1. 以字母/下划线开头，不能用数字
2. 区分大小写
3. 关键字不能用作变量名

定义规则：变量名 = 数据

赋值的时候不需要指定数据类型

type()，查询变量的数据类型

函数的分类：根据函数的返回值和函数的参数

#有参数无返回值的

#有参数有返回值的

#无参数有返回值的

#无参数无返回值的

函数返回值

概念：函数执行完以后，会返回一个对象，如果在函数的内部有return,就可以返回实际的值，否则返回一个空（None);

返回值的类型：任意类型

类型：返回值类型应该取决于return后面的类型

用途：给调用方返回数据

在一个函数内可以出现多个return值，但是肯定只能返回一个return

如果在一个函数体内执行了一个return，意味着函数就退出了，return后面的代码语句将不会执行。

关键字可变参数

用两个*定义

在函数体内，关键字参数是一个字典类型

key值必须是一个字符串 key是一个字符串

def keyFunc(**kwargs):

      print(kwargs)

      pass

调用

dictA={"name":"leo", "age":35}

keyFunc(**dictA)

或者

keyFunc(name='peter','age'=35)

def complexFunc(*args, **kwargs):

可选参数必须放到关键字可选参数之前；

可选参数接受的是元祖类型数据（或者接收后将数据转换为元组处理）

关键字可选参数接受的是字典型数据，或者将接受的数据转换为字典处理

调用时会根据实际参数的格式自动匹配到对应的形参类型。

complexFunc(age=36)

{'age':36}

函数定义：

def 函数名（参数列表）：0-n个

      代码块

函数的参数：

必选参数、默认参数（缺省参数）、可选参数、关键字参数

参数：函数为了实现某向特定的功能所必须的外部数据。

函数相当于一个房间，参数相当于这个房间的入口

def sum(a, b): 形式参数：只是意义上的一种参数，在定义的时候不占内存地址的。

      sum=a+b

      print(sum)

函数调用在调用的时候必选参数，是必须要赋值的

sum(20, 15)

#20和15就是实际参数，占用内存地址，是实实在在的参数

默认参数[缺省参数]

def sum(a=20, b=30):

      print('默认参数试用=%d'%(a+b))

      pass

# 默认参数调用

sum1(10)

默认参数试用40

# 在调用的时候如果未赋值，就会用定义函数时给定的值

缺省参数始终存在于参数列表的尾部；

可选参数（不定长参数）：当参数的个数不确定时试用，比较灵活

def getcomputer(*args):

.

什么是函数：一系列Python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能。

为什么要使用函数

打吗的复用最大化以及最小冗余代码，整体代码结构清晰，问题局部化

函数定义：

def 函数名():

      代码块

def + 关键字 +小括号 + 冒号 + 换行缩进 + 代码块

函数的调用：

函数名加（）即可调用该函数

先存在，再使用：先定义，再调用

函数说明文档：

函数内容的第一行可以用字符串进行函数说明

函数的参数：

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了。

Python的函数定义非常简单，但灵活度却非常大，除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数、使得函数定义出来的接口，不但能处理复杂的参数，还可以简单化调用者的代码。

缺省参数:

缺省参数，在调用函数时如果没有传参数，那么会使用定义函数时给的缺省值。缺省参数必须在参数列表的最后面，否则会报错。

不定长参数：

一个函数有时候会处理比当初声明的参数要多，这就是不定长参数，定义函数时不用生命参数名，加了星（*）的变量args会存放所有未命名的变量参数，args为元组；再加**的变量kwargs会存放命名参数，即形如key-value的参数，keywargs为字典。

引用传参：

Python中函数参数是引用传参（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身，而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。