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
更多关于函数内容,点击
数据结构
数据结构是编程的基础,必须熟练掌握!