python笔记

第一章

list 列表

[1,2,3,4] ['a','d',['c',2]]

dict 字典

{1:'food',2:'taste',3:'import'}

tuple 元组 不可修改

(2,-5,6) (3,)

set 集合 元素不允许重复

{'a','b','c'}

set可变 frozenset不可变

编程单元：

函数def

类class

模块module

Python启动时，会对[-5, 256]区间的整数进行缓存。也就是说，如果多个变量的值相等且介于[-5, 256]区间内，那么这些变量共用同一个值的内存空间。

对于区间[-5, 256]区间之外的整数，同一个程序中或交互模式下同一个语句中的同值不同名变量会共用同一个内存空间，不同程序或交互模式下不同语句不遵守这个约定。

字符串属于不可变序列

字符串界定符前面加字母r或R表示原始字符串，其中的特殊字符不进行转义，但字符串的最后一个字符不能是\。原始字符串主要用于正则表达式、文件路径或者URL的场合。

>>> a = [1,2,3]

>>> b = [4,5,6]

>>> c = a + b

>>> c

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

>>> d = list(map(str, c))

>>> d

['1', '2', '3', '4', '5', '6']

len(obj)返回对象obj包含的元素个数，适用于列表、元组、集合、字典、字符串以及range对象和其他可迭代对象

list([x])、set([x])、tuple([x])、dict([x])把对象x转换为列表、集合、元组或字典并返回，或生成空列表、空集合、空元组、空字典

str(obj)把对象obj直接转换为字符串

pow(x, y, z=None)返回x的y次方，等价于x ** y或(x ** y) % z

range([start,] end [, step] )返回range对象，其中包含左闭右开区间[start,end)内以step为步长的整数

round(x [, 小数位数])对x进行四舍五入，若不指定小数位数，则返回整数

sorted(iterable, key=None, reverse=False)返回排序后的列表，其中iterable表示要排序的序列或迭代对象，key用来指定排序规则或依据，reverse用来指定升序或降序。该函数不改变iterable内任何元素的顺序

ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符，str()则直接将其任意类型参数转换为字符串。

>>> ord('a') >>> chr(65)

97 'A'

>>> chr(ord('A')+1) >>> str(1)

'B' '1'

>>> str(1234) >>> str([1,2,3])

'1234' '[1, 2, 3]'

>>> str((1,2,3)) >>> str({1,2,3})

'(1, 2, 3)'

>>> import random

>>> a = [random.randint(1,100) for i in range(10)] #列表推导式

>>> a

[72, 26, 80, 65, 34, 86, 19, 74, 52, 40]

reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']

>>> reversed(x) #逆序，返回reversed对象

<list_reverseiterator object at 0x0000000002E6C3C8>

>>> list(reversed(x)) #reversed对象是可迭代的

['ba', 'b', 'd', 'bc', 'aaaa']

enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。

>>> list(enumerate('abcd')) #枚举字符串中的元素

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

内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。

>>> list(map(str, range(5))) #把列表中元素转换为字符串

['0', '1', '2', '3', '4']

>>> def add5(v): #单参数函数

return v+5

>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素

[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

>>> def add(x, y): #可以接收2个参数的函数

return x+y

>>> list(map(add, range(5), range(5,10)))

#把双参数函数映射到两个序列上

[5, 7, 9, 11, 13]

>>> import random

>>> x = random.randint(1, 1e30) #生成指定范围内的随机整数

>>> x

839746558215897242220046223150

例子2：有参匿名函数（无默认值）

x和y是函数的参数，x+y是表达式，它被执行并返回结果。

lambda x, y : x + y返回的是一个函数对象，它可以被赋值给任何变量。

lambda_fun = lambda x, y: x + y

print(lambda_fun(1,2)) 3

# 等价于

def def_fun(x,y):

return x + y

print(def_fun(1,2)) 3

例子3：有参匿名函数（有默认值）

lambda_fun = lambda x, y=100: x + y

print(lambda_fun(1)) 101

print(lambda_fun(1,2)) 3

# 等价于

def def_fun(x,y=100):

return x + y

print(def_fun(1)) 101

print(def_fun(1,2)) 3

return x.isalnum() #测试是否为字母或数字

map、filter、enumerate、zip等对象不仅具有惰性求值的特点，还有另外一个特点：访问过的元素不可再次访问。

input()函数的返回结果都是字符串，必要的时候可以使用内置函数int()、float()或eval()对用户输入的内容进行类型转换。

print(value1, value2, ..., sep=' ', end='\n', file=sys.stdout)

value参数为需要输出的内容（可以有多个）；

sep参数用于指定数据之间的分隔符，默认为空格；

end参数用于指定输出完数据之后再输出什么字符；

file参数用于指定输出位置，默认为标准控制台，也可以重定向输出到文件。

with open('test.txt', 'a+') as fp:

print('Hello world!', file=fp) #重定向，将内容输出到文件中

>>> import math

>>> math.sin(0.5) #求0.5的正弦

>>> import random

>>> x = random.random( ) #获得[0,1) 内的随机小数

>>> y = random.random( )

>>> n = random.randint(1,100) #获得[1,100]上的随机整数

from 模块名 import 对象名[ as 别名] #可以减少查询次数，提高执行速度

from math import * #谨慎使用

>>> from math import sin

>>> sin(3)

0.1411200080598672

>>> from math import sin as f #别名

>>> f(3)

0.141120008059867

x = input('输入两边长及夹角（度）：')

a, b, theta = map(float, x.split())

s = input('x,y,z=')

x, y, z = s.split(',')

s = input('x,y,z=')

x, y, z = sorted(s.split(','))

print(x, y, z)

列表方法：

a.append(num)在尾部追加元素

random()产生随机数

第二章

切片：切片是指对操作的对象截取其中一部分的操作，即从容器中取出相应的元素重新组成一个容器。语法格式如下：sname[start : end : step]左闭右开

2.1 列表

有序、可变序列

在Python中，一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、元组、字典、集合以及其他自定义类型的对象。

append() 方法用于在列表末尾添加新的对象。

语法格式：

listname.append(obj)

extend() 方法用于在列表末尾一次性追加另一个序列中的多个值，如果数据是一个序列，则将这个序列的数据逐一添加到列表。

extend()方法语法：

list.extend(seq)

insert() 方法用于将指定对象插入列表的指定位置。

insert()方法语法：

list.insert(index, obj)

根据元素值删除元素方法

如果想要删除一个不确定其位置的元素（即根据元素值删除），可以使用列表对象的remove()方法实现。

pop() 方法

用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

clear() 方法

用于清空列表，类似于 del a[:]。

clear()方法语法：list.clear()

reverse()方法

用于反向列表中元素。

reverse()方法语法：

list.reverse()

copy()方法

用于复制列表，类似于 a[:]。

index() 方法

用于从列表中找出某个值第一个匹配项的索引位置，即获取指定元素首次出现的下标。

count() 方法

用于统计某个元素在列表中出现的次数。

len() 方法

len() 方法功能是返回列表元素个数。

用in判断是否存在

通常可以用in判断指定数据在某个列表序列，如果在返回True，否则返回False。

列表元素的统计：在Python中，提供了sum()函数用于统计数值列表中各元素的和。

列表元素的排序：Python中提供了两种常用的对列表进行排序的法。使用列表对象的sort()方法实现、使用内置的sorted()函数实现。

all()和any()：

all()函数用来测试列表、元组等序列对象以及map对象、zip对象等类似对象中是否所有元素都等价于True;

any()函数用来测试序列或可迭代对象中是否存在等价于True的元素。

2.2 元组

属于不可变序列，元组一旦创建，用任何方法都不可以修改其元素。

1. 整体修改元组元素：元组是不可变序列，所以不能对它的单个元素值进行修改。但是元组也不是完全不能修改，可以对元组进行重新赋值

len(tup):

返回元组中元素的个数

max(tup):

返回元组中元素最大的值。

min(tup):

返回元组中元素最小的值。

tuple(seq):

将列表转化为元组。

列表可以使用append()、extend()、insert()、remove()和pop()等方法实现添加和修改列表元素：而元组则没有这几个方法，因为不能向元组中添加和修改元素，同样也不能删除元素。

列表不能作为字典的键，则元组则可以。

字典

通过映像函数创建字典

语法格式：dictionary = dict(zip(list1,list2))

参数说明如下：

dictionary：表示字典名称。

通过给定的“键-值对”创建字典

语法如下：

dictionary = dict(key1=value1,key2=value2,...,keyn=valuen)

(1)字典元素的增加

由于字典是可变序列，所以可以随时在其中增加“键-值对”，这和列表类似。向字典中添加元素的语法格式如下：

dictionary[key] = value

dictionary:表示字典名称；

key:表示要增加元素的键，必须是唯一的，并且不可变，例如可以是字符串、数字或者元组；

value:表示元素的值，可以是任何数据类型，不是必须唯一。

(2)字典元素的删除

del() / del：删除字典或删除字典中指定键值对

clear()：清空字典

pop() ：获取指定 key 对应的 value，并删除这个 key-value 对

(3)字典元素的查找

1）通过键值方式。前边已经讲述。

2）通过get()、keys()、values()以及items()函数方式查找。

集合

Python中的集合（set)与数学中的集合概念类似，也是用于保存不重复的元素。它有可变集合（set) 和不可变集合（frozenset)两种。在形式上，集合的所有元素都放在一对大括号中，两个相邻元素间使用逗号“,”分 隔。集合最好的应用就是去重，因为集合中的每个元素都是唯一的。

向集合中添加元素：add()方法。

update()方法是向集合追加的数据是序列

从集合中删除元素：del命令删除整个集合，集合的discard()方法、pop()方法或者remove()方法删除一个元素，或者使用集合对象的clear()方法清空集合，即使其变为空集合。

查找元素

在集合中用in判断数据在集合序列；not in：判断数据不在集合序列。

set(seq): 将序列转化为集合

第三章

选择结构

if 表达式:

语句块1

else:

语句块2

if 表达式1:

语句块A

elif 表达式2:

语句块B

elif 表达式3:

语句块C

else:

语句块D

循环结构

while 条件表达式:

循环体

for 迭代变量 in 对象range(start, end, step):

循环体

pass语句，表示空语句。它不做任何事情，一般起到占位作用。

while...else与for...else语句

与别的编程语言不一样的是python还支持这样的语法：while...else与for...else语句。

只要没有break或者return，不管while是否执行，都会执行else语句（continue也是可以执行else）。

第四章

1. 字符串的编码

用于将字符串转换为二进制数据（即bytes），也称为“编码”。encode()方法为str对象的方法，其语法格式如下：

str.encode([encoding="utf-8"][,errors="strict"])

2. 字符串的解码

用于将二进制数据转换为字符串，称为“解码”。decode()方法为bytes对象的方法，即将使用encode()方法转换的结果再转换为字符串。

bytes.decode([encoding="utf-8"][,errors="strict"])

4.1 字符串

1. 字符串的格式化

format()格式字符串

2. 字符串常用方法

find()、rfind()、index()、rindex()、count()

find()和rfind方法分别用来查找一个字符串在另一个字符串指定范围（默认是整个字符串）中首次和最后一次出现的位置，如果不存在则返回-1；

index()和rindex()方法用来返回一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果不存在则抛出异常；

count()方法用来返回一个字符串在当前字符串中出现的次数。

split()、rsplit()、partition()、rpartition()

split()和rsplit()方法分别用来以指定字符为分隔符，把当前字符串从左往右或从右往左分隔成多个字符串，并返回包含分隔结果的列表；

partition()和rpartition()用来以指定字符串为分隔符将原字符串分隔为3部分，即分隔符前的字符串、分隔符字符串、分隔符后的字符串，如果指定的分隔符不在原字符串中，则返回原字符串和两个空字符串。

对于split()和rsplit()方法，如果不指定分隔符，则字符串中的任何空白符号（空格、换行符、制表符等）都将被认为是分隔符，并删除切分结果中的空字符串。

>>> s = 'hello world \n\n My name is Dong '

>>> s.split()

['hello', 'world', 'My', 'name', 'is', 'Dong']

然而，明确传递参数指定split()使用的分隔符时，情况是不一样的，会保留切分得到的空字符串。

>>> 'a,,,bb,,ccc'.split(',') #每个逗号都被作为独立的分隔符

['a', '', '', 'bb', '', 'ccc']

split()和rsplit()方法还允许指定最大分割次数。

>>> s = '\n\nhello\t\t world \n\n\n My name is Dong '

>>> s.split(None, 1) #不指定分隔符，使用空白字符作为分隔符

['hello', 'world \n\n\n My name is Dong ']

>>> s.split(maxsplit=100) #最大分隔次数大于可分隔次数时无效

['hello', 'world', 'My', 'name', 'is', 'Dong']

字符串连接join()

>>> li = ["apple", "peach", "banana", "pear"]

>>> ','.join(li)

'apple,peach,banana,pear'

>>> '.'.join(li)

'apple.peach.banana.pear'

查找替换replace()，类似于Word中的“全部替换”功能。

>>> words = ('测试', '非法', '暴力', '话')

>>> text = '这句话里含有非法内容'

>>> for word in words:

if word in text:

text = text.replace(word, '***')

>>> text

'这句***里含有***内容'

字符串对象的maketrans()方法用来生成字符映射表，而translate()方法用来根据映射表中定义的对应关系转换字符串并替换其中的字符，使用这两个方法的组合可以同时处理多个字符。

#创建映射表，将字符"abcdef123"一一对应地转换为"uvwxyz@#$"

>>> table = ''.maketrans('abcdef123', 'uvwxyz@#$')

>>> s = "Python is a great programming language. I like it!"

>>> s.translate(table) #按映射表进行替换

'Python is u gryut progrumming lunguugy. I liky it!'

strip()、rstrip()、lstrip() 删除部分字符串

这三个方法的参数指定的字符串并不作为一个整体对待，而是在原字符串的两侧、右侧、左侧删除参数字符串中包含的所有字符，一层一层地从外往里扒。

>>> s = " abc "

>>> s.strip() #删除空白字符

'abc'

>>> '\n\nhello world \n\n'.strip() #删除空白字符

'hello world'

>>> "aaaassddf".strip("a") #删除指定字符

'ssddf'

>>> "aaaassddf".strip("af")

'ssdd'

>>> "aaaassddfaaa".rstrip("a") #删除字符串右端指定字符

'aaaassddf'

>>> "aaaassddfaaa".lstrip("a") #删除字符串左端指定字符

'ssddfaaa'

内置函数eval()

>>> eval("3+4") #计算表达式的值

7

>>> a = 3

>>> b = 5

>>> eval('a+b') #要求变量a和b已存在

8

>>> import math

>>> eval('math.sqrt(3)')

1.7320508075688772

>>> eval('aa') #当前上下文中不存在对象aa

NameError: name 'aa' is not defined

>>> eval('*'.join(map(str, range(1, 6)))) #5的阶乘

120

成员判断，关键字in

>>> "a" in "abcde" #测试一个字符中是否存在于另一个字符串中

True

>>> 'ab' in 'abcde'

True

>>> 'ac' in 'abcde' #关键字in左边的字符串作为一个整体对待

False

>>> "j" in "abcde"

False

s.startswith(t)、s.endswith(t)，判断字符串是否以指定字符串开始或结束

>>> s = 'Beautiful is better than ugly.'

>>> s.startswith('Be') #检测整个字符串

True

>>> s.startswith('Be', 5) #指定检测范围起始位置

False

>>> s.startswith('Be', 0, 5) #指定检测范围起始和结束位置

True

>>> import os

>>> [filename for filename in os.listdir(r'c:\\')

if filename.endswith(('.bmp','.jpg','.gif'))]

center()、ljust()、rjust()，返回指定宽度的新字符串，原字符串居中、左对齐或右对齐出现在新字符串中，如果指定宽度大于字符串长度，则使用指定的字符（默认为空格）进行填充。

>>> 'Hello world!'.center(20) #居中对齐，以空格进行填充

' Hello world! '

>>> 'Hello world!'.center(20, '=') #居中对齐，以字符=进行填充

'====Hello world!===='

>>> 'Hello world!'.ljust(20, '=') #左对齐

'Hello world!========'

>>> 'Hello world!'.rjust(20, '=') #右对齐

'========Hello world!'

isalnum()、isalpha()、isdigit()、isdecimal()、isnumeric()、isspace()、isupper()、islower()，用来测试字符串是否为数字或字母、是否为字母、是否为数字字符、是否为空白字符、是否为大写字母以及是否为小写字母。

>>> '1234abcd'.isalnum()

True

>>> '1234abcd'.isalpha() #全部为英文字母时返回True

False

>>> '1234abcd'.isdigit() #全部为数字时返回True

False

>>> 'abcd'.isalpha()

True

>>> '1234.0'.isdigit()

False

>>> '1234'.isdigit()

True

>>> '九'.isnumeric() #isnumeric()方法支持汉字数字

True

>>> '九'.isdigit()

False

>>> '九'.isdecimal()

False

>>> 'ⅣⅢⅩ'.isdecimal()

False

>>> 'ⅣⅢⅩ'.isdigit()

False

>>> 'ⅣⅢⅩ'.isnumeric() #支持罗马数字

True

切片也适用于字符串，但仅限于读取其中的元素，不支持字符串修改。

>>> 'Explicit is better than implicit.'[:8]

'Explicit'

>>> 'Explicit is better than implicit.'[9:23]

'is better than'

Pytho标准库zlib中提供的compress()和decompress()函数可以用于字节串的压缩和解压缩。

>>> import zlib

>>> x = 'Python程序设计系列图书，董付国编著'.encode()

>>> len(x)

48

>>> len(zlib.compress(x))

59

>>> x = ('Python系列图书'*3).encode()

>>> len(x)

54

>>> y = zlib.compress(x) #信息重复度越高，压缩比越大

>>> len(y)

30

>>> z = zlib.decompress(y)

>>> len(z)

54

>>> z.decode()

'Python系列图书Python系列图书Python系列图书'

Python标准库string中定义数字字符、标点符号、英文字母、大写字母、小写字母等常量。

>>> import string

>>> string.digits

'0123456789'

>>> string.punctuation

'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

>>> string.ascii_letters

'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

>>> string.ascii_lowercase

'abcdefghijklmnopqrstuvwxyz'

>>> string.ascii_uppercase

'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

在Python中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能重新创建一个新的字符串对象。然而，如果确实需要一个支持原地修改的unicode数据对象，可以使用io.StringIO对象或array模块。

lower()、upper()、capitalize()、title()、swapcase()

>>> s = "What is Your Name?"

>>> s.lower() #返回小写字符串

'what is your name?'

>>> s.upper() #返回大写字符串

'WHAT IS YOUR NAME?'

>>> s.capitalize() #字符串首字符大写

'What is your name?'

>>> s.title() #每个单词的首字母大写

'What Is Your Name?'

>>> s.swapcase() #大小写互换

'wHAT IS yOUR nAME?'

Jieba分词的三种模式

精确模式：把文本精确的切分开，不存在冗余单词

全模式：把文本中所有可能的词语都扫描出来，有冗余

搜索引擎模式：在精确模式基础上，对长词再次切分

txtFile=open(‘dream.txt’,’r’,encoding=’utf-8’)

str=txtFile.read()

txtFile.close()

正则表达式及常见的基本符号

2. 字符组：[字符组]

2.元字符

正则表达式语言由两种基本字符类型组成：原义（正常）文本字符和元字符。

3.量词

正则表达式的量词分别式贪婪，惰性，支配性。

贪婪量词：先看整个字符串是不是一个匹配。如果没有发现匹配，它去掉最后字符串中的最后一个字符，并再次尝试。

惰性量词: 先看字符串中的第一个字母是不是一个匹配。如果单独这一个字符还不够，就读入下一个字符，组成两个字符的字符串。如果还是没有发现匹配，惰性量词继续从字符串添加字符直到发现一个匹配或者整个字符串都检查过也没有匹配。

支配量词：只尝试匹配整个字符串。如果整个字符串不能产生匹配，不做进一步尝试，支配量词其实简单的说，就是一刀切。

re模块实现正则表达式操作

Python提供了re模块，用于实现正则表达式的操作。在实现时，可以使用re模块提供的方法（如search()、match()、 findall()等）进行字符串处理，也可以先使用re模块的compile()方法将模式字符串转换为正则表达式对象，然后再使用该正则表达式对象的相关方法来操作字符串。

re模块在使用时，需要先应用import语句引入，具体代码：

import re

1.使用match()方法进行匹配

match()方法用于指定文本模式和待匹配的字符串。从字符串的开始处进行匹配，如果在起始位置匹配成功，则返回match对象，否则返回None。

re.match(pattern, string, [flags])

pattern：表示模式字符串，由要匹配的正则表达式转换而来。

string：表示待匹配的字符串。

flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。常用的标志如表所示。

在使用match()方法时，如果匹配成功，则match方法返回Match对象，然后可以调用对象中的group方法获取匹配成功的字符串，如果文本模式就是一个普通的字符串，那么group方法返回的就是文本模式本身。

2搜索与替换字符串

sub与subn函数用于实现搜索和替换功能，这两个函数都是将某一个字符串中所有匹配的正则表达式的部分替换成其他字符串。

sub(pattern,repl,string,count=0,flag=0)

1.pattern正则表达式的字符串

2.repl被替换的内容

3.string正则表达式匹配的内容

4.count:由于正则表达式匹配的结果是多个，使用count来限定替换的个数从左向右，默认值是0，替换所有的匹配到的结果

5.flags是匹配模式，可以使用按位或者“|”表示同时生效

3 分割字符串：split()

split函数可以将字符串中与模式匹配的字符串都作为分隔符来分隔字符串，返回一个列表形式的分隔结果，每一个列表元素都是分隔的子字符串。

re.split(pattern, string, maxsplit=0, flags=0)

pattern compile 生成的正则表达式对象，或者自定义也可

string 要匹配的字符串

maxsplit 指定最大分割次数，不指定将全部分割

4 搜索字符串

1.使用search()方法搜索字符串

通常使用search()方法，该方法的参数与match()方法的参数一致。

re.search(pattern, string, flags=0)

pattern：匹配的正则表达式

string ：要匹配的字符串。

Flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

2.使用findall()和finditer()函数搜索字符串

findall函数用于查询字符串中某个正则表达式模式全部的非重复出现情况，与search函数在执行字符串搜索时类似，但与match和search函数不同之处在于，findall函数总会返回一个包含搜索结果的列表。

findall(string[, pos[, endpos]])

string : 待匹配的字符串。

pos : 可选参数，指定字符串的起始位置，默认为 0。

endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

5 编译标志

编译正则表达式模式，返回一个对象。使用顺序是：首先用import re引用，然后用re.compile()函数将正则表达式字符串编译成正则表达式对象，再利用re提供的内置函数对字符串进行匹配、搜索、替换、切分和分组等操作。

re.compile(pattern, flags=0)

pattern：指定编译时的表达式字符串

flags：编译标志位，用来修改正则表达式的匹配方式。支持 re.L|re.M 同时匹配。

第5章　函数的设计和使用

5.1 函数定义

将可能需要反复执行的代码封装为函数，并在需要该功能的地方进行调用，不仅可以实现代码复用，更重要的是可以保证代码的一致性，只需要修改该函数代码则所有调用均受到影响。

设计函数时，应注意提高模块的内聚性，同时降低模块之间的隐式耦合。

函数定义语法：

def 函数名([参数列表]):

'''注释'''

函数体

5.3.1 默认值参数

调用带有默认值参数的函数时，可以不对默认值参数进行赋值，也可以为其赋值，具有很大的灵活性。带有默认值参数的函数定义语法如下：

def 函数名(……，形参名=默认值):

函数体

注意：默认值参数必须出现在函数参数列表的最右端，任何一个默认值参数右边不能有非默认值参数。

原因在于默认值参数的赋值只会在函数定义时被解释一次。当使用可变序列作为参数默认值时，一定要谨慎操作。

可以使用“函数名.__defaults__”查看所有默认参数的当前值

5.3.2 关键参数

通过关键参数，实参顺序可以和形参顺序不一致，但不影响传递结果，避免了用户需要牢记位置参数顺序的麻烦。

>>> def demo(a,b,c=5):

print(a,b,c)

>>> demo(3,7)

3 7 5

>>> demo(a=7,b=3,c=6)

7 3 6

>>> demo(c=8,a=9,b=0)

9 0 8

5.3.3 可变长度参数

可变长度参数主要有两种形式：在参数名前加1个星号*或2个星号**。

*parameter用来接收多个位置实参并将其放在元组中。

**parameter接收多个关键参数并存放到字典中。

5.3.4 参数传递的序列解包

传递参数时，可以通过在实参序列前加一个星号将其解包，然后传递给多个单变量形参。

>>> def demo(a, b, c):

print(a+b+c)

>>> seq = [1, 2, 3]

>>> demo(*seq)

6

>>> tup = (1, 2, 3)

>>> demo(*tup)

6

>>> dic = {1:'a', 2:'b', 3:'c'}

>>> demo(*dic)

6

>>> Set = {1, 2, 3}

>>> demo(*Set)

6

>>> demo(*dic.values())

abc

如果函数实参是字典，可以在前面加两个星号进行解包，等价于关键参数。

>>> def demo(a, b, c):

print(a+b+c)

>>> dic = {'a':1, 'b':2, 'c':3}

>>> demo(**dic)

6

>>> demo(a=1, b=2, c=3)

6

>>> demo(*dic.values())

6

注意：调用函数时对实参序列使用一个星号*进行解包后的实参将会被当做普通位置参数对待，并且会在关键参数和使用两个星号**进行序列解包的参数之前进行处理。

全局变量可以通过关键字global来定义。这分为两种情况：

一个变量已在函数外定义，如果在函数内需要为这个变量赋值，并要将这个赋值结果反映到函数外，可以在函数内使用global将其声明为全局变量。

如果一个变量在函数外没有定义，在函数内部也可以直接将一个变量定义为全局变量，该函数执行后，将增加一个新的全局变量。

5.6 lambda表达式

lambda表达式可以用来声明匿名函数（也可以定义具名函数），也就是没有函数名字的临时使用的小函数，尤其适合需要一个函数作为另一个函数参数的场合。

lambda表达式只可以包含一个表达式，该表达式可以任意复杂，其计算结果可以看作是函数的返回值。

Lambda表达式格式：

lambda arg1,arg2,arg3……: <表达式>