s12-20160109-day02
*:first-child {
margin-top: 0 !important;
}
body>*:last-child {
margin-bottom: 0 !important;
}
/* BLOCKS
=============================================================================*/
p, blockquote, ul, ol, dl, table, pre {
margin: 15px 0;
}
/* HEADERS
=============================================================================*/
h1, h2, h3, h4, h5, h6 {
margin: 20px 0 10px;
padding: 0;
font-weight: bold;
-webkit-font-smoothing: antialiased;
}
h1 tt, h1 code, h2 tt, h2 code, h3 tt, h3 code, h4 tt, h4 code, h5 tt, h5 code, h6 tt, h6 code {
font-size: inherit;
}
h1 {
font-size: 28px;
color: #000;
}
h2 {
font-size: 24px;
border-bottom: 1px solid #ccc;
color: #000;
}
h3 {
font-size: 18px;
}
h4 {
font-size: 16px;
}
h5 {
font-size: 14px;
}
h6 {
color: #777;
font-size: 14px;
}
body>h2:first-child, body>h1:first-child, body>h1:first-child+h2, body>h3:first-child, body>h4:first-child, body>h5:first-child, body>h6:first-child {
margin-top: 0;
padding-top: 0;
}
a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 {
margin-top: 0;
padding-top: 0;
}
h1+p, h2+p, h3+p, h4+p, h5+p, h6+p {
margin-top: 10px;
}
/* LINKS
=============================================================================*/
a {
color: #4183C4;
text-decoration: none;
}
a:hover {
text-decoration: underline;
}
/* LISTS
=============================================================================*/
ul, ol {
padding-left: 30px;
}
ul li > :first-child,
ol li > :first-child,
ul li ul:first-of-type,
ol li ol:first-of-type,
ul li ol:first-of-type,
ol li ul:first-of-type {
margin-top: 0px;
}
ul ul, ul ol, ol ol, ol ul {
margin-bottom: 0;
}
dl {
padding: 0;
}
dl dt {
font-size: 14px;
font-weight: bold;
font-style: italic;
padding: 0;
margin: 15px 0 5px;
}
dl dt:first-child {
padding: 0;
}
dl dt>:first-child {
margin-top: 0px;
}
dl dt>:last-child {
margin-bottom: 0px;
}
dl dd {
margin: 0 0 15px;
padding: 0 15px;
}
dl dd>:first-child {
margin-top: 0px;
}
dl dd>:last-child {
margin-bottom: 0px;
}
/* CODE
=============================================================================*/
pre, code, tt {
font-size: 12px;
font-family: Consolas, "Liberation Mono", Courier, monospace;
}
code, tt {
margin: 0 0px;
padding: 0px 0px;
white-space: nowrap;
border: 1px solid #eaeaea;
background-color: #f8f8f8;
border-radius: 3px;
}
pre>code {
margin: 0;
padding: 0;
white-space: pre;
border: none;
background: transparent;
}
pre {
background-color: #f8f8f8;
border: 1px solid #ccc;
font-size: 13px;
line-height: 19px;
overflow: auto;
padding: 6px 10px;
border-radius: 3px;
}
pre code, pre tt {
background-color: transparent;
border: none;
}
kbd {
-moz-border-bottom-colors: none;
-moz-border-left-colors: none;
-moz-border-right-colors: none;
-moz-border-top-colors: none;
background-color: #DDDDDD;
background-image: linear-gradient(#F1F1F1, #DDDDDD);
background-repeat: repeat-x;
border-color: #DDDDDD #CCCCCC #CCCCCC #DDDDDD;
border-image: none;
border-radius: 2px 2px 2px 2px;
border-style: solid;
border-width: 1px;
font-family: "Helvetica Neue",Helvetica,Arial,sans-serif;
line-height: 10px;
padding: 1px 4px;
}
/* QUOTES
=============================================================================*/
blockquote {
border-left: 4px solid #DDD;
padding: 0 15px;
color: #777;
}
blockquote>:first-child {
margin-top: 0px;
}
blockquote>:last-child {
margin-bottom: 0px;
}
/* HORIZONTAL RULES
=============================================================================*/
hr {
clear: both;
margin: 15px 0;
height: 0px;
overflow: hidden;
border: none;
background: transparent;
border-bottom: 4px solid #ddd;
padding: 0;
}
/* TABLES
=============================================================================*/
table th {
font-weight: bold;
}
table th, table td {
border: 1px solid #ccc;
padding: 6px 13px;
}
table tr {
border-top: 1px solid #ccc;
background-color: #fff;
}
table tr:nth-child(2n) {
background-color: #f8f8f8;
}
/* IMAGES
=============================================================================*/
img {
max-width: 100%
}
-->
pytho自动化开发 day02
Date:2016.01.09
@南非波波
作者注：
经过第一天的学习以及后续的代码练习,给自己一个约定的代码风格、格式：
1. 模块名：
模块应该使用尽可能短的、全小写命名，可以在模块命名时使用下划线以增强可读性。
例如：
login_shop.py
2. 类名定义：
由于类名要求首字母必须大写，所以这样定义：
class MyFristClass: # 类名有三个单词组成，分别首字母大写
def __init__(self,a):
pass
3. 函数名定义：
普通函数：
选择使用字母小写，单词直接使用下划线_分割：
shop_mag(users):
pass
4. 变量名定义：
全局变量名：
字母全大写： SHOPLIST
普通变量名：
字母小写，单词分割选择使用首字母大写： shopUsers
以上规范并不是必须，但是作为个人的编程习惯而言，是一种很好的养成约束。
课程大纲地址： http://www.cnblogs.com/wupeiqi/articles/5115190.html
python知识拾忆：
Python2.x与Python3.x关于dict.keys()返回值的类型对比：
一、python种类
关于Python的一些版本内部执行的一些原理。从原理上来看待执行快慢的类型，从而选择自己需要的去学习。目前而言，最火的就是cpython了，这也是官方版本的Python。后面出现的pypy渐渐崭露头角，用银角大王的话讲：这货日后指定会火...
1. cpython 使用c解释器生产.pyc(字节码)，然后转换成机器码，最后到cpu
2. javapython java解释器-->字节码-->机器码-->cpu
3. IronPython C#解释器-->字节码 --> 机器码--> cpu
4. pypy 内部使用自己的解释器编译成字节码-->机器码.最后在外部执行的时候直接是机器码，速度要快
银角大王推荐阅读书：《python源码剖析》
二、字节码
在Python内部字节码直接的转换过程如图：
python中进行字节码之间的转换流程大概是这样的：字节码类型转换从utf-8转换成gbk类型，首先需要执行解码变成Unicode类型，然后再由Unicode类型编码成gbk类型。[图片来源：银角大王课堂笔记]
三、字符串
博客链接：http://www.cnblogs.com/songqingbo/p/5126957.html
字符串的常用操作包括但不限于以下操作：
字符串的替换、删除、截取、复制、连接、比较、查找、分割等
这里将对字符串的内置操作方法进行总结归纳，重点是以示例的方式进行展示。
使用type获取创建对象的类 type(name)
使用dir获取类的成员dir(name)
使用vars获取类的成员和各个成员的值
capitalize
功能：字符串首字母大写
name = 'swhthaitun'
name.capitalize()
返回结果：'Swht'
casefold()首字母小写
name = 'HelloWord'
reault = name.casefold()
print(reault)
返回结果：helloword
casefold
pass
center
功能：字符串宽度填充，使用原有字符串+填充字符构成指定长度的新的字符串
name = 'swhthaitun'
name.center(15)
返回结果：' swhthaitun ' #默认以空格进行填充
name.center(16,'*')
返回结果：'***swhthaitun***'
功能：字符串居中，以‘*’分割(20为新产生字符串的总的宽度)
name = 'HelloWord'
reault = name.center(20,'*')
print(reault)
返回结果：*****HelloWord******
count
功能：统计某个字符在字符串中出现的次数，或在字符串指定区间内完成上述操作
name = 'swhthaitun'
name.count('h')
返回结果：2
name.count('h',0,3) #从索引值0-3范围的字符中统计'h'出现的次数
返回结果：1
功能：统计子序列出现的次数
name = 'HelloWord'
reault = name.count('W') #如果换成'w'，返回结果为0，python对大小写敏感
print(reault)
返回结果：1
name = 'HelloWord'
reault = name.count('l',0,3) #统计单个字符出现的次数,可以指定起始范围,另外在python中起始范围讲究顾头不顾尾的原则，即[0,3)
print(reault)
encode
功能：对字符串进行编码操作
name = 'swhthaitun'
name.encode()
返回结果：b'swhthaitun'
功能：转变字符串的编码
name = '南非波波'
reault = name.encode('gbk')
print(reault)
返回结果：b'\xc4\xcf\xb7\xc7\xb2\xa8\xb2\xa8'
endswith
功能：判断字符串是否以某个字符串结尾的，返回值为bool型
name = 'swhthaitun'
name.endswith('s')
返回结果：False
name.endswith('n')
返回结果：True
name.endswith('tun')
返回结果：True
name = 'Iamalatterboy'
reault = name.endswith('y')
print(reault)
返回结果：True
expandtabs
功能：将制表符'\t'转换成指定宽度的tab键分割，默认tabsize=8
li = 'sw\tht'
li.expandtabs(4)
返回结果：'sw ht'
li.expandtabs()
返回结果：'sw ht'
find
功能：在字符串中查找指定字符串，找不到时返回-1
name = 'swht'
name.find('s')
返回结果：0
name.find('h')
返回结果：2
format
功能：格式化输出字符串
li = 'I\'m {},{}' #两个'{}'是占位符
li.format('swht','欢迎来中国')
返回结果："I'm swht,欢迎来中国"
参考：http://blog.chinaunix.net/uid-23802873-id-4477364.html
_contains_
功能：包含 -->'eal' in name
name = 'swhtkkskjj'
reault = name.__contains__('swht')
print(reault)
返回结果：True
index
功能：在字符串中查找指定的字符串,找不到时直接报错
name = 'swhthaitun'
name.index('w')
返回结果：1
join()
功能：字符串连接
name = 'swhthaitun'
'*'.join(name)
返回结果：'s*w*h*t*h*a*i*t*u*n'
isalnum
功能：检查判断字符串是否包含字母数字字符（http://www.yiibai.com/python/string_isalnum.html）
name = 'swhthaitun'
name.isalnum()
返回结果：True
isalpha
功能：检测字符串是否只由字母组成（http://www.runoob.com/python/att-string-isalpha.html）
name = 'swhthaitun'
name.isalpha()
返回结果：True
isdecimal
功能：检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。（参考：http://www.runoob.com/python/att-string-isdecimal.html）
name = 'swhthaitun'
name.isdecimal()
返回结果：False
isdigit
功能：检测字符串是否只由数字组成。(参考:http://www.runoob.com/python/att-string-isdigit.html)
name = 'swhthaitun'
name.isdigit()
返回结果：False
isidentifier
功能：检测字符串是否是字母开头
name = 'swhthaitun'
name.isidentifier()
返回结果：True
name = '1swhthaitun'
name.isidentifier()
返回结果：False
isnumeric
功能：检测字符串是否只由数字组成。这种方法是只针对unicode对象。
name = 'swhthaitun'
name.isnumeric()
返回结果：False
Li = '5523'
Li.isnumeric()
返回结果：True
isprintable
功能：判断字符串中所有字符是否都属于可见字符
a = "\tPuppy"
a.isprintable()
返回结果：False
name = 'swhthaitun'
name.isprintable()
返回结果：True
isspace
功能：检测字符串是否为空格
name = 'swhthaitun'
name.isspace()
返回结果：False
Li = ' '
Li.isspace()
返回结果：True
istitle
功能：判断字符串是否适合当作标题（其实就是每个单词首字母大写）
a = "a puppy"
b = "Puppy"
a.istitle()
返回结果：False
b.istitle()
返回结果：True
isupper
功能：判断字符串中所有字母字符是否都是大写字母
a = "puppy"
b = "PUPPY"
a.isupper()
返回结果：False
b.isupper()
返回结果：True
ljust
功能：返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。（参考：http://www.runoob.com/python/att-string-ljust.html）
语法：str.ljust(width[, fillchar])
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。
name = 'swhthaitun'
name.ljust(50,'*')
返回结果：'swhthaitun****************************************'
lower
功能：将所有的字母转换成小写字母
name = 'SWHT'
name.lower()
返回结果：'swht'
lstrip
功能：去除字符串左边开头的空格
name = ' swht '
name.lstrip()
返回结果：'swht '
rstrip
功能：去除字符串右边结尾的空格
name = ' swht '
name.rstrip()
返回结果：' swht'
strip
功能：去除字符串两边的空格
name = ' swht '
name.rstrip()
返回结果：'swht'
maketrans
功能：用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。
语法：str.maketrans(intab, outtab)
参数：intab -- 字符串中要替代的字符组成的字符串。
outtab -- 相应的映射字符的字符串。
intab = "swhtr"
outtab = "12345"
name = "hjjksknsnjmk"
name.maketrans(intab, outtab)
返回结果：{104: 51, 114: 53, 115: 49, 116: 52, 119: 50}
partition
功能：根据指定的分隔符将字符串进行分割。
如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
name = 'swht'
li = 'hhsslswhtolljm'
li.partition(name)
返回结果：('hhssl', 'swht', 'olljm')
replace
功能：把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
语法：str.replace(old, new[, max])
参数：old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
str = "this is string example....wow!!! this is really string"
str.replace("is", "was")
返回结果：'thwas was string example....wow!!! thwas was really string'
str.replace("is", "was", 3)
返回结果：'thwas was string example....wow!!! thwas is really string'
split
功能：字符串分割，默认是空格
name.split()
返回结果：['swht']
name.split('s') #以's'字符进行分割
返回结果：['', 'wht']
_add_
功能：在字符串后面增加指定的字符或字符串
name = 'swht'
name.__add__('e')
返回结果：'swhte'
li = 'hjh'
name.__add__(li)
返回结果：'swhthjh'
_contains_
功能：判断指定字符串是否包含在字符串中,返回值为True和False
name = 'swht'
name.__contains__('s')
返回结果：True
_eq_
功能：判断字符串是否相等，返回值为True和False
name = 'swht'
li = 'test'
name.__eq__(li)
返回结果：False
四、列表
博客链接：http://www.cnblogs.com/songqingbo/p/5126943.html
列表的基本操作示例展示：
append
功能：列表追加元素
name = ['sd','dfdf','drer']
name.append('sdsd')
返回结果：name
['sd', 'dfdf', 'drer', 'sdsd']
clear
功能：情况列表元素
name = ['sd','dfdf','drer']
name.clear()
返回结果：name
[]
copy
功能：浅拷贝，即只拷贝第一层的元素
name = ['sd','dfdf','drer']
li = ['ssd']
li = name.copy()
返回结果：li
['sd', 'dfdf', 'drer']
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
li = ['ssd']
li = name.copy()
返回结果：li
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd']]
count
功能：统计列表指定元素个数
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.count('sd')
返回结果：1
li = ['sd','sdsds',['sd','dffdg',],]
li.count('sd') #只统计第一层的元素个数
返回结果：1
extend
功能：追加字符元素或列表元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
li = ['sd','sdsds',['sd','dffdg',],]
name.extend('ss')
返回结果：name
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's']
name.extend('d')
返回结果：name
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's', 'd']
name.extend(li)
返回结果：name
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's', 'd', 'sd', 'sdsds', ['sd', 'dffdg']]
index
功能：定位列表中某元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.index('sd')
返回结果：0
name.index('drer')
返回结果：2
返回结果：name.index('dr') #当出现某元素不在列表中的时候会直接报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'dr' is not in list
insert
功能：在指定索引位置的元素前面插入新的元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.insert(3,'sd')
返回结果：name
['sd', 'dfdf', 'drer', 'sd', ['sddss', 'sdsdsd']]
pop
功能：删除指定索引值的元素,返回值为当前删除的元素的值。不指定索引值，默认删除最后一个元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.pop(3)
返回结果：'sd'
remove
功能：删除列表中指定的元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.remove('sd')
name
返回结果：['dfdf', 'drer', ['sddss', 'sdsdsd']]
reverse
功能：用于反向列表中元素。
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.reverse()
name
返回结果：[['sddss', 'sdsdsd'], 'drer', 'dfdf', 'sd']
sort
功能：对单层列表进行元素的排序
name = ['sd','dfdf','drer',]
name.sort()
name
返回结果：['dfdf', 'drer', 'sd']
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.sort() #报错的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
五、元组
关于元组的常用操作，请参考：http://www.runoob.com/python/python-tuples.html
博客链接：http://www.cnblogs.com/songqingbo/p/5126947.html
元组的元素不可修改 ，元组的元素的元素可修改
count(self,value)
功能：统计当前元组中某元素的个数
tup = (55,77,85,55,96,99,22,55,)
tup.count(55)
返回结果：3
备注：元素‘55’在元组tup中出现了3次
index(self, value, start=None, stop=None)
功能：获取元素在元组中的索引值,对于重复的元素,默认获取从左起第一个元素的索引值
tup = (55,77,85,55,96,99,22,55,)
tup.index(55)
返回结果：0
tup.index(85)
返回结果：2
tup.index(55,2,7)
返回结果：3
_add_
功能：将另一个元组追加到当前元组后面.__add__()只接收元组类型的序列
tup1 = (12,33,566,78,)
tup2 = (55,66,77,)
tup1.__add__(tup2)
返回结果：(12,33,566,78,55,66,77,)
_contains_
功能：包含，判断某元素是否包含在元组中
tup = (55,77,85,55,96,99,22,55,)
tup.__contains__(55)
返回结果：True
备注：返回值类型是bool型，该方法判断在对成员元素是否存在元组中，程序根据返回不同的bool值进行相应的值返回或者操作
_eq_
功能：判断两个元组是否相等，返回值类型为bool型
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__eq__(tup1)
返回结果：False
_getattribute_
pass
_getitem_
功能：获取指定索引值的元素值
tup = (55,77,85,55,96,99,22,55,)
tup.__getitem__(5)
返回结果：99
_getnewargs_
功能：只是获取原来的元组？？无卵用
tup = (55,77,85,55,96,99,22,55,)
tup.__getnewargs__()
返回结果：((55, 77, 85, 55, 96, 99, 22, 55),)
_ge_
功能：判断当前元组是否大于等于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__ge__(tup1)
返回结果：False #bool类型
_gt_
功能：判断当前元组是否大于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__ge__(tup1)
返回结果：False #bool类型
_hash_
功能：计算元组的hash值
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__hash__()
返回结果：-2123087613
tup1.__hash__()
返回结果：1338854611
_init_
功能：初始化作用，无返回值
_iter_
功能：获取元组的内存地址
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__iter__()
返回结果：<tuple_iterator object at 0x01C21F70>
tup1.__iter__()
返回结果：<tuple_iterator object at 0x01C21F50>
_len_
功能：获取元组的长度
tup.__len__() #该方法已经被放到python的内置函数中，可以使用len(tup)获取长度
返回结果：8
_le_
功能：判断当前元组是否小于等于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__le__(tup1)
返回结果：True #bool类型
_lt_
功能：判断当前元组是否小于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__lt__(tup1)
返回结果：True #bool类型
_mul_
功能：把当前元组按照某个值的倍数进行元组的扩展，产生新的元组
tup = (55,77,85,55,96,99,22,55,)
tup.__mul__(2)
返回结果：(55, 77, 85, 55, 96, 99, 22, 55, 55, 77, 85, 55, 96, 99, 22, 55)
tup.__iter__()
返回结果：<tuple_iterator object at 0x01C21F70>
tup.__mul__(2).__iter__()
返回结果：<tuple_iterator object at 0x01C2F050>
_new_
pass
_ne_
功能：判断当前元组不等于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__ne__(tup1)
返回结果：True #bool类型
_repr_
功能：将元组转换成一个字符串
tup = (55,77,85,55,96,99,22,55,)
tup.__repr__()
返回结果：'(55, 77, 85, 55, 96, 99, 22, 55)'
type(tup.__repr__())
返回结果：<class 'str'>
_rmul_
功能：？？怎么感觉跟__mul__一个德行？？
tup = (55,77,85,55,96,99,22,55,)
tup.__rmul__(2)
返回结果：(55, 77, 85, 55, 96, 99, 22, 55, 55, 77, 85, 55, 96, 99, 22, 55)
六、字典
博客链接：http://www.cnblogs.com/songqingbo/p/5127044.html
字典的常用操作：
clear
功能：清空字典
dict_li = {'users':'swht','age':'18',}
dict_li.clear()
返回结果：dict_li
{}
copy
功能：浅拷贝
dict_li = {'users':'swht','age':'18',}
dict_li.copy()
返回结果：{'age': '18', 'users': 'swht'}
dict_li = {'users':'swht','age':'18','address':{'sd':'dz'}}
dict_li.copy()
返回结果：{'age': '18', 'users': 'swht', 'address': {'sd': 'dz'}}
fromkeys()
功能：用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
语法：dict.fromkeys(seq[, value]))
参数：seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值。
li = ['users','age']
dict_li = dict.fromkeys(li,'swht')
返回结果：dict_li
{'age': 'swht', 'users': 'swht'}
get
功能：获取字典的value值
dict_li = {'users':'swht','age':'18',}
dict_li.get('users')
返回结果：'swht'
items
功能：返回可遍历的(键, 值) 元组数组
dict_li = {'users':'swht','age':'18',}
dict_li.items()
返回结果：dict_items([('age', '18'), ('users', 'swht')])
keys
功能：获取字典可遍历的键
dict_li = {'users':'swht','age':'18',}
dict_li.keys()
返回结果：dict_keys(['age', 'users'])
pop
功能：删除字典中指定的键值
dict_li = {'users':'swht','age':'18',}
dict_li.pop('age')
返回结果：'18'
popitem
功能：随机返回并删除字典中的一对键和值
dict_li = {'users':'swht','age':'18',}
dict_li.popitem()
返回结果：('age', '18')
dict_li
{'users': 'swht'}
setdefault
功能：查找键值，如果键不已经存在于字典中，将会添加键并将值设为默认值。
dict_li = {'users':'swht','age':'18',}
dict_li.setdefault('ID',5)
返回结果：5
dict_li
返回结果：{'age': '18', 'users': 'swht', 'ID': 5}
update
功能：把指定字典的键值更新到当前字典中
dict_li = {'users':'swht','age':'18',}
dict_ai = {'address':'山东'}
dict_li.update(dict_ai)
dict_li
返回结果：{'age': '18', 'users': 'swht', 'address': '山东'}
values
功能：获取字典的所有值
dict_li = {'age': '18', 'users': 'swht', 'address': '山东'}
dict_li.values()
返回结果：dict_values(['18', 'swht', '山东'])
七、set集合
博客链接：http://www.cnblogs.com/songqingbo/p/5128066.html
set集合是一个无序且不重复的集合。
创建一个set集合：
name = set('sdd')
name
返回结果：{'d', 's'}
add
功能：增加集合元素
name = {'d', 's'}
name.add('d')
name
返回结果：{'d', 's'}
name.add('sd')
name
返回结果：{'sd', 'd', 's'}
clear
功能：清空集合元素
name = {'d', 's'}
name.clear()
name
返回结果：{}
copy
功能：浅拷贝
name = {'sd', 'd', 's'}
li = name.copy()
返回结果：li
{'sd', 'd', 's'}
difference
功能：取差集
name = {'sd', 'd', 's'}
li = set()
name.difference(li)
返回结果：name.difference()
{'sd', 'd', 's'}
difference_update
功能：删除当前set中的所有包含在 new set 里的元素
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.difference_update(li)
name
返回结果：{'sd'}
discard
功能：移除元素
name = {'sd', 'd', 's'}
name.discard('s')
返回结果：name
{'sd', 'd'}
intersection
功能：取交集,建立新的set集合
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection(li)
返回结果：{'d', 's'}
intersection_update
功能：取交集,更新原来的set集合
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection_update(li)
返回结果：{'d', 's'}
isdisjoint
功能：判断没有交集，返回True,否则,返回False
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.isdisjoint(li)
issubset
功能：判断是否是子集
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li) #判断name是不是li的子集
返回结果：False
li.issubset(name) #判断li是不是name的子集
返回结果：True
issuperset
功能：判断是否是父集
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li) #判断name是不是li的父集
返回结果：True
li.issubset(name) #判断li是不是name的父集
返回结果：False
pop
功能：移除集合元素
name = {'sd', 'd', 's'}
name.pop('s')
返回结果：'sd' #从左侧删除收个
remove
功能：移除指定集合元素
name = {'sd','d','s'}
name.remove('s')
返回结果：name
{'sd', 'd'}
symmetric_difference
功能：去两个集合的差集，建立新的set集合对象
name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference(li)
返回结果：{'sd'}
symmetricdifferenceupdate
功能：去两个集合的差集，更新原来的集合对象
name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference_update(li)
返回结果：{'sd'}
union
功能：并集，创建新的对象
name = {'sd', 'd', 's'}
li = {'s', 'd','h'}
name.union(li)
返回结果：{'h', 's', 'd', 'sd'}
update
功能：更新已有集合
name = {'sd', 'd', 's'}
name.update('df')
name
返回结果：{'sd', 'd', 'f', 's'}
八、类与对象
对象
python中一切事物皆对象,对象是一开始就有的,只是我们无法访问它。访问对象需要以变量的形式去访问（即创建变量指向到对象的，变量即对对象的引用）
在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）
结论：对象=属性+方法
类
在python中，把具有相同属性和方法的对象归为一个类（class）
比如人类，动物，植物等等，这些都是类的概念。
类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。
类包含描述对象的方法。
int
取绝对值：
age = -19
age.__abs__() #int类函数调用
abs(-19) #内置函数方式操作
取商和余数：
age = 95
age.__divmod__(10) #95/10 -->(9,5)
相加：
a = 5，b=6
a.__add__(b) #调用int的类函数add，相当于a + b -->11
a + b #内置函数方式操作
作业：
1. 博客整理
2. 购物商城实现
1. 商品展示，价格
2. 购物车添加商品（进行差异商品，同一种商品应该只存在一条数据）
3. 付款（根据钱进行判断是否可以满足付款）
3. 预习
http://www.cnblogs.com/wupeiqi/articles/5115190.html 后面的部分