面向过程：根据业务逻辑从上到下写代码；首先思考这件事情怎么按照步骤去实现，然后将问题拆解为若干个步骤，并将这些步骤对应成方法一步一步的最终完成这些功能；
面向过程，关注如何做，不适合做大项目
函数式编程：将某功能代码封装到函数中，日后无序重复编写，仅调用函数即可。
面向对象编程：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程。
面向对象：oop [object oriented programming]是一种Python的编程思路；关注的是设计的思维，【找洗车店，给钱洗车】
面向对象适合做更大的项目；不注重细节过程，注重思考谁（对象）来做。

面向对象与面向对象编程：按人们认识客观世界的系统思维方式，采用基于对象（实体）的概念建立模型，模拟客观世界分析、设计、实现软件的办法
面向对象编程（Object Oriented Programming-OOP)是一种解决软件复用的设计和编程方法。这种方法把软件系统中相似、相近的操作逻辑和操作应用、
数据、状态，以类的形式描述出来，以对象、实例的形式在软件系统中复用，以达到提高软件开发效率的作用。

类和对象的概念
类就是模板、模型，模板里可以包含一些函数，函数里实现一些功能。
对象则是根据模板创建的实例，通过实例可以执行类中的函数。
类相当于制造汽车的图纸，对象相当于根据图纸制造出来的汽车。

类的组成部分：
类(Class) 由3各部分组成：
类的名称
类的属性：一组数据
类的方法：类可以操作的方法（行为）

例如：创建一个人类
食物名称（类名）：人
属性：身高、体重、年龄、肤色
方法：吃、跑

类是具有一组相同或相似特征（属性）和行为（方法）的一系列对象的组合

对象：是实实在在的一个东西，是类的具象化、实例化。
类是对象的抽象，对象是类的实例（凝聚态）

具有相同或相似属性和行为的一系列对象的集合都可以抽象出一个类
例如：小明开着他的宝马去逛街
小明--->可以抽象出人类
宝马--->可以抽象出车类

集合：

set()是python中的一种数据类型，是一个无序且不重复的元素集合

不支持索引和切片，是一个无序且不重复的容器

创建集合的方式

1、set1 = {"1", "2"}

2、list1 = ['1', '2', '3', '4']

set2 = set(list1)

集合操作函数

add()

clear()

difference()差集

intersection()交集

union()并集

pop()从集合中删除数据

discard()指定元素移除

update()更新

enumerate() 函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。

语法：enumerate(sequence, [start=0])

参数：

sequence--一个序列、迭代器或其他支持迭代的对象

start -- 下标起始位置

返回enumerate（枚举）对象

seasons = ['spring', 'summer', 'fall', 'winter']

list(enumerate(seasons))

[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]

sorted()函数对所有可迭代的对象进行排序操作

sort 与sorted 区别

sort是应用在list上的方法

sorted可以对所有可迭代对象进行排序操作

list的sort方法返回的是对已经存在的列表进行操作

内键函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作

语法：sorted(iterable[, key[, reverse]]])

参数：

iterable -- 可迭代对象

cmp -- 比较的函数，这个函数具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1, 等于则返回0

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序

reverse -- 排序规则， reverse - True降序，reverse - False升序（默认）

返回值：返回重新排序的列表

案例：

sorted([1, 2, 3, 5, 6, 9])

[1, 2, 3, 5, 6, 9]

sorted([1, 2, 3, 5, 6, 9].reverse=False)

[1, 2, 3, 5, 6, 9]

sorted([1, 2, 3, 5, 6, 9], reverse=True)

[9, 6, 5, 3, 2, 1]

sorted(['a', 'b', 'C', 'D', 'd'].key=str.lower)(字符串无关大小写排序）

['a', 'b', 'C', 'D', 'd'] 

元组不能用sort，因为元组一单定义，不能修改。

range()函数可创建一个整数列表，一般用在 for 循环中

语法： range(start, stop[, step])

参数：

start: 计数从start开始，默认是从0开始，例如range(5)，等价于range(0, 5)

stop:计数到stop结束，但不包括stop,例如：range(0, 5)是【0, 1, 2, 3, 4]没有5

step： 步长，默认为1 例如：range(0, 5)等价于range(0, 5, 1)

zip()函数用于将（成对的）可迭代的对象作为参数，将各对象中对应的元素(按照索引位置顺序排列）打包成一个个元组，然后返回有这些元组组成的列表

如果各个迭代器的元素个数不一致，则返回列表的长度与最短的对象相同，利用*号操作符，可以将元组解压为列表

语法zip([iterable,...])

参数：iterable --一个或多个迭代器；

返回值：返回元组列表

zip([1,2,3], ['a', 'b', 'c'])

<zip object at0x......

a=zip([1,2,3], ['a', 'b', 'c'])

list(a)

[1,'a'),(2, 'b'), (3, 'c')]

序列操作函数：

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()，查询变量的数据类型

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

#有参数无返回值的

#有参数有返回值的

#无参数有返回值的

#无参数无返回值的