今天将从函数开始说起，函数是功能相对独立且不会重复使用的代码的封装。学会使用定义和使用函数，就能够写出更为优质的代码。当然，Python语言的标准库中已经为我们提供了大量的模块和常用的函数，用好这些模块和函数就能够用更少的代码做更多的事情。

函数和模块定义函数

数学上的函数通常形如 或者 这样的形式，在 中，f是函数的名字，x是函数的自变量，y是函数的因变量；而 中，g是函数名，x和y是函数的自变量，z是函数的因变量。Python中的函数跟这个结构是一致的，每个函数都有自己的名字、自变量和因变量。我们通常把Python中函数的自变量称为函数的参数，而因变量称为函数的返回值。

在Python中可以使用def关键字来定义函数，和变量一样每个函数也应该有一个漂亮的名字，命名规则跟变量的命名规则是一致的。在函数名后面的圆括号中可以放置传递给函数的参数，就是我们刚才说到的函数的自变量，而函数执行完成后我们会通过return关键字来返回函数的执行结果，就是我们刚才说的函数的因变量。一个函数要执行的代码块（要做的事情）也是通过缩进的方式来表示的，跟之前分支和循环结构的代码块是一样的。大家不要忘了def那一行的最后面还有一个:，之前提醒过大家，那是在英文输入法状态下输入的冒号。

我们可以通过函数对上面的代码进行重构。所谓重构，是在不影响代码执行结果的前提下对代码的结构进行调整。重构之后的代码如下所示。

"""输入M和N计算C(M,N)Version: 0.1Author: 骆昊"""# 定义函数：def是定义函数的关键字、fac是函数名，num是参数（自变量）def fac(num):    """求阶乘"""    result = 1    for n in range(1, num + 1):        result *= n    # 返回num的阶乘（因变量）    return resultm = int(input('m = '))n = int(input('n = '))# 当需要计算阶乘的时候不用再写重复代码而是直接调用函数fac# 调用函数的语法是在函数名后面跟上圆括号并传入参数print(fac(m) // fac(n) // fac(m - n))

如果函数中没有return语句，那么函数默认返回代表空值的None。另外，在定义函数时，函数也可以没有自变量，但是函数名后面的圆括号是必须有的。Python中还允许函数的参数拥有默认值，我们可以把上一课“CRAPS赌博游戏”的摇色子获得点数的功能封装成函数，代码如下所示。

"""参数的默认值1Version: 0.1Author: 骆昊"""from random import randint# 定义摇色子的函数，n表示色子的个数，默认值为2def roll_dice(n=2):    """摇色子返回总的点数"""    total = 0    for _ in range(n):        total += randint(1, 6)    return total# 如果没有指定参数，那么n使用默认值2，表示摇两颗色子print(roll_dice())# 传入参数3，变量n被赋值为3，表示摇三颗色子获得点数print(roll_dice(3))

我们再来看一个更为简单的例子。

"""参数的默认值2Version: 0.1Author: 骆昊"""def add(a=0, b=0, c=0):    """三个数相加求和"""    return a + b + c# 调用add函数，没有传入参数，那么a、b、c都使用默认值0print(add())         # 0# 调用add函数，传入一个参数，那么该参数赋值给变量a, 变量b和c使用默认值0print(add(1))        # 1# 调用add函数，传入两个参数，1和2分别赋值给变量a和b，变量c使用默认值0print(add(1, 2))     # 3# 调用add函数，传入三个参数，分别赋值给a、b、c三个变量print(add(1, 2, 3))  # 6# 传递参数时可以不按照设定的顺序进行传递，但是要用“参数名=参数值”的形式print(add(c=50, a=100, b=200))    # 350

注意：带默认值的参数必须放在不带默认值的参数之后，否则将产生SyntaxError错误，错误消息是：non-default argument follows default argument，翻译成中文的意思是“没有默认值的参数放在了带默认值的参数后面”。

可变参数

接下来，我们还可以实现一个对任意多个数求和的add函数，因为Python语言中的函数可以通过星号表达式语法来支持可变参数。所谓可变参数指的是在调用函数时，可以向函数传入0个或任意多个参数。将来我们以团队协作的方式开发商业项目时，很有可能要设计函数给其他人使用，但有的时候我们并不知道函数的调用者会向该函数传入多少个参数，这个时候可变参数就可以派上用场。下面的代码演示了用可变参数实现对任意多个数求和的add函数。

"""可变参数Version: 0.1Author: 骆昊"""# 用星号表达式来表示args可以接收0个或任意多个参数def add(*args):    total = 0    # 可变参数可以放在for循环中取出每个参数的值    for val in args:        total += val    return total# 在调用add函数时可以传入0个或任意多个参数print(add())print(add(1))print(add(1, 2))print(add(1, 2, 3))print(add(1, 3, 5, 7, 9))

不管用什么样的编程语言来写代码，给变量、函数起名字都是一个让人头疼的问题，因为我们会遇到命名冲突这种尴尬的情况。最简单的场景就是在同一个.py文件中定义了两个同名的函数，如下所示。

def foo():    print('hello, world!')def foo():    print('goodbye, world!')foo()    # 大家猜猜调用foo函数会输出什么

当然上面的这种情况我们很容易就能避免，但是如果项目是团队协作多人开发的时候，团队中可能有多个程序员都定义了名为foo的函数，这种情况下怎么解决命名冲突呢？答案其实很简单，Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块再使用完全限定名的调用方式就可以区分到底要使用的是哪个模块中的foo函数，代码如下所示。

module1.py

def foo():    print('hello, world!')

module2.py

def foo():    print('goodbye, world!')

test.py

import module1import module2# 用“模块名.函数名”的方式（完全限定名）调用函数，module1.foo()    # hello, world!module2.foo()    # goodbye, world!

在导入模块时，还可以使用as关键字对模块进行别名，这样我们可以使用更为简短的完全限定名。

test.py

import module1 as m1import module2 as m2m1.foo()    # hello, world!m2.foo()    # goodbye, world!

上面的代码我们导入了定义函数的模块，我们也可以使用from...import...语法从模块中直接导入需要使用的函数，代码如下所示。

test.py

from module1 import foofoo()    # hello, world!from module2 import foofoo()    # goodbye, world!

但是，如果我们如果从两个不同的模块中导入了同名的函数，后导入的函数会覆盖掉先前的导入，就像下面的代码中，调用foo会输出hello, world!，因为我们先导入了module2的foo，后导入了module1的foo 。如果两个from...import...反过来写，就是另外一番光景了。

test.py

from module2 import foofrom module1 import foofoo()    # hello, world!

如果想在上面的代码中同时使用来自两个模块中的foo函数也是有办法的，大家可能已经猜到了，还是用as关键字对导入的函数进行别名，代码如下所示。

test.py

from module1 import foo as f1from module2 import foo as f2f1()    # hello, world!f2()    # goodbye, world!

Python标准库中提供了大量的模块和函数来简化我们的开发工作，我们之前用过的random模块就为我们提供了生成随机数和进行随机抽样的函数；而time模块则提供了和时间操作相关的函数；上面求阶乘的函数在Python标准库中的math模块中已经有了，实际开发中并不需要我们自己编写，而math模块中还包括了计算正弦、余弦、指数、对数等一系列的数学函数。随着我们进一步的学习Python编程知识，我们还会用到更多的模块和函数。

Python标准库中还有一类函数是不需要import就能够直接使用的，我们将其称之为内置函数，这些内置函数都是很有用也是最常用的，下面的表格列出了一部分的内置函数。

常用数据结构之字符串字符串的定义

所谓字符串，就是由零个或多个字符组成的有限序列，一般记为：

在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。字符串中的字符可以是特殊符号、英文字母、中文字符、日文的平假名或片假名、希腊字母、Emoji字符等。

s1 = 'hello, world!'s2 = "你好，世界！"print(s1, s2)# 以三个双引号或单引号开头的字符串可以折行s3 = '''hello, world!'''print(s3, end='')

提示：print函数中的end=''表示输出后不换行，即将默认的结束符\n（换行符）更换为''（空字符）。

转义字符和原始字符串

可以在字符串中使用\（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n不是代表反斜杠和字符n，而是表示换行；\t也不是代表反斜杠和字符t，而是表示制表符。所以如果字符串本身又包含了'、"、\这些特殊的字符，必须要通过\进行转义处理。例如需要一个带单引号或反斜杠的字符串，可以用如下所示的方法进行处理。

# 头尾带单引号的hello, world!s1 = '\'hello, world!\''print(s1)# 头尾带反斜杠的hello, world!s2 = '\\hello, world!\\'print(s2)

Python中的字符串可以r或R开头，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串'hello\n'中，\n表示换行；而在r'hello\n'中，\n不再表示换行，就是反斜杠和字符n。大家可以运行下面的代码，看看会输出什么。

# 字符串s1中\t是制表符，\n是换行符s1 = '\time up \now'print(s1)# 字符串s2中没有转义字符，每个字符都是原始含义s2 = r'\time up \now'print(s2)

Python中还允许在\后面还可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。另外一种表示字符的方式是在\u后面跟Unicode字符编码，例如\u9a86\u660a代表的是中文“骆昊”。运行下面的代码，看看输出了什么。

s1 = '\141\142\143\x61\x62\x63's2 = '\u9a86\u660a'print(s1, s2)

Python为字符串类型提供了非常丰富的运算符，我们可以使用+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串，我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符。

比较运算

对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。需要说明的是，因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的大小比较比的是每个字符对应的编码的大小。例如A的编码是65， 而a的编码是97，所以'A' < 'a'的结果相当于就是65 < 97的结果，很显然是True；而'boy' < 'bad'，因为第一个字符都是'b'比不出大小，所以实际比较的是第二个字符的大小，显然'o' < 'a'的结果是False，所以'boy' < 'bad'的结果也是False。如果不清楚两个字符对应的编码到底是多少，可以使用ord函数来获得，例如ord('A')的值是65，而ord('昊')的值是26122。下面的代码为大家展示了字符串的比较运算。

s1 = 'a whole new world's2 = 'hello world'print(s1 == s2, s1 < s2)      # False Trueprint(s2 == 'hello world')    # Trueprint(s2 == 'Hello world')    # Falseprint(s2 != 'Hello world')    # Trues3 = '骆昊'print(ord('骆'), ord('昊'))               # 39558 26122s4 = '王大锤'print(ord('王'), ord('大'), ord('锤'))    # 29579 22823 38180print(s3 > s4, s3 <= s4)      # True False

需要强调一下的是，字符串的比较运算比较的是字符串的内容，Python中还有一个is运算符（身份运算符），如果用is来比较两个字符串，它比较的是两个变量对应的字符串是否在内存中相同的位置（内存地址），简单的说就是两个变量是否对应内存中的同一个字符串。看看下面的代码就比较清楚is运算符的作用了。

s1 = 'hello world's2 = 'hello world's3 = s2# 比较字符串的内容print(s1 == s2, s2 == s3)    # True True# 比较字符串的内存地址print(s1 is s2, s2 is s3)    # False True

Python中可以用in和not in判断一个字符串中是否存在另外一个字符或字符串，in和not in运算通常称为成员运算，会产生布尔值True或False，代码如下所示。

s1 = 'hello, world'print('wo' in s1)    # Trues2 = 'goodbye'print(s2 in s1)      # False

获取字符串长度没有直接的运算符，而是使用内置函数len，我们在上节课时提到过这个内置函数，代码如下所示。

s1 = 'hello, world'print(len(s1))                  # 12print(len('goodbye, world'))    # 14

如果希望从字符串中取出某个字符，我们可以对字符串进行索引运算，运算符是[n]，其中n是一个整数，假设字符串的长度为N，那么n可以是从0到N-1的整数，其中0是字符串中第一个字符的索引，而N-1是字符串中最后一个字符的索引，通常称之为正向索引；在Python中，字符串的索引也可以是从-1到-N的整数，其中-1是最后一个字符的索引，而-N则是第一个字符的索引，通常称之为负向索引。注意，因为字符串是不可变类型，所以不能通过索引运算修改字符串中的字符。

s1 = 'abc123456'N = len(s1)# 获取第一个字符print(s1[0], s1[-N])    # a a# 获取最后一个字符print(s1[N-1], s1[-1])  # 6 6# 获取索引为2或-7的字符print(s1[2], s1[-7])    # c c# 获取索引为5和-4的字符print(s1[5], s1[-4])    # 3 3

如果希望从字符串中取出每个字符，可以使用for循环对字符串进行遍历，有两种方式。

方式一：

s1 = 'hello'for index in range(len(s1)):    print(s1[index])

方式二：

s1 = 'hello'for ch in s1:    print(ch)

在Python中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，对于一个字符串类型的变量，我们可以用变量名.方法名()的方式来调用它的方法。所谓方法其实就是跟某个类型的变量绑定的函数，后面我们讲面向对象编程的时候还会对这一概念详加说明。

大小写相关操作

下面的代码演示了和字符串大小写变换相关的方法。

s1 = 'hello, world!'# 使用capitalize方法获得字符串首字母大写后的字符串print(s1.capitalize())   # Hello, world!# 使用title方法获得字符串每个单词首字母大写后的字符串print(s1.title())        # Hello, World!# 使用upper方法获得字符串大写后的字符串print(s1.upper())        # HELLO, WORLD!s2 = 'GOODBYE'# 使用lower方法获得字符串小写后的字符串print(s2.lower())        # goodbye

如果想在一个字符串中查找有没有另外一个字符串，可以使用字符串的find或index方法。

s1 = 'hello, world!'# find方法从字符串中查找另一个字符串所在的位置# 找到了返回字符串中另一个字符串首字符的索引print(s1.find('or'))        # 8# 找不到返回-1print(s1.find('shit'))      # -1# index方法与find方法类似# 找到了返回字符串中另一个字符串首字符的索引print(s1.index('or'))       # 8# 找不到引发异常print(s1.index('shit'))     # ValueError: substring not found

在使用find和index方法时还可以通过方法的参数来指定查找的范围，也就是查找不必从索引为0的位置开始。find和index方法还有逆向查找（从后向前查找）的版本，分别是rfind和rindex，代码如下所示。

s = 'hello good world!'# 从前向后查找字符o出现的位置(相当于第一次出现)print(s.find('o'))       # 4# 从索引为5的位置开始查找字符o出现的位置print(s.find('o', 5))    # 7# 从后向前查找字符o出现的位置(相当于最后一次出现)print(s.rfind('o'))      # 12

可以通过字符串的startswith、endswith来判断字符串是否以某个字符串开头和结尾；还可以用is开头的方法判断字符串的特征，这些方法都返回布尔值，代码如下所示。

s1 = 'hello, world!'# startwith方法检查字符串是否以指定的字符串开头返回布尔值print(s1.startswith('He'))    # Falseprint(s1.startswith('hel'))   # True# endswith方法检查字符串是否以指定的字符串结尾返回布尔值print(s1.endswith('!'))       # Trues2 = 'abc123456'# isdigit方法检查字符串是否由数字构成返回布尔值print(s2.isdigit())    # False# isalpha方法检查字符串是否以字母构成返回布尔值print(s2.isalpha())    # False# isalnum方法检查字符串是否以数字和字母构成返回布尔值print(s2.isalnum())    # True

在Python中，字符串类型可以通过center、ljust、rjust方法做居中、左对齐和右对齐的处理。

s1 = 'hello, world'# center方法以宽度20将字符串居中并在两侧填充*print(s1.center(20, '*'))  # ****hello, world****# rjust方法以宽度20将字符串右对齐并在左侧填充空格print(s1.rjust(20))        #         hello, world# ljust方法以宽度20将字符串左对齐并在右侧填充~print(s1.ljust(20, '~'))   # hello, world~~~~~~~~

我们之前讲过，在用print函数输出字符串时，可以用下面的方式对字符串进行格式化。

a = 321b = 123print('%d * %d = %d' % (a, b, a * b))

当然，我们也可以用字符串的方法来完成字符串的格式，代码如下所示。

a = 321b = 123print('{0} * {1} = {2}'.format(a, b, a * b))

从Python 3.6开始，格式化字符串还有更为简洁的书写方式，就是在字符串前加上f来格式化字符串，在这种以f打头的字符串中，{变量名}是一个占位符，会被变量对应的值将其替换掉，代码如下所示。

a = 321b = 123print(f'{a} * {b} = {a * b}')

如果需要进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作。

修剪操作

字符串的strip方法可以帮我们获得将原字符串修剪掉左右两端空格之后的字符串。这个方法非常有实用价值，通常用来将用户输入中因为不小心键入的头尾空格去掉，strip方法还有lstrip和rstrip两个版本，相信从名字大家已经猜出来这两个方法是做什么用的。

s1 = '   jackfrued@126.com  \t\r\n'# strip方法获得字符串修剪左右两侧空格之后的字符串print(s1.strip())    # jackfrued@126.com

在Python中，列表是由一系元素按特定顺序构成的数据序列，这样就意味着定义一个列表类型的变量，可以保存多个数据，而且允许有重复的数据。跟上一课我们讲到的字符串类型一样，列表也是一种结构化的、非标量类型，操作一个列表类型的变量，除了可以使用运算符还可以使用它的方法。

在Python中，可以使用[]字面量语法来定义列表，列表中的多个元素用逗号进行分隔，代码如下所示。

items1 = [35, 12, 99, 68, 55, 87]print(items1)items2 = ['Python', 'Java', 'Go', 'Kotlin']print(items2)

除此以外，还可以通过Python内置的list函数将其他序列变成列表。准确地说，list并不是一个函数，而是创建列表对象的构造器（后面会讲到对象和构造器这两个概念）。

items1 = list(range(1, 10))print(items1)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]items2 = list('hello')print(items2)    # ['h', 'e', 'l', 'l', 'o']

需要说明的是，列表是一种可变数据类型，也就是说列表可以添加元素、删除元素、更新元素，这一点跟我们上一课讲到的字符串有着鲜明的差别。字符串是一种不可变数据类型，也就是说对字符串做拼接、重复、转换大小写、修剪空格等操作的时候会产生新的字符串，原来的字符串并没有发生任何改变。

定义和使用元组

在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组通常使用()字面量语法，元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。

# 定义一个三元组t1 = (30, 10, 55)# 定义一个四元组t2 = ('骆昊', 40, True, '四川成都')# 查看变量的类型print(type(t1), type(t2))    # <class 'tuple'> <class 'tuple'># 查看元组中元素的数量print(len(t1), len(t2))      # 3 4# 通过索引运算获取元组中的元素print(t1[0], t1[-3])         # 30 30print(t2[3], t2[-1])         # 四川成都 四川成都# 循环遍历元组中的元素for member in t2:    print(member)# 成员运算print(100 in t1)    # Falseprint(40 in t2)     # True# 拼接t3 = t1 + t2print(t3)           # (30, 10, 55, '骆昊', 40, True, '四川成都')# 切片print(t3[::3])      # (30, '骆昊', '四川成都')# 比较运算print(t1 == t3)    # Falseprint(t1 >= t3)    # Falseprint(t1 < (30, 11, 55))    # True

一个元组中如果有两个元素，我们就称之为二元组；一个元组中如果五个元素，我们就称之为五元组。需要提醒大家注意的是，()表示空元组，但是如果元组中只有一个元素，需要加上一个逗号，否则()就不是代表元组的字面量语法，而是改变运算优先级的圆括号，所以('hello', )和(100, )才是一元组，而('hello')和(100)只是字符串和整数。我们可以通过下面的代码来加以验证。

# 空元组a = ()print(type(a))    # <class 'tuple'># 不是元组b = ('hello')print(type(b))    # <class 'str'>c = (100)print(type(c))    # <class 'int'># 一元组d = ('hello', )print(type(d))    # <class 'tuple'>e = (100, )print(type(e))    # <class 'tuple'>

关于Python的入门知识，就讲到这里了。随着时代的飞速发展，社会对于计算机人才的需求也是有目共睹的。越来越多的人工都将被机械替代，而我们所要面对的就是这扑面而来的机械狂潮。学习更多知识，才不至于落后于社会。

喜欢小编别忘记关注一下哦~

想要更多学习资料的，私信【资料】即可领取