python的pad函数

A. python的内置函数有哪些,都是什么意思

print-输出，input-输入，int-将字符串转数字（字符串必须是数字），str-将数字转为字符串，list-将字符串/数字转为列表，for-有限循环，while-无限循环……………………………………

B. python中pow(x,y[,z])函数的使用

你的语法有错误。
内置函数power(x, y[, z])中的x和y是必选参数，z是可选参数；如果使用了参数z，中括号必须去掉，即power(x,y,z)，其结果是x的y次方再对z求余数，但是这种方式比power(x,y) % z的执行效率要高。

你可以使用power(2, 4)或者power(2,4,3)。
power(2,4)=2的4次方=16；
power(2,4,3)=2的4次方再模上3=16 % 3=1。

C. python中math.pi()是什么意思

因为pi是python，math函数库中的一个内建函数。

import math

print "math.modf(100.12) : ", math.modf(100.12)

print "math.modf(100.72) : ", math.modf(100.72)

print "math.modf(119L) : ", math.modf(119L)

print "math.modf(math.pi) : ", math.modf(math.pi)

(3)python的pad函数扩展阅读：

cmath是python中的标准库函数，用于做复杂的复数运算，

Python cmath 模块包含了一些用于复数运算的函数。

cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math模块运算的是数学运算。

polar 函数对一个输入的笛卡尔形势的复数进行计算，输出为一个二元组，第一个值为Z的模值， 第二个为幅度值。 rect() 函数对输入的模和幅度值进行计算输出笛卡尔表示。如果需要单独对一个复数进行幅度值的求解，可以调用 cmath.phrase(x) 函数，返回幅度值。

D. Python的函数都有哪些

Python 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以def关键词开头，后接函数标识符名称和圆括号()。

• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

• 函数内容以冒号起始，并且缩进。

• return [表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def functionname( parameters ): "函数_文档字符串"
function_suite
return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

实例

以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

实例(Python 2.0+)

def printme( str ): "打印传入的字符串到标准显示设备上"
print str
return

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定义函数def printme( str ): "打印任何传入的字符串"
print str
return
# 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")

以上实例输出结果：

• 我要调用用户自定义函数!再次调用同一函数



参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]
a="Runoob"

以上代码中，[1,2,3]是 List 类型，"Runoob"是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值a=5后再赋值a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值la=[1,2,3,4]后再赋值la[2]=5则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): a = 10
b = 2ChangeInt(b)print b # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def changeme( mylist ): "修改传入的列表"
mylist.append([1,2,3,4])
print "函数内取值: ", mylist
return
# 调用changeme函数mylist = [10,20,30]changeme( mylist )print "函数外取值: ", mylist

实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：

• 函数内取值: [10, 20, 30, [1, 2, 3, 4]]函数外取值: [10, 20, 30, [1, 2, 3, 4]]



参数

以下是调用函数时可使用的正式参数类型：

• 必备参数

• 关键字参数

• 默认参数

• 不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme()

以上实例输出结果：

• Traceback (most recent call last):


• File "test.py", line 11, in <mole>


• printme()TypeError: printme() takes exactly 1 argument (0 given)



关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme( str = "My string")

以上实例输出结果：

• My string



下例能将关键字参数顺序不重要展示得更清楚：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )

以上实例输出结果：

• Name: mikiAge 50



默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age = 35 ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )printinfo( name="miki" )

以上实例输出结果：

• Name: mikiAge 50Name: mikiAge 35



不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串"
function_suite
return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple: print var
return
# 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )

以上实例输出结果：

• 输出:10输出:706050



匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。

• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

• lambda [arg1 [,arg2,.....argn]]:expression



如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数print "相加后的值为 : ", sum( 10, 20 )print "相加后的值为 : ", sum( 20, 20 )

以上实例输出结果：

• 相加后的值为 : 30相加后的值为 : 40



return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def sum( arg1, arg2 ): # 返回2个参数的和."
total = arg1 + arg2
print "函数内 : ", total
return total
# 调用sum函数total = sum( 10, 20 )

以上实例输出结果：

• 函数内 : 30



变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

• 变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量

• 局部变量

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 这是一个全局变量# 可写函数说明def sum( arg1, arg2 ): #返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print "函数内是局部变量 : ", total
return total
#调用sum函数sum( 10, 20 )print "函数外是全局变量 : ", total

以上实例输出结果：

• 函数内是局部变量 : 30函数外是全局变量 : 0

E. python编写用pow()函数计算球的体积

使用键盘输入值并不是编辑表中值的唯一方式。在某些情况下，为了设置字段值，可能要对单条记录甚至是所有记录执行数学计算。您可以对所有记录或选中记录执行简单计算和高级计算。此外，还可以在属性表中的字段上计算面积、长度、周长和其他几何属性。以下各部分包括使用字段计算器的若干示例。使用 Python、SQL 和 Arcade 执行计算。

本主题着重于基于 Python 的计算字段示例。要了解有关 Arcade 表达式的详细信息，请参阅 ArcGIS Arcade 指南。要了解有关 SQL 表达式的详细信息，请参阅计算字段。

注：

• Python 强制将缩进作为语法的一部分。请使用两个或四个空格来定义每个逻辑级别。将语句块的开头和结尾对齐并且保持一致。

• Python 计算表达式字段将使用惊叹号 (!!) 括起。

• 命名变量时，请注意 Python 区分大小写，因此 value 不同于 Value。

• 输入语句后，如果想将其写入文件，请单击导出。导入按钮将提示您查找和选择一个现有的计算文件。


简单计算

仅通过一个短表达式就可以计算出多种计算结果。

简单字符串示例

一系列 Python 字符串函数均支持使用字符串，包括 capitalize、rstrip 和 replace。

将 CITY_NAME 字段中字符串的首字母大写。

!CITY_NAME!.capitalize()

去掉 CITY_NAME 字段中自字符串结尾起的所有空白区。

!CITY_NAME!.rstrip()

将 STATE_NAME 字段中的“california”全部替换为“California”。

!STATE_NAME!.replace("california", "California")

在 Python 中，字符串字段中的字符可以通过索引和分割操作进行访问。索引操作将在索引位置提取字符，而分割操作则会提取一组字符。在下表中，假设 !fieldname! 是值为 "abcde" 的字符串字段。

示例

说明

结果

!fieldname![0]

第一个字符

"a"

!fieldname![-2]

倒数第二个字符

"d"

!fieldname![1:4]

第二、三和四个字符

"bcd"

Python 也支持使用 format() 方法的字符串格式。

将合并后的 FieldA 和 FieldB 以冒号分隔开。

"{}:{}".format(!FieldA!, !FieldB!)

常见 Python 字符串操作

简单数学示例

Python 提供了处理数字的工具。Python 也支持一些数值和数学函数，包括 math、cmath、decimal、random、itertools、functools 和 operator。

运算符

说明

示例

结果

x + y

x 加上 y

1.5 + 2.5

4.0

x - y

x 减去 y

3.3 - 2.2

1.1

x * y

x 乘以 y

2.0 * 2.2

4.4

x / y

x 除以 y

4.0 / 1.25

3.2

x // y

x 除以 y（向下取整除法）

4.0 // 1.25

3.0

x % y

x 模 y

8 % 3

2

-x

x 的负数表达式

x = 5

-x

-5

+x

x 不变

x = 5

+x

5

x ** y

以 x 为底，以 y 为指数的幂

2 ** 3

8

乘

!Rank! * 2

根据给定的半径字段计算球体的体积。

4.0 / 3.0 * math.pi * !Radius! ** 3

旧版本：

在 ArcGIS Pro 中，使用的是 Python 3，在 ArcGIS Desktop 中，使用的 Python 2。Python 2 使用的是整型数学计算，这就意味着两个整型值相除将始终生成整型值 (3 / 2 = 1)。在 Python 3 中，两个整型值相除将生成浮点型值 (3 / 2 = 1.5)。

Python 内置函数

Python 包含多个可用的内置函数，包括 max、min、round 和 sum。

Python 内置函数

通过字段列表计算每条记录的最大值。

max([!field1!, !field2!, !field3!])

通过字段列表计算每条记录的总和。

sum([!field1!, !field2!, !field3!])使用代码块

通过 Python 表达式和代码块参数可执行以下操作：

• 在表达式中应用任意 Python 函数。

• 访问地理处理函数和对象。

• 访问要素几何的属性。

• 访问新的随机值运算符。

• 使用 if-then-else 逻辑对值进行重分类。

表达式类型

代码块

Python 3

支持 Python 功能。使用 Python 函数 (def) 表示代码块。在适当的情况下，几何属性将通过地理处理对象表示（如点对象）。

Arcade

支持 Arcade 功能。

SQL

支持 SQL 表达式。

执行 SQL 表达式可以更好地支持使用要素服务和企业级地理数据库的计算，尤其是在性能方面。使用该表达式可以将单次请求设置为要素服务或数据库，而不必一次执行一个要素或一行的计算。

旧版本：

在 ArcGIS Desktop 中，计算字段工具支持 VB、PYTHON 和 PYTHON_9.3 表达式类型。VB 表达式类型，在某些产品中受支持，但在 64 位产品中不受支持，其中包括 ArcGIS Pro。

出于相后兼容性考量，ArcGIS Pro 中仍然支持 PYTHON 和 PYTHON_9.3 关键字，但是不会作为选择列出。使用这些关键字的 Python 脚本将可继续使用。

Python 3 表达式类型与旧版 PYTHON_9.3 关键字的唯一区别在于 Python 3 会将日期字段中的值作为 Python datetime 对象返回。

注：

Python 3 表达式类型与随 ArcGIS Pro 安装的 Python 版本无关。这只是历史上的第三个 Python 相关关键字（继 PYTHON 和 PYTHON_9.3 之后。

各 Python 函数可通过 def 关键字定义，关键字后为函数名称及函数的输入参数。可编写 Python 函数，使 Python 函数能够接受任何数量的输入参数（也可以没有任何参数）。函数将通过 return 语句返回值。函数名称可由您自行选取（不得使用空格，也不得以数字开头）。

注：

如果函数未通过 return 语句显式返回值，则函数将返回 None。

注：

请牢记，Python 强制要求将缩进作为语法的一部分。请使用四个空格来定义每个逻辑级别。将语句块的开头和结尾对齐并且保持一致。

代码示例 - 数学

在使用以下数学示例时，请假设表达式类型为 Python 3。

将字段的值四舍五入为保留两位小数。

表达式：
round(!area!, 2)

通过 math 模块将米转换成英尺。以转换值为底，以 2 为指数进行幂运算，然后再乘以 area。

表达式：
MetersToFeet((float(!shape.area!)))
代码块：
import math
def MetersToFeet(area):
return math.pow(3.2808, 2) * area通过 Python 逻辑计算字段

可以使用 if、else 和 elif 语句将逻辑模式包含在代码块中。

按照字段值进行分类。

表达式：
Reclass(!WELL_YIELD!)
代码块：
def Reclass(WellYield):
if (WellYield >= 0 and WellYield <= 10):
return 1
elif (WellYield > 10 and WellYield <= 20):
return 2
elif (WellYield > 20 and WellYield <= 30):
return 3
elif (WellYield > 30):
return 4代码实例 - 几何

除以下代码示例外，请参阅下方的“几何单位转换”部分，以了解有关转换几何单位的详细信息。

计算某要素的面积。

表达式：
!shape.area!

计算某要素的最大 x 坐标。

表达式：
!shape.extent.XMax!

计算某要素中的折点数。

表达式：
MySub(!shape!)
代码块：
def MySub(feat):
partnum = 0
# Count the number of points in the current multipart feature
partcount = feat.partCount
pntcount = 0
# Enter while loop for each part in the feature (if a singlepart
# feature, this will occur only once)
while partnum < partcount:
part = feat.getPart(partnum)
pnt = part.next()
# Enter while loop for each vertex
while pnt:
pntcount += 1
pnt = part.next()

# If pnt is null, either the part is finished or there
# is an interior ring
if not pnt:
pnt = part.next()
partnum += 1
return pntcount

将点要素类中每个点的 x 坐标平移 100。

表达式：
shiftXCoordinate(!SHAPE!)
代码块：
def shiftXCoordinate(shape):
shiftValue = 100
point = shape.getPart(0)
point.X += shiftValue
return point几何单位转换

几何字段的面积和长度属性可通过用 @ 符号表示的单位类型进行修改。

• 面积测量单位关键字：

• 
  
  

• ACRES | ARES | HECTARES | SQUARECENTIMETERS | SQUAREDECIMETERS | SQUAREINCHES | SQUAREFEET | SQUAREKILOMETERS | SQUAREMETERS | SQUAREMILES | SQUAREMILLIMETERS | SQUAREYARDS | SQUAREMAPUNITS | UNKNOWN

• 线性测量单位关键字：

• 
  
  

• CENTIMETERS | DECIMALDEGREES | DECIMETERS | FEET | INCHES | KILOMETERS | METERS | MILES | MILLIMETERS | NAUTICALMILES | POINTS | UNKNOWN | YARDS

注：

如果数据存储在地理坐标系中且具有线性单位（例如英尺），则会通过测地线算法转换长度计算的结果。

警告：

转换地理坐标系中数据的面积单位会生成不正确的结果，这是由于沿 globe 的十进制度并不一致。

计算某要素的长度（以码为单位）。

表达式：
!shape.length@yards!

计算某要素的面积（以英亩为单位）。

表达式：
!shape.area@acres!

测地线面积和长度也可以通过带 @（后跟测量单位关键字）的 geodesicArea 和 geodesicLength 属性进行计算。

计算某要素的测地线长度（以码为单位）。

表达式：
!shape.geodesicLength@yards!

计算某要素的测地线面积（以英亩为单位）。

表达式：
!shape.geodesicArea@acres!代码实例 - 日期

日期和时间可使用 datetime 和 time 模块进行计算。

计算当前日期。

表达式：
time.strftime("%d/%m/%Y")

计算当前日期和时间。

表达式：
datetime.datetime.now()

计算的日期为 2000 年 12 月 31 日。

表达式：
datetime.datetime(2000, 12, 31)

计算当前日期和字段中的值之间的天数。

表达式：
(datetime.datetime.now() - !field1!).days

通过向字段中的日期值添加 100 天来计算日期。

表达式：
!field1! + datetime.timedelta(days=100)

计算字段中的日期值为一周中的周几（例如，星期天）。

表达式：
!field1!.strftime('%A')代码实例 - 字符串

可以使用多种 Python 编码模式来完成字符串计算。

返回最右侧三个字符。

表达式：
!SUB_REGION![-3:]

将所有大写字母 P 替换为小写字母 p。

表达式：
!STATE_NAME!.replace("P","p")

通过空格分隔符串连两个字段。

表达式：
!SUB_REGION! + " " + !STATE_ABBR!转换为正确的大小写形式

下列各例显示的是转换单词的不同方法，这些方法可使每个单词的首字母变为大写、其余字母变为小写。

表达式：
' '.join([i.capitalize() for i in !STATE_NAME!.split(' ')])表达式：
!STATE_NAME!.title()正则表达式

Python 的 re 模块提供了正则表达式匹配操作，可用于对字符串执行复杂的模式匹配和替换规则。

re - 正则表达式运算正则表达式的用法

使用单词 Street 替换 St 或 St.，在字符串的末尾生成一个新单词。

表达式：
update_street(!ADDRESS!)
代码块：
import re
def update_street(street_name):
return re.sub(r"""(St|St.)""",
'Street',
street_name)累加计算和顺序计算

可以使用全局变量来进行累加计算和顺序计算。

根据某间隔值计算顺序 ID 或数字。

表达式：
autoIncrement()
代码块：
rec=0
def autoIncrement():
global rec
pStart = 1 # adjust start value, if req'd
pInterval = 1 # adjust interval value, if req'd
if (rec == 0):
rec = pStart
else:
rec = rec + pInterval
return rec

计算数值型字段的累加值。

表达式：
accumulate(!FieldA!)
代码块：
total = 0
def accumulate(increment):
global total
if total:
total += increment
else:
total = increment
return total

计算数值型字段的百分比增量。

表达式：
percentIncrease(float(!FieldA!))
代码块：
lastValue = 0
def percentIncrease(newValue):
global lastValue
if lastValue:
percentage = ((newValue - lastValue) / lastValue) * 100
else:
percentage = 0
lastValue = newValue
return percentage随机值

可以使用 random 模块来计算随机值。

通过 numpy 站点包来计算 0.0 和 1.0 之间的随机浮点值。

表达式：
getRandomValue()
代码块：
import numpy
def getRandomValue():
return numpy.random.random()

使用随机模块来计算 0 与 10 之间的随机整数。

表达式：
random.randint(0, 10)
代码块：
import random计算空值

在 Python 表达式中，可通过 Python None 来计算空值。

注：

仅当该字段为空时，才可以进行以下计算。

使用 Python None 计算空值。

表达式：
None相关主题

有关字段计算的基础知识

授权转载：gisoracle

网课学习 + 权威结业证书

我们精心汇总了一些相对简单

培训考核通过便可获取的证书

自然资源部职鉴中心发证

可用于招投标、资质系统

等

测绘师继续教育20学时

中国测绘网新媒体中心

[email protected]

商务合作/微信 214979525

F. python中π怎么表示

表示为math函数库中的一个内建函数。

import math

print "math.modf(100.12) : ", math.modf(100.12)。

print "math.modf(100.72) : ", math.modf(100.72)。

print "math.modf(119L) : ", math.modf(119L)。

print "math.modf(math.pi) : ", math.modf(math.pi)。

根据PEP的规定，必须使用4个空格来表示每级缩进（不清楚4个空格的规定如何，在实际编写中可以自定义空格数，但是要满足每级缩进间空格数相等）。使用Tab字符和其它数目的空格虽然都可以编译通过，但不符合编码规范。支持Tab字符和其它数目的空格仅仅是为兼容很旧的的Python程序和某些有问题的编辑程序。

G. python的用途和优点

python的用途：

python也是一门程序语言。能写各种各样的程序。

优点：

1.支持OOP编程 从根本

上讲Python仍是一种面向对象的语言，支持多态、继承等高级概念，在Python里使用OOP十分容易 没有C++、Java那样复杂，但不必做Python下OOp高手，够用即可。

2. 免费Python的使用是完全免费的，您可以从网络上免费下载、安装使用， Python上的其他程序包，也可下载安装使用。 Python的免费的同时又有很多的的社区对用户的提问提出快速的技术支持，学习和使用Python技术不再是一个人在战斗！

3. 可移植性 Python的实现是用ansi c编写的，可以运行在目前所有主流平台上，手机、pad上均可运行Python程序，其下的程序包也具有可移植性。

4. 功能强大 从特性的观点上看，Python是一个混合体，他丰富的工具集使得他介于传统的脚本语言和系统语言之间。

拓展资料：

设计定位

Python的设计哲学是"优雅"、"明确"、"简单"。因此，Perl语言中"总是有多种方法来做同一件事"的理念在Python开发者中通常是难以忍受的。Python开发者的哲学是"用一种方法，最好是只有一种方法来做一件事"。

在设计Python语言时，如果面临多种选择，Python开发者一般会拒绝花俏的语法，而选择明确的没有或者很少有歧义的语法。由于这种设计观念的差异，Python源代码通常被认为比Perl具备更好的可读性，并且能够支撑大规模的软件开发。这些准则被称为Python格言。在Python解释器内运行import this可以获得完整的列表。

Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python内。所以很多人认为Python很慢。不过，根据二八定律，大多数程序对速度要求不高。在某些对运行速度要求很高的情况，Python设计师倾向于使用JIT技术，或者用使用C/C++语言改写这部分程序。可用的JIT技术是PyPy。

Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式程序设计工具。

虽然Python可能被粗略地分类为"脚本语言"(script language)，但实际上一些大规模软件开发计划例如Zope、Mnet及BitTorrent，Google也广泛地使用它。Python的支持者较喜欢称它为一种高级动态编程语言，原因是"脚本语言"泛指仅作简单程序设计任务的语言，如shellscript、VBScript等只能处理简单任务的编程语言，并不能与Python相提并论。

Python本身被设计为可扩充的。并非所有的特性和功能都集成到语言核心。Python提供了丰富的API和工具，以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。Python编译器本身也可以被集成到其它需要脚本语言的程序内。

因此，很多人还把Python作为一种"胶水语言"(glue language)使用。使用Python将其他语言编写的程序进行集成和封装。在Google内部的很多项目，例如Google Engine使用C++编写性能要求极高的部分，然后用Python或Java/Go调用相应的模块。

H. 新手关于python中pandas函数的使用

利用Python的pandas数据结构来读取excel表格的数据，部分代码如下：

#-*- coding:utf-8 -*-
import pandas as pd
import matplotlib.pyplot as plt

catering_data="catering_sale.xls"
data=pd.read_excel(catering_data,index_col=u'日期')
#读取数据，指定"日期"列为索引列

大多数书上都是这样写的，但是在Python2.7上运行时出现错误。（没有在Python3.x版本试过）
出现了如下问题：
这里写图片描述
使用help（pd.read_excel）发现参数中有必选参数sheetname,加入到函数中，代码如下：

#-*- coding:utf-8 -*-
import pandas as pd
import matplotlib.pyplot as plt

catering_data="catering_sale.xls"
data=pd.read_excel(catering_data,sheetname=0,index_col=u'日期')

运行成功。
sheetname=0 的意思是：读取xls文件中的第一个表格。（假设文件中有很多个表格）
另外，也可以将文件转换成csv格式，就不需要这个参数了。代码如下：

catering_data="catering_sale.csv"
data=pd.read_csv(catering_data)

I. python padnas 通过循环读取文件后，我不能找出有缺失值的那张表，请问应如何判断

可以使用numpy中的函数判读dataframe中是否有NaN的值
import numpy as np
if np.any(df.isnull()): 先判断是否有NaN的值，随后遍历dataframe的所有列，注意df.isna()函数，就是判断是否为NaN。循环体中的命令是将NaN替换成某种数值（平均值、中位数之类，依据你的处理逻辑）
for __column_index in df.columns[df.isna().any()].to_list():
df[__column_index].fillna(df[__column_index].mean(), inplace=True)