1.python中的三个读read(),readline()和readlines()

我们谈到“文本处理”时，我们通常是指处理的内容。Python 将文本文件的内容读入可以操作的字符串变量非常容易。文件对象提供了三个“读”方法： .read()、.readline() 和 .readlines()。每种方法可以接受一个变量以限制每次读取的数据量，但它们通常不使用变量。 .read() 每次读取整个文件，它通常用于将文件内容放到一个字符串变量中。然而 .read() 生成文件内容最直接的字符串表示，但对于连续的面向行的处理，它却是不必要的，并且如果文件大于可用内存，则不可能实现这种处理。

.readline() 和 .readlines() 非常相似。它们都在类似于以下的结构中使用：

Python .readlines() 示例

fh = open( 'c:\\autoexec.bat')

for line in fh.readlines():

print line

readline() 和 .readlines()之间的差异是后者一次读取整个文件，象 .read()一样。.readlines()自动将文件内容分析成一个行的列表，该列表可以由 Python 的 for... in ... 结构进行处理。另一方面，.readline()每次只读取一行，通常比 .readlines()慢得多。仅当没有足够内存可以一次读取整个文件时，才应该使用.readline()。

写：

writeline()是输出后换行，下次写会在下一行写。write()是输出后光标在行末不会换行，下次写会接着这行写

通过readline输出，对于比较大的文件，这种占用内存比较小。

#coding:utf-8

f = open('poem.txt','r')

result = list()

for line in open('poem.txt'):

line = f.readline()

print line

result.append(line)

print result

f.close()

open('result-readline.txt', 'w').write('%s' % '\n'.join(result))

#coding:utf-8

'''''cdays-4-exercise-6.py 文件基本操作

@note: 文件读取写入, 列表排序, 字符串操作

@see: 字符串各方法可参考hekp(str)或Python在线文档http://docs.python.org/lib/string-methods.html

'''

f = open('cdays-4-test.txt', 'r') #以读方式打开文件

result = list()

for line in f.readlines(): #依次读取每行

line = line.strip() #去掉每行头尾空白

if not len(line) or line.startswith('#'): #判断是否是空行或注释行

continue #是的话，跳过不处理

result.append(line) #保存

result.sort() #排序结果

print result

open('cdays-4-result.txt', 'w').write('%s' % '\n'.join(result)) #保存入结果文件

2.定义二维数组

matrix = [[0 for i in range(3] for i in range(3)]

里面循环的表示列。外面的表示行

3.Python中os与sys两模块的区别，以及两个模块常用方法

os与sys模块的官方解释如下：

os: This module provides a portable way of using operating system dependent functionality.

这个模块提供了一种方便的使用操作系统函数的方法。

sys: This module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter.

这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函数。

os 常用方法

os.remove() 删除文件

os.rename() 重命名文件

os.walk() 生成目录树下的所有文件名

os.chdir() 改变目录

os.mkdir/makedirs 创建目录/多层目录

os.rmdir/removedirs 删除目录/多层目录

os.listdir() 列出指定目录的文件

os.getcwd() 取得当前工作目录

os.chmod() 改变目录权限

os.path.basename() 去掉目录路径，返回文件名

os.path.dirname() 去掉文件名，返回目录路径

os.path.join() 将分离的各部分组合成一个路径名

os.path.split() 返回( dirname(), basename())元组

os.path.splitext() 返回 (filename, extension) 元组

os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间

os.path.getsize() 返回文件大小

os.path.exists() 是否存在

os.path.isabs() 是否为绝对路径

os.path.isdir() 是否为目录

os.path.isfile() 是否为文件

sys 常用方法

sys.argv 命令行参数List，第一个元素是程序本身路径

sys.modules.keys() 返回所有已经导入的模块列表

sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息

sys.exit(n) 退出程序，正常退出时exit(0)

sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0

sys.version 获取Python解释程序的版本信息

sys.maxint 最大的Int值

sys.maxunicode 最大的Unicode值

sys.modules 返回系统导入的模块字段，key是模块名，value是模块

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

sys.stdout 标准输出

sys.stdin 标准输入

sys.stderr 错误输出

sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息

sys.exec_prefix 返回平台独立的python文件安装的位置

sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'

sys.copyright 记录python版权相关的东西

sys.api_version 解释器的C的API版本

总结：

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

3.1 .sys.stdin读取数据

3.1.1 sys.stdin.readline()

3.1.1.1 https://blog.csdn.net/You_are_my_dream/article/details/54989618

while循环为了获得每一行内容，使用for循环是为了迭代每行内容的每个元素。

题目描述

设有n个正整数，将他们连接成一排，组成一个最大的多位整数。

如:n=3时，3个整数13,312,343,连成的最大整数为34331213。

如:n=4时,4个整数7,13,4,246连接成的最大整数为7424613。

输入描述:

有多组测试样例，每组测试样例包含两行，第一行为一个整数N（N<=100），第二行包含N个数(每个数不超过1000，空格分开)。

输出描述:

每组数据输出一个表示最大的整数

import sys # 与python解释器进行交互

from functools import cmp_to_key # 将老式比较函数转换成键函数，返回key值，用于比较

def mycmp(x, y): # 比较函数：字符串拼接，比较的是第一个字符

if x + y > y + x:

return 1

elif x == y:

return 0

else:

return -1

for i, v in enumerate(sys.stdin.readlines()): # enumerate函数给迭代器的数据设置下标，默认从零开始；sys.stdin.readlines()读取输入的数据

if i % 2 == 1: # 奇数位的下标对应比较的数

v = v.strip().split() # 去掉字符串的头尾空格，按空格切割成列表

v.sort(key=cmp_to_key(mycmp), reverse=True) # 排序

print("".join(v).lstrip("0") or "0")

3.2.2 http://www.cnblogs.com/dolphin0520/archive/2013/03/27/2985492.html

关于raw_input()与sys.stdin.readline()的区别

import sys

line = sys.stdin.readline()

for i in range(len(line)):

print line[i]+'hello'

import sys

line1 = sys.stdin.readline()

line2 = raw_input()

print len(line1),len(line2)

sys.stdin.readline( )会将标准输入全部获取，包括末尾的'\n'，因此用len计算长度时是把换行符'\n'算进去了的，但是raw_input( )获取输入时返回的结果是不包含末尾的换行符'\n'的。

4.Python enumerate() 函数

1.enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

Python 2.3. 以上版本可用，2.6 添加 start 参数。

for 循环使用 enumerate

>>>seq = ['one', 'two', 'three']

>>> for i, element in enumerate(seq):

... print i, seq[i]

...

0 one

1 two

2 three

>>>

5.Python bin() 函数内置函数

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

>>>bin(10) '0b1010'

>>> bin(20) '0b10100'

6，字符串

Python count()方法

Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

#!/usr/bin/python

str = "this is string example....wow!!!";

sub = "i";

print "str.count(sub, 4, 40) : ", str.count(sub, 4, 40) sub = "wow";

print "str.count(sub) : ", str.count(sub)

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

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)#此处进位

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

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

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

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

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

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.Python time time()方法返回的是秒

描述

Python time time() 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

语法

time()方法语法：

time.time()

参数

NA。

返回值

返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

实例

以下实例展示了 time() 函数的使用方法：

#!/usr/bin/python

import time

print "time.time(): %f " % time.time()

print time.localtime( time.time() )

print time.asctime( time.localtime(time.time()) )

以上实例输出结果为：

time.time(): 1234892919.655932

(2009, 2, 17, 10, 48, 39, 1, 48, 0)

Tue Feb 17 10:48:39 2009

---------------------

原文：https://blog.csdn.net/wangzhaotongalex/article/details/49157043

30.tqdm

https://www.cnblogs.com/q735613050/p/10127531.html

Tqdm 是 Python 进度条库，可以在 Python 长循环中添加一个进度提示信息。用户只需要封装任意的迭代器，是一个快速、扩展性强的进度条工具库。

用法：tqdm(iterator)

代码地址：https://github.com/tqdm/tqdm
安装：

pip install tqdm

使用方法一: 传入可迭代对象

import time

from tqdm import *

for i in tqdm(range(1000)):

time.sleep(.01) #进度条每0.1s前进一次，总时间为1000*0.1=100s

100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:10<00:00, 93.97it/s]

使用方法二: trange

trange(i) 是 tqdm(range(i)) 的简单写法

from tqdm import trange

for i in trange(100):

#do something

pass

100%|█████████████████████████████████████████████████████████████████████████████| 100/100 [00:00<00:00, 99344.01it/s]

使用方法三: 可以为进度条设置描述

在 for 循环外部初始化 tqdm，可以打印其他信息：

import time

from tqdm import tqdm

pbar = tqdm(["a", "b", "c", "d"])

for char in pbar:

# 设置描述

pbar.set_description("Processing %s" % char)

time.sleep(1)

Processing d: 100%|██████████████████████████████████████████████████████████████████████| 4/4 [00:04<00:00, 1.00s/it]

手动控制进度：

import time

from tqdm import tqdm

# 一共200个，每次更新10，一共更新20次with tqdm(total=200) as pbar:

for i in range(20):

pbar.update(10)

time.sleep(0.1)

100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [00:01<00:00, 98.87it/s]

tqdm 的 write 方法

bar = trange(10)

for i in bar:

time.sleep(0.1)

if not (i % 3):

tqdm.write("Done task %i" % i)

Done task 0

0%| | 0/10 [00:10<?, ?it/s]

0%| |

0/10 [00:00<?, ?it/s] 10%|████████▎ |

1/10 [00:00<00:01, 8.77it/s] 20%|████████████████▌ |

2/10 [00:00<00:00, 9.22it/s]

Done task 3

0%| |

0/10 [00:10<?, ?it/s] 30%|████████████████████████▉ |

3/10 [00:00<00:01, 6.91it/s] 40%|█████████████████████████████████▏ |

4/10 [00:00<00:00, 9.17it/s] 50%|█████████████████████████████████████████▌ |

5/10 [00:00<00:00, 9.28it/s]

Done task 6

0%| | 0/10 [00:10<?, ?it/s]

60%|█████████████████████████████████████████████████▊ |

6/10 [00:00<00:00, 7.97it/s]

70%|██████████████████████████████████████████████████████████ |

7/10 [00:00<00:00, 9.25it/s] 80%|██████████████████████████████████████████████████████████████████▍ |

8/10 [00:00<00:00, 9.31it/s]

Done task 9

0%| | 0/10 [00:11<?, ?it/s]

90%██████████████████████████████████████████████████████████████████████████▋ |

9/10 [00:01<00:00, 8.37it/s]

100%|██████████████████████████████████████████████████████████████████████████████████|

10/10 [00:01<00:00, 9.28it/s]

31.计算两个向量的余弦相似度

import numpy as np

import re

def bit_product_sum(x, y):

return sum([item[0] * item[1] for item in zip(x, y)])

def cosine_similarity(x, y, norm=False):

""" 计算两个向量x和y的余弦相似度 """

assert len(x) == len(y), "len(x) != len(y)"

zero_list = [0] * len(x)

if x == zero_list or y == zero_list:

return float(1) if x == y else float(0)

# method 1

res = np.array([[x[i] * y[i], x[i] * x[i], y[i] * y[i]] for i in range(len(x))])

cos = sum(res[:, 0]) / (np.sqrt(sum(res[:, 1])) * np.sqrt(sum(res[:, 2])))

# method 2

# cos = bit_product_sum(x, y) / (np.sqrt(bit_product_sum(x, x)) * np.sqrt(bit_product_sum(y, y)))

# method 3

# dot_product, square_sum_x, square_sum_y = 0, 0, 0

# for i in range(len(x)):

# dot_product += x[i] * y[i]

# square_sum_x += x[i] * x[i]

# square_sum_y += y[i] * y[i]

# cos = dot_product / (np.sqrt(square_sum_x) * np.sqrt(square_sum_y))

return 0.5 * cos + 0.5 if norm else cos # 归一化到[0, 1]区间内

32.将字符串列表转换成浮点型列表

def conver_float(x):

float_reg = re.compile(r'^-?\d+\.?\d+$')

float_str = x

return [float(f) for f in float_str if float_reg.match(f)

33.

python基础知识二相关推荐

CV：计算机视觉技术之图像基础知识(二)—以python的skimage和numpy库来了解计算机视觉图像基础(图像存储原理-模糊核-锐化核-边缘检测核，进阶卷积神经网络(CNN)的必备基础)
CV:计算机视觉技术之图像基础知识(二)-以python的skimage和numpy库来了解计算机视觉图像基础(图像存储原理-模糊核-锐化核-边缘检测核,进阶卷积神经网络(CNN)的必备基础) 目录 ...
Python基础知识入门（二）
Python基础知识入门(一) Python基础知识入门(三) Python基础知识入门(四) Python基础知识入门(五) 一.数字类型 Python 数字数据类型用于存储数值.数据类型是不允许改 ...
python的基础知识可以应用到哪方面-Python基础知识
python基础 python的诞生 2002年,python 2.x 2008年,python 3.x python的命名马戏团的名称 python简介简单.易学持快速开发. 跨平台. 开源. ...
python爬虫数据可视化_python 爬虫与数据可视化--python基础知识
摘要:偶然机会接触到python语音,感觉语法简单.功能强大,刚好朋友分享了一个网课<python 爬虫与数据可视化>,于是在工作与闲暇时间学习起来,并做如下课程笔记整理,整体大概分为4个 ...
Python基础知识有哪些？你都知道吗
Python基础知识有哪些?这几年,人工智能.数据分析等各行业的兴起,让更多人知道了Python,让Python是又火了一把.Python作为一个简介又实用的编程语言,让许多想从事信息技术行业的人准备 ...
Python 基础知识学习笔记——NumPy
Python基础知识学习笔记--NumPy 与 matlab 优秀的矩阵运算类似,python 提供了 numpy 库,这对熟悉 matlab 的用户来说非常友好.向量.矩阵和多维数组是数值计算中必不 ...
Python 基础知识学习笔记——OpenCV（1）
Python 基础知识学习笔记--OpenCV(1) OpenCV是一个开源的跨平台计算机视觉和机器学习软件库,它轻量而且高效,被广泛的使用. 整理一下OpenCV学习笔记,以防忘记. 文章目录 Py ...
Python基础知识学习笔记——Matplotlib绘图
Python基础知识学习笔记--Matplotlib绘图整理python笔记,以防忘记文章目录 Python基础知识学习笔记--Matplotlib绘图一.绘图和可视化 1.导入模块 2.一个简 ...
python基础知识学习笔记（1）
python 基础知识学习笔记(1) 总结一下Python基础知识,以防忘记. 文章目录 python 基础知识学习笔记(1) 一.起步 1.python安装与编译环境二.变量和简单数据类型三.列 ...

python基础知识二

题目描述

输入描述:

输出描述:

Python count()方法

实例

实例

实例

实例(Python 3.0+)

描述

语法

返回值

实例

实例

24.Python中的 // 与 / 的区别

tqdm 的 write 方法

python基础知识二相关推荐

最新文章

热门文章