Python编程从入门到实践

---

前言

第1章 起步

在Python自带的编辑器IDLE中或者Python shell中不能使用cd命令，那么跳到目标路径呢。方法是使用os包下的相关函数实现路径切换功能。

import os
os.getcwd() #获取当前路径
os.chdir("D:\\test") #跳到目标路径下
os.chdir('D:\\test') #单引号、双引号都可以

补充知识：Python更改IDLE默认保存路径
将起始位置更改为要保存文件的默认路径即可

变量字符串

使用方法修改字符串的大小写

name='san gong'
print(name.title())
print(name.upper())
print(name.lower())

输出：
San Gong
SAN GONG
san gong

合并（拼接）字符串

first_name='san'
last_name='zhang'
full_name=last_name+' '+first_name
print(full_name)
print("hello"+full_name+"!!!")
message="hello,"+full_name.title()+"!!!"
print(message)

输出：
zhang san
hellozhang san!!!
hello,Zhang San!!!

使用制表符或换行符来添加空白

print("abc")
print("\tabc")
print("Languages:\nPython\nC\nJavaScript")

输出：
abc
abc
Languages:
Python
C
JavaScript

删除空白

方法：使用方法lstrip()和rstrip()分别删除前端空白和后端空白，使用strp()删除两端的空白；

favor='        abc         '
favor.lstrip()
favor.rstrip()
favor.strip()

输出：
‘abc ’
’ abc’
‘abc’

使用字符串时避免语法错误

message = 'One of Python's strengths is its diverse community.'
message = "One of Python's strengths is its diverse community."
print(message)

输出：
SyntaxError: unterminated string literal (detected at line 1)
One of Python’s strengths is its diverse community.

数字

整数浮点数

使用函数 str()避免类型错误

age=23
print("happy"+str(age)+"birthday!")

输出：
happy23birthday!

注释/Python之禅

批量注释代码的快捷键：CTRL /
在Python中，注释用井号（#）标识。井号后面的内容都会被Python解释器忽略；

import this
The Zen of Python, by Tim Peters

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章 列表简介

列表简介

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)

输出：
[‘trek’, ‘cannondale’, ‘redline’, ‘specialized’]

访问列表元素

print(bicycles[0])
print(bicycles[0].title())

输出：
trek
Trek

索引从 0 而不是 1 开始

1）第一个列表元素的索引为0；
2）要访问第四个列表元素，可使用索引3；
3）通过将索引指定为-1，可让Python返回最后一个列表元素；

使用列表中的各个值

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print("my first bike is a "+bicycles[-2].title()+".")

输出：
my first bike is a Redline.

修改、添加和删除元素

1）要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值；
2）在列表中添加新元素时，最简单的方式是将元素附加到列表末尾，方法append()将元素添加到了列表末尾；
3）使用方法insert()可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值，这种操作将列表中既有的每个元素都右移一个位置；

从列表中删除元素

使用del语句删除元素

1）如果知道要删除的元素在列表中的位置，可使用del语句；

使用方法pop()删除元素

1）方法pop()可删除列表末尾的元素，并让你能够接着使用它。术语弹出（pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素

弹出列表中任何位置处的元素

1）使用pop()来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可，每当你使用pop()时，被弹出的元素就不再在列表中了

根据值删除元素

1）有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove()；
2）使用remove()从列表中删除元素时，也可接着使用它的值；
3）方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

name=['a','b','c','d','e','f']
del name[0]
print(name)
name.pop()
print(name)
name.pop(0)
best=name.pop(0)
print(name)
print('i like '+best.title()+"!")
name.remove('d')
print(name)

输出：
[‘b’, ‘c’, ‘d’, ‘e’, ‘f’]
[‘b’, ‘c’, ‘d’, ‘e’]
[‘d’, ‘e’]
i like C!
[‘e’]

name=['a','b','c','d','e','f']
name[0]='zzz'
print(name)
name.append('tt')
print(name)
name.insert(0,'yyy')
print(name)

输出：
[‘zzz’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’]
[‘zzz’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘tt’]
[‘yyy’, ‘zzz’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘tt’]

组织列表

使用方法 sort()对列表进行永久性排序

1）方法sort()永久性地修改了列表元素的排列顺序。按字母顺序排列的，
再也无法恢复到原来的排列顺序；

invitation=['ye','nai','ba','ma','jie','wo']
invitation.sort()
print(invitation)
invitation.sort(reverse=True)
print(invitation)

输出：
[‘ba’, ‘jie’, ‘ma’, ‘nai’, ‘wo’, ‘ye’]
[‘ye’, ‘wo’, ‘nai’, ‘ma’, ‘jie’, ‘ba’]

使用函数 sorted()对列表进行临时排序

1）要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted()。函数sorted()让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。

invitation=['ye','nai','ba','ma','jie','wo']
print("here is the sorted\t")
print(sorted(invitation))
print("here is the original\t")
print(invitation)

输出：
here is the sorted
[‘ba’, ‘jie’, ‘ma’, ‘nai’, ‘wo’, ‘ye’]
here is the original
[‘ye’, ‘nai’, ‘ba’, ‘ma’, ‘jie’, ‘wo’]

倒着打印列表

1）要反转列表元素的排列顺序，可使用方法reverse()；
2）方法reverse()永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse()即可。

确定列表的长度

使用函数len()可快速获悉列表的长度。

invitation=['ye','nai','ba','ma','jie','wo']
invitation.reverse()
print(invitation)
print(len(invitation))

输出：
[‘wo’, ‘jie’, ‘ma’, ‘ba’, ‘nai’, ‘ye’]
6

第4章 操作列表

遍历整个列表

invitation=['ye','nai','ba','ma','jie','wo']
for i in invitation:
    print(i)

输出：
ye
nai
ba
ma
jie
wo
不错的代码编写习惯

在 for 循环中执行更多的操作

invitations=['ye','nai','ba','ma','jie','wo']
for inviter in invitations:
    print("hello,"+inviter+" i am missing you!")
    print("i can see "+inviter+" again!\n")

输出：
hello,ye i am missing you!
i can see ye again!

hello,nai i am missing you!
i can see nai again!

hello,ba i am missing you!
i can see ba again!

hello,ma i am missing you!
i can see ma again!

hello,jie i am missing you!
i can see jie again!

hello,wo i am missing you!
i can see wo again!

在 for 循环结束后执行一些操作

for循环结束后再怎么做呢？通常，你需要提供总结性输出或接着执行程序必须完成的其他任务。在for循环后面，没有缩进的代码都只执行一次，而不会重复执行。

避免缩进错误

Python根据缩进来判断代码行与前一个代码行的关系。
Python通过使用缩进让代码更易读；简单地说，它要求你使用缩进让代码整洁而结构清晰。
在较长的Python程序中，你将看到缩进程度各不相同的代码块，这让你对程序的组织结构有大致的认识。当你开始编写必须正确缩进的代码时，需要注意一些常见的缩进错误。例如，有时候，程序员会将不需要缩进的代码块缩进，而对于必须缩进的代码块却忘了缩进。通过查看这样的错误示例，有助于你以后避开它们，以及在它们出现在程序中时进行修复。
为避免意外缩进错误，请只缩进需要缩进的代码。在前面编写的程序中，只有要在for循环中对每个元素执行的代码需要缩进。
常见的缩进错误
忘记缩进
忘记缩进额外的代码行
不必要的缩进
循环后不必要的缩进
遗漏了冒号

创建数值列表

需要存储一组数字的原因有很多，例如，在游戏中，需要跟踪每个角色的位置，还可能需要跟踪玩家的几个最高得分。在数据可视化中，处理的几乎都是由数字（如温度、距离、人口数量、经度和纬度等）组成的集合。
列表非常适合用于存储数字集合，而Python提供了很多工具，可帮助你高效地处理数字列表。明白如何有效地使用这些工具后，即便列表包含数百万个元素，你编写的代码也能运行得很好。

使用函数 range()

使用range()时，如果输出不符合预期，请尝试将指定的值加1或减1。

for value in range(1,5):
    print(value)

输出：
1
2
3
4

使用 range()创建数字列表

要创建数字列表，可使用函数list()将range()的结果直接转换为列表。如果将range()作为list()的参数，输出将为一个数字列表。

numbers=list(range(1,6))#数字转换为一个列表，可使用list()
print(numbers)

num2=list(range(2,11,2))#使用函数range()时，还可指定步长。
print(num2)

sqares=[]
for value in range(1,11):
    sqare=value**2
    sqares.append(sqare)
print(sqares)

输出：
[1, 2, 3, 4, 5]
[2, 4, 6, 8, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

对数字列表执行简单的统计

digits=[1,2,3,4,5]
print(min(digits))
print(max(digits))
print(sum(digits))

输出：
1
5
15

列表解析

列表解析让你只需编写一行代码就能生成这样的列表。列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。面向初学者的书籍并非都会介绍列表解析，这里之所以介绍列表解析，是因为等你开始阅读他人编写的代码时，很可能会遇到它们。

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

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

使用列表的一部分

切片

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。

invitation=['ye','nai','ba','ma','jie','wo']
print(invitation[0:3])
print(invitation[1:4])
print(invitation[:4])
print(invitation[3:])
print(invitation[-3:])

输出：
[‘ye’, ‘nai’, ‘ba’]
[‘nai’, ‘ba’, ‘ma’]
[‘ye’, ‘nai’, ‘ba’, ‘ma’]
[‘ma’, ‘jie’, ‘wo’]
[‘ma’, ‘jie’, ‘wo’]

遍历切片

如果要遍历列表的部分元素，可在for循环中使用切片。

invitation=['ye','nai','ba','ma','jie','wo']
for inviter in invitation[:3]:
    print(inviter.title())

输出：
Ye
Nai
Ba

复制列表

invitation=['ye','nai','ba','ma','jie','wo']
your_invite=invitation[:]
print(invitation)
print(your_invite)
invitation.append('lao')
your_invite.append('self')
print(invitation)
print(your_invite)

输出：
[‘ye’, ‘nai’, ‘ba’, ‘ma’, ‘jie’, ‘wo’]
[‘ye’, ‘nai’, ‘ba’, ‘ma’, ‘jie’, ‘wo’]
[‘ye’, ‘nai’, ‘ba’, ‘ma’, ‘jie’, ‘wo’, ‘lao’]
[‘ye’, ‘nai’, ‘ba’, ‘ma’, ‘jie’, ‘wo’, ‘self’]

元组

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

定义元组

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

遍历元组中的所有值

像列表一样，也可以使用for循环来遍历元组中的所有值；

dimensions=(200,50)
print(dimensions[0])
print(dimensions[1])
for dimension in dimensions:
    print(dimension)

输出：
200
50
200
50

修改元祖变量

虽然不能修改元组的元素，但可以给存储元组的变量赋值。
相比于列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。

dimensions=(200,50)
print("original")
for dimen in dimensions:
    print(dimen)
dimensions=(400,80)
for dimen2 in dimensions:
    print(dimen2)

输出：
200
50
400
80

设置代码格式

具体的参考文档为https://python.org/dev/peps/pep-0008/

格式设置指南

如果一定要在让代码易于编写和易于阅读之间做出选择，Python程序员几乎总是会选择后者。

缩进

PEP 8建议每级缩进都使用四个空格，这既可提高可读性，又留下了足够的多级缩进空间。

行长

很多Python程序员都建议每行不超过80字符。专业程序员通常会在同一个屏幕上打开多个文件，使用标准行长可以让他们在屏幕上并排打开两三个文件时能同时看到各个文件的完整行。PEP 8还建议注释的行长都不超过72字符，因为有些工具为大型项目自动生成文档时，会在每行注释开头添加
格式化字符。

空行

要将程序的不同部分分开，可使用空行。

if语句

一个简单示例

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

输出：
Audi
BMW
Subaru
Toyota

条件测试

每条if语句的核心都是一个值为True或False的表达式，这种表达式被称为条件测试。Python根据条件测试的值为True还是False来决定是否执行if语句中的代码。如果条件测试的值为True，Python就执行紧跟在if语句后面的代码；如果为False，Python就忽略这些代码。

检查是否相等

==双等号是等于的意思；

检查是否相等时要考虑大小写

car ='Audi'
print(car =='audi')

输出：
False

检查是否不相等

!=不相等

比较数字

= ＜ ＞ ≤ ≥

检查多个条件

你可能想同时检查多个条件，例如，有时候你需要在两个条件都为True时才执行相应的操作，而有时候你只要求一个条件为True时就执行相应的操作。在这些情况下，关键字and和or可助你一臂之力。
为改善可读性，可将每个测试都分别放在一对括号内，但并非必须这样做。

age1=13
age2=15
print((age1>10)and(age2>10))

输出：
true

检查特定值是否包含在列表中

有时候，执行操作前必须检查列表是否包含特定的值。例如，结束用户的注册过程前，可能需要检查他提供的用户名是否已包含在用户名列表中。在地图程序中，可能需要检查用户提交的位置是否包含在已知位置列表中。要判断特定的值是否已包含在列表中，可使用关键字in。

cars = ['audi', 'bmw', 'subaru', 'toyota']
print('BYD' in cars)

输出：
False

检查特定值是否不包含在列表中

还有些时候，确定特定的值未包含在列表中很重要；在这种情况下，可使用关键字not in。

banned_users = ['andrew', 'carolina', 'david']
user='andrew'
if user not in banned_users:
    print(user+", you can buy tickets")
else:
    print(user+", you are banned")

输出：
andrew, you are banned

布尔表达式

随着你对编程的了解越来越深入，将遇到术语布尔表达式，它不过是条件测试的别名。与条件表达式一样，布尔表达式的结果要么为True，要么为False。布尔值通常用于记录条件，如游戏是否正在运行，或用户是否可以编辑网站的特定内容；

a_alph='San'
b_alph='san'
print(a_alph==b_alph)
print(a_alph.lower()==b_alph)
a_digit=13
b_digit=15
print(a_digit<b_digit)
print(a_digit<10 and b_digit<20)
cars = ['audi', 'bmw', 'subaru', 'toyota']
print('BYD'not in cars)
print('Bmw' in cars)
print('bmw' in cars)

输出：
False
True
True
False
True
False
True

if语句

简单的if语句

if-else语句

if-elif-else 结构

经常需要检查超过两个的情形，为此可使用Python提供的if-elif-else结构。Python只执行if-elif-else结构中的一个代码块，它依次检查每个条件测试，直到遇到通过了的条件测试。测试通过后，Python将执行紧跟在它后面的代码，并跳过余下的测试。

age=12
if age<4:
    print('you are '+str(age)+' year-old,for free')
elif age<18:
    print('you are '+str(age)+' year-old,half price')
else:
    print('you are '+str(age)+' year,full price')

输出：
you are 12 year-old,half price

使用多个elif代码块

可根据需要使用任意数量的elif代码块，例如，假设前述游乐场要给老年人打折，可再添加一个条件测试，判断顾客是否符合打折条件。

省略else代码块

Python并不要求if-elif结构后面必须有else代码块。

测试多个条件

if-elif-else结构功能强大，但仅适合用于只有一个条件满足的情况：遇到通过了的测试后，Python就跳过余下的测试。这种行为很好，效率很高，让你能够测试一个特定的条件。
然而，有时候必须检查你关心的所有条件。在这种情况下，应使用一系列不包含elif和else代码块的简单if语句。在可能有多个条件为True，且你需要在每个条件为True时都采取相应措施时，适合使用这种方法。

requested_toppings = ['mushrooms', 'extra cheese']
if 'mushrooms' in requested_toppings:
    print("Adding mushrooms.")
if 'pepperoni' in requested_toppings:
    print("Adding pepperoni.")
if 'extra cheese' in requested_toppings:
    print("Adding extra cheese.")

print("\nFinished making your pizza!")

输出：
Adding mushrooms.
Adding extra cheese.

Finished making your pizza!

使用 if 语句处理列表

通过结合使用if语句和列表，可完成一些有趣的任务：对列表中特定的值做特殊处理；高效地管理不断变化的情形，如餐馆是否还有特定的食材；证明代码在各种情形下都将按预期那样运行。

检查特殊元素

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']
for requested_topping in requested_toppings:
    if requested_topping=='mushrooms':
        print('mushrooms are very good,add most')
    else:
        print("add "+requested_topping+"!")

print("\nvery good pizza")

输出：
mushrooms are very good,add most
add green peppers!
add extra cheese!

very good pizza

确定列表不是空的

requested_toppings = []
if requested_toppings:
    print('')
else:
    print('are you sure you want plain pizza?')

输出：
are you sure you want plain pizza?

使用多个列表

available_toppings = ['mushrooms', 'olives', 'green peppers','pepperoni', 'pineapple', 'extra cheese']
requested_toppings = ['mushrooms', 'green peppers', 'extra cheese','lajiaoyou']
for abc in requested_toppings:
    if abc in available_toppings:
        print("add "+str(abc))
    else:
        print('we do not have '+str(abc))

输出：
add mushrooms
add green peppers
add extra cheese
we do not have lajiaoyou

current_users=['ba','ma','ye','nai','SAN','jie','Self','admin']
new_users=['San','yanHhui','sitong','Admin','WO']
current_lower=[]
for current_user in current_users:
    current_lower.append(current_user.lower())
#print(current_lower)
for new_user in new_users:
    if new_user.lower() in current_lower:
        print('the name'+new_user+' has been registed')
    else:
        print('hello '+new_user+'!')

输出：
the nameSan has been registed
hello yanHhui!
hello sitong!
the nameAdmin has been registed
hello WO!

nums=['1','2','3','4','5','6','7','8','9']
for num in nums:
    if num=='1':
        print(num+'st')
    elif num=='2':
        print(num+'nd')
    elif num=='3':
        print(num+'rd')
    else:
        print(num+'st')

输出：
1st
2nd
3rd
4st
5st
6st
7st
8st
9st

第6章 字典

alien_0={'colr':'green','points':5}
print(alien_0['colr'])
print(alien_0['points'])

输出：
green
5

使用字典

在Python中，字典是一系列键—值对。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。键—值对是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。在字典中，你想存储多少个键—值对都可以。

访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键；
字典中可包含任意数量的键值对。

添加键值对

字典是一种动态结构，可随时在其中添加键—值对。要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值。

alien_0={'colr':'green','points':5}
print(alien_0['colr'])
print(alien_0['points'])
alien_0['x_position']=-30
alien_0['y_position']=-20
print(alien_0)

输出：
green
5
{‘colr’: ‘green’, ‘points’: 5, ‘x_position’: -30, ‘y_position’: -20}

创建空字典

使用字典来存储用户提供的数据或在编写能自动生成大量键—值对的代码时，通常都需要先定义一个空字典。

alien_0 = {} 

修改字典中的值

alien_0={'colr':'green','points':5}
alien_0['colr']='yellow'
print(alien_0)

输出：
{‘colr’: ‘yellow’, ‘points’: 5}

删除键值对

对于字典中不再需要的信息，可使用del语句将相应的键—值对彻底删除。使用del语句时，必须指定字典名和要删除的键。

alien_0={'colr':'green','points':5}
del alien_0['colr']
print(alien_0)

输出：
{‘points’: 5}

由类似对象组成的字典

确定需要使用多行来定义字典时，在输入左花括号后按回车键，再在下一行缩进四个空格，指定第一个键—值对，并在它后面加上一个逗号。此后你再次按回车键时，文本编辑器将自动缩进后续键—值对，且缩进量与第一个键—值对相同。定义好字典后，在最后一个键—值对的下一行添加一个右花括号，并缩进四个空格，使其与字典中的键对齐。另外一种不错的做法是在最后一个键—值对后面也加上逗号，为以后在下一行添加键—值对做好准备。

fav_language={
    'san':'english',
    'ba':'math','ma':'chinese',
    'jie':'history' 
}
print(fav_language)

输出：
{‘san’: ‘english’, ‘ba’: ‘math’, ‘ma’: ‘chinese’, ‘jie’: ‘history’}