目录

一、逻辑控制语句

条件控制语句 if-else

for 循环语句

while 循环

break 语句

continue 语句

Pass 语句

二、函数

函数的定义与调用

参数传递

函数的参数类型

Return 语句

三、类

类的定义

self 参数

实例化

Python 中类定义与 Java、C++ 的差别

继承

函数的重写

私有属性与私有方法

一、逻辑控制语句

条件控制语句 if-else

Python 条件控制语句的形式为：

if Condition1:Action1 
elif Condition2:Action2
else:Action3  

注意要点

1. 每个条件后面要使用冒号 :。
2. 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块（IDE 会自动缩进）。
3. 在 Python 中没有 switch–case 语句。

条件控制语句实例

实例1：从控制台输入两个数字 A、B，判断大小后输出较大数字，如果相等则输出提示和数值。

#从控制台输入数据默认为字符串类型，需要强制转换为int类型
A = int(input("Please enter the number A:"))
B = int(input("Please enter the number B:"))
if A > B:print('The larger number is:',A) 
elif A == B:print('A and B are equal to ',A)  
else:print('The larger number is:',B) 

执行结果：

for  in :

实例1：求一组数据的平均值。

#测试数据集
num_set = [98,94,82,67,58,90,86]
sumOfNum = 0
#遍历列表中的元素，求和
for element in num_set:sumOfNum += element
#求平均值并打印结果    
average = sumOfNum/len(num_set)
print("The average is:%f"%(average))

执行结果：

for index in range(4):print("index:",index)

执行结果：

#测试数据集
city_set = ['BeiJin','TianJin','ShangHai','HangZhou','SuZhou']
#索引从0开始，以步长2遍历
for index in range(0,len(city_set),2):print("city_set[%d]:%s"%(index,city_set[index]))

执行结果：

while Conditon:Action

实例1：求一组数据的平均值。

#初始化测试数据
num_set = [98,94,82,67,58,90,86]
sumOfNum = 0
index = 0while index < len(num_set):sumOfNum += num_set[index]index += 1
#求平均值并打印结果    
average = sumOfNum/len(num_set)
print("The average is:%f"%(average))

执行结果：

#初始化测试数据
num_set = [98,94,82,67,58,90,86]
for i in range(len(num_set)):if num_set[i] < 60:print("Someone failed!")breakelse:print(num_set[i])

执行结果：

#初始化测试数据
num_set = [98,94,82,67,58,90,86]
for i in range(len(num_set)):if num_set[i] < 60:print("Someone failed!")continueprint(num_set[i])

执行结果：

#初始化测试数据
num_set = [98,94,82,67,58,90,86]
for i in range(len(num_set)):if num_set[i] < 60:print("Someone failed!")else:pass

二、函数

在实际应用中，通常以函数作为一个基本的代码单元，对一组需求进行抽象，用于完成一项具体的任务。函数能提高应用的模块性，和代码的重复利用率。Python 会提供一些内建函数，比如 print()、sqrt()、append()、pop()。我们也可以自己创建函数，这种函数被称为用户自定义函数。

函数的定义与调用

在 C/C++、Java 中，函数（方法）的定义形式如下：

修饰符1，修饰符2，…，返回值类型，函数名（参数列表）
public static String getPath(String basePath, String fileName)

Python 中函数的定义则“简洁”得多，Python 函数无需声明返回值类型，也无需修饰符，一般地，函数的定义形式如下：

函数定义符，函数名（参数列表）
def getPath(basePath, fileName):
def getName():

下面的代码中定义了一个比较函数，并执行了3次调用。

#定义函数
def compare(parameter1, parameter2):if (parameter1 > parameter2):print(1)elif (parameter1 == parameter2):print(0)else:print(-1)#调用函数
compare(123,456)
compare(3.14,1.5)
compare(12,12.1)

执行结果：

a = 12
print("a=", a)
a = "ABCDE"
print("a=", a)
a = [1,2,3,4,5]
print("a=", a)
a = (1,2,3,4)
print("a=", a)
a = {'key':12,'key1':13}
print("a=", a)

执行结果：

def change(x):x = 10a = 5
change(a)
print("a=",a)

执行结果：

def change(x):x.append(2012)a = [1,2,3,4]
change(a)
print("a=",a)

执行结果：

#声明参数为一个
def update(arg):arg = arg + 1#正确
update(12)
#不正确，参数缺失
update()
#不正确，参数多余
update(1,2)

实例2：参数顺序要一致。

def printInfo(name, sex, age):print("name:",name)print("sex:",sex)print("age:",age)#正确
printInfo("Jack","female", 18)
#错误，参数顺序不对应
printInfo(18,"Jack","female")

关键字参数

上面已经提到，调用函数时，不仅参数数量要相等，还要顺序匹配。在 Python 中，还有一种方式可以更灵活的匹配参数：函数调用使用关键字参数来确定传入的参数值。

如下实例：

def printInfo(name, sex, age):print("name:",name)print("sex:",sex)print("age:",age)#都是正确的
printInfo(name="Jack",sex="female",age=18)
printInfo(sex="female",name="Jack",age=18)
printInfo(sex="female",age=18,name="Jack")

默认参数

有些场景下，如果调用函数时，参数错误可能会导致不可预期的严重后果，因此，为了增强函数的适应性和容错性，可以采取一种策略：调用函数时，如果没有传递参数，则会使用默认参数。如下实例：

#声明参数为一个
def printInfo(name, sex, age=0):print("name:",name)print("sex:",sex)print("age:",age)#正确
printInfo(name="Jack",sex="female")

不定长参数

有些场景下，我们希望设计一个参数数量不确定的函数，如任意个整数求和，调用形式可以是：sum(a)、sum(a,b,c)、sum(a,b,c,d)……，这时候我们需要使用一种不定长参数，一般定义形式如下：

def functionname([formal_args,] *var_args_tuple ):functionbody

加了（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

#定义一个求和函数
def sum(num, *num_list):sum = numfor element in num_list:sum += elementprint("sum=",sum)sum(1)
sum(1,2,3,4)

执行结果：

#定义比较函数
def compare(parameter1, parameter2):if (parameter1 > parameter2):return 1elif (parameter1 == parameter2):return 0else:return -1result = compare(123,456)
print("result=",result)

执行结果：

#这里的a是全局变量
a = 123
def function():a = 10 #这里的a是局部变量print("I a=",a)function()
print("II a=",a)

执行结果：

class ClassName:...

上面提到，类的本质是一种数据结构，一个类通常包含数据成员和函数成员。数据成员用于刻画类所描述的一类事物的属性，如描述人，一般用姓名、年龄、性别、学历等属性进行刻画，这就是数据成员；函数成员用于完成具体的任务，如查询、设置人名、打印基本信息等。如下实例：

#定义一个简单的类，描述一个人的基本信息        
class Person:#定义类的数据成员：姓名，年龄name=''age=0#定义一个函数：打印类实例的基本信息    def printPersonInfo(self):print('person-info:{name:%s, age:%d}'%(self.name,self.age))#定义一个简单的函数def hello(self):print("hello world!")#实例化，创建一个对象
p1 = Person()
#访问类的属性：数据成员,访问语法obj.X
print("name:",p1.name)
print("age:",p1.age)
#访问类的函数
p1.printPersonInfo()
p1.hello()

执行结果：

#定义一个简单的类，描述一个人的基本信息        
class Person:#定义类的数据成员：姓名，年龄name=''age=0#定义一个函数：打印类实例的基本信息    def printPersonInfo(self):print('name:',self.name)print('self:',self)print('self class:',self.__class__)#实例化，创建一个对象
p1 = Person()
#访问类的函数
p1.printPersonInfo()

执行结果：

 p1 = Person()

类中并没有定义名为 Person() 的函数，Person 是类名，在进行实例化创建对象的时候，会自动调用__init()__函数。该函数用于创建对象，并赋予所创建对象初始状态。

上述例子中，做了很多简化，创建的对象的所有属性都是默认值，在实际应用中，通常会采取更有效的方式来赋予对象初始状态。如下实例：

#定义一个简单的类，描述一个人的基本信息        
class Person:#定义类的数据成员：姓名，年龄name=''age=0  
#定义构造函数，用于创建一个类实例，也就是类的具体对象
#通过参数传递，可以赋予对象初始状态def __init__(self,name,age):self.name = nameself.age = age  #定义一个函数：打印类实例的基本信息    def printPersonInfo(self):print('person-info:{name:%s, age:%d}'%(self.name,self.age))#实例化，创建两个对象，默认调用构造函数：__init__()
p1 = Person("Zhang San",12)
p2 = Person("Li Si",13)
#访问类的属性：数据成员,访问语法obj.X
print("name:",p1.name)
print("age:",p1.age)
#调用函数
p1.printPersonInfo()
p2.printPersonInfo()

运行结果：

#定义一个简单的类，描述一个人的基本信息        
class Person:#定义构造函数，用于创建一个类实例，也就是类的具体对象def __init__(self,name,age):self.name = nameself.age = age  #定义一个函数：打印类实例的基本信息    def printPersonInfo(self):print('person-info:{name:%s, age:%d}'%(self.name,self.age))

继承

继承可谓一种带有褒义的懒惰行为，一个最直观的好处就是减少编写重复代码，通过继承，子类可以重用父类中的函数和数据成员。当然，继承的意义远不止于此，这里就不展开了。

关于继承，通常将实施继承行为的类称为子类（Child Class）或者派生类（Derived Class），被继承的类称为父类（Parent Class）或者基类（Base Class)。与 Java、C++ 相比，Python 中继承的一般形式颇为简洁：

class childClassName(parentClassName):...

下面结合实例来看一下，定义一个类 Occupation 和一个继承 Occupation 的类 Person，继承的定义形式为：Person(Occupation)，无需关键词声明。

#定义一个类Occupation，描述职业
class Occupation:#定义构造函数def __init__(self,salary,industry):self.salary = salaryself.industry = industrydef printOccupationInfo(self):print('Occupation-info:{salary:%d, industry:%s}'%(self.salary,self.industry)) #定义一个简单的类Person,继承自类Occupation     
class Person(Occupation):def __init__(self,name,age):self.name = nameself.age = age  #定义一个函数：打印类实例的基本信息    def printPersonInfo(self):print('person-info:{name:%s, age:%d}'%(self.name,self.age))#创建一个子类对象
temp = Person('Wu-Jing',38)
#访问父类的数据成员
temp.salary = 21000
temp.industry = "IT"
#分别调用本身和父类的函数
temp.printOccupationInfo()
temp.printPersonInfo()

执行结果：

class childClassName(parentClassName1，parentClassName2，…):...

关于多继承，实例如下：

#定义一个类BankAccount，描述银行账户
class BankAccount:def __init__(self,number, balance):self.number = numberself.balance = balance  #计算并返回年利息def getAnnualInterest (self):return self.balance*0.042  #定义一个类Occupation，描述职业
class Occupation:def __init__(self,salary,industry):self.salary = salaryself.industry = industrydef printOccupationInfo(self):print('Occupation-info:{salary:%d, industry:%s}'%(self.salary,self.industry)) #定义一个类Person,继承自类BankAccount和BankAccount      
class Person(Occupation,BankAccount):def __init__(self,name,age):self.name = nameself.age = age  #定义一个函数：打印类实例的基本信息    def printPersonInfo(self):print('person-info:{name:%s, age:%d}'%(self.name,self.age))#创建一个子类对象
temp = Person('Wu-Jing',38)
#访问父类数据成员
temp.number = 622202050201
temp.balance = 1000000.99
temp.salary = 21000
temp.industry = "IT"
#分别调用本身和父类的函数
temp.printOccupationInfo()
temp.printPersonInfo()
print('Annual interest:',temp.getAnnualInterest())

执行结果：

#定义一个类 BankAccount，描述银行账户
class BankAccount: def printInfo(self):print('BankAccount-info')  #定义一个类 Occupation，描述职业
class Occupation:def printInfo(self):print('Occupation-info') #定义一个类 Person,继承自类 BankAccount 和 BankAccount      
class Person(Occupation,BankAccount):def __init__(self,name,age):self.name = nameself.age = age  def printPersonInfo(self):print('person-info')#创建一个子类对象
temp = Person('Wu-Jing',38)
#调用父类中的函数
temp.printInfo()

执行结果：

#定义一个类Occupation，描述职业
class Occupation:#定义构造函数def __init__(self,salary,industry):self.salary = salaryself.industry = industrydef printInfo(self):print('salary:%d, industry:%s}'%(self.salary,self.industry)) #定义一个简单的类Person,继承自类Occupation     
class Person(Occupation):def __init__(self,name,age):self.name = nameself.age = age  #定义一个函数：打印类实例的基本信息    def printInfo(self):print('name:%s, age:%d'%(self.name,self.age))print('salary:%d, industry:%s'%(self.salary,self.industry))#创建一个子类对象
temp = Person('Wu-Jing',38)
#访问父类的数据成员
temp.salary = 21000
temp.industry = "IT"
#分别调用函数printInfo()
temp.printInfo()

执行结果：

#定义一个简单的类，描述一个人的基本信息        
class Person:#定义两个私有属性name,agedef __init__(self,name,age):self.__name = nameself.__age = age  #定义公有函数，在类外部可以访问    def getName(self):self.__fun()return self.__namedef getAge(self):return self.__age#定义一个私有函数，只能在类内部使用def __fun(self):print('hello')#实例化
p1 = Person("Zhang San",12)
#访问类的私有属性和私有函数，将会报错
print("name:",p1.__age)
print("age:",p1.__name)
p1.__fun()

对于私有属性和私有函数，如果需要在类外访问，可以通过公有函数实现，这与 Java 和 C++ 是一致的。

如下实例：

#定义一个简单的类，描述一个人的基本信息        
class Person:#定义两个私有属性name,agedef __init__(self,name,age):self.__name = nameself.__age = age  #定义公有函数，在类外部可以访问    def getName(self):self.__fun()return self.__namedef getAge(self):return self.__age#定义一个私有函数，只能在类内部使用def __fun(self):print('hello')#实例化
p1 = Person("Zhang San",12)
#访问类的公有函数
print("name:",p1.getName())

执行结果：

hello
name: Zhang San

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！