序列的基本操作
1. len()：求序列的长度
2. +：连接2个序列
3. *：重复序列元素
4. in/not in：判断元素是否在序列中
5. max()：返回最大值
6. min()：返回最小值
7. sum()：返回求和
8. cmp(x, y)：比较两个序列是否相等返回值大于0 ，等于0，小于0
cmp：按照字符串比较，字符串比较的原则就是一个字符一个字符的比较，字符按照ASCII码来比较，字符1比字符2小，所以gene1001小于gene2

------------------------------------------------------------

数值类型
- 整型 2^32个数字，范围-2,147,483,648到2147483647
- 长整型区分普通整型，需要在整数后加L或l。2345L，0x34al
- 浮点型 0.0，12.0，-18.8，3e+7
- 复数型 - 3.14j，8.32e-36j

-------------------------------------------------------------

字符串''类型

字符串是不可变数据类型
有三种方法定义字符串类型
str = 'this is a string'
str = "this is a string"
str = '''this is a string''' 或 """this is a string"""
三重引号（docstring）除了能定义字符串还可以用作注释
python里面单引号和双引号没有任何区别，而三引号可以转义，单引号和双引号不能转义

\n：换行
str = "this is a \nstring"

字符串前加 u
例：u"我是含有中文字符组成的字符串。"
作用：后面字符串以 Unicode 格式进行编码，一般用在中文字符串前面，防止因为源码储存格式问题，导致再次使用时出现乱码。
python3.x里,默认的str是(py2.x里的)unicode，u前缀没什么具体意义，（py3不用u）

字符串前加 b
例： b'\r\n'
作用：python3.x里默认bytes是(py2.x)的str, b""前缀代表的就是bytes
python2.x里, b前缀没什么具体意义（py2不用b）

Python 3 有两种表示字符序列的类型，分别是bytes 和str。前者的实例包含原始的8位值，后者的实例包含Unicode字符。
Python 2 也有两种表示字符序列的类型，分别叫作str 和Unicode 。与Python 3 不同的是， str 的实例包含原始的8位值（utf8，utf16等等），而Unicode 的实例包含Unicode 字符。
也就是说，在Python 3 中，字符串默认为Unicode 。但如果在Python 2中需要使用Unicode ，则必须在字符串前面显示地加上一个“ u ”前缀

字符串索引
字符串是序列，可以通过索引取每个字符
加号：字符串连接符
str = 'abcde'
str[0] + str[1]
字符串切片
str[start:end:step]
step：为负数表示从右向左，步长为正数，start那个数字的值不要，步长为负数，end那个数字的值不要

>>> str[1:3]
'bc'
>>> str[:3]
'abc'
>>> str[3:]
'de'
>>> str[::1]
'abcde'
>>> str[::2]
'ace'
>>> str[-1]
'e'
>>> str[-4:-1]
'bcd'
>>> str[-2:-4:-1]
'dc'

字符串相关函数
replace()
split()
join()
strip()
format() ：'{0},I\'m {1},my E-mail is {2}'.format('Hello','Hongten','hongtenzone@foxmail.com')
find()
import string
string.digits：返回数字0123456789

大小写相关方法
upper ：将字符串转换为大写
lower ：将字符串转换为小写
isupper ：判断字符串是否都为大写
islower ：判断字符串是否都为小写
swapcase ：将字符串中的大写转换为小写、小写转换为大写
capitalize ：将首字母转换为大写
istitle ：判断字符串是不是一个标题

注意：字符串是不可变的，因此，这里的方法并没有改变原来的字符串，而是产生了一个新的字符串。
如果需要修改字符串，则可以将修改过后的字符串赋值给原来的变量。

判断类方法
s.isalpha ：如果字符串只包含字母，并且非空，则返回True ，否则返回False
s.isalnum ：如果字符串值包含字母和数字，并且非空，则返回True ，否则返回False
s.isspace ：如果字符串值包含空格、制表符、换行符，并且非空，则返回True ，否则返回False
s.isdecimal ：如果字符串只包含数字字符，并且非空，则返回True ，否则返回False
s.isdigit：如果字符串是数字，并且非空，，则返回True ，否则返回False
startwith ：是否为字符串的前缀或后缀
endswith：是否为字符串的前缀或后缀

查找类函数
它们之间的区别可能是查找的方向不同，也可能是以不同的方式处理异常情况
find ：查找子串出现在字符串中的位置，如果查找失败，返回-1，也可以指定查找开始的下标，从第19个字符开始查找s.find('IN',19)，可以用in代替
index ：与find 函数类似，如果查找失败，抛出ValueError 异常
rfind ：与find 函数类似，区别在于rfind 是从后向前查找
rindex ：与index 函数类似，区别在于rindex 是从后向前查找

拼接和分割
join
split

去除空白字符
strip ：给strip 函数传递参数，参数中的所有字符都可以被裁剪
rstrip
lstrip
s ="##Hello, world## "
s.strip("#")
"Hello, world"

替换
replace

---------------------------------------------------------------------------

元组（）类型
元组和列表十分相似
元组和字符串一样是不可变的，不可变的意思是元组里面的元素不能修改，比如a[-1] = xx 会报错
- 元组可以存储一系列的值
- 元组通常用在用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。

创建元组
t= ()
t= (2,) 一定要加逗号才是元组，否则会当普通字符串对待
t = ('james', 'M')
t = ('james', 'M',(1,)) 元组里面包含元组
j = 'sd'
t = (j, 'M') 包含变量

print t
('sd', 'M')

print t[0] 返回第一个元素

元组操作
- 元组和字符串一样属于序列类型，可以通过索引和切片操作
- 元组值不可变
元组的拆分

t = (1,2,3)
a, b, c = t
a
1
b
2
c
3

M=2
t = ('james', M,'gg','cc')
for a in t:
    print a
james
2
gg
cc

b=('a','b','a','d','a')
print(b.count('a')) 统计'a'这个元素一共有多少个

---------------------------------------------------

列表[]类型

列表(list)是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目。
列表是可变类型的数据类型
创建列表
list1 = []
list2 = list() list()函数
list3 = ['a',1,2]
list4 = ['a',1,(1,),['sdf','sww]]

对某项目赋值，下标从0开始
list3[0] = 'b'

列表操作
- 取值
切片和索引

切片
l = list(range(10))
l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l[5:0:-1]  输出：[5, 4, 3, 2, 1]
l[5:4:-1]  输出：[5]
l[:3:-1]   输出：[9, 8, 7, 6, 5, 4]
l[0:3:-1]  输出：[]
l[9::-1]   输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
l[-2:]（ l[-2:10:1]）     输出：[8, 9]
l[2:]（ l[2:10:1]）   输出：[2, 3, 4, 5, 6, 7, 8, 9]
l[:-2]（ l[0:-2:1]）       输出：[0, 1, 2, 3, 4, 5, 6, 7]
l[0]     输出：0

l[列表最小值:列表最大值:步进]
步长为正数情况下输出不包含列表最大值
列表最小值下标从0开始
-1：9
-2：8

- 添加
list.append()
list1[2].append('abc') 如果列表里面又有列表使用下标来访问
添加 list= list +[6] ，list2 =[1,2] list = list + list2
- 删除
del list[x] 删除某个元素 del list 删除整个列表
list.remove(列表里面实际的值)
- 修改
list[] = x
- 查找
var in list
- 插入
list.insert(list[x],object) 在下标前插入一个对象
- 排序
list.sort()
- 反转
list.reverse()
- 弹出
list.pop([index]) 返回一个元素并删除这个元素，参数是下标，没有参数会删除最后一个元素
- 扩展
list.extend(iterable) 可迭代的，相比append()方法可以追加多个值，l.extend(range(10))
- 统计
a = ['s','c','c']
a.count('c') 统计'c'这个元素一共有多少个

https://www.cnblogs.com/meitian/p/4649173.html

Python合并列表，append()、extend()、+、+=
1.append() 向列表尾部追加一个新元素，列表只占一个索引位，在原有列表上增加
2.extend() 向列表尾部追加一个列表，将列表中的每个元素都追加进来，在原有列表上增加
3.+ 直接用+号看上去与用extend()一样的效果，但是实际上是生成了一个新的列表存这两个列表的和，只能用在两个列表相加上
4.+= 效果与extend()一样，向原列表追加一个新元素，在原有列表上增加

---------------------------------------------------------

字典{}类型

字典是python中的唯一的映射类型（哈希表）
字典对象是可变的，但是字典的键必须使用不可变对象，一个字典中可以使用不同类型的键值。
跟redis的set类型一样，字典里的key不能重复，赋值的时候如果发现已有key则替换

访问字典的常用方法：
items() 返回一个元组列表，key和value在一个元组里
iteritems() 返回一个元组列表，类似items()，不过一次只返回一个值
iterkeys() 返回一个key迭代器，用for循环读取这个迭代器
itervalues() 返回一个value迭代器，用for循环读取这个迭代器
keys() 返回一个key的列表
values() 返回一个value的列表

创建字典
dic = {}
dic = dict()

dict()函数
help(dict)

字典创建
第一种
dict((['a',1],['b',2])) #dict()函数方式1
aa=dict((['a',1],['b',2]))
print aa
{'a': 1, 'b': 2}

第二种
dict(a=1, b=2) #dict()函数方式2
bb=dict(a=1, b=2)
print bb
{'a': 1, 'b': 2}

第三种
dd = {'line':1,'char':2,'word':3} 或dd = {1:1,2:2,3:3}
print dd

{'char': 2, 'line': 1, 'word': 3}

第四种
info = {} #创建一个空字典
info['name'] = 'name'
info['age'] = 'age'
info['gender'] = 'gender'
print info
{'gender': 'gender', 'age': 'age', 'name': 'name'}

fromkeys()函数
fromkeys(S[,v]) S指定一个序列，v指定value的值，默认为None。
dic.fromkeys(range(3),100)
In [4]: dic.fromkeys(range(3),100)
Out[4]: {0: 100, 1: 100, 2: 100}
fromkeys函数创建的字典需要赋值到另一个字典才能保存
ddict = {}.fromkeys(('x','y'), 100)

update()函数
将一个字典添加到另一个字典
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }

dict1.update(dict2)
print "dict1 : %s" % dict1

get(key,default)函数
将代入key，返回value
dict1 = {'Name': 'Zara', 'Age': 7}
dict1.get('Age',‘111’) 如果没有age这个key，就返回111
print "dict1 : %s" % dict1 返回7

pop函数/del函数删除字典里某个key值
dict1 = {'Name': 'Zara', 'Age': 7}
dict1.pop('Age')
print dict1
del dict1['Age']
print dict1

zip函数 dict函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表
x = [1, 2, 3]
y = ['a', 'b', 'c']
xyz = zip(x, y,)
print xyz
print dict(xyz)

字典合并，重写，复制

字典合并，重写，复制
一个字典转储到一个新字典，相当于update()函数
dic = {'a': 1, 'b': 2, 'c': 3}
dic2 = {'e': "Python", 'f': 'everyday'}
all_dic = {**dic, **dic2}
all_dic
{'a': 1, 'b': 2, 'c': 3, 'e': 'Python', 'f': 'everyday'}

复制一个字典，同时添加一个新的值
add_dic = {**dic, 'g': 4}
add_dic
{'a': 1, 'b': 2, 'c': 3, 'g': 4}

复制/合并字典，同时重写特定的值
new_dic = {**dic, 'a': 111}
new_dic
{'a': 111, 'b': 2, 'c': 3}

https://mp.weixin.qq.com/s/_ThZ34hGtcOEqTeLgDO7bQ

访问字典
直接使用key访问：key不存在会报错，可以使用has_key()或者in和not in判断。
循环遍历 items() ,iteritems()函数
例：
for i in dic.keys():
for i in dic:
print i 读取的是key
print dic[i] 读取的是value

for i, o in dic.items():
    print i, o

建议使用iteritems函数，items函数会一次性把字典的所有键值全部取出来，而iteritems函数只会一次取出一个

dict1 = {'Name': 'Zara', 'Age': 7}
for i, o in dict1.iteritems():
    print i, o

#!/usr/bin/python

info = {} 创建一个空字典
name = raw_input("Please input name: ")
age = raw_input("Please input age: ")
gender = raw_input('Please input (M/F): ')
info['name'] = name
info['age'] = age
info['gender'] = gender
for k, v in info.items():
print "%s: %s" % (k, v)
print 'main end'

递归删除嵌套字典里某个key

https://*.com/questions/45335445/recursively-replace-dictionary-values-with-matching-key
https://*.com/questions/10179033/how-to-recursively-remove-certain-keys-from-a-multi-dimensionaldepth-not-known

def remove_keys(obj, rubbish):
    if isinstance(obj, dict):
        obj = {
            key: remove_keys(value, rubbish)
            for key, value in obj.iteritems()
            if key not in rubbish}
    return obj

dicttest = {", "msg": "设备设备序列号或验证码错误"}}
aa=remove_keys(dicttest,'msg')
print(aa)

设置嵌套字典某个key的value

dicccc['config']['settings']['getLastErrorDefaults']['wtimeout'] = 2000

 dicccc= {u'ok': 1.0,
             u'config':
                {u'settings':
                     {u'getLastErrorDefaults':{u'wtimeout': 2000, u'w': u'majority'},
                      u'heartbeatIntervalMillis': 2000,
                      u'getLastErrorModes': {},
                      u'replicaSetId': 'xx',
                      u'heartbeatTimeoutSecs': 10,
                      u'chainingAllowed': True,
                      u'catchUpTakeoverDelayMillis': 30000,
                      u'catchUpTimeoutMillis': -1,
                      u'electionTimeoutMillis': 10000
                      },
                      u'version': 2,
                      u'members': [{u'votes': 1, u'tags': {}, u'arbiterOnly': False, u'slaveDelay': 0L, u'priority': 1.0, u'host': u'192.168.15.15:7666', u'buildIndexes': True, u'hidden': False, u'_id': 0}],
                      u'protocolVersion': 1L,
                      u'_id': u'rpl',
                      u'writeConcernMajorityJournalDefault': False
                 },
              u'operationTime': 'xx',
              u'$clusterTime': {
                  u'clusterTime': 'xx',
                  u'signature': {u'keyId': 6623797459808157697L,u'hash': 'xx'}
              }

    }

集合

sets模块
python2.6或以上已经默认导入sets模块，集合内部实现是一个hash表，set集合是通过hash算法实现的无序不重复元素集
set(iterable)类
参数：传入可迭代对象
set中的元素不能重复

集合添加
add：是把要传入的元素做为一个整个添加到集合中，例如：
>>> a = set('boy')
>>> a.add('python')
>>> a
set(['y', 'python', 'b', 'o'])

update：是把要传入的元素拆分，做为个体传入到集合中，例如：
>>> a = set('boy')
>>> a.update('python')
>>> a
set(['b', 'h', 'o', 'n', 'p', 't', 'y'])

集合删除
discard：元素不存在不会抛出异常
remove：元素不存在会抛出异常
set(['y', 'python', 'b', 'o'])
>>> a.remove('python')
>>> a
set(['y', 'b', 'o'])

集合清空
clear()
set(['y', 'python', 'b', 'o'])
>>> a.clear()

集合的运算
-或set.difference(s)：差集
&或set.intersection(s)：交集
|或set.union(s)：并集、合集
!=：不等于
==：等于
in：成员关系
not in：不是成员关系

a=set('abc')
b=set('adcjj')
print a - b
set(['b'])
print a & b
set(['a', 'c'])
print a | b
set(['a', 'c', 'b', 'd', 'j'])
print a in b
False
print a != b
True

isdisjoint：判断没有交集，返回True,否则,返回False

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.isdisjoint(li)

issubset：判断是否是子集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li)

issuperset：判断是否是父集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issuperset(li)

不变集合
Python提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset
>>> a = frozenset("hello")
>>> a
frozenset({'l', 'h', 'e', 'o'})
需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。
如果要一个有frozenset中的所有元素的普通集合，只需把它当作参数传入集合的构造函数中即可：
>>> a = frozenset("hello")
>>> a = set(a)
>>> a.add(12)
>>> a
{'l', 12, 'h', 'e', 'o'}

set和list转换
list转set

m = [']
print set(m) # set(['11', '33', '44', '22'])

set转list

s = set(')
print list(s)

各种数据类型的xx重写，xx表达式，
列表，列表重写，列表表达式
[expr for iter_item in iterable if cond_expr]

    b = ['A','B','C']
    cc = [aa+'p' for aa in b]
    print cc

元组（借用生成器表达式），元组重写，生成器表达式
(expr for iter_item in iterable if cond_expr)

    b = ('A','B','C',)
    cc = (aa+'p' for aa in b)
    for i in  cc:
        print i

b = ('A', 'B', 'C',)
aa = (x for x in b)
print aa
<generator object <genexpr> at 0x00000000028F5E58>

集合set，集合重写，集合表达式
{expr for iter_item in iterable if cond_expr}

    b = set('adcjj')
    cc = {aa+'p' for aa in b}
    print ccset(['ap', 'cp', 'jp', 'dp'])

字典，字典重写，字典表达式
{expr1,expr2 for iter_item in iterable if cond_expr}

码农公寓

Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典 各种数据类型的的xx重写xx表达式

相关文章

Python第三天序列 5种数据类型数值字符串列表元组字典各种数据类型的的xx重写xx表达式