Python基础教程
内容简要：
1. 常量命名规则
2. pyc文件
3. 数据类型
数值型
字符型
列表
元组
字典
4. 数据运算
算数运算
比较运算
赋值运算
逻辑运算
身份运算
位运算
运算符优先级
一. 常量命令规则
关于变量的相关概念在day1中已经详细列出了 ，感兴趣的可以参考下，http://www.cnblogs.com/dubq/articles/5474785.html 。
此处关于常量的意义，也就是不愿被更改的变量，比如说配置文件里的MYSQL_CONNECTION='172.16.0.1'，一般情况下只要程序开始运行，肯定是轻易修改的；在Python中，会在变量命名上标明某变量是常量，通常采用全是大写的方式来标明，如：
HOST = '127.0.0.1'
PORT = '3306'
USER = 'test_db_user'
PASSWORD = '00e3c8e5'
二. pyc文件
说到pyc文件，先来了解下python的执行过程，编写一个test.py的文件：
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Author: DBQ(Du Baoqiang) msg = 'Hello world!' print(msg)
用python3运行下看看本地目录下的文件：
root@test2-ubunut:/pyex/s13/day2# python3 test.py Hello world! root@test2-ubunut:/pyex/s13/day2# ls test.py
再新建一个文件main.py：
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Author: DBQ(Du Baoqiang) import test
再次执行main.py,然后再查看目录下的文件：
root@test2-ubunut:/pyex/s13/day2# python3 main.py Hello world! root@test2-ubunut:/pyex/s13/day2# ls main.py __pycache__ test.py root@test2-ubunut:/pyex/s13/day2# tree . ├── main.py ├── __pycache__ │ └── test.cpython-34.pyc └── test.py 1 directory, 3 files
用python3执行后，生成了一个__pycache__目录，里面有一个导入的test.py生成的.pyc文件，查看下文件类型可以看到是pyc数据文件：
root@test2-ubunut:/pyex/s13/day2# file __pycache__/test.cpython-34.pyc __pycache__/test.cpython-34.pyc: data
删除__pycache__目录，用python2执行，再次查看pyc文件,可以看到直接生成了一个test.pyc文件，查看文件类型也是python2.7的字节码编译文件：
root@test2-ubunut:/pyex/s13/day2# python main.py Hello world! root@test2-ubunut:/pyex/s13/day2# tree . ├── main.py ├── test.py └── test.pyc 0 directories, 3 files root@test2-ubunut:/pyex/s13/day2# file test.pyc test.pyc: python 2.7 byte-compiled
so, python并不是完全解释型语言，也是编译的，先把源码文件（.py）编译成字节码文件(.pyc)，而后再由Python虚拟机执行，执行过程如下：
source code --> Complier ---> bytecode --> PVM Interpreter ---> processor
.py .pyc
程序在执行的时候，会去找源码目录下的相对应.pyc文件，当然也是会对比文件的时间戳等信息来判定源代码是否做了更改，如果没有更改，直接执行.pyc文件，否则先编译再执行。
三. 数据类型
1. 数值型
数值型又分为整数型和浮点型,主要用以存储数值，数据类型是不允许改变的，也就是说如果改变数据的值，会重新分配内存空间。
>>> i = 30 >>> i 30 >>> id(i) #查看i的指向的内存地址，使用id()查看 10106752 >>> i = 28 >>> i 28 >>> id(i) #可以看到两个内存地址已经不一样了 10106688
删除对象引用，使用del：
>>> del i >>> i Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'i' is not defined
常用的数值类型：
整形(int) -- 通常被称为是整形或者整数，可以是整数或者复数，但不能有小数点；
长整形(long) -- 无限大的整数，整数最后一个标识用L表示，在python3.0中已经不区分长整形和整形了；
#python2.7 root@test2-ubunut:/pyex/s13/day2# python Python 2.7.6 (default, Jun 22 2015, 17:58:13) [GCC 4.8.2] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> 2**63 9223372036854775808L # 再看Python3里的： root@test2-ubunut:/pyex/s13/day2# python3 Python 3.4.3 (default, Oct 14 2015, 20:28:29) [GCC 4.8.4] on linux Type "help", "copyright", "credits" or "license" for more information. >>> 2**160 1461501637330902918203684832716283019655932542976
浮点型(float) -- 带小数点的数字；
整型(int)常用方法：
bit_length() 返回表示该数字的二进制站位最少位数：
>>> i = 30
>>> i.bit_length()
5
conjugate() 返回该复数的共轭复数
>>> i.conjugate()
30
__abs__ 该数值的绝对值，与abs()一样
>>> i.__abs__() 30
>>> abs(i)
30
real() 实数，无意义
>>> i.real
30
numerator 分子=数字大小
>>> i.numerator
30
imag 虚数，无实际意义
>>> i.imag
0
>
denominator 分母等于1
>>> i.denominator
1
还有一些内置的方法：
>>> i = 30 >>> result = i.__abs__() #绝对值 >>> print(i) 30 >>> result = i.__add__(3) #x+y >>> print(result) 33 >>> result = i.__truediv__(3) #除法， x/y >>> print(result) 10.0 >>> result = i.__divmod__(2) #相除，得到商和余数组成的元组 >>> print(result) (15, 0) >>> result = i.__floordiv__(3) #整除，x//y >>> print(result) 10 >>> result = i.__float__() #将数值转换为浮点数 >>> print(result) 30.0 >>> result = i.__int__() #将数值转换为浮点数 >>> print(result) 30 >>> result = i.__invert__() #反转(~) -(x+1） >>> print(result) -31 >>> result = i.__lshift__(2) #左移 >>> print(result) 120 >>> result = i.__mod__(3) #余 >>> print(result) 0 >>> result = i.__mul__(3) #乘积 >>> print(result) 90 >>> result = i.__pow__(4) #幂，次方 >>> print(result) 810000 >>> result = i.__radd__(4) #相加，y+x >>> print(result) 34 >>> result = i.__rand__(5) #y&x >>> print(result) 4 >>> result = i.__repr__() #转换为解释器可以读取的形式 >>> print(result) 30 >>> result = i.__str__() #转换为人阅读的形式，没有适用于人阅读形式的话，则返回阅读器形式 >>> print(result) 30 >>> result = i.__rfloordiv__(50) #y//x >>> print(result) 1 >>> result = i.__rsub__(3) #y-x >>> print(result) -27 >>> result = i.__rtruediv__(5) #x/x >>> print(result) 0.16666666666666666 >>> result = i.__rxor__(10) #y^x >>> print(result) 20 >>> result = i.__xor__(10) #x^y >>> print(result) 20
2. 字符型
字符型是Python中最常用的数据类型，创建字符串很简单，使用赋值方法，用单引号或者双引号将值引住，在Python里，单引号和双引号，我们可以不加区分的使用它；
>>> msg = 'Welcome to Beijing'
>>> msg1 = "Welcome to Beijing"
Python访问字符串的值，可以直接输入变量名即可：
>>> msg 'Welcome to Beijing' >>> msg1 'Welcome to China'
>>> print(msg,msg1)
Welcome to China Welcome to China
如果要输入多行，可以使用三个单引号/双引号来格式化输出：
>>> msg2 = '''
... 欢迎来到中国
... 欢迎来到北京
... 欢迎来到地球
... '''
>>> print(msg2)
欢迎来到中国
欢迎来到北京
欢迎来到地球
# 也可以使用转义字符>>> msg3 = '中国\n北京\n海淀' >>> print(msg3) 中国 北京 海淀
常见的转义字符：
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
字符串运算符
+ 字符串连接：
>>> a = 'hello' >>> b = 'world' >>> a + b 'helloworld'
* 重复输出字符串
>>> a*5 'hellohellohellohellohello' ####hello world##### >>> print('hello world'.center(20,'#')) ####hello world#####
[] 通过索引值获取字符串中的字符
>>> a[1] 'e' >>> a[0] 'h'
: 截取字符串中的一部分，也叫切片
>>> a[:] #只输入一个:是显示字符串所有信息 'hello' >>> a[1:] #从左边第一个索引位置开始到最后 'ello' >>> a[1:5] #从第一个索引到第5个索引 'ello'
in 成员运算符，如果字符串里包含的话为True，否则为False
>>> 'he' in a True >>> 'haha' in a False
not in 成员运算符，如果不包含为True，否则为False
>>> 'haha' not in a True >>> 'ha' not in a True >>> 'h' not in a False
% 格式字符串
>>> a = '%s显示的内容' >>> print('第一行是打印的\n第二行才是打印的附加内容：%s'%a) 第一行是打印的 第二行才是打印的附加内容：%s显示的内容
Python 字符串格式化
Python支持格式化字符串的输出，最常用的方法就是%s，如上面刚才输出的格式化字符串
格式化的符号：
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
常用方法：
strip 移除空白
常用于和捕捉用户输入等场景，移除空白字符：
>>> n = input('请输入你的名字:') 请输入你的名字: daniel >>> print(n) daniel #使用strip之后就能脱掉空白 >>> n = input('请输入你的名字:').strip() 请输入你的名字: daniel >>> print(n) daniel
split 分割,并将结果保存在一个列表里，默认以空白分割，可以自行指定
>>> n = 'hello world' >>> n.split() ['hello', 'world']
len 取字符串长度
>>> print(len(n)) 11
index 索引,获取指定字符的下标，但是如果输入一个不存在的字符的时候会报错，因此推荐使用find方法，find在查找不存在时返回-1
>>> n.index('h') 0 >>> n.index('e') 1
: 切片,上面已经说明了，这里不再赘述
其他的方法
>>> n = 'hello world' >>> n.capitalize() #首字母变大写 'Hello world' >>> a.casefold() #大写变小写，小写变大写 'hello world' >>> a.center(20) #居中显示，需要指定一个位长度，可选指定一个填充符号，默认空白 ' hello world ' >>> a.center(20,'#') '####hello world#####' >>> a.count('h') #统计指定字符出现次数 1 >>> a.encode('utf8') #编码转换 b'hello world' >>> a.endswith('d') #判断是否是指定字符结束，是为True，否为False True >>> a.endswith('a') False >>> a.startswith('h') #判断是否是指定字符开始，是为True，否为False True >>> a.startswith('a') False >>> a.expandtabs() #将tab转换为空格，默认为一个tab为8个空格 'hello world' >>> a.find('b') #查找指定字符串，如果有返回下标，否则的话显示-1 -1 >>> a.isalnum() #是否是数字和字母 False >>> a.isalpha() #是否是字母 False >>> a.isdecimal() #是否是十进制 False >>> a.isdigit() #是否数值 False >>> a.isidentifier() # False >>> a.islower() #是否小写 True >>> a.isnumeric() # False >>> a.isprintable() True >>> a.isspace() #是否是空格 False >>> "".join(a) #连接 'hello world' >>> a = 'i am is daniel' >>> a.partition('is') #以指定字符串为分隔符分割字符串并转换为元组格式 ('i am ', 'is', ' daniel') >>> a = 'I an is {}, i am from {}' >>> a.format('daniel','shanxi') #字符串格式化，动态参数 'I an is daniel, i am from shanxi' >>> a.upper() #变大写 'I AM IS DANIEL' >>> a.lower() #变小写 'i am is daniel' >>> b = a.replace('i','I') #替换， >>> b 'I am Is danIel' TypeError: replace() takes no keyword arguments >>> b = a.replace('i','I',1) #指定替换几次 >>> b 'I am is daniel' >>> b.title() #将每个单词首字母变大写 'I Am Is Daniel'
3.列表
列表是Python最常用的数据类型，格式是方括号内[]包含以逗号分隔的字符或者数字。列表中的的每个元素都有一个位置(下标或者叫索引),从0开始...
创建列表：
>>> l1 = [1,2,3,4,5,]
或者
>>> l2 = list([5,4,3,2,1,])
常用操作：
获取列表中的值：
>>> l1 [1, 2, 3, 4, 5] >>> l1[1] 2
append 追加
>>> l1.append(6) >>> l1 [1, 2, 3, 4, 5, 6]
count 统计列表中的元素数量
>>> l1.count(6)
1
extend 扩展列表，通常用于把一个列表扩容到另一个列表中
>>> l1 [1, 2, 3, 4, 5, 6] >>> l1.extend(l2) >>> l1 [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
index 查看元素索引,返回的是第一个要查找元素的位置下标
>>> l1.index(5)
4
insert 插入元素,需要指定一个要插入的下标位置
>>> l1.insert(1,9) >>> l1 [1, 9, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
pop 删除元素, 可以指定下标，默认删除最后一个元素。而且pop比较特别的是，删除后还可以返回删除了哪个元素；
>>> l1 [1, 9, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1] >>> l1.pop() 1 >>> l1 [1, 9, 2, 3, 4, 5, 6, 5, 4, 3, 2] >>> l1.pop(1) 9 >>> l1 [1, 3, 4, 5, 6, 5, 4, 3, 2] >>> p = l1.pop(4) >>> p 6
remove, 删除元素，必须指定一个元素名称，和pop不一样。
>>> l1.remove(2) >>> l1 [1, 3, 4, 5, 6, 5, 4, 3, 2]
sort 排序元素。 python2中如果元素有数字和字符串，会按照ASCII码来排序，但在Python3中数字和字符串排序会报错；
Python 2.7.10 (default, Oct 23 2015, 19:19:21) [GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> l1 = ['c','b','d','z',1,3,2,5,3] >>> l1.sort() >>> l1 [1, 2, 3, 3, 5, 'b', 'c', 'd', 'z'] Python3: >>> l1 = ['c','b','d','z',1,3,2,5,3] >>> l1.sort() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unorderable types: int() < str() >>> l2 = [3,5,2,1,2,34,23,5] >>> l2.sort() >>> l2 [1, 2, 2, 3, 5, 5, 23, 34]
reverse 反转
>>> l2.reverse() >>> l2 [34, 23, 5, 5, 3, 2, 2, 1] >>> l1.reverse() >>> l1 [3, 5, 2, 3, 1, 'z', 'd', 'c', 'b']
删除元素 del ,也可以使用列表切片的形式来一次删除多个元素
>>> l1.reverse() >>> l1 [3, 5, 2, 3, 1, 'z', 'd', 'c', 'b'] >>> del l1[1] >>> l1 [3, 2, 3, 1, 'z', 'd', 'c', 'b'] >>> del l2[4] >>> l2 [34, 23, 5, 5, 2, 2, 1] >>> del l1[4] >>> l1 [3, 2, 3, 1, 'd', 'c', 'b'] >>> del l1[1:3] >>> l1 [3, 1, 'd', 'c', 'b']
修改元素
>>> l1 [3, 1, 'd', 'c', 'b'] >>> l1[2] = 'D' >>> l1 [3, 1, 'D', 'c', 'b']
列表元素个数 len
>>> len(l1)
5
max 返回列表中最大的元素，也是存在python3中不能字符串和数字比较的问题
>>> max(l1) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unorderable types: str() > int() >>> max(l2) 34
Python2:
>>> l1 = ['a','z',1,3,33]
>>> max(l1)
'z'
返回最小元素 min, 同max
Python2 >>> min(l1) 1 Python3 >>> min(l1) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unorderable types: str() < int()
列表切片 :
>>> l1 [3, 1, 'D', 'c', 'b'] #列出前三个元素 >>> l1[:3] [3, 1, 'D'] #列出最后一个元素 >>> l1[-1:] ['b'] #列出从第一个元素至倒数第二个元素 >>> l1[:-1] [3, 1, 'D', 'c'] #隔一个列出一个元素，这里在第三段设定一个步长即可； >>> l1[::2] [3, 'D', 'b']
copy 复制列表，但这里是浅copy, 也就是只copy一层元素，如果列表中嵌套了列表或者字典，这里的copy只是copy了第一层，嵌套的元素只是copy了一个内存指针，如果嵌套的元素变化，copy过来的元素也是会变的；
#定义一个l3列表，里面嵌套两层列表 >>> l3 = [1,2,3,['a','b','c',['A','B','D']],4,5] #l4从l3 copy >>> l4 = l3.copy() #列出l3元素 >>> l3 [1, 2, 3, ['a', 'b', 'c', ['A', 'B', 'D']], 4, 5] #列出l4元素 >>> l4 [1, 2, 3, ['a', 'b', 'c', ['A', 'B', 'D']], 4, 5] #修改l3嵌套的列表值 >>> l3[3][1] = 'X' >>> l3[3][2] = 'Y' >>> l3[3][3] = 'Z' #而后查看l3和l4的元素，发现l3改了之后l4也跟着改了 >>> l3 [1, 2, 3, ['a', 'X', 'Y', 'Z'], 4, 5] >>> l4 [1, 2, 3, ['a', 'X', 'Y', 'Z'], 4, 5] #如果要深度拷贝，可以使用Python标准模块copy的deepcopy方法： >>> import copy >>> l3 = [1, 2, 3, ['a', 'X', 'Y', 'Z'], 4, 5] >>> l5 = copy.deepcopy(l3) >>> >>> >>> l5 [1, 2, 3, ['a', 'X', 'Y', 'Z'], 4, 5] >>> l3 [1, 2, 3, ['a', 'X', 'Y', 'Z'], 4, 5] >>> l3[3][0] = 'A' >>> l3 [1, 2, 3, ['A', 'X', 'Y', 'Z'], 4, 5] >>> l5 [1, 2, 3, ['a', 'X', 'Y', 'Z'], 4, 5]
4. 元组
元组与列表相似，但是元组中的元素不能修改，元组使用小括号(),元素中间用逗号隔开
创建元组:
>>> t1 = tuple((1,2,3,4,5,))
#或者
>>> t2 = (5,4,3,2,1,)
修改元组
元组中的元素是不能修改的，但是可以对两个元组组合，如下：
>>> t1[1] = 'a' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment #不允许修改 #组合元组 >>> t3 = t1 + t2 >>> t3 (1, 2, 3, 4, 5, 5, 4, 3, 2, 1)
删除元组
元组中的元素也是不能删除的，但是可以删除整个元组，使用del
>>> del t3[1] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object doesn't support item deletion >>> del t3 >>> print(t3) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 't3' is not defined
元组的索引
元组也是一个序列，所以也可以通过下标的方式访问元组内的元素，也可以切片显示
#获取所有元素 >>> t1 (1, 2, 3, 4, 5) #切片显示 >>> t1[1] 2 >>> t1[0] 1 >>> t1[0:2] (1, 2) >>> t1[0:2:1] (1, 2) >>> t1[0::1] (1, 2, 3, 4, 5)
元组常用操作：
count 统计指定元素个数
>>> t1.count(1)
1
index 显示指定元组下标，如果存在多个同名元素，只出现第一个指定元素的下标
>>> t1.index(2)
1
5. 字典
字典是一种可变容器模型，并且可以存储任意类型的对象，使用键值对格式，每个键值之间用":"分割，整个字典包括在一对{}中
键必须是惟一的，值不需要唯一；
值可以是任何数据类型，但键必须是不可变的，如字符串、数字或者元组；
注意，字典是无序的。
创建字典：
>>> dic1 = {'Name':'Daniel','Age':'19','Job':'OPS'}
访问字典：
#直接返回所有元素 >>> dic1 {'Age': '19', 'Name': 'Daniel', 'Job': 'OPS'} #通过下标的方式获取值 >>> dic1['Name'] 'Daniel' #推荐使用get方法，如果直接使用下标的话，如果键不存在的话，会抛出异常，如下： >>> dic1.get('Age') '19' >>> dic1['Sex'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'Sex' #get一个不存在的键,会返回一个None，也可以指定一个值，如果不存在，则返回指定的值 >>> print(dic1.get('Sex')) None >>> print(dic1.get('Sex','M')) M
修改字典
>>> dic1['Age'] = 18 >>> dic1.get('Age') 18
删除字典元素
>>> del dic1['Sex'] >>> dic1 {'Age': 18, 'Name': 'Daniel', 'Job': 'OPS'}
常用操作：
clear 清空字典
>>> dic2 = {'Name':'Jack'}
>>> dic2
{'Name': 'Jack'}
>>> dic2.clear()
>>> dic2
{}
copy 也是浅拷贝，上面列表方法中已经详细说明了，此处不赘述
>>> dic3 = dic1.copy() >>> dic3 {'Age': 18, 'Name': 'Daniel', 'Job': 'OPS'}
get 上面获取元素已经说明，推荐使用get方法获取键值
>>> dic3.get('Name') 'Daniel'
items 返回所有元素
>>> dic1.items() dict_items([('Age', 18), ('Name', 'Daniel'), ('Job', 'OPS')])
keys 以列表的形式列出所有key
>>> dic1.keys() dict_keys(['Age', 'Name', 'Job'])
values 以列表形式列出所有值
>>> dic1.values() dict_values([18, 'Daniel', 'OPS'])
pop 删除指定键值
>>> dic1.pop('Job') 'OPS' >>> dic1 {'Age': 18, 'Name': 'Daniel'}
setdefault 取回一个key，如果不存在可以指定一个value，如果没设值（Value），默认返回None
>>> dic1 {'Age': 18, 'Name': 'Daniel'} >>> dic1.setdefault('Job') >>> dic1 {'Age': 18, 'Name': 'Daniel', 'Job': None} >>> dic1.setdefault('Name') 'Daniel' >>> dic1.setdefault('Sex','M') 'M' >>> dic1 {'Age': 18, 'Name': 'Daniel', 'Sex': 'M', 'Job': None}
update 把指定字典中的键值更新到另一个字典中
>>> dic2.setdefault('Country','China') 'China' >>> dic2.update(dic1) >>> dic1 {'Age': 18, 'Name': 'Daniel', 'Sex': 'M', 'Job': None} >>> dic2 {'Sex': 'M', 'Age': 18, 'Name': 'Daniel', 'Country': 'China', 'Job': None}
popitem 随机删除字典里的一个键值，这个很恐怖，慎用，除非你知道可能产生的影响；
>>> dic1.popitem() ('Age', 18) >>> dic1.popitem() ('Name', 'Daniel')
fromkeys 用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
#语法： >>>dict.fromkeys(seq[, value])) >>> seq = ('name','age','sex') >>> dic4 = dict.fromkeys(seq,10) >>> dic4 {'age': 10, 'sex': 10, 'name': 10}
四. 数据运算：
1. 算数运算
a,b = 10,20
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
>>> a + b 30 >>> a - b -10 >>> a * b 200 >>> a / b 0.5 >>> a % b 10 >>> a ** b 100000000000000000000 >>> a //b 0
2. 比较运算
a,b = 10,20
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等, python 3中已经废弃 | (a <> b) 返回 true。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
>>> a,b = 10,20 >>> a == b False >>> a != b True # <>在Python3中已经废弃掉 >>> a <> b File "<stdin>", line 1 a <> b ^ SyntaxError: invalid syntax >>> a > b False >>> a < b True >>> a >= b False >>> a <= b True
3. 赋值运算：
a,b = 10,20
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
>>> c = a + b >>> c 30 >>> c += a >>> c 40 >>> c = c+a >>> c 50 >>> >>> c -= a >>> c 40 >>> c *= a >>> c 400 >>> c /= a >>> c 40.0 >>> c %= a >>> c 0.0 >>> c **= a >>> c 0.0 >>> c //= a >>> c 0.0
4. 逻辑运算
a,b = 10,20
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
>>> if a and b:print('true') ... true >>> if a or b:print('True') ... True >>> if not a: ... print('a为空') ... else: ... print('a不为空') ... a不为空
5. 身份运算
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Author: DBQ(Du Baoqiang) x = 15 y = 28 z = (15,20,'x','tom','jerry') if x in z: print('%s是z的成员之一'%x) if y not in z: print('%s不是z的成员,应该滚粗'%y)
6. 位运算符
| 运算符 | 描述 |
| & | 按位运算，参与运算的两个数值都为1，则为真 |
| | | 按位或运算，只要对应的两个二进位有一个为1时，为真 |
| ^ | 按位异或运算，当两对应的二进位相异时，结果为真 |
| ~ | 按位取反运算符 -(x+1) 对数据的每个二进位取反，1变0，0变1 |
| << | 左移，高位丢弃，低位补0，往左移1位*2，2位*4，所以左移一般数值会变大 |
| >> | 右移，移动1位除2，2位除4... 所以右移一般数值会越小 |
7. 运算符优先级
优先级从高到低：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
扫一扫
51万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
