基于jupyter notebook的Python学习（三） str，list，tuple，dic，set学习

1. sorted的应用，将Iterable对象按照指定的顺序排序。具体参数可以通过help命令查看。

from collections import Iterable
l1 = ['zara', 'bubble','sort','jeans','jane']
l2 = ['zara', 'bubble','sort',('jeans','jane')]
s = 'zera and jane sort jeans bubble'
t1 = ('sorted', 'bubble', 'jeans', 'zara', 'jane')
t2 = ('sorted', 'bubble', 'jeans', ['zara', 'jane'])
dic = {'name':'jane', 'age': '22', 'name':'zera', 'age':'20'}
print(isinstance(l1, Iterable))
print(isinstance(l2, Iterable))
print(isinstance(dic, Iterable))
print('sorted l1: ',sorted(l1))
print('sorted s: ',sorted(s))
print('sorted t1: ',sorted(t1))
print('sorted dic: ',sorted(dic))
print('l2: ',l2)
print('sorted l1: ',sorted(l2))
result:

True
True
True
sorted l1:  ['bubble', 'jane', 'jeans', 'sort', 'zara']
sorted s:  [' ', ' ', ' ', ' ', ' ', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'd', 'e', 'e', 'e', 'e', 'j', 'j', 'l', 'n', 'n', 'n', 'o', 'r', 'r', 's', 's', 't', 'u', 'z']
sorted t1:  ['bubble', 'jane', 'jeans', 'sorted', 'zara']
sorted dic:  ['age', 'name']
l2:  ['zara', 'bubble', 'sort', ('jeans', 'jane')]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     14 print('sorted dic: ',sorted(dic))
     15 print('l2: ',l2)
---> 16 print('sorted l1: ',sorted(l2))
TypeError: '<' not supported between instances of 'tuple' and 'str'

由上述操作可知：（1），sorted也是按照对象的最小分割单元进行排序的。str中的最小单元是字符，故按照字符比较大小，其他对象的最小单元是以逗号分割的，故把每个最小单元当中一个整体比较大小。其中，字典是按照key来排序的。（2）可迭代的并不一定都能使用sorted进行排序，例如l2和t2，虽然可迭代，但是排序时报错，因为它们中的最小元素是可变的，这也就是（3），只有不可变的对象才能比较大小。

输入以下命令确定l2是可迭代的，并打印出每次迭代的元素。

for x in l2:
    print(x)
result：
zara
bubble
sort
('jeans', 'jane')

2. enumerate(iterable[, start])是将iterable数据转换成数字（从零开始）和迭代对象中的值一一对应起来的操作。

操作格式为  (0, seq[0]), (1, seq[1]), (2, seq[2]), ...

可以与对象的其他操作结合起来：其中n代表格式中的数字，item代表格式中的内容，即seq[n]

t1 = ('jupyter',['note i english', 'book'])
for n,item in enumerate(t1[1][0][3::2]):
    print(n+1,item)

result:
1 e
2 i
3 e
4 g
5 i
6 h

3. zip拼接和解拼接，将2个及以上的字符串按照序列顺序进行拼接或者解拼接。 有一下几点需要注意：

（1）zip拼接可以是不同的对象类型，只要对象可迭代即可；

（2）拼接的对象的长度可以不相同，拼接结果的长度是拼接对象中最短对象的长度；

（3）zip(iterable)命令返回的是一个zip对象，使用zip(*zip对象)命令可以将拼接后的对象解拼接；

（4）解拼接后的每个对象都是元组，不论原来的对象是什么；

（5）解拼接后的对象并不一定等于原对象；

（6）解拼接的赋值参数的个数一定要等于被拼接对象的个数，如例子中如果去掉r3，则执行报错。

s1 = 'without'
l2 = ['do ', 'ahat you like', 'zera']
t1 = ('jupyter',['note english', 'book'], 'work', 'test')
print(list(zip(s1,l2,t1)))
z1 = zip(s1,l2,t1)
r1,r2,r3 = list(zip(*z1))
print(r1)
print(r2)
print(r3)
result:
[('w', 'do ', 'jupyter'), ('i', 'ahat you like', ['note english', 'book']), ('t', 'zera', 'work')]
('w', 'i', 't')
('do ', 'ahat you like', 'zera')
('jupyter', ['note english', 'book'], 'work')

4. any与all都是对象的判空、0、false操作，any判断对象是否为空对象，如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true；all判断对象中的所有元素不为0、''、False或者x为空对象，则返回True，否则返回False。

（1）需要记住的是空格键不等于空，如s2; 

（2）false字符串不等于false关键字, 如s1；

（3）虽然s3对象为空，但是使用all（s3）返回结果却为true，这是因为s3缺是是没有任何对象为0，‘’或者false。

s1 = 'False'
s2 = ' '
s3 = ''
l3 = [1,2, False]
print(all(s1))
print(all(s2))
print(any(s3))
print(all(s3))
print(all(l3))
result:
True
True
False
True
False

5. 关于str类型转换的一点疑惑，为什么reversed返回的对象不能使用str正确转换呢？

l1 = ['guess', 'name']
print(l1)
r1 = reversed(l1)
print(list(r1))
print(str(r1))
result:
['guess', 'name']
['name', 'guess']

6. list中的count和index函数都是以存入内容为单位进行查找的，存入内存为指针时，仅能查到改指针

l1 = ['gogogo','to','you']
l2 = ['china','with','you','to']
l2.insert(0,l1)
print(l2)
print(l2.count('to'))
print(l2.index(l1))
print(l2.index(l1[0]))
result:
[['gogogo', 'to', 'you'], 'china', 'with', 'you', 'to']
1
0
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
      5 print(l2.count('to'))
      6 print(l2.index(l1))
----> 7 print(l2.index(l1[0]))

ValueError: 'gogogo' is not in list

7. dict的常用方法。

d1 = {'name':'python', 'age': 22, 'address':'china' ,'name':'java', 'age': 24}
print(d1)
print(d1.keys())
print(d1.values())
print(d1.items())
print(d1['name'])
print(d1.get('1name','jack'))
print(d1.pop('age'))
print(d1.popitem())
print(d1)
result:
{'name': 'java', 'age': 24, 'address': 'china'}
dict_keys(['name', 'age', 'address'])
dict_values(['java', 24, 'china'])
dict_items([('name', 'java'), ('age', 24), ('address', 'china')])
java
jack
24
('address', 'china')
{'name': 'java'}

help(dict)
 get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.

由以上用例可以总结出：（1）dict类似于集合，相同key的项只有最后一次赋值会生效；（2）dict访问所有元素有3种方式，可以只访问所有key，即冒号前面的元素，也可以只访问所有值value，即冒号后面的元素，还可以访问同时访问所有的键值对，即，所有的元素，他们的返回结果都是一个类集合的结果，无法进行处理。（3）访问某个key的value事可以用dict[key]或者get访问，如果不确定key，可以通过get方式访问，因为当key不在dict中时，使用[]的方式会报错，后面的内容不会执行，而使用get方式时，默认情况下返回的是None,也可以如上面一样指定不存在时的返回结果为‘jack’。

8. 集合的定义和差集

l1 = ['china', 'chinatoo', 'chinese', 'china']
s1 = set(l1)
s2 = {'china', 'chinatoo2', 'chinese', 'china'}
print(s1)
print(s2)
print(s1-s2)
result:
{'china', 'chinese', 'chinatoo'}
{'chinatoo2', 'china', 'chinese'}
{'chinatoo'}

集合可以通过使用set命令定义，也可以通过{}指定定义，当然，最终的定义结果都是集合中没有重复元素的。集合的差集返回的结果是-号前面的集合中有而后面-号前面的集合中没有的元素。a-b和b-a的结果不一定相同。

9. is与==的区别

b=a='welcome'
c = 'welcome'
e = d = ['welcome']
f = ['welcome']
print(id(a))
print(id(b))
print(id(c))
print(id(d))
print(id(e))
print(id(f))
print(a is c)
print(e is f)
print(a == c)
print(e == f)
reslut:
117360432
117360432
117360432
117542280
117542280
117431688
True
False
True
True

is和==都是比较符合，二者的区别在于==比较的是内容是否相同，is不仅比较内容，还比较二者指向的是否是同一个对象。对于不可变对象来说，二者没有区别，因为不可变对象不管如何赋值，只有内容一样，在内存中的位置都是一样的，而可变对象由于可能会被改变，故不同的赋值方式指向的对象可能不同。