Python编程：从入门到实践

Python编程

第一章 起步

1.1 搭建编程环境

Hello World程序。

>>> print("Hello world!")
Hello world!

第二章 变量和简单数据类型

2.1 变量

>>> message = “Hello”
>print(message)
Hello

2.1.1 变量的命名和使用

• 变量名只能包含字母、数字和下划线（不能有空格），且数字不能打头。
• 不要将函数名作为变量名
• 慎用小写l和大写O，易被委任为1和0。习惯用小写字母命名变量

2.2 字符串

2.2.1 表示方法：单、双引号
2.2.2 修改字符串大小写 → .title() 改为大写 → .upper() 改为小写 → .lower()
2.2.3 合并（拼接）字符串 → +

>>> lastname = "Guo"
>firstname = "Dongling"
>fullname = lastname + " " + firstname
>print("Hello，" + fullname.title() + " ！")
Hello，Guo Dongling ！

2.2.4 使用制表符或换行符来添加空白 → \n \t
2.2.5 删除末尾空白 → .rstrip() 删除开头空白 → .lstrip() 同时删除开头和结尾空白 → strip()

2.3 数字

2.3.1 整数

>>> 2 + 3*4
14
>>> (2 + 3) * 4
20

2.3.2 浮点数
2.3.3 使用函数str()避免类型错误（将数字转换为字符串）

2.4 Python之禅

>>>import this
>Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

第三章 列表简介

3.1 列表是什么

列表是由一系列按特定顺序排列的元素组成的，用[ ]来表示列表，并用逗号来分割其中的元素。
3.1.1 访问列表元素，索引是从0开始

>>> bicycle = ['trek','cannodale','redline']
>print(bicycle)
['trek', 'cannodale', 'redline']
>print(bicycle[0])
trek
>print(bicycle[-1])
redline

3.2 修改、添加和删除元素

3.2.1 修改列表元素
3.2.2 使用方法append列表末尾添加元素； 使用方法list列表中添加元素
3.3.3 从列表中删除元素：①使用del语句删除元素（已知元素的索引） ②使用方法pop删除列表中任何位置的元素（已知元素的索引,删除后可继续使用它的值）③使用方法remove删除元素（已知元素的值，删除后可继续使用它的值）
使用del和pop()的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就是要del语句；如果你要在删除元素后继续使用它，就是用pop()
使用remove()只删除第一个指定的值。如果要删除所有的，要是用循环来判断

>>> bicycle = ['trek','cannodale','redline']
>del bicycle[0]
>print(bicycle)
['cannodale','redline']
>>>bicycle = ['trek','cannodale','redline']
>first_owned = bicycle.pop(0)
>print(bicycle)
>print(first_owned)
['cannodale','redline']
trek
>>>bicycle = ['trek','cannodale','redline']
>bicycle.remove('cannodate')
>print(bicycle)
 ['trek','redline']

3.3 组织列表

3.3.1 使用方法sort对列表进行永久性排序（按照字母顺序排列）
3.3.2 使用函数sorted对列表进行临时排序（按照字母顺序排列）
调用sorted()，列表元素的排列顺序没有改变
3.3.3 使用方法reverse永久性倒序打印列表
3.3.4 使用函数len确定列表的长度
方法与函数的区别 方法：list.sort() 函数：sorted(list)

第四章 操作列表

4.1 遍历整个列表

>>>magicians = ['alice','david','carlina']
>sort_magicians = sorted(magicians)
>for magician in sort_magicians:
    print(magician.title() + ",that was a great trick!")
    print("I can't wait to see your next trick," + magician.title() + "\n")
print("Thank you, everyone. That was a great magic show!")

Alice,that was a great trick!
I can't wait to see your next trick,Alice

Carlina,that was a great trick!
I can't wait to see your next trick,Carlina

David,that was a great trick!
I can't wait to see your next trick,David

Thank you, everyone. That was a great magic show!

使用for循环式要避免缩进错误！

4.2 创建数字列表

4.2.1 使用函数range（差一行为）

>>>squares = []
for value in range(1,11):
    square = value**2
    squares.append(square)
print(squares)
 
 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>>squares = []
for value in range(1,11):
    squares.append(value**2)
print(squares)
 
 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

创建更复杂的列表时，可使用上述两种方法中的任何一种。有时候，使用临时变量会让代码更易读；而在其他情况下，这样做只会让代码无谓地变长。你首先应该考虑的是编写清晰易懂且能完成所需功能的代码。等到审核代码时，再考虑采用更高效的方法

4.2.2 对列表执行简单的统计计算
函数min、max、sum

4.2.3 列表解析
将for循环和创建新元素的代码合并成一行，并主动附加新元素。

>>>squares = [value**2 for value in range(1,11)]
print(squares)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

4.3 使用列表的一部分——切片

同样存在差一行为

>>>my_foods = ['noodles','pizza','cake']
friend_foods = my_foods[:]
print(my_foods)

['noodles', 'pizza', 'cake']

4.4 元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
元组用()来表示

dimensions = (200,50)
for dimension in dimensions:
    print(dimension)

200
50

元组中的元素虽然不能改变，但是可以直接修改元组变量。

4.5 设置代码格式

4.5.1 缩进 每级缩进使用4个空格，避免混用制表符和空格
4.5.2 行长 每行不超过80个字符，注释的行长不超过72个字符
4.5.3 空行 可以使用空行来将程序的不同部分分开，但不能滥用

第五章 if语句

5.1 条件测试

>>>cars = ["audi","bmw","subaru","toyota"]
for car in cars:
    if car == "bmw":
        print(car.upper())
    else:
        print(car.title())

Audi
BMW
Subaru
Toyota

5.1.1检查是否相等 使用两个等号"=="来进行判断
一个等个表示陈述，可解读为“将变量进行赋值”；两个等号表示发问，可解读为“变量的值是？？吗”
如果在判断时想要忽略大小写，可以使用方法lower()
5.1.2 检查是否不相等 使用“!=”来进行判断
5.1.3 比较数字
建议==、>=、<=等比较运算符两边各添加一个空格，可以让代码阅读起来更容易
5.1.4 使用and、or检查多个条件
5.1.5 使用in检查特定值是否包含在列表中

5.2 if语句

if-elif-else语句 如果判断条件较多，可以使用多个elif代码块，else代码块可以省略

5.3 使用if语句处理列表

#确定列表不是空的
>>>request_toppings = []
>if request_toppings:
	for request_topping in request_toppings:
		print("addling" + request_topping)
	print("\nfinish making your pizza!")
 else:
   	print("Are you sure you want a plain pizza?")

第六章 字典

在Python中，字典是一系列键-值对。每个键都与一个值相关联，你可以使用键对来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典，事实上，可将任何Python对象用作字典中的值。用花括号{ }来表示，相对应的键-值对之间用逗号分隔。

6.1 修改、删除字典中的值

#修改字典中的值
>>>alien = {
     
    'x_position':0,
    'y_position':25,
    'speed':'medium',
    }
>print("Alien's original position is (" + str(alien['x_position']) + "," + str(alien['y_position']) + ")")
>if alien['speed'] == 'slow':
    x_increament = 1
elif alien['speed'] == 'medium':
    x_increament = 2
else:
    x_increament = 3
>alien['x_position'] = alien['x_position'] + x_increament
>print("Alien now is on (" + str(alien['x_position']) + "," + str(alien['y_position']) + ")")

Alien's original position is (0,25)
Alien now is on (2,25)

#删除字典中的值
del alien['speed']

6.2 遍历字典

使用方法items、keys、values遍历键对值或键
可以使用方法set()来去除列表中的重复元素

favorite_lauguage = {
     
    'jen':'python',
    'sarch':'c',
    'edward':'ruby',
    'phil':'python'
}
#遍历所有键对值
friends = ['phil','sarch']
for name,language in favorite_lauguage.items():
    print(name.title() + "'s favorite language is ”+  favorite_lauguage.title())
print('\n')
#遍历所有键
for name in sorted(favorite_lauguage.keys()):
    print(name.title() + ",thank you for talking the poll.")
print('\n')
#遍历所有值
for language in sorted(set(favorite_lauguage.values())):
    print(language.title())


Jen's favorite language is Python
Sarch's favorite language is C
Edward's favorite language is Ruby
Phil's favorite language is Python


Edward,thank you for talking the poll.
Jen,thank you for talking the poll.
Phil,thank you for talking the poll.
Sarch,thank you for talking the poll.


C
Python
Ruby

6.3 嵌套

将一系列字典存储在列表中，或将列表作为存储在字典中，这称为嵌套。
6.3.1 字典列表

#创建一个用于存储外星人的空列表
aliens = []

#创建30个绿色的外星人
for alien_number in range(30):
    new_alien = {
     'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)

#显示前五个外星人
for alien in aliens[:5]:
    print(alien)
print("...")
print("Total number of aliens:" + str(len(aliens)))

{
     'color': 'green', 'points': 5, 'speed': 'slow'}
{
     'color': 'green', 'points': 5, 'speed': 'slow'}
{
     'color': 'green', 'points': 5, 'speed': 'slow'}
{
     'color': 'green', 'points': 5, 'speed': 'slow'}
{
     'color': 'green', 'points': 5, 'speed': 'slow'}
...
Total number of aliens:30

6.3.2 在字典中存储列表
每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。

favorite_lauguage = {
     
    'jen':['python','ruby'],
    'sarah':['c'],
    'edward':['ruby','go']
}

for name,languages in favorite_lauguage.items():
    if len(languages) == 1:
        print("\n" + name.title() + "'s favorite language is:")
        for language in languages:
            print("\t" + language.title())
    else:
        print("\n" + name.title() + "'s favorite languages are:")
        for language in languages:
            print("\t" + language.title())

Jen's favorite languages are:
	Python
	Ruby

Sarah's favorite language is:
	C

Edward's favorite languages are:
	Ruby
	Go

6.3.3 在字典中存储字典
可以在字典中嵌套字典，但这样做，代码可能会变得很复杂。

第七章 用户输入和while循环

7.1 函数input()的工作原理

函数input接受一个参数，即要向用户显示的提示或说明，让用户知道该如何做。

prompt = "If you tell us who you are, we can personalize the messages you see."t =
prompt += "\n What is your first name?"
name = input(prompt)
print("\nHello," + name.title() + "!")

Hello,Guo!

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

使用int可以将字符串转换成数值
求模运算符%，它将两个数相除返回余数。

7.3 while循环简介

for循环用于针对集合中的每个元素，而while循环不断地运行，知道指定的条件不满足为止。

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

1
2
3
4
5

7.3.1 使用标志
在要求很多条件都满足才继续运行的程序中，可以定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志，充当了程序的信号灯。你可让程序在标志位True时继续运行，并在任何时间导致标志的值为False时让程序停止运行。这样，在while语句就只需要检查一个条件——标志的当前值为True，并将所有测试（是否发生了将标志设置为False的事件）都放在其他地方，从而让程序变得更为整洁。

prompt = "Tell me something, and I will repeat it back to you:"
prompt += "\n Enter 'quit' to end the program"

active = True
while active:
    message = input(prompt)

    if message == 'quit':
        active = False
    else:
        print(message)

7.3.2 使用break退出循环
要立即退出while循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用break语句。

prompt = "Tell me something, and I will repeat it back to you:"
prompt += "\n Enter 'quit' to end the program"

while True:
    message = input(prompt)

    if message == 'quit':
        break
    else:
        print(message)

在任何Python循环中都可以使用break语句。例如，可使用break语句来退出遍历列表或字典的for循环

7.3.3 在循环中使用continue
要返回到循环开头，并根据条件测试结果决定是都继续执行循环，可使用continue语句，它不像break那样不再继续执行余下的代码并退出整个循环。

current_number = 0
while current_number < 10:
    current_number += 1
    if current_number %2 == 0:
        continue
    print(current_number)

1
3
5
7
9

要避免写无限循环，务必对每个while循环进行测试，确保它按预期那样结束。

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

for循环是一种遍历列表的有效方式，但在for循环中不应修改列表，否则将导致Python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用while循环。通过while循环同列表、字典结合起来使用，可收集、存储并组织大量输入，供以后查看和显示

7.4.1 在列表之间移动元素

unconfirmed_users = ['alice','brain','candace']
confirmes_users = []
while unconfirmed_users:
    current_user = unconfirmed_users.pop()
    print("Verifying user: " + current_user.title())
    confirmes_users.append(current_user)
print("\nThe following users have been confirmed:")
for confirmes_user in confirmes_users:
    print(confirmes_user.title())

Verifying user: Candace
Verifying user: Brain
Verifying user: Alice

The following users have been confirmed:
Candace
Brain
Alice

7.4.2 删除包含特定值的所有元素

pets = ['dog','cat','pig','cat','rabbit','cat']
print(pets)
pets.remove('cat')
print(pets)
while 'cat' in pets:
    pets.remove('cat')
print(pets)

['dog', 'cat', 'pig', 'cat', 'rabbit', 'cat']
['dog', 'pig', 'cat', 'rabbit', 'cat']
['dog', 'pig', 'rabbit']

7.4.3 使用用户输入来填充字典

responses = {
     }
polling_activate = True

while polling_activate:
    name = input("\nWhat is your name?")
    response = input("Which montain would you like to climb someday?")
    responses[name] = response
    repeat = input("Would you like to let another person respond? (yes / no)")
    if repeat == 'no':
        polling_activate = False

for name,response in responses.items():
    print(name.title() + " would like to climb " + response + ".")

第八章 函数

函数是带名字的代码块，用于完成具体的工作。通过使用函数，程序的编写、阅读、测试和修复都将更容易。
需要在程序中多次执行同一项任务时，你无需反复编写完成该任务的代码，而只需要调用执行该任务的函数即可。

8.1 定义函数

def greet_user(username):
    """显示简单的问候"""
    print("Hello, " + username.title() + "!")

greet_user('duan pengjie')

Hello, Duan Pengjie!

username是形参，‘duan pengjie’是实参

8.2 传递实参

8.2.1 位置实参

def describe_pet(animal_type,pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ", whose name is " + pet_name + "." )

describe_pet("dog","xiaoduan")

I have a dog, whose name is xiaoduan.

8.2.2 关键字参数

describe_pet(animal_type='cat',pet_name='duanduan')

I have a cat, whose name is duanduan.

8.2.3 默认值
编写函数时，可以给每个形参指定默认值。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。

def describe_pet(pet_name,animal_type='dog'):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ", whose name is " + pet_name + "." )

describe_pet("xiaoduan")

I have a dog, whose name is xiaoduan.

在使用默认值时，在形参列表中必须先列出没有默认值的形参，在列出有默认值的形参，这让python能够正确的解读位置实参。

8.3 返回值

在函数中，可使用return语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁种的工作转移到函数中去完成，从而简化主程序。
8.3.1 返回简单值

def get_formatted_name(first_name,last_name):
    """返回整洁的姓名"""
    full_name = first_name + ' ' + last_name
    return full_name.title()

scientiest = get_formatted_name('guo','dongling')
print("Next scientiest is " + scientiest + ".")

Next scientiest is Guo Dongling.

调用返回值的函数时，需要提供一个变量，用于存储返回的值。

8.3.2 让实参变成可选的
可以给形参指定一个默认值——空字符串，使其成为可选的参数，并将其移动到形参列表的末尾。

8.3.3 返回字典

def build_person(first_name,last_name,age=''):
    """返回一个字典"""
    person={
     'first name':first_name,'last name':last_name}
    if age:
        person["age"] = age
    return person

musician = build_person("Guo","Dongling",24)
print(musician)

{
     'first name': 'Guo', 'last name': 'Dongling', 'age': 24}

8.3.4 结合使用函数和while循环

def make_album(singer,album_name,song_number=""):
    album = {
     "singer":singer,"album":album_name}
    if song_number:
        album["song_number"] = song_number
    print("\nPlease enter your favorit singer and whose album !")
    print("enter 'q' at any time to quit.")
    return album

while True:
    name = input("Your favorit singer is :")
    if name == 'q':
        break
    name_album = input("What is his best album")
    if name_album == 'q':
        break

    message = make_album(name,name_album)
    print(message)

Please enter your favorit singer and whose album !
enter 'q' at any time to quit.
{
     'singer': 'Jay Zhou', 'album': 'daoxiang'}

8.4 传递列表

8.4.1 在函数中修改列表
将列表传递给函数后，可对其进行永久性的修改。

def print_models(unprinted_designs,completed_models):
    """
    模拟打印每个设计，直到没有未打印的设计为止
    打印每个设计后，都将其移动到列表completed_models中
    """
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print("Printing model: " + current_design)
        completed_models.append(current_design)

def show_complted_models(completed_models):
    """显示打印好的所有模型"""
    print("\nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

unprinted_designs = ['a','b','c']
completed_models = []

print_models(unprinted_designs,completed_models)
show_complted_models(completed_models)

Printing model: c
Printing model: b
Printing model: a

The following models have been printed:
c
b
a

每个函数都只应该负责一项工作，将更有助于将复杂的任务化划分成一系列的步骤。

8.4.2 禁止函数修改列表
当不想对原始列表进行修改时，可以采用切片表示法来 创建副本。

print_models(unprinted_designs[:],completed_models)

8.5 传递任意数量的实参

8.5.1 结合使用位置实参和任意数量实参
当预先不知道函数需要接受多少个参数时，可以创建一个空元组，用*来表示。要让函数同时接受不同类型的实参时，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

def make_pizza(size,*toppings):
    """"概述要制作的披萨"""
    print("\nMaking a" + str(size) + "-inch pizza with the following toppings :")
    for topping in toppings:
        print("-" + topping)

make_pizza(16,'pepperoni','mushrooms')

Making a16-inch pizza with the following toppings :
-pepperoni
-mushrooms

8.5.2 使用任意数量的关键字实参
当预先不知道传递给函数的具体信息时，可以创建一个空字典，用**来表示，可将函数编写成能够接收任意数量的键-对值。

def build_profile(first,last,**user_info):
    """创建一个字典，包含我们知道的有关用户的所有信息"""
    profile = {
     }
    profile['first name'] = first
    profile['last name'] = last
    for k,v in user_info.items():
        profile[k] = v
    return profile

user_infor = build_profile("dongling","guo",age = "24", gender = "famile")
print(user_infor)

{
     'first name': 'dongling', 'last name': 'guo', 'age': '24', 'gender': 'famile'}

8.6 将函数存储在模块中

函数可以使代码块与主程序分离，还可以将存储在被称为模块的独立文件中，再将模块导入import到主程序中。

8.6.1 导入整个模块
编写一条import语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。

import module_name
module_name.function_name()

8.6.2 导入特定的函数

from module_name import function_0， function_1
function_0()

使用这种语法，在调用函数时就不需要使用句点，只需指定其名称。

8.6.3 使用as给函数或模块指定别名
如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名，函数的另一个名称，类似于外号。

from module_name import function_0 as f0
f0()

import module_name as mn

8.6.4 导入模块中所有的函数

from module_name import *
function_0()

但是，使用并非自己编写的大型模块时，最好不要采用这种导入方法，可能会与主程序中的名称产生冲突。最佳的方法是只导入所需要的函数，或者导入整个模块采用句点式的方法进行表示

8.7 函数编写指南

• 编写函数时，应指定描述性的名称，只在其中使用小写字母和下划线
• 每个函数应该包含对其简要的功能注释
• 给形参指定默认值时，等号两边不要有空格
• 如果形参很多时，可在函数定义中输入左括号后按