Python（5-6-7）：数字+字符串+列表+元组+字典+集合

Python的数据类型

1. 数字
2. 序列
3. 字符串
4. 列表
5. 元组
6. 字典
7. 集合

数字

常用的内建函数

import math
import random

print 1/2   # 结果取整数部分      0
print 1.0/2                     0.5
print 1//2  # 舍去小数部分        0
print 3//2                      1
print 3**2      # 次方运算        9
print pow(3,2)  # 次方运算        9
print 4<<1                       8
print 4>>2                       1
print ~4                        -5
print coerce(1.0,2)                          (1.0, 2.0)
print divmod(10,3) # 得到商和余数                 (3,1)
print round(3.4) # 四舍五入                       3.0
print round(4.5) # 四舍五入                       4.0
print round(5) # 四舍五入                         5.0
print int(6.6) # 直接去掉小数                      6
print math.floor(7.7) # 小于原数整数               7.0
print bool(1)                                    True
print bool([])                                   False
print random.randint(1,8) #两个数之间的任意一整数    5
print random.randrange(9,20) # 任意一个整数        13
print random.choice("abcdef") # 取出任意一个字符    c

print hex(4345)#16进制        0x10f9
print oct(52625234)#8进制     0310577522
print chr(65)                A
print ord('a')               97

---

序列

成员关系操作
连接操作
重复操作
切片操作
用步长索引来进行扩展的切片操作

se='fadsf'
st=['a','c','b']
tu=('c','a','z','d')

print sorted(se),sorted(st),sorted(tu)
['a', 'd', 'f', 'f', 's'] ['a', 'b', 'c'] ['a', 'c', 'd', 'z']

print reversed(se),reversed(st),reversed(tu)
<reversed object at 0x0000000002BA6358> <listreverseiterator object at 0x0000000002BA6358> <reversed object at 0x0000000002BA6358>

print len(se),len(st),len(tu)         5 3 4
print zip('123','abc')
[('1', 'a'), ('2', 'b'), ('3', 'c')]

序列类型可用的内建函数

enumerate #输入输出都是迭代对象，输出是元素索引和值的元组
len
max
min
reversed
sorted
sum
zip       #返回一个列表

---

字符串

操作符

第一种：标准操作符

str1 = 'abcd'
str2 = 'lmno'
str3 = 'wxyz'

print str1 < str2        True

第二种：切片操作符

str1 = 'abcd'
str2 = 'lmno'
str3 = 'wxyz'

print str1[-1]           d
print str1[0]            a
print str1[-4]           a
print str1[0:]           abcd
print str1[1:3]          bc
print str1[-3:-1]        bc
print str1[:-1]          abc
print str1[-3:]          bcd

第三种：成员操作符

str1 = 'abcd'
str2 = 'lmno'
str3 = 'wxyz'

print 'ac' in str1          False
print 'ab' in str1          True
print 'mn' not in str1      True

第四种：连接操作符

import string

str1 = 'abcd'
str2 = 'lmno'
str3 = 'wxyz'

print str1 + str2                   abcdlmno
print str1 + ' ' + str2             abcd lmno
print ','.join((str1,str2,str3))    abcd,lmno,wxyz
print ' '.join((str1,str2,str3))    abcd lmno wxyz
print str1*2                        abcdabcd

第五种：普通字符串转化为Unicode

print 'hello' + u' ' + 'hh'
print '*'*40

hello hh
****************************************

第六种：格式化操作符

print '%.2f' %123.438       123.44
print '%f' %214             214.000000
print '%e' %1342.43432      1.342434e+03

内建函数

str1 = 'abcd'
str2 = 'lmno'
str3 = 'wxyz'

print cmp(str1,str2)  -1
print len(str1)       4
print max(str1)       d
print chr(65)         A

s='foo'
for i, j in enumerate(s): 
#enumerate(s)输入输出都是迭代对象，输出是元素索引和值的元组
    print i,j
print enumerate(s)

0 f
1 o
2 o
<enumerate object at 0x10a5394b0>

s,t='abcd', 'wxyz'
print zip(s,t)
#输出是一个列表，列表的成员是由字符串的相同索引位置上元素组成
[('a', 'w'), ('b', 'x'), ('c', 'y'), ('d', 'z')]

特殊字符串

his = '''hi
there'''
her = 'hi\nthere'

print his
hi
there

print her
hi
there

常用的内建函数总结

s1='faFs'
s2='FGHJF'
s3='fhsk ret'

# 字符串的内建方法有很多，大概有30种以上，常用的可见之下：

print s1.capitalize()             Fafs
print s1.center(10)                  faFs   
print s2.count('F')               2
print s3.find('a'),s3.find('k')   -1 3
print s3.index('f'),s3.index('k') 0 3
print s1.islower(),s2.isupper()   False True
print ' '.join(s1)                f a F s
print s2.lower()                  fghjf
print s2.replace('F','1239')      1239GHJ1239
print s3.split()                  ['fhsk', 'ret']
print s1.swapcase()               FAfS
print s1.title()                  Fafs

st = 'fha.fdj.fds'
print st.split('.') #用.对st进行分割
print ":".join(st.split('.'))

['fha', 'fdj', 'fds']
fha:fdj:fds

---

列表

列表的操作种类可以概括：
标准类型操作
切片操作
成员关系操作
连接操作
重复操作
列表解析操作
操作符

s1 = ['abc', 123, -23, 2.33]
s2 = ['dsf', 435]

print s1 < s2             True
print s1[0]               abc
print s1[1:]              [123, -23, 2.33]
print s1[:2]              ['abc', 123]
print s1[0:2]             ['abc', 123]
print s1[-1]              2.33
print s1[0][0]            a
print 'abc' in s1         True
print s1 + s2     ['abc', 123, -23, 2.33, 'dsf', 435]

print s1*2
['abc', 123, -23, 2.33, 'abc', 123, -23, 2.33]

内建函数

s1 = ['abc', 123, 'xyz', -23, 2.33]
s2 = ['dsf', 435]
s3 = [1,2,3]

print cmp(s1, s2)  -1
print len(s1)      5
print max(s1)      xyz
print sorted(s1)   [-23, 2.33, 123, 'abc', 'xyz']
print reversed(s1)
<listreverseiterator object at 0x00000000029563C8>
print zip(s1,s2)   [('abc', 'dsf'), (123, 435)]
print sum(s3)      6
print tuple(s1)    ('abc', 123, 'xyz', -23, 2.33)

常用的内建函数总结

lis=['fa','nd',123,'fa']

print lis.append('mm'),lis
None ['fa', 'nd', 123, 'fa', 'mm']

print lis.count('fa')       2

print lis.extend('faa'),lis
None ['fa', 'nd', 123, 'fa', 'mm', 'f', 'a', 'a']

print lis.index('nd')       1

print lis.insert(1,'fuck'),lis
None ['fa', 'fuck', 'nd', 123, 'fa', 'mm', 'f', 'a', 'a']

print lis.remove('fuck'),lis
None ['fa', 'nd', 123, 'fa', 'mm', 'f', 'a', 'a']

print lis.reverse(),lis
None ['a', 'a', 'f', 'mm', 'fa', 123, 'nd', 'fa']

print lis.sort(),lis   
None [123, 'a', 'a', 'f', 'fa', 'fa', 'mm', 'nd']

列表解析操纵

s=[i*2 for i in range(8) if i%2==0]
print s

[0, 4, 8, 12]

print [i for i in range(4)]
print [i for i in range(0, 4)]

[0, 1, 2, 3]
[0, 1, 2, 3]

---

元组

操作符

t1 = ('abc', 123, 'xyz', -23, [321,'fds'])
t2 = (123,534)
print t1 * 2      ('abc', 123, 'xyz', -23, [321, 'fds'], 'abc', 123, 'xyz', -23, [321, 'fds'])

print t1 + t2           ('abc', 123, 'xyz', -23, [321, 'fds'], 123, 534)
print 'abc' in t1       True
print t1[0][0]          a
print t1[:]     ('abc', 123, 'xyz', -23, [321, 'fds'])
print t1[-1]            [321, 'fds']

内建函数

t1 = ('abc', 123, 'xyz', -23, [321,'fds'])
t2 = (123,534)

print list(t1)      ['abc', 123, 'xyz', -23, [321, 'fds']]
print len(t1)       5
print max(t1)       xyz
print cmp(t1,t2)    1

---

字典

创建字典

d1 = {}
d2 = {'name':'shan','port':80}
d3 = dict((['x',1],['y',2]))
d4 = {}.fromkeys(('x','y'),1) #该函数创建的字典元素具有相同值

print d1       {}
print d2       {'name': 'shan', 'port': 80}
print d3       {'y': 2, 'x': 1}
print d4       {'y': 1, 'x': 1}

访问字典值

d2 = {'name':'shan','port':80}
d3 = dict((['x',1],['y',2]))
d4 = {}.fromkeys(('x','y'),1)
print d2['name']               shan

更新字典

d2 = {'name':'shan','port':80}
d2['name'] = 'zheng'

print d2['name']     zheng
print d2             {'name': 'zheng', 'port': 80}

删除字典元素和字典

d1 = {'name':'an','port':8}
d2 = {'name':'shan','port':80}

d1.clear()
del d2['name']

print d1     {}
print d2     {'port': 80}

操作符和内建函数

d1 = {'name':'an','port':8,'port1':84}
d2 = {'name':'shan','port':80}
d3 = {'xsdf':'shan','ofrt':80}
d4 = {'xsdf':'hans','ofrt':80}
d5 = {'xsdf':'hans','ofrt':80}

print d1.keys()     ['port1', 'name', 'port']
print d1.values()   [84, 'an', 8]
print d2            {'name': 'shan', 'port': 80}
print d1 < d2       False
print len(d1)       3
print cmp(d1,d2)    1
print cmp(d2,d3)    -1
print cmp(d3,d4)    1
print cmp(d4,d5)    0

字典中常用的内建函数

d={}.fromkeys('xy','34')
dd={'a':'1','b':'2'}
d3={'c':3}

print d,dd                    {'y': '34', 'x': '34'} {'a': '1', 'b': '2'}
print dd.get('a')             1
print dd.has_key('b') ,dd.has_key('c')       True False
print dd.items()              [('a', '1'), ('b', '2')]
print dd.keys(),dd.values()   ['a', 'b'] ['1', '2']
print dd.update(d3),dd        None {'a': '1', 'c': 3, 'b': '2'}
print dd.clear(),dd           None {}

---

集合

集合基本操作

s = set('asdfghj')
t = frozenset('fdsdh')
s.add('z')

print s         set(['a', 'd', 'g', 'f', 'h', 'j', 's', 'z'])
print t         frozenset(['h', 's', 'd', 'f'])
print len(s)    8
print len(t)    4
print 's' in s  True
s.remove('z')
print s         set(['a', 'd', 'g', 'f', 'h', 'j', 's'])

集合操作符

s = set('abcd')
t = set('cdef')

print s|t     set(['a', 'c', 'b', 'e', 'd', 'f'])
print s&t     set(['c', 'd'])
print s-t     set(['a', 'b'])
print s^t     set(['a', 'b', 'e', 'f'])

---