python语法总结

基于java对比的python学习总结

print

输出时拼接使用",",输出时会当做空格

注释

#开始到行尾的内容是注释

变量

直接赋值,不用写类型
不能以数字开头
在此体现动态语言的特征:
	a=123
	a='字符串'
	这样是可以的

数据类型

int    只有int
float  只有float
bool   True和False一定要首字母大写
complex
Str		可以用' ' 和 " " 
		如果字符串本身就有其中一种,例如输出 我说:"你是谁" 
		可以这样写 '我说:"你是谁"'  不需要转义  
		如果既有' '又有" "就需要转义了,
		大量的转义包括 \n \t 时很麻烦
		终极'''在这里面写的任意东西都会被原样输出,不会识别转义字符'''
List  	使用[]  有序 和Java的list类似 取数据list[0]  直接赋值
		倒序取数据从-1开始
		添加 append()添加到末尾     insert(下标,元素)插入到指定位置,原先位置以及后面的元素向后移一位
		删除 pop()   pop(下标) 后面的往前移一位
Tuple	使用()  不可变  里面的引用类型的内容可变
		只有一个元素时要加上逗号,否则可能按照括号处理
Sets	使用{} 
		类似java的set,无序,不可重复
		可以用in判断集合是否有这个元素   '元素'  in  set返回bool
		使用add()添加元素   remove()删除元素
Dict	使用{k:v}   java的map,用get取值,key不可重复,只能是不可变的类型,集合内部无序
		同样用 in 判断key是否存在
len(变量)返回长度

迭代

以map为例
for   key   in   dict:
    print   key
for   v   in   dict.values():
    print   v
for   key,value   in   dict.items():
    print   v
			
迭代时需要索引
 for  index,l    in  enumerate(list)
    print.....

另外

 直接获取   f1,f2,f3 = [1,2,3]   f1,f2,f3分别为1,2,3

集合和字符串的切片

以list为例    有两种方式   
list[参数1:参数2]
list[参数1:参数2 :参数3]
参数一和参数二布鞋默认是头和尾,都可以用倒序
参数三是每个几个取一次

列表生成

使用循环的方式  range包前不包后     
[x for x in  range(1,11)  if  x%2==0]  还可以加上  if   判断
还可以嵌套  [m + n for m in 'ABC' for n in '123']
本质上是循环,相当于
L = []
for x in range(1,11)
	L.append(x)
将dict转为列表变成一个html表格

关于数据类型的两个函数

type(变量/对象)  返回数据类型
isinstance(变量/对象,类型)   类似于java的isinstance,返回bool

运算符

除分为两种
	/	自动转为float
	//	只会返回整数
and or  not
	python中认为0,空字符串''和None为False
	其他数和非空字符串都是true
	and:表达式1 and 表达式2  ,前者为false返回前者,true返回后者
	or: 表达式1 or 表达式2  ,前者为true返回前者,false返回后者

循环和判断

python严格要求缩进,习惯4个空格
	相同缩进的代码认为是代码块
	if  条件:
	elif 条件:
	else:
	for  ..   in   .. :
		.....
	while  ..... :
		.....
	break和continue和java中一样

高阶函数

1.把函数当做参数
def add(x, y, f):
    return f(x)+f(y)
print(add(1,2,math.sqrt))
2.map(函数,list)  把函数作用在list的每一个元素上
3.reduce(函数f,list),但是f必须接受两个参数,返回的是集合所有的元素的和
可以有第三个参数代表初始值
在python3中要导包,from functools import reduce
	 reduce(lambda x, y:x + y, [1, 3, 5, 7, 9])    
4.filter函数   list = filter(lambda x:x%2==0,[1,2,3])
5.sorted函数对集合排序,字符串按照ASCII排序
	sorted(list)
	sorted(list,函数f)进行自定义排序

 函数返回函数
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1,2,3)
f1 =  lazy_sum(1,2,3)           f != f1
print(f)   返回的是函数(函数名+地址)

print('------------------')

print(f())   返回值

闭包

def count():
　　fs = []
　　for i in range(1,4):
　　　　def f():
　　　　　　return i*i
　　　　fs.append(f)   返回值把包含内部函数
　　return fs

f1, f2, f3 = count()
print f1()    #9
print f2()    #9
print f3()    #9

 想要得到1  4 9
def count():
　　fs = []
　　for i in range(1,4):
　　　　def f(j):
　　　　　　def g():
　　　　　　　　return j*j
　　　　　　return g
　　　　fs.append(f(i))    使用返回函数直接返回值
　　return fs

f1, f2, f3 =count()
print f1()
print f2()
print f3()

匿名函数
lambda x: x * x
等价于
def f(x):
    return x * x
作为返回值
def build(x,y):
 	return lambda: x*x +y*y

装饰器
	增强函数
def  add(x):
	return x++
对这个方法要增加打印方法名的操作
	直接修改方法
	装饰器
def log(f):
	def fn(x):
		print(f._name_)
		return f(x)
	return fn
这个新的函数就是装饰器
add = log(add)
把add函数进行增强

面向对象

导入  import
导入某几个函数  
	from math import pow, sin, log
导包冲突  设置别名
	from math import log
	from logging import log as logger 

类名首字母必须大写
创建对象  类名+()
	xiaoming = Person()
1：实例属性：
　  最好在__init__(self,...)中初始化
 　 内部调用时都需要加上self.
　　外部调用时用instancename.propertyname
2:类属性：
　　在__init__()外初始化
　　在内部用classname.类属性名调用
　　外部既可以用classname.类属性名又可以用instancename.类属性名来调用
　　def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth
	xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')
3：私有属性：
　　1）：单下划线_开头：只是告诉别人这是私有属性，外部依然可以访问更改
　　2）：双下划线__开头：外部不可通过instancename.propertyname来访问或者更改
_init_()初始化方法(有一个self参数)  

千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。

1：普通类方法：
　　def fun_name(self,...):
　　　　pass
　　外部用实例调用
2：静态方法：@staticmethod            
　　不能访问实例属性！！！   参数不能传入self！！！
　　与类相关但是不依赖类与实例的方法！！
3:类方法：@classmethod
	不能访问实例属性！！！   参数必须传入cls！！！
	必须传入cls参数（即代表了此类对象-----区别------self代表实例对象），并且用此来调用类属性：cls.类属性名
静态方法与类方法都可以通过类或者实例来调用。其两个的特点都是不能够调用实例属性

特殊方法

一些情况下我们需要重写特殊方法
__str__()    toString(),给用户看
__repr__()    显示给开发人员

__cmp__()     比较方法  compare()

__len__()   长度的方法

四则运算不局限于int和float,还可以是有理数,矩阵等
正确实现__add__方法

python的"get和set"

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.__score = score
    @property
    def score(self):
        return self.__score
    @score.setter
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score

class Student(object):
    __slots__ = ('name', 'gender', 'score') 
 __slots__ 限制类只能有这几个属性,不能任意添加动态属性,可以节省内存
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score

在Python中，函数其实是一个对象：

>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)
123
由于 f 可以被调用，所以，f 被称为可调用对象。

所有的函数都是可调用对象。

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

我们把 Person 类变成一个可调用对象：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print 'My name is %s...' % self.name
        print 'My friend is %s...' % friend
现在可以对 Person 实例直接调用：

>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...
单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。