目录
字符串
类型
字符串是python不可变的数据类型,不可以改变内容
字符串的相关操做
若a=''hello',b=''world''
操作符 | 操做 | 例子 | 结果 |
+ | 字符串相加 | a+b | helloword |
* | 字符串连续输出 | a*2 | hellohello |
[] | 提取字符 | a[0] | h |
[:] | 切片 | a[0:2] | he |
in | 是否包含 | 'h' in a | True |
not in | 是否不包含串 | 'h' not in a | False |
r/R | 原始字符 | r/R'\n' | \n |
PYTHON转义字符
转义字符 | 含义 |
\(在行尾时) | 续行符 |
\\ | 反斜杠符 |
\' | 单引号 |
\'' | 双引号 |
\a | 响铃符 |
\b | 退格符 |
\e | 转义符 |
\000 | 空 |
\v | 纵向制表符 |
\n | 换行符 |
\t | 横向制表符 |
\r | 回车符 |
\f | 换页符 |
\0xx | 八进制数 |
\xyy | 十六进制数 |
\other | 其它的字符以普通格式输出 |
格式化字符
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数(大写) |
%f | 格式化浮点数字 |
%e / %E | 用科学计数法格式化浮点数 |
%p | 用十六进制数格式化变量的地址 |
%% | 输出% |
字符串的函数
.upper() | 全部大写 |
.lower() | 全部小写 |
.swapcase() | 大小写互换 |
.capitalize() | 首字母大写,其余小写 |
.title() | 首字母大写 |
.ljust(width) | 获取固定长度,左对齐,右边不够用空格补齐 |
.rfill(width) | 获取固定长度,右对齐,右边不够用空格补齐 |
.center(width) | 获取固定长度,中间对齐,两边不够用空格补齐 |
.find() | 搜索指定字符串,没有返回-1 |
.rfind() | 从右边开始查找 |
.count() | 统计指定的字符串出现的次数 |
isdigit() | 是否是数字 |
abs | 求数值的绝对值 |
divmod | 返回两个数值的商和余数 |
max | 返回迭代对象中的元素的最大值或者所有参数的最大值 |
min | 返回可迭代对象中的元素的最小值或者所有参数的最小值 |
pow | 返回两个数值的幂运算值或其余指定整数的模值 |
round | 对浮点数进行四舍五入求值 |
sum | 对元素类型是数值的可迭代对象中的每个元素求和 |
reversed | 反转序列生成新的可迭代对象 |
sorted() | 对可迭代对象进行排序,返回一个新的列表 |
zip | 聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器 |
decode() | 以 encoding 指定的编码格式解码字符串 |
.isalnum() | 是否全是数字或字母 |
.isupper() | 是否全为大写 |
.islower() | 是否全为小写 |
.istitle() | 首字母是否大写 |
.isspace() | 是否是空格 |
type() | 字符串的类型 |
len() | 字符串的长度 |
format() | 格式化字符串 |
关于字符串的排序
- 字符串中没有sort()函数,即 str.sort()会报错
- 使用sorted()函数,传入字符串,sorted(str) 进行排序
关于字符串的相关题目代码
def donuts(count):
if count>=0 and count<=9:
return 'Number of donuts: '+str(count)
else:
return 'Number of donuts: many'
def both_ends(s):
if len(s)>=2:
a =s[0:2] + s[-2:]
else:
a=''
return a
def fix_start(s):
fc=s[0]
t = []
for i in range(0,len(s)):
t.append(s[i])
for i in range(1,len(t)):
if t[i]==fc:
t[i]='*'
t1=''.join(t)
return t1
def mix_up(a, b):
c=a[0:2]
d=b[0:2]
zh1=d+a[2:]
zh2=c+b[2:]
return zh1+' '+zh2
def test(got, expected):
if got == expected:
prefix = ' OK '
else:
prefix = ' X '
print('{0} got: {1} expected: {2}'.format(prefix, repr(got), repr(expected)))
def main():
print('donuts')
test(donuts(4), 'Number of donuts: 4')
test(donuts(9), 'Number of donuts: 9')
test(donuts(10), 'Number of donuts: many')
test(donuts(99), 'Number of donuts: many')
print
print('both_ends')
test(both_ends('spring'), 'spng')
test(both_ends('Hello'), 'Helo')
test(both_ends('a'), '')
test(both_ends('xyz'), 'xyyz')
print
print('fix_start')
test(fix_start('babble'), 'ba**le')
test(fix_start('aardvark'), 'a*rdv*rk')
test(fix_start('google'), 'goo*le')
test(fix_start('donut'), 'donut')
print
print('mix_up')
test(mix_up('mix', 'pod'), 'pox mid')
test(mix_up('dog', 'dinner'), 'dig donner')
test(mix_up('gnash', 'sport'), 'spash gnort')
test(mix_up('pezzy', 'firm'), 'fizzy perm')
if __name__ == '__main__':
main()
元组
创建元组
- a=()
- 当只有一个元素时要加逗号(否则不构成元组
元组的类型
元组是不可变的类型
元组里面的数据可以是实数、列表、字符串、甚至元组
元组的缝合
用加号 + 来链接两个元组
- a=(1,2)
- b=(3,4)
- a+b
- (1,2,3,4)
访问元组元素
通过下标的方式进行访问(下表从零开始)
- a=(1,2,(1,2))
- a[2][1]
- 2
元组的切片
tuple[ start : end : step] 其中范围是一个左闭右开的区间
- a=(1,2,3)
- a[0:]
- (1,2,3)
元组的内置函数
函数名 | 操做 |
cmp(tuple1,tuple2) | 比较两个元组的大小 |
len(tuple) | 返回元组的长度 |
max(tuple) | 返回元组的最大值 |
min(tuple) | 返回元组的最小值 |
tuple(seq) | 将列表转化为元组 |
列表
创建列表
- 与元组不同,列表的创建只要是 [ ] 即可
- 如果只有一个元素也不用 逗号,也是列表类型
列表的类型
列表是可变的数据类型,可以通过下标来修改
元组里面的数据可以是实数、元组、字符串、甚至列表
- a=[1,2,3]
- a[0]=5
- a
- [5,2,3]
列表的访问
通过下标访问列表
- a=[(1,2)]
- a[0][1]
- 2
列表的切片
list[ start : end : step] 其中范围是一个左闭右开的区间
- a=[ 1, 2, 3, 4,]
- a[ 1 : ]
- [ 2, 3, 4]
列表的内置函数
函数 | 操做 |
cmp(list1,list2) | 比较两个列表的大小 |
max(list) | 列表中的最大值 |
min(list) | 列表中的最小值 |
len(list) | 列表的元素个数 |
list(seq) | 将其他表转化为列表 |
list.append(数据) | 在列表的尾部插入数据 |
list.pop() | 移除一个元素,默认为表尾 |
list.remove(数据) | 移除这个数据第一次出现的位置 |
list.reverse() | 反向列表的元素 |
list.sort() | 对列表本身进行排序 |
list.insert(位置,数据) | 在指定位置插入元素 |
list.count(数据) | 统计列表中该数据的出现次数 |
list.index(数据) | 找出列表中与数据匹配的第一个位置 |
list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值 |
列表的排序(sort 与 sorted方法的比较)
- list.sort() 是对列表本身进行排序,列表本身该表
- sorted( list ) 是对列表中的元素排序,并将其复制,列表的本身没有改变
列表的相关代码
def match_ends(words):
znum=0
for everyone in words:
if len(everyone)!=0:
sy=everyone[0]
if len(everyone)>=2 and everyone.endswith(sy):
znum+=1
return znum
def clone_runoob(li1):
li_copy = li1[:]
return li_copy
def takelast(elem):
return elem[-1]
def front_x(words):
words1=[]
zc=[]
for everyword in words:
if everyword[0]=='x':
words1.append(everyword)
else:
zc.append(everyword)
words1.sort()
zc.sort()
for a in zc:
words1.append(a)
return words1
def sort_last(tuples):
fz=clone_runoob(tuples)
fz.sort(key=takelast)
return fz
def test(got, expected):
if got == expected:
prefix = ' OK '
else:
prefix = ' X '
print('{0} got: {1} expected: {2}'.format(prefix, repr(got), repr(expected)))
# Calls the above functions with interesting inputs.
def main():
print('match_ends')
test(match_ends(['aba', 'xyz', 'aa', 'x', 'bbb']), 3)
test(match_ends(['', 'x', 'xy', 'xyx', 'xx']), 2)
test(match_ends(['aaa', 'be', 'abc', 'hello']), 1)
print
print('front_x')
test(front_x(['bbb', 'ccc', 'axx', 'xzz', 'xaa']),
['xaa', 'xzz', 'axx', 'bbb', 'ccc'])
test(front_x(['ccc', 'bbb', 'aaa', 'xcc', 'xaa']),
['xaa', 'xcc', 'aaa', 'bbb', 'ccc'])
test(front_x(['mix', 'xyz', 'apple', 'xanadu', 'aardvark']),
['xanadu', 'xyz', 'aardvark', 'apple', 'mix'])
print
print('sort_last')
test(sort_last([(1, 3), (3, 2), (2, 1)]),
[(2, 1), (3, 2), (1, 3)])
test(sort_last([(2, 3), (1, 2), (3, 1)]),
[(3, 1), (1, 2), (2, 3)])
test(sort_last([(1, 7), (1, 3), (3, 4, 5), (2, 2)]),
[(2, 2), (1, 3), (3, 4, 5), (1, 7)])
if __name__ == '__main__':
main()
字典
字典的创建
只需要一对大括号( { } )即可
字典的类型
- 字典是可改变的数据类型
- 字典由 “键值对” 组成,一个键映射一个值
- 其中键的值必须是不可变的数据类型
字典的访问
通过get函数,键的值来访问值,不能通过下标
- a={'m':'1234','q':'5322'}
- a.get('m')
- '1234'
字典的性质
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住
- 键必须不可变,所以可以用数字,字符串或元组充当,所以用列表就不行
字典的函数
函数 | 操做 |
cmp(dict1,dict2) | 比较两个字典 |
len(dict) | 返回字典中键值对的个数 |
str(dict) | 输出字典可打印的字符串表示 |
dict.clear() | 清除字典 |
dict.copy() | 返回一个字典的浅复制 |
dict.fromkeys(key[,val]) | 创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值 |
dict.get(key) | 返回指定键的值 |
dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
dict.has_key(key) | 判断字典中是否有该键 |
dict.keys() | 返回字典中所有的键 |
dict.update(dict2) | 将dict2中的数据更新到dict中 |
dict.values() | 返回字典中的所有值 |
dict.pop(key) | 删除字典给定键 key 所对应的键值对 |
dict.popitem | 返回并删除字典中的最后一对键和值 |