一. 脚本格式，编程风格及数据基本介绍
一. python 脚本格式
前2行格式如下，第一行是表示用python执行，第二行是通用字符集，任何语言都能正常显示。
1)#！/usr/bin/env python
2)#_*_coding:utf-8_*_ （貌似写成#coding=utf-8也行）
其实上面的语句怎么写都行，只要符合coding[ := ]s*([-w.]+); 意思就是coding后面要紧紧的跟着冒号或者等号，之后可随意多少个空格，然后接utf-8，coding=utf-8前后随意加字符都行。
w匹配的是能组成单词的字符
s表示空格
3)第三行最好用双引号来写一个脚本文档，来对此脚本做解释
"......."
4)多行注释，三个双引号开头，三个双引号结尾。
"""
......
......
"""
注意，第一行很多人会写成#!/usr/bin/python，如果是系统默认有的python这样写是没错的，但是如果你升级了一个python，那么这个新版的python可能就会安装在usr/local/bin目录下，如果加上env，就会直接使用 新版的python，因为新装的python会自动写在env中。
2017/8/11 15:03
二. 编程风格
1. 语法要求，缩进统一： 属于同一代码块，也就是同一级别，相互之间没有依存关系的语言缩进必须是一致的，不然就会报错
注意，如果是在window下用notepad写的代码，用tab进行缩进时，需要在notepad中进行tab建和空格键的转换设置，在首选项中可设置。
2. 变量由字母，下划线，数字组成
标识符的第一个字符必须是字母（大小写都行）或者一个下划线
标识符的其他部分可以由字符（大小写）*，下划线或数字（0-9）组成。
无效的标识符例子有 2things; this is a man; my-name
3.python编译过程--脚本解释型语言
在运行脚本之后，得到结果之前
1)python先将脚本编译成字节码（pyc,pyo)
脚本中只要import 函数，就会生成pyc文件
2)python虚拟机解释并运行字节码文件
C语言--编译型语言的内部机制
1）先将源代码编译成机器码，生成可执行文件
2）运行可执行文件
4，动态语义--在赋值时确定数据类型
例如 a=5 b=string, 那么用type(a)=int; type(b)=string
5. python之禅
进入python，输入import this 会看到
2017/8/14/周一
三. python一切数据皆为对象
包含了一系列的数据和操作这些数据的方法的一个整体，就叫作对象。
一切变量都是对数据对象的引用
1. python内部的引用计数，sys.getrefcount
import sys
a='hello'
sys.getrefcount('hello')
输出为3---python中初始数为3
e='hello'
sys.getrefcount('hello')
输出为4
a=1
sys.getrefcount('hello')
输出为3,说明引用被销毁一次。
2.数据类型的组成
组成分为3部分。
身份： id方法来看一看他的唯一标示符，内存地址靠这个哦！
类型 ：type来看一看。
值： 表示数据项。
某书里的傲娇结论：python里一切都是指针，所以不用再考虑指针这个问题了！
3. 常用基本数据类型.
int 整型
boolean 布尔
a=True
b=False
注意：布尔值首字符必须大写
string 字符串
list 列表
tuple 元祖
dict 字典
4.数据类型的可变和不可变，意思就是如果变量的值改变后，id值是否改变
不可变类型：int，string，tuple
例如a = 5，看一下id值；然后a = 6, 再看一下id值，2个值是不同的
可变类型: list，dict
例如a = [1,2,3]
a.append(4),此时a=[1,2,3,4];但是改变前后，a的id值是不变的
5.如果给一个变量赋值后，它的数据类型就确定了，不能再随意改变
比如a="4",此时不能在进行a+1的运算，因为"4"和1不是一个数据类型，不能计算。如果想计算，需要先把字符串a转变为整型，方法就是int(a)+1.
二. 字符串认知与应用
认知1.字符串概念
认知2.ascii unicode utf8到底是啥
一 . len()
len:全写是length,是计算容量的函数；例如a = "1234", len(a)=4
如果是中文字符，比如a = "哈", len(a)=3, 那么怎么显示正确的数目呢？ （在python3中不存在这个问题)
方法一：
在中文字符前加u 例如：a = u"哈" ,len(a)值为1
方法二：
a ="哈哈"
g = a.decode('utf-8')
print len(g)值为2
也可以直接写成 a = "哈哈".decode('utf-8'), 其实最好是a.decode('utf-8')
注意:
就是在脚本中标明#coding=utf-8，len的值还是按ascii码来计算
比如
#coding=utf-8
d = "中文"
print len(d)
执行python test.py的值为6
二.转义符让文本更好处理
要转义的字符前面加个反斜杠
三. 字符串前面跟着的小尾巴到底是什么东西
例如:print r"
" 其中的字母 r 表示不对 斜线 进行转义，输出为
四. 访问子字符串
成员有是有序排列的,可以通过下标偏移量访问到它的一个或者多个成员
a = "abcd"
print a[0] 第一个字符
print a[-1] 最后一个字符，也可以是print a[len(a)-1]
a[0: ] 输出为abcd
a[0:1] 输出为a
a[0:2] 输出为ab
a[1:3] 输出为bc 注意第一项不是0，那么输出项是从a[1]开始的3-1位，并不会输出a[3]
a[:-1] 输出为abc
五. 替换字符串--replace()方法
a = "abc"
a.replace('a','hh')
'hhbc'
但是此时print a，输出还是abc，说明replace()并不会改变原变量值，如果想修改原值，可以重新赋值，比如
a = a.replace("a","his")，输出为hisbc
六.查找字符串--find()方法
a.find("hong") 如果找到了字符串"hong"会返回一个整型，这个数值是a字符串对象hong第一个字母"h"的下标 ，如果找不到"hong",会返回-1
如果有多个hong，怎么指定某一个hong呢，例如
a = "hong my name is hong"
此时用a.find("hong") 输出结果会是0，就是从第0个字符开始的就是hong，怎么找后面的那个hong呢？
a.find("is") 输出为13
a.find("hong",13)就会输出is后面的hong了，注意用help(a.find)文档
七. 字符串拼接
1.直接用加号来拼接，太耗资源，超级丑陋之千万别用。
2.可选方案之字符串模板
用%s....%来拼接： %s表示要插入字符串，叫做占位符；%后面的字符表示要插入字符串的内容
占位符通常有2种，%s：字符串的占位符， %d：数字的占位符。
例如
1) print "my name is hong, %s" % "i am 18"
2) print "my name is %s %s" % ("hong", "ten years old")
3) print "my name is hong, i am %d" % 18
4）print "this is a %s %s" % (4,10)，输出为this is a 4 10. 也就是说可以强制把整型转为字符串，小括号里的数据要按顺序写
3.优秀的拼接方案之使用join()，这种方法在参数是变量的情况比较好用
>>> a = "a"
>>> b = "bcd"
>>> c = "12cd"
>>> "".join([a,b,c])
'abcd12cd'
用 [] 把abc变成一个list，才能用join()进行拼接，直接用join(a,b,c)报错，因为join()函数只能有一个参数
注意：
join()函数基本语法： 'sep'.join(seq)，表示以sep为分隔符，将seq所有的元素合并成一个新的字符串
sep表示分隔符，可以为空；
seq表示要连接的元素序列，字符串，元组或者字典，也就是说上面的"".join([a,b,c])也可以把参数写成元组 "".join((a,b,c))
4. format格式化方式
b = "this is {} {}" .format ("my","apple")为什么要用format
print b
输出为 this is my apple
如果想调整一下输出参数的顺序，那么可以这样写
b = "this is {1} {0} .format ("my","apple"),那么输出结果就是
this is apple my
需要注意的是参数从0开始
算参数位置太麻烦，有时候还出错，来种更人性化的方法
b = "this is {whose} {fruit}" .format (fruit="apple",whose="my")
print b
输出为this is my apple
5. 还有一个方法，字典来了。
a = "this is %(whose)s %(fruit)s" % {'whose':'my','fruit':'apple'}
其中whose:my, whose是key位，my是word位
七. 读写文本
1. 在指定的文件中写入内容
d = open('a.txt','w')
d.write('hi,
hello')
d.close()
说明：open()中的第二个参数含义
w ：write
r ：read
a ：append
2. 读取指定文本内容
d = open('a.txt','r')
help(d) #查看对象d可使用的方法属性，举例说明readline(), readlines()以及read()的使用方法和区别
1) readline()，每次读取单行文本内容
print d.readline()
hi
print d.readline()
hello
2）read()，一次读取所有内容，以文本形式显示
>>> print d.read()
hi,
hello
注意：print d.read(100),但是显示为空，需要用d.seek(0)来调整一下读取位置，然后再print d.read(100)就能看到全部信息量，100不够就1000
3）readlines()，也是一次读取所有内容，不过是以列表的形式显示
>>> print d.readlines()
['hi,
', 'hello']
可用for循环显示每行内容
for line in d.readlines():
print line
小结：
.readline() 和 .readlines() 之间的差异是后者一次读取整个文件，象 .read() 一样。
.readlines() 自动将文件内容分析成一个行的列表，该列表可以由 Python 的 for … in … 结构进行处理。
另一方面，.readline() 每次只读取一行，通常比 .readlines() 慢得多。仅当没有足够内存可以一次读取整个文件时，才应该使用 .readline()。
4) 使用标准库linecache，也可实现访问指定文本行
a = open("tmp.txt","w")
a.write("haha
12faf
hong")
a.close()
如果想在python命令行中输出上面tmp文件的第一行，第二行内容，可以如下写。
import linecache
help(linecache)
print linecache.getline("tmp.txt",1)
print linecache.getline("tmp.txt",2)
使用这种方法的好处是不要考虑重置指针(seek函数)的问题，可随意取任意行
2017/8/15 8:59
八. 三个符号的区别 ：一对单引号，一对双引号，一对三个双引号
python中单双引号没区别,单引号里可以写双引号，双引号里也可以写单引号
一对三个双引号作用是格式化的输出多行内容，而且里面的内容可以任意加单引号，双引号等。例如
print """
author
"date"
'money'
"""
和多行注释用法一样
三. 列表
一. 列表基本特点
1. 有序的集合
a = [1,2,3]
2 通过偏移来索引，从而读取数据
a[-1]输出为3
3 支持嵌套
b = [[1,2,3],[4,5,6]]
b的输出为[[1,2,3],[4,5,6]]
此时如果想修改2为7，方法是b[0][1] = 7
4. 可变的类型
二. 列表基本使用方法
1. 切片：
a = [1,2,3,4,5,6,7］
正向索引
a[0:4:1] 表示从0位开始去到第4位，步长为1,结果为[1,2,3,4]
反向索引
a[-1:-4:-1],取到[7,6,5] #反向索引的步长一定要加上，并且步长要写为负数
默认索引
a[1:], 取到[2,3,4,5,6,7]
a[1::2], 取到[2,4,6]
注意：不管是正向索引还是反向索引，索引后面的一个值，是不算在内的
2. 添加操作：
1) + 生成一个新的列表
a = [1,2,3]
b = [4,5,6]
a + b 输出为[1,2,3,4,5,6]
2) Extend，扩展list，参数为其他列表名，结果是新元素自动融入list，类型一样。
接受参数并将该参数的每个元素都添加到原有的列表中，原地修改列表而不是新建列表
a.extend(b)
a的输出为[1,2,3,4,5,6],对比操作前后的id(a),值是不变的
3) Append :添加任意对象到列表的末端，参数为单个元素，这个元素可以是数字，也可以是list或者元组本身。
加入数字
a = [1,2,3]
a.append(4)
a的输出为[1,2,3,4]
加入列表
a.append([3,4,5])
a的输出为[1,2,3,4,[3,4,5]]
4) Insert: 插入任意对象到列表中，可以控制插入位置。
a.insert(1,"ab") 表示在下标为1处加上元素“ab”
a的输出结果是[1,"ab",2,3,4,[3,4,5]]
3. 修改：
修改列表本身只需要直接赋值操作就行。
A = [1,2,3]
A[0]=’haha’
4. 删除操作：
1) Del ：我们通过索引删除指定位置的元素。
a = [1,2,3,4,5]
del a[0] #只有del是用命令del，其他都是通过 a.函数名 的方式调用实现相应功能。
a输出为[2,3,4,5]
2) Remove：移除列表中指定值的第一个匹配值。如果没找到的话，会抛异常。
a.remove(4)
a.remove(6)
这里的参数4，6都是具体的列表中的实际值，而不是下标
3) Pop：返回最后一个元素，并从list中删除它。
a.pop()，输出为5，并删除5
也可指定元素索引值，弹出并删除指定元素，比如a.pop(1)，弹出并删除数字2
5. 成员关系：
通过in， not in的方法，我们可以判断一个元素是否在列表里。返回一个bool类型，元素在列表里返回true，否则返回fasle.
a = [1,2,3]
2 in a
True
5 in a
False
5 not in a
True
6. 列表推导式：
一般的，[expr for iter_var in iterable]
首先迭代iterable里所有内容，每一次迭代，都把iterable里相应内容放到iter_var中，再在expr中应用该iter_var的内容，最后用expr的计算值生成一个列表，。
比如我们要生成一个包含1到10的列表
方法一
[x for x in range(1,11)]
输出为[1,2,3,4,5,6,7,8,9,10]
方法二
range(1,11) #python2中，这种方法可以输出1-10的列表，但是在python3只会输出一个range类型range(1,11)
有条件的，[expr for iter_var in iterable if cond_expr]
加入了判断语句，只有满足条件的内容才把iterable里相应内容放到iter_var中，再在表达式中应用该iter_var的内容，最后用表达式的计算值生成一个列表。
要生成包含1到10的所有奇数列表。
方法一
range(1,11,2) 同理python2中可生成奇数列表，python3中不行
方法二
[x for x in range(1,11) if x % 2 == 1]
注意：表达式中的x都是表示一个相同的东西，我能改的只能是表达式的形式，也就是第一个x，比如改成x+1.
7. 排序和翻转：sort,reverse
sort：这个方式会直接修改原列表，它的返回值为none，所以b = a.sort() ,print b 输出的内容是None
例如
a = [33,11,22,44]
b = a.sort()
b的输出结果为None,也就是什么都不输出，可以用if语句判断
if b is None:
print "haha"
此时再输出a，发现a已经按顺序排好，输出为[11,22,33,44]
reverse和sort同理
b = a.reverse() #b的输出也是None
再看a的输出，发现a的值已经反转了
[44,33,22,11]
2017/8/16
三. 列表常见应用
1. 内置list的方法，常用来把字符串或者元组改成列表类型
a = "asd"
list(a)
['a','s','d']
返回一个列表，参数是可迭代对象。里面输出的内容保持了传入的可迭代对象的元素和顺序
元组转为列表
list((1,2))
输出为[1,2]
但是如果传入数字，就会报错，因为数字是不可迭代的对象
list(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
2.xrange和range的区别（只在python2中使用起来有区别）
xrange(开始，结束，步长）步长省略的话，默认为1
2个函数的区别：
xrange 会生成一个xrange对象，
range直接生成一个列表对象
创建一个xrange对象
>>> a = xrange(1,10)
>>> a
xrange(1, 10)
>>> a[0]
1
>>> a[3]
4
创建一个range对象b
>>> b = range(1,10)
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b[0]
1
>>> b[3]
4
xrange的使用场合
1. 当我们需要操作一个非常大的数据，而且内存比较吃紧的时候，我们可以用xrange来操作省内存
2. xrange一般用在循环里面，比如我们只需要操作部分数据，而不是返回全部元素来完成操作，推荐使用xrange
比如
for m in range(1000): #range()生成一个包含[0-999]的对象
if m == 10:
print "sss"
break
for m in xrange(1000): #xrange()每一个迭代循环，只返回一个元素，只需返回[0-10],11个对象
if m == 10:
print "sss"
break
3. 列表推导式之再应用
复习例子1，取出1-100的所有值的平方
按从右向左的顺序来写，比较人性化,先写一个1-100的序列，让x迭代，然后左边写运算，最后加一个中括号
[x*x for x in range(100)]
常见应用如下
1）生成字符串
["the %s" % x for x in xrange(10)]
输出为 ["the 0","the 1","the 2","the 3",...."the 9"]
2）生成元组
for x in range(2) 先生成一个列表，进行迭代
for y in range(2) 再生成一个列表，进行迭代
定义一个元组(x,y)
定义列表，也就是加上中括号
完整的句子就是：
[(x,y) for x in range(2) for y in range(2)]
输出如下
[(0,0),(0,1),(1,0),(1,1)]
3）生成字典，就是上面的一个打包操作，加上dict()
dict ([(x,y) for x in range(2) for y in range(2)])
输出如下
{0:1,1:1}
冒号左为key，右为value。key如果相同，后面的key会覆盖前面的key，所以前面的2个值(0,0),(0,1)只会有0:1； 后面的2个值也只会有1:1，道理一样。
4. 小技巧之再议删除
1）删除列表对象的引用
>>> a = [1,2,3]
>>> b = a #此时查看列表对象的地址,用id()查看，发现a,b的id值是一样的，也就是引用的列表对象的存储位置是一样的。
>>> del a
>>> b
[1, 2, 3]
2）清空列表对象里的元素
>>> c = b
>>> del c[:]
>>> c
[]
>>> b
[]
说明：
赋值符号“=”，表示引用，表示传址调用，他们有相同的ID号，如果修改某一个变量，另一个变量也会相应修改
[:] 表示复制，传值调用，2个变量ID号不同，此时修改b，不会影响a的值
a = [1,2,3]
b = a[:] #这个[:]是个什么东西
del a
b的值是什么。为什么呢？
当b=a时
>>> a=[1,2,3]
>>> b=a
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> id(a)
140076707413024
>>> id(b)
140076707413024
当b=a[:]时，这里生成了一个新的列表对象，b的变化，不会影响下面a的输出。
>>> a=[1,2,3]
>>> b=a[:]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> id(a)
140076707334048
>>> id(b)
140076707335272
>>> b=[1,2,3,4]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3, 4]
2017/8/17 8:52
四. 元组和集合
1. 元组是有序的集合
a = (1,2,3）
2. 通过偏移来取数据，也是通过下标来取，和列表一样。区别就是list是可变的，元组是不可变的。
a[0] 输出为1
a[1:3] 输出为(2,3)
3. 属于不可变的对象，不能在原地修改内容，没有排序，修改等操作。
dir(a)可以看到所有支持的方法
要想修改元组，需要先把元组重新赋值给一个列表，然后修改列表元素，之后再把列表转变给元组。方法如下
b = list(a)
b[0] = 5
type(b) 输出为list
a = tuple(b) #生成了一个新的元组对象
a
输出为（5,2,3）
tuple类型转换
那为什么有列表还要有元组呢？
元组不可变的好处。保证数据的安全，比如我们传给一个不熟悉的方法或者数据接口，确保方法或者接口不会改变我们的数据从而导致程序问题。
例子1
#encoding=utf-8
def info(a):
print "id %d" % id(a)
#a[0] = "haha" 第一个脚本完成后加这行进行测试
#return a 这行也是测试的
a = [1,2,3]
print "start-"
print id(a)
info(a)
#print a 测试用的
另外一种方法
#encoding=utf-8
def info(a):
b = a[:] #这里生成了一个新的列表对象，b的变化，不会影响下面a的输出。
b[0] = "haha"
return a
a = [1,2,3]
print "start-"
print id(a)
info(a)
print a
二. 集合
集合是没有顺序的概念。所以不能用切片和索引操作。
1. 创建集合
set():可变的
a = set("abc")
a
输出为set(['a', 'c', 'b'])
不可变的frozenset()：
>>> a = frozenset("abc")
>>> a
frozenset(['a', 'c', 'b'])
>>> a.add("222")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>> a.remove("a")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'remove'
查看对象是否可迭代的方法
用dir进行查看，比如dir(a),如果输出中有"_iter_"，说明可以进行迭代。
2. 添加操作： add，update
add函数
a.add("python")
a
输出为
set(['a', 'python', 'c', 'b']) #"python"做为一个整体来加入。
update函数
>>> b = set("hong")
>>> b
set(['h', 'g', 'o', 'n'])
>>> b.update("python")
>>> b
set(['g', 'h', 'o', 'n', 'p', 't', 'y']) #python分开来插入，如果重复自动忽略
注意：
update的参数也可以是list，如果使用list，那么集合中新加的元素还会保持原先list中的顺序。
比如c='hong'
b.update(list(c))
3. 删除 remove
a.remove("python")
a
输出为
set(['a', 'c', 'b'])
4. 成员关系 in,not in
"c" in a
True
"h" not in a
True
5. 交集，并集，差集 & | -
a = set('abcd')
b = set('bcdef')
a & b
set(['c','b','d'])
a | b #并集
set(['a','c','b','e','d','f'])
a - b #差集
set(['a'])
6. set去重
例子
>>> a = [1,2,3]
>>> a.append(1)
>>> a.append(3)
>>> a
[1, 2, 3, 1, 3]
>>> set(a)
set([1, 2, 3])
>>> list(set(a))
[1, 2, 3]
基础篇12-字典
字典是无序的，它不能通过偏移来存取，只能通过键来存取。
例1
>>> info = {'a':1,'b':2}
>>> info
{'a': 1, 'b': 2}
可以通过键值返回value值
>>> info['a']
1
例2
>>> binfo = {'a':[1,2,3],'b':[4,5,6]}
>>> binfo
{'a': [1, 2, 3], 'b': [4, 5, 6]}
>>> binfo['a'][2] = 5
>>> binfo
{'a': [1, 2, 5], 'b': [4, 5, 6]} #说明字典是可变的类型。
字典 = {'key':value} key：类似我们现实的钥匙，而value则是锁。一个钥匙开一个锁
特点：
内部没有顺序，通过键来读取内容，
可嵌套，方便我们组织多种数据结构，并且可以原地修改里面的内容，属于可变类型。
组成字典的键必须是不可变的数据类型，比如，数字，字符串，元组等，列表等可变对象不能作为键.
例3
key 为数字
>>> binfo = {1:"22",2:"dd"}
>>> binfo
{1: '22', 2: 'dd'}
key为字符串
>>> cinfo = {"a":"222","b":111}
>>> cinfo
{'a': '222', 'b': 111}
key为元组，需要注意的是元组中的元素也必须是不可变类型。
>>> dinfo = {(1,2,3):'ss',('b','c'):'222'}
>>> dinfo
{('b', 'c'): '222', (1, 2, 3): 'ss'}
元组中的元素是列表
>>> xinfo = {(1,'2',[2,3]):'a'}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
key为列表
>>> finfo = {[1,2,3]:'sss'}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
1. 创建字典。{},dict()
法1
info = {'name':'lilei', 'age': 20}---------------一般情况下还是用法一好！
法2
info = dict(name='lilei',age=20)
name是key，'lilei'是value
注意：
1. 法一是用花括号，法二是用小括号；
2. 法一key和value中的字符串必须加引号；法二key的字符串可以不用加双引号，value的字符串必须加双引号。
3. 法一用冒号，法二用等号
2. 添加内容 a['xx'] = 'xx'
比如在法1例子的基础上加上如下命令
info['phone'] = 'iphone5'，其中phone为key， iphone5为value
>>> info ={'name':'lilei','age':20}
>>> info
{'age': 20, 'name': 'lilei'}
>>> info['phone'] = 'iphone5'
>>> info
{'phone': 'iphone5', 'age': 20, 'name': 'lilei'}
3. 修改内容 a['xx'] = 'xx'
info['phone'] = 'htc'
update 参数是一个字典的类型，他会覆盖相同键的值
在例2的基础上做下面操作
>>> info.update({'city':'beijing','phone':'nokia'})
>>> info
{'phone': 'nokia', 'age': 20, 'name': 'lilei', 'city': 'beijing'}
4. 删除 del,clear,pop
1）del ainfo['phone'] 删除某个元素
>>> ainfo = {'age':22,'aa':22}
>>> ainfo
{'aa': 22, 'age': 22}
>>> del ainfo['aa'] #删除'aa'元素
>>> ainfo
{'age': 22}
删除ainfo的引用
>>> del ainfo
>>> ainfo
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'ainfo' is not defined
2）clear()删除字典的全部元素
>>> a = {'info':'22','age':'34'}
>>> a
{'info': '22', 'age': '34'}
>>> a.clear()
>>> a
{}
3）pop('name')
字典的pop方法
>>> a = {'11':'aa','bb':22}
>>> a
{'11': 'aa', 'bb': 22}
>>> a.pop('bb') #传入需要删除目标的key，就可删除。
22
>>> a
{'11': 'aa'}
需要注意的是，如果pop的key不存在，我们可以指定一个输出值让系统显示出来，
以上面字典a为例
>>> a.pop('33')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: '33'
>>> a.pop('33','not exist')
'not exist'
列表的pop方法
>>> binfo = []
>>> binfo.append('22')
>>> binfo.append('234')
>>> binfo
['22', '234']
>>> binfo.pop(0) #传的是索引下标
'22'
>>> binfo
['234']
5. in 和 has_key() 成员关系操作
例如
>>> a
{'11': 'aa', 'bb': 22}
1).in
>>> "phone" in a
False
2) a.has_key()
>>> a.has_key('11')
True
>>> a.has_key('aa')
False
3). keys(): 返回的是列表，里面包含了字典的所有键
>>> a.keys()
['11', 'bb']
4). values():返回的是列表，里面包含了字典的所有值
>>> a.values()
['aa', 22]
5) items()：生成一个字典的容器：------这个方法是字典转变为list的途径
>>> a.items()
[('11', 'aa'), ('bb', 22)].里面的每一项都是一个元组，元组第一项为key，第
二项为value
6) get：从字典中获得一个值
>>> a.get('11') #参数为key，输出为value
'aa'
>>> a.get('33') #key不存在，输出为空，且为NoneType类型
>>> b = a.get('33')
>>> type(b)
<type 'NoneType'>
>>> a.get('33','not exist') #key不存在，可以指定默认输出值
'not exist'
基础篇13-答疑课
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)] ##这里不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##这里不明白
一. 先得讲讲二进制
0 + 1 + 1 9 +1 = 10
99 +1 = 100
2进制冯二进1
0 +1 = 1
1 +1 = 10
10 +1 = 11
11 +1 = 100
100 + 1 = 101
101 + 1 = 110
二. 难缠符号来啦
bin：把10进制转换为2进制
例子
>>> bin(3)
'0b11'
只看0b后面的数值，就是转换后的2进制
1.难缠符号之一 >> <<
位移，移动的是2进制的位
例子
>>> 5 >> 1
2
5的2进制是101，向右边移动一位，结果就是10,十进制结果就是2
>>> 3 << 1
6
3的二进制是11，左移一位变为110，十进制就是6
2.难缠符号之二 &
按位与，对应位都是1结果才是1，其他都是0
1100
1000
1000
例子
>>> 10 & 20
0
10的2进制：01010 #第一位的0是补的
20的2进制：10100
发现没有一个对应位是1的，所有结果是全0.
>>> 40 & 32
32
注意2进制转变为10进制
>>> int(0b100000)
32
3.难缠符号之三 |
按位或,对应位只需一个为1，结果就是1
0100000
1100100
1100100
例子
32 | 100
100
4.难缠符号之四 ^
按位异或，对位相加，不进位
101
011
110
5.难缠符号之五 ~
按位取反，2进制数加1后，乘以-1
例如~5 = -6
~5=-(101+1)=-110=-6
所以
3+~5=-3
注意不能直接写3~5，这样是错的
三. 其他
1.&之奇偶判定,和1进行按位与运算，结果为1就是奇数，结果为0则是偶数
5 & 1
1
4 & 1
0
2.计算硬盘容量
比如一个文件大小是11866字节，想知道有多少k，那就是向右移10位，相当于11866除以2的10次方，相应的，想知道有多少M，就向右边移动20位。
11866 >> 10
3.真真假假不知晓
False & True & True
False
True & True & True
True
if is_boy() & is_18() & is_chinese():
print
四.回过头来再看这道题
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)] ##这里不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##这里不明白
2017/8/18 9:57
基础篇15. 答疑课之二：再议数据结构与数据类型
1.list，dict，tuple之它们其实是好基友
1.1 没有最优秀的数据结构，只有最适用的
1.2 了解每个结构的特点才能活学活用
1.3 它们相互转换如此简单
list是有序的
dict是无序的，适合存储有复杂名称的数据，比如{"xiaoming":86},比如电话薄，班级成绩单。
a = (1,2,3,4)
a = list(a) #元组转换成list
然后把list转变成tuple
a = tuple(a)
list转换成字典
a = [(1,3),(2,4)]
a = dict(a)
2.“推倒式”（列表推导）与再议
[x for x in xrange[101]
第一部分 []
第二部分 x
第三部分 for x in xrange[101]
等价于
new_list = []
for x in xrange(101):
new_list.append(x) #这里的x等同于第二部分的x
print new_list
3.排序
3.1 sorted--------可以用在字符串中进行排序，会生成一个list
help('sorted')来看帮助文档
a = [1,2,3,4]
sorted(a,reverse=True)
[4,3,2,1]
a
[1,2,3,4] #说明sorted并不是原地修改
要想修改a的值，需要赋值
a = sorted(a,reverse=True)
3.2 list之sort方法
a = [1,2,3,4]
a.sort(reverse=True)
a
[4,3,2,1] 说明内置函数sort是原地修改
sort帮助文档中的信息
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
key最好用,它可以对list中的元素进行操作
例1
>>> a = ["43214","324214","82310","9231"]
>>> a.sort(key=int)
>>> a
['9231', '43214', '82310', '324214']
>>> a.sort(key=int,reverse=True)
>>> a
['324214', '82310', '43214', '9231']
例子2，按照list中元组元素的第2个数字大小进行排序
>>> a = [('a',2),('b',5),('c',4)]
>>> a.sort(key=lambda x:x[1]) #x表示每一个元组单元，x[1]表示元组中下标为1的元素，也就是数字2,5,4.
>>> a
[('a', 2), ('c', 4), ('b', 5)]
>>> a.sort(key=lambda x:x[1],reverse=True)
>>> a
[('b', 5), ('c', 4), ('a', 2)]
cmp是什么
cmp是用来比较2个数字的值，只会返回三个结果：0,1,-1. 能用key最好不用cmp，python3中已经弃用，性能不好
用法
cmp(a,b) 等同于公式(a>b) - (a<b)
>>> cmp(1,3)
-1
>>> (1>3) - (1<3)
-1
>>> cmp (3,1)
1
>>> cmp (3,3)
0
3.3 多级排序咋个办
如下，按元组元素中的后两位数字进行排序，我的理解就是后两位看做一个数比大小。
>>> a = [(3,1,2),(6,7,8),(6,5,9)]
>>> import operator
>>> a.sort(key=operator.itemgetter(1,2)) #这里的1,2表示下标。
>>> a
[(3, 1, 2), (6, 5, 9), (6, 7, 8)]
3.4 字典如何去排序
自己摸索。。。
4.字符串模板应用
4.1 回忆一下，字符串模板有哪几种方式
"%s is a %s" %("he","boy")
"%(who)s is a %(gender)s" %{"who":"he","gender":"boy"}
"{who} is a {gender}".format(who="he",gender="boy") 这种最好
4.2 典型应用1：html模板
也是用占位符来替代相应模块中的内容
4.3 针对性比强大更为重要
三种字符串模板灵活运用，看哪个适用
基础篇16-python语句讲解1
1. print语句
1.1 基本输出
1.2 print的逗号
1.2 输出到文件 >>为重定向
解释与例子
在python脚本中，如果写入
print "2"
print "3"
那么执行的时候会自动进行换行，输出为
2
3
如果脚本中加上逗号，如下
print "2",
print "3"
那么执行的时候输出就是
2 3
不会进行换行，所有逗号的意思就是print语句还没执行完。
输出重定向,使用print命令来写文件内容 -----以后我就用这个方法吧，命令行也行
脚本中如下写
f = open('print.txt','w')
#一般情况下写入文件应该用命令f.write("my name is hong"),这里用print来写
print >> f,"my name is hong"
print >> f,"i am from china"
f.close()
这里当然也可以用逗号，来使2行变一行。
2. 控制流语句（control flow）
2.1 由条件和执行代码块组成。
2.1.1 条件可分为决策、循环和分支
2.2 格式（冒号与4个空格永不忘）
2.3 if，while，for 函数，皆为contorl flow
解释和例子
if True: #冒号分隔了条件和代码块。
print 4 #4个空格缩进的代码块
x = 3
if x: #相当于 if x == if bool(x)，返回结果为True
print 4
3. 布尔值
3.1 控制流与真假值息息相关
3.1.1 不要误解了真假与布尔值
3.2 布尔值的几个最基本运算符
3.2.1 and 全部都为bool真
3.2.2 or 至少一个为bool真
3.2.3 is 检查共享
3.2.4 == 检查值
3.2.5 not
3.2.6 其他若干比较符号
>>> True and False
False
>>> True or False
True
is是检查是否引用了同一个数据对象
>>> 5 is True
False
5是引用了一个整型的数据对象，True引用的是一个布尔类型的对象，所有结果是False
>>> a = 5
>>> b = 5
>>> a is b
True
== 检查左边和右边的值是否相同
1 == True
True
虽然左边是整型，右边是布尔型，但是他们的值都是1，所以返回True
>>> 4 == 9
False
not：取反。如果要表示真，后面一定要跟False,做这个的是太无聊了，整点花样。
if not False:
print "not False"
4. if语句 （控制流语句）
4.1 if的组成 if else elif pass
4.1.1 if与elif替代了switch
4.1.2 pass
例子
if True:
print "True"
else:
print "False"
if True:
print "True"
elif not True:
print "not True"
else:
pass #什么都不做
4.2 奇技淫巧 三元表达式
4.2.1 x if else
4.2.2 活用list
4.2.3 三元表达式玩玩就好
例子1
4 if True else 3
等同于
if True:
print 4
else:
print 3
>>> 4 if True else 3
4
例子2
>>> [4,3][True] #True值为1，所以返回下标为1的list值
3
>>> [4,3][False] #False值为0，所以返回下标为0的list值
4
>>> [4,3][0]
4
>>> [4,3][1]
3
基础篇17-python语句讲解-2
1.复习
1.1 控制流的基本组成部分 条件，执行代码块。
1.2 if的基本格式
if expression:
statement(s)
1.2 控制流的条件表达式(expression)结果，必须为True(真)，比如 条件可以写成if not True: 这样的返回结果为真，而不能写成if False，返回为假
1.3 冒号永不忘。尽量使用4个空格，而不是制表符
2.while语句
2.1 while的基本格式
while expression:
statement(s)
例子1
x = 1
while True:
x += 1
print x
#continue 通过加减这个命令来测试
if x > 20:
break
else:
2.2 while的基本组成部分
2.2.1 break 结束while
2.2.2 continue 跳出当前这次循环，但不结束while
2.2.3 else 结束while以后执行,是正常跑完，不是通过break强行结束。也就是说不能和break连用，不然break会把else语句也掐断。但是可以和continue一起用
while x < 20: #可以在while表达式中用<
x += 1
#continue 来测试是否能和continue一起用
print x
else:
print "end"
2.3 注意：普通应用里，while一定要给一个结束条件，否则就是传说中的死循环
3.for语句
3.1 for的基本格式
for item in iterable：
statement（s）
例子
for x in "hello,my name is hongjin"
print x
消除空格
for x in "hello,my name is hongjin".split(" "):
print x
用一行来显示出来文本内容
for x in "hello,my name is hongjin".split(" "):
print x，
3.2 for的基本组成部分
3.2.1 break
3.2.2 continue
3.2.3 else
3.3 注意：for的最后一个迭代值将保留，也就是循环结束后，最后一个循环取得值将被保留在内存中。如果不注意的话，可能会出现错误
4.布尔值再议
4.1 惰性求值，需要时再求值。
4.2 从左到右，从先到后。
4.3 利用小技巧。or之默认值。
比如
True and False and False and True
python在进行计算时，看到第二个是False,后面的就不计算了，直接返回False
在进行运算时，可以把可能是false的计算放在前面，把其他运算量很大的计算放后面，这样效率高
or之默认值
比如在爬网页的时候
定义一个变量
from_url = url.get("from") or None
就是爬上面的网址from后面的参数"=126mail"，有时候from后面有内容，有时候没有，如果没有的话，脚本还想继续运行，就需要加上or None
基础篇18-语句与数据结构应用
1.最基本的迭代
a = "abcdefg"
for i in a:
print i
b = [1,2,3,4,5]
for i in b:
print i
2.如何迭代字典
a = {"key":"value","key1":"value1"}
print a
a = {"key":"value","key1":"value1","key1":"value2"}
print a
相同的key,只会输出最后一个key的value
for i in a.keys():
print i
命令行中看一下a.items()是什么
脚本中
for x,y in a.items():
print x,y
3.如何为字典排序
例子1，把下面字典元素按照key中的字母序列排序
a = {"a":"haha","b":"xs","d":"fa","c":"faff"}
key_list = a.keys()
key_list.sort()
#print key_list
for x in key_list:
print x,a[x]
注意：字典可以使用如下方式查看字典的value
>>> print a["a"]
haha
4.字典根据键值查找键
那么如果想从字典的value得到key，应该怎么做呢
分析：
1） 字典索引的是键，而不是值 => 迭代，穷举
2） 字典具有唯一键，但值不要求唯一
3） 一个值可能对应多个键
例子,不同的key都有相同的value值，
a = {"a":"haha","b":"xixi","d":"haha","e":"xixixi","c":"haha"}
search_value = "haha"
key_list = []
for x,y in a.items(): #找到所有的key, value， for x,y ：设置两个参数，这个思想很牛x
# print x,y
if y == search_value: #建立相同value对应的key_list
key_list.append(x)
print key_list
5.sorted排序方法再议
在python脚本中这样写
import string #测试下不引入string时的输出情况。
a = "dcDSfag1f43"
a = ''.join([x for x in a if not x.isdigit()])
print sorted(a,key=string.upper)
执行后输出为
hong@calm:~$ python test.py
['a', 'c', 'd', 'D', 'f', 'f', 'g', 'S']
注意：
key=string.upper可以理解为
1.用string.upper这个方法，去执行列表中的每一个数据，假设我们有一个list
c = [a,b,c]
sorted(c,key=string.upper)相当于先生成一个新的列表
c = [string.upper(a),string.upper(b),string.upper(c)]，然后对这个新的列表进行排序。
结论：
[x for x in a if not x.isdigt()] 等价于下面代码
new_list = []
for x in a:
if not x.isdigit():
new_list.append(x)
6. 好玩的translate与maketrans---替换字符
例子1
>>> import string
>>> g = string.maketrans('123','abc') #建立翻译表，参数中的'123'和'abc'位数必须一致，因为它是一一对应翻译的，否则会报错
>>> a = '123456'
>>> print a.translate(g)
abc456
例子2
>>> a = '321123132'
>>> print a.translate(g)
cbaabcacb
对比replace
>>> a.replace('123','abc')
'321abc132'
例子3，删除操作
>>> a = '321123132'
>>> a.translate(g,'1') #输出删除1后对应的翻译
'cbbccb'
如果不翻译，输出删除1后的结果
>>> c = string.maketrans('','')
>>> a.translate(c,'1')
'322332'
>>> a.translate(c,'12')
'333'
逐个删除。
7. 一个新的语句，with，一个写文件的方法
普通方法
g = open('a.txt','w')
g.write('hello,
hi')
g.close()
with方法
with open('a.txt','a') as g: #参数a表示append
g.write("hello")
这种方法不需要写close语句
2017/8/20 8:58
基础篇20-python函数
一. 定义函数
1. def是关键字，括号冒号永不忘，执行代码块要缩进
2. 没有return的函数，不是真函数
3. 不写doc的函数，就像没有性别的人类，也就是要在函数中写说明，直接在def test():下一行用双引号写下说明就行了
例子1
def test():
print 4
test()
上面这个写法是错误的，应该如下写
def test():
return 4
print test()
例子2
#coding=utf-8
def test():
"这是一个测试函数"
return 1
print test.__doc__
#这个命令是直接打出函数说明信息的，也就是执行python test.py时，会输出"这是一个测试函数", 需要注意的是doc前面和后面是2个下划线。
二. 函数的参数
1） 位置参数
def test(a,b,c,d):
return a,b,c,d #这样的结果是会返回一个元组(1,2,3,4)
print test(1,2,3,4) #定义的时候有几个位置参数，这里就要写几个数，否则会报错
2）可选参数，直白意思就是调用函数的时候参数写不写都行，不会报错。
def test1(a=4)
return a
print test1()
输出结果是4
print test1(5)
输出结果是5
3）可选参数可以当做默认值进行设置
例子, 下面是伪代码，知道意思就好
def test2(a,b,c return_data="json"):
if return_data == 'json':
return json(a,b,c)
elif return_data == 'xml':
return xml(a,b,c)
return a,b,c
test2(1,2,3,return_data='xml)
2. 参数的值是局部变量
1）全局变量和局部变量
例1，在脚本中如下写
b = 3 #全局变量
def a():
#global b
b = 4 #局部变量
return b
def c():
return b
print a()
print c()
结果输出为
4
3
说明在局部变量和全局变量中都定义一个变量的时候，会优先使用局部变量的值，如果局部变量没有定义，则会自动使用全局变量值
如果想在函数a中修改全局变量b的值，方法是使用global b，那么此时print c()的值也是4了，说明全局变量修改成功，这个方法慎用。
2）如何修改参数
例子
有一个list b = [1,2,3]，想通过一个函数func(b),实现结果为把list b =[1,2,3,4], 方法如下
b = [1,2,3]
def func(x) #定义函数有一个参数
x.append(4)
return x
b = func(b)
#调用函数func，并且把返回值重新赋值给b，虽然不用赋值给b，结果也是正确的，但这不是一个好的编程习惯。
print b
3） 函数的参数魔法 ----- **和* 星星是字典，星是元组
例子1
def test(**kr):
return kr #kr可以是任意字符，表示字典名
print test(a=4,c=3)
输出结果为{'a':4, 'c':3}
例子2
def test(*z)：
return z
print test(1,2,[1,2])
输出结果为(1,2,[1,2])
例子3
def test(*z,**kr):
return z,kr
print test(1,2,a=5,b=9)
输出结果为 ((1, 2), {'a': 5, 'b': 9})
注意：
参数a=5这样的参数必须是一起写在1,2这样的参数后面。修改test(*z,**kr)的参数位置也不行。
例子4
def test(a,b,*z,**kr)
return z,kr
print test(1,2,4,5,c=4,d=9)
如果定义参数的时候，已经有了位置参数，那么在print test写入实参的时候是按照形参的顺序来写入的
实参中的c,d在定义中必须是没有c,d的，不然就会报错。