a, b = 0, 1while b < 10:print(b) #print(b,end=',')a, b = b, a+b相当于n=bm=a+ba=nb=m输出：112358#输出：1，1，2，3，5，8

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符！

条件控制：

1、每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块。2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。3、在Python中没有switch – case语句。

循环：

for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

continue语句，跳出本次循环，进行下一次循环；

range（初始值，终点值（取不到），步长）

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter()和next()。

字符串，列表或元组对象都可用于创建迭代器：

#!/usr/bin/python3list=[1,2,3,4]it = iter(list) # 创建迭代器对象for x in it:print (x, end=" ")1 2 3 4

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。

更多内容查阅：Python3 面向对象

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

#!/usr/bin/python3class MyClass:"""一个简单的类实例"""i = 12345def f(self):return 'hello world'# 实例化类x = MyClass()# 访问类的属性和方法print("MyClass 类的属性 i 为：", x.i)print("MyClass 类的方法 f 输出为：", x.f())MyClass 类的属性 i 为： 12345MyClass 类的方法 f 输出为： hello world

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:

#!/usr/bin/python3class Complex:def __init__(self, realpart, imagpart):self.r = realpartself.i = imagpartx = Complex(3.0, -4.5)print(x.r, x.i) # 输出结果：3.0 -4.5

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:def prt(self):print(self)print(self.__class__)t = Test()t.prt()#输出<__main__.Test object at 0x0000028E52F59B00><class '__main__.Test'>

类的方法

在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。后续再使用def关键字时，就可以使用_init_中的self，但你不可以在已经定义的self外引用参数。更近一步，如果想要新加self参数，可以用类的继承！

实例(Python 3.0+)#!/usr/bin/python3#类定义class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))# 实例化类p = people('runoob',10,30)p.speak()#输出runoob 说: 我 10 岁。

继承

继承Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。

#!/usr/bin/python3#类定义class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例class student(people):grade = ''def __init__(self,n,a,w,g):#调用父类的构函people.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))s = student('ken',10,60,3)s.speak()执行以上程序输出结果为：ken 说: 我 10 岁了，我在读 3 年级

更多关于类的说明，点击直达

总结：

#!/usr/bin/python3class MyClass:"""一个简单的类实例"""i = 12345def f(self):return 'hello world'# 实例化类x = MyClass()# 访问类的属性和方法print("MyClass 类的属性 i 为：", x.i)print("MyClass 类的方法 f 输出为：", x.f())MyClass 类的属性 i 为： 12345MyClass 类的方法 f 输出为： hello world-------------------------------------------------------------------类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，#!/usr/bin/python3class Complex:def __init__(self, realpart, imagpart):self.r = realpartself.i = imagpartx = Complex(3.0, -4.5)print(x.r, x.i) # 输出结果：3.0 -4.5----------------------------------#单继承示例class student(MyClass):grade = ''def __init__(self,n,a,w,g):#调用父类的构函MyClass.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))s = student('ken',10,60,3)s.speak()执行以上程序输出结果为：ken 说: 我 10 岁了，我在读 3 年级

函数

定义一个函数

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

函数代码块以def关键词开头，后接函数标识符名称和圆括号()。任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。函数内容以冒号起始，并且缩进。return [表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

#!/usr/bin/python3# 计算面积函数def area(width, height):return width * heightdef print_welcome(name):print("Welcome", name)print_welcome("Runoob")w = 4h = 5print("width =", w, " height =", h, " area =", area(w, h))以上实例输出结果：Welcome Runoobwidth = 4 height = 5 area = 20

匿名函数

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

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

#!/usr/bin/python3# 可写函数说明sum = lambda arg1, arg2: arg1 + arg2# 调用sum函数print ("相加后的值为 : ", sum( 10, 20 ))print ("相加后的值为 : ", sum( 20, 20 ))以上实例输出结果：相加后的值为 : 30相加后的值为 : 40

return语句

return [表达式]语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

#!/usr/bin/python3# 可写函数说明def sum( arg1, arg2 ):# 返回2个参数的和."total = arg1 + arg2print ("函数内 : ", total)return total# 调用sum函数total = sum( 10, 20 )print ("函数外 : ", total)以上实例输出结果：函数内 : 30函数外 : 30

变量作用域

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

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

L （Local） 局部作用域E （Enclosing） 闭包函数外的函数中G （Global） 全局作用域B （Built-in） 内置作用域（内置函数所在模块的范围）

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

g_count = 0 # 全局作用域def outer():o_count = 1 # 闭包函数外的函数中def inner():i_count = 2 # 局部作用域

调用函数使用的是函数内部的局部变量，未调用函数，使用的是全局变量！

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

更多关于函数内容，点击

数据结构

数据结构是编程的基础，必须熟练掌握！