一、运算符

算术运算

+ 加
- 减
* 乘
/ 除
% 取余（相除后的余数）
** 取幂（注意 ^ 并不执行该运算，你可能在其他语言中见过这种情形）
// 相除后向下取整到最接近的整数

按位运算

x << y 左移Y位 
3<<2：解法:11向左移动两位变为1100,即12 .

x >> y 右移Y位
3>>2：解法:11向右移动两位变为0.

x & y 按位与，都为1为1，否则为0
3&5 ：解法：3的二进制补码是 11,  5的是101, 3&5也就是011&101,先看百位(其实不是百位,这样做只是便于理解) 一个0一个1,根据(1&1=1，1&0=0，0&0=0，0&1=0)可知百位应该是1,同样十位上的数字1&0=0,个位上的数字1&1=1,因此最后的结果是1

x | y 按位或，都为0为0，否则为1
4|7： 解法：按位并的计算规律和按位与的很相似，只不过换了逻辑运算符，并的规律是： 1|1=1 ,1 |0=1, 0|0=0\.   4|7转换位二进制就是:100|111=111\.  二进制111即为十进制的7.小技巧：利用按位并可以将任意二进制数的最后一位变为1,即就是X|1.

~ x 按位取反，方法:   将二进制数+1之后乘以-1,x的按位翻转是-(x+1) . 注意,按位运算符是单目运算符.
~3  ：解法:3的二进制是11, -(11+1)=-100B=-4D. (注:B和D分别表示二进制和十进制).

x ^ y 按位异或，对位相加，特别要注意的是不进位
1^1：解法:1+1=0.(本来二进制1+1=10,但不能进位,所以结果是0)

赋值运算符

=
所有单目运算符加上=

比较运算符

符号使用情况          布尔型      运算符
5 < 3                False      小于
5 > 3                True       大于
3 <= 3               True       小于或等于
3 >= 5               False      大于或等于
3 == 5               False      等于
3 != 5               True       不等于

逻辑运算符

逻辑使用情况          布尔型     运算符
5 < 3 and 5 == 5    False     and - 检查提供的所有语句是否都为 True
5 < 3 or 5 == 5     True      or - 检查是否至少有一个语句为 True
not 5 < 3           True      not - 翻转布尔值

恒等运算符

二、数据类型

Number 数字类型

Number可以用到两种 python 数据类型：

int - 表示整数值
float - 表示小数或浮点数值

常用数字函数：

Bool 布尔类型

True 为真
False 为假

非0都为True
0为假
可以与Number类型进行强制转换,特别注意，要写布尔类型时，务必不要带引号，“True”是字符串类型，True才是布尔型。

String 字符串类型

String用到的python数据类型：

  str

可以使用双引号 " 或单引号 ' 定义字符串。

String运算
假设a = Hello，b = Python

String内常用转义字符

String常用方法

List列表类型

    list 使用方括号创建列表

• 使用列表的索引对列表的项进行查看与更新，注意是从0开始计数的，列表第一项索引为0，还可以使用复数进行索引，-1代表倒数第一项。
  例：

>>> lst_of_random_things = [1, 3.4, 'a string', True]
>>> lst_of_random_things[1]
3.4
>>> lst_of_random_things[-1]
True

• 列表也可进行切片操作，类似字符串切片，含头不含尾，负数同样代表倒数第几项。
  例：

>>> lst_of_random_things = [1, 3.4, 'a string', True]
>>> lst_of_random_things[1:2]
[3.4]
>>> lst_of_random_things[:2]
[1, 3.4]
>>> lst_of_random_things[1:]
[3.4, 'a string', True]
>>> lst_of_random_things[-1:]
[True]

注意到上面，索引时，取一项是个变量，切片时即使取一项，也是个列表。

列表运算

列表方法

Tuple元组类型

tuple 常用小括号，不过小括号是可选选项，如果小括号并没有对解释代码有影响，程序员经常会忽略小括号

元组同list列表，是有序存储的对象集合，可以用索引查找，但是与列表不同的是，元组不可变，你无法向元组中添加项目或从中删除项目，或者直接对元组排序。
修改元素是非法的，但可以进行+，*，for，in的运算
删除元素是非法的，只能删除整个元组

元组还有个特性叫元组解包，还可用*来解包，如下：

dimensions = 52, 40, 100
length, width, height = dimensions
print("The dimensions are {} x {} x {}".format(length, width, height))

例二：

a = 1,2,3
print(*a)
#输出
1 2 3
#如果直接输出a应该是(1,2,3)

Set集合类型

集合是一个包含唯一元素的可变无序集合数据类型。集合的一个用途是快速删除列表中的重复项。

set()或者{}来表示

集合和列表一样支持 in 运算符。和列表相似，你可以使用 add 方法将元素添加到集合中，并使用 pop 方法删除元素。但是，当你从集合中拿出元素时，会随机删除一个元素。注意和列表不同，集合是无序的，因此没有“最后一个元素”。
Set集合常用操作举例
如图理解

集合操作

1》交集
>>> x={1,2,3,4}
>>> y={3,4,5,6}
>>> x
set([1, 2, 3, 4])
>>> y
set([3, 4, 5, 6])
>>> x&y
set([3, 4])
>>> x.intersection(y)
set([3, 4])
2》并集
>>> x | y #集合并集
set([1, 2, 3, 4, 5, 6])
>>> x.union(y)
set([1, 2, 3, 4, 5, 6])
3》差集
>>> x-y # x与y的差集
set([1, 2])
>>> x.difference(y)# x与y的差集
set([1, 2])
>>> y-x # y与x的差集
set([5, 6])
>>> y.difference(x)# y与x的差集
set([5, 6])
4》对称差集
>>> x^y
set([1, 2, 5, 6])
>>> y^x
set([1, 2, 5, 6])
>>> x.symmetric_difference(y)
set([1, 2, 5, 6])
>>> y.symmetric_difference(x)
set([1, 2, 5, 6])
5》集合的子集和超集
>>> x
set([1, 2, 3, 4])
>>> z
set([1, 2, 3])
>>> z.issubset(x)#z是x的子集
True
>>> x.issuperset(z)#x是z的超集
True

Dictionary 字典

字典是存储的是唯一键到值的映射，键不能重复！如果给重复的键赋值，只会保留最后一次赋值的值。另外键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。
我们可以像检查某个值是否在列表或集合中一样，使用关键字 in 检查值是否在字典中。

dict 常用大括号{key:value}表示（注意如果没有key:value则为set）

操作

• 访问字典的值：通过键索引
• 修改字典的值：通过建索引
• 删除字典元素，del 字典名[键索引]
• 清空字典，字典名.clear()
• 删除字典，del 字典名

字典Dict方法

三、可变性与不可变性

可变性是指对象创建完毕后，我们是否可以在原内存下更改该对象。如果对象（例如列表或字符串）可以更改（地址不变的情况下，修改内容），则是可变的。但是，如果无法更改对象以创建全新的对象（必须新生成一块内存来存修改后的值，例如字符串），则该对象是不可变的。

可变：list,dict
不可变：int,string,float,tuple

可变例子：

def dict_test(): 
  a = {} 
  b = a 
  print(id(a)) 
  a['a'] = 'hhhh' 
  print('id a:' + str(id(a))) 
  print('a:' + str(a)) 
  print('id b:' + str(id(b))) 
  print('b:' + str(b)) 
if __name__ == '__main__': 
  dict_test()

输出：

140367329543360

id a:140367329543360

a:{'a': 'hhhh'}

id b:140367329543360

b:{'a': 'hhhh'}

如图：

地址不变

不可变例子：

def int_test():
  i = 77 
  j = 77 
  print(id(77)) #140396579590760 
  print('i id:' + str(id(i))) #i id:140396579590760 
  print('j id:' + str(id(j))) #j id:140396579590760 
  print i is j #True 
  j = j + 1 
  print('new i id:' + str(id(i))) #new i id:140396579590760 
  print('new j id:' + str(id(j))) #new j id:140396579590736 
  print i is j #False 
if __name__ == '__main__': 
  int_test()

如图：

地址变了

特别注意：
在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]
a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

四、有序和无序

有序：list，tuple
无序：dict，set