标签：

字符串，列表，元组，字典

1.字符串 

str.capitalize()

     返回首字符大写，而其余字符小写的字符串副本。

str.casefold()

      返回大小写折叠字符串副本。大小写折叠字符串可用于不区分大小写匹配情况。

      大小写折叠类似小写转换，但更过分；因为它的目的是移除所有字符串大小写区别。譬如：德语小写字母 ‘ß‘ 等价于 "ss"。由于它已是小写，因此，lower() 方法不会对 ‘ß‘ 做任何处           理；而casefold() 方法会把它转换成 "ss"。

str.center(width[, fillchar])

     返回长为width 的中对齐字符串。若 width (宽度)小于或等于 len(s) 内置函数的话，会返回原字符串。

str.count(sub[, start[, end]])

     返回子字符串 sub 在范围 [start, end] 间的非-重叠出现次数。

str.encode(encoding="utf-8", errors="strict")

     以字节对象形式返回编码版字符串。默认编码为 ‘utf-8‘。errors (错误) 自变量倾向于设置不同错误处理方案。errors (错误) 自变量默认值为 ‘strict (严格)‘，意味着编码错误会引发        UnicodeError (Unicode 错误)。

str.endswith(suffix[, start[, end]])

    若字符串以指定 suffix (后缀) 自变量结束的话，返回 True；否则，会返回 False。

str.find(sub[, start[, end]])

    返回在字符串切片 s[start:end] 中找到的子字符串 sub 自变量的最低索引。若找不到 sub 自变量的话，返回 -1。

str.index(sub[, start[, end]])

     类似 find() 方法；当找不到子字符串时，但会引发 ValueError (值错误)。

str.isalnum()

     若字符串所有字符是字母数字且至少有一字符的话，返回 True；否则，会返回 False。

str.isalpha()

      若字符串所有字符是字母且至少有一字符的话，返回 True；否则，会返回 False。

str.isdecimal()

      若字符串所有字符是十进制字符且至少有一字符的话，返回 True；否则，会返回 False。

str.isdigit()

      若字符串所有字符是数字且至少有一字符的话，返回 True；否则，会返回 False。

str.islower()

       若字符串所有大小写字符是小写且至少有一大小写字符的话，返回 true，否则，会返回 False。

str.isnumeric()

       若字符串所有字符是数值字符且至少有一字符的话，返回 true，否则，会返回 False。数值字符包括：数字字符、具有 Unicode 数值特性的所有字符；譬如：U+2155 普通分数 1/5。          形式上，数值字符是具有 Numeric_Type=Digit (数值类型=数字)、Numeric_Type=Decimal (数值类型=十进制)、Numeric_Type=Numeric (数值类型=数值) 特性值的        那些字符。

str.isprintable()

      若字符串所有字符可打印或字符串为空的话，返回 true，否则，会返回 False。

str.isspace()

      若字符串中只有空白字符且至少有一字符的话，返回 true，否则，会返回 False。

str.istitle()

     若字符串是首字母大写字符串且至少有一字符的话，返回 true，否则，会返回 False。譬如：大写字符之后仅紧跟无法大小写字符和仅大小写一次的小写字符。否则，会返回 False。

str.isupper()

       若字符串所有大小写字符是大写且至少有一大小写字符的话，，返回 true，否则，会返回 False。

str.join(iterable)

       返回原字符串和 iterable (可迭代) 的拼接字符串。会引发 TypeError (类型错误)，若 iterable (可迭代) 中有任何非-字符串值，包括 bytes (字节)对象的话。元素间的分隔符是由该            方法提供的原字符串。

str.ljust(width[, fillchar])

        返回长为 width (宽度) 的左对齐字符串。若 width (宽度) 自变量小于或等于 len(s) 内置函数的话，会返回原字符串。

str.lstrip([chars])

        返回移除前导字符的字符串副本。chars (字符) 是要移除字符集指定字符串。若省略或 None 的话，chars (字符) 会默认移除空白。如果chars (字符)不是前缀；一定程度上，会剥离它           的值的所有前导组合：

>>> ‘   spacious   ‘.lstrip()
‘spacious   ‘
>>> ‘www.example.com‘.lstrip(‘cmowz.‘)
‘example.com‘

str.maketrans(x[, y[, z]])

       该静态方法能返回可用于 str.translate() 方法的转译表

str.partition(sep)

       从 sep (分隔) 自变量首次出现处拆分字符串，并返回含有分隔符之前部分、分隔符本身、分隔符之后部分的 3-元组。若找不到分隔符的话，会返回含有字符串本身、紧接着是两空字符          串的 3-元组。

str.replace(old, new[, count])

        返回以 new 替换所有出现的 old 子字符串的字符串副本。若给定可选 count 自变量，则只会替换最先 count 次出现。

str.rfind(sub[, start[, end]])

        返回在字符串切片 s[start:end] 中找到的子字符串 sub 自变量的最高索引。可选 start (起始) 和 end (结束) 自变量的解释见切片表示法。失败时，会返回-1。

str.rindex(sub[, start[, end]])

        类似 rfind() 方法；但会引发 ValueError (值错误)，当找不到子字符串 sub 时。

str.rjust(width[, fillchar])

返回长为 width (宽度) 的右对齐字符串。若 width (宽度) 自变量小于或等于 len(s) 内置函数的话，会返回原字符串。

str.rpartition(sep)

从 sep (分隔) 最后一次出现处拆分字符串，并返回含有分隔符之前部分、分隔符本身、分隔符之后部分的 3-元组。若找不到分隔符的话，会返回含有两空字符串、紧接着是字符串本身的 3-元组。

str.rsplit(sep=None, maxsplit=-1)

返回以 sep (分隔) 作为定界字符串的字符串单词列表。若给定 maxsplit (最大拆分) 的话，最多拆分最右边那些 maxsplit 次。若 sep (分隔) 不指定或为 None 的话，分隔符是任意空白字符串。除从右侧拆分外，rsplit() 方法表现类似下文详细描述的 split() 方法。

str.rstrip([chars])

返回移除结尾字符的字符串副本。chars (字符) 自变量是要移除字符集指定字符串。若省略或 None 的话，chars (字符) 自变量会默认移除空白。chars (字符)自变量不是后缀；一定程度上，会剥离它的值的所有结尾组合：

>>> ‘   spacious   ‘.rstrip()
‘   spacious‘
>>> ‘mississippi‘.rstrip(‘ipz‘)
‘mississ‘

 

str.split(sep=None, maxsplit=-1)

返回以 sep (分隔) 作为定界字符串的字符串单词列表。若给定 maxsplit (最大拆分) 的话，最多拆分 maxsplit 次 (因此，返回列表最多具有maxsplit+1 元素)。若 maxsplit (最大拆分) 自变量不指定或为 -1 的话，会不限拆分次数 (产生所有可能拆分)。

若给定 sep (分隔) 的话，就不会把连续定界符分组到一起，且会认为是在定界空字符串；譬如：方法 ‘1,,2‘.split(‘,‘) 会返回 [‘1‘, ‘‘, ‘2‘]。sep (分隔) 自变量可由多字符组成；譬如：方法 ‘1<>2<>3‘.split(‘<>‘) 会返回 [‘1‘, ‘2‘, ‘3‘]。注意：以指定分隔符拆分空字符串会返回 [‘‘]。

譬如：

>>> ‘1,2,3‘.split(‘,‘)
[‘1‘, ‘2‘, ‘3‘]
>>> ‘1,2,3‘.split(‘,‘, maxsplit=1)
[‘1‘, ‘2 3‘]
>>> ‘1,2,,3,‘.split(‘,‘)
[‘1‘, ‘2‘, ‘‘, ‘3‘, ‘‘]

 

若 sep (分隔) 自变量不指定或为 None 的话，会应用不同拆分算法，譬如：把连续运行空白看成单分隔符，结果开头和结尾不会含有空字符串 (若字符串开头或结尾有空白的话)。因此，以 None 分隔符拆分空字符串或仅由空白组成的字符串会返回 []。

譬如：

>>> ‘1 2 3‘.split()
[‘1‘, ‘2‘, ‘3‘]
>>> ‘1 2 3‘.split(maxsplit=1)
[‘1‘, ‘2 3‘]
>>> ‘   1   2   3   ‘.split()
[‘1‘, ‘2‘, ‘3‘]

 

str.splitlines([keepends])

返回断于行边界的字符串行列表。该方法会以 universal newlines (通用换行符) 方式拆分行。

譬如：

>>> ‘ab c\n\nde fg\rkl\r\n‘.splitlines()
[‘ab c‘, ‘‘, ‘de fg‘, ‘kl‘]
>>> ‘ab c\n\nde fg\rkl\r\n‘.splitlines(keepends=True)
[‘ab c\n‘, ‘\n‘, ‘de fg\r‘, ‘kl\r\n‘]

 

不像split()方法,对于一个空字符串它返回空, 如果回车符号在字符串结尾处则不起作用:

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
[‘One line‘]

对比下 split(‘\n‘) 

>>> ‘‘.split(‘\n‘)
[‘‘]
>>> ‘Two lines\n‘.split(‘\n‘)
[‘Two lines‘, ‘‘]

str.startswith(prefix[, start[, end]])

若字符串以 prefix (前缀) 开始的话，返回 True，否则，会返回 False。此外，prefix (前缀) 还可以是要查找的前缀元组。使用可选 start (起始)，会从起始位置开始测试字符串。使用可选 end (结束) ，会在结束位置停止比较字符串。

str.strip([chars])

返回移除前导和结尾字符的字符串副本。chars (字符) 自变量是要移除字符集指定字符串。若省略或 None 的话，chars (字符) 自变量会默认移除空白。chars (字符) 自变量不是前缀或后缀；一定程度上，会剥离它的值的所有前导和结尾组合：

>>> ‘   spacious   ‘.strip()
‘spacious‘
>>> ‘www.example.com‘.strip(‘cmowz.‘)
‘example‘

str.swapcase()

大小写转换，返回大写字符转换成小写，小写字符转换成大写的字符串副本。注意：比较运算 s.swapcase().swapcase() == s 未必为 True。

str.title()

返回单词以大写字符开始且其余字符为小写的字符串首字母大写版。

譬如：

>>> ‘Hello world‘.title()
‘Hello World‘

str.translate(map)

返回一个 map (映射) 已映射所有字符 的副本。未映射字符保持不变。会删除映射到 None 的字符。

也采用 str.maketrans() 方法以不同格式，从字符-到-字符映射创建转译映射。

str.upper()

返回所有大小写字符被转换成大写的字符串副本。注意：str.upper().isupper() 方法可能为 False。

str.zfill(width)

        

        返回一个填充了ASCII码‘0’的字符串副本，若 width (宽度) 自变量小于或等于 len(s) 内置函数的话，会返回原字符串，。

        譬如：

>>> "42".zfill(5)
‘00042‘
>>> "-42".zfill(5)
‘-0042‘

2.列表

1. list 函数

类型转换，将一个可迭代类型的数据转化成列表

>>> list(‘python‘)
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]

2.元素赋值

>>> s
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s[1] = 1
>>> s
[‘p‘, 1, ‘t‘, ‘h‘, ‘o‘, ‘n‘]

3.切片

顾头不顾尾

>>> s
[‘p‘, 1, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s[2:5]
[‘t‘, ‘h‘, ‘o‘]

第三个数字是步长

>>> s
[‘p‘, 1, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s[2:5:2]
[‘t‘, ‘o‘]

4.删除元素

>>> s
[‘p‘, 1, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> del s[1]
>>> s
[‘p‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]

5.分片赋值

在使用分片赋值时，可以使用与原序列不等长的序列将分片替换：

>>> name = list(‘Perl‘)
>>> name[1:] = list(‘ython‘)
>>> name
[‘P‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]

分片赋值语句可以在不需要替换任何原有元素的情况下插入新的元素。

>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]

通过分片赋值来删除元素也是可行的。

>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = []
>>> numbers
[1, 5]

6.append方法

append方法用于在列表末尾追加新的对象：

>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

7.count方法

用户统计某个字符串出现的频率

>>> s = list(‘python perl php‘)
>>> s
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘, ‘ ‘, ‘p‘, ‘e‘, ‘r‘, ‘l‘, ‘ ‘, ‘p‘, ‘h‘, ‘p‘]
>>> s.count(‘p‘)
4

8.extend方法

用于扩展列表

>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s2
[‘p‘, ‘e‘, ‘r‘, ‘l‘]
>>> s1.extend(s2)
>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘e‘, ‘r‘, ‘l‘]

 extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。

>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s2
[‘p‘, ‘e‘, ‘r‘, ‘l‘]
>>> s1.extend(s2)
>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘e‘, ‘r‘, ‘l‘]
>>> s1 + s2
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘e‘, ‘r‘, ‘l‘, ‘p‘, ‘e‘, ‘r‘, ‘l‘]
>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘e‘, ‘r‘, ‘l‘]

9.index

找出某个元素在列表中的位置

>>> s1 = list(‘python‘)
>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s1.index(‘o‘)
4

如果某个元素不再列表中，则报出ValueError

>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s1.index(‘7‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.index(x): x not in list

10. insert

将某个元素插入到列表的某个位置

>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s1.insert(3,‘888‘)
>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘888‘, ‘h‘, ‘o‘, ‘n‘]

如果插入的索引位置超过了列表长度，则插入到最后一位

>>> s1.insert(10,‘888‘)
>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘888‘, ‘h‘, ‘o‘, ‘n‘, ‘888‘]

11.pop

 pop 方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值：

>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]

12.remove

remove 方法用于移除列表中某个值的第一个匹配项：

>>> x = [‘to‘, ‘be‘, ‘or‘, ‘not‘, ‘to‘, ‘be‘]
>>> x.remove(‘be‘)
>>> x
[‘to‘, ‘or‘, ‘not‘, ‘to‘, ‘be‘]
>>> x.remove(‘bee‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

 只有第一次出现的值被移除，删除不存在的元素会报出ValueError错误

13.reverse

reverse 方法将列表中的元素反向存放

>>> s1 = list(‘python‘)
>>> s1
[‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
>>> s1.reverse()
>>> s1
[‘n‘, ‘o‘, ‘h‘, ‘t‘, ‘y‘, ‘p‘]

14. sort

sort 方法用于在原位置对列表进行排序(根据ASCII码字母表)。

>>> s1
[‘n‘, ‘o‘, ‘h‘, ‘t‘, ‘y‘, ‘p‘]
>>> s1.sort()
>>> s1
[‘h‘, ‘n‘, ‘o‘, ‘p‘, ‘t‘, ‘y‘]

 sort 方法修改了 x 却返回了空值。

3.元组

不可变序列

元组使用小括号，列表使用方括号。

1.创建

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

>>> tup1 = (‘physics‘, ‘chemistry‘, 1997, 2000)
>>> tup1
(‘physics‘, ‘chemistry‘, 1997, 2000)

>>> tup3 = "a", "b", "c", "d" 
>>> tup3
(‘a‘, ‘b‘, ‘c‘, ‘d‘)

创建空元组

>>> tup1 = () 
>>> tup1
()

只有一个元素时

>>> tup1 = (50,) 
>>> tup1
(50,)

2. cmp()

cmp(tuple1, tuple2)

如果比较的元素是同类型的,则比较其值,返回结果。

如果两个元素不是同一种类型,则检查它们是否是数字。

• 如果是数字,执行必要的数字强制类型转换,然后比较。
• 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
• 否则,通过类型名字的字母顺序进行比较。

如果有一个列表首先到达末尾,则另一个长一点的列表"大"。

如果我们用尽了两个列表的元素而且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0。

>>> tuple1, tuple2 = (123, ‘xyz‘), (456, ‘abc‘)
>>> print cmp(tuple1, tuple2);
-1
>>> print cmp(tuple2, tuple1);
1

3 tuple

将可迭代类型转化成元组

>>> tuple([1,2,3,4])
(1, 2, 3, 4)

4.字典

1.创建字典

下边创建字典的方式返回的结果是相同的

>>> a = dict(one=1, two=2, three=3)
>>> b = {‘one‘:1, ‘two‘:2, ‘three‘:3}
>>> c = dict(zip([‘one‘, ‘two‘, ‘three‘], [1, 2, 3]))
>>> d = dict([(‘two‘, 2), (‘one‘, 1), (‘three‘, 3)])
>>> e = dict({‘three‘:3, ‘one‘:1, ‘two‘:2})
>>> a == b == c == d == e
True

2.访问字典里的值

3.访问字典里的键

python 基础回顾2

标签：

原文地址：http://www.cnblogs.com/9527chu/p/5495107.html