《python 从入门到实践》_笔记（第一章到第八章，未完待续）_python从入门到实践第三版第一章-CSDN博客

本文链接：https://blog.csdn.net/AlanMXC/article/details/128946370

第一章，安装编译器

2022年6月26日, 星期日

9:36

推出编译器操作

1.按住Ctrl +Z 之后按enter键即可关闭对话框

2.执行exit（）命令

这里就直接去网上找教程就行，没啥难度。

第二章，变量和简单数据类型（最基础的东西,学过c后就基本无压力

2.1

运行hello world.py程序

函数 print

print（“Hello world”)

这就是个最简单的函数输出，运行后的得到输出；Hello world

2.2

添加变量（等号左面为变量的名称，等号右面为赋予变量的值）程序中课随时修改变量的值，python始终记录变量的最新值。

2.2.1

变量的命名和使用

关于变量名的一些要求：1.不能用数字打头

2.不能包含空格（可用下划线）

3.不使用python的关键字和函数名

4.简短又有描述性

5.I和O可能会被看错成1和0

6.避免使用大写字母

2.2.2

traceback回溯法

拼写错误——很多程序员天资聪颖、经验丰富，却为找出这种细微的错误花费数小时。

2.3

字符串（引号括起来的都是字符串，可以是单or双引号）

字符串中可以包含引号和撇号（”“，）

2.3.1

title()单词首字母大写的方法

name="ada peace"

print（name.title())

title()首字母大写

lower()全小写

upper()全大写

2.3.2

合并or拼接字符串

合并： first_name+”“+last_name

拼接：“hello,"+first_name.title()+"!")

2.3.3

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

\t 对应的是空格键

\n对应回车键

\n\t 可以让对应的二者的两部操作

2.3.4

删除空白

在所用之后加。rstrip（）是去除末尾的空白。lstrip（）是去除开头的空白。

也可先后使用。

2.3.5

使用字符串避免语法错误（正确使用单引号和双引号）

2.3.6

print语句包含（）但是python2是不包含的

2.4

数字

2.4.1

+ - * /

**乘方（2+3)/4 次序执行

2.4.2

浮点数

0.1+0.1 0.2

2.4.3

str()函数来避免类型错误

message="happy"+str(age)+"rd Birthday!"

str()可以让数值23转化为字符串

2.4.4

计算整数结果时，采取的方式不是四舍五入，而是将小数部分直接删除。

2.5

注释让你能够使用自然语言在程序中添加说明。

2.5.1

如何编写注释

# 标识注释 #后面的内容会被python忽略

2.5.2

写什么样的注释

不要企图编写完美无缺的代码；先编写行之有效的代码，再决定是对其做进一步改进，还是转而去编写新代码。

2.6

python之禅

执行import this 命令可查看

2.7

小结：变量，消除语法和名称错误，字符串，大小写，去除空白，浮点数，注释。

第三章列表简介

3.1

列表

[]来表示列表，并用逗号分隔其中的元素。

eg.

bicycles=['treak','cannodale',redline',secialized']

print(bicycles)

其中bicycles为此列表的名称。

3.1.1

访问列表元素

在列表名称后面加[ ]中为数字，也可使用2.1中的title()使得输出结果更整洁，干净

3.1.2

索引的从0开始，访问列表中的任何元素，都可将其位置减一，并将结果作为索引。

将索引指定为-1，可让python返回最后一个列表元素

索引-2为倒数第二个列表元素（以此类推）

3.1.3

使用列表中的值

可以当作变量来使用

eg.

message="my bicycle was a "+bicycles[-1].title()+"."

3.2

修改，添加和删除元素

3.2.1

修改列表中的元素（任何元素都可修改）

与修改变量的操作一样

3.2.2

1.添加元素append（追加）

在一个列表的最后添加新元素

2.插入元素insert(0,'cook')

将cook这个元素插入到首部，其他元素向右移动

3.2.3

删除元素

1.使用del语句（del names[1] 把位置2的元素删去）

在删除列表的名称前加 del

3.1

列表

[]来表示列表，并用逗号分隔其中的元素。

eg.

bicycles=['treak','cannodale',redline',secialized']

print(bicycles)

其中bicycles为此列表的名称。

3.1.1

访问列表元素

在列表名称后面加[ ]中为数字，也可使用2.1中的title()使得输出结果更整洁，干净

3.1.2

索引的从0开始，访问列表中的任何元素，都可将其位置减一，并将结果作为索引。

将索引指定为-1，可让python返回最后一个列表元素

索引-2为倒数第二个列表元素（以此类推）

3.1.3

使用列表中的值

可以当作变量来使用

eg.

message="my bicycle was a "+bicycles[-1].title()+"."

3.2

修改，添加和删除元素

3.2.1

修改列表中的元素（任何元素都可修改）

与修改变量的操作一样用 = 来修改

eg.

mount[0]="app"

把列表mount中第一个元素修改为app

3.2.2

1.添加元素append（追加）

在一个列表的最后添加新元素

2.插入元素insert(0,'cook')

将cook这个元素插入到首部，其他元素向右移动

3.2.3

删除元素

1.使用del语句（del names[1] 把位置2的元素删去）

在删除列表的名称前加 del

删除值后，就再也无法访问

2.方法 pop() 删除列表中最后一个元素

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

当使用pop()时，被弹出的元素就不在列表中了

pop()可以在括号中指出所删除元素的索引即可

tips：

使用del语句是将此元素彻底删除且不再以任何方式使用此元素。

使用pop() 可以继续使用此元素。

根据值删除元素

remove()可在括号中输出所删的值

eg.

mount.remove('evil')

在mount这个列表里把其中evil这一元素删除。

在使用remove()删除后

warning：方法remove()只删除第一个指定的值。如果要删除的值在列表中出现多次，就使用循环来判断是否删除了所有这样的值。

3.3

组织列表

以特定的顺序呈现信息

3.3.1

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

eg.

cars.sort()

对列表cars进行字母顺序排列（列表中元素全为小写）

向方法sort()传递参数 reverse=true 即可反向排序

3.3.2

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

eg.

sorted（cars）

对列表cars进行临时排列

3.3.3

倒着打印列表

可使用方法reverse() 只是反转列表元素的排列顺序

eg.

mount.reverse()

对mount列表进行反转

3.3.4

确定列表的长度

使用方法len()可以快速获悉列表的长度。

想要显示长度要用print ： print(len(mount))

warning： Python计算列表元素素从1开始。

3.4

使用列表时避免索引错误

当要访问列表的最后一个元素时，可使用-1.

warning 发生索引错误时：把列表或其长度打印出来，对比与自己认为的是否一样。

3.5

列表是什么，如何定义列表以及如何增删元素，对列表中的元素进行（永久，临时）排序，确定列表长度，避免索引错误。

第四章操作列表

4.1 遍历整个列表

对每个元素执行相同的操作，可使用for循环

eg.

smartions=['jack_luo','jack_ma')

for smartion in smartions:

print(smartion)

将列表smartions取出一个元素存储在变量smartuon中，打印出来，重复执行则全部打印出来

4.1.1

深入地研究循环

自动的完成重复工作的方式之一。对于列表中的每个元素，都将执行循环指定的步骤。

可以使用单复数名称来帮助判断代码处理的单个列表元素还是整个列表。

4.1.2

在for循环中执行更多的步骤

for egg in eggs:

print (egg.title()+",that was a great trick!")

以上步骤即重复打印从eggs列表中的元素，先将eggs列表中的每个元素都赋值与egg这变量后打印出来。

4.1.3

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

需要将相应的代码放在for循环后面，且不缩进.

4.2

避免错误

比如忘记缩进

4.2.1

忘记缩进

位于for语句后面且属于循环组成部分的代码行，一定要缩进。

将紧跟在for语句后面的代码行缩进，可以消除这种缩进错误。

4.2.2

忘记缩进额外的代码行

4.23

缩进了无需缩进的代码行

4.2.4

缩进了应在循环结束后执行的代码

4.2.5

遗漏了冒号：

eg. 正确的循环格式

for magician in magicians：

print（magican）

4.3

创建数值列表

存储一组数字

4.3.1

使用函数range()

使用函数range可以生成一系列数字。

如果输出不符合预期，可以将指定的值加1或减1

eg.

for value in range(1,4):

print(value)

打印出来的值为1，2，3。并不包含4

4.3.2

使用range()创建数字列表

创建1到5这五个数的方法

numbers=list(range(1,6)

甚至可以只打印1-5内的偶数

numbers=list(range(1,6,2)

上面的代码行是从2开始不断加2直到达到或超过终值6

** 两个星号代表乘方运算。

如何将十个整数的平方加入到一个列表中

squares=[]

for value in range(1,11):

square=value**2

square.append(square)

print(squares)

以上操作将1-10中的每个整数进行平方后加入到列表squares中

也可简化，不使用临时变量square

squares.append(value**2)

4.3.3

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

min(digits)是找出列表digits中最小的数字

max(digits)—————————最大——

sum(digits)合计列表中的各个数字的总和

4.3.4

列表解析

只需编写一行代码就能生成。

eg.

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

print(squares)

首先指定一个描述性的列表名，squares，并定义一个表达式来生成存储到列表中的值。

squares列表，表达式value**2,for循环来给表达式提供值。注意，此处for循环没有冒号。

eg.

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

print(squares)

将列表squares 中的元素打印出来

2的立方表示为 2**3

2的平方表示为 2**2

4.4

使用列表的一部分

处理列表的部分元素——称之为切片

4.4.1

索引列表里的0-3项元素可以进行以下操作

print（players[0:3])

打印出名为players列表中的0到3的元素

如打印3-7的列表元素将[0:3]替换为[3:7]

4.4.2

遍历切片

在for循环中使用切片即可。

eg.

for player in players[:3]:

print(player.title())

以上操作将前三位球员的名字以大写首字母的形式打印出来。

4.4.3

复制列表

可创建一个包含整个列表的切片，同时省略起始索引和终止索引[:]

如果进行添加元素可使用list_name.append('element')

friend_foods=my_foods[:]

my_foods的副本存储到friend_foods

eg.

for pizza in pizzas[:]:

print(pizza)

从pizzas的列表里逐次赋予变量pizza的新值后，打印出来，直到pizzas列表数值打印完成。

4.5

元组

不可变的列表称之为元组。（创建一系列不可修改的元素）

不能修改的值称为不可变的。

4.5.1

定义元组

修改元组的操作是被禁止的，因此不能给元组的元素赋值。

4.5.3

修改元组的变量

可以给存储元组的变量赋值。如果要修改，可重新定义整个元组

eg.

mcds=('good','bad','terrifc')

创建了一个名为mcds的元组，其中三个元素无法进行变量赋值修改，除非重新定义整个元组。

4.6

设置代码格式

遵循一些格式设置指南

4.6.1

格式设置指南

PEP 8 中编码结构

python enhancement proposal

以易于阅读为先

4.6.2

缩进

PEP8 建议每级都缩进都使用4个空格。

不要混用制表符和空格

4.6.3

行长

建议每行不超过80字符，编译器会显示一条垂直的参考线。

4.6.4

空行

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

Python解释器根据水平缩进情况来解读代码，不关心垂直间距

4.6.5

其他格式设置指南

等介绍更复杂的Python结构时，我们再来分享相关的PEP 8指南。

4.7

小结

for循环遍历列表，避免缩进错误，创建简单的数字列表以及执行一些操作，通过切片来使用列表的一部分和复制列表，元组，设置格式。

如果只要执行一个代码块，就用if-elif-else 结构；如果要运行多个代码块就使用一系列独立的if语句。

第五章 if 语句

5.1

一个简单的示例

eg.

cars=['audi','bmw','subaru']

for car in cars:

if car == 'bmw':

print(car.upper())

else:

print(car.title())

5.2 条件测试

if语句的核心都是一个值为True或False的表达式，这种表达式称之为条件测试。

5.2.1

检查是否相等

= 一个等号是陈述

== 两个等号是发问

eg.

car='audi' 这是赋予car这一变量的值

car=='audi' 这是检查car这一变量的值是否为audi

5.2.2

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

两个大小写不同的值会被视为不相等

但如果大小写无关紧要可以将变量的值转为小写后进行比较

car.lower()=='audi'

函数lower（）不会修改存储在变量car中的值，

5.2.3

检查是否不相等

pet='dog'

if pet !='cat':

print ("hello")

首先变量pet的值为dog，接下来利用if语句，如果变量pet的值不等于cat则执行紧跟在if语句后面的代码。

5.2.4

比较数字

answer==1

answer !=1

age<1

age<=1

age>1

age>=1

5.2.5

检查多个条件

and、or

1.使用and检查多个条件

eg.

age_0>=21 and age_1>=21

当两个变量age_0和age_1成立时才为True

（age_0>=21)and (age_1>=21)

2.使用or 检查多个条件

至少有一个条件满足，就能通过整个测试。当两个测试都没通过时，使用or的表达式才为False。

5.2.6

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

使用关键字in

eg.

'dog' in pet

dog是否在列表pet中

5.2.7

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

关键字not in

eg.

if user not in banned_users:

print(user.title()+", you can post a response if you wish.")

5.2.8

布尔表达式

条件测试的别名，布尔值常用于记录条件。

布尔值用于跟踪程序状态或程序中重要的条件。

5.3

if语句

选择使用哪种if语句取决于要测试的条件数。

5.3.1

简单的if语句，只有一个测试和一个操作

eg.

age=19

if age>=18:

print("you are old enough to vote!")

print("have you registered to vote yet?)

符合条件if语句后面缩进的代码行将会执行。。

5.3.2

if-else语句

eg.

age = 9

if age >= 18:

print("You are old enough to vote!")

print("have you registered to vote yet?")

else:

print("sorry,you are too young to vote.")

5.3.3

if-elif-else结构

考虑的情形超过两个。

5.3.4

可使用多个elif代码块

5.3.5

可省略else代码块

else语句，只要不满足任何if或elif中的测试，就会执行其中的代码。

5.3.6

测试多个条件

将if语句连续使用即可。

5.4

使用if语句处理列表

5.4.1

检查特殊元素

先使用for语句将列表中的各个元素打印出来

可在for语句中添加if语句

5.4.2

确定列表不是空的

在运行for循环前确定列表是否为空很重要。

eg.

if requested_toppins:

for requested_topping in requested_toppings:

print("Adding"+ requested_topping+".")

print('\nFinished making your pizza!")

else:

print("Are you sure you want a plain pizza?")

在以上操作中，if 后的列表如果存在元素则会执行for循环，如果没有则会运行else后的代码行，在此例中为打印出Are you sure you want a plain pizza?

5.4.3

使用多个列表

检查顾客列表中是否为提供列表中的。

5.5

设置if语句的格式

建议在== >= <= 等这类符号左右添加空格，让代码更易读。

5.6 小结

条件测试，if语句，if-elif-else语句，for语句，代码格式

第六章字典（有点绕，但不难）

6.1

一个简单的字典

具体格式如下

alien_0 = {'color':'green','points':5}

创建了一个名为alien_0 的字典，其包括 color和points两个元素，在之后可被以

print(alien_0['color']) 的方式打印出来其元素的值。

：分号前的称为键后面的称为值

6.2

使用字典

可使用打印或者是新设置一个变量将字典中的值赋予这个变量。

6.2.1

访问字典中的值

emmm与访问列表中的值大同小异

6.2.2 添加键——值对

可随时在字典中添加键值对

eg.

alien_0['x'] = 0

以上操作在字典alien_0 中加入一个键值对 x=0

当值为数字是加与不加引号是相同的结果

6.2.3

先创建一个空字典

alien_0 = {}

6.2.4 修改字典中的值

用新的值来赋值旧的值

eg.

alien['color'] = 'yellow'

将字典alien中color的值修改为yellow

6.2.5

删除键值对

可使用del语句对其键值对彻底删除

6.2.6

由类似对象组成的字典

可以进行任意变量的的存储

eg.

languages = {

'tim' : 'python'

}

注意格式: 把右大括号放在最后一个键值对下面并与键对齐

6.3

遍历字典

可遍历字典的所有键值对，键or值

eg.

user={

'user_name':'efermi'

'first':'enrico'

}

for key,value in user.items():

print("\nKey:"+key)

print("value:"+value)

6.3.1

遍历所有的键值对

使用for循环

eg.

favorite_language = {

'jen':'python'

'tim':'c'

}

for name,language in favorite_language.items():

print(name.title()+" 's favorite language is "+ language.title()+".")

在for循环中不断将字典中的键值对打印出来。

6.3.2

遍历字典中的所有键

使用方法key()

eg.

for name in favorite.keys():

print(name.title())

将名为favorite的字典中所有键打印出来。

6.3.3

按顺序遍历字典中的所有键

使用函数sorted() 来获取特定顺序排列的键列表的副本。

6.3.4

遍历字典中所有的值

使用方法values()

eg.

for language in favorite.values():

print(language.title())

将favorite字典中的所有值打印出来，其中创建了一个新的变量language并将从字典favorite中提取出的值赋予这个变量后打印出来。

剔除重复元素可使用set（集合）

eg.

for language in set(favorite_language.values()):

print(language.title())

其中set()可以剔除字典favorite_language中的重复元素。

6.4

嵌套

将字典，列表二者互相存储称为嵌套。

6.4.1

字典列表

创建一个外星人列表，其中每个外星人都是一个字典。

eg.

aliens =[]

for alien_number in range (0,30):

new_alien = {'color':'green','points':5,'speed':'slow'}

aliens.append(new_alien)

将30个相同参数的alien加入到aliens这个字典。

6.4.2

在字典中存储列表

直接在字典里输入多个列表

eg.

languages ={

'jen':['python','tuby']

'sarah':['c']

}

字典languages中有两个列表jen和sarah。

6.4.3

在字典中存储字典

eg.

user = {

'jack':{

'first':'jack'

'last':'steve'

}

在字典user中创建了名为jack的字典

6.5

小结

如何定义字典，使用存储在字典中的信息，访问和修改字典中的元素，遍历字典中的所有信息，遍历键值对，列表和字典的嵌套

第七章用户输入和while循环

7.1

函数input（）的工作原理

input（）让程序暂停运行，等待用户输入一些文本后，python将其存储在一个变量中。

eg.

message = input('write something:')

print(message)

将用户输入的文本存储在message这个变量中后，用函数print打印出来。

7.1.1

编写清晰的程序

使用函数input（），指定清晰而易于明白。

prompt = "tell us"

prompt +="please"

name = input（prompt）

print（"\nhello,"+name+"!")

以上操作可输出两行提示

7.1.2

使用int（）来获取数值输入解读为字符串。

若将输入的数字字符串转换为数值则使用int（）对其变量重新赋值

可用来if语句中的是否符合身高条件

age = int(age)

7.1.3

求模运算符

它将两个数相除并返回余数

可以用来判断一个数的奇偶性

eg.

if number % 2 ==0:

print(\nthe number "+str(number)+" is even.")

else:

print(\nthe number "+str(number)+" is odd.")

even偶数 odd奇数

7.1.4

在python2.7中获取输入

raw_input() 与 input()

如果使用的是2.7要使用raw_input()而不是input()

7.2

while循环简介

与for循环不同，while循环不断地运行直到指定条件不满足为止。

7.2.1

使用while循环

eg.

current_number = 1

while current_number <= 5:

print(current_number)

current_number += 1

直到 current_number等于5时，此while循环结束。

7.2.2

让用户选择何时退出

while message != 'quit':

message = input(prompt)

print(message)

当用户输入quit时此while循环结束

7.2.3

使用标志

在要求很多条件都满足才能运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量称之为标志。

在进入while循环前设置一个变量

active = true

while active:

message = input(prompt)

if message == 'quit'

active = false

else:

print(message)

设置一个标志名为active 且设置成true 当用户输入quit将此标志设置成false，则while循环结束。

7.2.4

使用break退出循环

if city == 'quit'

break

else：

print("I'd love to go to"+city.title()+"!"）

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

7.2.5

在循环中使用continue

返回循环开头，并根据条件测试结果来决定是否继续执行循环。

可在if语句中使用

if current_number % 2 == 0:

continue

如果这个数除于而的余数是零则继续所在的循环。

7.2.6

避免无限循环

每个while循环必须有停止运行的途径

确认程序至少有一个能让循环条件为false或让break语句得以执行。

可按ctrl + C 来关闭程序输出的终端窗口

7.3

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

将while循环于字典和列表结合起来使用，可收集，存储并组织大量输入，供以查看和显示。

7.3.1

在列表之间移动元素

eg.

while unconfirmed_users:

current_user = unconfirmed_users.pop()

print("verifying user :" + current_user.title())

confirmed_users.append(current_user)

把列表uncomfirmed_users中的元素取出赋值current_user这个变量后将这个变量加到confirmed_users列表。

7.3.2

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

使用while循环直到pets列表里没有dog

while 'dog' in pets:

pets.remove('dog')

7.3.3

使用用户输入来填充字典

response = input('which mountain would you like to climb someday?')

responses[name] = response

将用户的输入赋值于 response后，以response为介质将其值赋值于responses字典中的键name。

7.4

小结

input()来让用户提供信息，处理文本和数字输入，while循环，多种控制while循环的方式，

设置活动标志，break语句和continue语句，用while在列表之间移动元素，从列表中删除包含特定值的元素，结合使用while循环和字典。

第八章函数（很重要，类似与java中的方法

8.1

定义函数

eg.

def greet_user():

print('hello')

定义define了一个名为greet_user()的函数主要操作为打印hello，可直接调用

8.1.1

向函数传递信息

可在定义函数的（）内添加username

eg.

def greet_user(username):

print('hello, '+username.title()+'!')

这让函数可以接受你给username任意值。

greet_user('jack')

这时候username 的值为jack

8.1.2

实参和形参

在greet_user(username)函数的定义中，变量username是一个形参。(形式（假）参数）

而在调用的时候，greet_user('jack') 中jack是一个实参。（实际用的参数）

warning 形参和实参容易混淆。

8.2.1

传递实参

函数定义中可能包含多个实参，调用也可能包含多个实参。

向函数传递实参的方式很多。参看下文

8.2.1

位置实参

基于实参的顺序来与形参进行关联。

eg.

def describe_pet(animal_type, pet_name):

print("\nI have a " + animal_type + "'s name is " + pet_name.title() + ".")

descri_pet('dog','harry')

animal_type这个形参对应dog这个实参

pet_name这个形参对应harry这个实参

8.2.2

关键字实参

传递函数的名称——值对。直接在实参中将名称和值关联起来，因此向函数传递实参是不会混淆的。不需考虑实参顺序。

eg.

describe_pet(animal_type = 'hamster',pet_name='harry')

这种方式来调用函数。

warning 使用关键字实参时，必须准确的指定函数定义中的形参名称。

8.2.3

默认值

编写函数时可给每个形参指定默认值。给形参指定默认值后，可在函数调用中省略相应的实参。

eg.

def describe_pet(pet_name,animal_type='dog'):

print("\nI have a "+animal_type+".")

其中如果在引用describe_pet 这个函数时如果不给animal_type一个实参。它将会以dog为实参来使用。

如果给animal_type 提供实参则会以提供的运行。

warning 使用默认值时，在形参列表中必须先列出没有默认值的形参，在列出有默认值的实参。

8.2.4

等效的函数调用

通常有多种等效的函数调用方式。（可混合使用位置实参，关键字实参和默认值）

escribe_pet('jack') 位置实参和默认值实参

describe_pet(pet_name='jack')关键字实参

describe_pet('harry','hamster')位置实参

describe_pet(pet_name='harry', animal_type='hamster')关键字实参

describe_pet(animal_type = 'hamster',pet_name = 'harry')关键字实参

warning 使用对于自己来说最顺手的来调用。

8.2.5

避免实参错误

当遇到实参不匹配的时候，冷静！

在运行后traceback会指出问题出在什么地方。

8.3

返回值

函数返回的值称之为返回值。可使用return语句将值返回到调用函数的代码行。

8.3.1

返回简单值

eg.

def get_formatted_name(first_name,last_name):

full_name = first_name + ' ' +last_name

return full_name.title()

在输入名和姓两个实参后会返回一个人名。

8.3.2

让实参变成可选的

可使用默认值来让实参变成可选的。

eg.

def get_formatted_name(first_name,middle_name,last_name=""):

if middle_name:

full_name = first_name + ' '+middle_name+' ' +last_name

else:

full_name =first_name +' '+last_name

return full_name.title()

8.3.3

返回字典

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

eg.

def build_person(first_name, last_name,age=''):

person = {'frist': first_name, 'last':last_name}

if age:

person['age'] = age

return(person)

age是一个可选形参，如果函数调用中包含这个形参的值，这个值将存储到字典中。

8.3.4

结合使用函数和while循环

定义函数后，在一个while循环中使用

eg.

def get_formatted_name(frist_name,last_name):

full_name = frist_name +' ' +last_name

return full_name.title()

while True:

print('\nPlease tell my your name:')

print("(enter 'q' at any time to qiut)")

f_name = input('first name:')

if f_name == 'q':

break

l_name = input('last name:')

if l_name == 'q':

break

formatted_name = get_formatted_name(f_name, l_name)

print('\nHello, '+formatted_name+'!')

8.4

传递列表

将列表传递给函数。

eg.

def greet_users(names):

for name in names:

msg = "hello, " + name.title()+"!"

print(msg)

usernames = ['hannah','try','magrot']

greet_users(usernames)

将usernames这个列表用函数greet_users处理了

8.4.1

在函数中修改列表

在函数中对这个列表所做的任何修改都是永久性的。

8.4.2

禁止函数修改列表

可向函数传递列表的副本而不是原件。

eg.

print_models(unprinted_designs[:], completed_models)

函数print_models调用unprinted_designs列表时为它的副本。在使用此函数后，仍然可以打印出它的列表本体。

8.5

传递任意数量的实参

在定义函数时，将形参调整为*toppings 即在形参名加*，这是创建了一个名为toppings的空元组。

eg.

def make_pizza(*toppings):

print('\nMaking a pizza with the following toppings:')

for topping in toppings:

print("."+topping)

make_pizza('pepperoni')

make_pizza('mushrooms','green peppers','extra chees')

8.5.1

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

让函数接受不同类型的实参，在函数定义中，将接纳任意数量实参的形参放在最后。

先位置实参，关键字实参，再将剩下的实参都收集到最后一个形参中。

eg.

def make_pizza(size, *toppings):

*toppings这个放到最后。

8.5.2

使用任意数量的关键字实参

将函数编写成能够接受任意数量的键值对。

**user_info 创建一个空字典为形参。

8.6

将函数存储在模块中

将函数存储在模块的独立文件后再将模块导入到主程序中。

import语句允许在当前运行的程序文件中使用模块中的代码。

8.6.1

导入整个模块

将函数保存到后缀为py 且于主程序在同一文件夹

在新的程序开头使用import语句

eg.

import pizza

pizza.make_pizza(16,'pepperoni')

8.6.2

导入特定的函数

导入模块中的特定函数。

eg.

from pizza import make_hotdog

从pizza这个模块中导入make_hotdog这个函数

函数间用，逗号隔开

from pizza import make_hotdog

一个模块中的函数，如果要使用要准确导入。

8.6.3

使用as给函数指定别名

给导入的函数一个特殊外号。

eg.

from pizza import make_pizza as mp

这里将make_pizza函数重命名为mp

8.6.4

使用as给模块指定别名

import pizza as p

将模块pizza指定别名为 p

8.6.5

导入模块中的所有函数

使用*星号

eg.

from pizza import *

这样会将模块pizza中的每个函数都复制到这个程序文件中。

不要轻易使用此方法导入别人写的模块！

8.7

函数编写指南

函数要用描述性名称且只使用小写字母和下划线（包含简要地阐述其功能的注释）

给形参指定默认值和函数调用中的关键字实参时等号两边不要有空格

def function_name(parameter_0, parameter_1='default value')

function_name(value_0, parameter_1='value')

import语句应当放到文件开头，除非在文件开头使用注释来描述整个程序

8.8

小结

如何编写函数，传递实参，让函数能够访问完成其工作所需的信息，如何使用位置实参和关键字实参，如何接受任意数量的实参，显示输出的函数，返回值的函数，如何将函数存储在称为模块的独立文件中，

第九章类

9.1

创建和使用类

使用类几乎可以模拟任何东西。接下来将编写dog这个类

9.1.1

创建Dog类

python中首字母大写的名称为类。

eg.

class Dog():

类中的函数称之为方法且方法的名称左右应用下划线（避免与python中默认方法冲突），

每个与类相关联的方法调用都自动传递实参self，所以必须在方法定义中包含形参self，

通过实参向Dog（）传递名字和年龄，self会自动传递因此不需要传递它。只需给除self之外的实参。

以self为前缀的变量都可供类中的所有方法使用。

可通过实例访问的变量称为属性

如何设置属性

eg.

self.age = age

python2.7中创建类需细微的修改，在括号内包含单词object

eg.

class ClassName(object):

9.1.2

根据类创建实例

可将类视为有关如何创建特定小狗说明

小写的名称指的是根据类创建的实例。

访问属性，可使用句点表示法，

在要访问的类中找到实例在其后面用.和名字来获取属性。

eg.

my_dog.name

将my_dog这个实例中的属性name

调用方法

根据Dog类创建实例后，就可以使用句点法来调用Dog类中定义的任何方法

创建多个实例

my_dog = Dog('willie', 6)

your_dog = Dog('lucy', 3)

print("My dog's name is " + my_dog.name.title() + ".") print("My dog is " + str(my_dog.age) + " years old.") my_dog.sit() print("\nYour dog's name is " + your_dog.name.title() + ".") print("Your dog is " + str(your_dog.age) + " years old.") your_dog.sit()

其中Dog（）这个类在开头省略了。运行时要写出来

9.2

使用类和实例。

修改实列的属性也可以编写方法以特定的方式进行修改。

9.2.1

car 类

将方法的第一个形参设未self。

eg.

class Car():

"""Simple test of a simulation car"""

def __init__(self,make,model,year):

#Initialize the attribute of the car#