python grammar、C/C++ Python Parsing Engine

时间:2023-03-09 03:29:44
python grammar、C/C++ Python Parsing Engine

catalog

. Python语言简介
. Python模块
. 嵌入式Python解析引擎: C++调用Python
. Python 调用 C (base)
. 扩展Python语法解析器功能: Python中调用C++
. Python 调用 C++ (Boost.Python)
. python 调用 c++ (ctypes)
. 脚本语言扩展性

1. Python语言简介

Python是一门简单易学且功能强大的编程语言。它拥有高效的高级数据结构,并且能够用简单而又高效的方式进行面向对象编程。Python优雅的语法和动态类型,再结合它的解释性,使其在大多数平台的许多领域成为编写脚本或开发应用程序的理想语言

. 我们可以*地从 Python官方点: http://www.python.org,以源代码或二进制形式获取 Python 解释器及其标准扩展库,并可以*的分发。此站点同时也提供了大量的第三方 Python 模块、程序和工具,及其附加文档
. 我们可以很容易的使用 C 或 C++(其他可以通过 C 调用的语言)为 Python 解释器扩展新函数和数据类型。Python 还可以被用作定制应用程序的一门扩展语言,这点和Lua是一致的

0x1: 使用 Python 解释器

. Python 解释器通常被安装在目标机器的 /usr/local/bin/pythonXXX 目录下。将 /usr/local/bin 目录包含进 Unix shell 的搜索路径里,以确保可以通过输入: pythonXX 命令来启动,进入交互模式
. 第二种启动 Python 解释器的方法是 python -c command [arg] ...,这种方法可以在 命令行 执行 Python 语句,类似于 shell 中的 -c 选项。由于 Python 语句通常会包含空格或其他特殊 shell 字符,一般建议将 命令 用单引号包裹起来
. 有一些 Python 模块也可以当作脚本使用。你可以使用 python -m module [arg] ... 命令调用它们,这类似在命令行中键入完整的路径名执行 模块 源文件一样
. 使用脚本文件时,经常会运行脚本然后进入交互模式。这也可以通过在脚本之前加上 -i 参数来实现

1. 参数传递

. 调用解释器时,脚本名和附加参数传入一个名为 sys.argv 的字符串列表。你能够获取这个列表通过执行 import sys,列表的长度大于等于1
. 没有给定脚本和参数时,它至少也有一个元素:sys.argv[] 此时为空字符串
) 脚本名指定为 '-' (表示标准输入)时,sys.argv[] 被设定为 '-'
) 使用 -c 指令 时,sys.argv[] 被设定为 '-c'
) 使用 -m 模块参数时,sys.argv[] 被设定为指定模块的全名
) -c 指令 或者 -m 模块 之后的参数不会被 Python 解释器的选项处理机制所截获,而是留在 sys.argv 中,供脚本命令操作

2. 交互模式

. 从 tty 读取命令时,我们称解释器工作于 交互模式。这种模式下它根据主提示符来执行,主提示符通常标识为三个大于号(>>>)
. 继续的部分被称为 从属提示符,由三个点标识(...)。在第一行之前,解释器打印欢迎信息、版本号和授权提示

aaarticlea/png;base64,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" alt="" />

3. 源程序编码

默认情况下,Python 源文件是 UTF-8 编码。在此编码下,全世界大多数语言的字符可以同时用在字符串、标识符和注释中 — 尽管 Python 标准库仅使用 ASCII 字符做为标识符,这只是任何可移植代码应该遵守的约定。如果要正确的显示所有的字符,你的编辑器必须能识别出文件是 UTF-8 编码,并且它使用的字体能支持文件中所有的字符
我们也可以为源文件指定不同的字符编码。为此,在 #! 行(首行)后插入至少一行特殊的注释行来定义源文件的编码

# -*- coding: encoding -*-
# -*- coding: cp- -*-

0x2: Python语法

1. 数字

. 解释器表现得就像一个简单的计算器:可以向其录入一些表达式,它会给出返回值。表达式语法很直白:运算符 +,-,* 和 / 与其它语言一样(例如:Pascal 或 C);括号 (()) 用于分组
. 整数(例如,, , )的类型是 int,带有小数部分的数字(例如,5.0, 1.6)的类型是 float
. 除法(/)永远返回一个浮点数。如要使用 floor 除法 并且得到整数结果(丢掉任何小数部分),你可以使用 // 运算符;要计算余数你可以使用 %
. 可以使用 ** 运算符计算幂乘方
. 号( '=' )用于给变量赋值。赋值之后,在下一个提示符之前不会有任何结果显示
. 变量在使用前必须 “定义”(赋值),否则会出错
. 浮点数有完整的支持;整数和浮点数的混合计算中,整数会被转换为浮点数
. 交互模式中,最近一个表达式的值赋给变量 _。这样我们就可以把它当作一个桌面计算器,很方便的用于连续计算,此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量,它屏蔽了系统内置变量的魔术效果
. 除了 int 和 float,Python 还支持其它数字类型,例如 Decimal 和 Fraction。Python 还内建支持 复数 ,使用后缀 j 或 J 表示虚数部分(例如,+5j)

aaarticlea/png;base64,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" alt="" />

2. 字符串

相比数值,Python 也提供了可以通过几种不同方式表示的字符串。它们可以用单引号 ('...') 或双引号 ("...") 标识。\ 可以用来转义引号

aaarticlea/png;base64,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" alt="" />

在交互式解释器中,输出的字符串会用引号引起来,特殊字符会用反斜杠转义。虽然可能和输入看上去不太一样,但是两个字符串是相等的

. 如果字符串中只有单引号而没有双引号,就用双引号引用
. 否则用单引号引用
. print() 函数生成可读性更好的输出, 它会省去引号并且打印出转义后的特殊字符

aaarticlea/png;base64,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" alt="" />

如果你前面带有 \ 的字符被当作特殊字符,你可以使用 原始字符串,方法是在第一个引号前面加上一个 r

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMUAAABWCAIAAADwqMVKAAAEDklEQVR4nO2dbXKDIBCGcy4P5Exu4xF6Ci/DYewPP1hgMSSuBuLzTGfaEmABXxe0lH38/f09n88HgAnoCSxBT2AJegJL0BNYgp7AEvQElqAnsKQ6PXWDm8b+cB1u6IIqp6jSfpxm3DCMMnNa0bG2lHGZodVaPCB9fhDeItBTN7gpqbY88Uq6wWVV14+aeERSP26/doOb9nqS1HUWlxlajCk3mIX92D9p9/IbiQnz5dq8wZp9TnBDPziRvGbzlc6X27nVl3RBvinOvn6qNFVoJn8vKn1SPcecb5qmaXSbrn3iXL1o5Tj3czHrM8pWJYb0vod24uEoMZQOyFqLgYdQ57t+TFrwTqJSmReMz+zLhhc48jzemUih5P2TNi6BxHZcm3qPpPLzKUHj1sRtyl5/WK7eXEzqJtSQZkjre9/3vvQmnDcM6d7IxENl109mjipsphiznJtI9BSU8EYzFl+uv/amysICgUeIW+lLrAWXb/3ohk74DM1FxZOQ0ndZg9fTW4ZU+nE6vobL6El1fuWJYQbZygr09MHaM1tiu++L9bRvPfpQ6bt8Xtk+ft+QavsUPVmvoPpR3Bqyj0f1JFYPskDJOkA+/0WzqN6jwMmKX2QzxMVYuqBe5v15ZdebPx7BjeQXQR8YemX6Q5LnuykWaXlirplu8K53bnHoizPL7GUNsBaLF+viiT9ZdLwcF9kAkXnnDhESDNoZaVE0acnmhuUZ0q8k9QpiQ7m++467ubUfGkquk8UD3vnvn8L57grOefT+zTcH1lbP1pN/sL5wiKL3mfCaU95nAhwEPYEl6AksQU9gCXoCS9ATWJLoqbKNQdAWoZ5q3BgELRHoqc6NQdAQUk/VbgyCZijUk85lG4OgFQrnuxyXbQyCNoie7+rdGARNoP8/QpUbg6ABDN5n4lZgg/fjYAl6AkvQE1iCnsAS9ASWoCewBD2BJegJLEFPYEmkJ4OzheDOxP7J4GwhuDFZ/2R7thDchOR8lXPOFoKbEOvppLOF4CZE891JZwvBXeB9AViCnsAS9ASWoCewBD2BJegJLEFPYAl6Akuq09MJ8e+ydgiKF1qLB+SDv6rdIv5dLhdB8SJjx4Pi/Xr8O93QWjVB8aKqDwfFu0P8u4whguKdEBTvDvHvSpYB9Z591VZQvDvEvytaVlZ89lVLQfHuEP+ucAzrPfuqoaB4Px7/TjeUoeKzr5oJikf8uzZMtRIUj/h3kOXo+0yAg6AnsAQ9gSXoCSxBT2AJegJLao9/x2EbbVF//Dv+s70lGoh/d+UeIDhIE/HvLtwDBMdoI/7dd/cAQTmtxL/75h4gKKeZ+Hdf3AME5TQU/+5be4DgDVqKf4dbqR/ej4Ml6AksQU9gyel6mrQv+FXQExjyD07NpBccywMFAAAAAElFTkSuQmCC" alt="" />

字符串文本能够分成多行。一种方法是使用三引号:"""...""" 或者 '''...'''。行尾换行符会被自动包含到字符串中,但是可以在行尾加上 \ 来避免这个行为。下面的示例: 可以使用反斜杠为行结尾的连续字符串,它表示下一行在逻辑上是本行的后续内容:

aaarticlea/png;base64,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" alt="" />

字符串可以由 + 操作符连接(粘到一起),可以由 * 表示重复:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAALEAAAAoCAIAAAA+IowZAAACF0lEQVR4nO2a4c2DIBCGncuBLnEbRnAKlmEYvh+C4nnogWLly/ukSRN60AMfkVKGeZ6naRoAWIETgAMnAAdOAA6cABw4AThwAnDgBODACcB5xwmy3nvvvTOjItYZTZujcd57S5Up3axe0OZo3I3vaZHnBTsnRuOOl01fmIFs7BPZ884R0eoE0dUwkL01WCXVjdMF3kzptTbP4fOEqKW+8JxLJ8J0optS9l5uQ7e04kzM0TknNVmitdaJQ5uxR1t1Kc+k35aM26dakucziM8OssJF0RcKLAJpDNK2OBwVS67c9gDKz1JXhsotl6UkVhfyjM+XcP3JJiNQkOczZNcTLSaMy95tQ1NzZ2ScWJvSrlQ20olLvSA6TSyT5xjKwtvOidfJOEFW6L6+MIv6hqvheSeElh+o3p8TT08QiTRkfe1V0bDOLsZ5/2knDnl+14kxrG92EfrCHGExUT31qtl+8pplJRe/2ZKw2iug1gn27EnujV2e1saPgyXv/9ZIwZ4V4MAJwIETgAMnAAdOAA6cABw4AThwAnCU+5g/prsjCF0jzBO/3URrwf/rUVMEJ2rPJbSIHAZhU7qDIwhdI60n6s8ltIg8xGeqf+oIQtdo1pj6/6BbRB7iM9U/9ddi18AJwNE5oT2X0CIyxnd1BKFrVPsT+nMJz0f2eQSha7BnBThwAnDgBODACcBp7oSXXuDLwAnAgROA8Qf3/bDeTSoBAwAAAABJRU5ErkJggg==" alt="" />

相邻的两个字符串文本自动连接在一起

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIQAAAAkCAIAAADHOgUeAAAB10lEQVRoge2Z3dGsIAyGty4KYma7SQlbRZpJMXwXKqLE3aByzsuYZ/Zijfwoj8BoXp/P5/1+vxwEXAYQLgMIlwGEywDCZQDhMoD4NzICSUqJYw5ETgXFCVv1SyUjGxu755Ia2MgIJEko1N3agl+oByCQLMeRf92Vffy+dpRRQq3conTHfmaoxu3BI2p55RhFFgrzbBGaIut/tbqxo+0MzFdLwjyfKQpPd1QEA0lKIlKVbLokO+oyFbnquyWoUT39hYz8d5KyVCib/T15LB1lSBYxa/HI+UYCSRGtSrZekpnDPaPTFNnVWp65NTi1o43gSX4sU5GXuVjK156PpWQ/DmQUj8mZoIGD4SYRCne6GFtG7ymxVlZrRhaiO287kMytrUuOImM71rnA/5Mxje6uS3uwgWJj1Rb0e3fG3NnU7HwotJ7h+NovnKGIcNyW7AXgS9+NS9RgIMn4Nl0eAZKMx+MygHAZQLgMIFwGEC4DCMMbeFvuYQdu8gAQZWZcyT0MlDwARJFxOvcwVvIAEG3PuJB7GCh5AIhpA7fnHgb6Xg2IVYYx9+AyrnBFhpJ7GCh5AIhBRlvuYZjkASAXX/qem3vowVkZj8899MA/hwDhMoDoLiNpP0fjD5BbxdnUaLTwAAAAAElFTkSuQmCC" alt="" />

它只用于两个字符串文本,不能用于字符串表达式

aaarticlea/png;base64,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" alt="" />

如果你想连接多个变量或者连接一个变量和一个字符串文本,使用 +,这个功能在你想切分很长的字符串的时候特别有用

aaarticlea/png;base64,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" alt="" />

字符串也可以被截取(检索)。类似于 C ,字符串的第一个字符索引为 0 。Python没有单独的字符类型;一个字符就是一个简单的长度为1的字符串(和PHP类似)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKYAAABRCAIAAADXfUqBAAADT0lEQVR4nO2dW5arIBBFGRcDYq3MhtEwmRqM/eGDV6HEYCdFnb3uR0Si6AZE6Loxr9fLAFVAuTqgXB1Qrg4pyl1YliW4QUeznvLDubAkvHmeIWWrivQYUbn1tJC3dUH6Ep/H07gbUluy8fAunN56yxRkQNnGVuoTslbO1rT+xJK16eyVY/3K+p3tc7L3yOySbCZpfsGNVF7X2lSkC+TtUaK0dEV3cBTTUwihuCLmMq2nZSGiKidbpIeoO3YXqtK8k1jkyHZvmy5k9SCKjAdccyZ7z9tAvLe9nXPVkhPlx8e0+PEz38r3M8YD85fpQp2zUaSH4J/lo5r7end2XYfxtB7UrYvd9fgdSWvN2rLTEqRFuejYXdg7BvYyk+Q95z/DKU+q553EPAN56yl4T0fP/IDy91s5dwjuK5627ibunEz54Ke5MS4EIvLW+EB09G3Jpab3r1BeVIdnBzcN5cYF8j5zYz1tm7FMjPLGZf6S8tVhUYj+xAbroMRsN8qmB6gHNmVi9vIUiHpP+j7peZjndNGVHbnX9G2TfNxTDFL3nHvK/rS70Rt9jpT38i8y8k3hF4DyNmdNXzBQrg4oVweUqwPK1QHl6oBydUhRXi+r5CtuR548bUua6R3rY+SulxebcbGqnLadbi7lQ+Sul7c3y7lrKM+Qu15+UgPOK4d25K6XQ/lN5K6Xo2O/idz18mr4Fo6HRcDw7QS56+WlSGZI2MipHCnv5TX9IqE8Q7LyjkkWTMXUyFUObgLl6oBydUC5OqBcHVCujqvZt2bg9f/FQ4OxlK28P/D63+KhwVhK5T2B162cQATVs7wr8JrPCURwPXxjA6+BXLqUozHPBJSr40r5pNGXmsFUjDqgXB1Qrg4oVweUqwPK1QHl6oBydUhRfhlfzoRDGPxRM8dM8eWtMmHGOGOa+HIo72Wa+PK0Yy8MQ3nGNPHlCf05VTJNfLlp74LyjFniy/OHBf5LgRMQX64OKe/lNYgvv4lk5Ygvv4Vc5eAmUK4OKFcHlKsDytUB5eromX1jQXy5VK7jy1sgvlwo5/HlP/F722Asl/Hl3/+9bTCWy+Hb93+JF4wFytUB5eo4V/4Tv7cNxoKpGHVAuTqgXB1Qro5nlS/cP/BV/gBGlVyHZWpVGAAAAABJRU5ErkJggg==" alt="" />

除了索引,还支持 切片。索引用于获得单个字符,切片 让你获得一个子字符串

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIIAAABFCAIAAAAJjKmmAAACrElEQVR4nO2cW7aDIAxFGRcDYjwZTSaTwXA/qDzCQ/RqxdWzVz80RcQkQgmkxgAAAAAAAAD+iWPvPbtMQuKVyLH3WtavzHvvhayS7V57N5Ykb9ZR4f2QKDMUp5bko0PH48bFgsaxFxrc4iEsSe0Q80JNcLBNJzZz389x7o9bYVd6eXRcdmMzZKeOM+UOW1qUrOt8Esfl23pQqEoUX39OHRe2SU+eKgwlbeG4VafUPc2PB2awldYXMoMx170W4UE3FUYr5Laxyo2tvtrEL0+ZYfSI5asweeHXyLz1jLAsIGRJmEhir3K7GXRX02qWr21Q1/kYF48OxjhmESFriEViB5OpIH9yPbiWJhp3SpY4dnRcmlm1k6Tb7gXMENqrfGReOKhVKBxEHacROo4tuagauMMYLVLcVKusMewnsR4rEiPTgn3uUBnMcJh6+vYvVpm+AQAAAACAIdWcM5s/Tfycm5xagz3qSGYWUdBhnZnLwRnqJZ069rYtDQRJOm5eDk5ReXxmhniYx+DKeNz+CwNOUcbhkjBou146AbfQUXQImMIK36KnacdCtLvAAi4hD/hrY2A4XgJ0SM8yekUAAAAAAAD4RSbyG1pZCy0am9XMOhtkXp7fMMhaUOT7B8e3eIg35zcU9x3mNyxvBmPMa/MbIioU2TRDLwiwkBmMeWV+Q2rOgaDvVJ1P8cr8BtPPWhgw3dF9l/fmN/SyFlp7TbIucbnct1fnN/SzFhru0smE0HWCGZDfsATIbwAAAAAA+EVm5sZHN88j6eE4w/yGyLFpDpIeDqOWdMpkn6hLEmau4gG9IAGSHo4zym+IpDhaKt5dRUDSwxXsdEpbuLQfvgZXADMsQQrKp5B/6z+kuqsI4BrUzpPPqZD6y832xhMAAAAArIdvfcC3qZUOM3T4A20GXHjDrri2AAAAAElFTkSuQmCC" alt="" />

注意,包含起始的字符,不包含末尾的字符。这使得 s[:i] + s[i:] 永远等于 s

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMwAAABFCAIAAACJ/561AAADs0lEQVR4nO2c65WDIBCFqYuCOCfdUEKqoJkphv2hKE+ddR113Pud/ZEgIVy8PCLsmO/3+/l8DABywGRAHJgMiAOTAXFgMiAOTAbEgcmAODAZEEeRyVyIMQaXpXiKddLoczHGSN5WaXsfvQOGzJ6icVn3yyxMZj219eYnyuOpav395vOU2tiFSH6jNP73SrMtc0MRp7QbqEcy66m1Pj+xZupKyY4265Pz67w7psyu7LpLvw1u12SblXJBymRXy+wqGml/nsmMMbPeeqDiJ1Y5isvzWxeKW7K2wlrglNMW/baZR35hMtvkPnMku1ZmV5Eykxlz3pA2tURquaXx81uSN1Z1s8p2dIHX+n01zczCsU4sGfany2V2FXV5rMmyLngkscxA3noK3tMyEVxrMhdi936cuia7VOZI0dHKC9Oa7ORVmTEuBCLy1vhASW+xmMhboWr96s4cmC49Dat47sL/MpkjRUqmy6maVRfhJw5YBnbraWnadUG8zEF5UrNOnpbERMWX7pusLJO51mnh5LxI5liREpNp44/Nd3/r81AvU7nJmtGJyUOeUvJQL1O1yYAOYDIgDkwGxIHJgDgwGRAHJgPiMJ74lxt4v/w53G73HoC5tQAeSmcka32RbXrU+2oV7VGHUx4GnmJVcBcdk7UHEtut3XQmakqZX1dnFtJHPIUQmkMMzUEr6ylGImpydqsEFNFbkzWjVWay5WW+xbu+7o9kyXBrwf2DVuvWcF2FnQEUPBrWwr/c5l0Tp/ueG2tnukynEgZnYLLk+hQrUAzXZL1xZDptUFyEyUDLX0xmXCDvCzdYT/PbderrmGxw0AomeycMk+UnnTrrrWpBXv271vyW/Hql+geLlDOlpFPM+D35Gv74MPb+s0rg+Rw12dbwBkABtpWAODAZEAcmA+LAZEAcmAyIA5MBcRSZ7Gh8MmPmJ73tGbknPn1hyqwVjcu6X+br45MZY+b9ryaz0vhkxpiRIk5pN/Af4pNNW6+SJrtBZqtIWZiCV8UnS3v2siPZlTIHipSZzJj3xCdbCjxiskfGJ9tQ1OWxJntPfLIqhk556cQ12XUyNxQdrbwwr49PtpFZaXyyUbqS6fJ98clMWYZk9OsrZXYVKTGZNtQH7uKhXqZyk8Vu393nIU8peaiXqdpkQAcwGRAHJgPiwGRAHJgMiAOTAXEQnwyIg/hkQBzEJwPiID4ZEAfxyYA4iE8GxEF8MiAO4pMBcRCfDIiD+GRAHGwrAXFgMiCOuMli7w/8J34Af785fY9/j4IAAAAASUVORK5CYII=" alt="" />

切片的索引有非常有用的默认值;省略的第一个索引默认为零,省略的第二个索引默认为切片的字符串的大小(include to the end)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGoAAABiCAIAAAA3ENGtAAACwUlEQVR4nO2c3ZWDIBCFrYuCqGeqoZkphn0wwjCAoKhZw/3OPphZfm8gypybLAsAAID/hnXee2dFhNjrUK2e994zGRVrVT2GIZZ9HA3eD7GSrz1/4k0k6zzTTmtXYIjzd6U/qFnf5U1oI5bL51ouiq2wTVdVWD3ONuXbHZR1t8v36Sdd6geDqkTy789L6xJN4zRig2tJk6yebPMekM9kpe+SrzqQE8twHfU29aCe1FROTKmdztm6lnx7s0mX3qHqRxGr40wwLcBkiB0Rh933rHzW+Vy7/urHuPjTb1msc8xMZiHHHDaimI+chpJPSXti8xJXh3i1fGvn6o3qD+60yrReBG3inSN8dspQdkNZ7x3MSadt+dI2m+rPxeD8Id/ZZ99bHpsBAAAA8DjZg7t4bu2413ceRX6XPLMhTk762NlTfS7yVGh+pt9Sc2skXherT0a2woR84VKe7dNzfnuBTkZ6vo/BVaU8DwkSKgKtCRSo16KmkHVM5PrSVtMiE25axNlvE4Ng455jb0kCAAAAAMxOp7/P7PgK0rbg78vnbx1T58M8/H0Fk4azOl4bKfx9WV6SKY8/LV+1z//t7wt1v7d5w0he6O9TDq3mJOHvK3f+pc37fn9fLC6KfeOz7w3A3zcE/H0AAADA7Awa9ODvGzPowd9X8PcVzlfMrM5XleqToRIb5dxcPL/rPAj8fZJKckmE9be0gQDyjVHOzUG+XvLc3BbZ0vBz32sBAAAAAAD4P1z5+317BYdSnW/39+VVqr/f19PFQV7u72sM5hnnxlv9fbuo7zXebHx5nb9P/9qXbqfT0HSJfK/09+1MplO7/jar/IC/b0nKlId4w+b9BX9faUaRWB6mv1umOpV8l+a5YfoDAAAAXgf8fWPA3zcE/H1jwN93ITCoDQH5xoC/bwz4+wAAADyJL/2BXnKxflS+P5HgLVsPEBgfAAAAAElFTkSuQmCC" alt="" />

Python字符串不可以被更改 — 它们是 不可变的。因此,赋值给字符串索引的位置会导致错误

aaarticlea/png;base64,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" alt="" />

如果你需要一个不同的字符串,你应该创建一个新的

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAM4AAABFCAIAAACNCk6IAAAEHElEQVR4nO2c65WDIBCFqcuCPCfdUEKqoJkphv1hQB4DDj5mjbnf2R8JQcVwMwjcHfN+v1+vlwHgaiA1oASkBpSA1IASkBpQAlIDSuhIbbLkvXczUxj4fMjWvAOzK9u1ND8pmp2XtX2peMe7vJJMapMlT3bKa8gLO9QdlXyUnahTs8KSam8Vl6veejcPNEm58f9PGdU68UdS2KIjzUJqIyLe6q0leoSzTUkYWiNqvFaoPOfR6hOBvHdzX2qtwtb39PNSM8Z8vt6yv+WFHLNrqbKQWqdmxXZvVSGT7GTM7DL9rSdZb2epmXzKDaCQ2gjNZ7WLwls8JNYvpSYgRhpfhib+QkEmUWlp/U5bpkwO5W9AKLUWkNpC8rvfU7jFQakFBL01O7KTJWctxREQUvsXaqldGs4Cq0CzAWwQSW/NzhGRnYx1RHEwJMuepJR9LkMMoIeoZqDeJ90wVjhEfDA/8IVLemuZZiwvoo7SdZZPYb70UkwWloYSZbdcz0DrtRsDqUWwhLubg1qB1ICUaglXDJZwAbgQSA0oAakBJSA1oASkBpSA1IASQ7sF9frkJiOeoCa3NbGBAZioJveW1UzMwuQJa5WnCBb8L4zUJN6yYO7KXheGiyANS865yoFROcYmS94TEefVGHVighvCPauJvGVpgFtf81EtyG49Me8YW3e0yyYMmNjATdmeFrRMNrE8rbAxgAZLRcPGUyh53x2Bm7JfasYsVolMXZAaaCFY7Gh7y2ZH1maamCx93q6DISO1hmMMUnsyonW1tresflyPc4Ol/POW7PpJ8X8koWYoCQZtzDkfxsEl3J8zXYHd7JVa6k6F2IAAbEwBJSA1oASkBpSA1IASkBpQAlIDSnyR1AQZztrHFW6Ra/497qCv7uG2PKX8aichSTtVHZK5STpnk1+3yUFf3bNteRfnV9POcNZtVLmver7U8l+gJe/JJs1Pbqew+nGHP43L86vpZjjrSK02nVyQNajw1aVNXm+Zt/oxhz+Ly/OrqWc4a7WiTmYjyQTocwZjTt7geG+s1e/xXJ9fTTvDGdcCPmnS9bnQ8iE7uTfG6vd4FPKraWY4q5u02s0rNKSWPYpmU+DS6vd4FPKrqWU4M7XU8nNKcvGxHIlqawvyczx6CsDxRetqNbfPcNbzEv/U4GnM10tt7zqsSoazGM/yy/yq1e+rpQa+CUgNKAGpASUgNaAEpAaUgNSAEoLdgnwj8Lz5+cPtWaBAlF8t2R0603vwbHsWKBDlV6v3wznTFexZoIcov1oiNS5rUHwNexZoM5YepohJpekK9izQRio1TiKV6Qr2LNDmiNQq0xXsWaCNLJVfc6Ujf7CHPQu0OTW/GuxZoM2J+dVgzwI9sDEFlIDUgBKXS81zf+AH0ZDaZgn4BSA1oMMfSosI6h1kmssAAAAASUVORK5CYII=" alt="" />

3. 列表(list)

Python 有几个 复合 数据类型,用于表示其它的值。最通用的是 list (列表) ,它可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型(这点和Lua是类似的)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOsAAAA0CAIAAADkAFh4AAADQUlEQVR4nO2c0Y3sIAxFqYuCkKYbSpgqaIZi8j4SwIB54xCSGWvv0X6smGCb5GIIQZj3+/16vQwASoGCgW6gYKAbKBjoBgoGuoGCgW6g4Gl83LZtCy4XuNAUnMf6OG1hj2e2+jD4ZDZ6O2ezqmuTuar0uHAq8krB1sc+UHnhH8PH6o77uAXXFp7EhejnLFgfj+fhwoQSRsFfecy7zSOk6Ns4meuvK9ikPtKYkheylH4XYo4y9c/orY/bFr0Lydz+E2lz7rPJYrrCVXmQ9G9yl1jvK2Dv+BUFWx+n+4ALpcnTMbQVqdFLuPCcgg+HzKghL+yspQtcONRmS/+k/YC0obTZOJcFSj0V17sD62OuQv5nvHPQ0S0J/sP9XKzgFPOCHDybNxvX1ocQLk1Ncmy5Or3Pjc2VCi6uliTjPB1KV9kq2DLssQrmZ05dgugkSIUr1OQ51io4N2fWQpl0xmGa+0DjuoyKc1MTY0yab3K/tDbXKtgFph/LCwfk1OiCVMEkWzeabYe4j0MeTdLcj9/NwZX/cZwyU2tmEfTRzk0o9vFA6G6ZglfPhElXyxqylVbJLCLnodRycmXzVtHdUzZPcN4XIVQwyWQzZs9W5+Za0upt8NVkrPwktMktq5BO0T2OFQreJdk8ZnkhDxnFSYvo2M693vnmvW4fHY8y2yQsO3bFe19CvxYxbKjUcWl/VSKozr3vnqg+CJ6+Bp8UcDuokTzSPbcUw9p58INcW4H6GqKwLy47frf6YzaNMVoVTNa8vxbDLN0XDY75V6AfqP6kzekx8hdyMADzQMFAN1Aw0A0UDHQDBQPdQMFAN1Aw0A32BwPdYH8w0A32BwPdYH8w0A32BwPdYH8w0A32BwPd/MJ6sNL9weAnwP5goJtfyMEAzAMFA91AwUA3UDDQDRQMdAMFA92wCsbJuDKbVd31J+MCCQMFt6fRBJyM29k8QrrvXFEgQaLg/xQKwcm4UPBdPKFgnIwLBd/HAwrGybhQ8I08oGCcjAsF38gVBeNkXMINJ+MCCcK1iOEWX5yMe9/JuECCPAe34GRcMVDwjci+aHDgZFyhTXzRuBV8VQa6gYKBbm5X8Mb9AbCKJxT8sQSAWf4BnMNnoI6kz2YAAAAASUVORK5CYII=" alt="" />

声明时使用[]和list()是等效的,同时就像字符串(以及其它所有内建的 序列 类型)一样,列表可以被索引和切片:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJMAAABfCAIAAABjrWKNAAAD2UlEQVR4nO2d27WrIBRFqcuCGCPdWEKqoBmK4Xz4YAMbD5qHrLDm17kG5YYpyGsb83w+H4+HIXDQHCo0h8rI5mYfQgjOxiPWhZAdWw/JVH2QmJtmH/w8pSnaD6Ix+8THNPtVkHXZd8tSdkFe56bZl3dY+0GVJWUIITi/F8F2e/t5mn0IfrZuu9zykZ/zs7cjMYVNqk1MKe8qNXdjTOFD/NO6mJeSsgvU1tK69MufPFhcbUtg3VrK8fY20r9edtbuYmROMeslg2n2+ynibyX3jbq5o496ofqce2Pl26rXnmpKSsK6Q3OiJoXUXHLHyGRJ2iL3nZ80Z51Sk9oPVtirgnWt5kTtzFzlD6Pi4VTNfePXWst3P+mimFh2U1JKorVcC3958mUps05RYUpkdJz7RtFDcesF4196yi4o+payI3DyoI5orYRm2YZp3ZY566+EELzfbpS0ZYwClaz03BdyH7IvNB2m7IEexnN3lUt7vjRXECtUS/V9M+VIXAFjJE6AoDlUaA4VmkOF5lChOVQKc0svuL9OMMnIzC2zhD0OPEmG2lrSHAA0hwrNoUJzqNAcKmXfsr6eRXqCI3FUaA4VmkOF5lChOVRoDhWaQ4XmUBnZXNOuPXXBsoetfIyf+y9NdcHy5jlCxs+1gGDOGDNq/NwBMOaMGS9+Lj8/uTiQuRHj5w7AMDds/NwB3ZsbPH5O42DBsidzN9F//NwnTn8Vxs9dKf7uRuIECJpDheZQoTlUaA4VmkOlEj+XDHBrM4fkTtT4OWPW+cjlYDZJT7qg3loms/U01x01c3JOWLaWDDXoBdXcsldBS67Ox5M7KM1ZdzSLyACtXlCisHI1Yu20WOIit6Gsz5XLUfUXP5Lb4EgcFZpDheZQoTlUaA4VmkOF5lChOVRGNte4a09EHbWk+9bsIOPnjol759sm2783r8v4uVZSc7Vvf585Ywzj5zImpVnt1JwxjJ8rbsfeW8sVxs8ptMX+3GeO8XPp6aLuitM7ay0ZP1dSWZvszNxNgMbPfe2aOoyfe1tJ3zkSJ0DQHCo0hwrNoUJzqNAcKpXfCMm7t9tw9FqXt/qbdttlLywYNcf59fAGjE/Q8usucZL+UkBI7RWRryzxnY3z+8FwiBZzcobwchHkJ/47QdxKU5zfoOaSOne1nhTXdM691ATv/7eWOL9BzaWzvu8xF1fAX4jJa4/zG9Zc00fHlOb2W+Baw3kqzm90c9p+gquviEw2HMSPGq95Ns5vUHPaHh7TLq72ikixteekuPNxfoOa0/nExr2PbQYcx1xDl+8Twf4fuuY4I3ECAM2B8geZSFz/PCYJGwAAAABJRU5ErkJggg==" alt="" />

所有的切片操作都会返回一个包含请求的元素的新列表。这意味着下面的切片操作返回列表一个新的(浅)拷贝副本

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJIAAAAjCAIAAADwj8QJAAAChklEQVRoge1aW7LDIAh1XS7Ime7G1bgZFsP9MCoabIjmUb2e6UdrFAxHqILq8/moheGwaBsSi7YhsWgbEou2IfFvabOAiOjM107GoaDXC0i0aQsIVueP5Y2jwYKUDHnP55B5m7awX1vyRha+JyKig/j+2ypGsNoCIljjgjj/CGw5OrSkHiZzmNSTLilWu1KKI6P2Tj9Pm1Jqs0rpTPLGnbTQwbjNJtpCMA41FLGOcZEkYyIrVFNS7RVoC3EI+c5oD5iNNqUudbvgWLGXzsxg3FfaiA9hTlu2XGi3rO9Oe8REQXKDcYwPyRsriE5gnJQ24pcFUQVtu9917QFT0Xb1v1tiJRlOZwSRILlZ3v/bFT2LXdCOJqLou/aAWYKkn3X+bicaeZAgRSxCQxe3T7HFBgURAYJN84CY2GNU8do9ZqHtJbxllKmC5KNIriRx3Isxy3F7YSAs2obEom1ILNqGxKJtSCzahsSett3O2O+CuzbB2kKzhHC6bhtenXwQ21CBIgeXMJbPnd53fuBoKzLl6EznkdM4sG0SUuKfzV4doTb5noJhypMaRwtMNYG3nNYPaevX7TOLbRJo7rF5DuXAw7yzFFmlYi7aQg73Am9r9ZBCtbbOua7IG+cWh9Mg2VwhOoG7aYsru1UCTSZfQ1uqpLdFXqVUuJjBPSllDklbka5vktE/h5K2yH9bvPSeL1T3W7SRNStCfcmLwF1KaE3hZ7cW0iOhTG5TTFZCRz32BCQ7yWrJTDqfVEnLWgTDuStAJ4ZXJk9vBp1krbz+QMqwu/1/mMN73lai887du8Mfk6mUepA2WSGq7yD35vAnZT523F4YAIu2IXEvbch9FvpxO22HLQvn8QfAr1rCcNQawQAAAABJRU5ErkJggg==" alt="" />

列表也支持连接这样的操作:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAS4AAAAiCAIAAABul6PbAAAEFElEQVR4nO2c3ZXjIAyFqYuCOGe6oYSpgmYohn1wAAEiBuRxyPp+Zx8yxEgK5iL8o1W/v78/Pz8KAPBZIEUAtgBSBGALIEUAtgBSXMb6EEJwJrcYF0IIIXirmSPb9kG09aWfZLBonIINqXU0TP7pTeNykHz36KloZxpfTetDdDeFFLX17XQZb/wvsH705FVHGhfPu3F0AohHyjhvqS9t/ctg6WicTki1o5kQX4Hk2JSyPjgzMZ5tkG13fbS+gtVvGqORL5Wiei2M9Qkeb2TRcQkOzqehIRnE+hC8NS6aO76K62vunVfceIQpMlM+ks401nufZSlmqEKayTGLtr6akdTkylTrhNQ6WjGpawNCMVTdyZ/GxfnANl7i/VbYDapxzG5qvLGxFg9IiSOvY4oKmh9TY5LSqKfs+nCgrU9dyGfG+1tEUtT1plVb55xgNxl/SDcrzmdcPiTO0Vyc7SKo1LrBTnf6Z/rMNl7i/Va614oXpseYANNR5dKZkwgrRZLrQinF9jqHQhVYeD8Nkp9TDSNZMaf6pd1k+o2lrxSr935aimxIHUejaOtiGHHhjECKo3SkaBwzFccbO6RkZdyoFEn+rMRX77NOt4I0bfa5YINKvqKjs7BXLZYXLviFqcaGdOroLE5y4rBBXaOV4tVXiyQbJDHoYvTIBpXMjObI6mZDM7PZtMN5f8uqFMkMNy7wW2V6vTe3Y2Wj4nbsAzY7IbGOBm0SO+dSnPrtzW2bmH5JImYbe973pbmD2iyK4408xc6vEGB7NyXfy7HVTZxjN/Zq09UirvuueO9vWM+KneslcttoTYn1cwLuPtacTS4kxtGETe4qoLxiKM/8gE2+OzvIf3aleis7PFf8pvEirIf9F4+CnmyzzzdNrQ9LMae86euTj9M+4h9l9XkgbM45Wj0/n2GHrAgAgBQB2ANIEYAtgBQB2AJIEYAtgBQB2AJWis1temHhmVKiWjhheV43eEEZIXkIE/v23pWdN4pyR9q4HOS3lTt2pFifOScoPFNKSWrhhOV5veAlT5rze7HkHbfqNbRZUO6oyjF8XLnjiBTfNA5yTS2cIIa6o7iMkBo6PgmlSE2i3DHxoLfJ75CirBZOWJ530L5VLCojJLGl7nSDumgT5Y5PLne8QYrCWjhhed5Bv+Bg/UWs421K7hvZy10odyRAildKUVgLd1EMtRQlZYQqZpRBd7Og3FES4Zvu/+0GVVh0N9t9sTyPcy0sI+TuFJIpWhZGjtlEuSNv8kHljoN3UAlk1CbGZL0WTlie1wleUEZY/9cdsQN/wTM8Sih3LE0+rtxxPCvWCAvPPtsdNmFzgB2k2Cx5LcLCs892h03YPHU0IIIrwYtvAGwBpAjAFvy5FAP3DwBQcYcUT1sAeDz/AMGNl+C95n05AAAAAElFTkSuQmCC" alt="" />

不像 不可变的 字符串,列表是 可变的,它允许修改元素

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOkAAABECAIAAADr14WEAAAEzElEQVR4nO2dXXaEIAyFXZcL8pzuhtWwGRdjH3QkQGDCX2vwfqcPLR1CwAsiRGb5+flZANAItAu0Au0CrUC7QCvQLtDKQ7Rr9uPYzX97sZj9OI7DbnfCZoOEMs7s1VX7ZD92swYpR4tfZzVvs+vnb1pSuZ+BN7HziYKuD5ZXxml3NXvsuTyxlc0+QrteC5r9sFuYKGez1wVZzV7RXmfpl6GrcUgrrZV+xRevzr3AT7bploU6nyuopjLeuHv2i8CIPJHH9T9rrVnPv+12/4dclbtf3oZJTyW1dql2rxUWC9uCDdr9+FyrM2opSKo06XzyTLUPRWl3nPMjtXsVxdw65ImRTx8hktGaOHpX7DL2+X0361XX64Pkd9f+m810IHqHEt5k+2qXeNCkDVamdV6txlqbGSDqp0cpf6jzmYL6aNcV0j4AJwaHhHa9eeZu1kh8VLKtbc3SV7ursfc8dav18+zyTGqVU+6mFzS4+39lZVmHeOe5gnpp9zPsVSYS2rTL3uBC++lZ8r+Pu141q6XGVvBry6QNkuc+xkaPyrqyMg+p0fy4WbvdZ7x0hnM33J1IlhfOmq5+rm9jQ1a7FQi1S0avHESwnnaF2c2e/FQsO6FNf+p1D8BkXk7aU2rz8jZ8VouyJguKs4vw1xmijiJPTMHOcdzakTnb5xQxMz30FoXutpaPpGUwF4ApSnxN+bmNLHt416AZ4ke3ApmRB914Hkq7hNQm00op59MPAP3mu29F1IKNS4QjVhi12EwD7bYS7U1w1D/P9Miu2maqoLo7KLQLtALtAq1Au0Ar0C7QCrQLtALtAq08RLu94nfjRS63DbIGSf1XgIK42JM1sz8GWpgsfjdY4nZxZtFqZWNUIlc02yib3U33ssCyTBe/m1TJaO0mgmPOYCRodwiTxe8yKln5zbKveioKQ2PjYm+fod0hTBa/+1/jLhsXe/cxaHcIk8XvZlRSGjBaNO6ycbGegQe8jTcbk8Xv+ookiiJv/HGfbIaJix1WFjiZLH43VEnfgFFhRaOlDoy7Q3jI+m4v5IrEWKie6bSbn5cuyzJwbwL8KZNpF7wIaBdoBdoFWoF2gVagXaAVaBdo5SHafcj5u0ATk8XvghcxWfwueBGTxe+CFzFZ/C54EZPF74IXMVn8LngRk8XvghfxkPVdAIqBdoFWoF2gFWgXaAXaBVqBdoFWoF2gFWgXaCXWbvSa+LkXUL0J0Hi4hgtDc2cmHR02J3qflcu2Uuy8t1cTbcFgp6UETrvhdzu2nMJ5b+DWfdG9C0NzhzKRSN/ar4TuflYu20qc87l2wHEnZXzVbiZRggunqdUZtRQkVZocdlZuOq9zHtrtxmjtZk4EKzUTe1Dn1bizclN5qfNsfEc+O+AZrd3V2HueutVemTNsnUmtcmrcWblsXt55v/RMdpBktHa9UN1qqbHX/mt0b9rgoLNy41ZKOs99Htoto1q7wm+oJ4L1tCvMnnnuj6UrtFl0Vq7UJpeXc550nJKDrwGDZJ2BW5ESX1P+/RxZ9vClH/9c6HA8K5CZ+KxcqU2mlVLO/+GRwJMjHHdDGl9zH/GWvBabaaDdMgR7ExzsyzhyGrOrtpkqCHsTpWBPGGgF2gVaGavdg/sBoAvQLtAKtAuU8guMWGrI1miVtQAAAABJRU5ErkJggg==" alt="" />

还可以使用 append() 方法在列表的末尾添加新的元素

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOQAAABDCAIAAAADLD6MAAAFWUlEQVR4nO2dUZKsIAxFXRcLourthtWwGRbj+9DGkARFtHsM3lPzMRMFIlwjamSmf//+TQCYAGIFZoBYgRkeItaQ5jmFv/biBnyc5zn60uhCSsEVu8zzPBPbauQFp6Vn6M4+0mLvYhOrC2kW/dBuvIqPQ4h1mqaQmOZ8JCoM6fOHj/n8XIyi4KR1dFHbuygiqwtJnt7tRp0tkMQYgyOxZ9myDpiPKbhPGMkVZ0sRhzZrTGKApZuklTWEZ5+WwqpRbd2FNM8pJeESKcw1V1UXPz9lQTUk+Hh/qLCBnAb4yK5Q54yMLZCQeExGJQ/YWtnn9xTcevlcdyS/b4Po48EZ431unJYpgpurGKutf/bMKnRFuGQu1bTlRCBlBhdijPzsLdp9G/qc9a4QKwdkmqaqWMmuPqbgSGDj87Zs2h81WgMpzBs61TqJd6vz5VFyKW1CZo6JaQ/rLKJ77t4Y8/vTaGJVY0G7kXBNrMc3EzT4qVtznTQa0yJZrNJYvQpfFauP+t2kFGvRkis21A56ZJhYb5+10vvg3PvZSB4CLCPoylLqBY8YS7Fyl4iIyJ1K0dBHBDWjcnxSrIVaxcyEndAhVXuNn9nF3GPndHgN5dMAcca3G2vQq2kxosuVNcT1pmSeUyC3Q47tScorJtoUtWw3dylv8pE0tE01FaPS1Odoos/byL3i8ndij+GotvjcYt1QWovTTR7na7X6lOesP0R9RvbVB2f3quu9Wn2dWLVQpRtvpHwpcA28FADAABArMAPECswAsQIzQKzADBArMMNDxPqafNbiNUPDo7JLT4W3dy/kVa3hJ1/IZ72d3XxWcpiVxImtmPd5/0/2mG7Ui8vsMPGHMZDPWjOqrd+Yz3qk1SIIk3QExXiAkrNlM7gin/Wv8lmPtEp75Xy/Z7flbMNubEU+65/ksx7H1Wk7B4qXtapxH+aR3QxD5LP+Pp+V1fIDuINjiBX5rKXx/nxWUcmXIM0ydY4wDUA+6w/yWbPpB7HNKd2pu2OFhzxn/SHW81kv8ihnTvI2sZrPZ73IIC8FAHg4ECswA8QKzACxAjNArMAMECsww0PEOkw+K/giyGcFZhg7nxUMxeD5rGAkxs5nBUMxcj4rGIyR8lnB4IyUzwoG5yHPWQE4BmIFZoBYgRkgVmAGiBWYAWIFZoBYgRkgVmAGKVaxltfyEL776fv2AuBScX0hvX6/Pi8gihe6buf//zX5KRe75K1oy291NMRKV8dIPcyTLfGyspfUhWDvf2mjiVVZqqlpyTsNutJeR4cVy/ORZMJ1c8vyZpVqNWeWdVl6alR7SXP+6hoCap21MbqSd1xZ3nWSvVTfs182OodivdjqlovSKyxaEzN1VlnJj1lqu+Jlvezm/H0LXvAOkevC3tNQKcG9XrIu1tqKSx3VSA/6vHIhxsizvHNOzDfESp1XcyU6kB3CDPphnm2Dla71kroQrDmxuhDzXHN3VfH9SpIy5e0N1WS93y0U5DB0u1h158vWz6LWKf8DfPXyfApS+qCXrEfWInW1W1vqYPde5mgSLul9ctPWm3Yoe6nqfGX/Fmp1SrHKw+wj13zYS2LW/gyxqv+WREIUWoi1sfjO3bkcgMY6yy9kDq5crXVqZTXniYTKZNzrHaJcmrXDbGuovrwrb2tvz1+Ltfy0pMxIbfFE/wSlrTj/roUWkPdbJ3RFvjjUn8CcrVPppZrz+iT+UodUxkg9zOZeqt5siF6q35b8TWTlXPwa+xsfc1up8yUNTdP0E7GKiCO5uCTtN1a0tVLnexpq0NE58LoVmAFiBWb4rlhn7QeAPr4u1kMLAI1ArMAMECuwwn92wNa2h75SdwAAAABJRU5ErkJggg==" alt="" />

也可以对切片赋值,此操作可以改变列表的尺寸,或清空它

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAWsAAADBCAIAAACG1AYTAAAM7ElEQVR4nO3d65GzOgyAYeqiIOqhGppxMdkfhOCLbAssh7C8z5yZsx8LKLBYMReLYQAAAAAAbKbl9Xq9Xq9luvqT2JpdvFXj7JTbqZ9Ts/jsXi83fyGQyZxHF5+W4Df33qJ16uv1er3cPHYMpJzz3Tit2uY4u327jk8smp3iU47SXOLEHyB8rOhgL9DPqVp8WjIZxDqQxZzHFw929Z23SD6Wr94i0wYmJjT9xLzoUwq5eOurvPwuizhRTuXrrG6ews7BPuviTFORsN+TxLoHj1r48RRcXHxa3PyJlexow0CD9ydxy7LsvzIP9ImzTMGutg4kHUtdAu1xouOh265z8xzkjEwg+6/oaUn25pGJovgg+OzB6GdNHyS3uP95pmX9WNv/199l99QY/HlVPTvps05LtNg0TfvHHEtzHhMt/t7u7ecwuVgGGma3/TvNYoaBxj1O8sVpHShzLJnvuiHbn+6165LTWzlQn06+dWfE/5RJc90ORF0GyS7u54sPrxdju580+93/qA3fMlXhkSHsBSPfOqMc4/OWXlELx1KncL333xi1tNzprafHh4q+x45OFESHhLyMsg+SbyGltlPcm0Z9kHSl2zz9WvW6djLIOX3/LrFHZJBOV0LCT5k5JvYN9k45hInZQyo5Hrw5dXtTT5VBtlk0Z7oNF9Smxfv2jE+YLAMFK69+e5wP5LeD4ulna6CD6anxoqc+gzTtuu04Xw+L6hJ2GWRNCcI1P91EWXQtVLxuum/AfpkuPMNOT1fixcfoQlUxjAXNft8/uatm2/PHzHq66120Laeqtlbg7+d+7To8+3T529XtgY4cIy2BwoZQaTtNW+TdPFiyN+k8P3qz89/r0Pf7SoeaQM8JpOvzkEGukT5R1qTnyT6BnhVo7+6o+qP/72lPAAAAAAAAAAAAaP3X+iAAQtQHAdCE+iAAGj2wPggAU9QHAXDW4+qDALBBfRAAp1AfBAAAAAAAAAAAAAAAAAAQSt9joH/89OCQ3criyauDewUymfPo4tFrhe69RdJw6Su3iPcYXEgYnaJ/h1bjewHjxafsS7eMA1nMeXzx+P2wt90iuYrL1VtEaZlrCPs9KSm0f+UID7w3vG4rXnxa3PyJlZQYMQw0+E/PL8uy/8o80CfOMsVFD0wDSd2CLoGiAQX9An12nZvnIGdkApFBriHt92Qw2zR5A9/G0pzHRIu/K35sP0fDZQwDDbPzxvL1CzTucZIvTutAmSoq5rtuyFaS67XrktNbORAZ5Bqa/e4PZOv5KtHwyCiN3m/zrVqKY3ze0itqoYpKp3C9998Y1ZjhndI/q77fvW+Djq16XTsZ5Jy+f5cYGQQ7VQbZZtGc6TZcUJsW79szPmGyDBSsvFo36Xwgvx0oCi+27boDCzZe9NRnkKZdt2WN9bCoLkEGuYZmv+9XHV31ltv5Y2Y93fUu2ireRN5481BVSqQpkF930eVvV7cHOlIdpSVQWAKm0rCbtsgrm71kb9J5yCDXMN7vjRfkCUQgcT2Kg5QMco30ibImPU/2CfSsQHt3R9Uf5YkyAAAAAAAAAAAAoGS7Afdz99WSm9bi664E8pigbrcPdeVavA8/78+zG1foCJ8dO1dBRhMoGdRTrKLCjdtfIT7to59YpHq2R/neXCPReoMxs8XnHZPhyNl1mlCUawlfEprkNcMKHd5fI3z03zqQv481VVR4eOw3dHprbvIHFkpXRK/HXGcXJ8qVL9ZZ3TyF39neg9AuThm5Tx+UNUo39PoMEmXwwiC6DjVH/C7J/jv7miNuHqUtoxTI73vX5BhPThTFpXTE0hXKPki+8sX+ebZDbz8Ek2FsuWMuCihmELEnX1inuKy8ikS1XEuxl2ZcCiQeIBuc4VgG2vZTenRRCuQWrDsj0YEXtqHtKNFlkELlC+Eryx/Hpmjt6zdceVvCtSv7NedpstLXWk8+gxjL9kGy85NBfog4ul0/URCdysrLKPsg+cOqdMAlFSXSYMox44WVfKsPEvpiKZDsWYy1aiWHZH4yyG/odCUk/ANnerx7Iw8vDcYTsx3m5JD25qxlkNnJG5Nsppc0FVmpnWadUXGTfiP5w/ImXyrXounrkEF+wNpWhMrJuomy6FqoeN1UuF0Y1SlNT1fixcMv90qYYRjSSzOZjoGQKP0y02ETuiqDfKm4SebCtnmgtKdGBsHPuay1X7vO25UC0SGD4Nvsy6CYru+Dci31QH32PAAAAAAAAAAAAPDP/Wx9EACmHlYfBIC1J9UHAdDFQ+qDAOjmAfVBAHTyiPogAOw9pz4IAFMPqw8CAAAAAAAAAAAAAAAAAKhKXy+gf/z04JDdyuKzyz63ZhtoGIbgybV5f7jVOFD4hN25nawJlIweKr5DqyFQGq/Xrjs0J6+AuJAwOkX/+rGWNx0Ki09L7slX80D+c/TJ8692gfyBPuGoIutA/osjo3FJtoGGXBWXDoEOzUlpmWsI+z0pKeS/+LE85zHx4tPi5k+spMSIXaDCmDzjLcq/vNo60JpBhC2zDxQMKOgX6NODc/Mc5IxMIDLINaT9ngxmmyZv4NtYmvOYaPF3xY/t52i4jFmgYiE02y0KY0XpxDTQ1rDFEdWWgYbsDjQNNM5u+2dyeisHIoNcQ7Pf/dPsni9HDY+M6tviz/pmKcV8BjGW7YN08IUdGO83xcBOMsg16vvd+zbofIR+KYN8qZ0Nw1A4i7EW9w57IoNgp8og2yyaM92GC2rT4vVxqk2i5cqdv/Jq57slkN8SqgnEaouqLbzxoqc+g5wP5GWN9bCoLkEGuYZmv+93Pl31ltv5Y2Y93fUu2pZTVVsr8E/MKitpTImZ27mmgZK7ub3+RvEmVRp209/IK5u9ZG/Secgg1zDe740X5AlEIHE9ioOUDHKN9ImyJo3X4wlEIH/xI/1RnigDAAAAAAAAAAAASrYbcD93Xy25aS2+7kogjwnqdvsw/pzcp8SPEp/20U8sUj3bo3xvrpFovftQn2kpP1iZDEfOrtOEuE6elcJP6vTW3OSIFypaiY97Z54BlwpirbO6eQq/s70HoV2cMnKfPihrlG4oGQQoedfkGE9OFAVHvD+wMvpZ0wfJLe5/nm3I2j50zStCJnykfEAxg+QGm1QbdjpcpZqFySC4IevOSDQyO2xDWyPXZZDs4uJQV68Xo2nt6/lZeVvCtSv7NeeRQXA7UTWwoxMFUZ1OeRllHyQ/JL40WD6pKJEGU44ZL6yEPgiertOVkPCIz4yv2ht5WPc4npgdnpVkEG/OWgaZnbwxyWZ6SVORldqRQXATa1sRKifrJsqia6HiddPkTmV4cUWYmC4efrlXwgzDkF6ayXQMhETpl5kOuzxkEOApvtbae6yTDAJczL4Miun6PniiDAAAAAAAAAAAAEAXP1sfBICph9UHAWDtSfVBAHTxkPogALp5QH0QAJ08oj4IAHvPqQ8CwNTD6oMAAAAAAAAAAAAAAAAAAKrS1yDoHz89OGS3svjsss+t2QYKpoZPr3UJpJyTFzvgjoTRKdOiPZD1c6oWn5bck6/GgYYhV4qkQ6BDc1IfBTcjHLJJSSH/xY/lOY+JF58WN39iJSVGDAMN0VPx/QJ9HrV38xzkjEwgMghuRjpkk8Fs0+QNfBtLcx4TLf6u+LH9HA2XMQw0DNlyaKaBxtlt/0zO0eRAZBDcjOaQ9QeyNXxBV4WNqjR638AXCiqOUaEUxehEMghupn7Iel+knVs1GYQMgrtRZZBtFs1FgoZrkdPi9XHiEybLQMNwJIOcD+RljXXbqkuQQXAzmkN2r9nhqncrzze39UqBd9G2nKpaEkhYx6TSsJsylVf7ecneafKQQXAzxods472MfxxI1+chg+Bm0ifKmjTeyvh/gfbujqpTxRNlAAAAAAAAAAAAALrY7l3+3C1J1U3rbvdT4+jcuMXtiQ9K6ScWqR6LUr4314h+vT0+gbhOHh7DzXV6a27SNoRiYNHrMdfZxYlyLbF1VjdP4be79wy5Cz9D2lxz20QGAQ541+QYT04UBW3DH5Ma/azpg+QW9z/PNop3H83rvcxb+Ejbys5lkPClvarTETII/jXrzkg0qD1sbVsj12WQ7OLi6H+vFxOtm7MYoJOoGtjRiYKgbeTKfCj7IPkqIaX6IUkxDsMMQh8EeOt0JSRsG5mhaXsj9045hInZkW1JBvHmVGQQroMADdYGJFRO1k2URddCxeumyT3NV1wQNT1diRcPuwGVMMMwkEEAtOA6CIDzeKIMAAAAAAAAAAAAwKP9bH0QAKYeVh8EgLUn1QcB0MVD6oMA6OYB9UEAdPKI+iAA7D2nPggAUw+rDwIAAAAAAAAAAAAAAAAAqOJFBADO42VIAM4jgwA4jwwC4DwyCIDzyCAAziODADiPDALgPDIIgPN4ogwAAADAc72k/wBAhQwC/Hd/841935oKirsAAAAASUVORK5CYII=" alt="" />

允许嵌套列表(创建一个包含其它列表的列表),例如

aaarticlea/png;base64,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" alt="" />

4. 简单编程示例

aaarticlea/png;base64,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" alt="" />

. 第一行包括了一个 多重赋值:变量 a 和 b 同时获得了新的值  和  最后一行又使用了一次,这点和Lua是类似的
. 变量赋值前,右边首先完成计算。右边的表达式从左到右计算。
条件(这里是 b < )为 true 时, while 循环执行。在 Python 中,类似于 C,任何非零整数都是 true; 是 false 条件也可以是字符串或列表,实际上可以是任何序列

0x3: Python流程控制

1. IF语句

>>> x = int(input("Please enter an integer: "))
Please enter an integer:
>>> if x < :
... x =
... print('Negative changed to zero')
... elif x == :
... print('Zero')
... elif x == :
... print('Single')
... else:
... print('More')
...
More

2. FOR语句

Python 中的 for 语句和 C 或 Pascal 中的略有不同。通常的循环可能会依据一个等差数值步进过程(如 Pascal),或由用户来定义迭代步骤和中止条件(如 C ),Python 的 for 语句依据任意序列(链表或字符串)中的子项,按它们在序列中的顺序来进行迭代,相当于PHP中的foreach

aaarticlea/png;base64,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" alt="" />

在迭代过程中修改迭代序列不安全(只有在使用链表这样的可变序列时才会有这样的情况)。如果你想要修改你迭代的序列(例如,复制选择项),你可以迭代它的复本。使用切割标识就可以很方便的做到这一点

>>> for w in words[:]:  # Loop over a slice copy of the entire list.
... if len(w) > :
... words.insert(, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

3. range()函数

如果你需要一个数值序列,内置函数 range() 会很方便,它生成一个等差级数链表:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAALQAAACGCAIAAAD7HTfDAAAEcElEQVR4nO3dXZKjIBiFYdblgqjq3bAaNsNinAui8vMdQ7qNic771FzMGIdoPAIKie7n58cBJsIBiXBAIhyQCAckwgHpjHBMIc0PKUzHlRn9sWt+gSmk9SMqPrbic/PxsM/wqS0cU0j9sRtfqE0hXebgfJiPRY7LoKh13quqOXJWm7ceX2gp0j/PKVT/vTolfMz/9PmlvaLzqiNv3685hTTPKaWRiszepHLbn5S5vH0KIS4F7FWj9XEX4XA+Gts9fEBe0TcrPhrbPb6w19Ucxd7Vdf5W4EDlOV4fNWv6uHyKAyehsUnerympot2UWexaSEuSppDKM2T9+1JIuddls9LuQLfZJ4VDvtVvq5A2HPWBL199qT39QziKY1ofnl6/SWZXoC+z2uslB1NVkbanlu4c1XHwcX622cewwmHWW+MLW7cKR1nVNQUNhGN/D3d6ztUufCocb+h1WM1KsW/li9cIx1JY2S03yixaDR/XDspeS1afanXjW27nB5qVXHzzYY0vtC1dMqMHV1esU9Nz3clIXebeusaay/tE/7RfKzZpLTR3QaOXZW4FxLilsNqorjNWLjC67cZa5bqn9DlwrNGr+ZHL1E9dyuJYWyUx2lyqy9eyzE/cBAMahAMS4YBEOCARDkiEA9L9w3HEfI72CrMv88wrzNPcPxyD9u5Tfdm9qdNcLhx5+Hu9vbQNguV7TfXci9H5HM199uYod2Oi5l33oUHIa7lcOB5HZzv65Qy62ZwOMjSfQ9cc5lE31r5f3XHNcFQnsjU0WhkaldXhMPssdjjOGUk/zSXDUY9fE453OWE+x9Hy7AgjEH8NxzblotovmpWHa4QjhW2qxTZhs5978dp8jm2iRj9XtpnnakzzuGE2rt+snPOOXMpewja76sRD8V3TLE5zuXDgPIQDEuGARDggEQ5IhAMS4YBEOCARDkiEAxLhgEQ4IF1wyB5nIRyQaFYgEQ5IhAMS4YBEOCARDkiEAxLhgNSEY/yBBLi/MhzbT5Lc8lsYeFUZjuYn6j+zQfgeIhwv/Ow8botwQKJZgVR3SOP6gI9IhxTGAwBf+ZV/3Bk3wSARDkiEAxLhgEQ4IBEOSIQDEuGAVIcjT+dgVAXOuXZsZY6eITcs+maFcOCBcEAiHJAIByTCAam5WtFPwcP/h5tgkAgHJMIBiXBAIhyQCAckwgGJcECy5nPwpSY456z5HM7d8bHs+AXRrPBFaohwTAy+wVnhmEKiTYFz5g/GkQxk7ZA9zQlWWzimejoHMQE3wSARDkiEAxLhgEQ4IBEOSIQDEuGAJJ63wnwO1OHwcV6ft8INUohmhXDA9eF4jLAQDVBzYIe6WmEuGMpw+LhepDDBGI7nrWAHN8EgEQ5IhAMS4YBEOCARDkiEAxLhgGR/V5aRFTgjHD6mwMAKnOvCkX98gXDAuX5sJQXHkCyyeprgY7yNcMC5nacmMGQP81KWmgPOmVcr1BzIuAkGiXBAIhyQCAek94Zjtv7gKt4ejqdL8LUIByTCAeUfZ5FkG2BbOccAAAAASUVORK5CYII=" alt="" />

可以指定一个不同的步进值(甚至是负数,有时这也被称为 "步长"),同时指定range的重复次数

range(, )
through range(, , )
, , , range(-, -, -)
-, -, -

需要迭代链表索引的话,如下所示结合使 用 range() 和 len()

aaarticlea/png;base64,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*BpBQhkADCjjS/w7UynX5Wyfojv7fzilbHAOIXVGTH+XKsSowEwiD6+wDD07yR3q0DuCbX7pseFGQxyTAX0s24dt48Fji74oQJgEMWMIPpX2kkuuRYPw6BXgW+h2zKlfFG4/eDohRkBGES1OhiHCs12Dy9u6iXZiheT1NLmZSxR0u3J5Z3qIgJgkTfEF3gMRABM8oL4Ao+B1RDYBAtiAOugAgDWQQUArIMKAFgHFQCwDioAYB39TuFYO6JIwYH4AgqmUD0ujagBAIdRWw05H6ZLRxafji8gZlez9idqAMBRlPEFZued8yqgiy8QWyov9dhsf6cQ2RqHaU1cZEHUAIAjqOILLK47FxwKdfEFnIt8hcbvp49366Gm3+G984lSZO4FRA0AOILGs3idWfd1Ky4zjMMBbCrg3ZZyU4Ej7sP4CwM00KhAEqqja3fK4wKtxa4dGxUAuBttxLFhGOQwgf3iC0SBQ7bJfVUFthru+j0xIwBooY4+usUiT670jC8QhQwI84bf98J3KTBMcVABMeZBrTBEAKCKgfgCiABAk78fXwCrIYA2WBADWAcVADDO/9Xy6YubR5bZAAAAAElFTkSuQmCC" alt="" />

4. break 和 continue 语句, 以及循环中的 else 子句

break 语句和 C 中的类似,用于跳出最近的一级 for 或 while 循环

5. pass 语句

pass 语句什么也不做。它用于那些语法上必须要有什么语句,但程序什么也不做的场合

>>> while True:
... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...

0x4: 定义函数

def fib(n):    # write Fibonacci series up to n
"""Print a Fibonacci series up to n."""
a, b = ,
while a < n:
print a,
a, b = b, a+b
print # Now call the function we just defined:
fib()

关于Python中的函数,需要明白以下几点

. 关键字 def 引入了一个函数 定义。在其后必须跟有函数名和包括形式参数的圆括号。函数体语句从下一行开始,必须是缩进的
. 函数体的第一行语句可以是可选的字符串文本,这个字符串是函数的文档字符串,或者称为 docstring
. 函数 调用 会为函数局部变量生成一个新的符号表。确切的说,所有函数中的变量赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找,然后是包含函数的局部符号表,然后是全局符号表,最后是内置名字表。因此,全局变量不能在函数中直接赋值(除非用 global 语句命名),尽管他们可以被引用
//这点和PHP是类似的 . 函数引用的实际参数在函数调用时引入局部符号表,因此,实参总是 传值调用(这里的 值 总是一个对象 引用 ,而不是该对象的值)(可以理解为指针传递)。一个函数被另一个函数调用时,一个新的局部符号表在调用过程中被创建。
. 一个函数定义会在当前符号表内引入函数名。函数名指代的值(即函数体)有一个被 Python 解释器认定为 用户自定义函数 的类型。 这个值可以赋予其他的名字(即变量名),然后它也可以被当做函数使用。这可以作为通用的重命名机制

aaarticlea/png;base64,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" alt="" />

定义一个返回斐波那契数列数字列表的函数,而不是打印它

aaarticlea/png;base64,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" alt="" />

0x5: 编码风格

. 使用  空格缩进,而非 TAB
. 在小缩进(可以嵌套更深)和大缩进(更易读)之间,4空格是一个很好的折中。TAB 引发了一些混乱,最好弃用折行以确保其不会超过 个字符
.使用空行分隔函数和类,以及函数中的大块代码
. 可能的话,注释独占一行
. 使用文档字符串
. 把空格放到操作符两边,以及逗号后面,但是括号里侧不加空格:a = f(, ) + g(, )
. 统一函数和类命名
. 推荐类名用 驼峰命名, 函数和方法名用 小写_和_下划线。总是用 self 作为方法的第一个参数
. 不要使用花哨的编码,如果你的代码的目的是要在国际化环境。Python 的默认情况下,UTF-,甚至普通的 ASCII 总是工作的最好
. 同样,也不要使用非 ASCII 字符的标识符,除非是不同语种的会阅读或者维护代码

0x6:  数组、多维数组、索引数组

1. 列表(普通一维、多维数组)

list列表是python内置类型,list: 列表(即动态数组,C++标准库的vector,但可含不同类型的元素于一个list中)

a = ["I","you","he","she"]      #元素可为任何类型 

列表可按下标读写,就当作数组处理,以0开始,有负下标的使用

. 0第一个元素
. -1最后一个元素,
. -len第一个元素
. len-1最后一个元素
. 取list的元素数量: len(list) #list的长度。实际该方法是调用了此对象的__len__(self)方法

list的方法

L.append(var)   #追加元素
L.insert(index,var)
L.pop(var) #返回最后一个元素,并从list中删除之
L.remove(var) #删除第一次出现的该元素
L.count(var) #该元素在列表中出现的个数
L.index(var) #该元素的位置,无则抛异常
L.extend(list) #追加list,即合并list到L上
L.sort() #排序
L.reverse() #倒序
list 操作符:,+,*,关键字del
a[:] #片段操作符,用于子list的提取
[,]+[,] #为[,,,]。同extend()
[]* #为[,,,]
del L[] #删除指定下标的元素
del L[:] #删除指定下标范围的元素
list的复制
L1 = L #L1为L的别名,用C来说就是指针地址相同,对L1操作即对L操作。函数参数就是这样传递的
L1 = L[:] #L1为L的克隆,即另一个拷贝 list comprehension
[ <expr1> for k in L if <expr2> ]

list用法

. 创建列表
sample_list = ['a',,('a','b')] . 得到列表中的某一个值
value_start = sample_list[]
end_value = sample_list[-] . 删除列表的第一个值
del sample_list[] . 在列表中插入一个值
sample_list[:] = ['sample value'] . 得到列表的长度
list_length = len(sample_list) . 列表遍历
for element in sample_list:
print element . 产生一个数值递增列表
num_inc_list = range()
#will return a list [,,,...,] . 用某个固定值初始化列表
initial_value =
list_length =
sample_list = [ initial_value for i in range()]
sample_list = [initial_value]*list_length
# sample_list ==[,,,,]

2. dictionary(索引一维、多维数组)

字典(即C++标准库的map)

dict = {'ob1':'computer', 'ob2':'mouse', 'ob3':'printer'}
//每一个元素是pair,包含key、value两部分。key是Integer或string类型,value 是任意类型,键是唯一的,字典只认最后一个赋的键值

dictionary的方法

D.get(key, )       #同dict[key],多了个没有则返回缺省值: 。[]没有则抛异常
D.has_key(key) #有该键返回TRUE,否则FALSE
D.keys() #返回字典键的列表
D.values() #以列表的形式返回字典中的值,返回值的列表中可包含重复元素
D.items() #将所有的字典项以列表方式返回,这些列表中的每一项都来自于(键,值),但是项在返回时并没有特殊的顺序 D.update(dict2) #增加合并字典
D.popitem() #得到一个pair,并从字典中删除它。已空则抛异常
D.clear() #清空字典,同del dict
D.copy() #拷贝字典
D.cmp(dict1,dict2) #比较字典,(优先级为元素个数、键大小、键值大小)
#第一个大返回1,小返回-,一样返回0 dictionary的复制
dict1 = dict #别名
dict2=dict.copy() #克隆,即另一个拷贝

利用dict实现索引数组

def addtwodimdict(thedict, key_a, key_b, val):
if thedict.has_key(key_a):
thedict[key_a][key_b] = val
else:
thedict.update({key_a:{key_b:val}}) addtwodimdict(mapdict, 'Beijing', 'city', 'Beijing')
addtwodimdict(mapdict, 'Chengdu', 'city', 'Chengdu')
addtwodimdict(mapdict, 'Beijing', 'age', )

3. tuple: 元组(常量数组)

tuple = ('a', 'b', 'c', 'd', 'e')
//可以用list的 [],:操作符提取元素。就是不能直接修改元素

4. string: 字符串(即不能修改的字符list) 

str = "Hello My friend"
//字符串是一个整体。如果想直接修改字符串的某一部分,是不可能的。但我们能够读出字符串的某一部分

string的操作

. 子字符串的提取
str[:] . 字符串包含判断操作符:in,not in
"He" in str
"she" not in str . string模块,还提供了很多方法,如
S.find(substring, [start [,end]]) #可指范围查找子串,返回索引值,否则返回-
S.rfind(substring,[start [,end]]) #反向查找
S.index(substring,[start [,end]]) #同find,只是找不到产生ValueError异常
S.rindex(substring,[start [,end]])#同上反向查找
S.count(substring,[start [,end]]) #返回找到子串的个数 S.lowercase()
S.capitalize() #首字母大写
S.lower() #转小写
S.upper() #转大写
S.swapcase() #大小写互换 S.split(str, ' ') #将string转list,以空格切分
S.join(list, ' ') #将list转string,以空格连接 . 处理字符串的内置函数
len(str) #串长度
cmp("my friend", str) #字符串比较。第一个大,返回1
max('abcxyz') #寻找字符串中最大的字符
min('abcxyz') #寻找字符串中最小的字符 . string的转换
float(str) #变成浮点数,float("1e-1") 结果为0.
int(str) #变成整型, int("") 结果为12
int(str,base) #变成base进制整型数,int("",) 结果为2
long(str) #变成长整型,
long(str,base) #变成base进制长整型, . 字符串的格式化(注意其转义字符,和C语言原理类似)
str_format % (参数列表) #参数列表是以tuple的形式定义的,即不可运行中改变
>>>print ""%s's height is %dcm" % ("My brother", 180) #结果显示为 My brother's height is 180cm . list 和 tuple 的相互转化
tuple(ls)
list(ls)

Relevant Link:

http://www.pythondoc.com/pythontutorial3/introduction.html
http://www.pythondoc.com/pythontutorial3/controlflow.html
http://blog.****.net/business122/article/details/753699

2. Python模块

如果你退出 Python 解释器并重新进入,你做的任何定义(变量和方法)都会丢失,为了满足这些需要,Python 提供了一个方法可以从文件中获取定义,这样的文件被称为 模块;模块中的定义可以 导入 到另一个模块或 主模块 中
模块是包括 Python 定义和声明的文件。文件名就是模块名加上 .py 后缀。模块的模块名(做为一个字符串)可以由全局变量 __name__ 得到
fibo.py

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
a, b = ,
while b < n:
print b,
a, b = b, a+b
print def fib2(n): # return Fibonacci series up to n
result = []
a, b = ,
while b < n:
result.append(b)
a, b = b, a+b
return result

可以使用import fibo命令导入这个模块,这样做不会直接把 fibo 中的函数导入当前的语义表;它只是引入了模块名 fibo。你可以通过模块名按如下方式访问这个函数:

aaarticlea/png;base64,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" alt="" />

如果打算频繁使用一个函数,你可以将它赋予一个本地变量

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAR8AAAA1CAIAAAD3dXj+AAAD30lEQVR4nO2dW5asIAxFHZcDcjyOxsk4GO+HL8AgB8FH3d579UcVCyGJCSCSrqYBAAAAAAAAAAAAeIy2H6eFsW+dwqFbq/TjNI39b/f+rprwadp+dLwiu/C04d2/onTDPW73WO/vqgmfZx59Ax/RCy328Xzah+1umL+713fD2G+jv9CwRGnv+3SUGE3eVRN+hm4wnEkvPBIb1P3ipbH1c7TZ1nPktJMW9O6I4S/wancEf4qqk5jsds7Xbqjld9d792VILvzeVRN+BXNM1QtD6rrdbXMX0QU3c8OTV8aSaXO1fqzmdQW9ezsQbv2YQV5UE77N7DLBjpZeaLM+2HuP+37hNPbtslWt7iGolPbuzpPBPOZH17tqAgAAAAAAAAAAAAAAAAD8JjUSn1rnXEPsJa91Jt0q5PwRPM2n87u843mtdYJoj1YneMzC8LAfwBN8Nr/LDwczupwQ3gPVLGzI/YC3+GB+V/DdXRluTbitbZ/NwqVFZi94h4/ld8VTF/ersqOLDHx4g8/ld50kBluBlF4ZEl3wAt/M7/KD2E/IX4Ok7YetcNh3NYzCpQ1WhvAcX87vCoLB/GcyeiHBBeBQNxwILgAHcxf+IrxNBgAAAAAAAAAAAIC3md/zKu+CcmtK533Xqomasfyu8yY1OY3T+Zrwppq6laIdtf2YbME0SLmV5J9qiappCq9oFHMb00ryPTrW9A82LEKZhcXMx/mUbKzcmk2TPtrXDasmqZe9+ruvraXkJaZGukimmrqV4h11w9gnW4glvJVYaf+s6W4JaQovaWTa07SSfo+sms7p0/3AnllYCb29zJ7lH4arGV3OiUQpGy15Fl/qU2pT6GiW+v7oMqzkvnLXhlFjjjoKL2oUSHcsM26Hfo+smqaDVA+uu6JLEnRZzWQshOSqkqcZMmoiudWDqqqVjh2tZ5SV6DoapNBK3twlWC8U0hRe1si9IozOo0L6PYrXNEWqHly3RNf8vwJUCbImitOqzsn4rhOaLJy7TDUvz13b7JE30ueP6hEr7U8+ozALHhbVhvC5GkXdpvrc9dDMdUN0zWPfKzJ4+V0lK0NBpJiaubfIyVhznq1lA14Yg5NWurAyNIXP0ujcbQqnmrCmefT0jvOodaNL2h9qGi9rK7H/Yed3RaqWRJcu0pmagpUSHaVaMA1SzUri81tMyGthYNnTtNIltznUfCK4/F91PB/ttJrhD0WmNivEZyS9prO5en4/bY3EjiJq6vaMd6S9UcjJbTOwrORefXrxiZqm8IJGMbcpVPPEyIYw8iYcAAAAAAAA/KdM1h8AVOAYS0QXQB2ILvjz/ANbMTUn6bB38gAAAABJRU5ErkJggg==" alt="" />

. 除了包含函数定义外,模块也可以包含可执行语句。这些语句一般用来初始化模块。他们仅在 第一次 被导入的地方执行一次
. 每个模块都有自己私有的符号表(符号表是模块独立的),被模块内所有的函数定义作为全局符号表使用。因此,模块的作者可以在模块内部使用全局变量,而无需担心它与某个用户的全局变量意外冲突
. 模块可以导入其他的模块。一个(好的)习惯是将所有的 import 语句放在模块的开始(或者是脚本),这并非强制。被导入的模块名会放入当前模块的全局符号表中
. import 语句的一个变体直接从被导入的模块中导入命名到本模块的语义表中。例如:
/*
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这样不会从局域语义表中导入模块名(如上所示,fibo没有定义)
*/ . 甚至有种方式可以导入模块中的所有定义
/*
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这样可以导入所有除了以下划线( _ )开头的命名
*/

0x1: 编译的Python文件

为了加快加载模块的速度,Python 会在 __pycache__ 目录下以 module.version.pyc 名字缓存每个模块编译后的版本,这里的版本编制了编译后文件的格式。它通常会包含 Python 的版本号
Python 会检查源文件与编译版的修改日期以确定它是否过期并需要重新编译。这是完全自动化的过程。同时,编译后的模块是跨平台的,所以同一个库可以在不同架构的系统之间共享
Python 不检查在两个不同环境中的缓存。首先,它会永远重新编译而且不会存储直接从命令行加载的模块。其次,如果没有源模块它不会检查缓存。若要支持没有源文件(只有编译版)的发布,编译后的模块必须在源目录下,并且必须没有源文件的模块

0x2: 标准模块

Python 带有一个标准模块库,并发布有独立的文档。有一些模块内置于解释器之中,这些操作的访问接口不是语言内核的一部分,但是已经内置于解释器了。这既是为了提高效率,也是为了给系统调用等操作系统原生访问提供接口。这类模块集合是一个依赖于底层平台的配置选项。例如,winreg 模块只提供在 Windows 系统上才有。有一个具体的模块值得注意: sys这个模块内置于所有的 Python 解释器

0x3: dir() 函数

内置函数 dir() 用于按模块名搜索模块定义,它返回一个字符串类型的存储列表

aaarticlea/png;base64,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" alt="" />

该列表列出了所有类型的名称:变量,模块,函数,等等,dir() 不会列出内置函数和变量名。如果你想列出这些内容,它们在标准模块 builtins 中定义

0x4: 包

包通常是使用用"圆点模块名"的结构化模块命名空间。例如,名为 A.B 的模块表示了名为 A 的包中名为 B 的子模块。正如同用模块来保存不同的模块架构可以避免全局变量之间的相互冲突,使用圆点模块名保存像 NumPy 或 Python Imaging Library 之类的不同类库架构可以避免模块之间的命名冲突(类似于Java对包的圆点命名管理)
假设现在想要设计一个模块集(一个"包")来统一处理声音文件和声音数据。存在几种不同的声音格式(通常由它们的扩展名来标识,例如:.wav, .aiff,.au),于是,为了在不同类型的文件格式之间转换,你需要维护一个不断增长的包集合。可能你还想要对声音数据做很多不同的操作(例如混音,添加回声,应用平衡 功能,创建一个人造效果),所以你要加入一个无限流模块来执行这些操作。你的包可能会是这个样子(通过分级的文件体系来进行分组)

sound/                          Top-level package
__init__.py Initialize the sound package
formats/ Subpackage for file format conversions
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ Subpackage for sound effects
__init__.py
echo.py
surround.py
reverse.py
...
filters/ Subpackage for filters
__init__.py
equalizer.py
vocoder.py
karaoke.py
...

当导入这个包时,Python 通过 sys.path 搜索路径查找包含这个包的子目录

Relevant Link:

http://www.pythondoc.com/pythontutorial3/modules.html

3. 嵌入式Python解析引擎: C++调用Python

在C/C++中嵌入Python,可以使用Python提供的强大功能,通过嵌入Python可以替代动态链接库形式的接口,这样可以方便地根据需要修改脚本代码,而不用重新编译链接二进制的动态链接库
C++调用Python有两种方式

. 第一种方式: 通过找到Python模块,类,方法,构造参数来调用
. 第二中方式: 就是通过构造出一个Python的脚本,用python引擎来执行

第一种方式可能更为优雅,符合大多数的反射调用的特点(如C#的反射机制、C#调用Com+、C#调用javascript脚本等)
这里存在的一个问题是,两种语言互相调用的时候,需要做数据结构(如基本类型、字符串、整数类型等、以及自定义的类等类型)间的转换,共享内存中的一个对象。比如,如何将C++的对象实例传入Python中,并在Python中使用。C++和Python并不在一个进程中,因此可以使用Boost的shared_ptr来实现。Python调用C++,换句话说就是需要把C++封装成Python可以"理解"的类型。同理C++去调用Python脚本也是一样的

0x1: 代码示例

test.c

/**
@file test.c
gcc -Wall -O2 -o test test.c -I/usr/include/python2.6 -L/usr/lib64/python2.6 -lpython2.6 -Wl,-R/usr/lib64/python2.6
*/
#include <stdio.h>
#include <string.h>
#include <Python.h> int main(int argc, char *argv[])
{
PyObject *pmod = NULL;
PyObject *pstr = NULL;
PyObject *pfunc = NULL;
PyObject *pargs = NULL; char *cstr = NULL; /* 初始化解释器 */
Py_Initialize(); /* 构建一个元组保存参数, PyEval_CallObject的第二参数是一个元组 */
pargs = Py_BuildValue("(s)", argv[]); /* 添加Python路径, 包括当前路径, 否则不能导入当前路径下的模块 */
PyRun_SimpleString("import sys;sys.path.append('.')"); /* 导入模块名称, 通常为调用的Python脚本程序名 */
pmod = PyImport_ImportModule("testpy");
if (pmod == NULL) {
printf("import module failed!\n");
return -;
} /* 获得导入模块的函数属性 */
pfunc = PyObject_GetAttrString(pmod, "testpy");
if (pfunc == NULL) {
printf("No such attribute!\n");
return -;
} /* 调用导入模块的入口函数, 获取返回结果 */
pstr = PyEval_CallObject(pfunc, pargs);
if (pstr == NULL) {
printf("callobject failed!\n");
return -;
} /* 分析返回的结果 */
PyArg_Parse(pstr, "s", &cstr); printf("%s\n", cstr); /* 关闭解释器 */
Py_Finalize(); return ;
}

在C程序中嵌入的Python脚本程序示例,testpy.py:

#!/usr/local/bin/python

import sys

def testpy(name):
if not name:
return 'Valid Arguments' str = "hello, " + name return str

aaarticlea/png;base64,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" alt="" />

Relevant Link:

http://www.qmailer.net/archives/103.html

4. Python 调用 C (base)

Python是解释性语言, 底层就是用C实现的

0x1: 代码示例

/**
@file wrapper.c
gcc -fPIC wrapper.c -o wrapper.so -shared -I/usr/include/python2.6 -I/usr/lib64/python2.6/config
*/
#include <Python.h> int fact(int n)
{
if (n <= )
return ;
else
return n * fact(n - );
} PyObject* wrap_fact(PyObject* self, PyObject* args)
{
int n, result; if (! PyArg_ParseTuple(args, "i:fact", &n))
return NULL; result = fact(n);
return Py_BuildValue("i", result);
} static PyMethodDef wrapperMethods[] =
{
{"fact", wrap_fact, METH_VARARGS, "Caculate N!"},
{NULL, NULL}
}; void initwrapper()
{
PyObject* m;
m = Py_InitModule("wrapper", wrapperMethods);
}

进入python, 可以如下使用

aaarticlea/png;base64,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" alt="" />

Relevant Link:

http://blog.****.net/fxjtoday/article/details/6059874

5. 扩展Python语法解析器功能: Python中调用C++

在python中调用C++类成员函数, 如下调用TestFact类中的fact函数
wrapper.cpp

/*
g++ -fPIC wrapper.cpp -o example.so -shared -I/usr/include/python2.6 -I/usr/lib64/python2.6/config
wrapper.cpp
*/
#include <Python.h> class TestFact
{
public:
TestFact(){};
~TestFact(){};
int fact(int n);
}; int TestFact::fact(int n)
{
if (n <= )
return ;
else
return n * (n - );
} int fact(int n)
{
TestFact t;
return t.fact(n);
} PyObject* wrap_fact(PyObject* self, PyObject* args)
{
int n, result; if (! PyArg_ParseTuple(args, "i:fact", &n))
return NULL; result = fact(n);
return Py_BuildValue("i", result);
} static PyMethodDef exampleMethods[] =
{
{"fact", wrap_fact, METH_VARARGS, "Caculate N!"},
{NULL, NULL}
}; extern "C" //不加会导致找不到initexample
void initexample()
{
PyObject* m;
m = Py_InitModule("example", exampleMethods);
}

然后在有此so库的目录, 进入python, 可以如下使用

aaarticlea/png;base64,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" alt="" />

Relevant Link:

http://www.oschina.net/question/234345_48628
http://www.yexiwei.com/2013/06/27/python%E8%B0%83%E7%94%A8cc%E5%87%BD%E6%95%B0/

6. Python 调用 C++ (Boost.Python)

Boost库是非常强大的库, 其中的python库可以用来封装c++被python调用, 功能比较强大, 不但可以封装函数还能封装类, 类成员

Relevant Link:

http://blog.****.net/fxjtoday/article/details/6059874

7. python 调用 c++ (ctypes)

ctypes is an advanced ffi (Foreign Function Interface) package for Python 2.3 and higher. In Python 2.5 it is already included.
ctypes allows to call functions in dlls/shared libraries and has extensive facilities to create, access and manipulate simple and complicated C data types in Python - in other words: wrap libraries in pure Python. It is even possible to implement C callback functions in pure Python.

Relevant Link:

http://blog.****.net/fxjtoday/article/details/6059874

8. 脚本语言扩展性

需要明白的是,无论是Lua中调用C++扩展API,还是Python中调用C++ API,本质上都是通过外部的C++实现逻辑功能代码,通过联合编译或者so/dll的方式导入到脚本引擎中,只是区别在于python已经有大量现成的代码库和so扩展库,而Lua在这方面还很原始,很多时候还需要使用联合编译的方式实现

0x1: SWIG

有一个外部工具叫SWIG,是Simplified Wrapper and Interface Generator 的缩写。其作者为David Beazley。这个工具可以根据特别注释过的C/C++头文件生成能给Python,Tcl 和Perl 使用的包装代码。使用SWIG 可以省去你写前面所说的样板代码的时间。你只要关心怎么用C/C++解决你的实际问题就好了。你所要做的就是按SWIG 的格式编写文件,其余的就都由SWIG 来完成

0x2: Pyrex

0x3: Psyco

Psyco 的理念与其它的方法截然不同。与其改成C的代码,为何不让你已有的Python代码运行的更快一些呢?Psyco 是一个just-in-time(JIT)编译器,它能在运行时自动把字节码转为本地代码运行。所以,你只要(在运行时)导入Psyco 模块,然后告诉它要开始优化代码就可以了。而不用修改自己的代码

Relevant Link:

http://swig.org
http://cosc.canterbury.ac.nz/~greg/python/Pyrex
http://blog.****.net/pipisorry/article/details/49532341

Copyright (c) 2015 LittleHann All rights reserved