python笔记

字符串的格式化

print "hello %s your age %d" %("zhangsan",18)

print "hello %s your age" % "zhangsan"  参数一个时 可以不要括号

 

print "hello {0} your age {1}".format("zhangsan",18)

print "hello {} your age {}".format("zhangsan",18) 也可以不用写参数的索引

三引号 连续的单引号或者双引号

print """

欢迎使用GEG.COM
下面是一些使用教程

"""

 

抛出错误

raise TypeError("bad err")

函数可以返回多个值

return 3,5

 

函数中传递任意数量的实参 def funname(*args)    一个星号    make(4,56,7,89)

函数中传递的是任意数量的键-值对 def funname(**args)  两个星号   makedic("rr","ad",name="zhangsan",age="asd")

?

1 2 3 4 5 6

def make(**args):     print args   make(a=4,b=6,c=7,d=6)   输出 {'a': 4, 'c': 7, 'b': 6, 'd': 6}<br><br><strong>参数形式必须是 key = val 的形式<br><br></strong><strong> </strong>

def make(*args):

print args

make(4,56,7,89)

#形参名*args 中的星号是让python创建一个名为args的空元组，并将收到的数据都封装到这个元组中

所以下面的打印如下

def make(*args):

print args

make(4,56,7,89)

list=[3,4,5]

make(list)

$ python test.py
(4, 56, 7, 89)    一个元组，里面的数据是3,56,7,89
([3, 4, 5],) 一个元组，里面的数据是一个列表。

 

 

 

def makedic(n,a,**args):

print n,a

for key,val in args.items():

print key,val

makedic("rr","ad",name="zhangsan",age="asd")

 

输出

(4, 56, 7, 89)
rr ad
age asd
name zhangsan

关于Python的切片

一个冒号表示范围，第二个冒号表示每一个取一个
list = range(10)print list[:4] 取前4个 同 list[0:4]
list[-4:]  取最后四个
[:]表示原有的list   
list[-10::2] 取倒数10个，每两个 取一个

 生成器，如果一个函数内有 yield 关键词， 那这个函数就不是一个普通函数了，而是一个 generator (生成器)

方法1
def make(n):
    b = 0
    while b<n:
        yield b
        b = b + 1
for x in make(5):
    print x

方法2 

list = (x for x in range(5))    列表生成式的方括号改为圆括号就是一个generator
for x in list:
print x

关于map

def make(x):
    return x * x

list = range(9)
print  map(make,list)  输出 [0,1,4,9,16,25,36,49,64]

关于 reduce，reduce 将一个函数作用于一个序列上，这个序列必须接受两个参数，reduce 把计算结果和序列的下一个元素做累积计算

def make(x,y):
    return x + y

list = range(4)  [0,1,2,3]
print  reduce(make,list) 输出结果为6

关于 filter 过滤序列，filter 把传入的函数依次作用于每一个元素，然后根据返回值是True 还是 Flase 来决定保留还是丢弃该元素

list = [2,5,7,3,19]

def make(x):
    return  x>=5

print filter(make,list)  输出 [5,7,19]

删除一到100之前的素数

list = range(1,101)
def make(x):
for i in range(2,x):
if (x % i) == 0:
return True

print filter(make,list)

关于sorted 排序

通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序

list=[4,7,2,25,45,8]
print sorted(list)
def comp(x,y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

print sorted(list,comp) //可以接受一个比较函数来进行自定义排序

关于 闭包 ,返回函数

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

f1 = lazy_sum(4,6,7)
f2 = lazy_sum(4,6,7)
print f1() == f2()
print f1 == f2

当我们每次调用lazy_sum 函数时，每次调用都会返回一个新的函数，即使传入的参数相同

 关于偏函数

import functools
int2 = functools.partial(int,base=2)
print int2('11101')

functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单

关于面向对象

类和实例

类型须要大写，可以通过__init__ 方法将属性绑定上去

print_sc  类的方法

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def print_sc(self):
        print "姓名%s ,分数%s" % (self.name,self.score)

bart = Student("jinkang",34)
bart.print_sc()
print bart.name  输出 jinkang
如果想让内部属性不被外部访问，在定义变量时  self.__name = name

 dir()  用来获取对象的所有属性和方法

format 函数  

name="hello"
cmd = 'ps -ef|grep "{0}"|grep -v grep\|{1}'.format(name,"master")
print cmd  #输出 ps -ef|grep "hello"|grep -v grep\|master

cmd = 'ps -ef|grep "{name}"|grep -v grep\|{age}'.format(name="hello",age="master")
print cmd #输出  ps -ef|grep "hello"|grep -v grep\|master

 函数 __doc__(文档字符串)

文档字符串应该遵循的惯例

它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述

def make():
    '''
    this is a script for making help
    '''
    print "helllo world"

make()
print make.__doc__
输出
helllo world
  this is a script for making help

 列表与字典的转换

a = ['name','age']
b = ['jinkang',20]
print dict([a,b])   //输出

{'jinkang': 20, 'name': 'age'}

join 方法，将序列中的元素以指定的字符连接生成一个新的字符串

list = ['a','z','t','c','b']
list.sort()
s= ''
r = s.join(list)
print r  #输出 abctz

 __name__

filename : t.py
if __name__ == '__main__':
    print "run by self"
else:
    print "run by import"

1 python t.py  : 输出  run by self
2 python (进入python命令行)>> import t  >>输出 run by import

 装饰器 ： 在代码运行期间动态增加功能的方式，称之为 "装饰器" Decorator

def make(func):
    def inner():
        return func() + 1
    return inner

@make
def add():
    return 4

print add()

 

def make(func):
    def dec(args):
        print "U exec hello %s" %(args)
        return func(args)
    return dec

@make
def show(name):
    print "hello"


show("hh")

输出 
U exec hello hh
hello

def log(text):
    def make(func):
        def dec(*args):
            print "U exec hello %s" %(text)
            return func(*args)
        return dec
    return make

@log("pp")
def show():
    print "hello"


show()

#输出 
U exec hello pp
hello

 

字典的排序

dicd = {"ss":23,"bc":45,"aa":66}

print  sorted(dicd.keys())   #按 key 排序 ，输出  ['aa', 'bc', 'ss']

print sorted(dicd.items(),key=lambda item:item[1]) #按 val排序，输出的是一个list  [('ss', 23), ('bc', 45), ('aa', 66)]
如果要倒叙，加个   reverse=True 就可以了

 字典的遍历

obj={
    "name": "zhangsan",
    "school": "xiaoxue",
    "add": "china",
}
print "only key"
for key in obj.keys():
    print key

print "only val"
for val in obj.values():
    print val
print "both"
for key,vak in obj.items():
    print key,val

 

关于匿名函数 lambda

?

1 2	sum = lambda x,y:x+y print sum(3,6) #输出9<br><br>等同于  def sum(x,y):<br>   return x + y<br>print sum(4,6)

下载软件版本判断

import os

version=""
while True:
     version=raw_input("input ver 2.5/2.7 :>  ")
     if version == "2.5":
         version = "2.5"
         break
     elif version == "2.7":
         version = "2.7"
         break
     else:
         print "please input the correct version"

print "you select the %s product" %(version)
print "beging download the package"

 python IO 读操作 read readline() readlines()

read 读取整个文件，将文件内容放到一个字符串变量中。
readline()方法每次读取一行；返回的是一个字符串对象，保持当前行的内存
with open(os.path.join(pwd,"cont.txt"),'r') as file:
    while True:
        line = file.read().decode('utf-8')
        if not line:
            print "end"
            break
        else:
            print line
readlines()一次性读取整个文件；自动将文件内容分析成一个行的列表。