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 += 1

        if 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+b

    return 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

>>>

hellowqp

   hellowqp

  wqp***a@foxmail.com

1年前 (2017-07-10)

   hackmeng

  715***8@qq.com

字典是支持无限极嵌套的，如下面代码：

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.位运算符

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

 

13.Python身份运算符

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

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

以下实例演示了Python所有身份运算符的操作：

实例(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运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
and or not	逻辑运算符

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

 

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

 

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

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

这个例子没什么用途，但是它让你知道，这个函数会返回一大批你只需要读一次的值.

为了精通 yield ,你必须要理解：当你调用这个函数的时候，函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象，这有点蹊跷不是吗。

那么，函数内的代码什么时候执行呢？当你使用for进行迭代的时候.

现在到了关键点了！

第一次迭代中你的函数会执行，从开始到达 yield 关键字，然后返回 yield 后的值作为第一次迭代的返回值. 然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的。

如果生成器内部没有定义 yield 关键字，那么这个生成器被认为成空的。这种情况可能因为是循环进行没了，或者是没有满足 if/else 条件。

 

23.正则表达式

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
re{ n,}	匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
\w	匹配字母数字及下划线
\W	匹配非字母数字及下划线
\s	匹配任意空白字符，等价于 [\t\n\r\f].
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

 

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

 

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