  算术运算符:
          加 / 减 / 乘 / 除 / 取模 / 幂 / 地板除
          +    -    *    /     %     **     //

  python2 的 除:
  10 / float(20)

  位运算符[二进制之间的运算]:
  bin(60) 转换成二进制数
  int('1100',2)   将二进制转换成十进制
  &	按位与        都为1 才为1    
  |	按位或		 存在1 即为1
  ^	按位异或		 相同的为0,不同的为1
  ~	按位取反	     正数的补码，反码都是其本身
  				负数的补码是:符号位不变,其余各位求反,末位加1 ，既11111
  				反码是:符号位为1,其余各位求反,但末位不加1 ，既11110
  			
  				假设有一个数~9，计算步骤如下，9=1001
  				其补码为01001，
  				对其取反10110，这个数是在内存中存放的，现在需要装换成原码，既先减1，然后取反得 
  				11010，符号位为1是负数，既-10
  <<	左移
  >>  右移

按位取反:

  ---
  正数的补码和反码都是其本身,但是前面要加上正数的符号位 "0"
  ---
  负数的符号位是"1"
  负数的补码是:符号位不变,其余各位求反,末位加1
  负数的反码是:符号位不变,其余各位求反
  ---
  二进制数在内存中是以补码的形式存放的
  ---


  60的按位取反计算:
  
  	第一步:
  	计算60的 [补码] 和 [反码]:
  
  				原码	补码 	反码
  		十进制	60
  		二进制	111100  0111100	0111100
  
  
  	第二步:
  	取反[取反操作是对补码进行取反]:
  
  
  						补码
  						1000011
  
  								反码
  								补码 - 1
  								1000010
  				原码
  				1111101
  				1 代表是负数
  			 	111101 转换成十进制为61
  				-61

比较运算符[返回布尔类型]:

  ==	等于
  !=	不等于
  >   大于
  <   小于

逻辑运算符:

	and		与 	同时True才为True
	or		或  只要存在True 则为True
	not 	非  取反

	逻辑运算的短路功能:
	前面False后面就不会再计算:
	1+2 >4 and (2+2) == 4

	前面是True就不会再计算后面:
	1+2 <4 or (2+2) == 3　

---
	def add(x, y):
		print("%d + %d" %(x, y))
		return x+y
	add(1, 2) > 4 and add(2, 3) == 5
	   ...: 
	1 + 2
	Out[2]: False

---
	def add(x, y):
		print("%d + %d" % (x, y))
		return x+y
	add(1, 2) < 4 and add(2,3) < 6
	...: 
	1 + 2
	2 + 3
	True

---
	def add(x, y):
		print("%d + %d" % (x, y))
		return x+y
	add(1, 2) < 4 and add(2,3) < 4
	...: 
	1 + 2
	2 + 3
	False

其他运算符:

  =		赋值运算符
  in 		成员运算符
  not in 	成员运算符
  is 		身份运算符, 比较两个元素的id; 列表不能用is 做比较
  is not 	身份运算符
  		is 使用的环境经常拿来判断是不是None;

表达式与优先级:

  1. 一元高于二元
  2. 数值高于逻辑
  3. 算术运算高于位运算
  4. 乘除高于加减
  5. 拿不准时加括号

程序结构:

  1.	顺序结构
  2.	分支结构
  3.	循环结构

  关于 SWITCH
  Python中并没有switch结构,因为'switch'结构完全可以由'if elif else'语句来实现
  
  switch实现方法:
  粗糙版:
  #coding:utf8  
  #add minus divide using python  
  from __future__ import division  
  x=1  
  y=2  
  operator='/'  
  result={  
  "+":x+y,  
  "-":x-y,  
  "*":x*y,  
  "/":x/y  
  }  
  print(result.get(operator)) 		

  改进版:
  #!/usr/bin/env python
  # -*- encoding:utf-8 -*-
  
  class calculate:
      def __init__(self, x, op, y):
          self.x = x
          self.op = op
          self.y = y
  
      def count(self):
          result={
          "+":self.x+self.y,
          "-":self.x-self.y,
          "*":self.x*self.y,
          "/":self.x/self.y}
          print(result.get(self.op))
  
  mark = calculate(10,"+",2)
  mark.count()

python的三元运算
```
  a = 4
  b = a if a > 0 else 0
```

RANGE函数

  range(x) 		[0,x)
  range(m, n) 	[m, n)
  range(m, n, s)	[m,n),步长为s

break 子句

  * 只能出现在循环结构中
  * 用于跳出当前循环结构

continue子句:

  * 只能出现在循环结构中
  * 用于跳过此次迭代的剩余操作

else子句:

  循环结构的else子句是python特有的,用于表示一个循环不是经过'break'跳出循环,提前结束循环,而是正常退出的,才会执行else中的语句;

二.内置容器:

列表

  * list是最常用的线性数据结构
  * list是一系列元素的有序组合
  * list是可变的
  
  列表的操作:
  定义列表:
  li = []
  li = list()
  li = [1, 2, 3]

  查看帮助文档:
  help(list)
  增:append, extend, insert
  删:clear, pop, remove
  改:reverse, sort
  查:count, index
  其他:copy

  增:
  li = []
  append:只能一个一个增加
  li.append(3)
  
  extend:扩展
  li.extend([5,6,7])
  li
  [3, 5, 6, 7]

  insert:位置之前插入
  li.insert(0, 0) 在第一个之前插入0

  删:
  clear:清空列表
  li.clear()

  remove:从左开始删除指定元素一个,如果删除的元素不存在会报错ValueError
  li.remove(3)  删除元素3
  
  pop:删除指定位置元素:如果不存在会报错IndexError
  li.pop()	删除最后一个元素
  li.pop(3)   删除key是3的元素

  改:
  reverse:颠倒列表顺序:
  sort:从小到大排序:	仅用于简单数字排序
  sort(reverse=True) 从大到小排序:

  查:
  count:显示匹配元素个数
  li.count(3)
  
  其他:
  index(3):返回指定元素在列表中的位置;如果不存在会报ValueError:
  index(value, [start, [stop]]) 

  copy: 深拷贝,会生成一个新的list
  		赋值是浅拷贝,浅拷贝的数据修改会对原来的list产生影响;

  下标操作:
  li[1]
  
  li[1] = 10

  切片:
  li[3:5]:  前面是闭区间  后面是开区间
  li[3:]
  li[:]  效果和copy是一样的,效率会比copy快;
  li[:4] 
  li[4:-2]	 切到倒数第二个;后面是开区间
  li[-4:-1]
  li[2:6:2]:	start, stop ,步长
  li[6:2:-1]  start,stop ,反向显示,步长为1
  li[6:2:-2]	start,stop,反向显示,步长为2
  li[::-1]
  li[::2]

元组[tuple]:

  tuple和list大多数地方类似
  tuple是不可变结构
  tuple只能获取值

  定义一个元组:
  t = ()
  t = tuple()

  count:统计元素个数
  index:返回指定元素在元组中的位置

  下标操作[通过下标获取value]:
  t[1]

PACKING & UNPACKING

  PACKING		:把多个变量的值变成一个元组或者列表,默认是变成元组
  UNPACKING	:也可以把一个元组或者列表赋值给多个变量

  x, *y = (1, 2, 3, 4)
  print(x)
  1
  print(y)
  [2, 3, 4]

  *x, y = (1, 2, 3, 4)
  print(x)
  [1, 2, 3]
  print(y)
  4

  *_ 这个表示赋值给一个不能用的变量:

  x, *_, y = (1, 2, 3, 4)
  print(x)
  1
  print(y)
  4

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

集合:

  集合的含义和数学上集合的含义相同
  集合不是线性结构
  * 集合元素是唯一的
  集合元素是可hash的
  
  集合的操作:
  初始化:
  s = set()
  s = set([1, 2, 3])

  增:
  s.add(3) 					//添加一个元素
  s.update([3, 4, 5, 6])		//集合添加list中的多个元素

  删:
  remove:		删除,删除不存在的元素会抛出异常;
  discard:	删除,删除不存在的元素不会抛出异常;
  clear:		清空
  pop:		随机删除集合中的一个元素
  
  集合运算:
  union					并集  			a | b
  intersection			交集  			a & b
  difference				差集,不可交换的	a - b
  symmetric_difference	集合之差的并集   	a ^ b

  集合判断[返回布尔值]:
  issubset	子集
  issuperset	超集
  isdisjoint

字典:

  * 字典是一种无序集合
  * 字典是一种KV结构
  * value可以是任何对象
  * key是唯一的
  * key必须是可hash对象

  字典的操作:
  d = dict()
  d = {'a':5, 'b':4}
  d['a']
  
  d.keys()
  dict_keys(['b', 'a'])

  遍历 key:
  for key in d.keys():
  	print(d[key])

  遍历 value:
  for value in d.values():
  	print(value)

  遍历key和value:
  for key,value in d.iterms():
  	print(key, value)
  	print('%s => %s' %(key, value))

  d.iterkeys()	返回的是一个生成器;
  
  pop,popitem 	用于删除元素
  d.pop('key')	需要指定key,删除不存在的值返回KeyError
  d.pop('key',6)	删除不存在的值将返回 6
  
  增加字典元素:
  d['c'] = 7

posted on 2016-02-24 20:00 roach57 阅读(322) 评论(0) 收藏举报

刷新页面返回顶部

导航

一.python基础:

二.内置容器: