python开发学习-day02(元组、字符串、列表、字典深入)

时间:2023-03-08 16:07:47

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开发学习-day02(元组、字符串、列表、字典深入)

一、python种类

关于Python的一些版本内部执行的一些原理。从原理上来看待执行快慢的类型,从而选择自己需要的去学习。目前而言,最火的就是cpython了,这也是官方版本的Python。后面出现的pypy渐渐崭露头角,用银角大王的话讲:这货日后指定会火...

1. cpython  使用c解释器生产.pyc(字节码),然后转换成机器码,最后到cpu
2. javapython java解释器-->字节码-->机器码-->cpu
3. IronPython C#解释器-->字节码 --> 机器码--> cpu
4. pypy 内部使用自己的解释器编译成字节码-->机器码.最后在外部执行的时候直接是机器码,速度要快

银角大王推荐阅读书:《python源码剖析》

二、字节码

在Python内部字节码直接的转换过程如图:

python开发学习-day02(元组、字符串、列表、字典深入)

    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开发学习-day02(元组、字符串、列表、字典深入)

对象

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 后面的部分