Python基础

Python基础

1. 基本认识

1.1 Python是什么?

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

• ** Python 是一种解释型语言**： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• ** Python 是面向对象语言**: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• ** Python 是初学者的语言**：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

1.2 Python语言特点

• Python语法简洁、清晰
• Python是纯粹的自由软件
• Python是一个高级程序设计语言，将许多机器层面上的实现细节隐藏，交给编译器处理。Python程序员可以花更多的时间用于思考程序的逻辑，而不是具体的机器实现细节。这一特征使得Python开始流行，尤其是在非计算机专业领域得到更加广泛的关注。
• Python具有良好的跨平台特性。
• Python是一种解释性语言。首先把Python编写的源代码转换成字节码的中间形式。运行时，解释器再把字节码翻译成适合于特定环境的机器语言并运行。这使得Python程序更加易于移植。
• Python语言具有良好的可扩展性。例如，Python可以调用使用C、C++等语言编写的程序，可以调用R语言中专业的数据分析功能。
• Python标准库非常庞大，可以处理各种工作。

1.3 Python的应用领域

目前Python在Web应用后端开发、云基础设施建设、DevOps、网络数据采集（爬虫）、自动化测试、数据分析、机器学习等领域都有着广泛的应用。

2. python基础语法

2.1 标识符

• 第一个字符必须是字母表中字母或下划线 _ 。

• 标识符的其他的部分由字母、数字和下划线组成。

• 标识符对大小写敏感。

• 在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

2.2 关键字

我们不能把关键字用作任何标识符名称。

Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：（也就是说所有这些keyword都不能拿来做变量名或者标识符哦）

import keyword
keyword.kwlist
1
2

2.3 注释

Python中单行注释以 # 开头，实例如下：

# 第一个注释
print ("Hello, Python!") # 第二个注释
1
2

多行注释可以用多个#号，也可以用'''和"""

# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")
1
2
3
4
5
6
7
8
9
10
11
12
13

2.4 行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：

if True:
    print ("True")
else:
    print ("False")
1
2
3
4

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误
1
2
3
4
5
6

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠\来实现多行语句，例如：

item_one = 1
item_two = 2
item_three = 3
total = item_one + \
        item_two + \
        item_three
1
2
3
4
5
6

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠\，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']
1
2

2.5 输入与输出

输入

input()函数用于输入数据，无论用户输入什么内容，该函数都返回字符串类型。其格式如下：
input(prompt=None, /)。其中prompt表示提示信息，默认为空，如果不空，则显示提示信息。然后等待用户输入，输入完毕后按回车键，并将用户输入作为一个字符串返回，并自动忽略换行符。

x=input("请输入x值")
x
type(x) #查看x的类型
1
2
3

当用户输入10，按回车键之后，input()函数将字符串’10’赋予变量x，结果就是字符串’10’。内置函数type()返回对象的类型。

输出

Python中最简单的输出方式就是使用print()函数。其格式如下：
print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
其中各参数的解释如下：

• value： 表示需要输出的对象，一次可以输出一个或者多个对象（其中…表示任意多个对象），当输出多个对象时，对象之间要用逗号,分隔；
• sep：表示输出时对象之间的间隔符，默认用一个空格分隔；
• end：表示输出以何字符结尾，默认值是换行符；
• file：表示输出位置，可将输出到文件，file指定的对象要有“写”的方法，默认值是sys.stdout（标准输出）；
• flush：将缓存里面的内容是否强制刷新输出，默认值是False。

print('hello','world','!')#一次输出三个对象。中间默认用空格隔开
print('hello','world','!',sep='*')#一次输出三个对象，中间用*隔开。
1
2

3. 导入模块与使用帮助

3.1 导入模块

我们在进行代码编辑过程中，除了简单的加减乘除外，还会需要使用到很多的数学运算、统计分析等，这时就需要用到大量的模块。

需要注意的是，当安装好Python 之后，有一些模块就已经默认安装了，这些模块称为 “标准库”，“标准库”中的模块无领另行安装，就可以直接使用。
比如，math 模块，不用安装就可以直接使用，而其他的模块（非标准库）如 NumPy、Pandas、 scipy、Matplotlib 等则需要安装。

导入模块的几种方式

# 几种导入方法示例
import math #方法1
import math as ma #方法2
import matplotlib.pyplot as plt #方法3
from math import log #方法4
from matplotlib.pyplot import figure,plot #方法5
1
2
3
4
5
6

3.2 使用帮助

Python提供了dir和help函数供用户查看模块、函数等的相关说明。
以查看math模块的相关说明为例，在Python命令窗口中输入dir(math)即可查看math模块的可用属性和函数

import math
dir(math)
1
2

help函数可以查看模块、函数等的详细说明信息。例如在import math后，输入命令help(math)，将列出math模块中所有的常量和函数详细说明。如果输入help(math.sqrt)将只列出math.sqrt函数的详细信息。

import math
help(math.sqrt)
1
2

4. 数据结构

4.1 Python 列表

List（列表） 是 Python 中使用最频繁的数据结构之一。

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

lis = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print(lis)               # 输出完整列表
print(lis[0])            # 输出列表的第一个元素
print(lis[1:3])          # 输出第二个至第三个元素 
print(lis[2:])           # 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2)       # 输出列表两次
print(lis + tinylist)    # 打印组合的列表
1
2
3
4
5
6
7
8

4.2 Python 元组

元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print(tuple)               # 输出完整元组
print(tuple[0])            # 输出元组的第一个元素
print(tuple[1:3])          # 输出第二个至第四个（不包含）的元素 
print(tuple[2:])           # 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2)       # 输出元组两次
print(tuple + tinytuple)   # 打印组合的元组
1
2
3
4
5
6
7
8
9

以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
lis = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
lis[2] = 1000     # 列表中是合法应用
1
2
3
4

4.3 Python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print(dict['one'])          # 输出键为'one' 的值
print(dict[2])              # 输出键为 2 的值
print(tinydict)             # 输出完整的字典
print(tinydict.keys())      # 输出所有键
print(tinydict.values())    # 输出所有值
1
2
3
4
5
6
7
8
9

4.4 Python 集合

集合（Set）是无序和无索引的集合。在 Python 中，集合用花括号 { } 编写。
集合一旦创建，就无法更改项目，但是可以添加新项目。

thisset = {"apple", "banana", "cherry"}
print(thisset) #输出thisset集合
thisset.add("orange") #添加项目
print(thisset)
thisset.update(["orange", "mango", "grapes"]) #使用update将多个项目添加到集合中
print(thisset)
print(len(thisset)) #输出集合的长度
thisset.remove("banana") #删除集合中的项目
print(thisset)
1
2
3
4
5
6
7
8
9

5. 变量

5.1 变量赋值

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号=用来给变量赋值。

等号=运算符左边是一个变量名,等号=运算符右边是存储在变量中的值。例如：

counter = 100    # 整型变量
miles = 1000.0   # 浮点型变量
name = "你好"     # 字符串

print (counter)
print (miles)
print (name)
1
2
3
4
5
6
7

5.2 多变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1
print(a,b,c)
1
2

以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "你好" #将两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "你好" 分配给变量 c。
print(a,b,c)
1
2

5.3 变量类型

在程序设计中，变量是一种存储数据的载体。
计算机能处理的数据有很多种类型，除了数值之外还可以处理文本、图形、音频、视频等各种各样的数据，那么不同的数据就需要定义不同的存储类型。
Python中的数据类型很多，我们先介绍几种常用的数据类型。

• 整型int：Python中可以处理任意大小的整数
• 浮点型float：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，浮点数除了数学写法（如123.456）之外还支持科学计数法（如1.23456e2）。
• 字符串型str：字符串是以单引号或双引号括起来的任意文本，比如’hello’和"hello"。
• 布尔型：布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来（例如3 < 5会产生布尔值True，而2 == 1会产生布尔值False）。
• 复数型：形如3+5j，跟数学上的复数表示一样，唯一不同的是虚部的i换成了j。实际上，这个类型并不常用，大家了解一下就可以了。

5.4 变量的使用

下面通过几个例子来说明变量的类型和变量使用。

"""
使用变量保存数据并进行加减乘除运算
"""
a = 321
b = 12
print(a + b)    # 333
print(a - b)    # 309
print(a * b)    # 3852
print(a / b)    # 26.75
1
2
3
4
5
6
7
8
9

在Python中可以使用type函数对变量的类型进行检查。程序设计中函数的概念跟数学上函数的概念是一致的，数学上的函数相信大家并不陌生，它包括了函数名、自变量和因变量。如果暂时不理解这个概念也不要紧，我们会在后续的章节中专门讲解函数的定义和使用。

"""
使用type()检查变量的类型
"""
a = 100
b = 12.345
c = 1 + 5j
d = 'hello, world'
e = True
print(type(a))    # 打印出变量a的类型
print(type(b))  
print(type(c))  
print(type(d))  
print(type(e))
1
2
3
4
5
6
7
8
9
10
11
12
13

可以使用Python中内置的函数对变量类型进行转换。
int( )：将一个数值或字符串转换成整数，可以指定进制。
float( )：将一个字符串转换成浮点数。
str( )：将指定的对象转换成字符串形式，可以指定编码。
chr( )：将整数转换成该编码对应的字符串（一个字符）。
ord( )：将字符串（一个字符）转换成对应的编码（整数）。
下面的代码通过键盘输入两个整数来实现对两个整数的算术运算。

"""
使用input()函数获取键盘输入(字符串)
使用int()函数将输入的字符串转换成整数
使用print()函数输出带占位符的字符串

"""
a = int(input('a= '))
b = int(input('b = '))
print('%d + %d = %d' % (a, b, a + b))
print('%d - %d = %d' % (a, b, a - b))
print('%d * %d = %d' % (a, b, a * b))
print('%d / %d = %f' % (a, b, a / b))
print('%d // %d = %d' % (a, b, a // b))
print('%d %% %d = %d' % (a, b, a % b))
print('%d ** %d = %d' % (a, b, a ** b))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6. 运算符

Python支持多种运算符，下面大致按照优先级从高到低的顺序列出了所有的运算符。
运算符的优先级指的是多个运算符同时出现时，先做什么运算然后再做什么运算。除了我们之前已经用过的赋值运算符和算术运算符，我们稍后会陆续讲到其他运算符的使用。

6.1 赋值运算符

赋值运算符应该是最为常见的运算符，它的作用是将右边的值赋给左边的变量。下面的例子演示了赋值运算符和复合赋值运算符的使用。

"""
赋值运算符和复合赋值运算符
"""
a = 10
b = 3
a += b        # 相当于：a = a + b
a *= a + 2    # 相当于：a = a * (a + 2)
print(a)      # 算一下这里会输出什么
1
2
3
4
5
6
7
8

6.2 比较运算符

比较运算符有的地方也称为关系运算符，包括==、!=、<、>、<=、>=，我相信没有什么好解释的，大家一看就能懂。

• 唯一需要提醒的是比较相等用的是==，请注意这个地方是两个等号，因为=是赋值运算符，我们在上面刚刚讲到过，==才是比较相等的比较运算符。比较运算符会产生布尔值，要么是True要么是False。

6.3 逻辑运算符

逻辑运算符有三个，分别是and、or和not。

（1）and字面意思是“而且”，所以and运算符会连接两个布尔值，如果两个布尔值都是True，那么运算的结果就是True；左右两边的布尔值有一个是False，最终的运算结果就是False。

• 相信大家已经想到了，如果and左边的布尔值是False，不管右边的布尔值是什么，最终的结果都是False，所以在做运算的时候右边的值会被跳过（短路处理），这也就意味着在and运算符左边为False的情况下，右边的表达式根本不会执行。

（2）or字面意思是“或者”，所以or运算符也会连接两个布尔值，如果两个布尔值有任意一个是True，那么最终的结果就是True。当然，or运算符也是有短路功能的，在它左边的布尔值为True的情况下，右边的表达式根本不会执行。

（3）not运算符的后面会跟上一个布尔值，它的作用是得到与该布尔值相反的值，也就是说，后面的布尔值如果是True运算结果就是False，而后面的布尔值如果是False则运算结果就是True。

"""
比较运算符和逻辑运算符的使用
"""
flag0 = 1 == 1
flag1 = 3 > 2
flag2 = 2 < 1
flag3 = flag1 and flag2
flag4 = flag1 or flag2
flag5 = not (1 != 2)
print('flag0 =', flag0)    # flag0 = True
print('flag1 =', flag1)    # flag1 = True
print('flag2 =', flag2)    # flag2 = False
print('flag3 =', flag3)    # flag3 = False
print('flag4 =', flag4)    # flag4 = True
print('flag5 =', flag5)    # flag5 = False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

tips：比较运算符的优先级高于赋值运算符，所以flag0 = 1 == 1先做1 == 1产生布尔值True，再将这个值赋值给变量flag0。print函数可以输出多个值，多个值之间可以用,进行分隔，输出的内容之间默认以空格分开。

7. 分支结构

迄今为止，我们写的Python代码都是一条一条语句顺序执行，这种代码结构通常称之为顺序结构。
然而仅有顺序结构并不能解决所有的问题。
比如我们设计一个游戏，游戏第一关的通关条件是玩家获得1000分，那么在完成本局游戏后，我们要根据玩家得到分数来决定究竟是进入第二关，还是告诉玩家“Game Over”，这里就会产生两个分支，而且这两个分支只有一个会被执行。类似的场景还有很多，我们将这种结构称之为“分支结构”或“选择结构”。给大家一分钟的时间，你应该可以想到至少5个以上这样的例子，赶紧试一试。

7.1 if语句

Python中if语句的一般形式如下所示：

if condition_1:  
    statement_block_1  
elif condition_2:  
    statement_block_2  
else:  
    statement_block_3  
1
2
3
4
5
6

• 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
• 如果 “condition_1” 为False，将判断 “condition_2”
• 如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
• 如果 “condition_2” 为False，将执行"statement_block_3"块语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：
1、每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

# 用户名是admin且密码是123456则身份验证成功否则身份验证失败
username = input('请输入用户名: ')
password = input('请输入密码: ')

if username == 'admin' and password == '123456':
    print('身份验证成功!')
else:
    print('身份验证失败!')
1
2
3
4
5
6
7
8

当然如果要构造出更多的分支，可以使用if…elif…else…结构或者嵌套的if…else…结构，下面的代码演示了如何利用多分支结构实现分段函数求值。

x = float(input('x = '))
if x > 1:
    y = 3 * x - 5
elif x >= -1:
    y = x + 2
else:
    y = 5 * x + 3
print('f(%.2f) = %.2f' % (x, y))
1
2
3
4
5
6
7
8

当然根据实际开发的需要，分支结构是可以嵌套的，例如判断是否通关以后还要根据你获得的宝物或者道具的数量对你的表现给出等级（比如点亮两颗或三颗星星），那么我们就需要在if的内部构造出一个新的分支结构，同理elif和else中也可以再构造新的分支，我们称之为嵌套的分支结构，也就是说上面的代码也可以写成下面的样子。

x = float(input('x = '))
if x > 1:
    y = 3 * x - 5
else:
    if x >= -1:
        y = x + 2
    else:
        y = 5 * x + 3
print('f(%.2f) = %.2f' % (x, y))
1
2
3
4
5
6
7
8
9

大家可以自己感受一下这两种写法到底是哪一种更好。在之前我们提到的Python之禅中有这么一句话“Flat is better than nested.”，之所以提倡代码“扁平化”是因为嵌套结构的嵌套层次多了之后会严重的影响代码的可读性，所以能使用扁平化的结构时就不要使用嵌套。

7.2 多分支if/elif/else语句

多分支结构比较复杂，可以画图表示如下：

实例
从键盘输入标准价格和订货量。根据订货量大小，价格给以不同的折扣，计算应付货款（应付货款=订货量×价格×(1-折扣)）。

• 订货量300以下，没有折扣；
• 订货量300及以上，500以下，折扣为3%；
• 订货量500及以上，1000以下，折扣5%；
• 订货量1000及以上，2000以下，折扣8%；
• 订货量2000及以上，折扣10%。

分析：键盘输入标准价格price、订货量Quantity，依照上述标准进行判断得到折扣率。注意，还需要考虑订货量和标准价格输入小于0时的错误情况。

price=float(input('请输入标准价格'))
quantity=int(input('请输入订货量'))

if quantity<0:
    coff=-1
elif quantity<300:
    coff=0.0
elif quantity<500:
    coff=0.03
elif quantity<1000:
    coff=0.05
elif quantity<2000:
    coff=0.08
else:
    coff=0.1

if quantity>=0 and price>=0:
    pays=quantity*price*(1-coff)
    print('支付金额：',pays)
else:
    print('输入的订货量与标准价格均不能小于零！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7.3 选择结构的嵌套

在某一个分支的语句体中，又嵌套新的分支结构，这种情况称为选择结构的嵌套。选择结构的嵌套形式因问题不同而千差万别，因此分析透彻每一个分支的逻辑情况是编写程序的基础。

实例
输入客户类型、标准价格和订货量。根据客户类型（<5为新客户，>=5老客户）和订货量给予不同的折扣，计算应付货款（应付货款=订货量×价格×(1-折扣)）。
如果是新客户：
订货量800以下，没有折扣；
否则折扣为2%。
如果是老客户：
订货量500以下，折扣为3%；
订货量500及以上，1000以下，折扣5%；
订货量1000及以上，2000以下，折扣8%；
订货量2000及以上，折扣10%。

ctype=int(input('请输入客户类型（小于5为新客户）:'))
price=float(input('请输入标准价格:'))
quantity=int(input('请输入订货数量:'))

if ctype>0 and price>0 and quantity>0:
    if ctype<5:
        if quantity<800:
            coff=0
        else:
            coff=0.02
    else:
        if quantity<500:
            coff=0.03
        elif quantity<1000:
            coff=0.05
        elif quantity<2000:
            coff=0.08
        else:
            coff=0.1
    pays=quantity*price*(1-coff)
    print('支付金额：',pays)
else:
    print('输入错误')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7.4 while 循环嵌套

while 嵌套就是：while 里面还有 while

7.4.1 循环嵌套基本语法

while 条件 1:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...
    
    while 条件 2:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...
    
        处理条件 2
    
    处理条件 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7.4.2 打印九九乘法表

# 定义起始行
row = 1
# 最大打印 9 行
while row <= 9:
    # 定义起始列
    col = 1
    # 最大打印 row 列
    while col <= row:
        # end = ""，表示输出结束后，不换行
        # "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
        print("%d * %d = %d" % (col, row, row * col), end="\t")
        # 列数 + 1
        col += 1
    # 一行打印完成的换行
    print("")
    # 行数 + 1
    row += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

7.5 for循环

如果明确的知道循环执行的次数或者要对一个容器进行迭代，那么推荐使用for-in循环。

7.5.1 for语句格式

for循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for循环的一般格式如下：

for  in :  
      
else:  
    
1
2
3
4

for 循环实例：

languages = ["C", "C++", "Perl", "Python"] 
for x in languages:
    print (x)
1
2
3

7.5.2 for循环加入break

以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

sites = ["Baidu", "Google","jindong","Taobao"]
for site in sites:
    if site == "jindong":
        print("购物!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
1
2
3
4
5
6
7
8
9

执行脚本后，在循环到 "jindong"时会跳出循环体，完成循环。

7.5.3 range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

for i in range(5):
    print(i)
1
2

利用range（）函数计算1~100和：

sum = 0
for x in range(101):
    sum += x
print(sum)
1
2
3
4

需要说明的是上面代码中的range(1, 101)可以用来构造一个从1到100的范围，当我们把这样一个范围放到for-in循环中，就可以通过前面的循环变量x依次取出从1到100的整数。当然，range的用法非常灵活，下面给出了一个例子：

• range(101)：可以用来产生0到100范围的整数，需要注意的是取不到101。
• range(1, 101)：可以用来产生1到100范围的整数，相当于左闭右开
• range(1, 101, 2)：可以用来产生1到100的奇数，其中2是步长，即每次数值递增的值。
• range(100, 0, -2)：可以用来产生100到1的偶数，其中-2是步长，即每次数字递减的值。
  知道了这一点，我们可以用下面的代码来实现1~100之间的偶数求和。

8. Python函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

8.1 定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

8.1.1 函数语法

定义函数使用 def 关键字，一般格式如下：

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]
1
2
3
4

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

8.1.2 实例1

以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

def printme(str):
   #"打印传入的字符串到标准显示设备上"
   print(str)
   return
1
2
3
4

8.2 函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")
1
2
3

8.3 参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]
a="Runoob"
1
2

以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

8.3.1 可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响。

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

8.3.2 python 传不可变对象实例

def ChangeInt(a):
    a = 10
b = 2
ChangeInt(b)
print(b) # 结果是 2
1
2
3
4
5

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

8.3.3 传可变对象实例

# 可写函数说明
def changeme( mylist ):
   # "修改传入的列表"
   mylist.append([1,2,3,4])
   print("函数内取值: ", mylist)
   return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print("函数外取值: ", mylist)
1
2
3
4
5
6
7
8
9
10

实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：

8.4 参数

以下是调用函数时可使用的正式参数类型：

• 必备参数
• 关键字参数
• 默认参数
• 不定长参数

8.4.1 必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

#可写函数说明
def printme(str1):
   "打印任何传入的字符串"
   print(str1)
   return
#调用printme函数
printme()
1
2
3
4
5
6
7

8.4.2 关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

#可写函数说明
def printme(str1):
   "打印任何传入的字符串"
   print(str1)
   return
#调用printme函数
str1 = "My string"
printme(str1)
1
2
3
4
5
6
7
8

下例能将关键字参数顺序不重要展示得更清楚：

#可写函数说明
def printinfo(name, age):
   "打印任何传入的字符串"
   print("Name:", name)
   print("Age:", age)
   return
#调用printinfo函数
printinfo(age=50, name="miki" )
1
2
3
4
5
6
7
8

8.4.3 默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

#可写函数说明
def printinfo(name, age=35):
   # "打印任何传入的字符串"
   print("Name:", name)
   print("Age:", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )
1
2
3
4
5
6
7
8
9
10

8.5 return语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和
   total = arg1 + arg2
   print("函数内:", total)
   return(total)
 
# 调用sum函数
total = sum( 10, 20 )
1
2
3
4
5
6
7
8
9

8.6. 全局变量和局部变量

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量
• 局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2 # total在这里是局部变量.
   print("函数内是局部变量 : ", total)
   return total
#调用sum函数
sum( 10, 20 )
print("函数外是全局变量:", total)
1
2
3
4
5
6
7
8
9
10

9. 练习

练习1：华氏温度转换为摄氏温度。

提示：华氏温度到摄氏温度的转换公式为：$C=(F-32)÷1.8$。

F = int(input("请输入一个华氏温度："))
C = (F - 32) / 1.8
print("华氏温度:%d, 摄氏温度:%d" % (F, C))
1
2
3

练习2：输入圆的半径计算计算周长和面积。

import math
R = float(input("请输入一个圆的半径："))
L = 2 * math.pi * R
S = math.pi * R**2
print("圆的半径:%.1f, 周长:%.2f, 面积:%.2f" % (R,L,S))
1
2
3
4
5

练习3：输入年份判断是不是闰年。

suggestion：比较运算符会产生布尔值，而逻辑运算符and和or会对这些布尔值进行组合，最终也是得到一个布尔值，闰年输出True，平年输出False。

year = int(input("请输入一个年份:"))
if((year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)):
    print("{}年是闰年!".format(year))
else:
    print("{}年不是闰年!".format(year))
1
2
3
4
5

练习4：英制单位英寸与公制单位厘米互换。

英制单位英寸与公制单位厘米互换:
1 厘米 = 0.39英寸；
1 英寸 = 2.54厘米；

length = float(input("请输入长度:"))
unit = input("请输入单位(英寸/厘米、in/cm)):")
if unit == 'in' or unit == '英寸':
    length_limi = length * 2.54 # 1 英寸 = 2.54厘米
    print('%.2f英寸 = %.2f厘米' % (length, length_limi))
elif unit == 'cm' or unit == '厘米':
    length_yingcun = length * 0.39
    print('%.2f厘米 = %.2f英寸' % (length, length_yingcun))
else:
    print('对不起，您输入有误，请重新输入！')
1
2
3
4
5
6
7
8
9
10

练习5：百分制成绩转换为等级制成绩。

要求：如果输入的成绩在90分以上（含90分）输出A；80分-90分（不含90分）输出B；70分-80分（不含80分）输出C；60分-70分（不含70分）输出D；60分以下输出E。

score = int(input("请输入您的成绩"))
if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'E'
print('根据您提供的成绩分数，最终评分等级为:%s' % grade)
1
2
3
4
5
6
7
8
9
10
11
12

练习6：输入三条边长，如果能构成三角形就计算周长和面积。

• 三角形边长就等于其三边之和：a + b + c；
• 已知三边，求三角形面积，根据海伦公式：

$$p=(a+b+c)/2$$

$$area=\sqrt{p\ast (p-a)\ast (p-b)\ast (p-c)}$$

a = float(input("请输入三角形第一条边长"))
b = float(input("请输入三角形第二条边长"))
c = float(input("请输入三角形第三条边长"))
if(a + b > c and a + c > b and b + c > a):
    perimeter = a + b + c
    p = (a + b + c) / 2
    area = (p*(p-a)*(p-b)*(p-c))**0.5
    print("根据您输入的三条边长，构成的三角形周长为: %.2f, 面积为: %.2f ;" % (perimeter, area))
else:
    print("您输入的三条边长不符合三角形性质，请重新输入！")
1
2
3
4
5
6
7
8
9
10