Python基础之(五)语句

时间  2020-06-18
标签 python 基础 语句 栏目 Python 繁體版
原文   原文链接

运算符

算术运算符

前面已经讲过了四则运算，其中涉及到一些运算符：加减乘除，对应的符号分别是：+ - * /，此外，还有求余数的：%。这些都是算术运算符。其实，算术运算符不止这些。根据中学数学的知识，也应该想到，还应该有乘方、开方之类的。java

下面列出一个表格，将全部的运算符表现出来。python

运算符 描述 实例
+ 加 - 两个对象相加 10+20 输出结果 30
- 减 - 获得负数或是一个数减去另外一个数 10-20 输出结果 -10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 10 * 20 输出结果 200
/ 除 - x除以y 20/10 输出结果 2
% 取余 - 返回除法的余数 20%10 输出结果 0
** 幂 - 返回x的y次幂 10**2 输出结果 100
// 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

比较运算符

如下假设a=10，b=20：git

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True.
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y (a < b) 返回 True。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

逻辑运算符

（假设a=10，b=20）github

运算符 描述 实例
and 布尔"与" - 若是x为False，x and y返回False，不然它返回y的计算值。 (a and b) 返回 20。
or 布尔"或" - 若是x是True，它返回True，不然它返回y的计算值。 (a or b) 返回 10。
not 布尔"非" - 若是x为True，返回False。若是x为False，它返回True。 not(a and b) 返回 false。

  • and编程

and，翻译为“与”运算，但事实上，这种翻译容易引发望文生义的理解。app

先说一下正确的理解。less

A and B，含义是：编程语言

首先运算A，若是A的值是True，就计算B，并将B的结果返回作为最终结果，若是B是False，那么A and B的最终结果就是False，若是B的结果是True，那么A and B的结果就是True；函数

若是A的值是False ，就不计算B了，直接返回A and B的结果为False.优化

简单语句

print

在Python 2中，print是一个语句，可是在Python 3中它是一个函数了。这点请注意。

以Python 2为例，说明print语句。若是说读者使用的是Python 3，请自行将print xxx修改成print(xxx)，其它不变。

print发起的语句，在程序中主要是将某些东西打印出来，还记得在讲解字符串的时候，专门讲述了字符串的格式化输出吗？那就是用来print的。

>>> print "hello, world"
hello, world
>>> print "hello","world" //逗号表示打印在同一行
hello world

原本，在print语句中，字符串后面会接一个n符号。即换行。可是，若是要在一个字符串后面跟着逗号，那么换行就取消了，意味着两个字符串"hello"，"world"打印在同一行。

可是，在Python 3中状况有变。默认的end='n'，若是不打算换行，能够在使用print()函数的时候，修改end这个参数的值。

>>> for i in [1,2,3,4]:
    print(i, end=',')

1,2,3,4,

import

import引入模块的方法，是Python编程常常用到的。引用方法有以下几种：

>>> import math
>>> math.pow(3,2)
9.0

这是一种可读性很是好的引用方式，而且不一样模块的同名函数不会产生冲突。

>>> from math import pow
>>> pow(3,2)
9.0

这种引用方法，比较适合于引入模块较少的时候。若是引入模块多了，可读性就降低了，会不知道那个函数来自那个模块。

>>> from math import pow as pingfang
>>> pingfang(3,2)
9.0

将从某个模块引入的函数重命名，好比讲pow充命名为pingfang，而后使用pingfang()就至关于在使用pow()了

>>> from math import pow, e, pi
>>> pow(e,pi)
23.140692632779263

引入了math模块里面的pow,e,pi，pow()是一个乘方函数，e是那个欧拉数；pi就是π.

>>> from math import *
>>> pow(3,2)
9.0
>>> sqrt(9)
3.0

一下将math中的全部函数都引过来了。不过，这种方式的结果是让可读性更下降了。仅适用于模块中的函数比较少的时候，而且在程序中应用比较频繁。

事实上，不只函数能够引入，模块中还能够包括常数等，均可以引入。在编程中，模块中能够包括各样的对象，均可以引入。

赋值

a = 3
>>> x, y, z = 1, "python", ["hello", "world"]
>>> x
1
>>> y
'python'
>>> z
['hello', 'world']
>>> a = "itdiffer.com", "python"
>>> a
('itdiffer.com', 'python')

原来是将右边的两个值装入了一个元组，而后将元组赋给了变量a。

两个变量的值对调,python只要一行就完成了:

>>> a = 2
>>> b = 9
>>> a, b = b, a
>>> a
9
>>> b
2

由于我前面已经数次提到的Python中变量和对象的关系。变量至关于贴在对象上的标签。这个操做只不过是将标签换个位置，就分别指向了不一样的数据对象。

还有一种赋值方式，被称为“链式赋值”

>>> m = n = "I use python"
>>> print m, n            #Python 3：print(m, n)
I use python I use python

用这种方式，实现了一次性对两个变量赋值，而且值相同。

>>> id(m)
3072659528L
>>> id(n)
3072659528L

用id()来检查一下，发现两个变量所指向的是同一个对象。

另外，还有一种判断方法，来检查两个变量所指向的值是不是同一个（注意，同一个和相等是有差异的。在编程中，同一个就是id()的结果同样。

>>> m is n
True

这是在检查m和n分别指向的对象是不是同一个，True说明是同一个。

>>> a = "I use python"
>>> b = a
>>> a is b
True

这是跟上面链式赋值等效的。

可是：

>>> b = "I use python"
>>> a is b
False
>>> id(a)
3072659608L
>>> id(b)
3072659568L

>>> a == b
True

看出其中的端倪了吗？此次a、b两个变量虽然相等，但不是指向同一个对象。

还有一种赋值形式，若是从数学的角度看，是难以想象的，如：x = x + 1，在数学中，这个等式是不成立的。由于数学中的“=”是等于的含义，可是在编程语言中，它成立，由于"="是赋值的含义，即将变量x增长1以后，再把获得的结果赋值变量x.

这种变量本身变化以后将结果再赋值给本身的形式，称之为“增量赋值”。+、-、*、/、%均可以实现相似这种操做。
为了让这个操做写起来省点事（要写两遍一样一个变量），能够写成：x += 1

>>> x = 9
>>> x += 1
>>> x
10

除了数字，字符串进行增量赋值，在实际中也颇有价值。

>>> m = "py"
>>> m += "th"
>>> m
'pyth'
>>> m += "on"
>>> m
'python'

条件语句

if语句

>>> a = 8
>>> if a == 8: //冒号是必须的
...     print a //四个空格的缩进是必须的
...
8
>>>

  • 必需要经过缩进方式来表示语句块的开始和结束

  • 缩进用四个空格也是必须的

if...elif...else

#coding:utf-8
print "请输入一个整数数字:"
number = int(raw_input())

if number == 10:
    print "您输入的数字是： %d" % number
    print "You are smart"
elif number > 10:
    print "您输入的数字是： %d" % number
    print "This number is more than 10."
elif number < 10:
    print "您输入的数字是： %d" % number
    print "This number is less than 10."
else:
    print "Are you a human?"
    
结果打印：

请输入一个整数数字:
12
您输入的数字是： 12
This number is more than 10.

请输入一个整数数字:
10
您输入的数字是： 10
You are smart

请输入一个整数数字:
9
您输入的数字是： 9
This number is less than 10.

三元操做符

>>> name = "liuguoquan" if "deason" else "xiaoniu"
>>> name
'liuguoquan'
>>> name = "liuguoquan" if "" else "xiaoniu"
>>> name
'xiaoniu'
>>> name = "liuguoquan" if "xiaoniu" else ""
>>> name
'liuguoquan'

总结一下：A = Y if X else Z
根据上述例子能够看出：

  • 若是X为真，那么就执行A = Y

  • 若是X为假，那么就执行A = Z

>>> a = "python" if x > y else "java"
>>> a
'java'
>>> a = "python" if x < y else "java"
>>> a
'python'
>>>

for循环

For循环的基本结构是：

for 循环规则： //须要冒号

操做语句        //语句要缩进

简单的for循环

>>> hello = "liuguoquan"
>>> for i in hello:
...     print i
...
l
i
u
g
u
o
q
u
a
n

or:

>>> for i in range(len(hello)):
...     print i
...
0
1
2
3
4
5
6
7
8
9

range（start,stop,[,step])

range是个内建函数，通常形式是range（start,stop,[,step])

关于range()函数注意一下几点：

  • 该函数能够建立一个数字元素组成的列表

  • 该函数最经常使用于for循环

  • 函数的参数必须是整数，默认从0开始

  • step默认值是1，不写就是默认值

  • step是正数，返回list最后的值不包含stop的值，即start + step的值小于stop；step是负数，start + step的值大于stop；

  • step不能等于0

参数解释：

  • start：开始数值，默认为0

  • stop：结束数值，必需要写

  • step：变化的步长，默认是1，不能为0

正数

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

负数

>>> rang(-9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'rang' is not defined
>>> range(0,-9,-1)
[0, -1, -2, -3, -4, -5, -6, -7, -8]
>>> range(0,-9,-2)
[0, -2, -4, -6, -8]
>>>

获取列表的索引值组成的列表

>>> lgq = ["I","am","a","Android"]
>>> index = range(len(lgq))
>>> index
[0, 1, 2, 3]
>>>

找出100之内的可以被3整除的正整数

#coding:utf-8
result = []
for n in range(1,100):
    if n % 3 == 0:
        result.append(n)
        
print result

or:

print range(3,100,3)

结果打印：

[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

for对象

#coding:utf-8

name = "liuguoquan"

print "str"
for i in name:
    print i,

print "list"
name_list = list(name)
print name_list
for i in name_list:
    print i,
    
print "set"
name_set = set(name)
print name_set
for i in name_set:
    print i,
    
print "tuple"
name_tuple = set(name)
print name_tuple
for i in name_tuple:
    print i,
    
print "dict"
name_dict = {"name":"liuguoquan","sex":"male","age":"18"}
print name_dict
for i in name_dict:
    print i,"-->",name_dict[i]
    
 结果打印:
 
str:
l i u g u o q u a n 

list:
['l', 'i', 'u', 'g', 'u', 'o', 'q', 'u', 'a', 'n']
l i u g u o q u a n 

set:
set(['a', 'g', 'i', 'l', 'o', 'n', 'q', 'u'])
a g i l o n q u 

tuple
('l', 'i', 'u', 'g', 'u', 'o', 'q', 'u', 'a', 'n')
l i u g u o q u a n 

dict:
{'age': '18', 'name': 'liuguoquan', 'sex': 'male'}
age --> 18
name --> liuguoquan
sex --> male

字典遍历的多种写法

name_dict = {"name":"liuguoquan","sex":"male","age":"18"}
print name_dict
for i in name_dict:
    print i,"-->",name_dict[i]

注意到，上面的循环，实际上是读取了字典的key。在字典中，有一个方法，dict.keys()，获得的是字典key列表。

#获取字典key列表
for k in name_dict.keys():
    print k    #Python 3: print(k)

这种循环方法和上面的循环方法，结果是同样的，可是，这种方法并不提倡，觉得它在执行速度上表现欠佳。

若是要得到字典的value怎么办？不要忘记dict.values()方法

for k,v in name_dict.items():
    print k,"-->",v

用上面的方法，要把全部的内容都读入内存，内存东西多了，可能会出麻烦。为此，Python中提供了另外的方法。

for k,v in name_dict.iteritems(): #注意：仅在Python2中可用，Python 3中已经作了优化，d.items()即有同等功能。
    print k,"-->",v

这里是循环一个迭代器，迭代器在循环中有不少优点。除了刚才的dict.iteritems()以外，还有dict.itervalues()，dict.iterkeys()供你选用（以上三个dict.iter*都只用在Python 2中，Python 3中已经不须要了）

如何判断一个对象是不可迭代的？

>>> import collections

引入collections这个标准库。要判断数字321是否是可迭代的，能够这么作：

>>> isinstance(321, collections.Iterable)
    False

返回了False，说明321这个整数类型的对象，是不可迭代的。再判断一个列表对象。

>>> isinstance([1,2,3], collections.Iterable)
    True

从返回结果，咱们知道，列表[1,2,3]是可迭代的。

固然，并非要你在使用for循环以前，非要判断某个对象是否可迭代。由于至此，你已经知道了字符串str、列表list、字典dict、元组tuple、集合set都是可迭代的。

zip()

zip()——一个内建函数,Python 2中，参数是seq1, seq2, ...，意思是序列数据；在Python 3中，参数须要时可迭代对象。这点差异，一般是没有什么影响的，由于序列也是可迭代的。值得关注的是返回值，在Python 2中，返回值是一个列表对象，里面以元组为元素；而Python 3中返回的是一个zip对象。
经过实验来理解上面的文档：

Python 2：
    >>> a = "qiwsir"
    >>> b = "github"
    >>> zip(a, b)
    [('q', 'g'), ('i', 'i'), ('w', 't'), ('s', 'h'), ('i', 'u'), ('r', 'b')]
    
Python 3：
    >>> zip(a, b)
    <zip object at 0x0000000003521D08>
    >>> list(zip(a, b))
    [('q', 'g'), ('i', 'i'), ('w', 't'), ('s', 'h'), ('i', 'u'), ('r', 'b')]

若是序列长度不一样，那么就以"the length of the shortest argument sequence"为准。

>>> c = [1, 2, 3]
>>> d = [9, 8, 7, 6]
>>> zip(c, d)        #这是Python 2的结果，若是是Python 3，请仿照前面的方式显示查看
[(1, 9), (2, 8), (3, 7)]
>>> s = {"name":"qiwsir"}
>>> t = {"lang":"python"}
>>> zip(s,t)
[('name', 'lang')]

zip是一个内置函数，它的参数必须是序列，若是是字典，那么键视为序列。而后将序列对应的元素依次组成元组，作为一个列表的元素。

问题：有两个列表，分别是：a = [1, 2, 3, 4, 5], b = [9, 8, 7, 6, 5]，要计算这两个列表中对应元素的和。

  • for循环实现

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> c = []
>>> for i in range(len(a)):
...     c.append(a[i]+b[i])
... 
>>> c
[10, 10, 10, 10, 10]

  • zip()实现

>>> d = []
>>> for x,y in zip(a,b):
...     d.append(x+y)
... 
>>> d
[10, 10, 10, 10, 10]

问题：有一个字典，myinfor = {"name":"qiwsir", "site":"qiwsir.github.io", "lang":"python"}，将这个字典变换成：infor = {"qiwsir":"name", "qiwsir.github.io":"site", "python":"lang"}

  • for循环

>>> myinfor = {"name":"qiwsir", "site":"qiwsir.github.io", "lang":"python"}
>>> infor = {}
>>> for k,v in myinfor.items():
...     infor[v]=k
... 
>>> infor
{'python': 'lang', 'qiwsir.github.io': 'site', 'qiwsir': 'name'}

  • zip()

>>> dict(zip(myinfor.values(), myinfor.keys()))
{'python': 'lang', 'qiwsir.github.io': 'site', 'qiwsir': 'name'}

enumerate()

enumerate()也是内建函数。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

若是要同时获得元素索引和元素怎么办？

  • for循环

week = ["monday","sunday","friday"]
for i in range(len(week)):
    print week[i] + ' is ' + str(i) #注意，i是int类型，若是和前面的用+链接，必须是str类型

  • enumerate

for (i,day) in enumerate(week):
    print day + " is " + str(i)

问题：将字符串中的某些字符替换为其它的字符串。原始字符串"Do you love Canglaoshi? Canglaoshi is a good teacher."，请将"Canglaoshi"替换为"PHP".

raw = "Do you love Canglaoshi? Canglaoshi is a good teacher."
print raw

#1. 先将字符串转换为列表
raw_list = raw.split(" ")
print type(raw_list)
print raw_list

#2. 对列表中的字符串进行替换
for i,string in enumerate(raw_list):
    if "Canglaoshi" in string:
        raw_list[i] = "PHP"
        
print raw_list

#3. 将列表转换为字符串
print " ".join(raw_list)

列表解析

Python有一个很是强大的功能，就是列表解析，它这样使用：

>>> squares = [x**2 for x in range(1, 10)]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> mybag = [' glass',' apple','green leaf ']   #有的前面有空格，有的后面有空格
>>> [one.strip() for one in mybag]              #去掉元素先后的空格
['glass', 'apple', 'green leaf']

在不少状况下，列表解析的执行效率高，代码简洁明了。是实际写程序中常常被用到的。
如今Python的两个版本，对列表解释上，仍是有一点点差异的，请认真看下面的比较操做。

Python 2:

    >>> i = 1
    >>> [ i for i in range(9)]
    [0, 1, 2, 3, 4, 5, 6, 7, 8]
    >>> i
    8

Python 3:

    >>> i = 1
    >>> [i for i in range(9)]
    [0, 1, 2, 3, 4, 5, 6, 7, 8]
    >>> i
    1

先i = 1，而后是一个列表解析式，很是巧合的是，列表解析式中也用了变量i。这种状况，在编程中是经常遇到的，咱们一般把i=1中的变量i称为处于全局命名空间里面（命名空间，是一个新词汇，暂且用起来，后面会讲述），而列表解析式中的变量i是在列表解析内，称为处在局部命名空间。在Python 3中，for循环里的变量再也不与全局命名空间的变量有关联了。

while语句

while

while i< 5:
    print i
    i += 1
print "quit"

0
1
2
3
4
quit

break

i= 10
while i:
    if i % 2 == 0:
        break
    else:
        print "%d is odd number" %i
        i = 0
print "%d is even number" %i

10 is even number

continue

i= 10
while i:
    if i % 2 == 0:
        i -= 1
        continue; # 继续下一次循环
    else:
        print "%d is odd number" %i
        i -= 1
print "%d is even number" %i

while...else

while...else有点相似if ... else，只须要一个例子就能够理解。 固然，一遇到else了，就意味着已经不在while循环内了。

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"
   
执行结果：

    0 is less than 5
    1 is less than 5
    2 is less than 5
    3 is less than 5
    4 is less than 5
    5 is not less than 5

for...else

除了有while...else外，还能够有for...else。这个循环也一般用在当跳出循环以后要作的事情。

from math import sqrt

    for n in range(99, 1, -1):
        root = sqrt(n)
        if root == int(root):
            print n # 知足此条件后,不执行else
            break

    else:
        print "Nothing." # break不执行就会执行else
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程