python基础知识

1.list中添加新元素

http://blog.sina.com.cn/s/blog_b2f983a50102yqzu.html

append(a)只能在末尾 添加
insert(i,a)在指定位置添加
extend(a,b)可以一次添加多个元素

2.python3 list、tuple(元组)、str之间的相互转换

list()方法是把字符串str或元组转成数组
tuple()方法是把字符串str或数组转成元组

>>> s = "xxxxx"
>>> list(s)
['x', 'x', 'x', 'x', 'x']
>>> tuple(s)
('x', 'x', 'x', 'x', 'x')
>>> tuple(list(s))
('x', 'x', 'x', 'x', 'x')
>>> list(tuple(s))
['x', 'x', 'x', 'x', 'x']列表和元组转换为字符串则必须依靠join函数
>>> "".join(tuple(s))
'xxxxx'
>>> "".join(list(s))
'xxxxx'
>>> str(tuple(s))
"('x', 'x', 'x', 'x', 'x')"#要是使用sublime text 3插件sublimeREPl，是不会显示外层的双引号的。上面同理。>>>

3.python中无穷大与无穷小表示

float(‘inf’) 表示正无穷
-float(‘inf’) 或 float(’-inf’) 表示负无穷
其中，inf 均可以写成 Inf

4.TypeError: ‘int’ object is not iterable，int在循环里不能直接相加求累积和

把所有int型的数放到列表L里，然后用sum（L）

5.输入

a =input() #a为一个任意字符的字符串，可以任意常

6.Cpickle

https://www.xuebuyuan.com/3243387.html
pickle模块会创建一个python语言专用的二进制格式，你基本上不用考虑任何文件细节，它会帮你干净利落地完成读写独享操作，唯一需要的只是一个合法的文件句柄。
        pickle模块中的两个主要函数是dump()和load()。dump()函数接受一个文件句柄和一个数据对象作为参数，把数据对象以特定的格式保存到给定的文件中。当我们使用load()函数从文件中取出已保存的对象时，pickle知道如何恢复这些对象到它们本来的格式。
        dumps()函数执行和dump() 函数相同的序列化。取代接受流对象并将序列化后的数据保存到磁盘文件，这个函数简单的返回序列化的数据。
        loads()函数执行和load() 函数一样的反序列化。取代接受一个流对象并去文件读取序列化后的数据，它接受包含序列化后的数据的str对象, 直接返回的对象。
        cPickle是pickle得一个更快得C语言编译版本。
        pickle和cPickle相当于java的序列化和反序列化操作。

怎么打开pickle文件

import pickle# f = open('./save/target_params.pkl', 'rb')f=pickle.load(open("./save/target_params.pkl", 'rb'), encoding='iso-8859-1')count = 0    for line in f:count += 1if count <= 50:print(line)else:break

7.map()

map() 函数语法：
map(function, iterable, …)

>>>def square(x) : # 计算平方数 ... return x ** 2 ...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] #

提供了两个列表，对相同位置的列表数据进行相加

>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])[3, 7, 11, 15, 19]

8.lamda

1、应用在函数式编程中
Python提供了很多函数式编程的特性，如：map、reduce、filter、sorted等这些函数都支持函数作为参数，lambda函数就可以应用在函数式编程中。如下：
需求：将列表中的元素按照绝对值大小进行升序排列

list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))

当然，也可以如下：

list1 = [3,5,-4,-1,0,-2,-6]
def get_abs(x):return abs(x)
sorted(list1,key=get_abs)

只不过这种方式的代码看起来不够Pythonic
2、应用在闭包中

def get_y(a,b):return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 结果为2

当然，也可以用常规函数实现闭包，如下：

def get_y(a,b):def func(x):return ax+breturn func
y1 = get_y(1,1)
y1(1) # 结果为2

只不过这种方式显得有点啰嗦。

9.dict

9.1 dict的深拷贝(备份的一直不变)和浅拷贝（备份会变）

<<<d = {"username":"rose", "password":["ddh", "yjy", "gg"]}
<<<g = d.copy()
<<<g1 = deepcopy(d)
<<<d["username"] = "dawson"
<<<print d
{"username":"dawson", "password":["ddh", "yjy", "gg"]}
<<<print g
{"username":"dawson", "password":["ddh", "yjy", "gg"]}
<<<print g1{"username":"rose", "password":["ddh", "yjy", "gg"]}`

9.2 字典特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
实例

#!/usr/bin/python3
dict = {['Name']: 'Runoob', 'Age': 7} print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'Runoob', 'Age': 7}TypeError: unhashable type: 'list'

9.2

字典的键值是"只读"的，所以不能对键和值分别进行初始化，即以下定义是错的：

>>> dic = {}>>> dic.keys = (1,2,3,4,5,6)Traceback (most recent call last):
File "<stdin>", line 1, in <module>AttributeError: 'dict' object attribute 'keys' is read-only
>>> dic.values = ("a","b","c","d","e","f")Traceback (most recent call last):
File "<stdin>", line 1, in <module>AttributeError: 'dict' object attribute 'values' is read-only
>>>

字典是支持无限极嵌套的，如下面代码：
cities={
‘北京’:{
‘朝阳’:[‘国贸’,‘CBD’,‘天阶’,‘我爱我家’,‘链接地产’],
‘海淀’:[‘圆明园’,‘苏州街’,‘中关村’,‘北京大学’],
‘昌平’:[‘沙河’,‘南口’,‘小汤山’,],
‘怀柔’:[‘桃花’,‘梅花’,‘大山’],
‘密云’:[‘密云A’,‘密云B’,‘密云C’]
},
‘河北’:{
‘石家庄’:[‘石家庄A’,‘石家庄B’,‘石家庄C’,‘石家庄D’,‘石家庄E’],
‘张家口’:[‘张家口A’,‘张家口B’,‘张家口C’],
‘承德’:[‘承德A’,‘承德B’,‘承德C’,‘承德D’]
}}

可以使用如下方法进行列出

for i in cities['北京']:
print(i)

将列出如下结果：

朝阳海淀昌平怀柔密云

for i in cities['北京']['海淀']:
print(i)

输出如下结果：

圆明园苏州街中关村北京大学

9.3 s.update( “字符串” ) 与 s.update( {“字符串”} ) 含义不同:

s.update( {“字符串”} ) 将字符串添加到集合中，有重复的会忽略。
s.update( “字符串” ) 将字符串拆分单个字符后，然后再一个个添加到集合中，有重复的会忽略。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> print(thisset){'Google', 'Runoob', 'Taobao'}
>>> thisset.update({"Facebook"})
>>> print(thisset)
{'Google', 'Runoob', 'Taobao', 'Facebook'}
>>> thisset.update("Yahoo")
>>> print(thisset){'h', 'o', 'Facebook', 'Google', 'Y', 'Runoob', 'Taobao', 'a'}

9.4 集合的 set.pop() 的不同认为

有人认为 set.pop() 是随机删除集合中的一个元素、我在这里说句非也！对于是字典和字符转换的集合是随机删除元素的。当集合是由列表和元组组成时、set.pop() 是从左边删除元素的如下:
列表实例：

set1 = set([9,4,5,2,6,7,1,8])print(set1)print(set1.pop())print(set1)

输出结果:

{1, 2, 4, 5, 6, 7, 8, 9}1{2, 4, 5, 6, 7, 8, 9}

元组实例：

set1 = set((6,3,1,7,2,9,8,0))print(set1)print(set1.pop())print(set1)

输出结果:

{0, 1, 2, 3, 6, 7, 8, 9}0{1, 2, 3, 6, 7, 8, 9}

10.集合

10.1 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,…}或者set(value)
实例

#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉

成员测试

if 'Rose' in student :print('Rose 在集合中')
else :print('Rose 不在集合中')

set可以进行集合运算

a = set('abracadabra')
b = set('alacazam')
print(a) print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素

以上实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}

10.2 集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

11.Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
实例#!/usr/bin/python3

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值

以上实例输出结果：
1 - 菜鸟教程
2 - 菜鸟工具

{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：
实例>>>dict([(‘Runoob’, 1), (‘Google’, 2), (‘Taobao’, 3)]) {‘Taobao’: 3, ‘Runoob’: 1, ‘Google’: 2} >>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36} >>> dict(Runoob=1, Google=2, Taobao=3) {‘Taobao’: 3, ‘Runoob’: 1, ‘Google’: 2}

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

12.位运算符

[外链图片转存失败(img-rO0XWn4x-1563622653452)(en-resource://database/3876:1)]

13.Python身份运算符

身份运算符用于比较两个对象的存储单元

[外链图片转存失败(img-vKGukQNB-1563622653453)(en-resource://database/3878:1)]

实例(Python 3.0+)

#!/usr/bin/python3
a = 20
b = 20
if ( a is b ):print ("1 - a 和 b 有相同的标识")
else:print ("1 - a 和 b 没有相同的标识")
if ( id(a) == id(b) ):print ("2 - a 和 b 有相同的标识")
else:print ("2 - a 和 b 没有相同的标识")

修改变量 b 的值

b = 30
if ( a is b ):print ("3 - a 和 b 有相同的标识")
else:print ("3 - a 和 b 没有相同的标识")
if ( a is not b ):print ("4 - a 和 b 没有相同的标识")
else:print ("4 - a 和 b 有相同的标识")

以上实例输出结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

>>>a = [1, 2, 3]
>>> b = a
>>> b is a True
>>> b == a True
>>> b = a[:]
>>> b is a False
>>> b == a True

14.Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：
[外链图片转存失败(img-97PEjbZG-1563622653453)(en-resource://database/3880:1)]

15.数字Number

“4舍6入5看齐,奇进偶不进”我觉得并不是因为浮点数在计算机表示的问题。计算机浮点数的表示是 ieee 定义的标准规则，如果 python 中存在，没道理其他语言中不存在。事实上是因为该取舍方法比过去的 “四舍五入” 方法在科学计算中更准确。而国家标准也已经规定使用 “4舍6入5看齐,奇进偶不进” 取代"四舍五入".
从统计学的角度上来讲,如果大量数据无脑的采用四舍五入会造成统计结果偏大。而"奇进偶舍"可以将舍入误差降到最低。
奇进偶舍是一种比较精确比较科学的计数保留法，是一种数字修约规则。
其具体要求如下（以保留两位小数为例）：
（1）要求保留位数的后一位如果是4或者4以下的数字，则舍去，例如 5.214保留两位小数为5.21。
（2）如果保留位数的后一位如果是6或者6以上的数字，则进上去，例如5.216保留两位小数为5.22。
（3）如果保留位数是保留整数部分或保留一位小数，则要根据保留位来决定奇进偶舍：

>>> round(5.215,2)#实际并没有进位
5.21
>>> round(5.225,2)
5.22
>>> round(1.5)#此处进位
2
>>> round(1.5)==round(2.5)#偶数舍去
True
>>> round(1.15,1)
1.1
>>> round(1.25,1)
1.2
>>> round(1.151,1)
1.2
>>> round(1.251,1)
1.3

(4) 如果保留位数的后一位如果是5，且该位数后有数字。则进上去，例如5.2152保留两位小数为5.22，5.2252保留两位小数为5.23，5.22500001保留两位小数为5.23。
从统计学的角度，“奇进偶舍”比“四舍五入”要科学，在大量运算时，它使舍入后的结果误差的均值趋于零，而不是像四舍五入那样逢五就入，导致结果偏向大数，使得误差产生积累进而产生系统误差，“奇进偶舍”使测量结果受到舍入误差的影响降到最低。

16.Python 标识符

在 Python 里，标识符由字母、数字、下划线组成。
在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；
以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。

17.字符串

17.1 字符串截取字符补充：

0、a,b为参数。从字符串指针为a的地方开始截取字符，到b的前一个位置（因为不包含b）

var1 = "hello world";print(var1[a: b]);

1、如果a,b均不填写，默认取全部字符。即，下面这两个打印结果是一样的

print(var1[: ]); # hello world
print(var1);      # hello world

2、如果a填写，b不填写（或填写的值大于指针下标），默认从a开始截取，至字符串最后一个位置

print(var1[3: ]); # lo world

3、如果a不填写， b填写，默认从0位置开始截取，至b的前一个位置

print(var1[: 8]); # hello wo

4、如果a为负数，默认从尾部某一位置，开始向后截取

print(var1[-2: ]); # ld

5、如果a>=b, 默认输出为空。

print(var1[3: 3]);
print(var1[3: 2]);

17.2 python字符串格式化符号:

%g 是 %f 和 %e 的简写是什么意思？到底是 %f 还是 %e？
对此我用代码测试了一下：

>>> a=100000
>>> print("%g"%(a))
100000
>>> a=10000000
>>> print("%g"%(a))
1e+07
>>> a=1000000
>>> print("%g"%(a))1e+06

可以发现，%g 是自动选择输出格式的，在六位数的情况下就会以科学计数法方式输出，文章中说 %g 是 %f 和 %e 的简写，但是我发现上述不是科学计数法方式输出的时候输出的是一个整数，于是又进行了如下测试：

>>> a=100000.0
>>> print("%g"%(a))
100000
>>> print("%f"%(a))
100000.000000
>>>

发现 %g 在不是用 %e 输出的情况下和%f还是有区别的
对此我又做了如下测试：

>>> a=100000.1
>>> print("%g"%(a))
100000
>>> a=1.0
>>> print("%g"%(a))
1
>>> a=1.1
>>> print("%g"%(a))
1.1

发现在 a=100000.1 的时候输出的数并没有小数点后面的 1，对此我对比了 C 语言 %g 的格式输出，猜想 python 中应该如同 C 语言一样，%g 用于打印数据时，会去掉多余的零，至多保留六位有效数字。

17.3 使用格式化符号进行进制转换

>>> num=10
>>> print('十六进制：%#x' % num)    #使用%x将十进制num格式化为十六进制
十六进制：0xa
>>> print('二进制:', bin(num))      #使用bin将十进制num格式化为二进制
二进制:0b1010
>>> print('八进制：%#o' % num)      #使用%o将十进制num格式化为八进制
八进制：0o12
上面使用格式化符号进行进制转换中，多加入了一个#号，目的是在转换结果头部显示当前进制类型，如不需要，可将#号去除，如下
>>> print('八进制：%o' % num)
八进制：12
>>> print('十六进制：%x' % num)
十六进制：a

17.4 [::2] 表示的是从头到尾，步长为2。第一个冒号两侧的数字是指截取字符串的范围,第二个冒号后面是指截取的步长。

>>> L=['a','b','c','d','e','f','g']
>>> print(L[::2])
['a', 'c', 'e', 'g']

17.5字符串的分割还有partition()这种方式。

partition(sep) --> (head,sep,tail)
从左向右遇到分隔符把字符串分割成两部分，返回头、分割符、尾三部分的三元组。如果没有找到分割符，就返回头、尾两个空元素的三元组。

s1 = "I'm a good sutdent."#以'good'为分割符，返回头、分割符、尾三部分。
s2 = s1.partition('good')#没有找到分割符'abc'，返回头、尾两个空元素的元组。
s3 = s1.partition('abc')print(s1)print(s2)print(s3)

结果如下：

I'm a good sutdent.
("I'm a ", 'good', ' sutdent.')
("I'm a good sutdent.", '', '')

17.6 针对 Counter 的升级使用，示例如下：

#必须引用如下库from collections import Counter#定义两个字符串变量
Var1 = "1116122137143151617181920849510"
Var2 = "1987262819009787718192084951"#以字典的形式，输出每个字符串中出现的字符及其数量
print (Counter(Var1))
print (Counter(Var2))
输出如下：
Counter({'1': 12, '2': 3, '6': 2, '3': 2, '7': 2, '4': 2, '5': 2, '8': 2, '9': 2, '0': 2})
Counter({'1': 5, '9': 5, '8': 5, '7': 4, '2': 3, '0': 3, '6': 1, '4': 1, '5': 1})

17.7 isdigit 和 isnumeric的区别?

def dn():dgt=[]num=[]c=0for c in range(2**16):ch=chr(c)if ch.isdigit():dgt.append(ch)if ch.isnumeric():num.append(ch)print('digits:',dgt)  print('numeric:',num)   //多了中文
dn()

18.列表

18.1 列表的复制

>>> a = [1, 2, 3]>>> b = a
>>> c = []>>> c = a
>>> d = a[:]>>> a, b, c, d
([1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3])>>> b[0] = 'b'>>> a, b, c, d
(['b', 2, 3], ['b', 2, 3], ['b', 2, 3], [1, 2, 3])>>> id(a), id(b), id(c), id(d)(140180778120200, 140180778120200, 140180778120200, 140180778122696)>>> c[0] = 'c'>>> a, b, c, d
(['c', 2, 3], ['c', 2, 3], ['c', 2, 3], [1, 2, 3])>>> id(a), id(b), id(c), id(d)(140180778120200, 140180778120200, 140180778120200, 140180778122696)>>> d[0] = 'd'>>> a, b, c, d
(['c', 2, 3], ['c', 2, 3], ['c', 2, 3], ['d', 2, 3])>>> id(a), id(b), id(c), id(d)(140180778120200, 140180778120200, 140180778120200, 140180778122696)

可以看到a b c 三个是同一id值，当改变当中任一列表元素的值后，三者会同步改变。
但d的元素值不会变，改变d的元素值其它三个变量内的元素值也不会变。
从a b c d 的id值来看，a b c 地址全一样，唯有d分配了新地址。
所以一般情况下想复制得到一个新列表并改变新列表内元素而不影响原列表，可以采用d的赋值方式。
这只是针对这种比较单一的普通列表。

其实可以用copy模块里 copy()函数解决，实例如下：

import copya = [1,2,3,4]
b = a
d = copy.copy(a)
b[0] = 'b'
print(a,b,d)
print(id(a),id(b),id(d))

还有一个就是用list自带的copy()方法,把重新开辟内存空间存储新列表。

original_list=[0,1,2,3,4,5,6,7,8]
copy_list=original_list.copy()
copy_list=copy_list+['a','b','c']
print("original_list:",original_list)print("copy_list modify:",copy_list)
运行结果
original_list: [0, 1, 2, 3, 4, 5, 6, 7, 8]
copy_list modify: [0, 1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c']

18.2 空列表

可以简单地通过两个中括号进行表示([])- 一里面什么东西都没有，但是，如果想创建一个占用十个元素空间，却不包括任何有用内容的列表，又该怎么办呢?首先可以类似于下面的方法，用某一个具体的值代替。

>>> list_empty = [0]*10
>>> list_empty
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

这样就生成了一一个包括10个0的列表。然而，有时候可能会需要一个值来代表空一意味着没有在里面放置任何元素。这个时候就需要使用None。None 是一个Python的内建值，它的确切含意是"这里什么也没有"。因此，如果想初始化个长度为10的列表，可以按照下面的例子来实现:

>>> list_empty = [None]*10>>> list_empty
[None, None, None, None, None, None, None, None, None, None]

18.3 有时在取 list 中元素时可能会遇到以下情形：

>>> a=[]>>> a[0]Traceback (most recent call last):File "<stdin>", line 1, in <module>IndexError: list index out of range

这种情况发生是因为只定义了一个空列表，没有进行任何的赋值，所以列表里什么也没有，而后面的报错也明确表示了索引超出范围，即写上的0其实是第一位值的位置，而此时是空列表没有赋值，故而报错。
而如果我们使用以下语句则不会报错：

>>> a[0:][]

这个不是什么小技巧，这是不一样的语句意义，这句话其实是把这个列表 a 里的所有值都输出，其效果和下面表达的最终结果是一致的。

>>> a[:][]

而这个语句并不能避免上面报错中超出索引范围的错误，这个根本就是两种不同的意义的语句。a[0:] 和 a[:] 在脚本输出时相当于 print(a) 的意思。这不是解决错误的方式，不能将它当成 trick 来用。

18.4

列表推导式书写形式：　　
[表达式 for 变量 in 列表]或者[表达式 for 变量 in 列表 if 条件]

19.zip

描述zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。
如果需要了解 Pyhton3 的应用，可以参考 Python3 zip()。
语法zip 语法：
zip([iterable, …])
参数说明：
iterabl – 一个或多个迭代器;
返回值返回元组列表。
实例以下实例展示了 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 相反，*zipped 可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]

20.tuple

tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：
代码如下：

>>> classmates = ('Michael', 'Bob', 'Tracy')

现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：
代码如下：

>>> t = (1, 2)
>>> t
(1, 2)

如果要定义一个空的tuple，可以写成()：
代码如下：

>>> t = ()
>>> t
()

但是，要定义一个只有1个元素的tuple，如果你这么定义：
代码如下：

>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号 ,来消除歧义：
代码如下:

>>> t = (1,)
>>> t
(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。
在来看一个"可变的"tuple：
代码如下:

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

这个tuple定义的时候有3个元素，分别是’a’，‘b’和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？
别急，我们先看看定义的时候tuple包含的3个元素：当我们把list的元素’A’和’B’修改为’X’和’Y’后，tuple变为：表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的"不变"是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！理解了"指向不变"后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

21.使用内置 enumerate 函数进行遍历:

for index, item in enumerate(sequence):
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;process(index, item)

实例

>>> sequence = [12, 34, 34, 23, 45, 76, 89]
>>> for i, j in enumerate(sequence):... print(i, j)...
0 121 342 343 234 455 766 89

22 yield关键字

yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器。

>>> def createGenerator() :... mylist = range(3)... for i in mylist :... yield i*i...
>>> mygenerator = createGenerator() # create a generator
>>> print(mygenerator) # mygenerator is an object!<generator object createGenerator at 0xb7555c34
>>
>> for i in mygenerator:... print(i)

这个例子没什么用途，但是它让你知道，这个函数会返回一大批你只需要读一次的值.
为了精通 yield ,你必须要理解：当你调用这个函数的时候，函数内部的代码并不立马执行，这个函数只是返回一个生成器对象，这有点蹊跷不是吗。
那么，函数内的代码什么时候执行呢？当你使用for进行迭代的时候.
现在到了关键点了！
第一次迭代中你的函数会执行，从开始到达 yield 关键字，然后返回 yield 后的值作为第一次迭代的返回值. 然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的。
如果生成器内部没有定义 yield 关键字，那么这个生成器被认为成空的。这种情况可能因为是循环进行没了，或者是没有满足 if/else 条件。

23.正则表达式

[外链图片转存失败(img-CV9pY0GT-1563622653454)(en-resource://database/3886:1)]
[外链图片转存失败(img-JR8g2mPP-1563622653454)(en-resource://database/3888:1)]
[外链图片转存失败(img-0b0en018-1563622653454)(en-resource://database/3890:1)]

import os
import reimport warningswarnings.simplefilter("ignore", UserWarning)
from matplotlib import pyplot as pltimport pandas as pdpd.options.mode.chained_assignment = None
import numpy as np
from string import punctuationfrom nltk.tokenize import word_tokenizefrom sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, auc, roc_auc_score
from sklearn.externals import joblibimport scipy
from scipy.sparse import hstackdata = pd.read_csv('./data/tweets.csv', encoding='latin1', usecols=['Sentiment',
'SentimentText'])
data.columns = ['sentiment', 'text']
data = data.sample(frac=1, random_state=42)
print(data.shape)for row in data.head(10).iterrows():
print(row[1]['sentiment'], row[1]['text'])def tokenize(tweet):
tweet = re.sub(r'http\S+', '', tweet)
tweet = re.sub(r"#(\w+)", '', tweet)
tweet = re.sub(r"@(\w+)", '', tweet)
tweet = re.sub(r'[^\w\s]', '', tweet)
tweet = tweet.strip().lower()
tokens = word_tokenize(tweet)
return tokensdata['tokens'] = data.text.progress_map(tokenize)
data['cleaned_text'] = data['tokens'].map(lambda tokens: ' '.join(tokens))
data[['sentiment', 'cleaned_text']].to_csv('./data/cleaned_text.csv')data = pd.read_csv('./data/cleaned_text.csv')
print(data.shape)data.head()x_train, x_test, y_train, y_test = train_test_split(data['cleaned_text'],
data['sentiment'],
test_size=0.1,
random_state=42,
stratify=data['sentiment'])print(x_train.shape, x_test.shape, y_train.shape, y_test.shape)pd.DataFrame(y_test).to_csv('./predictions/y_true.csv', index=False, encoding='utf-8')

24.Python中的 // 与 / 的区别通常C/C++中，"/ " 算术运算符的计算结果是根据参与运算的两边的数据决定的，比如：

6 / 3 = 2 ; 6,3都是整数，那么结果也就是整数2;
6.0 / 3.0 = 2.0 ; 6.0,3.0是浮点数，那么结果也是浮点数2.0，跟精确的说，只要" / " 两边有一个数是浮点数，那么结果就是浮点数。
　　在Python2.2版本以前也是这么规定的，但是，Python的设计者认为这么做不符合Python简单明了的特性，于是乎就在Python2.2以及以后的版本中增加了一个算术运算符" // “来表示整数除法，返回不大于结果的一个最大的整数，而” / " 则单纯的表示浮点数除法，但是，为了折中，所有2.X版本中，也是为了向后兼容，如果要使用" // “，就必须加上一条语句：
　　from future import division
　　一看到这句，” / “就表示浮点数除法，返回浮点结果;” // “表示整数除法。
　　但是，预计在Python3.0发布时，就没有这种折中情况了，，” / “就一定表示浮点数除法，返回浮点结果;” // "表示整数除法。

25.python强制刷新缓冲区sys.stdout.flush() tqdm进度条

缓冲区的刷新方式：
1.flush()刷新缓存区
2.缓冲区满时，自动刷新 3.文件关闭或者是程序结束自动刷新。

当我们打印一些字符时，并不是调用print函数后就立即打印的。一般会先将字符送到缓冲区，然后再打印。这就存在一个问题，如果你想等时间间隔的打印一些字符，但由于缓冲区没满，不会打印。就需要采取一些手段。如每次打印后强行刷新缓冲区。

for i in range(n):print " * ",sys.stdout.flush() #刷新缓冲区time.sleep(1)

在使用tqdm时，就遇到这种问题：
明明是一个加载条，却打印出两个，影响美观。后发现是因为在加载条前有一句打印语句，可以看到tqdm先打印了一个加载条，但后面又来了个print，导致tqdm只能重新再打印一个加载条。因此强行刷新了缓冲区。

print(f'starting load trainset {cur_class} {n}')
sys.stdout.flush()
for i in tqdm(range(n)):

26.random

import randomprint( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)

27.pickle

持久化数据对象

import pickle
'''
persistent object
'''
output = open('test.pkl', 'wb')
f = [1, 2, 3, '1', '2', '6']
data = {'a': [1, 2.0, 3, 4+6j],'b': ('string', u'Unicode string'),'c': None}

Pickle the list using protocol 0.

pickle.dump(f, output)

Pickle dictionary using the hightest protocol available.

pickle.dump(data, output, -1)
output.close()'''
deserialization
'''
import pprint, picklepkl_file = open('test.pkl', 'rb')f = pickle.load(pkl_file)
pprint.pprint(f)data = pickle.load(pkl_file)
pprint.pprint(data)pkl_file.close()

28.’’‘np.array’’’

p = np.array([[1, 3, 3, 4, 5, 6, 7, 8, 9, 0], [2, 3, 6, 7, 5, 6, 7, 8, 9, 0]])
print(p[1, 0::2])  # 显示第二行位置是偶数的数字

29.time.time()

返回当前时间，单位秒

30.tqdm

解决进度条无法正常显示的原因：

try:&nbsp;&nbsp;&nbsp;&nbsp; with tqdm(...) as t:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for i in t:            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...except KeyboardInterrupt:&nbsp;&nbsp;&nbsp;&nbsp; t.close()&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;raise
t.close()

31.判断字符串是数字还是字母

str_1 = "123"
str_2 = "Abc"
str_3 = "123Abc"#用isdigit函数判断是否数字print(str_1.isdigit())
Ture
print(str_2.isdigit())
False
print(str_3.isdigit())
False#用isalpha判断是否字母print(str_1.isalpha())
False
print(str_2.isalpha())
Ture
print(str_3.isalpha())
False#isalnum判断是否数字和字母的组合print(str_1.isalnum())
Ture
print(str_2.isalnum())
Ture
print(str_1.isalnum())
Ture

32.[外链图片转存失败(img-w330zFo4-1563622653455)(en-resource://database/3854:1)]

33. pycharm

代码跳转后退的快捷键是 ctrl+alt+←(左箭头)