Python基础教程

Python基础教程

第一章：基础知识

1.获取用户的输入;input()

2.幂运算：**；pow(x,y[,z])返回x的y次方对Z求模的结果

abs()计算绝对值

round() 将浮点数圆整为与之最接近的数

cmath.sqrt()计算平方根,可用于负数

math.sqrt()计算平方根,不可用于负数

bytes(string,encoding[, errors])对指定的字符串进行编码，并以指定的方式处理错误

math.ceil() 以浮点数的方式返回向上圆整的结果

math.floor() 以浮点数的方式返回向下圆整的结果

repr(number) 返回指定值得字符串表示

str() 将值得的值转换为字符串。用于转换bytes时，可指定编码和错误处理方式。

len() 返回序列包含的元素的个数

min() 返回序列中最小的元素

max() 返回序列中国最大的元素

#：注释

/ 对引号进行转义

\n换行符

’‘’ ’‘’ ：三引号表示很长的字符串（跨越多行的字符串）。常规字符串有可以跨越多行，只要在末尾加上反斜杠

原始字符串：r(原始字符串不能以单个反斜杠结尾)

例：>>>print(r’c:\Windows’)
c:\Windows

print(r’c:\Windows.filrs \frond\bar’)

​ c:\Windows.filrs \frond\bar

第二章：列表和元组

2.1

序列：列表，元组，

1.列表：

用列表来表示：所有元素都放在方括号内，并用逗号隔开

一个大仓库，你可以随时往里边添加和删除任何东西。

元组：

封闭的列表，一旦定义，就不可改变（不能添加、删除或修改）。

2.2

适用于所有序列的操作：索引，切片，相加，相乘，和成员资格检查。

索引:

>>>greeting = ‘hello’

greeting[0]
‘h’

1.字符串就是有字符组成的序列，索引0指向第一个元素。（python中没有专门表示字符的类型，因此一个字符就是只包含一个元素的字符串）

2.负数索引：从右开始往左数，因此-1是最后一个元素的位置。

切片

>>>numbers = [1,2,3,4,5,6,7,8,9,10]

numbers[7:10]
[8, 9, 10]

1.第一个索引指定的元素包含在切片里，但第二个索引指定的元素不包含在切片里。

numbers[-3，-1]

[8, 9]

2.从列表末尾开始数，可以用负数索引

numbers[-3，0]

[]

3.如果第一个索引指定的元素位于第二个索引指定的元素后面，结果就为空序列。

numbers[-3，]

[8, 9, 10]

4.如果切片结束于序列末尾，可省略第二个索引。

numbers[:,3]

[1,2,3]

5.如果切片开始于序列开头，可省略第一个索引。

numbers[:]

[1,2,3,4,5,6,7,8,9,10]

6.复制整个序列

numbers[0:10:2] (2:步长，意味着从起点到终点每隔一个元素提取一个元素)

[1,3,5,7,9]

7.* 特殊的两种

像这两种情况：步长为正数时，它从起点移到终点，而步长为负数时，它从终点移到起点

number[5::-2]

[6,4,2]

number[:5:-2]

[10,8]

序列可相加：不能拼接不同类型的序列

[1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]

‘hello’+‘worid’
‘helloworid’

[1,2,3]+‘hello’
Traceback (most recent call last):
File “<pyshell#2>”, line 1, in
[1,2,3]+‘hello’
TypeError: can only concatenate list (not “str”) to list

乘法：将序列与数相乘时，将重复这个序列x次来创建新序列

‘pyhthon’*5
‘pyhthonpyhthonpyhthonpyhthonpyhthon’

成员资格：运算符in，检查是否满足指定的条件，并返回相应的值：满足时返回true,不满足时返回false

permissions = ‘rw’

‘w’ in permissions
True
‘x’ in permissions
False

2.3 列表：一个大仓库，你可以随时往里边添加和删除任何东西。所以列表是可以修改的

list() 使用字符串来创造列表

list(‘hello’)
[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]

1.修改列表：给元素赋值（不能给不存在的元素赋值）

x = [1,1,1]

x[1] = 2 -------给特定位置的元素赋值
x
[1, 2, 1]

2.删除元素：del

names = [‘hello’,‘tian’,‘jian’,‘zhen’]

del names[2] ------删除特定位置的元素
names
[‘hello’, ‘tian’, ‘zhen’]

3.给切片赋值

name = list (‘perl’)

name
[‘p’, ‘e’, ‘r’, ‘l’]
name[2:]=list(‘ar’)
name
[‘p’, ‘e’, ‘a’, ‘r’]

4.列表方法

append:用于将一个对象附加到列表末尾

st = [1,2,3,4]

lst.append(4)
lst
[1, 2, 3, 4, 4]

clear:就地清空列表的内容

st = [1,2,3,4]

lst.clear()
lst
[]

copy:复制列表

b = a.copy()

b[1] = 4
a
[1, 2, 3]
b
[1, 4, 3]

count:计算指定的元素在列表中出现了多少次

[‘to’,‘be’,‘or’,‘not’,‘to’,‘be’].count(‘to’)
2

x = [[1,2],1,1,[2,1,[1,2]]]
x.count(1)
2
x.count([1,2])
1

extend；将多个值附加到列表末尾

a = [1,2,3]

b = [4,5,6]
a.extend(b)
a
[1, 2, 3, 4, 5, 6]

index:在列表中查找指定值第一次出现的索引

knights = [‘we’,‘are’,‘the’,‘knights’,‘who’,‘say’,‘ni’]

knights.index(‘who’)
4

insert：用于将一个对象插入列表

numbers = [1,2,3,4,5,6,7]

numbers.insert(3,‘four’)
numbers
[1, 2, 3, ‘four’, 4, 5, 6, 7]

pop：从列表中删除一个元素（末尾为最后一个元素），并返回这个元素。----是唯一既修改列表有返回非None的值得列表方法。----pop可实现一种常见的数据结构–栈（先进后出）

x = [1,2,3]

x.pop()
3
x
[1, 2]
x.pop(0)
1
x
[2]

remove:用于删除第一个为指定值得元素(就地修改且不返回值)

x = [‘to’,‘be’,‘or’,‘not’,‘to’,‘be’]

x.remove(‘be’)
x
[‘to’, ‘or’, ‘not’, ‘to’, ‘be’]

reverse:按相反的顺序排列列表中的元素

x = [1,2,3]

x.reverse()
x
[3, 2, 1]

reversed；按相反的顺序迭代序列，不返回列表，而是返回一个迭代器

x = [1,2,3]

list(reversed(x))
[3, 2, 1]

sort:对列表就地排序（就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本）

x = [4,6,2,1,7,9]

x.sort()
x
[1, 2, 4, 6, 7, 9]

高级排序：方法sort接受两个可选参数：key和reverse

要根据长度对元素进行排序，可将参数key设置为函数len

x = [‘aardvark’,‘balone’,‘acme’,‘add’,‘aerate’]

x.sort(key=len)
x
[‘add’, ‘acme’, ‘balone’, ‘aerate’, ‘aardvark’]

对于reverse,只需将其指定为一个真值（True或False）以指出是否要按相反的顺序对列表进行排序

x = [4,6,2,1,7,9]

x.sort(reverse=True)
x
[9, 7, 6, 4, 2, 1]

2.4元组：封闭的列表，一旦定义，就不可改变（不能添加、删除或修改）----只要将一些值用逗号分隔，就能自动创建一个元组

tuple() 将一个序列作为参数，并将其转换为元组。如果参数是元组，就原封不动的返回它。

tuple([1,2,3])
(1, 2, 3)

tuple(‘abc’)
(‘a’, ‘b’, ‘c’)

tuple((1,2,3))
(1, 2, 3)

第三章：使用字符串

-----------------------------字符串是不可变的

format = "hello,%s.%senough for ya?"

values = ('world','hot')
format % values
'hello,world.hotenough for ya?'

%s称为转换说明符，指出了药将值插入什么地方。s意味着将值视为字符串进行格式设置

字段名：索引或标识符，指出要设置哪个值得格式并使用结果来替换改字段

转换标志：跟在叹号后面的单个字符，当前支持的字符包括r（repr）,s(str),a(ascii)

格式说明符;跟在冒号后面的表达式。

替换字段名

在最简单的情况下，只需要向foemat提供要设置其格式的未命名参数，并在格式字符串中使用未命名字段。

“{foo}{}{bar}{}”.format(1,2,bar=4,foo=3)
‘3142’

基本转换

message="The number is {num}".format(num=42)
print(message )


The number is 42-----结果

b ：将整数表示为二进制数

c ：将整数解读为Unicode码点

d :将整数视为十进制数进行处理，这是整数默认使用的说明符

e :使用科学表示法来表示小数（用e来表示指数）

E :与e相同，但使用E来表示指数

f :将小数表示为定点数

F :与f相同，但对于特殊值（nan和inf），使用大写表示

g :自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数

G :与g相同，但使用大写来表示指数和特殊值

n :与g相同，但插入随区域而异的数字分隔符

o :将整数表示为八进制数

s :保持字符串的格式不变，这是默认用于字符串的说明符

x :将整数表示为十六进制数并使用小写字母

X :与x相同，但使用大写字母

% :将数表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）

宽度，精度和千位分隔符

设置浮点数的格式时，默认在小数点后面显示6位小数

数和字符串的对齐方式不同，如下：

b="{num:10}".format(num=3)
print(b)


         3

c="{name:10}".format(name="Bob")
print(c)


Bob       

精度

d="pi day is {pi:.2f}".format(pi=pi)
print(d)

修改默认对齐方式

​ 在指定的宽度和精度的数前面，可添加一个标志，这个标志可以是0，+，-或空格，其中零表示使用零来填充数字

​ 要指定左对齐，右对齐和居中可分别使用<,>,和^

print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'format)
3.14
   3.14
      3.14

说明符等号

print('{0:10.2f}\n{1:10.2f}'.format(pi,-pi))

      3.14
     -3.14
print('{0:10.2f}\n{1:=10.2f}'.format(pi,-pi))   

      3.14
-     3.14

字符串方法：

​ 模块string未死

虽然字符串方法完全盖住了模块string的风头，但这个模块包含一些字符串没有的常量

和函数。下面就是模块string中几个很有用的常量①。

 string.digits：包含数字0～9的字符串。

 string.ascii_letters：包含所有ASCII字母（大写和小写）的字符串。

 string.ascii_lowercase：包含所有小写ASCII字母的字符串。

 string.printable：包含所有可打印的ASCII字符的字符串。

 string.punctuation：包含所有ASCII标点字符的字符串。

 string.ascii_uppercase：包含所有大写ASCII字母的字符串。

虽然说的是ASCII字符，但值实际上是未解码的Unicode字符串。

center:通过在两边添加填充字符（默认为空格）让字符串居中

A="The Middle by Jimmy Eat World".center(39)
print(A)

The Middle by Jimmy Eat World     

B="The Middle by Jimmy Eat World".center(39,"*")
print(B)

   
*****The Middle by Jimmy Eat World*****

find：在字符串中查找子串。如果找到，就返回子串的第一个字符发热索引，否则返回-1

C='With a moo-moo here,and a moo-moo there'.find('moo')
print(C)

7

join:合并序列的元素(所合并的元素必须都是字符串)

lower:返回字符串的小写版本

title:将字符串转换为词首大写

replace:将指定子串都替换为另一个字符串，并返回替换后的结果。

split:用于将字符串拆分为序列。（如果没有默认指定的分隔符，将默认在单个或多个连续的空白字符（空格，制表符，换行符等））处进行拆分。

strip:将字符串开头和末尾的空白（不包括中间的空白）删除，并返回删除后的结果

还可以在一个字符串参数中指定要删除哪些字符

B='***SPAM * for * everyone!!!***'.strip('*!')
print(B)


SPAM * for * everyone

translate:替换字符串的特定部分，只能进行单字符替换能够同时替换多个字符

​ 然而，使用translate前必须创建一个转换表。这个转换表指出了不同Unicode码点之间的转

换关系。要创建转换表，可对字符串类型str调用方法maketrans，这个方法接受两个参数：两个

长度相同的字符串，它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字

符

isspace,isdigit,isupper:判断字符串是否具有特定的性质（如包含的字符全为空白，数字或大写）如果是则返回True,否则返回False

字符串格式设置：求模运算符（%）可用于将值合并为包含转换标志（如%s）的字符串，这让你能够以众多方式设置值的格式，如左对齐或右对齐，指定字段宽度和精度，添加符号（正号或负号）以及在左边填充0等。

字符串方法：字符串有很多方法，有些很有用（如split和join），有些很少用到（如istitle和capitalize）。

string.capwords(s[, sep]) :使用split根据sep拆分s，将每项的首字母大写，再以空格为分隔符将它们合并起来

ascii(obj) :创建指定对象的ASCII表

第4章：当索引行不通时

4.1 字典的用途

字典旨在让你能够轻松的找到特定的单词（键），此次获悉其定义（值），是python中唯一的内置映射类型

字典的用途：1.表示棋盘的状态，其中每个键都是由坐标组成的元组

​ 2.存储文件修改时间，其中的键为文件名

​ 3.数字电话/地址簿

4.2：创建和使用字典

字典以类似下面的方式表示：

phonebook = {
   'Alice':'2341','Beth':'9102','Cecil':'3258'}

字典由键极其相应的值组成，这种键-值对称为项（item）。每个键与值之间都用冒号（：）分隔，项之间用逗号分隔，而整个字典放在花括号内。空字典（没有任何项）用两个花括号表示

*键必须是独一无二的。

4.2.1:函数dict:从其他映射（如其他字典）或键-值对序列创建字典

items = [('name','Gumby'),('age',42)]
d = dict(items)
print(d)


{
   'name': 'Gumby', 'age': 42}

4.2.2基本的字典操作

 len(d)返回字典d包含的项（键值对）数。

 d[k]返回与键k相关联的值。

 d[k] = v将值v关联到键k。

 del d[k]删除键为k的项。

 k in d检查字典d是否包含键为k的项

 键的类型：字典中的键可以是整数，但并非必须是整数。字典中的键可以是任何不可变的类型，如浮点数（实数）、字符串或元组。

 自动添加：即便是字典中原本没有的键，也可以给它赋值，这将在字典中创建一个新项。然而，如果不使用append或其他类似的方法，就不能给列表中没有的元素赋值。

 成员资格：表达式k in d（其中d是一个字典）查找的是键而不是值，而表达式v in l（其中l是一个列表）查找的是值而不是索引。

x = []
x[42] = 'Foobar'      赋给一个空列表中索引为42的元素
print(x)

IndexError: list assignment index out of range

x = {
   }
x[42] = 'Foobar'         赋给一个空字典的键42
print(x)

{
   42: 'Foobar'}

4.2.3将字符串格式设置功能用于字典

​ 可在字典中包含各种信息，这样只需在格式字符串中提取所需的信息即可。为此，必须使用format_map来指出你将通过一个映射来提供所需的信息。

phonebook = {
   'Beth':'9102','Alice':'2341','Cecil':'3258'}
A = "Cecil's phone number is {Cecil}.".format_map(phonebook)
print(A)

Cecil's phone number is 3258.

4.2.4：字典方法

1.clear:删除所有的字典项（就地执行的，因此什么都不返回）

d = {
   }
d['name'] = 'Gumby'
d['age'] = 42
print(d)
returned_value = d.clear()
print(d)
print(returned_value)

{
   'name': 'Gumby', 'age': 42}
{
   }
None

x = {
   }    ------将一个空字典赋给x来“清空”它
y = x            ------这对y没有任何影响
x['key'] = 'value'
print(y)         -----它依然指向原来的字典
x = {
   }
print(x)
print(y)


{
   'key': 'value'}
{
   }
{
   'key': 'value'}

第二种情况

x = {
   }
y = x
x['key'] = 'value'
print(y)
x.clear()     ------删除原来字典额所有元素，要用clear
print(y)     ------因此y也是空的

{
   'key': 'value'}
{
   }

2.copy：返回一个新字典，其包含的键-值对于原来的字典相同

copy()当替换副本中的值时，原件不受影响。然而，如果修改副本中的值（就地修改而不是替换），原件也将发生变化，因为原件指向的也是被修改的值为避免这种问题，一种办法是执行深复制，即同时复制值及其包含的所有值，

copy():浅复制。deepcopy():深复制

from copy import deepcopy
d = {
   }
d['names'] = ['Alfred','Bertrand']
c = d.copy()
dc = deepcopy(d)
d['names'].append('Clive')
print(c)
print(dc)

{
   'names': ['Alfred', 'Bertrand', 'Clive']}
{
   'names': ['Alfred', 'Bertrand']}

3.fromkeys:创建一个新字典，其中包含指定的键，且每个键对应的值都是None

A = {
   }.fromkeys(['name','age'])   ------最前面的空的花括号的意思是：首先创建一个空字典。
print(A)

{
   'name': None, 'age': None}

A = dict.fromkeys(['name','age'],'(unknown)')  ---可以不先创建一个空字典，直接对dict调用方法，
print(A)                                      -----dict是所有字典所属的类型

                                               ------如果不想使用默认值，可提供特定的值
{
   'name': '(unknown)', 'age': '(unknown)'}

4.get:为访问字典项提供了宽松的环境

d = {
   }
print(d.get('name'))


None

5.items:返回一个包含所有字典项的列表，其中每个元素都为（key,value)的形式，字典项在列表中的排列顺序不确定

返回值属于一种名为字典视图的特殊类型。视图的一个优点是不复制，它们始终是底层字典的反映。

6.keys；返回一个字典视图，其中包含指定字典中的键

7.pop：可用于获取与指定键相关联的值，并将该键—值对从字典中删除

8.popitem:随机的弹出一个字典项。

9.setdefault:获取与指定键相关联的值，它还在字典不包含指定的键时，在字典中添加指定的键-值对。

d = {
   }
d['name'] = 'Gumby'
d.setdefault('name','N/A')
print(d)

{
   'name': 'Gumby'}

10.update:使用一个字典中的项来更新另一个字典

11.values:返回一个由字典中的值组成的字典视图，可能包含重复的值

d = {
   }
d[1] = 1
d[2] = 2
d[3] = 3
d[4] = 4
print(d.values())

dict_values([1, 2, 3, 4])

小结：

映射：映射让你能够使用任何不可变的对象（最常用的是字符串和元组）来标识其元素。python中只有一种映射类型，那就是字典。

将字符串格式设置功能用于字典：要对字典执行字符串格式设置操作，不能使用format和命名参数，而必须使用format_map

字典方法：字典有很多方法，这些方法的调用方式与列表和字符串的方法相同

第五章：条件，循环及其他语句

5.1 print,import

5.1.1打印多个参数

print("I","wish","to","register","a","complaint",sep="_")---可自定义分隔符

I_wish_to_register_a_complaint

5.1.2导入时重命名

在模块导入时，通常使用：import somemodule （如果有两个模块，它们都包含：open,并这样调用函数：module.open 还有一种方法是在语句末尾添加as子句并指定别名）或使用from somemodule import somefunction 或者from somemodule import somefunction,anotherfunction,yetanotherfunction 或者from somemodule import*(当你确定要导入模块中的一切时)5.

5.2赋值

5.2.1 序列解包（可迭代对象解包）：将一个序列（或任何可迭代对象）解包，并将得到的值存储到一系列变量中。

values = 1,2,3
print(values)
x,y,z= values
print(x)

(1, 2, 3)
1

*假设要从字典中随便获取一个键-值对，可使用方法popitem

scoundrel = {
   'name':'robin','girlfriend':'marion'}
key,value = scoundrel.popitem()
print(key)
print(value)

girlfriend
marion

*可使用星号运算符来收集多余的值。这样无需确保值和变量的个数相同。

a,b,*rest = [1,2,3,4]
print(rest)

[3, 4]

5.2.2链式赋值：用于将多个变量关联到同一个值

x = y =somefunction()与y =somefunction() x = y 等价

5.2.3增强赋值

可以不编写代码x=x+1,而将右边表达式中的运算符（这里是+）移到赋值运算符（=）的前面，从而写成x+=1.这成为增强赋值，适用于所有标准运算符，如*，/，%等

x = 2
x += 1
x *=2
print(x)

6

fnord = 'foo'
fnord += 'bar'
fnord *= 2
print(fnord)

foobarfoobar

5.3代码块：缩进

代码块是一组语句，可在满足条件时执行（if语句），可执行多次（循环），等等。代码块是

通过缩进代码（即在前面加空格）来创建的。

​ 注意 也可使用制表符来缩进代码块。Python将制表符解释为移到下一个制表位（相邻制表位

相距8个空格），但标准（也是更佳的）做法是只使用空格（而不使用制表符）来缩进，

且每级缩进4个空格。

​ 在同一个代码块中，各行代码的缩进量必须相同。

​ 在Python中，使用冒号（:）指出接下来是一个代码块，并将该代码块中的每行代码都缩进相同的程度。发现缩进量与之前相同时，你就知道当前代码块到此结束了。

5.4条件和条件语句

5.4.1布尔值（真值）

用作布尔表达式（如用作if语句中的条件）时，下面的值都将被解释器视为假：

False None 0 “” () [] {}

换而言之，标准值False和None、各种类型（包括浮点数、复数等）的数值0、空序列（如空

字符串、空元组和空列表）以及空映射（如空字典）都被视为假，而其他各种值都被视为真，

包括特殊值True。

​ 布尔值True和False属于类型bool

print(bool('I think , therefore I am'))
print(bool(42))
print(bool(''))
print(bool(0))

True
True
False
False

​ 注意: 虽然[]和"“都为假（即bool([]) == bool(”") == False），但它们并不相等（即[] != “”）。

对其他各种为假的对象来说，情况亦如此（一个更显而易见的例子是() != False）。

5.4.2 有条件的执行和if语句

是if语句，让你能够有条件地执行代码。这意味着如果条件（if和冒号之间的表达式）

为前面定义的真，就执行后续代码块；如果条件为假，就不执行。

5.4.6更复杂的条件

1.比较运算符

​ 表 达 式 描 述

​ x == y x 等于y

​ x < y x小于y

​ x > y x大于y

​ x >= y x大于或等于y

​ x <= y x小于或等于y

​ x != y x不等于y

​ x is y x和y是同一个对象

​ x is not y x和y是不同的对象

​ x in y x是容器（如序列）y的成员

​ x not in y x不是容器（如序列）y的成员

==用来检查两个对象是否相等，而is用来检查两个对象是否相同（是同一个对象），不要将is用于数和字符串等不可变的基本值。

5.4.7断言：assert

如果知道必须满足特定条件，程序才能正确地运行，可在程序中添加assert语句充当检查点，

5.5循环

5.5.2for循环

for number in range(1,101):
        print(number)
        
        1......100-------包含起始位置，不包含结束位置

​ 范围类似于切片。它们包含起始位置（这里为0），但不包含结束位置（这里为10）。在很多

情况下，你都希望范围的起始位置为0。实际上，如果只提供了一个位置，将把这个位置视为结

束位置，并假定起始位置为0。

5.5.3迭代字典

d = {
   'x':1,'y':2,'z':3}
for key in d:-----要遍历字典的所有关键字，可像遍历序列那样使用普通的for语句。
        print(key,'corresponds to',d[key])
        
x corresponds to 1
y corresponds to 2
z corresponds to 3

​ 也可使用keys等字典方法来获取所有的键。如果只对值感兴趣，可使用d.values。你可能还

记得，d.items以元组的方式返回键值对。for循环的优点之一是，可在其中使用序列解包。

​ 字典元素的排列顺序是不确定的。换而言之，迭代字典的键或值时，一定会处理所有的

键或值，但不知道处理的顺序。如果顺序很重要，可将键或值存储在一个列表中并对列

表排序，再进行迭代。要让映射记住其项的插入顺序，可使用模块collections中的

OrderedDict类。

1.

names = ['anne','beth','george','damon']
ages = [12,45,32,102]
for i in range(len(names)):
        print(names[i],'is',ages[i],'years old')
        
        
anne is 12 years old
beth is 45 years old
george is 32 years old
damon is 102 years old

​ i是用作循环索引的变量的标准名称。一个很有用的并行迭代工具是内置函数zip，它将两个

序列“缝合”起来，并返回一个由元组组成的序列。返回值是一个适合迭代的对象，要查看其内

容，可使用list将其转换为列表。

​ 函数zip可用于“缝合”任意数量的序列。需要指出的是，当序列的长度不同时，函数zip将

在最短的序列用完后停止“缝合”。

2.迭代时获取索引：enumerate

strings = ['xxs','sss','xxx',]
for index,string in enumerate(strings):
        if 'xxx'in string:
                strings[index] = '[censored]'
                print(strings)
 --------你需要在迭代对象序列的同时获取当前对象的索引。例如，你可能想替换一
个字符串列表中所有包含子串'xxx'的字符串。               
                
['xxs', 'sss', '[censored]']

​ 这个函数让你能够迭代索引值对，其中的索引是自动提供的。

3.反向迭代和排序后再迭代：reversed,sorted,可用于任何序列或可迭代的对象，且不就地修改对象，而是返回

反转和排序后的版本。

print(sorted([4,3,6,8,3]))

[3, 3, 4, 6, 8]

print(list(reversed('hello,world!')))

['!', 'd', 'l', 'r', 'o', 'w', ',', 'o', 'l', 'l', 'e', 'h']

​ sorted返回一个列表，而reversed像zip那样返回一个更神秘的可迭代对象

​ 不能对它执行索引或切片操作，也不能直接对它调用列表的方法。要执行这些操作，可先使用list对返回的对象进行转换。

5.5.5跳出循环：

1.break

from math import sqrt
for n in range(99,0,-1):
        root = sqrt(n)
        if root == int(root):
                print(n)
                break
                
                
    81

​ *注意到我向range传递了第三个参数——步长，即序列中相邻数的差。通过将步长设置为负数，可让range向下迭代，

2.continue:

​ 语句continue没有break用得多。它结束当前迭代，并跳到下一次迭代开头。这基本上意味着跳过循环体中余下的语句，但不结束循环。这

3.while True/break成例

while True:
        word = input('please enter a word:')
        if not word:break
        print('the word was',word)
        
 please enter a word:enter
the word was enter
please enter a word:

​ while True导致循环永不结束，但你将条件放在了循环体内的一条if语句中，而这条if语句

将在条件满足时调用break。这说明并非只能像常规while循环那样在循环开头结束循环，而是可

在循环体的任何地方结束循环。if/break行将整个循环分成两部分：第一部分负责设置（如果使

用常规while循环，将重复这部分），第二部分在循环条件为真时使用第一部分初始化的数据。

5.5.6循环中的eles 语句

​ 如何判断循环是提前结束还是正常结束的呢？

​ 1.可在循环开始前定义一个布尔变量并将其设置为False，再在跳出循环时将其设置为True。这样就可在循环后面使用一条if语句来判断循环是否是提前结束的。

​ 2.一种更简单的办法是在循环中添加一条else子句

from  math import sqrt
for n in range(99,81,-1):
        root = sqrt(n)
        if root == int(root):
                print(n)
                break
else:
        print("didn't find it!")
        
        
        
        didn't find it!

5.6简单推导

列表推导是一种从其他列表创建列表的方式，类似于数学中的集合推导。列表推导的工作原理非常简单，有点类似于for循环。

 [x * x for x in range(10)]-----------这个列表由range(10)内每个值的平方组成
 
 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[x*x for x in range(10) if x % 3 == 0] ---想打印那些能被3整除的平
方值，


[0, 9, 36, 81]

girls = ['alice','bernice','clarice']
boys = ['chris','arnold','bob']
letterGirls = {
   }
for girl in girls:
        letterGirls.setdefault(girl[0]