Python学习（四）：用户输入，函数_input函数需要导入模块吗

Python学习（四）

用户输入

在有时候，我们需要让用户手动输入一些数据，比如用户的姓名，年龄等，之后再对用户输入的数据进行处理。为此Python提供了一些函数。

使用input()函数进行输入输出

函数input()会让程序暂停运行，等待用户输入一些文本，在input()函数中，我们也可以输入一些文本，来提示用户需要什么类型的数据，我们也可以将这些文本保存在变量中，再将变量传递给input()函数：

name = input("please input your name: ")
print("your name is : " + name)

'''
please input your name: yuejinzhao
your name is : yuejinzhao
'''
1
2
3
4
5
6
7

使用int()函数来获取数值输入

在使用input()函数时，Python会将所有用户输入的数据解读为字符串，但是我们知道字符串不能够进行数值运算，这时候我们需要用int()函数将字符串转换为数值。

age = input("please input your age: ")
print(type(age))				#<class 'str'>
age = int(age)
print(type(age))				#<class 'int'>
1
2
3
4

while循环

for循环主要用于针对集合中的每一个元素，知道遍历完集合中所有的元素才会结束。而while循环将会不断地运行，直到满足指定的条件。

一个简单的while循环

下边是一个统计从1到5的程序

number = 1
while number <= 5:
    print(number)
    number += 1

#1,2,3,4,5
1
2
3
4
5
6

从上边看出，Python的while循环与其它语言的while循环非常类似，在上述代码第二行设置了循环条件，当number的值小于等于5的时候进行循环，第四行设置了步进值来确保不会无限循环下去，同时while循环依然是根据缩进值来判断代码是否是循环体中的代码。

让用户选择何时退出循环

while循环也可以让用户在他们愿意的情况下不断运行，我们可以在其中设置一个退出值，只要用户输入的不是这个值，程序就一直运行：

idea = "告诉我你想说的消息，并且可以通过输入退出两个字符来停止输入: "
message = ""
while message!="退出":
    message =input(idea)
    if message != "退出":
        print(message)

'''
告诉我你想说的消息，并且可以通过输入退出两个字符来停止输入: 这是一个while循环示例
这是一个while循环示例
告诉我你想说的消息，并且可以通过输入退出两个字符来停止输入: 要好好学习Python
要好好学习Python
告诉我你想说的消息，并且可以通过输入退出两个字符来停止输入: 退出
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这里我们定义了一个消息，告诉用户要么输入一个message，要么输入退出来退出循环。之后创建一个message来存储消息，并将起始值设置为空字符，之后在循环时让message与设定的退出循环的值进行比较，如果不相等，就继续执行循环，如果相等就退出循环。

使用break和continue

break

要立刻退出循环，并且不再执行剩下的代码，我们可以使用break关键字：

idea = "告诉我你想说的消息，并且可以通过输入退出两个字符来停止输入: "
message = ""
while message!="退出":
    message =input(idea)
    if message == "退出":
        break
     else:
        print(message)
1
2
3
4
5
6
7
8

上述代码与让用户选择合适退出循环所展示的代码功能是相同的，不过这里使用了if-else语句来判断何时退出程序。

continue

当在循环过程中发现continue关键字时，系统会自动跳过本次循环，及逆行循环判断，如下代码，打印的是1-10之间所有的奇数：

number = 0
while number <= 9:
    number += 1
    if number % 2 == 0:
        continue
    else:
        print(number)

'''
1
3
5
7
9
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

无限循环

每个while语句都必须有中止的方式，否则就会没完没了的一直执行下去：

number = 1
while number <= 5:
    print(number)
1
2
3

如上述代码，我们没有设置步进值，因此number的值始终为1，循环条件一直成立，这样系统就会无限制的输出1。

使用while循环来处理列表和字典

遍历列表时使用for循环时很有效的方式，但是一般情况下我们不会在for循环中修改列表，因为在修改过程中原列表的长度可能会发生变化，导致for循环的遍历不到位，在设计对列表字典的修改时通常使用while循环。

函数

函数能够使程序分成多个很小的部分，其中每个部分负责完成一项具体的任务，我们可以根据需要使用同一个函数任意次，还可以将函数存储在独立的文件中。

定义函数

下边给出了一个简单的函数的示例：

def welcome():
    """简单的欢迎函数"""
    print("Hello")
welcome()
help(welcome)

'''
Hello
Help on function welcome in module __main__:

welcome()
    简单的欢迎函数

'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Python使用关键字def定义函数，在def后边使用空格与函数的名字分隔开，之后使用冒号指出函数体部分。与循环相同的，函数也使用缩进值表明函数体的位置和数量，因此需要注意缩进值的使用。

三个引号扩起来的被称为Python的文档注释，我们通常使用这个文档注释来表明函数的具体功能，我们可以用help函数查看文档注释的内容。

要使用函数可以调用它，要调用函数可以依次指定函数名以及用括号括起的必要信息，由于这个函数不需要传入任何参数，所以直接调用即可。

向函数传递信息

有时候，我们在向用户问候时也希望能够指出当前使用的用户的具体的名字，因此可以在定义函数时添加username，让函数能够接收你给出的值。

def welcome(username):
    """简单的欢迎函数"""
    print(username + " Hello")
welcome("越今朝")				#越今朝 Hello
1
2
3
4

形参和实参

形参是我们在声明函数时，函数的小括号中定义的变量被称为形参，如上述代码的username。

实参是我们在调用函数时，往函数的小括号中传入的值，如上述代码中的"越今朝"

传递实参

函数在定义时可能包括多个形参，因此函数调用时也需要多个实参，传递实参的方式有很多，可以使用位置实参，这要求实参的顺序和形参相同；也可以使用关键字实参，其中每个实参由变量名和值组成，也可以使用列表和字典等等。

位置实参

在调用函数时，Python必须将函数调用中的每个实参都关联到函数定义的一个形参中，为此，最简单的关联方式是基于实参的顺序，这种关联方式被称为位置实参。

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)
pet("dog","white")				#I have an animal: dog   its color is: white
pet("orange","cat")				#I have an animal: orange   its color is: cat
1
2
3
4
5

我们可以根据需要调用函数任意次，但是在使用位置实参的方法调用函数时，一定要注意实参的顺序，因为这种方式是按照位置将实参和形参对应，否则就会出现和上述代码第五行一样的问题。

关键字实参

关键字实参时传递给函数名称-值对，可以直接在实参中将名称和值关联起来，因此采用这种方法传递实参时不会引起混淆，也不需要考虑实参的顺序。

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)
pet(animale = "dog", color = "white")

#I have an animal: dog   its color is: white

pet(color = "orange", animal = "cat")

#I have an animal: cat   its color is: orange

1
2
3
4
5
6
7
8
9
10
11

通过将位置实参和关键字实参进行对比，我们可以很容易的看出关键字实参的顺序是无关紧要的，因为Python知道值应该存储在哪个形参中。

默认值

编写函数时，可以给形参指定默认值，在调用函数的过程中如果给形参指定了相应的实参时，Python将使用指定的实参值，否则使用形参的默认值。给形参指定默认值后，可以在函数调用中省略相应的实参，使用默认值可以简化函数的调用，还能指出函数的经典用法。

def pet( color, animal = "dog"):
    print("I have an animal: " + animal)
    print("its color is: " + color)
pet(color = "white")

#I have an animal: dog   its color is: white

pet(color = "orange", animal = "cat")

#I have an animal: cat   its color is: orange
1
2
3
4
5
6
7
8
9
10

需要主要的是，使用默认值时，需要在形参列表中先列出没有默认值的形参，再列出有默认值的形参，如下就是一种错误写法：def pet(animal = "dog",color,):

使用默认值，可以让实参变成可选的，这样使用函数的人就可以仅仅在必要的情况下才提供额外的信息。其中可选的实参可以设置空字符为默认值，比如有的人不想登记宠物颜色：

def pet( animal, color = ""):
    print("I have an animal: " + animal)
    if color != "":
        print("its color is: " + color)
pet("dog")

#I have an animal: dog

pet(color = "orange", animal = "cat")

#I have an animal: cat   its color is: orange
1
2
3
4
5
6
7
8
9
10
11

实参错误

在使用函数时，一定要注意实参的顺序，否则可能导致代码输出逻辑有问题。同时如果忘了在函数的调用时传递参数，也可能出现如下错误：

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)
pet()

'''
    pet()
TypeError: pet() missing 2 required positional arguments: 'animal' and 'color'
'''
1
2
3
4
5
6
7
8
9

上边的traceback会提醒你函数调用缺乏必要的信息，并指出缺少的形参的名称。

返回值

函数不是仅能直接显示输出，相反，它可以处理一些数据，并返回一个或者一组值。函数被返回的值成为返回值，可以使用return语句将值返回到调用函数的代码行。

返回简单值

def pet(animal, color):
    message = animal +" "+ color
    return message
message = pet("dog","white")
print(pet)
1
2
3
4
5

在调用函数时，需要提供一个变量用于存储返回的值，这里定义了message用来接收。

返回字典

函数可以返回任何类型的值，包括列表和字典等复杂的数据结构

def pet(animal, color):
    pet_message = {"type":animal, "color":color}
    return pet

pet_messsage = pet("dog", "white")
print(pet_message)				#{'type': 'dog', 'color': 'white'}
1
2
3
4
5
6

结合函数使用while循环

如果一个用户由多种宠物，我们可以通过while循环的方式能够使其一直输入，直到将所有的宠物信息都录入进去：

def pet(animal, color):
    message = animal +" "+ color
    return message
while True:
    print("请输入宠物信息：")
    print("输入Q可以退出")
    animal = input("宠物的种类是：")
    if animal == "Q":
    	break
    color = input("宠物的颜色是：")
    if color == "Q":
    	break
    message = pet(animal, color)
    print(message)

'''
请输入宠物信息：
输入Q可以退出
宠物的种类是：dog
宠物的颜色是：white
dog white

请输入宠物信息：
输入Q可以退出
宠物的种类是：Q
'''
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

从上述代码我们可以看出，由于一开始我们不知道用户有多少宠物，所以我们令循环条件为真，这时候就可以使while语句一直循环下去，确保用户能一直输入。但是我们需要给循环设定退出条件，这里方法是当用户输入Q，就是用break语句跳出循环。

传递列表

假设有一个用户列表，我们要向其中的每位用户发出问候：

def greet(names):
    for name in names:
        print("HELLO " + name)
names = ["TOM", "Jane", "Maria"]
greet(names)
#HELLO TOM	HELLO Jane	HELLO Maria
1
2
3
4
5
6

传递任意数量的实参

有时候我们不知道需要接受多少个实参，因此我们需要在声明函数时使函数能够接受任意个参数：

def hobby(*my_hobbys):
    for my_hobby in my_hobbys:
        print(my_hobby)
hobby("basketball","football")

#basketball	football
1
2
3
4
5
6

从上边看出来，形参*my_hobby中的星号让python能够创建一个名为my_hobbys的元组，并将接收到的所有值都存入元组中。但是需要注意的是，即便传入的仅仅只有一个值，Python也会按照元组的方式保存。

结合使用位置实参和任意数量的参数

如果要让函数接收不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后，Python将先匹配位置实参和关键字实参，再将余下的实参放在最后一个形参中。

使用任意数量的关键字实参（键值对实参）

有时候需要接收任意数量的实参，但是预先会传递给函数什么信息，在这时，可以将函数编成能够接收任意数量的键值对，调用语句提供多少键值对，就接受多少。

def pet(animal, color, **message):
    pet_message = {}
    pet_message["animal"] = animal
    pet_message["color"] = color
    for key, value in message.items():
        pet_message[key] = value
    return pet_message

pet_message = pet("dog", "white", name = "KK", like = "wangwang")
print(pet_message)

#{'animal': 'dog', 'color': 'white', 'name': 'KK', 'like': 'wangwang'}
1
2
3
4
5
6
7
8
9
10
11
12

函数pet要求提供宠物的种类，颜色，以及任意数量的名称-值对，形参**message让Python创建了一个名为message的字典，并将所有的名称-值对存入字典，我们可以像访问其他字典一样访问这个字典。

将函数存储在模块中

函数的优点是将代码块与主程序分离，通过给函数指定描述性名称，可以使主程序很容易被理解。此外，我们也可以将函数存储在模块中，再将模块导入到主程序中。import语句允许在当前的程序文件中使用模块中的代码。

通过将函数存储在独立的文件中，可以隐藏代码的细节，将细节放在更高的逻辑上，同时还可以在不同的代码中通过导入模块来重用函数，以及与其他人分享模块。

导入整个模块

要让函数可以导入，首先要创建模块，模块是扩展名为.py的文件，包含要导入程序的代码，下边来创建一个Pet模块：

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)

#这个文件被命名为Pet.py

#之后我们在Pet.py所在的文件目录中创建另一个名为Test.py的文件

import Pet
Pet.pet("dog", "white")		#I have an animal: dog	its color is: white
1
2
3
4
5
6
7
8
9
10

可以看出程序能够正常运行，这种导入方法只需要编写一条import语句，并且指定需要导入的模块名即可。调用的方法就是模块名.函数名

导入特定的函数

也可以导入模块中的特定函数，导入语法如下：from module_name import function_name，通过使用逗号分隔函数名，可以导入任意数量的函数：from module_name import function_1, function_2,function_3

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)

#这个文件被命名为Pet.py

#之后我们在Pet.py所在的文件目录中创建另一个名为Test.py的文件

from Pet import pet
pet("dog", "white")		#I have an animal: dog	its color is: white
1
2
3
4
5
6
7
8
9
10

使用as给函数指定别名

如果要导入的函数名与程序现有的变量名冲突，或者函数名太长，可以使用as在导入时给其指定一个别名，格式如下：

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)

#这个文件被命名为Pet.py

#之后我们在Pet.py所在的文件目录中创建另一个名为Test.py的文件

from Pet import pet as p
p("dog", "white")		#I have an animal: dog	its color is: white
1
2
3
4
5
6
7
8
9
10

使用as给模块指定别名

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)

#这个文件被命名为Pet.py

#之后我们在Pet.py所在的文件目录中创建另一个名为Test.py的文件

import Pet as P
P.pet("dog", "white")		#I have an animal: dog	its color is: white
1
2
3
4
5
6
7
8
9
10

导入模块中的所有的函数

使用*运算符可以让Python导入模块中的所有函数：

def pet(animal, color):
    print("I have an animal: " + animal)
    print("its color is: " + color)

#这个文件被命名为Pet.py

#之后我们在Pet.py所在的文件目录中创建另一个名为Test.py的文件

from Pet import *
pet("dog", "white")
1
2
3
4
5
6
7
8
9
10

import语句中的*让Python将模块中的每个函数都复制到该文件中，因此无需使用句点表示法，可以直接使用函数名进行调用。