基于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中，函数也是对象，对象和函数的区别并不显著。
