当前页面: 首页>> 主机教程 >>正文


这一篇比较适合Python与R编程入门的目录文章

在数据科学领域,程序就是数据与处理数据方法的集合。简单的讲,首先要有数据,然后通过运行代码处理数据,最终获得想要的结果。而编写和理解一段Python或R代码,完全可以像读写英文一样。Python与R是很容易入门的计算机语言,两者在很多方面具有相似性。本文简单介绍了Python与R的基本语法、数据的结构、程序的结构、函数、面向对象编程共5个方面的内容,希望读者在读完本篇文章之后,对程序有所了解。文章目录如下:

一、基本语法
1、变量赋值
2、显示器输出和键盘输入
3、基本数据类型
4、运算符
二、数据的结构
1、Python之列表、元组、字典、集合、多维数组、序列、数据框
2、R之向量、矩阵、数组、数据框、因子、列表
3、Python与R数据结构比较
三、程序的结构
1、注释
2、代码块
3、条件判断
4、循环
    4.1 遍历循环
    4.2 无限循环
四、函数
1、使用函数
2、编写函数
五、编程方式
1、面向过程编程
2、面向对象编程
3、面向过程与面向对象的比较

以下为正文内容



一、基本语法
1、变量赋值
    赋值就是告诉程序,用一个标识表示它是什么(初级数学里很常见),比如:用a表示它是数值5,用b表示它是10,那么a+b就等于15。被赋值之后,它就是程序里的一个变量,可以打印输出或者被调用。
    Python用"="进行赋值:


a = 5b = 10
    R用"<-","->"或"="都可以赋值:



a <- 510 -> bc = 20
    被赋值的叫做"标识符",随便你起什么名字,但是要遵守几个规则:
    ①只有字母(区分大小写)、数字、"_"(下划线)、"."(英文句号)可以出现,且开头只能是大小写字母(Python也允许开头是'_')
    ②标识符不能是关键字,比如 for、while、break、def等

2、显示器输出和键盘输入
    ①显示器输出就是将程序运行的结果显示在程序界面上。
    Python用print()输出:


print(a + b)15
    R用print()或cat()输出:




print(a + b)[1]15cat(a + b)15
    ②键盘输入就是程序在运行过程中接收来自键盘的输入:
    Python使用input()接收键盘输入:




a = input()abc #输入abcprint(a)abc
    R使用readline(),readLines(), scan()接收键盘输入:





















#输入单个a <- readline() abc  #输入abcprint(a)[1] "abc"#输入多个方式1a <- readLines(n=3) #连续输入3个值abcprint(a)[1] "a" "b" "c"#输入多个方式2a <- scan() #连续输入,最后一个不输入,按下回车键,输入结束1: 12: 23: 34:Read 3 itemsprint(a)[1] 1 2 3

3、基本数据类型
    Python与R的基本数据类型主要包括两种:数值型(整数、浮点、复数、布尔)与字符型,示例如下:

数据类型
示例
Python中
类型名称
R中
类型名称
整数
1、2、3
int
numeric---integer
浮点
1.22、1.2345
float
numeric---double
复数
1 + 2j、 1.1 + 2.2j
complex
complex
布尔
Python: True/False
R: TRUE/FASLE/1/0
bool
logical
字符
"a"、"1234"
str
character
空值/缺失值
Python:None/numpy.NaN
R: NULL/NA
NoneType
NULL

    可以通过以下语句判断一个变量的数据类型:
    Python中使用 type()查看数据类型



import typesa = 'abc'type(a)
    R中使用typeof()或mode()查看数据类型




a <- '123'typeof(a)[1] "character"mode(a)[1] "character"

 4、运算符
    程序中主要的运算符包括算数运算符、逻辑运算符、关系运算符(Python还有按位运算符和赋值运算符,此处不做介绍)。
    ①算数运算符,运算返回的结果是数值型数据('+' 在Python中还可作为字符数据的连接符号)

描述
Python
R
+
+
-
-
*
*
/
/
求幂
**
^或**
求余
%
x%%y
整除
//
x%/%y

    ②逻辑运算符,运算返回的结果是布尔型数据

描述
Python
R
小于
<
小于或等于
<=
<=
大于
>
>
大于或等于
>=
>=
等于
==
==
不等于
!=
!=
非x
not x
!x
x或y
x or y
x | y
x和y
x and y
x & y

    ③关系运算符,运算返回的结果是布尔型数据

x在y中 ,y包含x
x in y
x %in% y
x不在y中,y不包含x
x not in y
!x %in% y
x是y
x is y
x不是y
x is not y

    通常来讲,运算符的优先顺序一般是:算数>逻辑>关系,如果记不清顺序,建议使用括号"()",比如:(x or y)and ((a/5) >= (b**2))

二、数据的结构
    现实中,一个物体会包含很多数据,比如描述其特点的“物美价廉”、生产地是字符型数据,而价钱、长度、宽度等是数值型数据,这些数据是不同的类型;另外,比如一个班级,每个人都有自己的身高,我们需要将所有的身高汇总起来,这些数据是相同的类型。这时,单个数据(比如一个数值,或者一个字符)就无法支持这样的数据收集,我们需要将这些数据按照不同方式进行组织,于是产生了不同结构的数据。
1、Python之列表、元组、字典、集合、多维数组、序列、数据框
①列表(list)
    列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型。创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。



list1 = ['hello', 'world', 1000, 2000]list2 = [1, 2, 3, 4, 5 ]list3 = ["a", "b", "c", "d"]
②元组(tuple)
    Python 的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。



tup1 = ('hello', 'world',  1000, 2000)tup2 = (1, 2, 3, 4, 5 )tup3 = "a", "b", "c", "d"   #  不需要括号也可以
③字典(dict)
    字典是另一种可变容器模型,且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下所示:
    d = {key1 : value1, key2 : value2 }
键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
④集合(set)
    集合是一个无序的不重复元素序列,可以使用大括号 { } 或者 set() 函数创建集合,
    注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。






basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}print(basket){'orange', 'banana', 'pear', 'apple'}a = set('abracadabra')print(a){'r', 'b', 'c', 'd', 'a'}
⑤多维数组(ndarray)
     Python虽然也提供了array模块,但其只支持一维数组,不支持多维数组,也没有各种运算函数,因而不适合数值运算。NumPy的出现弥补了这些不足。





import numpy as npa = np.array([2,3,4]) b = np.array([2.0,3.0,4.0])c = np.array([[1.0,2.0],[3.0,4.0]])d = np.array([[1,2],[3,4]],dtype=complex) #
    序列是pandas提供的数据格式,是由一组数据(各种NumPy数据类型),以及一组与之相关的数据标签(索引)组成,序列不要求数据类型是相同的。序列可以看作是一维数组。










import pandas as pddata = ['a','b','c','d','e']serie = pd.Series(data,index=[2,4,6,8,10],dtype=str)print(serie)2    a4    b6    c8    d10   edtype: object
⑦数据框(DataFrame)
    DataFrame同样不是Python自带的数据格式,而是Pandas库中的一种数据结构它类似Excel,是一种二维表,含有一组有序的列,每列可以是不同的值,可以看做是多个Series的集合,不同的Series使用共同索引(index)。DataFrame既有行索引,也有列索引。DataFrame可以有多种创建方式,最常用的是通过dict创建。













import pandas as pddata = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],        'year':[2000,2001,2002,2001,2002],         'pop':[1.5,1.7,3.6,2.4,2.9]        }frame = pd.DataFrame(data)frame        state  year  pop0    Ohio  2000  1.51    Ohio  2001  1.72    Ohio  2002  3.63  Nevada  2001  2.44  Nevada  2002  2.9

2、R之向量、矩阵、数组、数据框、因子、列表
①向量(vector)
    向量是用于存储数值型、字符型或逻辑型数据的一维数组。执行组合功能的函数c()可用来创建向量。



a <- c(1,2,3,4,5,6)b <- c('one','two','three')c <- c(TRUE,TRUE,FALSE,FALSE)
    单个向量中的数据必须拥有相同的类型或模式(数值型、字符型或逻辑型),同一向量中无法混杂不同模式的数据。
②矩阵(matrix)
    矩阵是一个二维数组,只是每个元素都拥有相同的模式(数值型、字符型或逻辑型)。可通过函数matrix创建矩阵。








a <- matrix(1:20,nrow=5,ncol=4)print(a)     [,1] [,2] [,3] [,4][1,]    1    6   11   16[2,]    2    7   12   17[3,]    3    8   13   18[4,]    4    9   14   19[5,]    5   10   15   20
③数组(array)
    数组与矩阵类似,但是维度可以大于2。数组可通过array函数创建。





















dim1 <- c('A1','A2')dim2 <- c('B1','B2','B3')dim3 <- c('C1','C2','C3','C4')a <- array(1:24,c(2,3,4),dimnames=list(dim1,dim2,dim3))print(a), , C1   B1 B2 B3A1  1  3  5A2  2  4  6, , C2   B1 B2 B3A1  7  9 11A2  8 10 12, , C3   B1 B2 B3A1 13 15 17A2 14 16 18, , C4   B1 B2 B3A1 19 21 23A2 20 22 24
④数据框(dataframe)
    由于不同的列可以包含不同类型(数值型、字符型等)的数据,数据框的概念较矩阵来说更为一般。它与你通常在Excel、SPSS看到的数据集类似。数据框将是R中最常处理的数据结构。数据框可通过函数data.frame()创建。






df <- data.frame(col1=c(1,2,3),col2=c('a','b','c'),col3=c(TRUE,FALSE,FALSE))df  col1 col2  col31    1    a  TRUE2    2    b  TRUE3    3    c FALSE
⑤因子(factor)
    变量可归结为名义型有序型连续型变量。
    名义型变量是没有顺序之分的类别变量。糖尿病类型Diabetes(Type1、Type2)是名义型变量的一例。即使在数据中Type1编码为1而Type2编码为2,这也并不意味着二者是有序的。
    有序型变量表示一种顺序关系,而非数量关系。病情Status(poor, improved, excellent)是顺序型变量的一个上佳示例。我们明白,病情为poor(较差)病人的状态不如improved(病情好转)的病人,但并不知道相差多少。
    连续型变量可以呈现为某个范围内的任意值,并同时表示了顺序和数量。年龄Age就是一个连续型变量,它能够表示像14.5或22.8这样的值以及其间的其他任意值。
    类别(名义型)变量和有序类别(有序型)变量在R中称为因子(factor)。因子在R中非常重要,因为它决定了数据的分析方式以及如何进行视觉呈现。因子可以用factor创建。要表示有序型变量,需要为函数factor()指定参数ordered=TRUE












#类别diabetes <- c('Type1','Type2','Type1','Type1')diabetes <- factor(diabetes)  #将此向量存储为(1, 2, 1, 1),并在内部将其关联为 1=Type1和2=Type2print(diabetes)[1] Type1 Type2 Type1 Type1Levels: Type1 Type2#有序类别status <- c('Poor','Improved','Excellent','Poor')status <- factor(status, ordered=TRUE) #会将向量编码为(3, 2, 1, 3),并在内部将这些值关联为1=Excellent、2=Improved以及3=Poorprint(status)[1] Poor  Improved  Excellent Poor     Levels: Excellent < Improved < Poor
⑥列表(list)
    列表是R的数据类型中最为复杂的一种。一般来说,列表就是一些对象的有序集合。列表允许你整合若干(可能无关的)对象到单个对象名下。例如,某个列表中可能是若干向量、矩阵、数据框,甚至其他列表的组合。可以使用函数list()创建列表。


















a <- 'hello world'b <- c(1,2,3)c <- matrix(1:4,2,2)d <- data.frame(x=c(1,2),y=c('a','b'))List <- list(Str = a,vector = b, matrix = c,dataframe = d) #创建列表并给列表命名List$Str[1] "hello world"$vector[1] 1 2 3$matrix     [,1] [,2][1,]    1    3[2,]    2    4$dataframe  x y1 1 a2 2 b

3、Python与R数据结构比较
    总体而言,R自带的数据结构更适合数据分析,而Python的第三方库Numpy、Pandas弥补了其在数据分析方面的不足。

数据组织形式
Python实现
R实现
一维数组
列表(list)
元组(tuple)
集合(set)
序列(pandas.Series)
向量(vector)
二维数组
列表(list)
元组(tuple)
多维数组(numpy.ndarray)
矩阵(matrix)
多维数组
列表(list)
元组(tuple)
多维数组(numpy.ndarray)
数组(array)
行列式结构
数据框(pandas.DataFrame)
数据框(data.frame)
键值对
字典(dict)
列表(list)
多种数据的集合
列表(list)
元组(tuple)
列表(list)


三、程序的结构
1、注释
    注释在程序中不会被运行,仅作为标记或记录使用,在编程中使用注释是正确的风格。
    Python中的注释分为单行注释(使用#)和多行注释(使用'''或者""")













#单行注释#第一个注释#第二个注释#多行注释一'''第三个注释第四个注释'''#多行注释二"""第五个注释第六个注释"""
   R只提供单行注释


#第一个注释#第二个注释

2、代码块
    代码块是一种常见的代码形式,一般来讲,一个代码块可执行一个功能。
    python最具特色的就是使用冒号":"和缩进来表示代码块,不需要使用大括号 {} 。缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。实例如下:








#条件判断代码块if True:    print ("True")else:    print ("False")#for循环代码块for i in [1,2,3,4]:    print (i)

    如果代码最后一行语句缩进数的空格数不一致,会导致运行错误:












if True:    print ("True1")    print ("True2")else:    print ("False1")  print ("False2")    # 缩进不一致,会导致运行错误#以上代码运行结果如下  File "<tokenize>", line 6    print ("False2")    # 缩进不一致,会导致运行错误    ^IndentationError: unindent does not match any outer indentation level
    R使用{}表示代码块,空行缩进量不会对代码产生影响;但不建议仅仅用{},因为这样结构层次并不明显,不易维护与他人阅读,良好的习惯是在R中也使用缩进!




#条件判断代码块if (TRUE) {print ("TRUE")} else {print ("FALSE")}#for循环代码块for (i in 1:4) {print (i)}
      良好的R编程风格应该是:










#条件判断代码块if (TRUE) {    print ("TRUE")} else {    print ("FALSE")}#for循环代码块for (i in 1:4) {    print (i)}

3、条件判断
    什么是条件判断,简单的讲,就是有一个条件,如果条件满足(True),就执行一个操作,如果条件不满足(False),就执行另外一个操作,如下图所示:
①单一判断:if...else...
②多重判断:if...else if...else...
     Python中的条件判断使用if...elif...else...结构








a = 5b = 10if a == b:    print ('a等于b')elif a > b:    print ('a大于b')else:    print ('a小于b')
    R中的条件判断使用if...else if...else...结构









a <- 5b <- 10if (a == b){    print ('a等于b')}else if (a > b){    print ('a大于b')}else{    print ('a小于b')}

4、循环
    在不少实际问题中有许多具有规律性的重复操作,因此在程序中就需要重复执行某些语句。循环结构是在一定条件下反复执行某段程序的流程结构,被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。循环包括遍历循环和无限循环。
4.1 遍历循环
    先说一下什么是遍历。举个例子,老王一共有5个孩子,过年时每个孩子给老王1000块的红包。每个孩子1个红包,谁也不落下,这就是遍历。1000红包数额是固定的,老王共收了5个红包,这就是循环了5次。再举个例子,9*9乘法口诀,从1到9,遍历了两遍,一共9×9=81个循环。遍历循环需要使用for和in进行定义,for x in set,表示将set中的每一个x,执行相同的操作。
①Python中的for循环























#老王每个孩子给他发红包children = ['老大','老二','老三','老四','老五']for  child in children: #使用in遍历children中的每一个child    print (child + '给了老王1000块钱的红包')老大给了老王1000块钱的红包老二给了老王1000块钱的红包老三给了老王1000块钱的红包老四给了老王1000块钱的红包老五给了老王1000块钱的红包   #for循环9*9乘法口诀for row in range(1, 10):    for col in range(1, row+1):        print('{}*{}={}'.format(col, row, col * row), end=' ')    print()       1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
②R中的for 循环


























#老王每个孩子给他发红包children <- c('老大','老二','老三','老四','老五')for  (child in children){ #使用in遍历children中的每一个child    print (paste0(child, '给了老王1000块钱的红包'))}[1] "老大给了老王1000块钱的红包"[1] "老二给了老王1000块钱的红包"[1] "老三给了老王1000块钱的红包"[1] "老四给了老王1000块钱的红包"[1] "老五给了老王1000块钱的红包"   #for循环9*9乘法口诀for (row in 1:9){    for (col in 1:row){        cat(col,'*',row,'=',col*row,' ',sep='')    }    cat('\n')}1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
4.2 无限循环
    什么又是无限循环呢?我们再次请老王和他的孩子们出来,老王有天生病了,需要孩子照顾们照顾,但5个孩子每个最多能请1天假,前5天每天都是由孩子照顾(这就是循环了5次),后面就需要请保姆了。无限循环需要使用while定义。while循环结构中,除了要执行的操作,通常还包括两个内容:第一,使用while判断是否继续循环,第二,变量的重新赋值,比如 i = i +1。这就表示在一轮循环开始时,首先判断是否符合条件,如果符合,执行某个操作,然后在原有i的基础上加一个1,再进入下一轮循环,直到不符合条件便终止循环。如果不重新赋值,程序便会一直运行下去,进入一个真正的“无限”循环,也成“死循环”。
①Python中的while循环




























#孩子照顾生病的老王i = 1while i <=5:     print('孩子照顾了老王{}天'.format(i) )    i = i+1 孩子照顾了老王1天孩子照顾了老王2天孩子照顾了老王3天孩子照顾了老王4天孩子照顾了老王5天#while循环9*9乘法口诀row = 1while row <= 9:    col = 1    while col <= row:        print('{}*{}={}'.format(row, col, row * col), end=' ')        col = col+1    print()    row = row+11*1=1 2*1=2 2*2=4 3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 4*3=12 4*4=16 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
②R中的while循环































#孩子照顾生病的老王i = 1while (i <=5){    print(paste0('孩子照顾了老王',i,'天' ))    i = i+1}    [1] "孩子照顾了老王1天"[1] "孩子照顾了老王2天"[1] "孩子照顾了老王3天"[1] "孩子照顾了老王4天"[1] "孩子照顾了老王5天"#while循环9*9乘法口诀row = 1while (row <= 9){    col = 1    while (col <= row){        cat(col,'*',row,'=',col*row,' ',sep='')        col = col+1     }      cat('\n')     row = row+1}   1*1=1 2*1=2 2*2=4 3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 4*3=12 4*4=16 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

四、函数
1、使用函数
    首先,举一个数学中的函数(function)的例子:
    f(x) = x+ x^2 ......表示为:f(x)的值是x加x的平方,x是函数的参数,x+ x^2是函数的计算过程。当x=2时,f(2)=2+2^2=6
    f(x,y) = (x+y)^2......表示为:f(x,y)是x+y的和的平方,x和y是函数的参数,(x+y)^2是函数的计算过程,当x和y分别为1和2时, f(1,2)=(1+2)^2=9
    程序的函数与数学中的函数类似,比如sum()在python程序中是一个求和的函数。我们定义一个变量 a =[1,2,3,4,5],在sum()函数的括号内传入参数a,然后该函数执行一个过程,并返回一个求和的结果,这样程序就完成了一个调用函数的过程。






#Python中的求和函数a = [1,2,3,4,5]sum(a)#R中的求和函数a = c(1,2,3,4,5)sum(a)
    除了数学计算函数,在程序中出现带括号xxx()的,都可称之为函数。比如print()函数,是将括号内输入的内容打印在显示器上;再比如pandas.Series([1,2,3])是将括号内的列表生成一个序列。除了带括号的,运算符(+、-、*、/、==,in、and等)也是特殊的函数。
    函数的使用,在Python和R中有所区别。
    在R中,使用函数的方法单一,都是将数据和参数置于xxx()的括号内,比如:sum(c(1,2,3))、head(data)等




#R中使用函数的方式sum(c(1,2,3,4,5)) #对向量求和data <- data.frame(x=c(1,2,3,4,5,6,7,8),y=c('a','b','c','d','e'))head(data,3) #查看data.frame的前几行
    在Python中使用函数,除了将数据和参数置于xxx()括号内,还可以通过".xxx()"的方式。这是因为Python是面向对象编程(详见本文第五章),'.xxx()'是引用该类的一个方法,这种函数的使用方法用于一些内置类,比如numpy的ndarray类求和时使用sum()函数,pandas的DataFrame对象查看前几行数据使用head()函数。
    Python的两种函数使用方法,要注意以下两点区别:
    ①直接使用xxx()的方式,通常是Python自带的函数,或者基于Python内置数据结构自编的函数,一般仅支持Python内置数据结构(某些函数对numpy、pandas的数据结构也支持);
    ②使用'.xxx()'方式使用函数,这个函数通常是第三方库所带数据结构的一个方法,比如numpy中ndarray可以使用sum()函数,你可以在ndarray上使用该方法,但不能在Python自带的列表上使用,np.array([1,2,3,4,5]).sum()可以正常运行,但[1,2,3,4,5].sum()就会报错。














#Python中使用函数方式一:括号内使用a = [1,2,3,4,5]sum(a)a.sum() #会报错#Python中使用函数方式二:使用对象的方法import numpy as npb = np.array([1,2,3,4,5]) b.sum()  #ndarray对象求和时使用sum()函数sum(b)   #对ndarray对象求和也可以调用Python自带的sum()函数 import pandas as pddf = pd.DataFrame({'x':[1,2,3,4,5],'y':['a','b','c','d','e']})df.head(3) #pandas的DataFrame对象查看前几行数据使用head()函数df.x.sum() #DataFrame对象对x列求和sum(df.x)  #对DataFrame的列求和也可以调用Python自带的sum()函数

2、编写函数
    一般来说,无论是程序内置函数,还是第三方库/包提供的函数,很难满足你各种奇奇怪怪的要求,比如:你想根据体重和身高计算BMI,并建议是否需要增重或减肥。这时候你就需要自己编写一个函数实现此功能了。
    函数的定义过程分为以下几个部分:
    step1:告诉程序,你要定义一个函数了,函数的名字是什么,要传入哪些数据、哪些参数;
    step2:函数的运算过程(相当于是把传递的数据、参数作为变量,进行一些运算);
    step3:程序最终返回的结果(也可以不返还任何结果)。
 ①Python定义函数的过程如下:



















#根据体重、身高计算BMI,并给出建议#step1:使用关键词def定义函数,BMI是函数的名称,括号内的weight、height是两个参数def BMI(weight,height):     #step2.1:将weight、height作为函数内变量,在函数内进行运算,生成BMI值      bmi = weight/height**2       #step2.2:将计算所得结果bmi作为一个函数内变量,根据bmi大小,新生成一个变量suggestion    if bmi < 18:          suggestion = '偏瘦,需要增重了!'    elif bmi >24:        suggestion = '偏胖,需要减肥了!'     else:        suggestion = '正常,请继续保持!'    #step3:将所有运算结果整合至一段话,并返回一个最终结果        return ('您的体重为:%dkg,身高为:%.2fm,BMI指数为:%.2f,体型%s'%(weight, height, bmi,suggestion))BMI(70,1.8) #使用函数时,如果不指名参数是哪个,位置要与函数定义中的参数保持一致#或者BMI(height=1.8,weight=70)  #如果指名参数是哪个,位置可以随意调整#以上代码输出结果为:'您的体重为:70kg,身高为:1.80m,BMI指数为:21.60,体型正常,请继续保持!'
②R定义函数的过程如下:





















#根据体重、身高计算BMI,并给出建议#step1:使用关键词function定义函数,BMI是函数的名称,括号内的weight、height是两个参数BMI<-function(weight,height){    #step2.1:将weight、height作为函数内变量,在函数内进行运算,生成BMI值      bmi <- weight/height**2       #step2.2:将计算所得结果bmi作为一个函数内变量,根据bmi大小,新生成一个变量suggestion    if (bmi < 18){        suggestion <- '偏瘦,需要增重了!'    } else if(bmi >24) {        suggestion <- '偏胖,需要减肥了!'     }else{        suggestion = '正常,请继续保持!'    }    #step3:将所有运算结果整合至一段话,并返回一个最终结果        return (paste0('您的体重为:',weight,'kg,身高为:',height,'m,BMI指数为:',round(bmi,2),',体型',suggestion))}BMI(70,1.8) #使用函数时,如果不指名参数是哪个,位置要与函数定义中的参数保持一致#或者BMI(height=1.8,weight=70)  #如果指名参数是哪个,位置可以随意调整#以上代码输出结果为:'您的体重为:70kg,身高为:1.80m,BMI指数为:21.60,体型正常,请继续保持!'

五、编程方式
1、面向过程编程(Procedure Oriented Programming, POP)
    从名字可以看出它是注重过程的。当解决一个问题的时候,面向过程会把事情拆分成: 一个个函数和数据(用于方法的参数) 。然后按照一定的顺序,执行完这些方法(每个方法看作一个过程),等方法执行完了,事情就搞定了。
    面向过程编程很容易理解,此处举个计算BMI值的例子:首先定义一个计算BMI的函数,然后在函数中输入体重和身高两个参数,得到计算结果,这样就完成了整个过程。以Python代码为例:





#定义一个函数def BMI(weight,height):    return (weight/height**2)#再函数中输入体重和身高完成计算BMI(70,1.8)

2、面向对象编程(Object Oriented Programming, OOP)
    看名字它是注重对象的。当解决一个问题的时候,面向对象会把事物抽象成对象的概念,就是说这个问题里面有哪些对象,然后给对象赋一些属性和方法,然后让每个对象去执行自己的方法,问题得到解决。
    而面向对象编程难理解一些,想理解这种理念,有两个概念十分重要:类和对象。两者的关系,举个例子,比如钱,钱是一个事务的统称(),钱有几个特点:材质、属于某个国家、可以交易(这些都是属性),显而易见,钱这个概念比较虚。美元,它是钱的实际例子(实例化),拥有钱的所有特点(材质是纸、属于美国、可以交易),可以说,美元是钱的一个对象。当然,人民币、英镑、欧元等都是钱的对象。
    再次以计算BMI为例,面向对象编程过程如下:我们首先定义一个类(比如叫体重管理类),这个类包括体重和身高两个属性,还包括一个计算BMI的方法;然后我们创建该类的一个对象,然后使用该类的方法(本文第四章,".xxx()"的方式使用函数),得到BMI值。以Python代码为例:




上一篇>>CloudCone:$3/月KVM-1GB/20GB/1TB/洛杉矶(MC)

下一篇>>Python 的 RST 文件是什么


可能下面的内容我们比较有兴趣>>