python基础教程总结4—基本语句

一、print 和 import 的更多信息

   print 打印多个表达式也是可行的，只要将它们用逗号隔开就好：

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

   可以看到，每个参数之间都插入了一个空格符。如果想要同时输出文本和变量值，却又不希望使用字符串格式化的话，那这个特性就非常有用了。

   从模块导入函数的时候，可以使用

import  somemodule

        或者

from  somemodule import  somefunction

        或者

from somemodule import somefunction, anotherfunction, yetanotherfunction

        或者

from somemodule 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

         对于open函数，可以像下面这样使用：

from module1 import open as open1
from module2 import open as open2

 

二、赋值

        1. 序列解包

        多个赋值操作可以同时进行：

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

        用它交换两个（或更多个）变量：

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

        事实上，这里所做的事情叫做序列解包（sequence unpacking）或可选代解包——将多个值的序列解开，然后放到变量的序列中。当函数或者方法返回元组（或者其他序列或可选迭代对象）时，这个特性尤其有用。它允许函数返回一个以上的值并且打包成元组，然后通过一个赋值语句很容易进行访问。

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

        所解包的序列中元素数量必须和放置在赋值符号 = 左边的变量数量完全一致，否则 Python 会在赋值时引发异常：

>>> x, y, z = 1, 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 2 values to unpack
>>> x, y, z = 1, 2, 3, 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 3)

        Python 3.0中有另外一个解包的特性：可以像在函数的参数列表中一样使用星号运算符。例如，a, b, *rest = [1, 2, 3, 4]最终会在 a 和 b 都被赋值之后将所有其他的参数都是收集到 rest 中。

 

2. 链式赋值

        链式赋值（chained assignment）是将同一个赋值给多个变量的捷径。   x = y = somefunction()   

 

3. 增量赋值

        将表达式运算符(本例中是 + -) 放置在赋值运算符 = 的左边，写成 x +=1。这种写法叫做增量赋值。

>>> x = 2
>>> x += 1
>>> x *= 2
>>> x
6

        对于其他数据类型也适用：

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

 

三、语句块

        语句块是在条件为真(条件语句)时执行或者执行多次（循环语句）的一组语句。在代码前放置空格来缩进语句即可创建语句块。

        在Python中，冒号(:)用来标识语句块的开始，块中的每一个语句都是缩进的(缩进量相同)。当回退到和已经闭合的块一样的缩进量时，就表示当前块已经结束了。

 

四、条件和条件语句

 1. 布尔变量

        下面的值在作为布尔表达式的时候，会被解释器看作假（false）：

                 False     None     0     “”     ()      []     {}

        换句话说，也就是标准值 False 和 None、所有类型的数字 0（包括浮点型、长整型和其他类型）、空序列（比如空字符串、元组和列表）以及空的字典都为假。其他的一切都被解释为真，包括特殊值 True。

        布尔值True 和 False 属于布尔类型，bool函数可以用来（和list、str以及tuple一样）转换其他值。 

>>> bool('I think, therefore I am')
True
>>> bool(42)
True
>>> bool('')
False
>>> bool(0)
False

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

 

2. 条件执行（if / else / elif）

num = input('Enter a number: ')
if num > 0:
    print('The number is positive')
elif num < 0:
    print('The number is negative')
else:
    print('The number is zero'

3. 嵌套代码块

name = raw_input('What is your name? ')
if name.endswith('Gumby'):
    if name.startswith('Mr. '):
        print('Hello, Mr. Gumby')
    elif name.startswith('Mrs. '):
        print('Hello, Mrs. Gumby')
    else:
        print('Hello, Gumby')
else:
    print('Hello, stranger')

 

 4. 更复杂的条件

 4.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 容器的成员

           在Python 3.0中，比较不兼容类型的对象已经不再可行。

 

           在Python中比较运算和赋值运算一样是可以连接的——几个运算符可以连在一起使用，比如：0 < age < 100。

 4.2 相等运算符

           如果想要知道两个东西是否相等，应该使用相等运算符，即两个等号 == ：

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

 4.3 is：同一性运算符

            is 运算符是判定同一性而不是相等性的

>>> x = y = [1, 2, 3]
>>> z = [1, 2, 3]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z
False

           使用 == 运算符来判定两个对象是否相等，使用 is 判定两者是否等同（同一个对象）。

 

 4.4 in：成员资格运算符

 4.5 字符串和序列比较

           字符串可以按照字母顺序排列进行比较。

>>> "alpha" < "beta"
True

           其他的序列也可以用同样的方式进行比较，不过比较的不是字符而是元素的其他类型。

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

     

4.6 布尔运算符

           and ， or 和 not 运算符就是所谓的布尔运算符。

 

 

5. 断言

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

      如果需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert语句就有用了，它可以在程序中置入检查点。条件后可以添加字符串，用来解释断言：

>>> age = -1
>>> assert 0 < age < 100, 'The age must be realistic'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: The age must be realistic

 

五、循环

5.1 while 循环

>>> while x <= 100:
...     print(x)
...     x += 1
...

 

5.2 for 循环

>>> words = ['this', 'is', 'an', 'ex', 'parrot']
>>> for word in words:
...     print(word)
...

      因为迭代(循环的另外一种说法)某范围的数字是很常见的，所以有个内建的范围函数 range 供使用：

>>> for number in range(1, 101):
...     print(number)
...

 

5.3 循环遍历字典元素

        一个简单的 for 语句就能循环字典的所有键，就像处理序列一样： 

>>> d = {'x':1, 'y':2, 'z':3}
>>> for key in d:
...     print(key, 'corresponds to', d[key])
...
z corresponds to 3
x corresponds to 1
y corresponds to 2

        d.items 方法会将键 - 值对作为元组返回，for循环的一大好处就是可以循环中使用序列解包：

>>> for key, value in d.items():
...     print(key, 'corresponds to', d[key])
...

        字典元素的顺序通常是没有定义的。换句话说，迭代的时候，字典中的键和值都能保证被处理，但是处理顺序不确定。

 

 5.4 一些迭代工具

 a。并行迭代

               程序可以同时迭代两个序列.

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

               而内建的 zip 函数可以用来进行并行迭代,可以把两个序列"压缩"在一起。     zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。

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

               zip 函数也可以作用于任意多的序列。关于它很重要的一点是 zip 可以应付不等长的序列：当最短的序列“用完”的时候就会停止。

 

b. 编号迭代

               enumerate 函数可以在提供索引的地方迭代 索引 - 值 对。        enumerate 函数用于遍历序列中的元素以及它们的下标：

>>> for i,j in enumerate(('a','b','c')):
 print i,j

0 a
1 b
2 c
>>> for i,j in enumerate([1,2,3]):
 print i,j

0 1
1 2
2 3
>>> for i,j in enumerate({'a':1,'b':2}):
 print i,j

0 a
1 b

>>> for i,j in enumerate('abc'):
 print i,j

0 a
1 b
2 c

　　

c。翻转和排序迭代

     reversed 和 sorted 作用于任何序列或可迭代对象上，不是原地修改对象，而是返回翻转或排序后的版本： 虽然 sorted 方法返回列表，reversed 方法却返回一个更加不可思议的迭代对象。

>>> sorted('Hello, world!')
[' ', '!', ',', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> list(reversed('Hello, world!'))
['!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H']

   

　　注： sort   sorted（）   reverse（）   reversed（）的区别　　　　　　

　　1）. sort()是可变对象(字典、列表)的方法，无参数，无返回值，sort()会改变可变对象，因此无需返回值。　　

　　　　 sort()方法是可变对象独有的方法或者属性，而作为不可变对象如元组、字符串是不具有这些方法的，如果调用将会返回一个异常。

　　　　　　　　>>> a=[5,4,3,2,1]
　　　　　　　　>>> a.sort()
　　　　　　　　>>> 
　　　　　　　　>>> a
　　　　　　　　[1, 2, 3, 4, 5]

　　　　sorted()是python的内置函数，并不是可变对象(列表、字典)的特有方法，

　　　　sorted()函数需要一个参数(参数可以是列表、字典、元组、字符串)，无论传递什么参数，都将返回一个以列表为容器的返回值，如果是字典将返回键的列表。

　　　　　　　　>>> mystring="54321"
　　　　　　　　>>> mytuple=(5,4,3,2,1)
　　　　　　　　>>> mylist=[5,4,3,2,1]
　　　　　　　　>>> sorted(mystring)
　　　　　　　　['1', '2', '3', '4', '5']
　　　　　　　　>>> sorted(mytuple)
　　　　　　　　[1, 2, 3, 4, 5]
　　　　　　　　>>> sorted(mylist)
　　　　　　　　[1, 2, 3, 4, 5]

　　　　reverse()与sort的使用方式一样，而reversed()与sorted()的使用方式相同

　　　　　　　　>>> mylist=[5,4,3,2,1]
　　　　　　　　>>> mylist.reverse()
　　　　　　　　>>> mylist
　　　　　　　　[1, 2, 3, 4, 5]
　　　　　　　　>>> mylist=[5,4,3,2,1]
　　　　　　　　>>> for i in reversed(mylist):
　　　　　　　　...     print i,
　　　　　　　　... 
　　　　　　　　1 2 3 4 5

 

5.5 跳出循环

a。break

              结束（跳出）循环可以使用 break 语句。

b。continue

              continue 会让当前的迭代结束，“跳”到下一轮循环的开始

c。while True / break 习语

>>> while True:
...     word = input('Please enter a word: ')
...     if not word: break
...     print('The word was ' + word)
...

      while True 的部分实现了一个永远不会自己停止的循环。但是在循环内部的 if 语句中加入条件可以的，在条件满足时调用 break 语句。

 

5.6 循环中的 else 子句

      在循环中增加一个 else 子句 —— 它仅在没有调用 break 时执行。

>>> 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

 

六、列表推导式

      列表推导式（list comprehension）是利用其它列表创建新列表的一种方法。它的工作方式类似于 for 循环：

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

        可以增加一个if部分添加到列表推导式： 

>>> [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)]

         也可以和if子句联合使用，像以前一样：

>>> girls = ['alice', 'bernice', 'clarice']
>>> boys = ['chris', 'arnold', 'bob']
>>> [b + '+' + g for b in boys for g in girls if b[0]==g[0] ]
['chris+clarice', 'arnold+alice', 'bob+bernice']

 

 

七、pass、del和exec

 1. 什么都没发生

        有的时候，程序什么事情都不用做。这种情况不多，但是一旦出现，就应该让 pass 语句出马。

2. 使用 del 删除

        使用 del 语句，它不仅会移除一个对象的引用，也会移除这个名字本身。

3. 使用 exec 和 eval 执行和求值字符串 

 a。exec

        执行一个字符串的语句是 exec。

>>> exec('print("Hello, world!")')
Hello, world!

        exec 语句最有用的地方在于可以动态地创建代码字符串。

 

b。eval

      evel(用于“求值”)是类似于 exec 的内建函数。exec语句会执行一系列 Python 语句，而eval 会计算 Python 表达式（以字符串形式书写），并且返回结果值。

>>> eval(input("Enter an arithmetic expression: "))
Enter an arithmetic expression: 6 + 18 * 2
42