python的重点和难点_python小知识点

1、c, d = [int(i) for i in a[:2]]

2、d = [int(i) for i in a[:2]]

>>> a = [3, 4]

>>> c, d = [int(i) for i in a[:2]]

>>> print(c, d)

3 4

>>> d = [int(i) for i in a[:2]]

>>> print(d)

[3, 4]

3、dict(enumerate(set)) 会自动生成索引

4、dict(zip(e.values(), e.keys()))

>>> a = {'a', 'b', 'd', 'c'}

>>> h = enumerate(a)

>>> for i in h:

>>> print(i)

(0, 'c')

(1, 'a')

(2, 'b')

(3, 'd')

>>> e = dict(enumerate(a))

{0: 'c', 1: 'a', 2: 'b', 3: 'd'}

>>> vocab_to_idx = dict(zip(e.values(), e.keys()))

>>> print(vocab_to_idx)

{'c': 0, 'a': 1, 'b': 2, 'd': 3}

zip( )：zip([iterable, ...]) :一个或多个迭代器zipped = zip(a,b)# 打包为元组的列表

zip(*zipped)# 与 zip 相反，可理解为解压，返回二维矩阵式

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

>>> b = [4,5,6]

>>> c = [4,5,6,7,8]

>>> zipped = zip(a,b)# 打包为元组的列表

[(1, 4), (2, 5), (3, 6)]

>>> zip(a,c)# 元素个数与最短的列表一致

[(1, 4), (2, 5), (3, 6)]

>>> zip(*zipped)# 与 zip 相反，可理解为解压，返回二维矩阵式

[(1, 2, 3), (4, 5, 6)]

l = ['a', 'b', 'c', 'd', 'e','f']

print zip(l[:-1],l[1:])

[('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e'), ('e', 'f')]

5、 np.arange生成随机序列

shuffle_indices = np.random.permutation(np.arange(len(y)))

6、

iterations = int(np.ceil(data_size/batch_size))

7、dict.items()返回的是一个完整的列表，元素是元组［(key,value),(key,value),...］

count_pairs = sorted(dict.items(), key=lambda x:-x[1])

8、os.path.join( )

open(os.path.join(self._data_dir,"char_to_id.json"),"r")

9、np.random.shuffle(index)：打乱数据集

np.random.shuffle(indexes)

10、

batch_data = sentences[_pos:_pos + batch_size]

实现去重和计数，比set更完美现在有一个单词的序列，快速获取哪些单词出现频率最高：

from collections import Counter

words = ['look', 'into', 'my', 'eyes', 'look', 'into',

'my', 'eyes', 'the', 'eye', 'the', 'eyes', 'not',

'around', 'the', 'eyes', "don't", 'look', 'around',

'the', 'eyes', 'look', 'into', 'my', 'eyes', "you're",

'under']

word_counts = Counter(words) # Counter对象是一个元素和其数目对应关系所构成的字典

print(word_counts.most_common(3)) # 倒序排列的前三个

[('eyes', 6), ('look', 4), ('the', 4)]

12、pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。list.pop(obj=list[-1]) : obj是可选对象，默认是-1

aList = [123, 'xyz', 'zara', 'abc']

print "A List : ", aList.pop()

print "B List : ", aList.pop(2)

A List : abc

B List : zara

13、排除为空的元素

for sentence in [line.strip() for line in data if line.strip()]:

sentences.append(list(sentence.split()))

14、

x = []

for line in new_lines:

tmp = [words_idx[word] if word in words_idx else 0 for word in line]

x.append(tmp)

del tmp

15、tf.reduce_sum

16、赋值、浅copy、深copy

总结：1. 赋值是将一个对象的地址赋值给一个变量，让变量指向该地址（旧瓶装旧酒）。

2. 浅拷贝是在另一块地址中创建一个新的变量或容器，但是容器内的元素的地址均是源对象的元素的地址的拷贝。也就是说新的容器中指向了旧的元素（新瓶装旧酒）。

3. 深拷贝是在另一块地址中创建一个新的变量或容器，同时容器内的元素的地址也是新开辟的，仅仅是值相同而已，是完全的副本。也就是说（新瓶装新酒）。赋值：是系统先给一个变量或者对象(这里是'hello')分配了内存，然后再将地址赋给a, b, c。所以它们的地址是相同的。

字符串str类型：

>>> a = 'hello'

>>> b = 'hello'

>>> c = a

>>> [id(x) for x in a,b,c]

[4404120000, 4404120000, 4404120000]因为str是不可变的，所以同样是'hello'只有一个地址;

>>> a = 'world'

>>> [id(x) for x in a,b,c]

[4404120432, 4404120000, 4404120000]

>>> print a, b, c

world hello hello这时a的地址和值变了，但是b, c地址和值都未变。因为str的不可变性，a要重新赋值则需重新开辟内存空间，所以a的值改变，a指向的地址改变。b, c由于'hello'的不变性，不会发生改变。

列表：

但是list是可变的，所以就算两个变量刚开始赋值时是同样的值，也必须分配两个地址。

由于list的可变性，所以修改list的值不需要另外开辟空间，只需修改原地址的值。

>>> a = ['hello']

>>> b = ['hello']

>>> c = a

>>> [id(x) for x in a,b,c]

[4403975952, 4404095096, 4403975952]但是list是可变的，所以必须分配两个地址。

>>> a[0] = 'world'

>>> [id(x) for x in a,b,c]

[4403975952, 4404095096, 4403975952]

>>> print a, b, c

['world'] ['hello'] ['world']这时a, c的值和地址均改变，但二者仍相同，b不改变。由于list的可变性，所以修改list的值不需要另外开辟空间，只需修改原地址的值。所以a, c均改变。

2. 浅copy

浅拷贝的特点，只是将容器内的元素的地址复制了一份。

1 >>> a = ['hello', [123, 234]]

2 >>> b = a[:]

3 >>> [id(x) for x in a,b]

4 [4496003656, 4496066752]

5 >>> [id(x) for x in a]

6 [4496091584, 4495947536]

7 >>> [id(x) for x in b]

8 [4496091584, 4495947536]a, b地址不同，这符合list是可变的，应开辟不同空间。

a, b中元素的地址是相同的。如果说字符串'hello'地址一致还能理解，但是第二个元素是list地址仍一致。这就说明了浅拷贝的特点，只是将容器内的元素的地址复制了一份。

1 >>> a[0] = 'world'

2 >>> a[1].append(345)

3 >>> print 'a = ', a, '\n\r', 'b = ', b

4 a = ['world', [123, 234, 345]]

5 b = ['hello', [123, 234, 345]]a中第一个元素str改变，但是b中未改变；a中第二个元素改变，b中也改变。这就符合不可变的对象修改会开辟新的空间，可变的对象修改不会开辟新空间。也进一步证明了浅拷贝仅仅是复制了容器中元素的地址。

3. 深copy

完全copy了一个副本

1 >>> from copy import deepcopy

2 >>> a = ['hello', [123, 234]]

3 >>> b = deepcopy(a)

4 >>> [id(x) for x in a, b]

5 [4496066824, 4496066680]

6 >>> [id(x) for x in a]

7 [4496091584, 4496067040]

8 >>> [id(x) for x in b]

9 [4496091584, 4496371792]深拷贝后，可以发现a, b地址以及a, b中元素地址均不同。这才是完全拷贝了一个副本。

1 >>> a[0] = 'world'

2 >>> a[1].append(345)

3 >>> print 'a = ', a, '\n\r', 'b = ', b

4 a = ['world', [123, 234, 345]]

5 b = ['hello', [123, 234]]仅仅a修改了，b没有任何修改。因为b是一个完全的副本，元素地址均与a不同，a修改，b不受影响。

17. 排序

Python list内置sort()方法用来排序，也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列

使用sort()方法对list排序会修改list本身,不会返回新list，通常此方法不如sorted()方便，但是如果你不需要保留原来的list，此方法将更有效sort()。

sort()不能对dict字典进行排序

1、sorted：对字典排序，是按照值的大小排序

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

result = sorted(my_dict)

print result

2、可指定key来排序

student_tuples = [

('john', 'A', 15),

('jane', 'B', 12),

('dave', 'B', 10),

]

result = sorted(student_tuples, key=lambda student: student[2])

print result

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

18. 格式化字符串

Python中内置的%操作符可用于格式化字符串操作，控制字符串的呈现格式。

a = "I'm %s. I'm %d year old" % ('Vamei', 99)

print(a)

我们还可以用词典来传递真实值。如下：

print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99})

19. dic.get() 方法和 dic[key] 方法的不同

dic = {'1':1, '2':2}

print(dic[0]) # 会报错

print(dic.get(0))

Noneget() 方法在遇到错误的时候没有给我们任何反馈，也许你觉得这样不好，其实原因是我们省略了一个参数，我们可以增加第二个参数指定 get() 方法在遇到错误的时候返回一些信息.

>>> dic.get(0,'抱歉你请求的 key 不存在')

>'抱歉你请求的 key 不存在'

print(dic.get(0, '不存在'))

不存在

20. 关键字参数关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

1 #!/usr/bin/env python

2 # -*- coding: utf-8 -*-

3 # 关键字参数:**kw

4 def person(name,age,**kw):

5 print('name:',name,'age:',age,'other:',kw)

6 person('Frank','37')

7 person('Frank','37',city='Shanghai')

8 person('Frank','37',gender='M',job='Engineer')name: Frank age: 37 other: {}

name: Frank age: 37 other: {'city': 'Shanghai'}

name: Frank age: 37 other: {'gender': 'M', 'job': 'Engineer'}

把dic作为关键字参数传入：

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Jack', 24, **extra)name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

21. 命名关键字参数