Python

版本

Python 3.9 以上的版本不再支持 Windows 7

事实上vcpkg里已经有人做了这个工作了, 只修改了两三个api, 主要是pathcch.

PathCchSkipRoot PathCchCombineEx PathCchCanonicalizeEx 这三个API是在Windows 8中引入的, 对应的 Windows 7 API是 PathSkipRoot PathCombine PathCanonicalize, 功能少一点, 但不是不能用.

docker

​x
mkdir -p /data/my_python_script

docker run -it --rm --name my_python python:3.6.15-buster python
docker run -it --rm --name my_python python:3.6.15-buster pip list

docker run -d --name my_python_script \
-v /data/my_python_script:/usr/src/myapp \
-v /etc/localtime:/etc/localtime:ro \
-w /usr/src/myapp \
python:3.6.15-buster python my_python_script.py

pip

参考：pip

Python Shell

在Shell中，可以直接使用变量名查看变量的值，不能在脚本中使用

xxxxxxxxxx
>>> myString = 'Hello World!'
>>> print myString
Hello World!
>>> myString
'Hello World!'

模板

xxxxxxxxxx
#!/usr/bin/env python
# -*- coding: utf-8 -*-


def main(path):
    pass


if __name__ == '__main__':
    try:
        path = sys.argv[1]
    except IndexError as e:
        print('Usage: python %s <xls_file>' % __file__)
        sys.exit()

    main(path)


# 创建一个bat脚本接收命令行参数
"C:\Python36\python.exe" "xxx.py" %*

::pause
sleep 1

退出

执行该语句会直接退出程序，这也是经常使用的方法，也不需要考虑平台等因素的影响，一般是退出Python程序的首选方法. 该方法中包含一个参数status，默认为0，表示正常退出，也可以为1，表示异常退出.

xxxxxxxxxx
import sys
sys.exit()

print格式化输出

％-formatting

• %s：用于字符串格式化。可以接受任何类型的对象，并将其转换为字符串。
• %d：用于整数格式化。可以接受整数类型的对象。
• %f：用于浮点数格式化。可以接受浮点数类型的对象。
• %x：用于十六进制整数格式化。可以接受整数类型的对象，并将其转换为十六进制表示形式。
• %o：用于八进制整数格式化。可以接受整数类型的对象，并将其转换为八进制表示形式。
• %r：用于原始字符串格式化。可以接受任意类型的对象，并将其转换为其原始字符串表示形式。

xxxxxxxxxx
name = "Python"
num = 1

"%s is number %d!" % (name, num)     # ==> 'Python is number 1!'
"%10s is number %d!" % (name, num)   # ==> '    Python is number 1!'  # 填充，默认居右
"%+10s is number %d!" % (name, num)  # ==> '    Python is number 1!'  # 居右
"%-10s is number %d!" % (name, num)  # ==> 'Python     is number 1!'  # 居左

str.format()

xxxxxxxxxx
# Python >= 2.6 or Python >= 3.0

"{} is number {}!".format(name, num)         # ==> 'Python is number 1!'
"{0} is number {1}!".format(name, num)       # ==> 'Python is number 1!'  # 下标
"{:10} is number {}!".format(name, num)      # ==> 'Python     is number 1!'  # 填充，默认居左
"{:<10} is number {}!".format(name, num)     # ==> 'Python     is number 1!'  # 居左
"{:>10} is number {}!".format(name, num)     # ==> '    Python is number 1!'  # 居右
"{:^10} is number {}!".format(name, num)     # ==> '  Python   is number 1!'  # 居中
"{:#^10} is number {}!".format(name, num)    # ==> '  Python   is number 1!'  # 填充符号，默认空格
"{0:#^10} is number {1}!".format(name, num)  # ==> '  Python   is number 1!'

f-string

出现于Eric Smith在2015年提交的 PEP 498 – Literal String Interpolation 提案。

xxxxxxxxxx
# f-string是在.format格式化的基础之上做了一些变动，核心思想一样，Python >= 3.6

f"{name} is number {num}!"       # ==> 'Python is number 1!'
f"{name:10} is number {num}!"    # ==> 'Python     is number 1!'  # 填充，默认居左
f"{name:<10} is number {num}!"   # ==> 'Python     is number 1!'  # 居左
f"{name:>10} is number {num}!"   # ==> '    Python is number 1!'  # 居右
f"{name:^10} is number {num}!"   # ==> '  Python   is number 1!'  # 居中
f"{name:#^10} is number {num}!"  # ==> '##Python## is number 1!'  # 填充符号，默认空格

文档字符串

xxxxxxxxxx
# 规范写法，和Python自带的模块、方法、类展示效果类似

def foo():
    '''This is a DocStrings.

This is detailed description1
This is detailed description2'''
    return True

>>> print(foo.__doc__)
This is a DocStrings.

This is detailed description1
This is detailed description2

>>> help(foo)
Help on function foo in module __main__:

foo()
    This is a DocStrings.

    This is detailed description1
    This is detailed description2

重定向

xxxxxxxxxx
import sys
print >> sys.stderr, 'Fatal error: invalid input!'
>>>
Fatal error: invalid input!

raw_input

xxxxxxxxxx
>>> user = raw_input('Enter login name: ')
Enter login name: Joy

操作符

xxxxxxxxxx
不等于：!=和<>    分别是C风格和ABC 、Pascal风格
不支持a++、a--、++a、--a
>>> 3 < 4 < 5    #等价于3 < 4 and 4 < 5
True

变量名

大小写敏感。Python 是动态类型语言，也就是说不需要预先声明变量的类型。

if语句

xxxxxxxxxx
a=3;b=36
if a<b:
    print "a<b"
elif a>b:
    print "a>b"
else :
    print "a=b"

为什么在Python中没有switch或case语句？ 对于需要从大量可能性中进行选择的情况，可以创建将案例值映射到要调用的函数的字典。例如：

xxxxxxxxxx
def function_1(...):
    ...

functions = {'a': function_1,
             'b': function_2,
             'c': self.method_1, ...}

func = functions[value]
func()

while循环

xxxxxxxxxx
a=0
while a<3:
    print a
    a+=1

range

xxxxxxxxxx
range(start, stop[, step])
>>> range(1,9,2)
[1, 3, 5, 7]    #注意不包括9

for循环

xxxxxxxxxx
for i in ["a","b","c","d"]:
    print i
>>>
a
b
c
d

print 不换行

xxxxxxxxxx
# Python2
print(line,)

# Python3
print(line, end = '')

# 去掉换行符 "\n"
line=line.strip('\n')

for in range

xxxxxxxxxx
for i in range(4):
    print i,
>>>
0 1 2 3

异常

xxxxxxxxxx
# python2:
# except Exception, e

# python3 & 2:
# except Exception as e:

x=10
y='dsaf'

try:
    print(x/y)
except ZeroDivisionError as e:
    print(e)
except TypeError as e:  # 捕获异常及对象
    print(e)
except:                 # 会捕获其他错误，不建议这么做
    pass
else:                   # 不出异常会被执行
    print("no error.")
finally:                # 无论如何都会执行
    print("finally.")

try:
    y=0
    print(x/y)
except (ZeroDivisionError, TypeError) as e:  #一个块捕获多个异常
    print(e)

主动抛出移除

xxxxxxxxxx
# 抛出一个常规的ValueError异常
raise ValueError("输入值不在预期范围内")
 
# 抛出一个自定义的异常
class MyCustomError(Exception):
    pass
 
# 在代码中主动抛出自定义异常
raise MyCustomError("发生了一个特定的错误情况")

参数

当要使函数接收元组/列表或字典形式的参数的时候，有一种特殊的方法，它分别使用 * 和 ** 前缀。这种方法在函数需要获取可变数量的参数的时候特别有用。在函数中接收元组/列表：

xxxxxxxxxx
def powersum(power, *args):
    '''Return the sum of each argument raised to specified power.'''
    print args              # (3, 4)
    total = 0
    for i in args:
        total += pow(i, power)
    return total

print powersum(2, 3, 4)     # 3^2+4^2=25
print powersum(2, 10)       # 10^2=100

由于在args 变量前有 * 前缀，所有多余的函数参数都会作为一个元组存储在 args 中。如果使用的是 ** 前缀，多余的参数则会被认为是一个字典的键/值对。在函数中接收字典：

xxxxxxxxxx
def test(**params):
    print params            # {'y': 2, 'x': 1, 'z': 3}

test(x=1,y=2,z=3)

同时接收元组/列表或字典：

xxxxxxxxxx
def all(x, y, z=333, *a, **b):
    print x,y,z             # 1 2 3
    print a                 # (4, 5, 6)
    print b                 # {'ss': 888, 'tt': 777}

all(1,2,3,4,5,6,tt=777,ss=888)

可以使用*/**操作符来解包列表/字典，并将其中的值作为函数的单独参数。例如：

xxxxxxxxxx
def my_function(a, b, c):
    print(a, b, c)
 
args = [1, 2, 3]
params = {x=1, y=2}

my_function(*args)
my_function(**params)

import 模块

xxxxxxxxxx
import xxx

from 包 import 模块
from packages import bdtb

from 包.模块 import 模块属性（类、方法）
from packages.bdtb import BDTB

# 返回当前脚本/指定模块的路径
print(__file__)
print(xxpackage.__file__)

# 返回指定模块的文档
print(xxpackage.__doc__)

# 返回指定模块的帮助
print(help(xxpackage))

字符串的encode与decode

更新时间：2009年03月23日 23:56:50 作者： Python2字符串的encode与decode研究心得乱码问题解决方法

为什么Python使用过程中会出现各式各样的乱码问题，明明是中文字符却显示成"\xe4\xb8\xad\xe6\x96\x87"的形式？为什么会报错"UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)"？本文就来研究一下这个问题。

字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。

decode的作用是将其他编码的字符串转换成unicode编码，如str1.decode('gb2312')，表示将gb2312编码的字符串str1转换成unicode编码。

encode的作用是将unicode编码转换成其他编码的字符串，如str2.encode('gb2312')，表示将unicode编码的字符串str2转换成gb2312编码。

因此，转码的时候一定要先搞明白，字符串str是什么编码，然后decode成unicode，然后再encode成其他编码

代码中字符串的默认编码与代码文件本身的编码一致。

如：s='中文'

如果是在utf8的文件中，该字符串就是utf8编码，如果是在gb2312的文件中，则其编码为gb2312。这种情况下，要进行编码转换，都需要先用decode方法将其转换成unicode编码，再使用encode方法将其转换成其他编码。通常，在没有指定特定的编码方式时，都是使用的系统默认编码创建的代码文件。

如果字符串是这样定义：s=u'中文'

则该字符串的编码就被指定为unicode了，即python的内部编码，而与代码文件本身的编码无关。因此，对于这种情况做编码转换，只需要直接使用encode方法将其转换成指定编码即可。

如果一个字符串已经是unicode了，再进行解码则将出错，因此通常要对其编码方式是否为unicode进行判断：

isinstance(s, unicode) #用来判断是否为unicode

用非unicode编码形式的str来encode会报错

如何获得系统的默认编码？

xxxxxxxxxx
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
print sys.getdefaultencoding()

该段程序在英文WindowsXP上输出为：ascii

在某些IDE中，字符串的输出总是出现乱码，甚至错误，其实是由于IDE的结果输出控制台自身不能显示字符串的编码，而不是程序本身的问题。

如在UliPad中运行如下代码：

s=u"中文" print s

会提示：UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)。这是因为UliPad在英文WindowsXP上的控制台信息输出窗口是按照ascii编码输出的（英文系统的默认编码是ascii），而上面代码中的字符串是Unicode编码的，所以输出时产生了错误。

将最后一句改为：print s.encode('gb2312')

则能正确输出"中文"两个字。

若最后一句改为：print s.encode('utf8')

则输出：\xe4\xb8\xad\xe6\x96\x87，这是控制台信息输出窗口按照ascii编码输出utf8编码的字符串的结果。

unicode(str,'gb2312')与str.decode('gb2312')是一样的，都是将gb2312编码的str转为unicode编码

使用str.__class__可以查看str的编码形式

Python2,3 的编码对比

在 Python 中，不论是 Python2 还是 Python3 中，总体上说，字符都只有两大类：

• 通用的 Unicode 字符；
• （unicode 被编码后的）某种编码类型的字符，比如 UTF-8，GBK 等类型的字符。

Python2 中字符的类型：

• str： 已经编码后的字节序列
• unicode： 编码前的文本字符

Python3 中字符的类型：

• str： 编码过的 unicode 文本字符
• bytes： 编码前的字节序列

我们可以认为字符串有两种状态，即文本状态和字节（二进制）状态。Python2 和 Python3 中的两种字符类型都分别对应这两种状态，然后相互之间进行编解码转化。编码就是将字符串转换成字节码，涉及到字符串的内部表示；解码就是将字节码转换为字符串，将比特位显示成字符。

在 Python2 中，str 和 unicode 都有 encode 和 decode 方法。但是不建议对 str 使用 encode，对 unicode 使用 decode, 这是 Python2 设计上的缺陷。Python3 则进行了优化，str 只有一个 encode 方法将字符串转化为一个字节码，而且 bytes 也只有一个 decode 方法将字节码转化为一个文本字符串。

Python2 的 str 和 unicode 都是 basestring 的子类，所以两者可以直接进行拼接操作。而 Python3 中的 bytes 和 str 是两个独立的类型，两者不能进行拼接。

Python2 中，普通的，用引号括起来的字符，就是 str；此时字符串的编码类型，对应着 Python 文件本身的编码（在终端直接执行代码与系统环境有关），最常见的 Windows 平台中，默认用的是 GBK，Linux平台是 utf-8。Python3 中，被单引号或双引号括起来的字符串，就已经是 Unicode 类型的 str 了。对于 str 为何种编码，有一些前提：

• Python 文件开始已经声明对应的编码
• Python 文件本身的确是使用该编码保存的
• 两者的编码类型要一样（比如都是 UTF-8 或者都是 GBK 等）

这样 Python 解析器才能正确的把文本解析为对应编码的 str。

总体来说，在 Python3 中，字符编码问题得到了极大的优化，不再像 Python2 那么头疼。在 Python3 中，文本总是 Unicode, 由 str 类型进行表示，二进制数据使用 bytes 进行表示，不会将 str 与 bytes 偷偷的混在一起，使得两者的区别更加明显。

Python2编码转换

Python2 中把 str 转为 unicode, 如 xxx ==> u'xxx'

xxxxxxxxxx
# 方法一：
'i am \xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')  # ==> u'i am \u4e2d\u6587'
'i am \xd6\xd0\xce\xc4'.decode('gbk')            # ==> u'i am \u4e2d\u6587'

# 此时str的编码类型跟Python环境有关，要根据环境选择decode的encoding。
# UnicodeDecodeError: 'gbk' codec can't decode bytes ...
# UnicodeDecodeError: 'utf8' codec can't decode byte ...
'i am 中文'.decode('utf-8')  # ==> u'i am \u4e2d\u6587'
'i am 中文'.decode('gbk')    # ==> u'i am \u4e2d\u6587'
# 通用写法
'i am 中文'.decode(sys.stdin.encoding)

# 方法二：
unicode('i am \xe4\xb8\xad\xe6\x96\x87', 'utf-8')  # ==> u'i am \u4e2d\u6587'
unicode('i am \xd6\xd0\xce\xc4', 'gbk')            # ==> u'i am \u4e2d\u6587'

Python2 中把 unicode 转为 str, 如 u'xxx' ==> xxx

xxxxxxxxxx
# 方法一：
u'i am 中文'.encode('utf-8')  # ==> 'i am \xe4\xb8\xad\xe6\x96\x87'
u'i am 中文'.encode('gbk')    # ==> 'i am \xd6\xd0\xce\xc4'

# 方法二：无

raw_unicode_escape

生成适合作为 Python 源代码中的原始 Unicode 文字的字符串

unicode_escape

生成适合作为 Python 源代码中的 Unicode 文字的字符串

string_escape

生成适合作为 Python 源代码中的字符串文字的字符串

Python2打印list

当字典中的中文字符是unicode类型时

xxxxxxxxxx
name = {"name": u"中国"}  # <type 'dict'>  # {'name': u'\u4e2d\u56fd'}
name = str(name)         # <type 'str'>   # "{'name': u'\\u4e2d\\u56fd'}"
name = name.decode("unicode_escape")      # u"{'name': u'\u4e2d\u56fd'}"
print(name)                               # {'name': u'中国'}


name = {"name": u"中国"}  # <type 'dict'>  # {'name': u'\u4e2d\u56fd'}
name = repr(name).decode('unicode_escape')
print(name)                               # {'name': u'中国'}

当字典中的字符串是string类型时

xxxxxxxxxx
name = {"name": "中国"}  # <type 'dict'>  # {'name': '\xd6\xd0\xb9\xfa'}       # 这是gbk
name = str(name)        # <type 'str'>   # "{'name': '\\xd6\\xd0\\xb9\\xfa'}"
name = name.decode("string_escape")      # "{'name': '\xd6\xd0\xb9\xfa'}"
print(name)                              # {'name': '中国'}


name = {"name": "中国"}  # <type 'dict'>  # {'name': '\xd6\xd0\xb9\xfa'}       # 这是gbk
name = repr(name).decode('string_escape')
print(name)                              # {'name': '中国'}

repr

返回一个包含对象的可打印表示形式的字符串。 这与转换（反向引号）产生的值相同。 有时，能够将这个操作作为普通函数来访问是很有用的。 对于许多类型，此函数会尝试返回一个字符串，该字符串在传递给 eval() 时会产生具有相同值的对象，否则表示形式是用尖括号括起来的字符串，其中包含对象类型的名称 附加信息通常包括对象的名称和地址。 类可以通过定义 __repr__() 方法来控制该函数为其实例返回的内容。

str

返回一个字符串，其中包含对象的良好可打印表示形式。 对于字符串，这将返回字符串本身。 与 repr(object) 的区别在于 str(object) 并不总是尝试返回 eval() 可接受的字符串； 它的目标是返回一个可打印的字符串。 如果未给出参数，则返回空字符串''。

有关字符串的更多信息，请参阅 Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange，其中描述了序列功能（字符串是序列），以及 String Methods 部分中描述的特定于字符串的方法。 要输出格式化字符串，请使用模板字符串或 String Formatting Operations 部分中描述的 % 运算符。 另外请参阅 String Services 部分。 另请参见 unicode()。

Python3编码转换

Python3 中把 bytes 转为 str, 如 b'xxx' ==> 'xxx'

xxxxxxxxxx
# 方法一：
str(b'i am \xe4\xb8\xad\xe6\x96\x87', encoding="utf-8")  # ==> 'i am 中文'
str(b'i am \xd6\xd0\xce\xc4', encoding="gbk")            # ==> 'i am 中文'

# 方法二：
b'i am \xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')  # ==> 'i am 中文'
b'i am \xd6\xd0\xce\xc4'.decode('gbk')            # ==> 'i am 中文'

Python3 中把 str 转为 bytes, 如 'xxx' ==> b'xxx'

xxxxxxxxxx
# 方法一：
bytes('i am 中文', encoding="utf-8")  # ==> b'i am \xe4\xb8\xad\xe6\x96\x87'
bytes('i am 中文', encoding="gbk")    # ==> b'i am \xd6\xd0\xce\xc4'

# 方法二：
'i am 中文'.encode("utf-8")  # ==> b'i am \xe4\xb8\xad\xe6\x96\x87'
'i am 中文'.encode("gbk")    # ==> b'i am \xd6\xd0\xce\xc4'

raw_unicode_escape

对于其他代码点，使用 \uXXXX 和 \UXXXXXXXX 进行 Latin-1 编码。 现有的反斜杠不会以任何方式转义。 它用于 Python pickle 协议。

若某字符串的内容为bytes形式, 如 a = '\xe7\x8e\x8b\xe8\x80\x85\xe5\x86\x9c\xe8\x8d\xaf'

可使用encode('raw_unicode_escape')将此str转化为bytes, 再decode为str

可使用decode('raw_unicode_escape')输出内容为bytes形式的字符串

xxxxxxxxxx
a = '\xe4\xb8\xad\xe6\x96\x87'       # <class 'str'>
b = a.encode('raw_unicode_escape')
b.decode()                           # ==> '中文'
b.decode('raw_unicode_escape')       # ==> 'ä¸\xadæ\x96\x87'

unicode_escape

适合作为 ASCII 编码的 Python 源代码中 Unicode 文字内容的编码，但引号不会转义。 从 Latin-1 源代码解码。 请注意，Python 源代码实际上默认使用 UTF-8。

若某字符串的内容为unicode形式, 如s = '\u5403\u9e21\u6218\u573a', 在py3中默认为utf-8编码, py3将其自动解释为 '吃鸡战场'

encode('unicode_escape')可将此str编码为bytes类型, 内容则是unicode形式

decode('unicode_escape')可将内容为unicode形式的bytes类型转换为str

xxxxxxxxxx
a = '\u4e2d\u6587'              # <class 'str'>
b = a.encode('unicode_escape')
b.decode('unicode_escape')      #  ==> '中文'

repr

返回一个包含对象的可打印表示形式的字符串。 对于许多类型，此函数会尝试返回一个字符串，该字符串在传递给 eval() 时会产生具有相同值的对象，否则表示形式是用尖括号括起来的字符串，其中包含对象类型的名称 附加信息通常包括对象的名称和地址。 类可以通过定义 __repr__() 方法来控制该函数为其实例返回的内容。

str

返回对象的 string 版本。 如果未提供对象，则返回空字符串。 否则，str() 的行为取决于是否给出编码或错误，如下所示。

如果既没有给出编码也没有给出错误， str(object) 返回 object.__str__()，这是 object 的“友好的”或很好打印的字符串表示形式。 对于字符串对象，这是字符串本身。 如果 object 没有 __str__() 方法，则 str() 会回退到返回 repr(object)。

如果至少给出了编码或错误之一，则 object 应该是 bytes-like object （例如bytes or bytearray）。 在这种情况下，如果 object 是 bytes (or bytearray) object，则 str(bytes, encoding, errors) 相当于 bytes.decode(encoding, errors)。 否则，在调用 bytes.decode() 之前获取缓冲区对象底层的 bytes 对象。 有关缓冲区对象的信息，请参阅 Binary Sequence Types — bytes, bytearray, memoryview 和 Buffer Protocol。

将 bytes 对象传递给 str() 而不带编码或错误参数属于返回非正式字符串表示的第一种情况（另请参阅 Python 的 -b 命令行选项）。 例如：

xxxxxxxxxx
>>> str(b'Zoot!')
"b'Zoot!'"

有关 str 类及其方法的更多信息，请参阅 Text Sequence Type — str 和下面的 String Methods 部分。 要输出格式化字符串，请参阅 Formatted string literals and Format String Syntax 部分。此外，请参阅 Text Processing Services 部分。

字符串连接方式汇总

更新时间：2014年08月21日 10:16:21 投稿：shichen2014

这篇文章主要介绍了python字符串连接方式汇总,很实用的基础技巧汇总,需要的朋友可以参考下

在python中有很多字符串连接方式，今天就在这里具体总结一下：

①.最原始的字符串连接方式：str1 + str2 ②.python 新字符串连接语法：str1, str2 ③.奇怪的字符串方式：str1 str2 ④.% 连接字符串: 'name: %s; sex: ' % ('tom', 'male') ⑤.字符串列表连接：str.join(some_list)

下面具体分析一下：

第一种，想必只要是有编程经验的人，估计都知道，直接用 “+” 来连接两个字符串：

xxxxxxxxxx
'Jim' + 'Green' = 'JimGreen'

第二种比较特殊，如果两个字符串用“逗号”隔开，那么这两个字符串将被连接，但是，字符串之间会多出一个空格：

xxxxxxxxxx
'Jim', 'Green' = 'Jim Green'

第三种也是 python 独有的，只要把两个字符串放在一起，中间有空白或者没有空白：两个字符串自动连接为一个字符串：

xxxxxxxxxx
'Jim''Green' = 'JimGreen'
'Jim' 'Green' = 'JimGreen'

第四种功能比较强大，借鉴了C语言中 printf 函数的功能，如果你有C语言基础，看下文档就知道了。这种方式用符号“%”连接一个字符串和一组变量，字符串中的特殊标记会被自动用右边变量组中的变量替换：

xxxxxxxxxx
'%s, %s' % ('Jim', 'Green') = 'Jim, Green'

第五种就属于技巧了，利用字符串的函数 join (推荐)。这个函数接受一个列表，然后用字符串依次连接列表中每一个元素：

xxxxxxxxxx
var_list = ['tom', 'david', 'john']
a = '###'
a.join(var_list) = 'tom###david###john'

其实，python 中还有一种字符串连接方式，不过用的不多，就是字符串乘法，如：

xxxxxxxxxx
a = 'abc'
a * 3 = 'abcabcabc'

使用 + 操作时，每执行一次+操作就会导致在内存中生成一个新的字符串对象，造成无谓的内存浪费，而用 join 方法整个过程只会产生一个字符串对象。

逗号的三种作用

更新时间：2015年06月08日 11:47:38 作者：liuzx32

这篇文章主要介绍了Python中逗号的三种作用,实例分析了Python中的逗号在类型转换与打印输出时的使用技巧,需要的朋友可以参考下

本文实例讲述了Python中逗号的三种作用。分享给大家供大家参考。具体分析如下：

最近研究python 遇到个逗号的问题 一直没弄明白 今天总算搞清楚了

1.逗号在参数传递中的使用：

这种情况不多说 没有什么不解的地方 就是形参或者实参传递的时候参数之间的逗号

例如def abc(a,b)或者abc(1,2)

2.逗号在类型转化中的使用 主要是元组的转换

例如:

xxxxxxxxxx
>>> a=11
>>> b=(a)
>>> b
11
>>> b=(a,)
>>> b
(11,)
>>> b=(a,22)
>>> b
(11, 22)
>>> b=(a,22,)
>>> b
(11, 22)

从中可以看出 只有当b元组中只有一个元素的时候 需要逗号来转换为元组类型

3.逗号在输出语句print中的妙用:

例子:

xxxxxxxxxx
>>> for i in range(0,5):
...   print i
...
0
1
2
3
4
>>> for i in range(0,5):
...   print i,
...
0 1 2 3 4

很明显 print语句默认的会在后面加上 换行 加了逗号之后 换行 就变成了 空格

python embed版本的使用

1. 下载并解压 python-3.6.8-embed-amd64.zip，重命名为 python-3.6.8

xxxxxxxxxx
unzip python-*-embed-amd64.zip
mv python-* python-3.6.8

2. 安装 setuptools

xxxxxxxxxx
cd python-*
unzip setuptools-44.1.1.zip
cd setuptools-*
# 将 setuptools pkg_resources 复制到python-3.6.8，安装setuptools过程需要setuptools模块。
..\python setup.py install

这一步会在 python-3.6.8-embed-amd64 目录创建Lib\site-packages文件夹。也可以手动完成。

3. 安装 pip

xxxxxxxxxx
cd python-*
tar -xf pip-20.3.4.tar.gz
cd pip-*
..\python setup.py install

4. 修改pythonXX._pth

把pythonXX._pth文件里的#import site前的#删除。即在该环境初始化时，导入site模块，该模块会附加特定的路径到包导入搜索路径并且添加一些内建对象，其中就包括python环境根目录的site-packgages路径。

执行python -m pip list，检查是否正常。

5. 现在可以用python -m pip install <packgage>命令来安装pip包了。也可以直接将pip包解压到 Lib\site-packages 文件夹中。为了减少打包后的大小，可以删除所有的 __pycache__ 目录。

xxxxxxxxxx
@echo off

::遍历文件，包括子目录

setlocal enabledelayedexpansion

set n=1

for /R %%i in (__pycache__) do (

echo 第 !n! 个文件：
echo %%i

rd /S /Q %%i

set /a n+=1

echo.

)

pause

6. 将你的python main脚本如 main.py 放在 python-3.6.8-embed-amd64 的同级目录。
7. 创建 main.bat

xxxxxxxxxx
@echo off

"%~dp0\python-3.6.8\python.exe" "%~dp0main.py" %*

pause
::sleep 1

8. 双击 main.bat ，有文件作为参数时，将文件拖到 main.bat上，即可运行。