---

原创作者：有理想、有本领、有担当的有志青年
博客地址：https://blog.csdn.net/ngtnmd?spm=1000.2115.3001.5343

前言

本文旨在带大家开开心心地进入Python的世界。与其他教学文章不同，笔者更偏向于简单通俗地解读程序语言，即使你是从未接触编程世界的小白，也能够很容易地理解这门神奇的语言。希望大家学得开心，也感谢各位前辈指教！

配置环境

系统：Window10 （其他我不会，长大后再学）
编译器：Pycharm
Python版本：3.9

这位老哥写的很详细，可以点击这里看一下

创建 Python 文件

• 任意文件夹里创建一个文本文件，将其后缀名改为.py，拖入 Pycharm即可
• 也可以在Pycharm中项目中点击右键并直接创建Python文件
  

Hello world

写下你的第一个Python程序

print('hello world')
# 输出结果：hello world

快速运行：shift+F10

伴我们一生的变量

变量到底是什么

一般来讲，变量是计算机中的内存空间及里面的值

通俗地讲，小区有很多栋楼（内存空间），小明（ Hello World！）住进了 1单元101（变量名），此后，物业（计算机）便以 1单元101户主 来称呼小明了

message = 'Hello World!'
print(message)
# 运行结果：Hello World!
''' message是计算机中一块内存空间的名字，我们将文本 “Hello World！” 存进去，作为变量message的值即 message 代表了 Hello World!
'''

变量的名字有讲究

• 只能包含字母，数字和下划线（特殊符号或者空格都白搭，给你报错）
• 不能以数字开头
• 不能用 Python 里有特殊含义的单词（如：print ）和函数名（下面会讲到函数）
• 最好让人一看就知道是什么 比如存学生名字用 student_name

敲一敲

1. 将“人生苦短，我用Python”存储到变量中，再将其打印出来
2. 再将变量修改为“我爱Python”，并将其打印出来

简单数据类型

大多数程序都定义并收集某种数据，然后使用它们做些有意义的事情。
数据可以是数字，字符，或是一串字符等等，鉴于此，对数据进行分类大有裨益。

字符串

字符串就是一系列字符，如’abcdefg’。它有三种定义方式：

str = 'abcdefg' #使用单引号str = "abcdefg" #使用双引号str = '''abcdefg''' #使用三引号，当没有换行时，与前两种完全相同
str = '''abcd
efg'''              #当有换行时，三引号能够保存原有换行格式，而前两种不能# 我们可以根据需要对不同引号嵌套，满足不同的需求
str = 'I told my friend,"Python is my favorite language!"'
print(str)
# 输出结果：I told my friend , "Python is my favorite language!"

字符串的方法

了解了字符串的定义，我们开始学习方法，我们看下面的例子：

name = "ada lovelace"
print(name.title())
# 输出结果：Ada Lovelace

方法是Python可对数据执行的操作。不同的数据类型可以调用不同的方法。通俗的讲，我们把不同的数据类型看做不同职业的人，那么不同职业的人各自的本领就是方法。在今后我们还会学习很多方法，方法 是我们学习编程语言最重要的其中一部分

使用方法：变量名.方法名（） 括号中会提供使用方法必要的信息（参数）

在上面的例子中，name是字符串类型，调用了 title() 方法，即将每个单词首字母大写，类似的还有

name = "Ada Lovelace"
# 将字符串大写
print(name.upper())
# 将字符串小写
print(name.lower())

字符串的拼接

Python使用加号（+）来拼接字符串

# 拼接字符串
hello1 = '你'
hello2 = '好'
hello = hello1+hello2
print(hello)
# 输出结果：你好

请记住这个简单用法，我们今后还会用到它

关于空白

在编程中，空白泛指任何非打印字符，如空格，制表符（四个空格），换行符。我们可以使用空白来组织输出，以使其更易阅读

当我们需要在此处换行时，我们就需要转义字符 \n

print('Hello world!')
# 输出结果：Hello world!
print('Hello\nworld')
# 输出结果：Hello
#           world!

要在字符串中添加制表符，可使用字符组合 \t

print("Python")
# 输出结果：Python
print("\tPython")
# 输出结果：  Python

当我们不需要多余的空白时，Python可以帮助我们删除多余的空白

str1 = ' Python '
str2 = 'qwer'
# 只删除串尾空白
print(str1.rstrip()+str2)
# 输出结果： Pythonqwer# 只删除串首空白
print(str1.lstrip()+str2)
# 输出结果：Python qwer#同时删除两边空白
print（str1.strip()+str2）
# 输出结果：Pythonqwer

敲一敲

1. 个性化消息: 将用户的姓名存到一个变量中，并向该用户显示一条消息。显示的消息为“Hello Eric(用户的姓名)，would you like to learn some Python today?”
2. 调整名字大小写: 将一个人的名字存储到一个变量中，再以小写，大写和首字母大写的方式显示这个人名。
3. 名言: 找出依据你钦佩的名人说的名言，将这个名人的姓名和他的名言打印出来。输出应类似于下面这样（包括引号）：Albert Einstein once said,"A person who never made a mistake never tried anything new."
4. 名言2: 将名人的姓名存储在变量 person 中，再创建要显示的消息，并将其存储在变量message中，然后打印message
5. 剔除人名中的空白: 存储一个人名,并在其开头和结尾使用“/t”和“/n”来制造一些空白，打印这个人名。之后分别用 lstrip（），rstrip()，strip（）对人名进行处理，并打印结果

username = 'Eric'
print('Hello '+username+'，would you like to learn some Python today?')name = 'Tom'
print(name.title()) #首字母大写
print(name.upper()) #大写
print(name.lower()) #小写print('Albert Einstein once said,"A person who never made a mistake never tried anything new."')person = 'Albert Einstein'
message = person + ' once said,"A person who never made a mistake never tried anything new."'
print(message)name = '\t\nJerry\n\t'
print(name)
print(name.strip()) #去除两边空白
print(name.lstrip()) #去除串首空白
print(name.rstrip()) #去除串尾空白

数字

对于数字的操作想必大家并不陌生，我们先来看一下能对整数进行什么操作

# 加法
num = 2+3
print(num)
# 输出结果：5# 减法
num = 2-3
print(num)
# 输出结果：-1# 乘法
num = 2*3
print(num)
# 输出结果：6# 乘方
num = 2**3
print(num)
# 输出结果：8# 除法
num = 1/2
print(num)
# 输出结果：0.5# 整除法
num = 1//2
print(num)
# 输出结果：0# 取余（求模）
num = 4 % 3
print(num)
# 输出结果： 1

Python将带有小数点的数字都成位浮点数。浮点数的运算几乎与整数完全相同。需要注意的是，浮点数的运算结果仍然是浮点数

num = 0.5+0.5
print(num)
# 输出结果：1.0num = 0.5 * 2
print(num)
# 输出结果：1.0

其次，你会偶尔发现这种现象

num = 0.2+0.1
print(num)
# 输出结果：0.30000000000000004

鉴于计算机内部储存数字的方式，所有语言都会出现这种问题，在后来的学习中，我们将学习在需要时处理多余位小数的方式

加入，我们祝人生日快乐

age = 23
message = 'HAPPY '+ age + 'rd Birthday!'
print(message)

不出意外的话，他会出现意外

程序报错也就是我们程序员常说的 Bug:。俗话说“无Bug，不生活”，Bug对程序猿的追逐，对软件的痴迷，比现在的死忠粉还要厉害，不论在哪里，上天入地，都会与你在一起，不离不弃。

下面我们学习一下读报错内容

这句话是在提醒你报错的位置，是在"C:\Users\a\Desktop\python系统学习\字符串.py"文件中的第112行中的 message = 'HAPPY '+ age + ‘rd Birthday!’

这句话是报错的内容 类型错误：只能连接字符串类型（而不是整数类型）到字符串

原来我们用字符串拼接的方法只能拼接字符串，而age是整数类型，因此它会报错

下面我们学习，怎样将整数类型转化为字符串类型

age = 23
message = 'HAPPY '+ str(age) + 'rd Birthday!'
print(message)
# 输出结果：HAPPY 23rd Birthday!

像上面的字符串中使用整数时，需要你明确地命令Python将这个整数转化为字符串。为此，可调用str（）函数，它让Python将非字符串转换为字符串

在后面的学习中，我们将对函数展开全面的学习

敲一敲

最喜欢的数字: 将你最喜欢的数字存储在一个变量中，再使用这个变量创建一条消息，指出你最喜欢的数字，然后将这条消息打印出来

num = 2022888
message = 'Favorite number is '+str(num)
print(message)

注释

程序员最讨厌的两件事：
①给自己的程序写注释
②别人的程序没写注释

那么什么是注释呢？我们看下面的例子

注释就是说明代码的作用。随着程序越来越大，越来越复杂，恰当的注释能让后来的你知道当初写的什么鬼。后来的你一定会感谢现在努力写注释的你

如何写注释

在Python中，注释可以用 # 标识。在其后面的内容都会被解释器忽略

# 向大家问好
print("Hello Python people!")
# 输出结果：Hello Python people! 只执行了第二行

注释为什么重要

在开发项目期间，你对你的程序了如指掌，但过段时间后，有些细节你可能记不得了，通过编写注释，你能够很快的想起来当时为什么这么写，可以节省很多时间。其次要成为专业程序员，会不可避免的与他人合作，通过注释能让大家快速的交换思路，提高开发效率。作为新手，最值得养成的习惯之一是，在代码中编写清晰、间接的注释

初识列表

列表是一系列按特定顺序排列的元素(各种数据)组成。

通俗地讲，想象一个大箱子里有很多纸板做的隔间，我们可以把书本，日用品，衣服都可以放进去。然后，我们把隔间弄上编号0，1，2，3，4…，之后我们就可以根据编号来相应取出我们想要的的东西。

列表就是这个大箱子，数字，字符串各种数据类型都可以放进列表。根据他们的下标（从0开始），我们就可以取出我们想要的数据

基础中的基础

在 Python 中，用 方括号 [ ] 来表示列表，并用 , 来分隔其中的元素

# 创建列表
list = ['1','Lisa','Tom',1234]
print(list)
# 输出结果：['1', 'Lisa', 'Tom', 1234]

使用其下标来获取列表中的元素 注意：是从0开始

list = ['1','Lisa','Tom',1234]
print(list[0])
print(list[1])
print(list[2])
print(list[3])
'''输出结果：
1
Lisa
Tom
1234'''

我们写一个游戏，要求玩家射杀从天而降的外星人；为此，我们可以开始时将一些外星人存储在列表

aliens = ['亡刃将军','暗夜比邻星','黑矮星','乌木喉','超巨星']

有的外星人可以进化真·外星人，我们修改原列表中的外星人

aliens = ['亡刃将军','暗夜比邻星','黑矮星','乌木喉','超巨星']
aliens[0] = '真·亡灵将军' # 修改即给原下标重新赋值
print(aliens[0])
# 输出结果：真·亡灵将军

每当有外星人被射杀，就将其从列表中删除

aliens = ['亡刃将军','暗夜比邻星','黑矮星','乌木喉','超巨星']
del aliens[0] # “del 删除内容” 即可删除
print(aliens)
# 输出结果：['暗夜比邻星', '黑矮星', '乌木喉', '超巨星']aliens = ['亡刃将军','暗夜比邻星','黑矮星','乌木喉','超巨星']
name = aliens.pop(1) # 使用pop()方法从列表中删除并返回删除内容，参数为下标，默认为最后一个
print(name)
print(aliens)
# 输出内容：
# 暗夜比邻星
# ['亡刃将军', '黑矮星', '乌木喉', '超巨星']aliens = ['亡刃将军','暗夜比邻星','黑矮星','乌木喉','超巨星']
aliens.remove('超巨星')# 使用remove方法根据指定值删除列表中的内容，一次只能删除一个
print(name)
print(aliens)
# 输出内容：['亡刃将军', '暗夜比邻星', '黑矮星', '乌木喉']
# 注意：如果列表中没有指定删除的内容，编译器将会报错

每当有新外星人出现，就将其添加到列表中

aliens = ['亡刃将军','暗夜比邻星','黑矮星','乌木喉','超巨星']
aliens.append('灭霸') # 使用append方法添加到表位
print(aliens)
# 输出结果：['亡刃将军', '暗夜比邻星', '黑矮星', '乌木喉', '超巨星', '灭霸']aliens = ['亡刃将军','暗夜比邻星','黑矮星','乌木喉','超巨星']
aliens.insert(0,'灭霸') # 可以使用inset方法插入到表中任意位置，第一个参数为目标位置，第二个参数为插入的内容
print(aliens)
# 输出结果: ['灭霸', '亡刃将军', '暗夜比邻星', '黑矮星', '乌木喉', '超巨星']

敲一敲

1. 嘉宾名单：请创建一个列表，其中包含至少3个你想邀请的人；然后，使用这个列表打印消息，邀请这些人来与你共进晚餐。
2. 修改嘉宾名单：你刚得知有位嘉宾无法赴约，因此需要另外邀请一位嘉宾。
   ·在程序末尾添加一条print语句，指出哪位嘉宾无法赴约。
   ·修改嘉宾名单，将无法赴约的嘉宾的姓名替换为新邀请的嘉宾的姓名。
   ·再次打印一系列消息，向名单中的每位嘉宾发出邀请。
3. 添加嘉宾:你刚找到了一个更大的餐桌，可容纳更多的嘉宾。请想想你还想邀请哪三位嘉宾。
   ·在原程序末尾添加一条print语句，指出你找到了一个更大的餐桌。
   ·使用insert()将一位新嘉宾添加到名单开头。
   ·使用insert()将另一位新嘉宾添加到名单中间。
   ·使用append()将最后一位新嘉宾添加到名单末尾。
   ·打印一系列消息，向名单中的每位嘉宾发出邀请。
4. 缩减名单：你刚得知新购买的餐桌无法及时送达，因此只能邀请两位嘉宾。
   ·在原程序末尾添加一行代码，打印一条你只能邀请两位嘉宾共进晚餐的消息。
   ·使用pop()不断地删除名单中的嘉宾，直到只有两位嘉宾为止。每次从名单中弹出一位嘉宾时，都打印一条消息，让该嘉宾知悉你很抱歉，无法邀请他来共进晚餐。
   ·对于余下的两位嘉宾中的每一位，都打印一条消息，指出他依然在受邀人之列。
   ·使用del将最后两位嘉宾从名单中删除，让名单变成空的。打印该名单，核实程序结束时名单确实是空的。

# 1
vistors = ['钢铁侠','雷神','绿巨人']
print('请以下嘉宾来赴宴：')
print(vistors)# 2
print('绿巨人坐飞船去了宇宙，不能赴约')
vistors[2] = '鹰眼'
print('请以下嘉宾来赴宴：')
print(vistors)# 3
print('我找到了一个更大的餐桌，我将邀请更多的人')
vistors.insert(0,'黑寡妇')
vistors.insert(2,'蜘蛛侠')
vistors.append('黑豹')
print('请以下嘉宾来赴宴：')
print(vistors)# 4
print('不好意思，我买的餐桌不能及时送达，因此我只能邀请两位嘉宾共进晚餐')
vistor1 = vistors.pop()
print(vistor1+'很抱歉，不能邀请您来共进晚餐')
vistor2 = vistors.pop()
print(vistor2+'很抱歉，不能邀请您来共进晚餐')
vistor3 = vistors.pop()
print(vistor3+'很抱歉，不能邀请您来共进晚餐')
vistor4 = vistors.pop()
print(vistor4+'很抱歉，不能邀请您来共进晚餐')
print(vistors[0]+'您依然在受邀人之列')
print(vistors[1]+'您依然在受邀人之列')
del vistors[1]
del vistors[0]
print(vistors)
print('名单为空')'''输出结果：
请以下嘉宾来赴宴：
['钢铁侠', '雷神', '绿巨人']
绿巨人坐飞船去了宇宙，不能赴约
请以下嘉宾来赴宴：
['钢铁侠', '雷神', '鹰眼']
我找到了一个更大的餐桌，我将邀请更多的人
请以下嘉宾来赴宴：
['黑寡妇', '钢铁侠', '蜘蛛侠', '雷神', '鹰眼', '黑豹']
不好意思，我买的餐桌不能及时送达，因此我只能邀请两位嘉宾共进晚餐
黑豹很抱歉，不能邀请您来共进晚餐
鹰眼很抱歉，不能邀请您来共进晚餐
雷神很抱歉，不能邀请您来共进晚餐
蜘蛛侠很抱歉，不能邀请您来共进晚餐
黑寡妇您依然在受邀人之列
钢铁侠您依然在受邀人之列
[]
名单为空
'''

玩一玩列表的顺序

在创建的列表中，元素的排列顺序常常是无法预测的，因为用户提供数据的顺序是我们不能控制的。因此，我们就有必要对列表使用一些方法，使其以特定的顺序呈现信息。

我们创建一个无序的数字列表

number = [5,4,2,6,1]

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

number = [5,4,2,6,1]
number.sort()
print(number)
# 输出结果：[1, 2, 4, 5, 6]number = [5,4,2,6,1]
number.sort(reverse = True) #你还可以通过修改reverse参数进行倒序排列
print(number)
# 输出结果：[6, 5, 4, 2, 1]

sort（）方法不会保留原来的排列顺序，如果你想保留原列表的排列顺序，可以试试sorted（）函数

number = [5,4,2,6,1]
print(sorted(number))
print(number)
# 输出结果：[1, 2, 4, 5, 6]
#          [5, 4, 2, 6, 1] 原先的排列顺序并没有发生改变

下面我们将学习怎样反转列表元素的排列顺序

number = [5,4,2,6,1]
number.reverse()
print(number)
# 输出结果：[1, 6, 2, 4, 5]

与上面学习过的sort（）方法中改变reverse参数的方法不同，reverse（）方法只会反转原列表的排列顺序并不会进行大小比较后排列

在今后的程序里，我们将经常使用感到列表的长度，Python为我们提供了len（）函数来轻松获取列表长度

number = [5,4,2,6,1]
num = len(number)
print(num)
# 输出结果：5

敲一敲

奇妙数字：想出至少五个数字
·将这些地方存储在一个列表中，并确保其中的元素不是按大小顺序排列的。
·按原始排列顺序打印该列表。不要考虑输出是否整洁的问题，只管打印原始Python列表。
·使用sorted()按大小顺序打印这个列表，同时不要修改它。
·再次打印该列表，核实排列顺序未变。
·使用sorted()按与大小顺序相反的顺序打印这个列表，同时不要修改它。
·再次打印该列表，核实排列顺序未变。
·使用reverse()修改列表元素的排列顺序。打印该列表，核实排列顺序确实变了。
·使用reverse()再次修改列表元素的排列顺序。打印该列表，核实已恢复到原来的排列顺序。
·使用sort()修改该列表，使其元素按大小顺序排列。打印该列表，核实排列顺序确实变了。
·使用sort()修改该列表，使其元素按与大小顺序相反的顺序排列。打印列表，核实排列顺序确实变了
·使用len()方法获取列表长度并打印

number = [1,2,5,3,6,0]
print(number)
print(sorted(number))
print(number)
print(sorted(number,reverse=True))
print(number)
number.reverse()
print(number)
number.reverse()
print(number)
number.sort()
print(number)
number.sort(reverse=True)
print(number)
print(len(number))
'''输出结果：
[1, 2, 5, 3, 6, 0]
[0, 1, 2, 3, 5, 6]
[1, 2, 5, 3, 6, 0]
[6, 5, 3, 2, 1, 0]
[1, 2, 5, 3, 6, 0]
[0, 6, 3, 5, 2, 1]
[1, 2, 5, 3, 6, 0]
[0, 1, 2, 3, 5, 6]
[6, 5, 3, 2, 1, 0]
6
'''

我们应该注意避免出现索引错误。假如列表中有三个元素，而你却想要对第四个元素进行操作，此时编译器就会报错。我们可以通过事先获取列表长度，来尽可能避免出现这种错误。

list = [1,2,3]
print(list[3])
# 报错：IndexError: list index out of range

操作列表

我们知道，如果我们想获取列表中某一个元素，可以通过列表名[下标]的方式。那么问题来了，如果我们想对列表中每一个元素进行操作，比如都加1，除了一个个按上面那种方法，该怎么操作呢？

遍历整个列表

我们看下面一段代码

toys = ['玩具猫','玩具狗','玩具枪','奥特曼','蜘蛛侠']
for toy in toys:print(toy)
''' 输出结果：
玩具猫
玩具狗
玩具枪
奥特曼
蜘蛛侠
'''

如何理解这两段代码呢？通俗地讲，我们有一个箱子（列表），里面装满了玩具（列表中的元素），现在我们需要一个个把他们拿出来，并记录下他们的名字，直到箱子空了为止

代码第1行定义了一个列表名为toys的列表，代码第2行就相当于我们从箱子拿出玩具的过程，代码第3行，就相当于我们把拿出的玩具记录下来

for循环

现在我们把焦点集中到代码第2、3行上，学习for循环的用法

其中 i 代表着 in 后列表中的元素

for循环的执行过程为，对于列表中的每一个元素，都会执行for循环语句下的循环体中的操作。那么如何确定是循环体内还是循环体外呢？一起看下面的例子

names = ['Tom','Jeck']
for name in names:print('你好')
print('大家都挺好哈')
''' 输出结果：
你好
你好
大家都挺好哈
'''

在上面的例子中我们看到，打印“你好”的语句执行了2次，打印“大家都挺好哈”的语句执行了1次。这是因为，打印“你好”的语句缩进了（4个空格或1个tab键），在循坏体内。而打印“大家都挺好哈”的语句没有缩进，在循环体外。

如果你的循环不能如你所愿地工作，请看看是否又缩进错误（忘了？多了？位置错了？），如果报错，请看看是否忘了冒号

敲一敲

动画人物：想出至少三种你喜欢的动画人物，将其名称存储在一个列表中，再使用for循环将每位动画人物的名称都打印出来。
·修改这个for循环，使其打印包含动画人物名称的句子，而不仅仅是动画人物的名称。对于每位动画人物，都显示一行输出，如“I like 孙悟空”。
·在程序末尾添加一行代码，它不在for循环中，指出你有多喜欢动画人物，如“I really love cartoon!”。

characters = ['波吉','黑猫警长','葫芦娃']
for character in characters:print(character)for character in characters:print('I like '+character)print('I really love cartoon')
'''输出结果：
波吉
黑猫警长
葫芦娃
I like 波吉
I like 黑猫警长
I like 葫芦娃
I really love 黑猫警长'''

玩转数值类表

列表非常适合于存储数字结合，而Python提供了很多工具，可帮助你高效地处理数字列表。明白如何使用后，即便列表包含数百万个元素，你编写的代码也能运行得很好。

使用函数 range（）

for i in range(1,5)print(i)
''' 输出结果：
1
2
3
4
'''

在上述代码中好像应该打印1~5，但实际上却不会打印5。这是你在编程语言中，经常看到差一行为的结果。函数 range（）让Python从你指定的第一个值开始数，到你指定结束的前一个值结束。所以，如果你想打印数字1~5，你需要这么写

for i in range(1,6)print(i)
''' 输出结果：
1
2
3
4
5
'''

在使用 range（）函数时，你还可以设置步长

for i in range(1,11,2):print(i)
'''输出结果：
1
3
5
7
9
'''

从数字1开始，每加2，输出一个值，知道大于10为止

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

创建数字列表

可以使用 list（）函数将 range（）函数的结果直接保存为数字列表

print(list(range(1,6)))
# 输出结果：[1, 2, 3, 4, 5]

使用 range() 函数，几乎能创建任何需要的数字集。下面我们学习如何创建一个包含前十个整数的平方的列表

squares = [] # 创建一个空列表
for value in range(1,11):square = value**2 # 用square存储平方值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]

列表推导式

对于上面的例子，你还可以用一行代码来解决

squares = [value**2 for value in range(1,11)]# []内先写值，再写循环语句
print(squares)
# 输出结果：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

对数字列表简单的统计

list = [1,2,3,4,65,123,44]
print(sum(list)) # 求和
print(max(list)) # 最大值
print(min(list)) # 最小值
''' 输出结果：
242
123
1
'''

敲一敲

1. 数到20：使用一个for循环打印数字1～20（含）。
2. 一百万：创建一个列表，其中包含数字1～1000000，再使用一个for循环将这些数字打印出来（如果输出的时间太长，按Ctrl+C停止输出，或关闭输出窗口）。
3. 计算1～1000000的总和：创建一个列表，其中包含数字1～1000000，再使用min()和max()核实该列表确实是从1开始，到1000000结束的。另外，对这个列表调用函数sum()，看看Python将一百万个数字相加需要多长时间。
4. 奇数：通过给函数range()指定第三个参数来创建一个列表，其中包含1～20的奇数；再使用一个for循环将这些数字都打印出来。
5. 3的倍数：创建一个列表，其中包含3～30内能被3整除的数字；再使用一个for循环将这个列表中的数字都打印出来。
6. 立方：将同一个数字乘三次称为立方。请创建一个列表，其中包含前10个整数（即1～10）的立方，再使用一个for循环将这些立方数都打印出来。
7. 立方解析：使用列表解析生成一个列表，其中包含前10个整数的立方.

# 数到20：使用一个for循环打印数字1～20（含）。
for i in range(1,21):print(i)
# 一百万：创建一个列表，其中包含数字1～1000000，再使用一个for循环将这些数字打印出来（如果输出的时间太长，按Ctrl+C停止输出，或关闭输出窗口）。
list = [number for number in range(1,1000001)]
print(list)
# 计算1～1000000的总和：创建一个列表，其中包含数字1～1000000，再使用min()和max()核实该列表确实是从1开始，到1000000结束的。另外，对这个列表调用函数sum()，看看Python将一百万个数字相加需要多长时间。
print(min(list))
print(max(list))
print(sum(list))
# 奇数：通过给函数range()指定第三个参数来创建一个列表，其中包含1～20的奇数；再使用一个for循环将这些数字都打印出来。
list = [i for i in range(1,21,2)]
# 3的倍数：创建一个列表，其中包含3～30内能被3整除的数字；再使用一个for循环将这个列表中的数字都打印出来。
list = [3*i for i in range(1,11)]
print(list)
# 立方：将同一个数字乘三次称为立方。例如，在Python中，2的立方用2**3表示。请创建一个列表，其中包含前10个整数（即1～10）的立方，再使用一个for循环将这些立方数都打印出来。
list = []
for i in range(1,11):list.append(i**3)
for i in list:print(i)
# 立方解析：使用列表解析生成一个列表，其中包含前10个整数的立方。
list = [i**3 for i in range(1,11)]
print(list)

把列表切开（切片操作）

如果只想使用列表的一部分，我们就可以使用列表的切片操作

names = ['Tom','Jeck','Rose','David']
print(names[0:2])
# 输出结果:['Tom', 'Jeck']

与range（）函数规则相同，索引值会从第一个值开始，结束值前一个终止。所以在上述例子中，只打印了下标为0和下标为1的元素。

如果你没有指定初始值，会默认从第一个开始。相同的，如果没有指定结束值，会默认一直到结束。

names = ['Tom','Jeck','Rose','David']
print(names[:2]) # 输出结果：['Tom', 'Jeck']
print(names[1:]) # 输出结果：['Jeck', 'Rose', 'David']
print(names[:]) # 输出结果：['Tom', 'Jeck', 'Rose', 'David']

你还可以使用负数，即从右到左开始

names = ['Tom','Jeck','Rose','David']
print(names[1:-1])
print(name[-1:-3:-1]) # 切片操作也可以设置步长
# 输出结果：['Jeck', 'Rose']
#          ['David', 'Rose']

遍历切片和遍历列表样子相差不大

names = ['Tom','Jeck','Rose','David']
print('前三个人：')
for i in names[0:3]:print(i)
''' 输出结果：
前三个人：
Tom
Jeck
Rose
'''

在很多情况下，切片都很有用。比如在编写游戏时，你可以在玩家退出游戏时将其最终得分加入到一个列表中。然后，为了获取玩家的三个最高得分，你可以现将列表降序排列，再用切片取前三个数即可

复制列表

如果需要从已有的列表中，创建全新的列表，我们就会用到复制列表的操作

假设有一个列表中存储了你最喜欢的三种食物。现在你需要创建一个全新的列表存储你朋友最喜欢的食物，恰巧你喜欢的你朋友也喜欢，我们可以这么做

my_foods = ['饺子','炸酱面','汤圆']
print(my_foods)
friend_foods = my_foods[:]
print(friend_foods)
# 输出结果：['饺子', '炸酱面', '汤圆']
#          ['饺子', '炸酱面', '汤圆']

我们在不指定任何索引的情况下，从列表my_foods中提取了一个切片，在将其保存在变量friend_foods中。打印后我们发现他们是完全相同的

为核实我们确实是有两个列表，我们在每个列表后添加不同的食物

my_foods = ['饺子','炸酱面','汤圆']
friend_foods = my_foods[:]
my_foods.append('月饼')
friend_foods.append('煎饼')
print(my_foods)
print(friend_foods)
# 输出结果：
# ['饺子', '炸酱面', '汤圆', '月饼']
# ['饺子', '炸酱面', '汤圆', '煎饼']
# 由此我们可以知道，他们的确是两个不同的列表

但如果我们只是让 friend_foods = my_foods 会发生什么呢？

my_foods = ['饺子','炸酱面','汤圆']
friend_foods = my_foods
my_foods.append('月饼')
friend_foods.append('煎饼')
print(my_foods)
print(friend_foods)
# 输出结果：
# ['饺子', '炸酱面', '汤圆', '月饼', '煎饼']
# ['饺子', '炸酱面', '汤圆', '月饼', '煎饼']
# 我们可以看到明明是对两个不同列表名进行的操作，结果却相当于对同一列表进行的操作

如果你想练习更多有关列表有关知识，可以看一下我之前的博文
好好学python · 你真的会列表吗（列表推导式质检员）

敲一敲

切片：选择你在本章编写的一个程序，在末尾添加几行代码，以完成如下任务。
·打印消息“The first three items in the list are:”，再使用切片来打印列表的前三个元素。
·打印消息“Three items from the middle of the list are:”，再使用切片来打印列表中间的三个元素。
·打印消息“The last three items in the list are:”，再使用切片来打印列表末尾的三个元素

我们的童年：我们的童年：在你为完成练习动画人物而编写的程序中，创建动画人物列表的副本，并将其存储到变量friend_characters中，再完成如下任务。
·在原来的动画人物列表中添加一种动画人物。
·在列表friend_characters中添加另一种动画人物。
·核实你有两个不同的列表。为此，打印消息“My favorite cartoon characters are:”，再使用一个for循环来打印第一个列表；打印消息“My friend’s favorite characters are:”，再使用一个for循环来打印第二个列表

# 切片
list = ['饺子', '炸酱面', '汤圆', '月饼', '煎饼']
print('The first three items in the list are:')
print(list[0:3])
print('Three items from the middle of the list are:')
print(list[1:4])
print('The last three items in the list are:')
print(list[-3:])# 我们的童年
my_characters = ['波吉','黑猫警长','葫芦娃']
friend_characters = my_characters[:]
my_characters.append('哪吒')
friend_characters.append('孙悟空')
print('My favorite cartoon characters are:')
for character in my_characters:print(character)
print('My friend’s favorite cartoon characters are:')
for character in friend_characters:print(character)

元组

列表非常适合于存储在程序运行期间可能变化的数据集。然而有时候你需要创建一些列不可修改的元素，元组可以满足这种需求。

Python把不能修改的值称为不可变的，而不可变的列表被称为元组

# 定义元组
dimensions = (1,2,3) # 元组用小括号存放元素
print(dimensions[0])
print(dimensions[1])
# 输出结果：1
#          2

可以看到元组除了使用小括号存放元素外，其余操作与列表基本相同。此外，如果你试图修改元组内的值，比如dimensions[0]=2编译器就会报错。

虽然不能修改元组的值，但可以修改元组的变量

dimensions = (1,2,3)
print(dimensions)
dimensions = (3,4,5)
print(dimensions)
# 输出结果：
# (1, 2, 3)
# (3, 4, 5)
# 我们看到dimensions所存储的元组发生了改变

敲一敲

自助餐：有一家自助式餐馆，只提供五种简单的食品。请想出五种简单的食品，并将其存储在一个元组中。
·使用一个for循环将该餐馆提供的五种食品都打印出来。
·尝试修改其中的一个元素，核实Python确实会拒绝你这样做。
·餐馆调整了菜单，替换了它提供的其中两种食品。请编写一个这样的代码块：给元组变量赋值，并使用一个for循环将新元组的每个元素都打印出来

foods = ('馒头','烧饼','炊饼','煎饼','油饼')
for i in foods:print(i)
# foods[0] = '糖饼'
foods = ['馒头','烧饼','炊饼','大饼','糖饼']
for i in foods:print(i)

if 语句

初识 if 语句

我们买东西，比如买游戏皮肤的时候，我们会依据价格，特效等判断是否值得我们购买。如果价格合适，特效够炫，那必买啊！！那么在程序中如何实现呢

price = 99 # 皮肤价格
print('判断皮肤是否值得购买')
if price<100:print('价格合适，可以考虑购买')
else:print('还是去打工算了')
# 输出结果：
# 判断皮肤是否值得购买
# 价格合适，可以考虑购买

if 语句的格式是这样的

它的运行过程是这样的

如果有很多条件呢？

price = 99
special_effect = True # 代表有特效
if price<100 and special_effect: # 利用 and连接符 表示条件同时满足print('买它！买它！')
else:print('不买')
# 输出结果：买它！买它！price = 100
special_effect = True # 代表有特效
limit = True # 代表皮肤是限定的
# 使用 or连接词表示，两边条件只要有一边满足即可
if (price<100 and special_effect) or limit: # 不管价格是多少，只要皮肤是限定的就买它！print('买它！买它！')
else:print('不买')
# 输出结果：买它！买它！

special_effect = True 称为布尔表达式，是条件测试的别名。结果要么为True，要么为False

也可以使用嵌套

如果有很多种情况呢？

price = 100
special_effect = True # 代表有特效
limit = True # 代表皮肤是限定的
# 使用 or连接词表示，两边条件只要有一边满足即可
if price<100 and special_effect:print('买它！买它！')
elif price>=100 and limit:print('借钱买！')
else:print('不买')
# 输出结果：借钱买！

它的执行过程是这样的

深入 if语句

每条if语句的核心都是一个值为True 或 False 的表达式，这种表达式称为条件测试。Python根据条件测试的值为True还是False来决定是否执行 if语句中的代码。

条件测试可以是以下的例子：

检查是否相等

name = 'Tom'
if name == 'Tom': # 判等一定是双等号 判断不相等用 !=print('是Tom')
else:print('不是Tom')
# 输出结果：是Tom# 如果不考虑大小写呢？
name = 'Tom'
if name.lower() == 'tom':print('是Tom')
else:print('不是Tom')
# 输出结果：是Tom

比较数字

answer = 17
if answer != 42:print('猜错咯')
else:print('牛掰，这都猜对了')
# 输出结果：猜错咯

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

list = ['Tom','Jeck','Jerry','Rose']
if 'Tom' in list:print('Tom在名单里')
else:print('没在名单里')
# 输出结果：Tom在名单里if 'Leo' not in list:print('Leo没在名单里')
else:print('Leo在名单里')
# 输出结果：Leo没在名单里

敲一敲

1. 买不买皮肤： 判断LOL腕豪虎年限定皮肤是否值得购买
   （已知价格为100RMB，有特效，是限定皮肤）
2. 条件测试:

car = 'subaru'
print("Is car == 'subaru'? I predict True.")
print(car == 'subaru')
print("\nIs car == 'audi'? I predict False.")
print(car == 'audi')

详细研究实际结果，直到你明白了它为何为True或False。

1. 外星人颜色：假设在游戏中刚射杀了一个外星人，请创建一个名为alien_color的变量，并将其设置为’green’、‘yellow’或’red’。
   ·编写一条if语句，检查外星人是否是绿色的；如果是，就打印一条消息，指出玩家获得了5个点。
   ·编写这个程序的两个版本，在一个版本中上述测试通过了，而在另一个版本中未通过（未通过测试时没有输出）。

2. 外星人颜色2：像练习5-3那样设置外星人的颜色，并编写一个if-else结构。
   ·如果外星人是绿色的，就打印一条消息，指出玩家因射杀该外星人获得了5个点。
   ·如果外星人不是绿色的，就打印一条消息，指出玩家获得了10个点。
   ·编写这个程序的两个版本，在一个版本中执行if代码块，而在另一个版本中执行else代码块。

3. 外星人颜色#3：将练习5-4中的if-else结构改为if-elif-else结构。
   ·如果外星人是绿色的，就打印一条消息，指出玩家获得了5个点。
   ·如果外星人是黄色的，就打印一条消息，指出玩家获得了10个点。
   ·如果外星人是红色的，就打印一条消息，指出玩家获得了15个点。
   ·编写这个程序的三个版本，它们分别在外星人为绿色、黄色和红色时打印一条消息。

4. 人生的不同阶段：设置变量age的值，再编写一个if-elif-else结构，根据age的值判断处于人生的哪个阶段。
   ·如果一个人的年龄小于2岁，就打印一条消息，指出他是婴儿。
   ·如果一个人的年龄为2（含）～4岁，就打印一条消息，指出他正蹒跚学步。
   ·如果一个人的年龄为4（含）～13岁，就打印一条消息，指出他是儿童

# 1
# 实现过程不唯一，只要程序按照预期执行即可
price = 99
special_effect = True
limit = True
if (price<100 and special_effect) or limit:print('值得购买')
else:print('不值得购买')# 2
# 略 自己好好想# 3
alien_color = green
if alien_color == green:print('玩家获得5点')
# 输出结果：玩家获得5点
alien_color = yellow
if alien_color ==green:print('玩家获得5点')
# 输出结果： (空)# 4
alien_color = green
if alien_color == green:print('玩家获得5点')
else:print('玩家获得10点')
# 输出结果：玩家获得5点
alien_color = yellow
if alien_color == green:print('玩家获得5点')
else:print('玩家获得10点')
# 输出结果：玩家获得10点# 5
alien_color = green  # 输出结果：5点
# alien_color = yellow # 输出结果：10点
# alien_color = red    # 输出结果：15点
if alien_color == green:print('玩家获得5点')
elif alien_color == yellow:print('玩家获得10点')
else:print('玩家获得15点')
# 6
age = 4
if age<2:print('他是个婴儿')
elif age>=2 and age<4:print('他正在蹒跚学步')
elif age>=4 and age<13:print('他是儿童')
elif age>=13 and age<20:print('他是青少年')
elif age>=20 and age<65:print('他是成年人')
else:print('他是老年人')# 7
favorite_fruits = ['苹果','香蕉','西瓜']
if '苹果' in favorite_fruits:print('You really like 苹果!')
if '西瓜' in favorite_fruits:print('You really like 西瓜!')
if '香蕉' in favorite_fruits:print('You really like 香蕉!')
if '橘子' in favorite_fruits:print('You really like 橘子!')
if '橙子' in favorite_fruits:print('You really like 橙子!')

用 if语句处理列表

假设我们是一家比萨店，制作比萨时，每添加一种配料，都打印一条信息

request_toppings = ['mushrooms','green peppers','extra cheese']
for request_topping in request_toppings:print('添加'+request_topping)
print('完成制作')
'''
输出结果:
添加mushrooms
添加green peppers
添加extra cheese
完成制作
'''

然而很遗憾，我们的青椒用完了，该如何处理呢。我们在比萨中，对每种配料进行检查，如果有青椒，告知顾客不能点青椒的原因

request_toppings = ['mushrooms','green peppers','extra cheese']
for request_topping in request_toppings:if request_topping == 'green peppers':print('不好意思，青椒断货了')else:print('添加'+request_topping)
print('制作完成')
'''输出结果：
添加mushrooms
不好意思，青椒断货了
添加extra cheese
制作完成
'''

由于顾客的要求往往是五花八门的，在比萨配料方面尤其如此。比如有些顾客喜欢加香菜，有些顾客喜欢加大蒜。于是，我们定义两个列表，一个存放我们现有原料，一个存放顾客的需求原料

available_toppings = ['mushrooms','olives','green peppers','pineapple']
requested_toppings = ['mushrooms','french fries','extracheese']
for requested_topping in requested_toppings:if requested_topping in available_toppings:print('添加'+requested_topping)else:print(requested_topping+'这个真没有')
''' 输出结果：
添加mushrooms
french fries这个真没有
extracheese这个真没有
'''

敲一敲

1. 以特殊方式跟管理员打招呼：创建一个至少包含5个用户名的列表，且其中一个用户名为’admin’。想象你要编写代码，在每位用户登录网站后都打印一条问候消息。遍历用户名列表，并向每位用户打印一条问候消息。
·如果用户名为’admin’，就打印一条特殊的问候消息，如“Hello admin, would you like to see a status report?”。
·否则，打印一条普通的问候消息，如“Hello Eric, thank you for logging in again”。
2. 处理没有用户的情形：在为完成练习5-8编写的程序中，添加一条if语句，检查用户名列表是否为空。
·如果为空，就打印消息“We need to find some users!”。
·删除列表中的所有用户名，确定将打印正确的消息。
3. 检查用户名：按下面的说明编写一个程序，模拟网站确保每位用户的用户名都独一无二的方式。
·创建一个至少包含5个用户名的列表，并将其命名为current_users。
·再创建一个包含5个用户名的列表，将其命名为new_users，并确保其中有一两个用户名也包含在列表current_users中。
·遍历列表new_users，对于其中的每个用户名，都检查它是否已被使用。如果是这样，就打印一条消息，指出需要输入别的用户名；否则，打印一条消息，指出这个用户名未被使用。
·确保比较时不区分大小写；换句话说，如果用户名’John’已被使用，应拒绝用户名。
4. 序数：序数表示位置，如1st和2nd。大多数序数都以th结尾，只有1、2和3例外。
·在一个列表中存储数字1～9。
·遍历这个列表。
·在循环中使用一个if-elif-else结构，以打印每个数字对应的序数。输出内容应为1st、2nd、3rd、4th、5th、6th、7th、8th和9th

# 1
names = ['Tom','Jeck','admin','Rose','Jerry']
for name in names:if name == 'admin':print('Hello admin, would you like to see a status report?')else:print('Hello '+name+' thank you for logging in again')# 2
names = ['Tom','Jeck','admin','Rose','Jerry']
names.clear() # clear()函数  请空列表
if names:for name in names:if name == 'admin':print('Hello admin, would you like to see a status report?')else:print('Hello'+name+' thank you for logging in again')
else:print('We need to find some users!')# 3
current_users = ['Tom','Jeck','admin','Rose','Jerry']
new_users = ['Tom','Jeck','Leo','Alice','Harry']
for name.lower in new_users.lower():if name in current_users:print('需要输入别的用户名')else:print('这个用户名未被使用')# 4
current_users = ['Tom','Jeck','admin','Rose','Jerry']
new_users = ['Tom','Jeck','Leo','Alice','Harry']
for i in current_users:i = i.lower()
for name in new_users:lower_name = name.lower()if name in current_users:print('需要输入别的用户名')else:print('这个用户名未被使用')

字典

初识字典

在Python中，字典是一系列键值对。什么是键值对，通俗地讲，一个门牌号（键）对应唯一的业主名字（值），但是业主的名字不一定对应唯一的门牌号（有可能会重名）

字典与列表，元组大同小异，列表和元组是下标帮助查找元素，而字典是以键来查找元素。他们的添加修改删除基本相同

下面我们举一个简单例子

alien_0 = {'color':'green','points':5}
print(alien_0)
# 输出结果：{'color': 'green', 'points': 5}

可以看到，字典由大括号围成，每一个逗号隔开一对键值对，键和值之间用冒号。自此，我们已经学习了，小括号围成的元组，中括号围成的列表，以及大括号围成的字典

由于键与值一一对应，因此我们可以通过键来返回值。这与列表和元组的下标取值类似，但要注意，字典没有下标

alien_0 = {'color':'green','points':5}
print(alien_0['color'])
# 输出结果：green

添加键值对操作简单，只需简单赋值即可

alien_0 = {'color':'green','points':5}
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
# 输出结果：{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}

修改键值对，也是直接赋值

alien_0 = {'color':'green','points':5}
alien_0['color'] = 'red'
print(alien_0)
# 输出结果：{'color': 'red', 'points': 5}

来看一个有趣的例子：对一个能够以不同速度移动的外星人的位置进行跟踪。为此，我们存储该外星人的当前速度，并根据此确定该外星人将向右移动多远：

alien_0 ={'x_position':0,'y_position':25,'speed':'medium'}
print("Original x_position:" + str(alien_['x_position']))
# 向右移动外星人
# 据外星人当前速度决定将其移动多远
if alien_0['speed'] == 'slow':x_increment = 1
elif alien_0['speed'] == 'medium':x_increment = 2
else:# 这个外星人的速度一定很快x_increment = 3
# 新位置等于老位置加上增量
alien_0['x_position'] = alien_0['x_position']+x_increment
print('New x_position:' +str(alien_0['x_position']))
# 输出结果：Original x_position:0
#          New x_position:2

这种技术很棒。我们可以通过修改外星人字典里的值，就能够改变外星人的行为

删除键值对，与列表类似，需要使用到del关键字

alien_0 = {'color':'green','points':5}
del alien_0['color']
print(alien_0)
# 输出结果：{'points': 5}

前面外星人的例子，字典存储的是同一个对象的不同属性（一个外星人的坐标，速度），我们也可以存储不同对象的同一属性（如不同人喜欢的编程语言）

favorite_languages = {'Tom':'python','John':'C','Jcak':'Java',
}
print('Tom喜欢的语言是'+favorite_languages['Tom'])
# 输出结果：Tom喜欢的语言是python

遍历所有键值对

我们先来看一个新字典，他用于存储有关网站用户的信息

user_0 = {'name':'有理想有本领有担当的有志青年','age':19,'school':'河北师范大学'
}

下面我们用for循环来遍历这个字典

user_0 = {'name':'有理想有本领有担当的有志青年','age':19,'school':'河北师范大学'
}
for k,v in user_0.items(): # items()方法它返回一个键-值对列表 dict_items([('name', '有理想有本领有担当的有志青年'), ('age', 19), ('school', '河北师范大学')])print('\nKey'+k)print('Value'+value)
'''输出结果：
Key: name
Value: 有理想有本领有担当的有志青年Key: age
Value: 19Key: school
Value: 河北师范大学
'''

for循环依次将每个键—值对存储到指定的两个变量中，k和v是两个变量，可使用任何名称。需要注意的是，Python只跟踪键和值之间的关联关系，因此，输出顺序可能会与存储顺序不同

除此之外，我们还可以使用keys（）方法只遍历字典的键

favorite_languages = {'Tom':'python','John':'C','Jack':'Java',
}
for name in favorite_languages.keys():print(name.title())
''' 输出结果:
Tom
John
Jack
'''

我们前面已经知道了，Python不关心字典输出的顺序，那么怎样才能按顺序遍历字典中的所有键。这里我们用到了sorted() 函数

favorite_languages = {'Jom':'python','John':'C','Jcak':'Java',
}
for name in sorted(favorite_languages()):print(name.title())
'''输出结果:
Jcak
John
Jom
sorted（）函数是按照从第一个字母开始比较顺序排列（先比较第一个字母，第一个字母相同，再比较第二个字母...）
'''

下面我们再遍历字典的值，与遍历键类似，我们需要用到 values()。

favorite_languages = {'Jom':'python','John':'C','Jcak':'Java',
}
for language in favorite_languages.values():print(language.title())
'''输出结果：
Python
C
Java
'''

这种做法虽然能提取所有值，但没有考虑是否重复。如果被调查者很多，最终的列表可能包含大量的重复项。为剔除重复项，可使用set（）集合函数。我们在中学学习过，集合具有互异性，即不存在相同的元素。

favorite_languages = {'Jom':'python','John':'C','Jcak':'Java','Tom':'C'
}
for language in set(favorite_languages.values()):print(language.title())
'''
输出结果：
Python
C
Java
'''

敲一敲

1. 人：使用一个字典来存储一个熟人的信息，包括姓名，年龄，学校。该字典应包含键name、age和school。将存储在该字典中的每项信息都打印出来。
2. 河流：创建一个字典，在其中存储三条大河流及其流经的国家。其中一个键—值对可能是’nile’: ‘egypt’。
   ·使用循环为每条河流打印一条消息，如“The Nile runs through Egypt.”。
   ·使用循环将该字典中每条河流的名字都打印出来。
   ·使用循环将该字典包含的每个国家的名字都打印出来。
3. 调查：在favorite_languages 的基础上，
   ·创建一个应该会接受调查的人员名单，其中有些人已包含在字典中，而其他人未包含在字典中。
   ·遍历这个人员名单，对于已参与调查的人，打印一条消息表示感谢。对于还未参与调查的人，打印一条消息邀请他参与调查。

# 1
my_friend = {'name':'有理想，有本领，有担当的有志青年','age':19,'city':'河北师范大学'}
for k,v in my_friend.items():print(k+':'+str(v))# 2
rivers = {'长江':'中国','黄河':'中国','叶尼塞河':'俄罗斯'}
for k,v in rivers.items():print(k+'流经'+v)
for k in rivers.keys():print(k,end=' ') # 实现不换行输出
print()
for v in rivers.values():print(v,end=' ')# 3
favorite_languages = {'Jom':'python','John':'C','Jcak':'Java','Tom':'C'
}
respondents = ['Jom','John','Jcak','Tom','Rose','Leo']
for k in favorite_languages.keys():if k in respondents:print(k+',感谢您参与')else:print(k+',诚邀您参与')

用户输入

基本用法

大多数程序都旨在解决最终用户问题，为此，通常需要从用户那里获取一些信息。比如我们可以根据用户输入自己的年龄，来判断是否到达了投票的年龄。这就需要我们学习函数input（）

函数 input（）让程序暂停运行，等待用户输入文本。获取用户输入后，Python将其存储在一个变量中供我们使用。

message = input("What's your name") # input函数内参数是要向用户显示的提示或说明
print(message)

输出结果

其中 Tony 为用户输入信息

用 input（）接收到的用户输入信息，默认为字符串类型。因此，如果我们想利用输入的数值，我们需要首先将其转化为数值类型

下面我们通过获取用户年龄，来判断一个人身高是否满足过山车的要求

height = int(input('你多高？'))
if height>=140:print('可以坐')
else:print('长大后再来吧')

敲一敲

汽车租赁：编写一个程序，询问用户要租赁什么样的汽车，并打印一条消息，如：让我看看有没有玛莎拉蒂

car = input('你想租什么样的汽车? ')
print('让我看看有没有'+car)

输出结果

While循环

前面我们已经学习了 for循环，for循环用于针对集合中的每个元素的一个代码块。而while循环不断地运行，直到指定条件不满足为止。通俗地讲，比如有一箱子瓶子，我们把他们拿出来并拧开，我们就可以使用到 for循环。当然while循环也可以做到，只需要把条件设置为当箱子非空的时候，执行拿出瓶子并拧开即可。而我们不知道需要循环多少遍，如我们打铁的时候，不知道打多少次才算打好，因为受很多因素影响，没有固定次数，因此我们需要打一次看一次，如果打好了，我们就停止。这是for循环不能做到的，而while可以轻松做到。

基本用法

下面我们具体学习while循环的用法

相信通过前面的学习，你能轻松掌握while循环的用法

# 从1数到5
current_number = 1
while current_number<=5: # 当current_number<=5时执行以下代码print(current_number)current_number+=1
''' 输出结果：
1
2
3
4
5
'''

在游戏中，会经常使用到while循环，确保在玩家想玩时不断运行，并在玩家想要退出时停止运行。

player = input('告诉我你还想玩吗？（T/F）')
while player == 'T':print('继续游戏中')player = input('告诉我你还想玩吗？（T/F）')
print('结束游戏')

输出结果

对于上面的例子，我们还可以对while循环语句进行简化

active = True
while active:print('继续游戏中')player = input('告诉我你还想玩吗？（T/F）')if player == 'T':active = Trueelse:active = False
print('结束游戏')

我们默认第一次继续游戏，对while循环语句进行简化。我们加入active标志来判断是否进行循环，看似简单地改动，实则当条件过多时，可以很好地帮助我们修复bug

如果我们想对循环进行额外的操作，我们可以使用 break和 continue。通俗地讲，假如我们给一个小区的人做核酸检测，但是做核酸的试纸不够了，我们需要终止本次核酸检测，因此需要用到break。假如在正常做核酸过程中，有一个人忘记带身份证，我们就跳过他，给下一个人进行核酸检测，这就需要用到continue。

由此，我们可以利用break，继续简化前面的程序

while True:player = input('告诉我你还想玩吗？（T/F）')if player == 'F':print('终止游戏')breakelse:print('继续游戏')

输出结果

如果我们需要通过循环输出奇数，那么continue将是不错的选择

current_number = 0
while current_number<10:current+=1if current_number %2 ==0:continueprint(current_number)
'''输出结果
1
3
5
7
9
'''

在编写循环时，一定要注意循环条件的正确性。如果循环条件出问题，很可能会使程序运行无限循环，这时我们可按Ctrl+C来终止程序，并检查条件

敲一敲

比萨配料:编写一个循环，提示用户输入一些类的比萨配料，并在用户输入‘quit’时结束循环。每当用户输入一种配料后，都打印一条消息，说我们会在比萨中添加这种配料

while True:ingredient = input('请加入一些比萨配料： ')if ingredient == 'quit':breakelse:print('我们将在比萨中加入'+ingredient)

用while循环处理列表和字典

在今后，我们需要记录大量的用户和信息，for循环虽然是一种遍历列表中不应修改列表，否则将导致Python难以跟踪其中的元素，这就需要在while循环中使用列表和字典。

假设有一个列表，其中包含新注册但还未验证的网站用户;验证这些用户后，如果将他们移到另一个已验证用户列表中呢？一种办法是使用一个while循环，在验证用户的同时将其从未验证用户列表中提取出来，再将其加入到另一个已验证用户列表中。

uncomfirmed_users = ['alice','brian','candace']
comfirmed_users = []
while uncomfirmed_users:user = uncomfirmed_users.pop()comfirmed_users.append(user.title())
print(comfirmed_users)
# 输出结果：['Candace', 'Brian', 'Alice']

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

假设我们有一个宠物列表，其中包含多个值为‘小猫’的元素，要删除所有这些元素，可不断运行一个while循环，直到列表中不再包含小猫

pets = ['小狗','小猫','小狗','金鱼','小猫','小兔','小猫']
while '小猫' in pets:pets.remove('小猫')
print(pets)
# 输出结果：['小狗', '小狗', '金鱼', '小兔']

使用用户输入来填充字典

下面我们来创建一个调查程序，其中的循环每次执行时都提示输入被调查者的名字和回答。我们将收集的数据存储在一个字典中，以便将回答同被调查者关联起来

reponses = {}
active = True
while active:key = input('您的姓名： ')value = input('您的回答： ')reponses[key] = valuerepeat = input('还有其他人要回答吗(T/F)')if repeat == 'F'active = False
print(reponses)

敲一敲

1. 熟食店：创建一个名为sandwich_orders的列表，在其中包含各种三明治的名字；再创建一个名为finished_sandwiches的空列表。遍历列表sandwich_orders，对于其中的每种三明治，都打印一条消息，XX三明治制作中，并将其移到列表finished_sandwiches。所有三明治都制作好后，打印一条消息，将这些三明治列出来。

2. 梦想的度假胜地：编写一个程序，调查用户梦想的度假胜地。使用类似于“如果你去旅游，你会去什么地方”的提示，并编写一个打印调查结果的代码块。

# 1
sandwich_orders = ['鸡蛋三明治','水果三明治','果酱三明治']
finished_sandwiches = []
while sandwich_orders:sandwich = sandwich_orders.pop()print(sandwich+'制作中')finished_sandwiches.append(sandwich)
print(finished_sandwiches)# 2
results={}
while True:person = input('您的名字： ')place  = input('您想去哪玩？ ')results[person] = placerepeat = input('还有其他人吗？')if repeat == 'no':break
print(results)

函数

前面我们已经学习了部分函数，接下来我们将具体学习什么是函数。函数是带名字的代码块，用于完成具体的任务。函数既可以是Python中内置的，也可以是我们编写的。通过使用函数，程序的编写、阅读、测试和修复都将更容易。

定义函数

我们写一个简单的问候函数

def greet_user():print('Hello!')
greet_user() # 调用函数
# 输出结果：Hello!

我们也可以向函数传递信息，下面我们将用户的名字加入到问候语中

def greet_user(username):print('Hello! '+username)
greet_user('张三')
# 输出结果: Hello! 张三

传递参数

在上面的例子中，username叫作形参（形式参数），张三叫作实参（实际参数）。怎么理解形参和实参呢？通俗地讲，形参的作用是规定好函数要什么，比如人名，实参的作用是具体传给函数的东西，比如张三。这种例子还很多，比如形参是衣服，实参可以是粉色的裙子等等。

传递实参的方式有两种，一种是位置上和形参一一对应，很好理解

def describe_pet(animal_type,pet_name):print('动物类型： '+animal_type)print('动物名字： '+pet_name)
describe_pet('狗','大黄') # 狗对应animal_type，大黄对应pet_name
# 输出结果：动物类型： 狗
#          动物名字： 大黄

我们可以多次不同地调用它

def describe_pet(animal_type,pet_name):print('动物类型： '+animal_type)print('动物名字： '+pet_name)
describe_pet('狗','大黄')
describe_pet('猫','花花')
''' 输出结果：
动物类型： 狗
动物名字： 大黄
动物类型： 猫
动物名字： 花花
'''

另一种是关键字实参，说白了就是用等号说明哪个实参对应哪个形参

def describe_pet(animal_type,pet_name):print('动物类型： '+animal_type)print('动物名字： '+pet_name)
describe_pet(pet_name ='大黄',animal_type ='狗')
'''输出结果:
动物类型： 狗
动物名字： 大黄
'''

这就不需要位置一一对应了，而第一种方法必须位置严格一一对应

除此之外，我们还可以设置默认值。比如在调查的宠物中，狗占绝大多数，因此，我们把动物类型默认设置为狗，这样只需要传入动物名字就可以了

def describe_pet(pet_name,animal_type='狗'):print('动物类型： '+animal_type)print('动物名字： '+pet_name)
describe_pet('大黄')
'''输出结果：
动物类型： 狗
动物名字： 大黄
'''

注意：有默认值的形参一定要放在没默认值的后面

敲一敲

T恤：编写一个名为make_shirt()的函数，它接受一个尺码以及要印到T恤上的字样。这个函数应打印一个句子，概要地说明T恤的尺码和字样。
使用位置实参调用这个函数来制作一件T恤；再使用关键字实参来调用这个函数。

def make_shirt(size,style):print('该T恤的尺码为'+size+',字样为'+style)
make_shirt('xl','Love')
make_shirt(style = 'Love',size = 'xl')
'''输出结果：
该T恤的尺码为xl,字样为Love
该T恤的尺码为xl,字样为Love
'''

返回值

函数的主要作用并非直接显示输出，而是处理一些数据并返回一个或一组值。函数返回的值称为返回值。在函数中，可使用return语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁重干工作移到函数中完成，从而简化主程序

下面这个函数，它接受名和姓，并返回整洁的姓名

def get_formatted_name(first_name,last_name):full_name = first_name+' '+last_namereturn full_name.title()
print(get_formatted_name('harry','potter'))
# 输出结果：Harry Potter

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

# 返回一个字典，其中包含有关一个人的信息
def build_person(first_name,last_name,age = ' '):person = {'fist':first_name,'last':last_name}if age:person['age']=agereturn person
musician = build_person('jimi','hendrix',age = 27)
print(musician)
# 输出结果：{'fist': 'jimi', 'last': 'hendrix', 'age': 27}

除此之外，我们可以将函数与前面介绍的任何Python结构结合起来使用。

def build_person(first_name,last_name,age = ' '):person = {'fist':first_name,'last':last_name}if age:person['age']=agereturn person
while True:first_name = input('Your first name: ')last_name = input('Your last name: ')age = input('Your age: ')print(build_person(first_name,last_name,age))repeat = input('还有其他人嘛')if repeat == 'no':break

敲一敲

专辑:编写一个名为make_album()的函数，它创建一个描述音乐专辑的字典。这个函数应接受歌手的名字和专辑名，并返回一个包含这两项信息的字典。使用这个函数创建三个表示不同专辑的字典，并打印每个返回的值，以核实字典正确地存储了专辑的信息。
给函数make_album()添加一个可选形参，以便能够存储专辑包含的歌曲数。如果调用这个函数时指定了歌曲数，就将这个值添加到表示专辑的字典中。调用这个函数，并至少在一次调用中指定专辑包含的歌曲数。

def make_album(singer_name,album_name,amount = ' '):album = {}album['歌手'] = singer_namealbum['专辑名'] = album_nameif amount:album['数量'] = amountreturn album
print(make_album('周杰伦','范特西',10))
# 输出结果：{'歌手': '周杰伦', '专辑名': '范特西', '数量': 10}

传递列表

你会经常发现，向函数传递列表很有用。下面我们使用函数来提高处理列表的效率

向列表中的用户发出问候

def greet_users(names):for name in names:msg = 'Hello,'+name+'!'print(msg)
username = ['Tom','Tommy','Leo']
greet_users(usernames)

将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据

还记得这个例子吗

uncomfirmed_users = ['alice','brian','candace']
comfirmed_users = []
while uncomfirmed_users:user = uncomfirmed_users.pop()comfirmed_users.append(user.title())
print(comfirmed_users)

下面我们用函数来优化这个程序

def print_users(uncomfirmed,comfirmed):while uncomfirmed:user = uncomfirmed.pop()comfirmed.append(user.title())print(comfirmed)
uncomfirmed_users = ['alice','brian','candace']
comfirmed_users = []
print_users(uncomfirmed_users,comfirmed_users)
# 输出结果：['Candace', 'Brian', 'Alice']

相比于没有使用函数的版本，这个程序更容易扩展和维护。如果以后需要打印其他用户，只需再次调用即可。如果我们发现需要对打印代码进行修改，只需修改这些代码一次，就能影响所有调用该函数

在上述例子中，我们清空了原有的列表uncomfirmed_users 如果我们想保留原有列表，仍实现原有的效果，我们可以使用切片操作来创建列表副本

def print_users(uncomfirmed,comfirmed):while uncomfirmed:user = uncomfirmed.pop()comfirmed.append(user.title())print(comfirmed)
uncomfirmed_users = ['alice','brian','candace']
comfirmed_users = []
print_users(uncomfirmed_users,comfirmed_users)
print(uncomfirmed_users)
# 输出结果：['Candace', 'Brian', 'Alice']
#           []def print_users(uncomfirmed[:],comfirmed):while uncomfirmed:user = uncomfirmed_users.pop()comfirmed.append(user.title())print(comfirmed)
uncomfirmed_users = ['alice','brian','candace']
comfirmed_users = []
print_users(uncomfirmed_users,comfirmed_users)
print(uncomfirmed_users)
# 输出结果：['Candace', 'Brian', 'Alice']
#          ['alice', 'brian', 'candace']

敲一敲

魔术师：创建一个包含魔术师名字的列表，并将其传递给一个名为show_magicians()的函数，这个函数打印列表中每个魔术师的名字。

编写一个名为make_great()的函数，对魔术师列表进行修改，在每个魔术师的名字中都加入字样“the Great”。调用函数show_magicians()，确认魔术师列表确实变了。

在调用函数make_great()时，向它传递魔术师列表的副本。由于不想修改原始列表，请返回修改后的列表，并将其存储到另一个列表中。分别使用这两个列表来调用show_magicians()，确认一个列表包含的是原来的魔术师名字，而另一个列表包含的是添加了字样“the Great”的魔术师名字。

def show_magicians(magicians):for magician in magicians:print(magician,end=' ')
def make_great(magicians):list = []while magicians:magician = 'the Great '+magicians.pop()list.append(magician)return list
magicians = ['Tom','Leo','Tommy']
print('原列表')
show_magicians(magicians)
print()
# print('列表确实变了')
# magicians = make_great(magicians)
# show_magicians(magicians)
list = make_great(magicians)
show_magicians(magicians)
show_magicians(list)

传递任意数量的实参

有时候，你不知道函数需要接受多少个实参，好在Python允许函数可接收任意数量的实参

def make_pizza(*toppings):print(toppings)
make_pizza('大蒜')
make_pizza('大蒜','洋葱')
# 输出结果：('大蒜',)
#          ('大蒜', '洋葱')

※+形参名让Python创建一个名为toppings的空元组可存储多个普通参数，※※+形参名让Python创建一个空元祖可存储多个关键字参数，不管函数收到的实参是多少个，这种语法都适用

如果你想了解更多有关函数参数的细节，可以参考我以前的博文

好好学python·函数

敲一敲

汽车:编写一个函数，将一辆汽车的信息存储在一个字典中。这个函数总是接受制造商和型号，还接受任意数量的关键字实参。这样调用这个函数：提供必不可少的信息，以及两个名称—值对，如颜色和选装配件。这个函数必须能够像下面这样进行调用：car = make_car('subaru','outback',color ='blue',tow_package = True)打印返回的字典，确认正确地处理了所有的信息

def make_car(manufacturers,model,**others):car = {}car['制造商'] = manufacturerscar['型号'] = modelfor k,v in others.items():car[k]=vreturn car
car = make_car('subaru','outback',color ='blue',tow_package = True)
print(car)
# 输出结果 ；{'制造商': 'subaru', '型号': 'outback', 'color': 'blue', 'tow_package': True}

函数的优点之一是，使用他们可将代码块与主程序分离，通过函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在称为模块的独立文件中，再将模块导入到主程序中。

下面我们将学习通过import语句如何导入模块

假设我们已经写好了py文件，里面有很多我们已经写好的函数，文件名为pizza.py

def make_pizza():print('制作披萨中')

在我们主程序的文件中，我们就可以直接导入来使用pizza.py中的函数

import pizza
pizza.make_pizza() # 格式：模型名.函数名（参数）
# 输出结果：制作披萨中

我们还可以直接导入模块中的指定函数

from pizza import make_pizza # 格式：from 模型名 import 函数名1，函数名2...
make_pizza()
# 输出结果：制作披萨中

除此之外，我们还可以使用as给导入的模块或者函数换个更简单的名字

import pizza as p
p.make_pizza()from pizza import make_pizza as mp
mp()
# 输出结果：制作披萨中

最后，在编写函数时，需要牢记几个细节。

• 应给函数指定描述性名称，且只使用小写字母和下划线
• 每个函数都应包含简要阐述其功能的注释
• 给形参指定默认值或调用关键字实参时，等号量变不要有空格
• 所有的import语句都应放在文件开头或文件注释后

类

什么是类

面向对象编程是最有效的软件编写方法之一。在面向对象编程中，你编写表示现实世界中的食物和情景类，并基于这些类来创建对象。在编写类时，你定义一大类对象都有的通用行为。基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。通俗地讲，我们把人可作一个类，人的属性有身高，体重，工作等等，那么类也应该包含这些属性。同时，我们具体到一个人，比如张三，张三身高170，体重120，工作是程序员，这便是我们根据类实例化出的对象，同时，张三有超出常人的博士学历。我们就可以在实例化时加上，学历为博士

理解面向对象编程有助于我们向程序员一样看世界，还可以帮助我们真正明白自己编写的代码，了解类背后的概念可培养逻辑思维，让我们能够通过编写程序来解决遇到的几乎任何问题

创建dog类

class Dog(): # 注意在Python中类的首字母都大写'''一次模拟小狗的简单尝试'''def __init__(self,name,age):'''初始化属性name和age'''self.name = nameself.age = agedef sit(self):'''模拟小狗被命令时蹲下'''print(self.name.title()+' is now sitting.'')def roll_over(self):'''模拟小狗被命令时打滚'''print(self.name.title+' rolled over!')

类名应采用驼峰命名法，每个单词首字母大写而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加下划线

类中的函数称为方法，我们前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式

__init__()是一个特殊的方法，每当我们根据Dog类创建新实例，即每创建一个具体的小狗，Python都会自动运行它，在一般情况下，__init__()都会给属性赋值，相当于人生重开模拟器中的一开始点天赋一样，因此又叫做初始化函数。在上述程序中的__init__()里面包含着三个形参，其中形参self是必不可少的，它是一个指向实例本身的引用。通俗地讲，假如我们在路上遇到一个小花狗，我们想把它写入程序，于是我们把小花狗传入我们写好的Dog类，于是self便指代我们传入的小花狗self.name便是指小花狗的名字 在之后的name和age形参，便与我们先前讲过的函数的形参相同

此外Dog类还定义了两个方法：sit（）和roll_over（）。由于这些方法不需要额外的信息，因此只有一个形参self。我们将在后面的学习中创建实例对象能够访问这些方法。当前这两个方法过于简单，作用有限，实际情况中，比如游戏中，我们会加入动画效果的代码来实现小狗的蹲下和打滚儿

下面我们将学习实例化对象

class Dog(): # 注意在Python中类的首字母都大写'''一次模拟小狗的简单尝试'''def __init__(self,name,age):'''初始化属性name和age'''self.name = nameself.age = agedef sit(self):'''模拟小狗被命令时蹲下'''print(self.name.title()+' is now sitting.'')def roll_over(self):'''模拟小狗被命令时打滚'''print(self.name.title+' rolled over!')my_dog = Dog('小花狗'，3) # 实例化对象
print("My dog's name is "+my_dog.name.title()+'.')
my_dog.sit()
'''输出结果
My dog's name is 小花狗.
小花狗 is now sitting.
'''

当我们实例化对象时，实参小花狗和3会调用Dog类中的方法__init__()，初始化函数会帮助我们创建一个表示特定小狗的实例，并使用我们提供的值来设置属性name和age，之后虽然没有写出return语句，Python也会自动返回一个表示这条小狗的实例，储存在我们给的变量my_dog中

创建好对象后，我们可以使用句点访问对象的属性,也可以同时使用我们之前学过的方法，如my_dog.name.title(),此外，我们也可以调用类中的方法my_dog.sit()。我们还可以同时创建多个对象，来满足实际环境的需要

敲一敲

虎年的问候：创建一个名为User的类，其中包含属性name，还有用户简介通常会存储的其他几个属性。在类User中定义一个名为describe_user()的方法，它打印用户信息摘要；再定义一个名为greet_user()的方法，它向用户发出个性化的问候。

class User():def __init__(self,name,age):self.name = nameself.age = agedef describe_user(self):print('姓名:'+self.name)print('年龄:'+str(self.age))def greet_user(self):print(self.name+'祝您虎年大吉')
user = User('亲爱的读者',19)
user.describe_user()
user.greet_user()
'''输出结果：
姓名:亲爱的读者
年龄:19
亲爱的读者祝您虎年大吉
'''

使用类和实例

我们可以使用类来模拟现实世界中的很多情景。类编写好后，大部分时间都将花在使用根据类创建的实例上，而其中一个重要任务是修改实例的属性。我们可以直接修改实例的属性，也可以编写方法以特定的方式进行修改

下面我们编写一个汽车类

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yeardef get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()
my_new_car = Car('上汽通用五菱','新五菱宏光S',2021)
print(my_new_car.get_descriptive_name())
# 输出结果：2021 上汽通用五菱 新五菱宏光S

类中每个属性必须有初始值，但在有些情况下，我们可以在__init__()内指设置默认值，这样就无需再专门为其提供形参了

下面我们为汽车类加上总里程的属性，其中默认值为0。此外，我们换添加了一个名为read_odometer()的方法，用于读取汽车的里程表

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')
my_new_car = Car('上汽通用五菱','新五菱宏光S',2021)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()
'''输出结果：
2021 上汽通用五菱 新五菱宏光S
这车已经走了0里路了
'''

下面我们学习如何修改汽车的里程

我们可以直接修改，虽然这有点傻

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')
my_new_car = Car('上汽通用五菱','新五菱宏光S',2021)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading=23
my_new_car.read_odometer()
'''输出结果：
2021 上汽通用五菱 新五菱宏光S
这车已经走了23里路了
'''

较为常用的是，我们设置能够自动更新属性的方法，比如汽车是根据跑了多少来更新里程表，更贴合实际环境。这样我们无需人为访问属性进行修改，可将值传递给一个方法，由他在内部更新，比如汽车更新里程表一样

我们先加入一个专门更新里程数的方法

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')def update_odometer_reading(self,mileage):# 禁止将里程表读数往回调if mileage>=self.pdpmeter_reading:self.odometer_reading = mileageelse:print('你不能这么做')
my_new_car = Car('上汽通用五菱','新五菱宏光S',2021)
print(my_new_car.get_descriptive_name())
update_odometer_reading(23)
my_new_car.read_odometer()

上述方法，虽与直接修改属性的结果相同，但过程更为安全，更为规范。下面，我们再加入方法，使得属性的值能够递增，来更贴切实际情况

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')def update_odometer_reading(self,mileage):# 禁止将里程表读数往回调if mileage>=self.odometer_reading:self.odometer_reading = mileageelse:print('你不能这么做')def increment_odometer(self,v,t):self.odometer_reading+=v*t
my_new_car = Car('上汽通用五菱','新五菱宏光S',2021)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer_reading(23)
my_new_car.read_odometer()
print('以平均时速60km/h，走了三个小时')
my_new_car.increment_odometer(60,3)
my_new_car.read_odometer()
'''输出结果：
2021 上汽通用五菱 新五菱宏光S
这车已经走了23里路了
以平均时速60km/h，走了三个小时
这车已经走了203里路了
'''

敲一敲

餐馆: 创建一个名为Restaurant的类，其方法__init__()设置两个属性：restaurant_name和cuisine_type。创建一个名为describe_restaurant()的方法和一个名为open_restaurant()的方法，其中前者打印前述两项信息，而后者打印一条消息，指出餐馆正在营业。

• 添加一个名为number_served的属性，并将其默认值设置为0。根据这个类创建一个名为restaurant的实例；打印有多少人在这家餐馆就餐过，然后修改这个值并再次打印它。
• 添加一个名为set_number_served()的方法，它让你能够设置就餐人数。调用这个方法并向它传递一个值，然后再次打印这个值。
• 添加一个名为increment_number_served()的方法，它让你能够将就餐人数递增。调用这个方法并向它传递一个这样的值：你认为这家餐馆每天可能接待的就餐人数。

class Restaurant:def __init__(self,restaurant_name,cuisine_type):self.restaurant_name = restaurant_nameself.cuisine_type = cuisine_typeself.number_served = 0def describe_restaurant(self):print('餐馆名称：'+self.restaurant_name)print('烹饪风味：'+self.cuisine_type)def open_restaurant(self):print(self.restaurant_name+'正在营业！')def set_number_served(self,number):self.number_served = numberdef increment_number_served(self,number):self.number_served+=numberrestaurant = Restaurant('张马大酒店','鲁、川、粤、苏、闽、浙、湘、徽样样精通')
restaurant.describe_restaurant()
print('累计就餐人数'+str(restaurant.number_served))
restaurant.number_served = 111000
print('累计就餐人数'+str(restaurant.number_served))
restaurant.set_number_served(121000)
print('累计就餐人数'+str(restaurant.number_served))
restaurant.increment_number_served(1000)

继承

我们编写类时，并非总是从空白开始写。比如我们想写一个五菱宏光类，我们可以在汽车的基础上做补充，换句话说，让它继承汽车的类。这就相当于汽车类衍生出了五菱宏光类，因此汽车类又叫父类，五菱宏光类称为子类。子类拥有父类的所有属性和方法，也可以有自己的属性和方法。

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')def update_odometer_reading(self,mileage):# 禁止将里程表读数往回调if mileage>=self.odometer_reading:self.odometer_reading = mileageelse:print('你不能这么做')def increment_odometer(self,v,t):self.odometer_reading+=v*t
class ElectricCar(Car):def __init__(self,make,model,year):super().__init__(make,model,year)
my_wuling= ElectricCar('五菱宏光','五菱宏光MINIEV','2021')
print(my_wuling.get_descriptive_name())

继承操作很简单，只需要在创建子类时括号内参数填入父类，在初始化函数内调用super（）函数即可。super（）是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar的父类的方法__init__(),从而让ElectircCar包含父类的所有属性。由于父类也叫做超类，super因此而得名

当孩子继承父亲后，孩子具有父亲所有属性和方法，但不仅仅局限于此，下面我们为电动汽车类添加电瓶容量属性和打印描述电瓶容量信息的方法

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')def update_odometer_reading(self,mileage):# 禁止将里程表读数往回调if mileage>=self.odometer_reading:self.odometer_reading = mileageelse:print('你不能这么做')def increment_odometer(self,v,t):self.odometer_reading+=v*t
class ElectricCar(Car):def __init__(self,make,model,year):super().__init__(make,model,year)self.battery_size = 70def describe_battery(self):print('车还有'+str(self.battery_size)+'度电')
my_wuling= ElectricCar('五菱宏光','五菱宏光MINIEV','2021')
print(my_wuling.get_descriptive_name())
my_wuling.describe_battery()
'''输出结果：
2021 五菱宏光 五菱宏光Miniev
车还有70度电
'''

此外，对于父类的方法，只要它不符合子类的需要，都可以对其进行重写。重写是指在子类中对父类某个方法的代码块进行修改，修改后，子类中的方法与父类原方法的名相同但内容不同。重写后，根据子类实例化的对象在调用该方法时，Python将不会考虑父类方法，而只关注子类中定义的响应方法。

我们在汽车类中加入加满油的方法，因为电动汽车不需要加油，因此我们对其进行重写

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')def update_odometer_reading(self,mileage):# 禁止将里程表读数往回调if mileage>=self.odometer_reading:self.odometer_reading = mileageelse:print('你不能这么做')def increment_odometer(self,v,t):self.odometer_reading+=v*tdef fill_gas_tank(self):print('油加满了')
class ElectricCar(Car):def __init__(self,make,model,year):super().__init__(make,model,year)self.battery_size = 70def describe_battery(self):print('车还有'+str(self.battery_size)+'度电')def fill_gas_tank(self):print('电加满了')
my_wuling= ElectricCar('五菱宏光','五菱宏光MINIEV','2021')
print(my_wuling.get_descriptive_name())
my_wuling.fill_gas_tank()
'''输出结果：
2021 五菱宏光 五菱宏光Miniev
电加满了
'''

我们发现自己给类添加的细节越来越多，代码越来越长，在这种情况下，我们可能需要将类的一部分作为一个独立的类提取出来

下面我们将电动汽车的方法提取出来称为Battery类，成为电动汽车类的一个属性

class Car():def __init__(self,make,model,year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year)+' '+self.make+' '+self.modelreturn long_name.title()def read_odometer(self):print('这车已经走了'+str(self.odometer_reading)+'里路了')def update_odometer_reading(self,mileage):# 禁止将里程表读数往回调if mileage>=self.odometer_reading:self.odometer_reading = mileageelse:print('你不能这么做')def increment_odometer(self,v,t):self.odometer_reading+=v*tdef fill_gas_tank(self):print('油加满了')
class Battery():def describe_battery(self):print('车还有'+str(self.battery_size)+'度电')def fill_gas_tank(self):print('电加满了')
class ElectricCar(Car):def __init__(self,make,model,year):super().__init__(make,model,year)self.battery_size = 70self.battery = Battery()
my_wuling= ElectricCar('五菱宏光','五菱宏光MINIEV','2021')
print(my_wuling.get_descriptive_name())
my_wuling.battery.fill_gas_tank() # 弄清楚谁是谁的就好啦'''输出结果：
2021 五菱宏光 五菱宏光Miniev
电加满了
'''

通过解决上述问题，我们进入了程序员的另一个境界：解决上述问题，我们从较高的逻辑层面来考虑，我们考虑的不是某个列表或者某个循环语句，而是真真正正地去思考怎么用代码来表示实物，来解决实际问题。到达这种境界后，我们会经常发现，现实世界的建模方法并没有对错之分。有些方法效率更高，但找出方法的过程需要经过一定的实践。只要我们的代码像希望的那样运行，就说明我们做的很好！即使我们发现自己不得不多次尝试使用不同的方法来重写类，也不必气馁，要编写出高效、准确的代码，都得经过这样的过程，加油！

敲一敲

冰淇淋小店：冰淇淋小店是一种特殊的餐馆。编写一个名为IceCreamStand的类，让它继承你为完成练习9-1或练习9-4而编写的Restaurant类。这两个版本的Restaurant类都可以，挑选你更喜欢的那个即可。添加一个名为flavors的属性，用于存储一个由各种口味的冰淇淋组成的列表。编写一个显示这些冰淇淋的方法。创建一个IceCreamStand实例，并调用这个方法。

class IceCreamStand(Restaurant):def __init__(self,restaurant_name,cuisine_type):super().__init__(restaurant_name,cuisine_type)self.flavors = []def show_icecream(self):print(self.flavors)def add_icecream(self,*icecream):self.flavors = list(icecream)icecream_shop = IceCreamStand('哈根达斯','冰淇淋')
icecream_shop.add_icecream('香草冰淇淋','抹茶冰淇淋','酸奶冰淇淋')
icecream_shop.show_icecream()
# 输出结果：['香草冰淇淋', '抹茶冰淇淋', '酸奶冰淇淋']

与函数相同，类也可以使用import导入，要注意的是各个文件的命名最好具体，以方便我们导入。通过导入的方式，只需在程序开头包含一条简单的import语句，我们就可以使用其他程序员编写好的模块。

用Python处理文件

接下来我们将学习如何处理文件，让程序能够快速地分析大量的数据，使用起来更加容易

读取文件

我们先创建一个文件夹，里面包含一个python文件和txt文件,在txt文件中写入“祝各位：虎年大吉！”

我们为了学习方便，直接将其放在同一目录下。需要知道的是，如果我们想要对文件进行操作，就需要告诉 Python 文件的准确位置。文件路径有相对路径和绝对路径之分，可以看下这位老哥的文章

绝对路径和相对路径详解

之后，我们便在python文件中编写我们的程序

with open('被处理文件.txt') as file_object:contents = file_object.read()print(contents)
# 输出结果：祝各位看官虎年大吉！

如果出现乱码也不必着急，只需改变编码方式即可。将utf-8修改为ANSI

在上述程序中，以文件名字为参数，open（）函数打开文件并返回该文件对象，我们随后将其储存在file_object变量中。关键字with在程序不需要访问文件后将其关闭。

我们其实也可以用open（）和close（）搭配，但是程序如果有bug，执行不了close（），就可能导致文件数据丢失甚至更严重。因此我们最好使用with关键字，把这个难题丢给Python自己解决。

有了文件对象后，我们使用 read（）函数读取文件全部内容，并将其作为字符串存储在contents中，打印contents就可显示全部内容

我们经常会在文件中查找特定的信息，或者修改文件中的文本，例如我们酒店房间数据中，找到空房间的房间号，所以我们常常需要检查文件每一行

为了学习方便，我们把文件文本写成如下格式

之后我们使用for循环读取每一行

with open('被处理文件.txt') as file_object:for line in file_object:print(line)

我们看到输出结果会感觉很奇怪

为什么中间会有这么多空行呢？这是因为在文本文件中，每行末尾都有一个看不见的换行符，而我们知道print语句也会使输出换行，因此就会有如此多的空白行。去除空白行也很容易，只需加入我们学过的 rstrip（）就好啦

with open('被处理文件.txt') as file_object:for line in file_object:print(line.rstrip())

除此之外，我们还能利用 readlines（）函数来从文件中读取每一行并将其存储在列表中

with open('被处理文件.txt') as file_object:lines = file_object.readlines()print(lines)
# 输出结果：['祝各位看官：\n', '\t\n', '\t虎年大吉！']

通过输出结果，我们能看到换行符

通过学习上面简单操作，我们就可以与先前知识结合起来，比如利用循环语句和判断语句在文件找指定的字等等

敲一敲

Python学习笔记：在文本编辑器中新建一个文件，写几句话来总结一下你至此学到的Python知识，其中每一行都以“In Pythonyou can”打头。将这个文件命名为learning_python.txt，并将其存储到为完成本章练习而编写的程序所在的目录中。编写一个程序，它读取这个文件，并将你所写的内容打印三次：第一次打印时读取整个文件；第二次打印时遍历文件对象；第三次打印时将各行存储在一个列表中，再在with代码块外打印它们。

with open('learning_python.txt') as file_object:# lines = file_object.read()# print(lines)# for line in file_object:#     print(line.rstrip())lines = file_object.readlines()print(lines)

写入文件

保存数据的最简单的方式之一就是写入到文件中。通过将输出写入文件，我们可以在程序运行结束后查看这些输出，也可与别人分享输出文件，还可编写程序来讲这些输出读取到内存中并进行处理。写入文件很简单，只需要注意两点就好啦。

filename = 'Love.txt'
with open(filename,'w') as file_object:file_object.write('I love Python')

在上述示例中，调用open（）函数多了一个参数 'w'，告诉Python，我们要以写入模式打开这个文件。不同的打开模式，有不同的作用效果

参数	名称	效果
‘r’	读取模式	默认，只能读取文件不能修改文件
‘w’	写入模式	若文件不存在创建文件，若文件存在，清空后再写入
‘a’	附加模式	若文件不存在创建文件，若文件存在，在文件末尾写入
‘r+’	能写能读模式	兼有读取模式和写入模式

之后，我们使用write函数来写入内容，就这么简单

敲一敲

调查：编写一个while循环，询问用户你喜欢的明星是谁。将结果存储到文件中。

with open('superstar.txt','a') as file:while True:name = input('您的姓名')superstar = input('您喜欢的明星')file.write(name+':'+superstar+'\n')repeat = input('还有其他人嘛')if repeat = = 'no':break

异常

异常说白了，就是bug。每当Python遇到bug时，会让它不知所措，并它创建一个异常对象。我们可以编写处理异常的编码，告诉Python该怎么做

合理处理异常能够有效避免程序崩溃。要不然，不懂技术的用户会被它们搞糊涂，或者若有用户怀有恶意，通过tarceback获悉你不希望他知道的信息，训练有素的攻击者可根据这些信息判断出对你的代码发起什么样的攻击

处理ZeroDivisionError异常

当我们执行print(5/0)这行代码时我们可以看到

其中ZeroDivisionError是一个异常对象，Python无法按照你要求做时，就会创建这种对象，并停止运行程序，指出引发了哪种异常。而我们可以告诉Python遇到这种情况怎么办

当我们认为可能发生了错误时，可编写一个try-except代码块来处理可能发生的异常

try:print(5/0)
except ZeroDivisionError:print('你不能把0作为除数')
# 输出结果：你不能把0作为除数

上述程序执行顺序为，Python执行try代码块内的代码，如果没错误，将会跳过except代码块，如果有错误会寻找对应错误的except代码块，并运行其中代码。如此，程序就不会因错误而中断

除此之外，如果需要依赖于try代码块成功执行的代码，都需要把他们放到else代码块中。如果没有发生错误，就会执行else代码块中的代码

print('给我两个数字，我们算除法')
print('想退出，就按q')
while True:first_number = input('被除数')if first_number == 'q':breaksecond_number = input('除数')try:answer = int(first_number) / int(second_number)except ZeroDivisionError:print('你不能把0当作除数')else:print(answer)

类似于ZeroDivisionError的异常还有很多，大家可以根据可能的报错内容自行编写

敲一敲

加法运算：提示用户提供数值输入时，常出现的一个问题是，用户提供的是文本而不是数字。在这种情况下，当你尝试将输入转换为整数时，将引发ValueError异常。编写一个程序，提示用户输入两个数字，再将它们相加并打印结果。在用户输入的任何一个值不是数字时都捕获ValueError异常，并打印一条友好的错误消息。对你编写的程序进行测试：先输入两个数字，再输入一些文本而不是数字。

try:print('下面我们进行加法运算')num1 = int(input('输入第一个整数'))num2 = int(input('输入第二个整数'))
except ValueError:print('不好意思，请您确认您输入的是整数')
else:print(num1+num2)

存储数据

很多游戏都有存档的功能，当用户关闭程序时，我们几乎总是要保存他们提供的信息，一种简单的方式是使用模块json来存储数据

模块json能让我们将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。由于JSON数据格式并非Python专有，因此我们不仅可以在Python程序之间分销数据，更重要的是，可以与使用其他编程语言的人分享

下面我们使用 json.dump() 函数将数据存储到json文件中，它一共有两个参数，一个是需要存储的内容，一个是文件对象

import json
numbers = [2,3,5,7,11,13]
filename = 'numbers.json'
with open(filename,'w') as f_obj:json.dump(numbers,f_obj)

而后我们在使用 json.load（）函数将数据加载进程序

import json
filename = 'numbers.json'
with open(filename) as f_obj:numbers = json.load(f_obj)
print(numbers)
# 输出结果：[2,3,5,7,11,13]

保存和读取用户生成的数据

对于用户生成的数据，如果不以某种方式进行存储的话，等程序停止时用户的信息将丢失。

我们看这么一个例子，用户首次运行程序时被提示输入自己的名字，这样再次运行程序时就记住他了

import json
username = input('来着何人')
filename = 'name.json'
with open(filename,'w') as file:json.dump(username,file)print('我们将记住你' + username)

在之后的用户输入中，如果已经存在，就向用户问好，不存在就创建新文件

import json
filename = 'username.json'
try:with open(filename) as file:username = json.load(file)
except FileNotFoundError:username = input('来者何人？')with open(filename,'w') as file:json.dump(username,file)print('OK,我们已经成功记住你了')
else:print('欢迎回来'+username)

上述程序适用于首次登陆单机游戏的操作

对于上述程序，我们还可以进行代码重构，即将部分代码转化为函数，以简化主程序

敲一敲

暗恋的人:编写一个程序，提示用户输入他暗恋的人的名字，并使用json.dump()将这个名字存储到文件中。从文件中读取这个值，并打印消息“I know your lover! She’s _____.”。如果存储了用户喜欢的人，就向用户显示它，否则提示用户输入他喜欢的人并将其存储到文件中。

import json
filename = 'lover.json'
try:with open(filename) as file:lovername = json.load(file)
except FileNotFoundError:lovername = input('偷偷告诉我你爱上了谁')with open(filename,'w') as file:json.dump(lovername,file)print('wow，原来你爱上了她，我记住了')
else:print('我还记得你爱上了谁，但是，你现在还爱吗？')

感谢您能看到最后！希望这篇文章能对您有价值

愿大家在今后的日子里烦恼少一点，直到消失，幸福多一点，直到永远！

我の第一篇万字博文 | 带大家开开心心地进入Python世界相关推荐

1. 一篇万字博文带你入坑爬虫这条不归路 【万字图文】

2. 偶然在回收站中看到《我的第一篇csdn博文》

   原文: 临近期末考.除了c和英语.挂科已成必然. 从进入大学,进入计算机这个专业开始,我才知道自己可以这么专注与一件事.为了一道题的算法 ,可以一通宵不睡觉.可以走路都想着怎么缩减运行的时间.这几天想 ...

3. 36篇博文带你学完opencv :python+opencv进阶版学习笔记目录

   基础版学习笔记传送门 36篇博文带你学完opencv :python3+opencv学习笔记汇总目录(基础版) 进阶版笔记 项目 opencv进阶学习笔记1: 调用摄像头用法大全(打开摄像头,打开摄像 ...

4. 读书/观影-《红箭 红箭》话剧-观后感/我的第一篇的博文

   一.我的第一篇博文 最近忙完研究生调剂的事情,静下心来,也开始构筑我早期想构筑的自己的博客. 1.总结和介绍下我自己 TQ,男,目前考研调剂到一个研究院. 为啥调剂呢?当然是没学好英语啦,英语不过校线 ...

5. 第一篇51博文：思想决定行为。

   这是我在51上面的第一篇文章,我生活经验不足,专业知识欠缺,望各位前辈多多指点.在此谢过. 我今年大二,计算机科学与技术专业. 通过学习计算机科学,我有一点个人体会,关于人生的体会.我们为什么要学习. ...

6. 2019第一篇万字长文！30+家一线投资机构已出投资新策略...

   新年伊始,我们和30多位深谙行业走向的投资人聊了聊,这一年新的投资策略,得到数万字的回复,字字玑珠! 清科集团创始人.董事长 倪正东: 第一,现金流是企业的生死线,要控制成本,控制扩张的速度,一定让自 ...

7. 第一篇技术类博文：Git以及GitHub常用命令记录与总结【Rico】（已完结！）

   Git身为目前世界上最先进的分布式版本控制系统,本菜鸟也是刚刚开始学习,目前上手还是有点难度,记录下来,希望更多的初学者看到,也可以让自己需要用到的适合可以方便的查阅. 1.Git的安装 Git最早使 ...

8. csdn第一篇博文 关于国内互联网发展的感叹（今后望这儿的氛围更好，结识各行各业志趣相投的朋友）

   本人现今是一位大学学生,逛过或者说曾经混迹过各种贴吧/论坛,有过QTCN之类的技术性论坛,也有MAXPDA之类数码产品论坛,也有天涯,百度贴吧. 但是,我觉得都有一个现象,就是过于浮躁了.对于一件事的 ...

9. 【论文写作】-我的第一篇论文形成记(投稿过程、课题来源、python与数学学习、实验设计、论文思路建立与写作、回复审稿人)

   我的第一篇论文形成记 投稿过程 背景记录 课题来源-本科毕业设计 python及数学学习 实验设计 调参阶段 实验阶段 论文思路建立 论文写作 回复审稿人 总结 投稿过程 2022年12月28日 投A ...

最新文章

1. 控制-频域操作-傅里叶级数和傅里叶变换
2. linux /etc/fstab 挂载列表 简介
3. 计算机硬件技术 实验的软件,计算机硬件技术基础软件实验讲义.doc
4. Policy Injection Application Block
5. 【数字逻辑】第四章 组合逻辑电路：端口设计 端口拓展的方法
6. shell之文本过滤（grep）
7. Linux、Mac 命令行快捷键
8. python切片操作 当所有数据都省略时_python疑难问题---13、Python切片操作
9. 短信网关 php,通过ICQ网关发送手机短信的PHP源程序_PHP
10. GetProcAddress()函数动态调用DLL中的函数，是否必须通过extern C声明导出函数？
11. VS调试按钮和运行按钮无法使用
12. Android 使用MotionLayout实现动画效果
13. 关于买鸡的问题,5文钱可以买一只公鸡，3文钱可以买一只母鸡,1文钱可以买3只雏鸡.现在用100文钱买100只鸡，那么各有公鸡、母鸡、雏鸡多少只？
14. AD16弹出错误对话框
15. Graham扫描法求解二维凸包问题
16. SPSS MODELER笔记1----数据基本处理和整体方法概念
17. JsonCpp库遍历
18. openwrt passwall设置_和广告说再见！ADGUARD全客户端设置教程2.0
19. 网友自曝：编程从入门到放弃！方法比选择更重要！
20. 爆款！如何利用知乎引上万流量，我是这样做的！｜实战

热门文章

1. UA MATH571A QE练习 R语言 单因子试验的回归分析
2. ArcGIS空间分析要点学习
3. 图解LanHelper 使用
4. 游戏编程十年总结（下）（转）
5. 《如何阅读一本书》之 阅读的层次
6. TableLayoutPanel
7. java属性编辑器，即PropertyEditor
8. hibernate的一种报错
9. makefile中的include *******
10. Hama笔记：Unable to load native-hadoop library 和 Snappy native library not loaded 的解决