文章目录

• 一、再谈print和import
• 1. 打印多个参数
• 2. 导入时重命名

• 1. 序列解包
• 2. 链式赋值
• 3. 增强赋值

• 1. 这正是布尔值的用武之地
• 2. 有条件地执行和if语句
• 3. else子句
• 4. elif子句
• 5. 代码块嵌套
• 6. 更复杂的条件
• 6.1 比较运算符
• (1) 相等运算符：==
• (2) 相同运算符：is
• (3) 成员资格运算符：in
• (4) 字符串和序列的比较

• 1. while循环
• 2. for循环

• 4. 一些迭代工具
• 4.1 并行迭代
• 4.2 迭代时获取索引
• 4.3反向迭代和排序后再迭代

• 5.1 break
• 5.2 continue
• 5.3 while True/break成例

• 1. 什么都不做
• 2. 使用del删除
• 3. 使用exec和eval执行字符串及计算其结果
• 3.1 exec
• 3.2 eval
• 3.3 浅谈作用域

一、再谈print和import

  下面就来看看

print

import

1. 打印多个参数

print

>>> print('Age:',42)	#Age: 42

  默认会在输出时在逗号两边的内容之间加入一个空格。
  我们可以使用

sep='xxx'

>>> print("I","wish","to","register","a","complaint",sep='_')
#I_wish_to_register_a_complaint

  还可以自定义结束字符串，以替换默认的换行符。例如，如果将结束字符串指定为空字符串，以后就可继续打印到当前行。

>>> print('Hello,', end='')
>>> Print('world!')
#'Hello, world!

  仅当这些代码包含在脚本中时才如此。

2. 导入时重命名

  从模块导入时，通常使用

import somemodule

from somemodule import somefunction

from somemodule import somefunction, anotherfunction, yetanotherfunction

from somemodule import *

import math

math.py

sys

path

>>> import sys
>>> print('Python的搜索路径为：%s'%sys.path)
#['C:/Users/MIC/Desktop', 'C:\\Users\\MIC\\AppData\\Local\\Programs\\Python\\Python36\\Lib\\idlelib', 'C:\\Users\\MIC\\AppData\\Local\\Programs\\Python\\Python36\\python36.zip', 'C:\\Users\\MIC\\AppData\\Local\\Programs\\Python\\Python36\\DLLs', 'C:\\Users\\MIC\\AppData\\Local\\Programs\\Python\\Python36\\lib', 'C:\\Users\\MIC\\AppData\\Local\\Programs\\Python\\Python36', 'C:\\Users\\MIC\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages']

sys.path

sys.path

>>> from modname import name1[,name2[,…nameN]]

  如果导入模块，就会得到模块中所有对象；如果指定导入某个对象，就只能得到改对象。
  如果要访问模块中的多个对象，可以从一个导入语句导入多个函数，多个函数之间用都好分割。

>>> from math import pi,sin

  可以将所有对象引入。

>>> from math import *

  但如果有两个模块，它们都包含函数

open

module1.open(…)
module2.open(…)

  但还有一种办法：在语句末尾添加

as

>>> import math as foobar
>>> foobar.sqrt(4)	#2.0

  导入特定函数并给它指定别名

>>> from math import sqrt as foobar
>>> foobar(4)	#2.0

二、赋值魔法

  赋值语句也蕴含着一些使用窍门。

1. 序列解包

  可以同时(并行)给多个变量赋值。

>>> x,y,z = 1, 3, 5
>>> print(x,y,z)	#1 3 5

  可以交换多个变量的值。

>>> x, y = y, x
>>> print(x,y,z)	#3 1 5

  实际上，这里的操作称为序列解包(或可迭代对象解包)：将一个序列(或任何可迭代对象)解包，并将得到值存储到一些列的变量中。

>>> values = 1,2,3
>>> x,y,z = values
>>> x	#1

  这在使用返回元组(或其他序列或可迭代对象)的函数火方法时很有用。假设要从字典中随便获取(或删除)一个键-值对，可使用方法

popitem

>>> scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}
>>> key ,value = scoundrel.popitem()
>>> key		#'girlfriend'
>>> value	#'Marion'

  这让函数能够返回被打包成元组的多个值，然后通过一条赋值语句轻松地访问这些值。要解包的序列包含的元素个数必须与你在等号左边列出的目标个数相同，否则Python将引发异常。

>>> x,y,z =1,2
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
x,y,z =1,2
ValueError: not enough values to unpack (expected 3, got 2)

  可使用**星号运算符(

*

>>> a,b,*rest = [1,2,4,5,6,7]
>>> rest	#[4, 5, 6, 7]

  还可将带星号的变量放在其他位置。

>>> name = "Albus Percival Wulfric Brian Dumbledore"
>>> first, *middle, last = name.split()
>>> middle	#['Percival', 'Wulfric', 'Brian']

  赋值语句的右边可以是任何类型的序列，但带星号的变量最终包含的总是一个列表。在变量和值的个数相同时亦如此。

>>> a, *b, c = "abc"
>>> a, b, c		#('a', ['b'], 'c')

2. 链式赋值

  链式赋值是一种快捷方式，用于将多个变量关联到一个值。

x = y = somefunction()

  与下面的代码

y = somefunction()

x = y

x = somefunction()

y = somefunction()

3. 增强赋值

  可以不编写代码

x = x + 1

x += 1

/

*

%

-

>>> fnord = 'foo'
>>> fnord += 'bar'
>>> fnord *= 2
>>> fnord	#'foobarfoobar'

三、代码块：缩进的乐趣

  代码块是一组语句，可在满足条件时执行(if语句)，可执行多次(循环)，等等。代码块是通过缩进代码(即在前面加空格)来创建的。
  注意：也可使用制表符来缩进代码块。Python制表符解释为移到下一个制表位(相邻制表位相距8个空格)，但标准(也是更佳)的做法是只使用空格来缩进，且每级缩进4个空格。
  在同一个代码块中，各行代码的缩进量必须相同。
  在Python中，使用冒号(:)指出接下来是一个代码块，并将该代码块中的每行代码都缩进相同的程度。发现缩进量与之前相同时，你就知道当前代码块到此结束了。

四、条件和条件语句

1. 这正是布尔值的用武之地

  真值也称布尔值。
  用作布尔表达式时,下面的值都将被解释器视为假：
  

False

None

0

""

()

{}

[]

False

None

0

True

1

0

True

False

True

False

bool

bool

list

str

tuple

>>> bool(42)	#True

  因为所有值都可以用作布尔值，所以几乎不需要对它们进行显示转换，Python会自动转换这些值。

2. 有条件地执行和if语句

  if语句，让你能够有条件地执行代码。这意味着当条件(if和冒号之间的部分)为真，就执行后续代码块；如果条件为假，就不执行。

>>> name = input("what's you name ")
>>> if name.endswith("Gumby"):
print("hello ,Mr.Gumby)

3. else子句

  可以使用else子句增加一种选择(之所以叫子句是因为else不是独立的语句，而是if语句的一部分)，修改上面的代码。

>>> name = input("what's you name ")
>>> if name.endswith("Gumby"):
print("hello ,Mr.Gumby")
else :
print("hello ,stranger")

  如果没有执行第一个代码块(因为条件为假)，将执行else后面的语句
  还有一个与if语句很像的"亲戚"，它就是条件表达式—C语言中三目运算符的Python版本。

>>> status = "friend" if name.endswith("Gumby") else "stranger"

  如果条件(紧跟在if后面)为真，表达式的结果为提供的第一个值(这里为"friend")，否则为第二个值(这里为"stranger")。

4. elif子句

  要检查多个条件，可使用elif。elif需要和if联合使用，不能单独使用。

>>> a = 1
>>> b = int(input('Enter a number:')) 	#input  提示输入 输出的是字符串
>>> if a>b:     #if  必须接判断语句
print(a)
elif a == b:    # elif  也必须接判断语句  可以多个
print('相等')
else:       #不能接判断语句
print(b)
#pass    占位

  必须满足判断条件才会执行相应的语句

5. 代码块嵌套

  条件语句可以嵌套，注意缩进即可。所谓嵌套代码，是指把

if

else

elif

if

else

elif

>>> a=input('请输入： ')
>>> if a.isdigit():		#字符串是否为数字
a=int(a)
if a >= 90:   #非0即true
print('A')
elif a >= 80:
print('B')
elif a >= 60:
print('C')
else:
print('差')
else:
print('输入错了')

  补充：

random

>>> a=random.randint(1,5)	# 闭区间  随机生成一个整数
>>> random.random()	# 随机生成一个0-1的浮点数
>>> random.randrange(5)	#0,1,2,3,4  左闭右开
>>> random.randrange(1,5)	#1,2,3,4
>>> li = [1,23,3,4,5]
>>> random.sample(li,2)	#从序列中生成两个
>>> random.choice(li)	#从序列中生成

6. 更复杂的条件

  下面来说说条件本身，因为它们是有条件执行中最有趣的部分。

6.1 比较运算符

  在条件表达式中，最基本的就是比较运算符，它们用于执行比较。
  

==

<

>

<=

>=

!=

is(is not)

in(not in)

<

<=

0<age<100

(1) 相等运算符：==

  要确定两个对象是否相等，可使用比较运算符，用两个等号(==)表示。

>>> "foo" == "foo"	#True
>>> "foo" == "bar"	#False

(2) 相同运算符：is

  其作用看似与

==

is

>>> x = y =[1, 4, 5]
>>> z = [1, 4, 5]
>>> x is y	#True
>>> x is z	#False
>>> x == y == z	#True

  变量x和y指向同一个列表，而z指向另一个列表。这两个列表虽然相等，但并非同一个对象。
  注意：尽量避免用is运算符比较数值和字符串这类不可变值。由于Python内部操作这些对象方式的原因，使用is运算符的结果是不可预测的，除非你对堆栈有一定熟悉程度，否则很难预测运算结果。

(3) 成员资格运算符：in

  也可用于条件表达式中。

>>> name = input('What is your name')
>>> if 's' in name:
print('your name contains the letter "s".')
else:
print('your name does not contain the letter "s".')

(4) 字符串和序列的比较

  字符串是根据字符的字母排列顺序进行比较的。

>>> "alpha" < "beta"	#True

  虽然基于的是字母排列顺序，但字母都是

Unicode

ord

chr

>>> ord('a')	#97
>>> chr(97)		#'a'

  其他序列的比较方式与此相同，但这些序列包含的元素可能不是字符，而是其他类型的值。

>>> [1, 2] < [2, 1]	#True

  如果序列的元素为其他序列，将根据同样的规则对这些元素进行比较。

>>> [2, [1, 4]]] < [2, [1, 5]]	#True

6.2 布尔运算符

  运算符and是一个布尔运算符。它接受两个真值，并在这两个值都为真时返回真，否则返回假。还有另外两个布尔运算符：or和not。通过使用这三个运算符，能以任何方式组合真值。

>>> if ((cash > price) or customer_has_goo_credit) and not out_of_stock:
Give_goods()

  布尔运算符有个有趣的特征：只做必要的计算。这种行为称为短路逻辑。
  短路原则：

• 对于 and 来说：
    如果第一个条件的结论为假，那么 and 前后两个条件组成的表达式计算结果一定为假，后面的条件计算机不会进行计算。
• 对于 or`来说：
    如果第一个条件的结论为真，那么 and 前后两个条件组成的表达式计算结果一定为真，后面的条件计算机不会进行计算。

>>> a, b = 0, 1
>>> (c = a) and (b = 3)	#c=0; b=1

7. 断言

  if语句有一个很有用的亲戚，其工作原理类似于下面的伪代码：

>>> if not condition:
crash program

  因为让程序在错误条件出现时立即崩溃胜过以后再崩溃。基本上，你可要求某些条件得到满足(如核实函数参数满足要求或为出事测试和调试提供帮助)，为此可在语句中使用关键字

assert

>>> age = 1
>>> assert 0< age <10
>>> age = -1
>>> assert 0<age<10
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
assert 0<age<10
AssertionError

  这里看到，当

assert

assert

assert

>>> assert 0<age<10, 'The age must be realistic'
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
assert 0<age<10
AssertionError: The age must be realistic

  使用

assert

1. assert

   断言用来声明某个条件是真的。
2. 如果你非常确信你使用的列表中至少有一个元素，想要检验这一点，并在它非真时引发一个错误，那么

   assert

   语句是应用在这种情形下的理想语句。

3. assert

   语句失败时，会引发一个

   AssertionError

   。

五、循环

1. while循环

  在Python编程中，

while

>>> while True:     #满足条件执行，需要终止条件
print(1)

  这样会一直打印1，因为没有结束条件

>>> while a < 5:
>>> 	a+=1
>>> 	print(a)
>>> name = ''
>>> while not name:
name = input("name:")
print("hello ,{}".format(name))

  请尝试运行这些代码，并在要求你输入名字时直接按回车。你会看到提示信息再次出现，因为name还是为空字符串，这相当于假。

break

>>> a=10
>>> while a>4:
a-=1
if a == 5:
break
print(a)
continue  #跳过本次循环，但是不结束循环
>>> a=10
>>> while a>4:
a-=1
if a == 5:
break
print(a)

  while语句非常灵活，可用于在条件为真时反复执行代码块。

2. for循环

  为序列(或其他可迭代对象)中每个元素执行代码块。
  基本上，可迭代对象是可使用for循环进行遍历的对象。因为代码更简洁，代码量也少。所以，能用for循环，就不要用while循环。
  在Python中，for关键字叫做for循环，for循环可以遍历任何序列的项目，如一个列表或字符串。语法格式如下：
  for iterating_var in sequence:
    statements(s)
  

sequence

iterating_var

statements

>>> num = [1,3,4,5,7,8]
>>> for n in num:
print(n)

  鉴于迭代(也就是遍历)特定范围内的数是一种常见的任务，Python提供了一个创建范围的内置函数

range()

>>> range(10)	# range(0, 10)
>>> range(0,10)	# range(0, 10)
>>> range(0,10,2)	# range(0, 10, 2)
>>> list(range(0,10))	#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0,10,2))	#[0, 2, 4, 6, 8]

  范围类似于切片。它们包含起始位置，但不包含结束位置。

>>> for i in range(0,6):	#in后面是可迭代对象
print(num[i])

  相同点：都是具有循环功能。
  不同点：while 需要写终止条件。

3. 迭代字典

  要遍历字典的所有关键字，可像遍历序列那样使用普通的for语句。

>>> d = {1: 'a', 2: 'b', 3: 'c'}
>>> for key in d:
print(key, '--', d[key])
#1 -- a
#2 -- b
#3 – c

  for循环的优点之一是，可在其中使用序列解包。

>>> for key, value in d.items():
print(key, 'corresponds to', value)
#1 corresponds to a
#2 corresponds to b
#3 corresponds to c

  注意：字典元素的排列顺序是不确定的。换而言之，迭代字典的键或值时，一定会处理所有的键或值，但不知道处理的顺序。如果顺序很重要，可将键或值存储在一个列表中并对列表排序，再进行迭代。要让映射记住其项的插入顺序，可使用模块

collections

OrderedDict

4. 一些迭代工具

  Python提供了多个可帮助迭代序列(或其他可迭代对象)的函数，其中一些位于第10张的模块

itertools

4.1 并行迭代

  当你想同时迭代两个序列时，你可以这样：

>>> names = ['a', 'b', 'c', 'd']
>>> ages = [1, 3, 5, 45]
>>> for i in range(len(names)):
print(names[i], 'is', ages[i], 'years old .')
#a is 1 years old .
#b is 3 years old .
#c is 5 years old .
#d is 45 years old .

i

zip

>>> list(zip(names,ages))
#[('a', 1), ('b', 3), ('c', 5), ('d', 45)]

  缝合后，可在循环中将元组解包。

>>> for name, age in zip(names,ages):
print(name, 'is', age, 'years old .')

  函数

zip

>>> list(zip(range(5), range(100000)))
#[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

4.2 迭代时获取索引

  在有些情况下，你需要在迭代对象序列的同时获取当前对象的索引。例如，你可能想替换一个字符串列表中所有包含子串

xxx

enumerate

>>> strings = ['ab', 'cd', 'ef']
>>> for index, string in enumerate(strings):
if 'ab' in string:
strings[index] = 'AB'
print(strings)		#['AB', 'cd', 'ef']

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

4.3反向迭代和排序后再迭代

  两个很有用的函数：

reversed

sorted

>>> sorted([5,2,1,4,8,6])	#[1, 2, 4, 5, 6, 8]
>>> sorted('Hello!')	#['!', 'H', 'e', 'l', 'l', 'o']
>>> list(reversed('Hello!'))	#['!', 'o', 'l', 'l', 'e', 'H']
>>> ''.join(reversed("Hello!"))	#'!olleH'

  请注意，

sorted

reversed

>>> reversed('gege')	#<reversed object at 0x000001D57476D550>

  提示：要将字母表排序，可先转换为小写。为此，可将

sort

sorted

str.lower

>>> sorted('aBc', key=str.lower)	# ['a', 'B', 'c']

5. 跳出循环

  通常，循环会不断地执行代码块，知道条件为假或使用完序列中的所有元素。但在有些情况下，你可能想中断循环、开始新迭代(进入下一轮代码块执行流程)或直接结束循环。

5.1 break

  要结束(跳出)循环，可使用

break

>>> from math import sqrt#求小于100的最大平方数
>>> for i in range(99, 0 , -1):
n = sqrt(i)
if n==int(n):
print(int(n))
break;

range

range

5.2 continue

  用于结束当前迭代，并跳到下一次迭代开头。用的也不如

break

>>> for letter in 'hello':
if letter == 'l':
continue
print('当前字母：',letter)
#当前字母： h
#当前字母： e
#当前字母： o

  只是跳过一次循环，不会跳出整个循环。

5.3 while True/break成例

  先让其“死循环”，再利用

break

>>> word = 'dummy'
>>> while word:
word = unput('Please enter a word:')
# 使用这个单词做一些事情
print('The word was', word)

  如你所见，这些代码有点难看。为进入循环，你需要将一个哑值(未用的值)赋给

word

>>> word = input('Please enter a word:')
>>> while word:
# 使用这个单词做一些事情
print('The word was', word)
word = input('Please enter a word:')

  哑值消除了，但包含重复的代码(这样也不好)：需要在这两个地方使用相同的赋值语句并调用

input

while True/break

>>> while True;
word = input('Please enter a word:')
if not word: break
# 使用这个单词做些事情
print('The word was', word)

while True

6. 循环中的else子句

  这种语法要解决一种很常见的问题：循环可能是

break

else

>>> from math import sqrt
>>> for i in range(99, 0 , -1):
n = sqrt(i)
if n == int(n):
print(int(n))
break;
>>>	else:
print("Don't find it")

  无论是在for循环还是while循环中，都可使用

continue

break

else

六、简单推导

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

>>>	[x * x for x in range(10)]	#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

  这个列表由

range(10)

y % 3

>>>	[x * x for x in range(10) if x % 3 == 0]	#[0, 9, 36, 81]

  还可以添加更多的for部分

>>>	[(x,y) for x in range(3) for y in range(3)]
#[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

  男孩/女孩首字母配对。

>>>	girls = ['alice','bernice','clarice']
>>>	boys = ['chris','arnold','bob']
>>>	letterGirls = {}
>>>	for girl in girls:
letterGirls.setdefault(girl[0],[]).append(girl)
#{}.setdefault()返回其值[]。
>>>	print([b+'+'+g for b in boys for g in letterGirls[b[0]]])
#['chris+clarice', 'arnold+alice', 'bob+bernice']

  这个程序创建一个名为

letterGirls

>>>	squares = {i:"{} squared is {}".format(i, i**2) for i in range(4)}
>>> squares[3]	# '3 squared is 9'
>>> squares
#{0: '0 squared is 0', 1: '1 squared is 1', 2: '2 squared is 4', 3: '3 squared is 9'}

  在列表推导中，for前面只有一个表达式，而在字典推导中，for前面有两个用冒号分隔的表达式。这两个表达式分别为键及其对应的值。

七、三人行

在本章结束前，大致介绍下另外三条语句：

pass

del

exec

1. 什么都不做

pass

pass

>>> a, b = 1, 2
>>> if a>b:
print(a)
elif a == b:
print('相等')
else:
pass    # 占位

  注意：也可不使用注释和

pass

2. 使用del删除

  Python中，当某个值不再使用（没有任何变量或数据结构成员指向它），系统会将其自动回收。

>>> robin = {'age': 52}
>>> robin = None
>>> robin	#None

  当将

robin

None

del

>>> x = [1, 3, 4]
>>> y = x
>>> del x
>>> y	#[1, 3, 4]

  事实上，在Python中，根本就没有办法删除值，而且你也不需要这么做，因为对于你不再使用的值，Python解释器会立即将其删除。

3. 使用exec和eval执行字符串及计算其结果

  如果你有一天突发奇想，想执行一个字符串或者计算式（前提是他们能够执行），你可以考虑使用

exec

eval

3.1 exec

  函数

exec

>>> str = 'print("hello ")'
>>> exec(str)	#hello

  然而，调用函数

exec

>>> str = 'sqrt = 1'
>>> from math import sqrt
>>> sqrt(4)	#2.0
>>> exec(str)
>>> sqrt(4)
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
sqrt(4)
TypeError: 'int' object is not callable

  函数

exec

x=1

exec

eval

>>> from math import sqrt
>>> scope = {}
>>> exec('sqrt = 1',scope)
>>> sqrt(4)	  #2.0
>>> scope['sqrt']	#1

  如你所见，可能带来破坏的代码并非覆盖函数

sqrt

sqrt

exec

scope

scope

__builtins__

>>> len(scope)	#2
>>> scope.keys()	#dict_keys(['__builtins__', 'sqrt'])

3.2 eval

exec

eval

exec

>>> eval(input('input :'))
#input :2*4 + 5
#13

  与

exec

eval

eval

exec

3.3 浅谈作用域

  向

exec

eval

>>> scope = {}
>>> scope['x'] = 2
>>> scope['y'] = 3
>>> eval('x * y', scope)	#6

  同样，同一个命名空间可用于多次调用

exec

eval

>>> scope = {}
>>> exec('x = 2', scope)
>>> eval('x * x', scope)	#4