Python_Basic

---

继续（换行分隔）: \

---

Python解释器执行

#！/usr/bin/python  #第一行是特殊注释行，称之为组织行，用来告诉我们GUN/Linux系统应该使用哪个解释器来执行
#-*-coding:utf-8-*-
#FileName: 
#Author:
#Date:

Python风格

==Pythonic==

PEP

• PEP7
• PEP8
• PEP257

  OOP-Python面向对象

  面向对象概述：(ObjectOriented ,OO)

• OOP思想
  • 几个名词
    1. OO:面向对象
    2. OOA:面向对象的分析
    3. OOD：面向对象的设计
    4. OOI：面向对象的实现
    5. OOP：面向对象的编程
    6. OOA–>OOD–>OOI:面向对象的实现过程

变量

运算符
: =/!= 运算符 >（ ）运算符 > not 运算符 > or/and 运算符

#在函数内使用全局变量
num = 1
def f:
  global num
  print(num)
  num = 200
  print (num)

#从非空序列中随机选择元素
random.choice(sequence)

生成器 generator

返回值：返回生成器。

# 实例
# 以下实例展示了 xrange 的使用方法：
# 占用内存小
>>>xrange(8)
xrange(8)
# 通过list方法，将生成器xrange内容给生成出来
>>> list(xrange(8))
[0, 1, 2, 3, 4, 5, 6, 7]
>>> range(8)                 # range 使用
[0, 1, 2, 3, 4, 5, 6, 7]
>>> xrange(3, 5)
xrange(3, 5)
>>> list(xrange(3,5))
[3, 4]
>>> range(3,5)               # 使用 range
[3, 4]
>>> xrange(0,6,2)
xrange(0, 6, 2)              # 步长为 2
>>> list(xrange(0,6,2))
[0, 2, 4]

yield

yield
: 是一个类似 return 的关键字，迭代一次遇到yield时就返回yield后面(右边)的值。
在下一次迭代时，从上一次迭代遇到的yield
后面的代码开始执行，可以理解为每执行完一次迭代，yield会记住上一次迭代的位置，然后在下一次迭代开始时，从上一次位置的下一位开始，再执行yield后的命令

运用
: 在一堆有规律或者有着固定顺序（类似数列）的数据中，需要按照一定规律，将数据分类时，可以使用yield生成器来完成

利用递归生成器处理嵌套问题–树状问题

# 解释：当展开元素为单个元素时，会引发TypeError，则只会生成该元素的生成器
# 当展开多层元素时，可以分层展开，利用faltten()递归
def faltten(nested):
  try:
    for sublist in nested:
      for element in faltten(sublist):
        yield element
  except TypeError:
    yield nested

# 利用生成器检查展开对象是否为类似字符串的对象
def faltten(nested):
  try:
    # 不要迭代类似字符串的对象
    try: nested + ''        # 通过和字符串的拼接来检查
    except TypeError: pass     # 对非字符串对象不做处理
    else : raise TypeError      # 对字符串对象进行报错
    for sublist in nested:
      for element in faltten(sublist):
        yield element
  except TypeError:
    yield nested

匿名函数 – lambda 函数无固定名

sum = lambda a,b:a+b
print(sum(10,20))
#变量名 = lambda 参数1，参数2，。。。: 表达式

列表

列表方法

引用方法：对象.方法(参数)

1.append -----在列表末尾追加新的对象
>>>lst =[1,2]
>>>lst.append(3)
>>>lst
[1,2,3]

2.count -----统计某个元素在列表中出现的次数
>>>x =[1,1,1,2,3]
>>>x.count(1)
3

3.extend  -----用新列表来拓展原有列表
>>>a= [1,2]
>>>b= [3,4]
>>>a.extend(b)
>>>a
[1,2,3,4]
#  该方法与原始的列表连接不同(a+b),该方法返回的是一个全新的列表
#  若要添加多个元素，则在括号内用列表
例如：x.extend(['a','b'])
4.index -----从列表中找出某个值的第一个匹配项的索引位置
>>>x =[a,b,c]
>>>x.index(c)
>>>2

5.insert -----将对象插入到列表中
>>>numbers = [1,2,3,4,5]
>>>numbers.insert(3,'four')
  #（）逗号前 3 为插入的位置，逗号后为插入的内容
>>>numbers
[1,2,3,'four',4,5]

6.pop -----移除列表中的一个元素
>>>x= [1,2,3]
>>>x.pop()
 #若括号内为空，则默认移除最后一个元素
3
 #注意这里pop方法返回了元素值，且pop方法为唯一一个既能修改列表又返回元素值的列表方法
>>>x
[1,2]

# Tip:使用pop方法可以实现一种数据结构——栈。栈的原理如堆放盘子，只能在顶部放一个盘子
# 也只能从顶部拿走一个盘子，即后进先出（LIFO)
# Python没有入栈的方法，但可以用append代替，。如果入栈刚刚出栈的值，则列表不变

7.remove  -----用于移除列表中某个值的第一个匹配项
>>>x = [1,2,1]
>>>x.remove(1)
>>>x
[2,1]            #只移除第一个匹配项

8.reverse ----将列表中的元素反向存放
>>>x =[1,2,3]
>>>x,reverse()
>>>x
[3,2,1]

# Tip:如果需要对一个序列进行反向迭代，使用reversed函数，返回一个迭代器对象

9.sort -----将列表中的元素按照一定的顺序排列，无副本，只对原列表直接改变
>>>x =[2,3,1]
>>>x.sort()             #虽然sort方法修改了x却返回了空值
>>>x
[1,2,3]
如果需要副本，可以自建
>>>x =[2,1,3]
>>>y =x[ : ]            #这里【 ： 】相当于strcpy，不能直接 y = x
如果使用y=x，则改变x的值，也会同时改变y，因为x为y的原列表
>>>y.sort()
>>>>x
[2,1,3]
>>>y
[1,2,3]                 #既保留了原列表x,又创建了新列表y
倒序  x.sort(reverse=True)
10.高级排序
cmp 比较
>>>x =[2,1,3]
>>>x.sort(cmp)
>>>x
[1,2,3]

# 这里sort方法有两个可选参数，也称为关键字参数：key 和 reverse
# 此类函数不是直接来确定对象大小，而是为每个元素创建一个键，根据键来排序
例：>>>x =['abc','a','ab']
    >>>x.sort(key = len )
    >>>x
    ['a','ab',abc']
# 另一个关键字参数reverse是布尔值
>>>x =[1,2,3]
>>>x.sort(reverse =True)
>>>x
[3,2,1]

11.enumerate迭代器
# 将列表中的index和value以元组的形式表示出来
list(enumerate（x）)

---

元组

1.元组大部分时候通过圆括号括起来
2.空元组 >>>()
3.一个值的元组 >>>42,

• #元组加逗号是十分关键的

更新元组
x = (1,2)
x = x[ :1] +(‘0,’ )+x[1: ]
x
x = (1,2,3)

#优先级，索引，内容
(prioroty,index,item)

构建一键多值

#collections模块中的defaultdict类
from collections import defaultdict
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)

d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)

字典

oni = {"name"="chen","id"=4545}
oni.keys() #查看键
oni.values() #查看值
oni.items() #查看键值

wd 为汉字编码

注意：
1.字典中的键不可以重复，会返回后面的值
2.字典中的键是任意可hash对象（不可变对象，如数字，元组，字符串）

---

格式化字符串

• format:字符串格式化的一种方式

  "我是{}会".format(1)
  "我是{}会".format([1,2,3])
  "我是{}会".format({1,2,3})
  "我是{}会{}".format({1,2,3},[1,2,3])
  "我是{}会{}".format({1,2,3},1)

• 列表推导式

  • 帮助生成包含一组数据的列表
    [i+10 for i in range(10)] —> [10,11, ,19]
  • 与字符串一起使用
    • ["10月{}日".format(i) for i in range(1,10)]
      —>[“10月1号”，“10月2号”， ]
      list[0]将列表第一个元素转换
  • 字典推导式
    • 帮助我们快速生成包含一堆数据的字典

      {i+10:i for i in range(10)}   #{10:0,11:1,   ,19:9}
      {"a{}".format(i):10 for i in range(3)}  #{"a{0}":10,,,,}

• 三元运算

  • if 后面的条件成立，就把i前面的结构赋值给a，否则把else后面的
    结果赋值给a

    a=10 if 4>2 else 20 # a = 10

  ---

  "let's learn %r" % "python"
  #格式化%可以为s,d,r,其中r可以打印任何内容
  #%r用来调试最好，%s和其他格式符用来向用户显示变量
            %c     格式化字符及其ASCII码
            %s     格式化字符串
            %d     格式化整数
            %u     格式化无符号整型
            %o     格式化无符号八进制数
            %x     格式化无符号十六进制数
            %X     格式化无符号十六进制数（大写）
            %f     格式化浮点数字，可指定小数点后的精度
            %e     用科学计数法格式化浮点数
            %E     作用同%e，用科学计数法格式化浮点数
            %g     %f和%e的简写
            %G     %f 和 %E 的简写
            %p     用十六进制数格式化变量的地址

  %.xf 表示将小数中小数点后面的位数固定到x位
  如果小数的位数比x大，则保留x位小数
  eg:

  \>>> "%.3f" % 3.1415926
  '3.142'

如果小数的位数比x小，则用0补足
eg:

\>>> "%.4f" % 3.1
'3.1000'

浮点数四舍五入
round() :round(1.733)

if __name__ == "__main__"作用

让Python知道该模块是作为程序运行还是导入到其他程序中

---

模块

sys 模块 & os模块

分别作用

• sys模块负责程序与Python解释器的交互
  提供了一系列函数和变量用于操控Python运行时的环境

• os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口

sys模块内容

sys.path
: 查找模块所在的目录列表.
若要在与解释器不同路径下导入模块，则需要在解释器路径下添加路径sys.path.append("路径")

sys.argv
: 「argv」是「argument variable」参数变量的简写形式，一般在命令行调用的时候由系统传递给程序。
这个变量其实是一个List列表，argv[0] 一般是被调用的脚本文件名或全路径，和操作系统有关，argv[1]和以后就是传入的数据了。

os模块内容

• 命令

命令	作用
os.linesep	在当前平台使用的行终止符

包（package)

1. 创建一个文件夹，用于存放相关的模块，文件夹的名字即为包的名字
2. 在文件夹中创建一个__init__.py的模块文件，内容可以为空
3. 将相关的模块放入文件夹中
4. 调用方法 ：import M1.module

函数

#运行，调用，使用函数为同一个意思
def print_two(*args):
#*代表可以接收所有参数
def print_two_again(arg1,arg2)

eval()

eval()
: 是程序语言中的函数，功能是获取返回值，不同语言大同小异，函数原型是返回值 = eval( codeString )，如果eval函数在执行时遇到错误，则抛出异常给调用者。

语法

eval(expression[, globals[, locals]])
有三个参数，表达式字符串，globals变量作用域，locals变量作用域。 其中第二个和第三个参数是可选的。

如果忽略后面两个参数，则eval在当前作用域执行。
实例:

a=1
eval("a+1")
2

如果指定globals参数

a=1
g={'a':10}
eval("a+1",g)

11

如果指定locals参数

a=10
b=20
c=20
g={'a':6,'b':8}
l={'b':9,'c':10}
eval("a+b+c",g,l)

Help(模块名) help(模块.函数名)

这是得到模块帮助文档的方式，所谓帮助文档就是定义函数时放在”‘ ‘“之间的东西，也被称为文档注释

name

用于检测主程序代码中的模块是被导入还是被直接执行

• 如果模块是被导入，则__name__的值为模块名字
• 如果模块是被直接执行，则__name__的值为'__main__'

---

类

新式类与旧式类
: python的新式类是2.2版本引进来的，
官方给的解释是：
为了统一类(class)和类型(type)。
在2.2之前，比如2.1版本中，类和类型是不同的，如a是ClassA的一个实例，那么a.class返回 ‘ class main.ClassA‘ ，type(a)返回总是。而引入新类后，比如ClassB是个新类，b是ClassB的实例，b.class和type(b)都是返回‘class ‘main.ClassB’ ，这样就统一了。

• 类的实例化

  if __name__ == '__main__':
  Spider(param)

使用 class 关键字定义类，可以选择提供一个父类或者说基类

class Filter:
  def init(self):
    self.blocked=[]
  def filter(self,sequence):
    print ([x for x in sequence if x not in self.blocked])

#Spam_Filter是Filter的子类
class Spam_Filter(Filter):
#重写Filter超类中的init方法
  def init(self):
    #过滤的元素序列
    self.blocked = [1]

Filter是用于过滤序列的通用类

>>> f = Spam_Filter()
>>> f.init()
>>> f.filter([1,2,3])
>>> [2,3]

Python内建 issubclass :判断一个类是否是另一个类的子类

issubclass(Spam_Filter,Filter)
True

查看子类的基类 ： bases

print (Spam_Filter.__bases__)
(<class __main__.Filter at 0x171e40>.)
#若无基类，则返回一个空序列

查看对象属于哪一个类 ： class

print (f.__class__)
<class __main__.Spam_Filter at 0x1707c0>

调用绑定类的方法时，使用类名
Teacher.say()

继承

注意
: 若子类继承了父类，但是在子类中，==父类的构造方法被重写==，即__init__内容被改变，
且新的构造方法中==没有任何关于初始化父类构造方法中特性的代码==，则会发生异常

python （未）绑定方法

解释 —绑定方法
: 在调用一个实例的方法时，该方法的self参数会被自动绑定到实例上

因为绑定方法的缘故，若在子类中使用父类的方法，且在子类中新的构造方法没有关于
初始化新特性的代码，故程序会报错

解决方案

1. 在子类函数中直接调用类的方法，例如Bird.__init__(self),则实例就不会被绑定，就
   可以自由地提供需要的self参数
   例子

   class songbird(Bird):
       def __init__(self):
           Bird.__init__(self） # 在子类构造函数中使用父类的构造方法
           self.sound = ’squawk’

2. 使用Super函数
   在子类的构造函数中直接使用Super()函数，在python3.0之后版本中Super中可以不带任何参数

   class songbird(Bird):
       def __init__(self):
           super().__init__()
           self.sound = ‘squawk’

---

接口（“协议”）与内省

hasattr(对象名,'方法&特性',None)
: 检测特性是否存在

getattr(对象名,'方法&特性',None)
: 直接访问特性，若特性不存在，则返回None

setattr(对象名,'方法&特性','内容')
: 设置对象的特性

私有方法(成员)

Python的私有不是真的私有，是一种成为name mangling的改名策略
可使用对象.__classname_attribuename访问

# 在方法名前加上双下划线__即可
def __func(self):

---

异常处理

try:
  a = 100
  c = a+'a'
except TypeError as f:
  print("出错"，f)
except NameError as f:
  print("出错"，f)

# else使你可以编写只有在try子句中没有遇到任何异常时才能运行的代码。
# finally使您能够执行应始终运行的代码段，无论是否遇到任何异常。
# 捕捉异常

#若对异常不进行处理
try:
  a = 100
  c = a+'a'
except:
  pass
#对所有异常类型的处理
except Exception as f:
  print("Exception",f)
finally:
  print("最终输出")

# 打印错误内容
except (TypeError,NameError) as e:
  print(e)

# 用一个块来捕捉异常,用元组列出
try:
  a = 100
  c = a+'a'
except (TypeError,NameError):
  print('Error')

#抛出（制造）异常
a = 1
b = 2
c = a+b
raise TypeError("你就是错了")
raise Exception(' ')

# 屏蔽异常
class MuffledCalculator:
  muffled = False
  def calc(self,expr):
    try:
    #  eval()是程序语言中的函数，功能是获取返回值，不同语言大同小异
    # 函数原型是返回值 = eval( codeString )
    # 如果eval函数在执行时遇到错误，则抛出异常给调用者。
      return eval(expr)
    except ZeroDivisionError:
    # 当给muffled赋值为True时，关闭屏蔽
      if self.muffled:
        print 'Division by zero is illegal'
      else:
        raise

# 嵌套加入else子句
try:
  print('a')
except:
  print('b')
else:
  print('c')