Python2.7笔记

变量

• id(a)可以查看a的地址

输入输出

• raw_input():取得值为字符，化为整数需要用：int(raw_input)
• print ‘xxxxxx’
  (int():指可将纯数字字符串转成数字，type():可以查看变量类型)

运算符

• 3**2（运算结果为3^2）
• 5/2（2）
• 5.0/2（2.5）
• 5.0//2（2.0，整数除法，用于需要取商的整数部分，且除数或被除数中存在未知变量）
• 5%2（1）
• 成员测试:in, not in

数据类型

• int: -2147483647~2147483647(超此变为long型)
• 213L(l)将强制定义为常整型
• 213.0将强制定义为浮点型
• 213j将强制定义为复数类型
• ‘213’或”213”将强制定义为字符串

注释

• 单行注释：#
• 多行注释：’’’xxxx’’’

索引

• a = ‘acvfs’
• a[2]为v，此为索引。a[1]+a[2]为’cv’(Python中加号两边都为字符类型，则会进行字符连接。若有一边为int则会异常。两边都是序列也会进行连接，两边同类型则不会异常)

切片

• a[0:5]为acvfs(注意结束点要+1)
• a[:5]从0位置开始取到结尾
• a[0:]从0位置开始取到结尾（更倾向于此种方式）

步长

• a[::2] avs,此处步长为1
• a[-1] s,负数反着取
• a[:-1] acvf(负数最少都会丢一个尾数)
• a[1:-1] cvf

元组(tuple)

一般用于定义不变数据

>>> t = ('lz', 23, 'boy')
>>> name , age, sex = t
>>> name
'lz'
>>> age
23
>>> sex
'boy'
>>>  

列表(list)

列表操作方法：

• 取值操作：
  切片和索引
  列表名[]
• 添加：
  列表名.append()
• 删除：
  del(列表名)
  list.remove(元素)（不用特意加引号，用于删除列表中第一次出现的某元素）
  list.remove(列表名[xx])(用于删除列表中索引为xx的元素)
• 修改：
  列表名.[xx] = xx
• 查找：
  if 元素 in 列表名

字典

• 字典添加值：dir[add key] = add value

• 字典修改值：dir[old key] = new value

• 删除并返回key为’a’的元素:dict1.pop(‘a’)

• 删除字典所有元素：dict1.clear()#将为空字典
• 删除整个字典：del dict1#将无此字典类型的变量 :

一些常用函数：

• dir.get(‘key’,3)#有’key’对应的value则取出，若没有则返回3这一数值
• dir.values():打印所有value值,组成一个list
• dir.keys():打印所有key值，组成一个list

Python中的形参

• 传入元组，元组元素依次对应形参传入函数：

  >>> def parmarytest(x,y,z):
          return x+y+z
  
  >>> tuplenum = (1,2,3)
  >>> parmarytest(*tuplenum)#传入元组时加入参数，可以使元组元素单独处理
  6
  >>> listnum = [1,2,3]
  >>> parmarytest(*list)#只可以使用元组，列表不行
  
  Traceback (most recent call last):
    File "<pyshell#10>", line 1, in <module>
  parmarytest(*list)
  TypeError: parmarytest() argument after * must be a sequence, not type
  >>> 
  

• 处理多余实参：

  >>> def surplusparm(x,*y,**z):
      print x
      print y
      print z
  
  >>> surplusparm(1,2,3,4,5,6,a = 7, b = 8, c = 9)
  1
  (2, 3, 4, 5, 6)
  {'a': 7, 'c': 9, 'b': 8}
  >>> surplusparm(1,2,3,4,5,6,x = 7, b = 8, c = 9)
  
  Traceback (most recent call last):
    File "<pyshell#25>", line 1, in <module>
      surplusparm(1,2,3,4,5,6,x = 7, b = 8, c = 9)
  TypeError: surplusparm() got multiple values for keyword argument 'x'
  >>> 
  

lambda表达式

• 用lambda定义一个函数：

  g = lamdba x,y:x*y # 冒号后x*y为需要执行的内容。执行这个lamdba表达式：g(3,2)    
  fun = lamdba : function()#用fun()即可执行function()函数
  

reduce函数

switch实现

• Python中没有switch case语句，但可以用字典和它的get方法加lamdba语句实现：

  def NumberToString(arg):
      switcher = {0:'zero', 1:'one', 2:'two'}  
      return switcher.get(arg, 'none')  
  

Python常用内置函数（可查看想关函数库进行详细了解）

abs()#返回绝对值  
max()#返回最大值  
min()#返回最小值  
len()#返回字符串、列表、元组、字典的长度，字典长度按key或value个数来统计  
divmod(x, y)#返回(x/y, x%y)  
pow(x, y)#返回x^y的值  
round(x)#返回x的浮点数形式  
callable(func)#测试func()函数是否可被调用，可以返回true  
type(x)#返回x的类型  
isinstance(x, list)#判断x的类型是否是list是则true否则false  
cmp(x, y)#比较x和y的大小，x<y返回-1，x>y返回1，相等返回0  
range(x, y)#生成x至y-1个数组成的list（顺序）  
tuple(x)#将x转换成元组  
hex(x)#将十进制数x转换成十六进制数返回str类型  
oct(x)#将十进制数x转换成八进制数，返回str类型  
ord(x)#将一个ASCII码转换成十进制数，返回int类型  

String函数

str1.capitalize()#将str1字符串的第一个字符大写  
str1.replace('xxx', '2', 1)#从左到右将str1字符串中的'xxx'字符串替换为'2'这一字符，替换一次  
str1.split('.', 1)#将str1字符串以'.为界切割一次，返回一个list，list内两个元素字符串分别为分割的左右两边  

序列处理函数

• filter(func, list):#func为过滤规则，list为输入量，tulpe也可以进行过滤

  >>> list1 = [1,2,3,4,5,6,7]
  >>> def f_fliter(x):#过滤规则，大于5的数保留
      if x >5:
          return True
  >>> filter(f_fliter, list1)
  [6, 7]
  >>>     
  

• zip(list1, list2):可以遍历两个列表，组成一个对应的由元组组成的新列表

  >>> l = [2,4,5,6]
  >>> li = [29,0,3]
  >>> zip(li, l)
  [(29, 2), (0, 4), (3, 5)]
  >>> zip(l,li)
  [(2, 29), (4, 0), (5, 3)]    
  

• map(func, list1, list2):分别取两列表中的元素按func规定的方式进行处理，返回结果为一个list（list1和list2中的元素个数要相同）

>>> li1 = [1,2,3,4]
>>> li2 = [5,6,7,8]
>>> def Add(x, y):
    return x + y

>>> map(Add, li1, li2)
[6, 8, 10, 12]
>>> li2 = [5,6,7,8,9]
>>> map(Add, li1, li2)

Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    map(Add, li1, li2)
  File "<pyshell#27>", line 2, in Add
    return x + y
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
>>>  

• reduce(func, list):去列表中的元素按func定义的规则进行相应运算，并输出运算结果

  >>> li1 = [1,2,3,4]
  >>> def func(x, y):
      return x + y
  
  >>> reduce(func, li1)
  10
  >>>   
  

Python模块（库）

• import的模块名和库名、脚本名相同：例如编写一个名为Items.py的脚本，则可在另一个脚本中使用import Items语句来导入它
• __name__==’__main__’：在IDE中直接运行某py文件中的函数时等号会成立，若处于import引用的环境下则此处等号不成立
• 优先导入当前目录下的py文件
• Python中的模块可以按目录组织为包：步骤如下：
  建立了一个名字为包名字的文件夹
  在该文件夹下创建一个__init__.py文件
  根据需要在该文件夹下存放脚本文件、已编译扩展及子包
  import pack.m1, pack.m2, pack.m3
• from 文件夹名.py文件名 import .py文件中的类或函数 #from后一定要跟到.py文件，虽然导入的模块和当前编写的文件一般在同一文件夹中，但也可以用文件夹名来开头
• import .py文件 #import后面跟到.py文件，在程序中具体要使用哪个类或者函数，再用.py文件名.类名/函数名，调用（一般推荐此种做法）

正则表达式

浅拷贝与深拷贝

• 浅拷贝：

  >>> a = [2,3,4]
  >>> b = a#浅拷贝，可将b看做是一个a的引用（将b也放入了a的坑中），copy.copy(a)效果相同
  >>> a.append(1)
  >>> a
  [2, 3, 4, 1]
  >>> b
  [2, 3, 4, 1]#a增加的同时b也增加了
  >>> a = [0,6]#改变a的值，在Python中其实是将a丢入某个值中
  >>> b#所以b并未改变，b还是在a之前的那个坑中
  [2, 3, 4, 1]
  

• 深拷贝：

  >>> import copy
  >>> a = [1,2,3]
  >>> c = copy.deepcopy(a)#深拷贝，将a所在的坑重新复制了一个，并将c放入新坑中，所以c不能看做a的引用
  >>> a.append(5)
  >>> a#a增加
  [1, 2, 3, 5]
  >>> c#c未增加
  [1, 2, 3]  
  

Python文件读写

mode:

• r：只读
• r+：读写
• w：写入，先删除原文件，再重新写入，如果文件没有则创建
• w+：读写，先删除原文件，再重新写入，如果文件没有则创建（可以写入输出）
• a：写入，在文件末尾追加新的内容，文件不存在，则创建
• a+：读写，在文件末尾追加新的内容，文件不存在，则创建
• b：打开二进制的文件，可以与r,w,a,+结合使用
• U：支持所有的换行符号

read：

s = open/file(r'路径')  
s.read()  
s.close()  

write：

s = open/file(r'路径'，'w')  
s.write('ssss')  
s.close()#一定要执行这一步才会真正写入文件  

Python中的类（一般规定Python类名用大写开头，函数用小写字母开头）

• 类定义->类对象（class test: ,test就是一个类对象）->类实例对象：含self的方法必须要有实例对象才能被调用，不含self，且不含参数的方法可以直接被类对象调用。有self作为形参定义的方法才是实例对象可用的方法
• 类中属性名若和方法名相同，则属性将会覆盖方法
• Python的重载只能使用def test(x, y, z=4)这种，参数默认值的方式实现重载（默认值就是python用来实现函数重载的重要方法）

• 私有变量的定义与访问

  >>> class test:
      def __init__(self):
          self.__test1 = 1
  

>>> o = test()
>>> o._test__test1#通过此种调用可以访问到类中的私有成员变量
1
>>>   

• 继承：
  1、xxx一般是魔法方法，coding时一般不要这样定义一个属性
  2、子类中定义和父类同名属性或方法，此子类的实例对象会将父类方法覆盖
  3、子类中若定义了init方法，则会自动的将父类中的init方法覆盖掉，所以在子类的init方法中应该要包含一个父类的init方法：
  父类名.init(self) 或 super().init()

• 多重继承（慎用）：
  同时继承多个父类的属性和方法

• 访问实例对象self属性（非私有属性）：
  实例名.属性名

• 组合：
  在一个类中实例化其他类的对象就形成了组合

• BIF：
  issubclass(a, b):检查a是否是b的子类，是True，否False，a,b同类也返回True。 （b不用是字符串的形式）
  isinstance(a, b):实例对象a是否属于b类(b也可以是类组成的元组)，是True。（b不用是字符串的形式）
  hasattr(a, “b”):实例对象a中是否有b这一属性，若b为私有属性，则都返回False
  getattr(a, “b”, “no have the attribute”):实例对象a中若存在b属性，则返回该属性名，若没有则返回no have the attribute
  setattr(a, “b”, value):实例对象a中若存在b属性则将其值改为value，否则增加该属性值
  delattr(a, “b”):删除实例对象a中的b属性，若不存在则抛出异常
  property():通过属性来设置属性，在一个class中写：a = property(获得属性的方法名， 修改属性的方法名， 删除属性的方法名)使得我们可以通过 实例.a 这种方式去修改实例中的属性：

  >>> class Student:
      def __init__(self):
          self.__name = 'lz'
      def set_name(self, name):
          self.__name = name
      def display_name(self):
          return self.__name
      def delete_name(self):
          del self.__name
      a = property(display_name, set_name, delete_name)
  

>>> x = Student()
>>> x.a
'lz'
>>> x.a = 'lizhong'
>>> x.a
'lizhong'
>>> del x.a
>>> 
>>> x.a#这里是疑问点，按正常来说应该是不会存在了
'lz'
>>> del x.a

Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    del x.a
AttributeError: Student instance has no attribute 'a'

魔法方法

被(双下横线)包围的方法称为魔法方法
常用魔法方法：
1、def str(self)#使用print方法打印时会自动调用此魔法方法，但要注意return后必须为str类型
2、def repr(self)#直接输入实例对象时需要返回的字符串，return后必须为str类型
3、def getattribute(self, name)#当用户访问一个属性时，此方法被调用（只要有访问属性，就会调用此方法，无论访问的属性是否存在）
4、def getattr(self, name)#当用户访问一个不存在的属性时，此方法被调用，name会传入用户访问的属性名
5、def setattr__(self, name, value)#当一个属性被设置时，此方法被调用，类内部赋值也会触发此方法，此处name传入的是被设置的属性名，value传入的是值（可以是字符也可以是数值）

class test(object):
    def __init__(self):
        self.wide = 0#此处也会调用__setattr__方法  
        self.height = 0
    def __setattr__(self, name, value):
        print '__setattr__ was callback'

        if name == 'square':
            self.wide = value
            self.height = value
        else:
            object.__setattr__(self, name, value)#__setattr__和__getattribute__方法需要调用（返回）基类的中的此方法，防止死循环  

6、def delattr(self, name)#当一个属性被删除时，此方法被调用
7、def del(self)#该方法只有在del最后一个应用变量时，才会被调用

运算相关魔法方法：

闭包和装饰器

闭包：

进制转换

其中bin()、oct()、hex()只接收十进制数，int()需要格式为：
二进制转十进制int(‘’, 2)、十六进制转十进制int(‘’, 16)、八进制转十进制int(‘’, 8)
bin()、hex()后进行切片处理([2:])然后再加zfill()对数据进行补零处理，可保证数据位数

赏

谢谢你请我吃糖果

支付宝