一 字符串:通过下标获取元素
声明变量 str=''
str(x)
(1) 字符串元素
字符索引:[indexId]
>>> var1 = "Hello world"
>>> var2 = "Python Rnnob"
>>> print "var1[0]",var1[0]
var1[0] H
字符串截取成子串:[start,end]
>>> print "var2[1:5]",var2[1:5]
var2[1:5] ytho
[:n]: 获取n(从0开始索引)之前的所有元素
>>> concatStr = var1[:6]+'Runnoob'
>>> print concatStr
[:-1] :上界为1(下标从0开始),下界(-1为字符串长度)开始截取元素
>>> concatStr = var1[:6]+'Runnoob'
>>> print concatStr
>>> print concatStr[:-1]
Hello Runnoo
[1:-1] :上界为第二个元素,下界(字符串长度)
Hello Runnoo
>>> print concatStr[1:-1]
ello Runnoo
转义字符:
转义字符 描述
\(在行尾时) 续行符
\\ 反斜杠符号
\' 单引号
\" 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出
转义:
转义字符串:
>>> print "abcd \" nedfg"
abcd " nedfg
转义单引号
>>> print "abcd \' nedfg"
abcd ' nedfg
纵向制表符(换向)
>>> print "abcd \v nedfg"
abcd
nedfg
转义回车
>>> print "abcd \r nedfg"
nedfg
转义换页
>>> print "abcd \f nedfg"
abcd
nedfg
(2)字符串操作
a:字符串拼接:
>>> var1 = "Hello world"
>>> var2 = "Python Rnnob"
>>> concat = var1+var2
>>> print concat
Hello worldPython Rnnob
b:索引字符串元素 [start:end]
>>> var1 = "Hello world"
c:第一个元素
>>> print var1[1]
e
d:第二个至第五个
>>> print var[1:4]
yth
>>> print var[1:-1]
ython Rnno
e:判断元素是否存在: exist noexist
存在
>>> if "H" in var1:
... print "existence"
... else:
... print "no"
existence
不存在
>>> if("M" not in var1):
... print "no existence"
... else:
... print "existences"
no existence
f: 格式化输出
>>> print "My name is %s and weight is %d" %('zara',23)
My name is zara and weight is 23
(3)字符串格式化输出
python字符串格式化符号:
符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
a.格式化输出: 字符串,整型,浮点数
>>> print "My name is %s ,age is %d,have money %2f",('zara',12,12.00)
My name is %s ,age is %d,have money %2f ('zara', 12, 12.0)
b.多个变量进行格式数据
>>> print "My name is %(name)s ,age is %(age)d,have money %(money).4f" %{'name':'zara','age':12,'money':12.34533434}
My name is zara ,age is 12,have money 12.3453
>>> print "My name is %s ,age is %d,have money %.4f" %('zara',12,12.3343343)
My name is zara ,age is 12,have money 12.3343
c.计算保留两位小数(四舍五入)
四舍五入:
>>> var=round(12343.510034,2)
>>> print var
12343.51
四舍五入:
>>> round(12.3434,2)
12.34
使用Decimal保留两位小数(四舍五入)
>>> from decimal import Decimal
>>> Decimal('5.02609').quantize(Decimal('0.00'))
Decimal('5.03')
科学计数法:
>>> print "原数:%d,科学计数:%e" %(1000000000,1000000000)
原数:1000000000,科学计数:1.000000e+09
>>> print "原数:{:d},科学计数:{:e}".format(1000000000,1000000000)
原数:1000000000,科学计数:1.000000e+09
d:format方式
格式：
[[fill][align][sign][#][0][width][,][.precision][type]
参数：
fill 【可选】空白处填充的字符
align 【可选】对齐方式（需配合width使用）
<，内容左对齐
>，内容右对齐(默认)
＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
，内容居中
sign 【可选】有无符号数字
+，正号加正，负号加负；
-，正号不变，负号加负；
空格 ，正号空格，负号加负；
# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
， 【可选】为数字添加分隔符，如：1,000,000
width 【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type 【可选】格式化类型
传入” 字符串类型 “的参数
s，格式化字符串类型数据
空白，未指定类型，则默认是None，同s
传入“ 整数类型 ”的参数
b，将10进制整数自动转换成2进制表示然后格式化
c，将10进制整数自动转换为其对应的unicode字符
d，十进制整数
o，将10进制整数自动转换成8进制表示然后格式化；
x，将10进制整数自动转换成16进制表示然后格式化（小写x）
X，将10进制整数自动转换成16进制表示然后格式化（大写X）
传入“ 浮点型或小数类型 ”的参数
e， 转换为科学计数法（小写e）表示，然后格式化；
E， 转换为科学计数法（大写E）表示，然后格式化;
f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
g， 自动在e和f中切换
G， 自动在E和F中切换
%，显示百分比（默认显示小数点后6位）
>>> print "原数:{:d},科学计数:{:e}".format(1000000000,1000000000)
原数:1000000000,科学计数:1.000000e+09
二.元组: 与字符串同,都是序列:同列表相似,不同之处在于元组不能修改,列表可以add,append
a.声明 tup= () (元组用()表示)
b.定义声明元组:因为无法修改,一般用来赋值进行迭代计算
>>> tup1=(40,23,34,'34')
>>> tup2=(23,)
>>> tup3=()
>>>
c.截取元组 :
>>> print tup1[1:3]
(23, 34)
d.获取元素
>>> print tup2[0]
23
>>>
>>> tup4=tup1+tup2
>>>
>>> print tup4
(40, 23, 34, '34', 23)
>>>
e:因为无法修改(增加,删除)元组元素,但是可以删除元组本身
>>> print tup4
(40, 23, 34, '34', 23)
>>> del tup4
>>> print tup4
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'tup4' is not defined
f: 元组拼接
>>> tup4=tup1+tup2
>>> print len(tup4)
g:元组长度
5
>>> print tup1+tup2
(40, 23, 34, '34', 23)
>>>
>>> print tup4*2
(40, 23, 34, '34', 23, 40, 23, 34, '34', 23)
>>>
h:判断元素是否存在,不存在
>>> print 40 in tup4
True
>>> 40 in tup4
True
>>> 40 not in tup4
False
i: 重复构造该变量多次
>>> print tup4*3
(40, 23, 34, '34', 23, 40, 23, 34, '34', 23, 40, 23, 34, '34', 23)
>>>
j: 迭代元组
>>> for x in tup4:
... print x
40
23
34
34
23
k:索引元素
>>> tup1=(23,34,20,29,38)
>>> tup2=(1,2,3.00,32,90)
>>> tup4=tup1+tup2
>>> print tup4
(23, 34, 20, 29, 38, 1, 2, 3.0, 32, 90)
>>>
获取下标为2的元素
>>> print tup4[2]
20
获取从右边offset 为2的元素
>>> print tup4[-2]
32
获取下标为1 以及之后的元素
>>> print tup4[1:]
(34, 20, 29, 38, 1, 2, 3.0, 32, 90)
>>>
l:比较两个元素操作
>>> tup11=(23,34)
>>> tup22=(23,34)
如果相等,则为0
>>> print cmp(tup11,tup22)
0
>>> tup22=(23,33)
>>> tup11=(23,314)
如果不等,则为1
>>> print cmp(tup11,tup22)
1
>>>
获取元素的最大值
>>> print max(tup4)
90
获取元素的最小值
>>> print min(tup4)
1
>>>
>>> list=[23,34,343,30]
列表转化为Tuple
>>> print tuple(list)
(23, 34, 343, 30)
三.列表: 元素可重复
a.声明 list=[]
b.获取列表元素
>>> list1 = ['pysics','chemistry',1997,2000]
>>> list2 = [1,2,3,4,5,6,7]
>>>
>>> print('list1[0]',list1[0])
list1[0] pysics
>>>
>>> print('list2[1:5]',list1[1:5])
list2[1:5] ['chemistry', 1997, 2000]
>>>
>>>
>>> print('list1[0]',list1[0])
list1[0] pysics
>>> print('list1[1:5]',list1[1:5])
list1[1:5] ['chemistry', 1997, 2000]
>>>
>>> print('list2[0:5]',list2[0:5])
list2[0:5] [1, 2, 3, 4, 5]
c.修改列表元素
1.增加元素:
>>> list3 = []
>>> list3.append('Google')
>>> list3.append('Runnob')
>>>
>>> print(list3)
['Google', 'Runnob']
2.(根据列表元素下标)删除列表元素
>>> list4 = ['physics','chemistry',1993,2000]
>>> del list4[0]
>>> print(list4)
['chemistry', 1993, 2000]
3.删除列表所有元素
>>> list4 = ['physics','chemistry',1993,2000]
>>> print(list4)
['physics', 'chemistry', 1993, 2000]
>>> del list4
>>> print('After deleting value at index 2: ')
After deleting value at index 2:
删除后无法引用
>>> print(list4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'list4' is not defined
4.API
a.长度
>>> list4 = ['physics','chemistry',1993,2000]
>>> len(list4)
4
b.重复显示
>>> list4*2
['physics', 'chemistry', 1993, 2000, 'physics', 'chemistry', 1993, 2000]
c.判断元素是否存在,不存在 于列表
>>> 2000 in list4
True
>>> 12000 in list4
False
>>>
>>> 12000 not in list4
True
e:迭代
>>> for i in list4:
... print(i)
...
physics
chemistry
1993
2000
f:判断集合内容是否相等
>>> list4 = ['physics','chemistry',1993,2000]
>>> list5 = list4*2
>>>
>>> cmp(list4,list5)
-1
>>> cmp(list4,list4)
0
g: 3.5导入operator,比较两集合内容是否相等
>>> import operator
>>> operator.eq(list4,list5)
False
>>>
>>> operator.eq(list4,list4)
True
>>>
>>> list4.count(1993)
1
>>> list4.count('physics')
1
>>> list5
['physics', 'chemistry', 1993, 2000, 'physics', 'chemistry', 1993, 2000]
索引集合某个元素的下标:
>>> print(list5.index(1993))
2
在特定的下标将新元素插入
>>> list5.insert(2,3)
>>> list5
['physics', 'chemistry', 3, 1993, 2000, 'physics', 'chemistry', 1993, 2000]
删除集合某个元素
>>> list5.remove(3)
h:API操作
>>> list6 = [1,3,3,5,6,7]
在集合后面添加集合
>>> list6.extend([23,3]
... )
>>> list6.extend((233,33))
集合排序-默认升序
>>> list6.sort()
>>> list6
[1, 3, 3, 3, 5, 6, 7, 23, 33, 233]
集合排序--设置降序
>>> list6.sort(reverse=True)
>>> list6
[233, 33, 23, 7, 6, 5, 3, 3, 3, 1]
>>>
按照某个key排序集合元素
>>> def takeSecond(elem):
... return elem[1]
...
>>> random = [(2,3),(3,4),(4,2),(1,3)]
>>>
>>> random.sort(key=takeSecond)
>>> print(random)
[(4, 2), (2, 3), (1, 3), (3, 4)]
>>> random
[(4, 2), (2, 3), (1, 3), (3, 4)]
>>> sortedRandom=random.sort(key=takeSecond)
四.集合:无序不可重复元素
a.集合,元组转换为set
>>> list1
[1, 12, 3, 3, 33, 33]
>>>
>>> tup1 = (2,34,34,34)
>>> tup1
(2, 34, 34, 34)
>>> s={1}
b.转换为集合set
>>> s=set(tup1)
>>> s
{2, 34}
>>> list1
[1, 12, 3, 3, 33, 33]
>>>
>>> list1
[1, 12, 3, 3, 33, 33]
>>> tup1
(2, 34, 34, 34)
>>>
>>> s={1}
>>> s=set(s)
>>> s
{1}
>>> s=set(tup1)
c.元组转换为集合会进行去重:
>>> distinctSet=set(tup1)
>>> distinctSet
{2, 34}
d.定义集合后会进行去重
>>> s1 = {12,3,3,3,'a'}
>>> s1
{3, 12, 'a'}
>>> s1.add(233)
>>> s1
{233, 3, 12, 'a'}
e.更新集合元素 (参数可以是 集合,元组,字典；参数可以有多个,用逗号(,)分隔
>>> s1.update([39,399])
>>> s1
{3, 39, 233, 12, 399, 'a'}
>>> s1.update([39,399],[396,389])
>>> s1
{389, 39, 396, 399, 'a'}
不可更新单个元素
>>> s1.update(39)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>>
>>> s1
{3, 39, 233, 12, 399, 'a'}
#删除元素
>>> s1.discard(39)
>>> s1
{3, 233, 12, 399, 'a'}
删除的元素不存在,不会返回错误
>>> s1.discard('b')
>>> s1
{3, 233, 12, 399, 'a'}
>>>
删除集合中存在的元素,建议用discard(不会报错)
>>> s1.remove(12)
>>> s1
{3, 233, 399, 'a'}
>>>
随机删除集合元素
>>> s1.pop()
3
>>> s1.pop()
233
>>> s1
{399, 'a'}
f.集合操作(并集,交集,非对称差集(以左边为参照) ,对称差集(以双方为参照),右边参数 也可以是列表，元组，字典。
判断某个元素是否存在,不存在集合
>>> 3 in s1
True
>>> 3 not in s1
False
>>>
>>> s2 = {3,34,'b',30}
>>> s1
{3, 12, 'a'}
>>> s2
{34, 3, 'b', 30}
并集
>>> s1.union(s2)
{34, 3, 12, 'b', 30, 'a'}
交集
>>> s1.intersection(s2)
{3}
非对称差集(以左边为参照), 右边参数 也可以是列表，元组，字典。
>>> s1.difference(s2)
{12, 'a'}
对称差集(以左边,右边双边为参照),右边参数 也可以是列表，元组，字典。
>>> s1.symmetric_difference(s2)
{34, 12, 'b', 'a', 30}
>>> s1
{3, 12, 'a'}
>>> s2
{34, 3, 'b', 30}
>>>
>>> s1.difference(s2)
{12, 'a'}
>>> s3={3}
#判断左边是否为右边的子集,右边参数 也可以是列表，元组，字典。
>>> s1.issubset(s3)
False
>>> s3.issubset(s1)
True
>>>
判断左边是否为右边的父集,右边参数 也可以是列表，元组，字典。
>>> s1.issuperset(s3)
True
五.字典:
a.声明 dict={}
b.声明赋值字典
>>> dict = {'Alice':'2341','Beth':'9102','Cecil':'3258'}
>>>
c.获取字典元素
>>> print dict['Alice']
2341
d.修改字典元素
>>> dict['Alice'] = '4568'
>>> print dict['Alice']
4568
>>>
>>> dict
{'Beth': '9102', 'Alice': '4568', 'Cecil': '3258'}
e: 删除字典元素
>>> del dict['Alice']
>>> dict
{'Beth': '9102', 'Cecil': '3258'}
>>>
>>> dict
{'Beth': '9102', 'Cecil': '3258'}
f:清空字典元素
>>> dict.clear()
>>>
>>> dict
{}
g: 删除字典
>>> del dict
>>> dict
<type 'dict'>
>>>
h: 删除后无法获得
>>> del dict
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'dict' is not defined
>>> print dict
<type 'dict'>
i:迭代元素---字典同java,scala中map集合相似,key,value(java通过keyset进行获取),通过key获取value
>>> dict = {'Alice':'2341','Beth':'9102','Cecil':'jerry'}
(1) 迭代获取字典key
>>> for key in dict.keys():
... print 'key',':',key,'-','value',':',dict[key]
...
key : Beth - value : 9102
key : Alice - value : 2341
key : Cecil - value : jerry
(2) 获取字典value
>>> for value in dict.values():
... print 'value',':',value
...
value : 9102
value : 2341
value : jerry
(3)获取字典的key,value ,其实字典是复杂数据结构,内部的key,value是元组
>>> for kv in dict.items():
... print '(key,value)',':',kv
...
(key,value) : ('Beth', '9102')
(key,value) : ('Alice', '2341')
(key,value) : ('Cecil', 'jerry')
(4)获取字典的key,value,可以把元组分开来--->tup(key,value) 然后分开获取key,value
>>> for key,value in dict.items():
... print 'key',':',key,'--','value',':',value
...
key : Beth -- value : 9102
key : Alice -- value : 2341
key : Cecil -- value : jerry
>>>
(4)python 单引号,双引号
单引号:当打印输出,获取集合元素,或其他只有''的时候,无"",可以使用'' :
获取元素--dict['Alice']
>>> print dict['Alice']
2341
打印输出:
>>> print 'abd','dcde'
abd dcde
(5)双引号:当打印输出,或其他有""的时候,必须使用"", 外部"" ,内部用'' "",也可以直接使用""
需要使用''进行输出
>>> dict = {'Alice':'2341','Beth':'9102','Cecil':'jerry'}
>>> print "dict['Alice']",dict['Alice']
dict['Alice'] 2341
直接使用""
>>> print "agd","dfbb"
agd dfbb
(6)比较方法cmp(dict1,dict2) : 比较两字典的内容是否相同,相等为0,不等为1
>>> dict1 = {'Alice':'2341','Beth':'9102','Cecil':'jerry'}
>>>
>>> dict2 = {'North':'256','Jerry':'sharon'}
>>>
>>> cmp(dict1,dict2)
1
>>>
>>> dict3 = {'Alice':'2341','Beth':'9102','Cecil':'jerry'}
>>>
>>> cmp(dict1,dict3)
0
(7)长度,转换为str,list
长度:
>>> len(dict1)
3
>>>
>>> strRes = str(dict1)
转换为str: 字符串完全转换
>>> dict1
{'Beth': '9102', 'Alice': '2341', 'Cecil': 'jerry'}
>>> strRes = str(dict1)
>>> print 'type(strRes)',type(strRes),'--','length',':',len(strRes),'value',':',strRes
type(strRes) <type 'str'> -- length : 51 value : {'Beth': '9102', 'Alice': '2341', 'Cecil': 'jerry'}
转换为list: 转换为list,得到key的集合
>>> dict1
{'Beth': '9102', 'Alice': '2341', 'Cecil': 'jerry'}
>>> list1=list(dict1)
>>> print 'type(list1)',':',type(list1),'length',':',len(list1),'value',':',list1
type(list1) : <type 'list'> length : 3 value : ['Beth', 'Alice', 'Cecil']
(8)字典复制生成新的字典变量,获取字典元素(可以设置在无对应key时,设置默认值)
>>> dict1 = {'Alice':'2341','Beth':'9102','Cecil':'jerry'}
字典复制生成新的字典变量
>>> dict1Copy = dict1.copy()
>>> print dict1Copy
{'Beth': '9102', 'Alice': '2341', 'Cecil': 'jerry'}
>>>
获取字典元素(可以设置在无对应key时,设置默认值)
>>> dict1Copy.get('Jerry','sharon')
'sharon'
>>>
>>> dict1Copy.get('Jerry','')
''
>>> dict1Copy.get('Jerry')
设置字典元素对应的key(可以设置在无对应key时,设置默认值)
>>> dict1Copy.setdefault('Jerry','如果没该key,此行为默认值')
'\xe5\xa6\x82\xe6\x9e\x9c\xe6\xb2\xa1\xe8\xaf\xa5key,\xe6\xad\xa4\xe8\xa1\x8c\xe4\xb8\xba\xe9\xbb\x98\xe8\xae\xa4\xe5\x80\xbc'
>>>
>>> print dict1Copy.get('Jerry')
如果没该key,此行为默认值
判断key是否存在于字典中
>>> dict1Copy.has_key('Jerry')
False
获取字典的所有集合( 每对key,value是元组 (key,value))
>>> dict1Copy.items()
[('Beth', '9102'), ('Alice', '2341'), ('Cecil', 'jerry')]
获取字典的keys
>>> dict1Copy.keys()
['Beth', 'Alice', 'Cecil']
获取字典的values
>>> dict1Copy.values()
['9102', '2341', 'jerry']
>>>
>>>
>>> dict1Copy
{'Jerry': '\xe5\xa6\x82\xe6\x9e\x9c\xe6\xb2\xa1\xe8\xaf\xa5key,\xe6\xad\xa4\xe8\xa1\x8c\xe4\xb8\xba\xe9\xbb\x98\xe8\xae\xa4\xe5\x80\xbc', 'Beth': '9102', 'Alice': '2341', 'Cecil': 'jerry'}
获取字典的keys
>>> dict1Copy.keys()
['Jerry', 'Beth', 'Alice', 'Cecil']
>>> dict1Copy.values()
['\xe5\xa6\x82\xe6\x9e\x9c\xe6\xb2\xa1\xe8\xaf\xa5key,\xe6\xad\xa4\xe8\xa1\x8c\xe4\xb8\xba\xe9\xbb\x98\xe8\xae\xa4\xe5\x80\xbc', '9102', '2341', 'jerry']
>>> dict1Copy.items()
[('Jerry', '\xe5\xa6\x82\xe6\x9e\x9c\xe6\xb2\xa1\xe8\xaf\xa5key,\xe6\xad\xa4\xe8\xa1\x8c\xe4\xb8\xba\xe9\xbb\x98\xe8\xae\xa4\xe5\x80\xbc'), ('Beth', '9102'), ('Alice', '2341'), ('Cecil', 'jerry')]
删除字典某个元素,删除后返回该key对应的value,否则无该key,返回默认值
>>> dict1Copy.pop('Jerry','default')
'\xe5\xa6\x82\xe6\x9e\x9c\xe6\xb2\xa1\xe8\xaf\xa5key,\xe6\xad\xa4\xe8\xa1\x8c\xe4\xb8\xba\xe9\xbb\x98\xe8\xae\xa4\xe5\x80\xbc'
>>>
>>> dict1Copy.pop('Jerry','default')
'default'
>>>
>>> dict1Copy.pop('Jerry','如果该key,不存在,则返回默认值')
'\xe5\xa6\x82\xe6\x9e\x9c\xe8\xaf\xa5key,\xe4\xb8\x8d\xe5\xad\x98\xe5\x9c\xa8,\xe5\x88\x99\xe8\xbf\x94\xe5\x9b\x9e\xe9\xbb\x98\xe8\xae\xa4\xe5\x80\xbc
(9)字典元素操作
>>> dict4 = {'a':[1,2],'b':[3,4,5],'c':[6,7,8,9,10]}
>>>
>>> print dict4['a'][0:2]
[1, 2]
>>>
>>> print dict4['c'][0:len(dict4['c'])]
[6, 7, 8, 9, 10]
>>>