Python notes

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()对数据进行补零处理,可保证数据位数