[Python知识库]python学习随手笔记（2）

Python编程：

a, b = b, a+b 的计算方式为先计算右边表达式，然后同时赋值给左边,等价于：

n=b
m=a+b
a=n
b=m

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

条件控制：
Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

• 1、每个条件后面要使用 : 表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在Python中没有switch – case语句。
• 4、不用{ }包围代码块,不用加分号；表示结束。
• 5、多层嵌套if也是缩进相同而区分。

循环：
在 Python 中没有 do…while 循环。但有while…else语句，当判断为false执行else的语句，区别于if…else语句。

类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中。

for 语句：
Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。甚至可以不用给变量赋初始值并自增变量值，默认为初始0自增1。

一般格式：

for <variable> in <sequence>:# in不是那个判断是否包含的成员运算符！
    <statements>
else:
    <statements>

尤其循环遍历列表时，容易和if判断语句混淆：

#!/usr/bin/python3
 
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:  #从Baidu开始遍历，直到Runoob！
    if site == "Runoob":  #每次都进入if语句进行判断
        print("菜鸟教程!")
        break   #跳出当前if循环体
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!") 

 
 '''
    输出结果：
    循环数据 Baidu
    循环数据 Google
    菜鸟教程!
    完成循环! 
 '''

range()函数:
如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列。

>>>for i in range(0, 10, 3) : #10,3都是range的其他参数！
    print(i)
 
    
0
3
6
9

break 和 continue 语句及循环中的 else 子句：

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
???参考图片：https://www.runoob.com/python3/python3-loop.html

pass 语句:
Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句。

迭代器：

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

• 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
• 字符串，列表或元组对象都可用于创建迭代器,迭代器对象可以使用常规for语句进行遍历。

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2

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

创建迭代器：

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

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
#相当于面向对象里的构造函数，在对象初始化时执行，如php中的__construct()函数。

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

StopIteration：

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

生成器：

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

https://www.runoob.com/python3/python3-iterator-generator.html

函数：

注意缩进，冒号。def定义自定义函数。

参数传递：
变量不是类型，仅仅是一个指针（对象的引用）。

传可更改(mutable)与不可更改(immutable)对象：

strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a) #三次输出结果相同，表示虽然赋给了a新的值，实际上是让a指向那个创建的新知，而非改变了a的值，相当于新生成了a。

关键字参数：

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python 解释器能够用参数名匹配参数值。

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

#名字:  runoob
#年龄:  50

默认参数：
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值。

不定长参数：
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

还有一种就是参数带两个星号，参数会以字典的形式导入，基本语法如下：

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

PS：声明函数时，参数中星号 * 可以单独出现，但参数必须用关键字传入。

匿名函数：
使用 lambda关键字来创建匿名函数。

强制位置参数：

数据结构： https://www.runoob.com/python3/python3-data-structure.html

不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

列表推导式：

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。例：

嵌套列表解析：

列表可以互相嵌套。

元组和序列：
元组由若干逗号分隔的值组成，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

>>> t = 12345, 54321, 'hello!' #可以不带括号
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:    
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))  #元组可以被嵌套。

集合：

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

字典：

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。

遍历技巧：

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

其他遍历：

模块：
import关键字：

Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python标准库的方法。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。

from … import 语句：

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。

from … import * 语句：
把一个模块的所有内容全都导入到当前的命名空间也是可行的。

__name__属性：

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

包：

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

• 不用担心不同库之间的模块重名的情况
• 不用担心不同模块之间的全局变量相互影响

https://www.runoob.com/python3/python3-module.html

输入和输出:
传统的print（）输出以及repr() 函数来格式化输出值，第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

更加多样化的输出使用 str.format() 函数来格式化输出值。

str.format() 函数其它选项：

%运算符：

读和写文件 file 函数：

open()函数：https://www.runoob.com/python3/python3-inputoutput.html
?????????????????????https://www.runoob.com/python3/python3-file-methods.html

文件对象的方法：

• .read()
• .readlines()
• .write()
• .seek()
• 等等

pickle 模块：

python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

OS 文件/目录方法:

os(操作系统) 模块提供了非常丰富的方法用来处理文件和目录。

参考：https://www.runoob.com/python3/python3-os-file-methods.html

错误和异常：

参考：https://www.runoob.com/python3/python3-errors-execptions.html

异常处理：

• try/except语句
• try-finally语句

异常：

• raise 语句

用户自定义异常：
创建一个新的异常类来拥有自己的异常类。

面向对象：

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

__init__() 的方法（构造方法）：在类实例化时会自动调用。

self代表类的实例，而非类！
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称！按照惯例它的名称是 self。self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的。

从执行结果可以很明显的看出，self 代表的是类的实例（在php面向对象中学过，在类内用self代表类的实例即对象，可以实例化对象后直接调用！），代表当前对象的地址，而 self.class 则指向类。

类的方法：

继承：

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

多继承：

方法重写:
在子类中重写父类方法。

#!/usr/bin/python3
 
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

类属性与方法：

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

类的专有方法：

命名空间和作用域：

一般有三种命名空间：

内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

# var1 是全局名称
var1 = 5
def some_func():
 
    # var2 是局部名称
    var2 = 6
    def some_inner_func():
 
        # var3 是内嵌的局部名称
        var3 = 7

作用域：
Python 的作用域一共有4种:

• L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
• E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A
  里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
• G（Global）：当前脚本的最外层，比如当前模块的全局变量。
• B（Built-in）： 包含了内建的变量/关键字等，最后被搜索。
• 规则顺序： L –> E –> G –> B。

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

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。

global 和 nonlocal关键字：

用于当内部作用域想修改外部作用域的变量时。

#!/usr/bin/python3
 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)
#输出结果： 1  123 123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了：

#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()  
#输出：  100 100

标准库：https://www.runoob.com/python3/python3-stdlib.html

实例练习：https://www.runoob.com/python3/python3-examples.html