python基础知识

字典值可以是任何 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 
dict = {['Name']: 'Runoob', 'Age': 7}TypeError: unhashable type: 'list'

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

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

输出如下结果：

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

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'}

有人认为 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}

基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 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 不在集合中')

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'}

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

字典（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、创建空字典使用 { }。

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

[外链图片转存失败(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 = 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 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

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

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

“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。
从统计学的角度，“奇进偶舍”比“四舍五入”要科学，在大量运算时，它使舍入后的结果误差的均值趋于零，而不是像四舍五入那样逢五就入，导致结果偏向大数，使得误差产生积累进而产生系统误差，“奇进偶舍”使测量结果受到舍入误差的影响降到最低。

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

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

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

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

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

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

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

%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 用于打印数据时，会去掉多余的零，至多保留六位有效数字。

>>> 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

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

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.", '', '')

#必须引用如下库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})

def dn():
    dgt=[]
    num=[]
    c=0
    for 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()

>>> 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 copy

a = [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']

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

>>> 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]

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

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

>>> a[0:][]

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

>>> a[:][]

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

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

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

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的每一个元素本身也不能变。

for index, item in enumerate(sequence):
     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

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!>
>> for i in mygenerator:
        ... print(i)

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

[外链图片转存失败(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 re

import warnings

warnings.simplefilter("ignore", UserWarning)
from matplotlib import pyplot as plt

import pandas as pd


pd.options.mode.chained_assignment = None
import numpy as np
from string import punctuation

from nltk.tokenize import word_tokenize

from 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 joblib

import scipy
from scipy.sparse import hstack

data = 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 tokens


data['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')

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发布时，就没有这种折中情况了，，” / “就一定表示 浮点数除法，返回浮点结果;” // "表示整数除法。

缓冲区的刷新方式：
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)):

import random

print( 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)

持久化数据对象

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.dump(f, output)

pickle.dump(data, output, -1)
output.close()


'''
deserialization
'''
import pprint, pickle


pkl_file = open('test.pkl', 'rb')


f = pickle.load(pkl_file)
pprint.pprint(f)


data = pickle.load(pkl_file)
pprint.pprint(data)


pkl_file.close()

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])  # 显示第二行位置是偶数的数字

返回当前时间，单位秒

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

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

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

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