一.python基础:
-
数据类型:
原始类型: int float byte 复合类型: 由其他原始类型组合起来的类型 list dict cuple -
运算符和表达式:
算术运算符:
加 / 减 / 乘 / 除 / 取模 / 幂 / 地板除
+ - * / % ** //
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