astr在python_python对象（间）运算

这里的对象，指的是像字符串、列表、元祖这样的序列对象和像字典的类序列。

切片

就像下标可以从字符串、列表和元祖中取得单个值一样，“切片”可以从字符串或列表、元祖中取得多个值。切片输入在一对方括号中，像下标一样，但它有两个冒号分隔的整数，用一个下标和另一个下标指定一个范围，开始下标将被包含，结束下标则不包含。切片并没有修改原来的字符串。可以从一个变量中获取切片，记录在另一个变量中。

作为快捷方法，你可以省略切片中冒号两边的一个下标或两个下标。省略第一个下标相当于使用0，或列表的开始。省略第二个下标相当于使用列表的长度，意味着分片直至列表的末尾。记住切片是正向增长的。

如果两个下标相等，则返回结果为空，如

>>> astr="1234"

>>> astr[0:0]

''

>>> astr[1:1]

''

>>>

>>> alist=[1,2,3]

>>> alist[0:0]

[]

下标可以为负值，表示从倒数第几个开始向后

>>> astr="12avd"

>>> astr[-2:]

'vd'

>>> alist[-3:-1]

[2, 3]

>>> alist[-3:]

[2, 3, 4]

>>>

多重赋值

多重赋值(或称解压赋值)技巧是一种快捷方式，让你在一行代码中，作用于任何可迭代对象上面，而不仅仅是列表或者元组。包括字符串，文件对象，迭代器和生成器的值为多个变量赋值。但变量的数目和列表或元祖的长度必须严格相等，否则Python将给出ValueError。

>>> a,b,c=['12',23,12]

>>> b

23

>>>

如果只想需要某一部分变量值，丢弃其他值，可以使用任意变量名去占位，到时候丢掉这些变量就行了，如

>>> astr,bstr,_,cstr="qwer"

>>> bstr

'w'

>>> cstr

'r'

>>>

我们也可以明显的写出变量个数小于一个可迭代对象的元素个数的赋值操作，但这需要借助星号表达式。格式

val1,val2,*val3,val4..,valn=可迭代对象

上面val1和val2接收可迭代对象前两个值，val3接收除去val4到valn值以外的所有值，以列表的形式存储。如

>>> record = ('Dave', 'dave@example.com','773-555-1212','123',24)

>>> name,*relation,age=record

>>> relation

['dave@example.com', '773-555-1212', '123']

>>>

运算符+\-\*\in

加法运算符以两个对象为操作数，可用于字符串、列表上。将其连在一起，即将第一个操作对象的末尾连接到第二个操作对象的开头，这两个操作对象的类型需要相同(即不能是字符串+列表)。这是一个运算符重载的使用，同一个运算符在面对两种不同操作数类型时进行两种不同的操作。当python解释器遇到+运算符时，首先对操作数的类型进行检查，如果都是数字，解释器将执行加法运算；如果都是字符串，解释器执行连接操作；如果操作数是数字和字符的混合，则解释器将提示出错。

Python不像JS或者PHP这种弱类型语言里在字符串连接时会自动转换类型，而是直接报错。如把连接一个int和一个string，直接报错：TypeError: cannot concatenate 'str' and 'int'

objects。解决这个方法只有提前把num转换为字符串类型，可以使用bytes函数或str函数把int型转换为string型。

减法运算符用在集合类型间，用于删除被减集合中出现的减数集合元素。

乘法运算符用于字符串、列表上，需要的操作数时1个整数和一个对象，表示将对象复制多少次。

in 运算符用来检测成员，查询第一个操作数是否在第二个操作数中，如果在返回值为真。其反向用法是not in。用于字符串、列表、元祖和字典上。

>>> [1,2,3,'af']+[2,'f',5]

[1, 2, 3, 'af', 2, 'f', 5]

>>>

>>> {1,2,3,4,5,6}-{3,4}             #集合减法

{1, 2, 5, 6}

>>>

>>> [1,2]*5

[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

>>>

>>> 1 in [1,2]

True

>>>

#in用于字典，检查某个键或值是否存在于字典中

>>> spam = {'name': 'Zophie', 'age': 7}

>>> 'name' in spam.keys()             #等价于'name' in spam

True

>>> 7 in spam.values()

True

>>>

函数和方法len\max\min\sum\reverse\index\sort

方法和函数是一回事，只是它是调用在一个值上。

len()函数用于字符串，返回字符串中的字符数。用于列表，返回列表中的元素个数，如果列表中某个元素是一个列表，这个列表元素仍是一个元素。用于元祖返回元祖中的元素个数，如果元祖中某个元素是一个元祖，这个元祖元素仍是一个元素。用于字典，返回字典中items个数。长度和其本身的编码有关

>>> len("本")

1

>>> "本".encode("utf-8")

b'\xe6\x9c\xac'

>>>

>>> len("本".encode("utf-8"))

3

min()函数返回字符串或列表中最小的元素，如果列表的元素是列表或元祖，只考虑该元素列表或元祖中第一个元素。max()与之类似。

sum()函数只能用于列表，列表中所有元素必须为数字。

reverse()方法将列表中的元素反向排列，python3中字符串没有此方法

sort()方法将数值的列表或字符串的列表默认从小到大，也可以指定reverse关键字参数为True，让sort()按逆序排序。列表的元素可以为元祖，先看元祖第一个元素，如果相同，再看第二个元素，依次类推。

index()方法返回字符串或列表中传入参数对应的下标，如果没有报ValueError

>>> astr="abegz"

>>> min(astr)

'a'

>>>

>>> alist=[1,4,6,7]

>>> sum(alist)

18

>>>

>>> alist.reverse()

>>> alist

[7, 6, 4, 1]

>>>

>>>alist=[(3,'ss'),(31,'dd')]

>>>alist.sort(reverse=True)

>>>alist

[(31, 'dd'), (3, 'ss')]

reverse()方法和sort()方法当场对列表进行反转和排序。不要写出spam = spam.sort()/reverse()这样的代码，试图记录返回值，因为其返回值为None。

[if !supportLists]Ø  [endif]字符串转字典

将字符串转为字典格式，需要字符串为json格式的字符串，然后通过eval()函数转换成dict格式。

dict_json={'imei':'imei',

'from':'W',

'params':'{"userName":"18810756676","password":"e10adc3949ba59abbe56e057f20f883e","ip":"","tagCode":"INVEST"}'

}

sub=dict_json['params']

printtype(sub)         #

printtype(eval(sub))           #

[if !supportLists]Ø  [endif]字典转字符串

直接使用str()函数转化

[if !supportLists]Ø [endif]元祖转字典

单个元祖不可以转为字典，但元祖序列可以转为字典，即至少需要两个元祖才可以转化为字典

>>>alist=[('a',1),('b',2)]

>>>dict(alist)

{'a': 1,'b': 2}

[if !supportLists]Ø  [endif]字典转列表

利用keys()、values()和items() 方法的返回值传递给 list函数。

printlist(dict_json)     # ['imei', 'params', 'from']

print list(dict_json.values())   # ['imei', 'W','{"userName":"18810756676","password":"e10adc3949ba59abbe56e057f20f883e","ip":"","tagCode":"INVEST"}']

列表转字符串

先将列表中每个元素转换为字符串类型，再连接在一起

l=[12,’w’,’r’,’ ’]

''.join([str(i) for i in l])

字符串转列表

字符串经过split()指定分割符操作后，就返回列表形式。若字符串没有明显分隔符，则直接使用list(string)函数即可将字符串分割为单个字符组成的列表。

>>> list("abdd34")

['a', 'b', 'd', 'd', '3', '4']

>>>

字符转整型

通过ord函数可以将assii码对应范围以内的字符转换为assii码。通过chr函数可以返回一个字符，参数必须是0~255的整形数值。

>>> chr(97)

'a'

>>> ord('a')

97

>>>

[if !supportLists]Ø [endif]列表和元组互转

函数list()和tuple()将返回传递给它们的值的列表和元组版本。

>>> alist=[1,2,'a']

>>> tuple(alist)

(1, 2, 'a')

>>>

列表不可以转为字典

[if !supportLists]Ø [endif]函数dict()、list()都可以接收一个可迭代对象，将其转化为对应的字典或列表。

集合转列表

直接使用list()函数即可

>>> aset={1,'12','q',100}

>>> list(aset)

[100, 1, '12', 'q']

>>>

列表转集合

使用set()函数，但会造成重复元素的去重，还会造成顺序的打乱

>>> alist=[1,2,'a','cc','a',1,3,4,'cc']

>>> set(alist)

{1, 2, 3, 'a', 4, 'cc'}

>>>

[if !supportLists]Ø  [endif]字符串转集合

使用set()函数，但会造成重复元素的去重，还会造成顺序的打乱

>>> astr="12abcdb"

>>> set(astr)

{'c', 'a', 'b', '1', 'd', '2'}

>>>

排序

使用内置的sorted函数可以实现列表、字符串、字典、元祖的排序。

>>> help(sorted)

Help on built-in function sorted in module builtins:

sorted(iterable, /, *, key=None, reverse=False)

Return a new list containingall items from the iterable in ascending order.

A custom key function can besupplied to customize the sort order, and the

reverse flag can be set torequest the result in descending order.

>>>

sorted默认按ASSCII码进行排序(从2.4开始)，返回副本，原始输入不变。key参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较(或传入一个callable对象给它，这个callable对象对每个传入的对象返回一个值，这个值会被sorted用来排序这些对象)。这个技术是快速的因为key指定的函数将准确地对每个元素调用。

[if !supportLists]Ø [endif]对列表的排序

可以对列表实施按元素首字母assii码、元素大小、元素长度进行排序

[if !supportLists]•     [endif]按照列表元素的长度排序

>>> alist=['abc','12344','Aeeds','qddssss']

>>> sorted(alist,key=lambda s:len(s))

['abc', '12344', 'Aeeds', 'qddssss']

>>>

上述代码与下面是等价的

>>> def f(x):

...     return len(x)

...

>>> sorted(alist,key=f)

['abc', '12344', 'Aeeds', 'qddssss']

>>>

[if !supportLists]•     [endif]按元素大小排序

>>> students = [('john','A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>> sorted(students,

key=lambda s: s[2]) # 按年龄排序

[('dave', 'B', 10), ('jane', 'B',12), ('john', 'A', 15)]

可以看出，可以指定元素的子元素作为排序参照。

[if !supportLists]Ø [endif]对字典的排序

默认sorted是对dict的key排序的，并返回key组成的列表。如果要根据dict的value排序就需要指定sorted函数的key参数了。

>>> my_dict ={"a":2, "c":5, "b":1}

>>>

>>> sorted(my_dict)

['a', 'b', 'c']

>>>sorted(my_dict.items(),key=lambda x:x[1])#先转换为dict_items对象，取第2个元素做比较

[('b',1), ('a', 2), ('c', 5)]

>>>

排序后的返回值是一个list，而原字典中的名值对被转换为了list中的元组。

items()方法将字典的元素 转化为了dict_items对象，而这里key参数对应的lambda表达式的意思则是选取元组中的第二个元素作为比较参数。之所以要转化为dict_items对象，这样就可以使用下标取值进行比较了，否则没有办法得到排序参考的元素。如果是字典列表，则可以不用转化，如

>>>rows = [

...{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},

...{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},

... {'fname': 'John', 'lname':'Cleese', 'uid': 1001},

... {'fname': 'Big', 'lname':'Jones', 'uid': 1004}

... ]

>>> sorted(rows,key=lambda r: (r['lname'],r['fname']))

[{'fname': 'David', 'lname':'Beazley', 'uid': 1002}, {'fname': 'John', 'lname': 'Cleese', 'uid': 1001},{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}, {'fname': 'Brian', 'lname':'Jones', 'uid': 1003}]

>>>

对字典排序时，各元素键或值的类型需要一致，否则报typeerror错误。

也可以使用zip函数，zip()函数创建的是一个只能访问一次的迭代器。通过将字典”反转”为(值，键)元组序列来解决了上述问题。当比较两个元组的时候，值会先进行比较，然后才是键。这样的话你就能通过一条简单的语句就能很轻松的实现在字典上的求最值和排序操作了。

>>> prices = {

... 'ACME': 45.23,

... 'AAPL': 612.78,

... 'IBM': 205.55,

... 'HPQ': 37.20,

... 'FB': 10.75

... }

>>> max_price =max(zip(prices.values(), prices.keys()))

>>>

>>> max_price

(612.78, 'AAPL')

>>> prices_sorted =sorted(zip(prices.values(), prices.keys()))

>>> prices_sorted

[(10.75, 'FB'), (37.2, 'HPQ'),(45.23, 'ACME'), (205.55, 'IBM'), (612.78, 'AAPL')]

>>>

因此，对于排序类型相同的对象，但是他们不支持原生的比较操作情况下，都可以使用上述给sorted()函数关键字参数key传一个可调用对象的方法。