一些 python 的学习笔记。

一、基本数据类型

Nunber、string、list、tuple、dict、set

1、number 类型

主要包含: int、float、bool Bool 类型在 python 中归纳为 int 的一个子类，值有两个：True / False

2、string 类型

主要包含: 字母、数字、下划线、汉字等一般使用单引号或双引号来包裹字符或字符串。可用三个单引号包裹多行字符串：

'''
 ABCD
 abcd
'''

3、list 类型

列表用[]来表示,[]中可放字符、字符串、数字或是嵌套列表

4、tuple 类型

元组使用 () 来表示, () 中可放字符、字符串、数字或是嵌套元组。元组是特殊的列表, 其元素不可更改

5、dict 类型

一般情况下，key 使用字符串，需用引号括起来

6、set 类型

集合使用{}表示，{}里直接放值如：{123, abc, 编程}

二、input 输入函数

1、参数是提示信息 2、输入的内容使用变量接收。如：password = input (“请输入密码：”) 3、input 函数执行完毕后返回的是字符串类型 4、input 函数执行时，输入结束后按下回车键 input () 才会结束，进而执行下一段代码

三、python 的数据类型转换

转换形式：int –> string string –> int bool –> int 在 python 中，字符串和整型不能直接进行数学运算

1、int (x, base=10) 将其它类型转换为整型

参数： 1、x, 要转换的数据变量 2、base = 10, 以十进制（默认）转换为整型不是所有类型都可通过 int () 转换为整型，如“python”转换时会报错。一般是数字字符串转换为整型

2、str (x) 将其它类型转换为字符串类型

参数： x, 要转换的数据变量

3、float (x) 将其它类型转换为浮点型

参数： x, 要转换的数据变量不是所有类型都可通过 int () 转换为整型，如“python”转换时会报错。一般是数字字符串转换为浮点型

4、bool (x) 将其它类型转换为布尔型

Python 中 bool 类型有两个值：True 和 False（注意首字母大写）数字 0、空字符串、空列表、空元组、空字典、空集合等为 False，其余为 True 隐式类型转换，不通过 bool () 进行转换，一般用于条件表达式：如：“ 3>4 ” 为 False，“1+1=2”为 True

5、list (x) 将其它类型转换为列表

如：

tup = (1,2,3)      //此时tup类型为tuple
list(tup)          //将tup类型转换为list

不是所有类型都可通过 list () 转换为列表，一般是字符串或元组转换为列表

6、tuple (x) 将其它类型转换为元组

一般情况下，是字符串和列表转换为元组

注: type (x) 可返回变量 x 的类型

三、python 的算术运算符

'+'(加法)   '-'(减法)   '*'(乘法)  '/'(除法)  '%'(取余或求模)  '**'(幂)  '//'(取整)

算术运算符在字符串中的应用

 “hello" + "world" = "helloworld" (拼接字符串)

注意：python 中，数字和字符串不能进行加法运算，只能是字符串和字符串拼接

四、python 的赋值运算符

1、简单的赋值运算符: “=”, 表示把右边的值赋给左边的变量, 和数学中的等好不同 2、复合运算符:

'+='  '-='  '*='  '/='  '%='  '**='  '//='

注意：pyhon 中不支持‘++’‘–’操作

五、python 的关系运算符

'>'  '<'  '>='  '<='  '=='  '!='

除数字外，字符串也可使用关系运算符进行操作，字符串比较时通过 ASCLL 码值进行比较

六、python 的成员运算符

‘in’ (在指定序列中找到指定值则返回 True, 否则返回 False) ’not in’ (指定值不在指定序列中返回 True, 否则返回 False)

七、python 的逻辑运算符

‘and’ (且运算) ‘or’ (或运算) ’not’ (非运算)

A and B ==> A和B同时为真时返回True,只要有一个为假,则返回False
A or B  ==> A和B有一个为真即返回True,同时为假才返回False
not A   ==> 对原来的结果取反

Python 的逻辑运算符可以操作任何类型的表达式，不论表达式是否为 bool 类型。

同时，其运算的结果也不一定为 bool 类型。

短路运算

Python 中的‘and’和‘or’不一定会计算右边表达式的值，有时只需计算左边表达式即可得出结果 ‘and’和’or‘会将其中一个表达式的值作为最终结果，而不是 True 或 False

八、python 的流程控制

1、顺序结构:

程序从头到尾执行每一条语句。不重复、不跳过任何一行代码。

2、分支结构 (选择结构):

让程序有选择地执行某段代码。

单分支语句：

if 条件:
	代码块  			//这里强制缩进,是python的语法特点,不需要花括号。

执行流程: 若条件成立, 则执行缩进的代码块, 否则跳过。

双分支语句：

if 条件:
	代码块1
else:
    代码块2

执行流程: 若条件成立, 则执行代码块 1, 否则执行代码块 2。

三元运算符:

三元运算符是对 if.. Else.. 语句的简化三元运算符的写法：

max = a if a > b else b

运算流程: 若 a>b 成立, 则把 a 赋给 max, 否则把 b 赋给 max

多分支语句:

if 条件1:
	代码块1
elif 条件2:
	代码块2
elif 条件3:
    代码块3
else:
    代码块4

多分支语句中，只会执行其中满足条件的一项

if 语句的嵌套

if 条件1:
	if 条件1.1:
		代码块1
	elif 条件1.2:
		代码块2:
	else:
        代码块3
else:
	if 条件2.1:
		代码块4
	else:
        代码块5

Pass 关键字, 在 python 中没有任何意义, 只用来实现单纯的占位, 保证语句完整

3、循环结构

while 循环

语法：

初始条件
while 判断条件:
	代码块
    更新条件

Break 和 continue 关键字：

Break 指跳出循环不再执行。

Continue 指跳出此次循环，继续执行下一次循环。

for 循环

Python 中的 for 循环与其它语言不同，指的是 for… In… 循环。语法：

for 元素 in 可迭代对象:         --->      for i in range(m,n)
	代码块                                   代码块

注意: 1、python 中的可迭代对象一般指字符串、列表、元组、集合等 2、python 中使用 for.. In.. 循环时, 一般需配合一个内置类 range。 Range 可生成一个指定区间的序列。语法: range (m, n) //生成区间为[m, n) 的序列 (左闭右开) 循环的嵌套: 实际应用中，循环的嵌套层级不会超过三层

九、python 的字符串

1、字符串的声明：

使用一对单引号/双引号/三引号进行声明例如:

str1 = 'hello world'
str2 = "hello python"
str3 = '''hello code'''

2、字符串的嵌套规则:

外层是单引号, 内层只能是双引号。外层是双引号, 内层只能是单引号。

3、字符串的转义字符:

\ (让符号失去原有的意义)

例如：

如要单独输出双引号,则应使用\""代替
\''   -->表示转义单引号
\""   -->表示转义双引号
\n    -->表示换行
\t    -->表示制表符(相当于tab键的作用)

4、特殊字符

“r”: 字符串前加 r 表示原样输出 “f”: 字符串前加 f 表示支持花括号语法，即在字符串中嵌入变量例如:

name = "张三"
age = 18
print(f"我的名字是{name},年龄是{age}")
==>我的名字是张三,年龄是18

5、字符串的下标和切片

下标 (索引): 表示第几个元素, 默认从 0 开始。可通过下标获取指定位置的元素例如：

str = "hello world"
print(str[4])
==>o

切片: 从字符串中复制指定的一段内容, 生成一个西的字符串切片的语法:

str[start:end:step]
str表示要切片的字符串
start表示开始下标(包含开始下标的数据)
end表示结束下标(不包含结束下标的数据)
step表示步长，默认为1

6、字符串的常见功能

1> 统计字符串长度 len ()

例如: len (str)

2> 在整个字符串中, 统计子串出现的次数 count ()

例如: str.Count (str 1) –> 统计在字符串 str 中，子串 str 1 出现的次数

3> 字符串的大小写转换: upper () lower () swapcase () title ()

例如:

str1.upper()     -->将str1中的小写字母转换为大写字母
str2.lower()     -->将str1中的大写字母转换为小写字母
str3.swapcase()  -->将字符串中的大写字母转换为小写字母，小写字母转换为大写字母
str4.title()     -->将单词的首字母转换为大写

4> 查找字符串出现的位置: find () index ()

Find () 查找子串在字符串中第一次出现的位置。若找到，返回下标，否则返回-1。例如: str.Find (“str 1”) –> 寻找 str 1 在 str 中第一次出现的位置

在指定范围内查找: str.Find (“x”, start. End)

Rfind () 查找子串在字符串中最后一次出现的位置。若找到，返回下标，否则返回-1。

Index () 和 find () 功能类似，区别是若未找到即报错。

Rindex () 和 rfind () 功能类似，区别是若未找到即报错。

5> 字符串的提取: strip () lstrip () rstrip ()

Strip () 去除字符串两边的指定字符，默认为空格例如: str.Strip (“x”) –>去除 str 两边的 x

Lstrip () 只去除字符串左边的指定字符 Rstrip () 只去除字符串右边的指定字符

6> 字符串的分割和合并: split () join ()

Split () 以指定字符对字符串进行风格，默认为空格例如: str.Split ()

Join () 合并字符串例如: str.Join (tup) –>用 str 对 tup 进行拼接

7> 字符串的替换和判断:

Replace () isupper () islower () isdigit () isTitle () isalpha ()

Replace () 将字符串中的指定内容进行替换参数 1: 要替换的内容参数 2: 替换后的内容参数 3: 控制替换的次数例如: str.Replace (“A”,“B”, 1) –>将字符串 str 中的 A 替换成 B，次数为 1 Isupper () 检测字符串中的字母是否全为大写，返回值为布尔型 (True/False) 用法: str.Isupper ()

Islower () 检测字符串中的字母是否全为小写，返回值为布尔型 (True/False) 用法: str.Islower ()

Isdigit () 检测字符串是否只由数字组成，返回值为布尔型 (True/False) 用法: str.Isdigit ()

IsTitle () 检测字符串中单词的首字母是否全为大写。

Isalpha () 检测字符串中的字符是否全为字母、汉字或数字组成。

7、字符串的编码、解码及 ascii 码的转换

//常用编码格式: GBK UTF-8

1> encode () 编码

Str.Encode (‘utf-8’) –> 以 UTF-8 格式对字符串 str 进行编码

2> decode () 解码

Str.Decode (‘gbk’) –> 以 GBK 格式对字符串 str 进行解码

3> chr () 将 ascii 码值转换为对应的字符

Chr (97) –> ascii 码'97’对应的字符为 a

4> ord () 将字符转换为对应的 ascii 码值

Ord (‘a’) –> 97

8、字符串的格式化输出

通过%占位符的方式进行输出

%     -->   占位符
%d    -->   表示整数
%f    -->   表示浮点数
%.2f  -->   表示按两位小数输出(小数位数可控)
%c    -->   表示单个字符
%s    -->   表示字符串

例如:

name = '张三'
print("my name is:%s" %name)    //这里与C语言的区别在对变量的引用,需用%加持。

注: 这里也可在字符串前加 f，使其支持花括号语法进行占位。

十、列表 (相当于 C 中的数组)

列表可以一次性保存多个数据, 每一个数据叫做一个元素。列表使用[]来表示。列表的索引可正可负, 正数表示从左往右, 负数表示从右往左。

定义列表:

list1 = ['A','1','你好']

列表中的元素可以是不同的数据类型，也可以是一个新的列表，即列表的嵌套。
获取/修改列表的元素是通过下标进行的，下标从 0 开始。

遍历列表:

方式一

for i in list1:
	......

方式二 (可同时遍历索引和值)

for index,value in enumerate(list1):
        ......

列表的常见操作：

1、合并列表 (通过’+‘实现)

list1 = ['A','B','C']
list2 = ['a','b','c']
list3 = list1 + list2

2、判断指定元素是否在列表中

(通过成员运算符’in’或’not in’进行检查, 返回值为 True/False)

if 'str' in list1:
	......

3、列表的切片

list1[start:end:step]

4、列表元素的添加

方法一: append () 向列表尾部追加元素

list1.append("x")  		//向列表list1尾部追加元素x

注意:

1、append () 追加单个元素时，直接把要追加的内容放到函数内即可。 2、append () 一次性追加多个元素，需要以列表的形式追加，但原来的列表会变成二维列表。

方法二: extend () 可以在列表尾部一次性追加多个元素且不改变原列表的维度，但仍需以列表的形式追加。

list1.extend(['x','y'])

用 extend () 追加一个元素，会对元素做一次拆分后追加

方法三: insert () 向列表的指定位置添加指定元素

list1.insert(参数1,"参数2")  	//参数一:追加的位置(某个下标前)  参数二:追加的内容

若要一次性追加多个元素，需要以列表的形式追加，但会改变原列表的维度。

5、列表元素的删除

方法一: pop () 删除指定位置的元素

list1.pop(参数)  		//参数为要删除元素的下标。不填参数时默认删除最后一个元素

方法二: remove () 删除指定元素

list1.remove(参数)  	//参数为要删除的元素

方法三: clear () 清空列表

list1.clear()  		//清空整个列表

6、列表元素的排序、反转和获取

列表的排序

方法一: sort ()

list1.sort()  				//对原列表中的元素进行排序,默认为升序,不会生成新列表
list1.sort(reverse=True)  	//降序排列,传入参数reverse=True

方法二: sorted ()

list2 = sorted(list1)  		//对原列表(list1)进行排序,默认为升序,会生成一个新列表,传递给list2。
list2 = sorted(list1,reverse=True)  //降序排列,传入参数reverse=True
list2 = sorted(list1,key=len)  		//添加key=len(排序依据),按照元素长度进行排序

列表的翻转

Reverse () 翻转列表元素

 list1.reverse()

获取列表长度 (获取列表的元素个数)

Len ()

len(list)

获取列表中元素的最大值/最小值

Max () / min ()

max(list) / min(list)

获取指定元素的索引

Index ()

list.index(x)  //获取元素x在列表list中的下标

7、列表的嵌套

列表中的元素还是列表 (相当于二维数组)，称为二维列表访问二维列表的方式与 C 中访问而为数组元素的方式相同，即:

list[m][n]

8、列表生成式

1> list1 = list(range(start,end,step))   						//生成指定区间内整数组成的列表
2> list2 = [i ** 2 for i in range(start,end,step)]  	   //生成指定区间内整数的平方组成的列表
3> list3 = [i for i in range(start,end,step) if i %2 == 0]    //生成指定区间内的偶数组成的列表

十一、字典

字典相当于 C 语言中的结构体字典用花括号标识字典由键 (key) 和值 (value) 组成，健和值一一对应，由": “连接。不同键值对间用”,“隔开

dict1 = {"name":"张三", "age":18, "school":"清华大学"}

访问字典中的元素:

1、通过索引的方式访问 --> 	dict1['key']
2、通过get()        -->     dict1.get('key')

修改字典中的元素:

dict1['key'] = '更改为的值'

向字典中添加元素:

dict1['新增加的key'] = '新增加的值'

删除字典中的元素:

1、pop()  		--> 	dict1.pop('key')  	//key为要删除元素的键
2、popitem() 	--> 	dict1.popitem() 	//删除字典的最后一对key:value
3、clear()   	--> 	dict1.clear()   	//清空字典

字典的获取:

Len () 获取字典的长度

len(dict1)  --> 统计键值对的个数

Keys () 获取字典中所有的 key

dict1.keys()

Values () 获取字典中所有的 value

dict1.value()

Items () 获取字典中所有的 key 和 value

dict1.items()

遍历字典:

方式一: 直接遍历字典

for i in dict1:     //遍历字典中所有的key
	......

方式二: enumrate ()

for k,v in enumrate(dict1):     //遍历字典中所有的key及其下标
	......

方式三: items ()

for k,v in dict1.items():       //遍历字典中所有的key和value
	......

方式四： values ()

for v in dict1.values():        //遍历字典中所有的value
	......

方式五: keys ()

for k in dict1.keys():          //遍历字典中所有的key
	......

合并字典

Update 方法

dict1.update(dict2)         //把字典dict2追加到字典dict1后部

十二、集合

集合 (set) 是 python 中的一种数据类型，和数学中的集合类似

集合的特点：

1、无序 2、无重复

创建集合:

set1 = {value1, value2,....}    	//集合和字典的区别就是集合只有值(value),没有键(key)

注意:集合不能通过下标访问或修改 (无序性)

获取集合的长度: len ()

len(set1)   		//获取集合中的元素个数

向集合中添加元素: add () update ()

set1.add(value)     //向集合set1中添加值value,add()方法一次只能添加一个元素
set1.update(list)   //向集合set1中添加多个值,以列表list的形式添加

删除集合中的元素: pop () remove () discard () clear ()

set1.pop()              //随机删除集合中的一个元素
set1.remove(value)      //删除集合中值为value的元素,若删除不存在的元素会报错  
set1.discard(value)     //删除集合中值为value的元素,若删除不存在的元素不会报错
set1.clear()            //清空集合

遍历集合:

for i in set1:
	......

十三、元组

元组和列表类似，本质上是一种有序的集合。元组和列表有区别:

1、定义元组使用 ()，定义列表使用[] 2、元组中的元素不可修改，列表中的元素可修改

创建元组:

tup = (value1, value2, ......)      //元组中的元素可以为任意类型

若创建元组时元组中只有一个元素, 需要在该元素的后面加上一个逗号, 否则不会被识别为元组

访问元组: (和列表类似)

通过下标访问 tup[x]

合并元组:

通过‘+’来实现

tup = tup1 + tup2

判断元素是否在元组中:

使用成员运算符‘in / not in‘

元组的切片:

tup[start:end:step]

获取元组的长度:

len(tup1)

获取元组中元素的最大值/最小值:

max(tup)/min(tup)

其它数据类型转换为元组

tuple ()

tup = tuple(list1)      //将列表list1转换为元组后传递给tup

遍历元组: (与遍历列表类似)

直接遍历:

for v in tup1:
	......

enumrate ():

for i,v in enumerate(tup1):     同时遍历元组的元素及其下标
	......

十四、赋值、浅拷贝、深拷贝

赋值: 本质上就是对象的引用

list1 = ['a', 'b', 'c']
list2 = list1

如此赋值，实际上是让 list 2 指向 list 1 中元素在内存的地址，即 list 1 和 list 2 共同指向内存中的同一个地方，所以当修改 list 1 中的值时，list 2 的值也会被修改

浅拷贝:

为了解决上述问题，可以使用浅拷贝 (copy) 的方法: 使用浅拷贝，需导入 copy 模块: import copy

import copy
list1 = [value1, value2, ......]
list2 = list1.copy()        			//如此操作后,开辟了一段新的内存空间,list1和list2的值就互不影响

浅拷贝可以解决一维列表的复制问题对于二维列表，使用浅拷贝后，外部列表分别位于内存的不同空间，但内部列表的元素仍位于同一内存空间

深拷贝:

使用深拷贝 (deepcopy) 可以解决二维 (多维) 列表修改元素时不能独立处理的问题。同样需要导入 copy 模块

import copy
list1 = [value1, value2, ......]
list2 = copy.deepcopy(list1)        //注意深拷贝的语法，与浅拷贝不同

十五、函数

函数要解决的问题: 1、重复的代码 2、程序的维护 ===> 函数就是把在项目中经常使用的功能代码提取出来并封装，方便后续不同地方的调用。

函数的基本语法:

def 函数名(参数1, 参数2, ......):
	函数体

使用 def 关键字来声明函数
函数由两部分组成: 声明部分和实现部分
函数定义时的参数，叫做形参，可写可不写，取决于函数功能
函数体要缩进
函数在使用前必须调用，调用格式: 函数名 ()
函数的调用必须在函数定义之后

函数调用时的注意事项:

在同一个文件中，若出现定义的函数名相同的情况，后面定义的函数会覆盖前面定义的函数
若将函数名复制给一个变量，就可以通过这个变量来调用函数
函数必须先定义后使用

函数的参数:

定义函数时传递的参数叫作形参
调用函数时传递的参数叫作实参，实参会取代形参的位置
若在定义函数时有形参，则在调用函数时必须传入实参，且实参和形参的数量必须相同

函数中参数的类型:

a.必须参数  -->  在调用函数时, 必须以正确的顺序传递参数
b.关键字参数  -->  使用关键字参数调用函数，允许实参和形参的顺序不一致

def f(x,y):
	......
f(y=value1, x=value2)

c.默认参数  -->  定义函数时若定义了默认参数，在调用时可以不传递实参，使用默认参数，而传递实参后，会覆盖默认参数。默认参数应置于参数列表末尾。

def f(x,y=5):
	......
f(6)				#函数f在定义时有两个形参，但有一个参数被定义为了默认函数，所以在调用该函数时可以只传递一个实参

d.不定长参数:

*args 用来接收多个未知参数，得到的是一个元组。
def f(*args):        //如此定义后,调用函数时可以同时传递任意多个参数。不定长参数应置于参数列表末端。
	......

**kwargs 用来接收多个关键字参数，得到的是一个字典。在传递参数时，必须是以key=value的形式。
def f(**kwargs):
	......
f(key1=value1, key2=value2, ......)

函数的返回值:

函数按照有无返回值分为两类: a.有返回值  b.无返回值
函数的返回值需要使用‘return’关键字进行返回, 函数在哪里调用，函数的返回值就返回到哪里
函数的返回值使用，可以使用变量接收，也可以直接打印输出

def f():
	......
    return x

函数中的代码执行到 return 关键字之后就停止，return 关键字之后的语句不会执行
函数中没有 return 关键字或没有数据返回，则默认返回 NULL
Return 可以一次性返回多个数据，数据之间使用逗号隔开，返回的结果是一个元组

函数的嵌套:

函数之间可以相互嵌套，即自定义函数内部可以调用其它函数

匿名函数：

函数按照有无名字，分为两类: 有名函数和匿名函数匿名函数是一个使用 lambda 定义的表达式，比普通函数简单。 Lambda 表达式中包含参数、函数体、返回值

num1 = lambda num:num ** 2      //参数为num.返回值为num**2

回调函数：？

把一个函数 f () 作为一个参数传递到另一个函数中，那么 f () 称为回调函数

def f():
	......
def g(func):
    func()
g(f)            	//把函数f作为参数传入函数g,实现函数g对函数f的调用

闭包函数：？

若一个函数内部嵌套了另一个函数，则外部函数称作外函数，内部的函数称作内函数闭包: 若在一个外部函数中定义了一个内部函数，且外部函数的返回值是这个内部函数，则这个内部函数成为闭包最简单的闭包:

def outer():
    def inner()
        ......
    return inner      		//注意: 这里返回的是函数体,不是函数的调用
fn = outer()            	//这里使变量fn指向inner函数
fn()                   		//这里就相当于调用的inner函数

闭包函数的特点: 内部函数可以使用外部函数的变量, 闭包函数主要应用于装饰器函数的实现

函数的作用域

分支语句和循环语句不存在作用域的问题，它们内部定义的变量可以在外部直接访问函数内部定义的变量，在函数外部不能直接访问函数内部可以直接访问函数外部的变量若要在函数内部修改函数外部的变量，需要使用 global 关键字将函数内部的变量变为全局变量

十六、filter 和 map 方法

Filter 在 python 3 中是一个内置类, 但仍以函数的方式调用 Filter () 内置类有两个参数, 第一个参数是一个函数, 第二个参数是一个可迭代对象 Filter () 的返回值是一个 filter 类型的对象

Map 和 filter 的功能类似 Map () 有两个参数, 第一个参数是一个函数, 第二个参数是一个可迭代对象 Map () 的返回值是一个 map 类型的对象 Filter () 适用于对可迭代对象中元素的筛选,map () 适用于对可迭代对象中元素的处理

十七、装饰器

装饰器可以在程序运行过程中，动态地添加功能

装饰器的常规写法:

def f1():
        ......
#这里的outer()就是一个装饰器,用于修改某个函数的功能
def outer(fn):               #fn表示形参，实际调用装饰器时，传入的实参是原函数的名字
	def inner():
	   	fn()				 #调用原函数
       	补充的功能语句         #给原函数添加功能
	return inner			 #闭包函数的写法，返回的是函数体，不是函数的调用，不加括号
  
f1 = outer(f1)
f1()

装饰器的简化写法：

@ + 装饰器名称

def outer(fn):               #fn表示形参，实际调用装饰器时，传入的实参是原函数的名字
	def inner():
	   	fn()				 #调用原函数
       	补充的功能语句         #给原函数添加功能
	return inner			 #闭包函数的写法，返回的是函数体，不是函数的调用，不加括号

@outer       	#等价于f1 = outer(f1)，这是简化写法，表示给函数f1添加一个装饰器
def f1():		#使用简化写法时，原函数定义必须在装饰器函数下面，否则报错
	......
f1()			#经装饰器修饰、添加功能后，再次调用原函数

装饰器的其它用法：

1、一个装饰器函数修饰多个函数

def outer(fn):
	def inner(*args):			#这里使用不定长参数，使得传入的原函数带有多少个参数都可以
		fn(*args)
		补充的功能语句
	return inner
@outer							#每次修饰前都调用一次装饰器函数即可
def f1(parameter1，parameter2)
	......
@outer
def f2(parameter1,parameter2,parameter3)
	......
f1(parameter1,parameter2)
f2(parameter1,parameter2,parameter3)

2、一个原函数有多个装饰器函数修饰

def outer1(fn):					#定义第一个装饰器
	def inner1():
		fn()
		补充的功能语句
	return inner

def outer2(fn):					#定义第二个装饰器
	def inner2():
		fn()
		补充的功能语句
	return inner2

@outer1							#在定义原函数前，调用要使用的装饰器
@outer2							#修饰的顺序是：从离原函数近的装饰器开始
def f():						#不论有多少个装饰器，原函数只执行一次
	......

十八、python 中的模块

1、模块的介绍及引用

python 模块的简单介绍：

Python 中的模块可理解为具有不同功能的. Py 文件，但不是所有. Py 文件都能被当作模块导入使用。

能作为模块导入使用的. Py 文件必须遵循命名规则

Python 提供了很多内置模块可直接使用

常见的内置模块：

Os、sys、re、math、random、datetime、time、calendar、hashlib、hmac 等

调用模块的方式：

第一种：直接使用 import 关键字导入模块

import 模块名称

导入某个模块后，可以使用该模块下的方法

第二种：

from 模块名 import 该模块下的方法名

这种方法可以直接导入指定的方法，调用此方法时可直接使用，不用以模块. 方法的方式使用

第三种：

from 模块名 import *		#此处的星号表示该模块下的所有方法和变量名

第四种：

import 模块名 as 别名   #as表示给导入的模块起一个新的名称，调用时可以直接使用别名

第五种：

from 模块名 import 方法名 as 别名   #as表示给导入的方法起一个新的名称，调用时可以直接使用别名

2、math 模块的使用

Math 模块保存了数学运算的相关方法，主要用于数学运算的操作

使用前需要导入：

import math

Math 模块的常用方法：

math.fabs(x)			#取绝对值
math.ceil(x)			#向上取整
math.floor(x)			#向下取整
math.pi					#圆周率的值
math.pow(x,y)			#计算x的y次方
math.factorial(x)		#计算x的阶乘
......

3、os 模块的使用

Os 模块主要用于获取系统的功能，操作文件或文件夹

使用前需要导入：

import os

Os 模块的常用方法：

os.curdir						 #获取当前目录
os.getcwd()						 #获取当前路径
os.mkdir("路径+文件夹名称")	    #创建文件夹，只能创建不存在的文件夹，不能创建已存在的文件夹
os.rmdir("路径+文件夹名称")	 	#删除文件夹，只能删除空文件夹
os.rename("原来的名字","新名字")    #重命名
os.remove("路径+文件名")			  #删除文件
os.path.join("路径1","路径2")	   #拼接路径
os.path.getsize("路径+文件名")	  #获取文件大小
os.path.isfile("路径+文件名")	  #判断是否为文件，返回值为True/False
os.path.isdir("路径+文件名")		  #判断是否为文件夹，返回值为True/False
os.path.exists("路径+文件名")	  #判断文件/文件夹是否存在，返回值为True/False

一、基本数据类型#

1、number 类型#

2、string 类型#

3、list 类型#

4、tuple 类型#

5、dict 类型#

6、set 类型#

二、input 输入函数#

三、python 的数据类型转换#

1、int (x, base=10) 将其它类型转换为整型#

2、str (x) 将其它类型转换为字符串类型#

3、float (x) 将其它类型转换为浮点型#

4、bool (x) 将其它类型转换为布尔型#

5、list (x) 将其它类型转换为列表#

6、tuple (x) 将其它类型转换为元组#

三、python 的算术运算符#

算术运算符在字符串中的应用#

四、python 的赋值运算符#

五、python 的关系运算符#

六、python 的成员运算符#

七、python 的逻辑运算符#

短路运算#

八、python 的流程控制#

1、顺序结构:#

2、分支结构 (选择结构):#

单分支语句：#

双分支语句：#

三元运算符:#

多分支语句:#

if 语句的嵌套#

3、循环结构#

while 循环#

for 循环#

九、python 的字符串#

1、字符串的声明：#

2、字符串的嵌套规则:#

3、字符串的转义字符:#

4、特殊字符#

5、字符串的下标和切片#

6、字符串的常见功能#

1> 统计字符串长度 len ()#

2> 在整个字符串中, 统计子串出现的次数 count ()#

3> 字符串的大小写转换: upper () lower () swapcase () title ()#

4> 查找字符串出现的位置: find () index ()#

5> 字符串的提取: strip () lstrip () rstrip ()#

6> 字符串的分割和合并: split () join ()#

7> 字符串的替换和判断:#

7、字符串的编码、解码及 ascii 码的转换#

1> encode () 编码#

2> decode () 解码#

3> chr () 将 ascii 码值转换为对应的字符#

4> ord () 将字符转换为对应的 ascii 码值#

8、字符串的格式化输出#

十、列表 (相当于 C 中的数组)#

定义列表:#

遍历列表:#

方式一#

方式二 (可同时遍历索引和值)#

列表的常见操作：#

1、合并列表 (通过’+‘实现)#

2、判断指定元素是否在列表中#

3、列表的切片#

4、列表元素的添加#

5、列表元素的删除#

6、列表元素的排序、反转和获取#

列表的排序#

列表的翻转#

获取列表长度 (获取列表的元素个数)#

获取列表中元素的最大值/最小值#

获取指定元素的索引#

7、列表的嵌套#

8、列表生成式#

十一、字典#

访问字典中的元素:#

修改字典中的元素:#

向字典中添加元素:#

删除字典中的元素:#

字典的获取:#

遍历字典:#

方式一: 直接遍历字典#