python整理之（字符串、元组、列表、字典）

一、关于字符串的整理总结

对于字符串的操作常用的有这些：

字符串的操作通过dir()函数可以查看

我们先整理没有下划线的用法，有下划线的暂时不去考虑。

1、capitalize

功能：使字符串的首字母大写

例如：

>>> name = "sanjiang"
>>> name.capitalize()
'Sanjiang'

2、casefold

功能：使字符串的首字母小写

例如：

>>> name = "Sanjiang"
>>> name.casefold()
'sanjiang'

3、center

功能：字符串宽度填充，使用原有字符串+填充字符构成指定长度的新的字符串

>>> name = "sanjiang"

>>> name.center(30,'*')

#30指的是原有字符串加上填充字符构成字符串的长度。'*'指的是以*分隔，默认空格填充， 
'***********sanjiang***********'

4、count

功能：统计某个字符在字符串中出现的次数，或在字符串指定区间内完成上述操作

>>> name = "sanjiang"
>>> name.count('s')
1
>>> name.count('a')
2
>>> name.count('a',0,4) 　　#从索引值0-4范围的字符中统计'a'的次数
1

5、format

    功能：格式化输出字符串
>>> li = 'I\'m {},{}' #两个'{}'是占位符
>>> li.format('swht','欢迎来中国')
返回结果："I'm swht,欢迎来中国"

6、join()

功能：字符串连接

>>>name = 'swhthaitun‘

>>>’*'.join(name) 

返回结果：'s*w*h*t*h*a*i*t*u*n'

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 #内置函数方式操作