python编程-迭代器（类，方法，继承），函数，数据结构，
a, b = 0, 1
while b < 10:
print(b) #print(b,end=',')
a, b = b, a+b
相当于
n=b
m=a+b
a=n
b=m
输出：
1
1
2
3
5
8
#输出：
1，1，2，3，5，8关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符！
条件控制：
- 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
- 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
- 3、在Python中没有switch – case语句。
循环：
for 实例中使用了 break 语句，break 语句用于跳出当前循环体：
continue语句，跳出本次循环，进行下一次循环；
range（初始值，终点值（取不到），步长）
迭代器
迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器：
#!/usr/bin/python3
list=[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/python3
class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：
当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:
#!/usr/bin/python3
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i) # 输出结果：3.0 -4.5self代表类的实例，而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
#输出
<__main__.Test object at 0x0000028E52F59B00>
类的方法
在类的内部，使用 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 = n
self.age = a
self.__weight = w
def 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 = n
self.age = a
self.__weight = w
def 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/python3
class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world
-------------------------------------------------------------------
类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，
#!/usr/bin/python3
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = 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 * height
def print_welcome(name):
print("Welcome", name)
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
以上实例输出结果：
Welcome Runoob
width = 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
相加后的值为 : 40return语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：
#!/usr/bin/python3
# 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", 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/python3
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total
#调用sum函数
print ("函数外是全局变量 : ", total)
sum( 10, 20 )
输出
函数外是全局变量 : 0
函数内是局部变量 : 30更多关于函数内容，点击
数据结构
数据结构是编程的基础，必须熟练掌握！
| 特征 | 常见用法 | ||
| 不可变数据 | 数字=123 | 用于计算，没有索引；注意优先级（**》*/》not》and》or） | >>> 17 % 3 # 取余 2 |
| 字符串='' | Python 字符串不能被改变，可以添加索引 常用用法：+字符串，*2复制2遍 |
a='string' a[0]='c' #非法 print(a[0]) #合法 print (a * 2) # 输出字符串两次 |
|
| 元组=（） | 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。 | tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号 |
|
| 可变数据 | 列表=[] | 可以被索引，可以更改（不同于字符串），列表中元素的类型可以不相同，+，*依旧有效； | >>>a = [1, 2, 3, 4, 5, 6] >>>del a[2] #删除列表元素 |
| 字典={} | 字典是无序的对象集合，不能通过索引，但可以通过键找值（键唯一）；构造字典方法很多； | b={'adf':'www','eee':123} a={} #构造空字典 |
|
| 集合={} | 集合区分其它数据类型很大一个特点就是：集合可以进行交集，差集，补集的运算。创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。 | # set可以进行集合运算 {'b', 'a', 'c', 'r', 'd'}#用{}拆分后表示 |
|
| 数据类型转换 | list() | list() 方法用于将元组,字符串,字典，集合转换为列表 其中，字符串转换成列表，是将字符串中的每个字符转换成列表的一个元素。 |
aTuple = (123, 'Google') 列表元素 : [123, 'Google'] |
| tuple() | tuple()将列表,字符串,字典，集合转换为元组；字符串都被单一拆分开来了； | list1= ['Google', 'Taobao'] ('Google', 'Taobao') |
|
| pandas | DataFrame | DataFrame是Python中Pandas库中的一种数据结构，它类似excel，是一种二维表。 | 可由列表，字典创建
|
| pandas | series | Series 是个定长的字典序列。Series有两个基本属性：index 和 values。 | |
| numpy | ndarray | list 的元素在系统内存中是分散存储的，而 NumPy 数组存储在一个均匀连续的内存块中，方便遍历；此外，numpy矩阵运算采用多线程方式，可以提升计算效率。 | |