python是一门动态类型语言,解释器会为其分配内存。
每个变量在赋值后才会在内存中创建该变量,包括(变量的标识、名称、数据这些信息)
python的数据类型:number、string、list、tuple、dictionary。
python是一门动态类型的语言,不需要如(int、string的提前声明)
python中的不可变类型:numbers、str、tuples(引用其他地方)
python中的可变类型:dictionary、list。
这里的可变不可变,说的是内存中内容的那块value是否可以改变。
numbers在改变的时候实际上改变的是指向的地方。
不可变类型传入进function中,在function中modify不会改变该参数内容本身。
而可变类型传入function中会改变数据本身。
不可变类型为变量名是指向一块内存的。
python在解释以后,会生成一份字节码,字节码会保存为一个以.pyc文件结尾的扩展名。
下次如果python的源代码没有改动过,接着运行.pyc,否则就是重新生成.pyc的字节码。
pvm是python的运行引擎,其最终解释python。
常见的一个东西
#!/user/local/bin/python
~
这句话是告诉系统,python解释器所在的位置
python中的import也是需要开销的,所以尽量不要对相同的模块重新import
但是如果想要调用python中import别的代码的程序,
from imp import reload
可以通过reload(M)来调用。
骚操作
#test[x:y:k]是指把这个list从x到y的数据按照k的步长输出,其中如果变量没有指定那么就是一直到末尾
#test[::-1]把数据反转
关于import:
import内容的顺序:
1、默认从当前目录开始找该模块。
2、从$PYTHONPATH寻找模块。
3、从PYTHON的默认路径下寻找模块。
list:
list1 = [1,2,3]
list1.append(4)
list1.remove(2)
list1.sort()
list1.pop(index)
list1[0:2]
list1.insert(index,value) #在index地方插入value。且其他变量后移。
max1 = max(list1)
#append 与 pop 默认index为tail
tuple:
a = (1,2,3)
b = (4,5,6)
c = a + b
d = (1,) #当只有一个元素的时候需要加个,
#元组中的值不允许修改
现在有nametuple这么个东西,挺好用的,就是给元组的index带名字了。
list与tuple的不同:
1、list传入函数中改变时真实改变,而tuple不会改变。
2、元组的value不会改变,只能用上述类似c的方式'+'。
tuple1 = tuple(list1)
list1 = list1(tuple1) # 可以互换
dictionary:
dictionary = {}
dictionary = {'abc':1,'edf':2,'ghi':3}
dictionary['a'] = 5
for key in dictionary: #遍历tuple 和 list 都可以使用这样的方法
print(key) #仅仅输出key,下面输出包括value
print(dictionary['key'])
for info in dictionary.items: #这里拿出的是tuple
print(info[0])
print(info[1])
if 'abc' in key: #判断一个key是否在这个字典中
dict.clear()#删除字典
def dict['key'] #把字典的某个key删除
del dict #直接删除整个字典
#dict,插入与查找为logn,速度快,但是内存稍微占用多一些。
set的使用:
list1 = [3,4,6,3] list2 = set(list1) list2.add(5) list2.remove(3) print(list2)
1、test(a)
2、test(a=5) # 这样的传参,可以参数的顺序不一致,传入的称为关键字传参数
3、test(a , *args): # b表示后面不定长的参
4、test(a:str, b:int): # 参数带:表示参数限制了数据类型
使用a=test(a,6,7,8)丢到test(a , *args)
这里b会成为一个元组,里面是(6,7,8)
4、test(a,**kwargs)) # 这里传入的不定长参数b作为字典的方式传入函数
5、test(a,*,b,c,d) # 这里为强制b要求关键字传参
self,表示自己 # 这个类相当于实例化的类
cls,表示类本身 # 没有实例化
读写相关:
#r读,r+读写,w覆盖写,行尾添加a
f = open("aa.txt","r")
f.write('it is a good idea')
f.read('it is a good idea')
f.close()方法 # 刷新缓冲区还没有写入的信息,但是这种方法可能会出问题,就是read没成功read就close之类。
#另一种较为优秀的写读方式
with open("filename.txt","w") as out_file:
out_file.write('it is a pen')
with open("filename.txt","r+") as in_file:
test = in_file.read()
print(test)
python中面对对象:
1、封装
外部不是直接使用,那么做成protected(被继承后也可以使用)、privated(只有自己用)。
希望共给外部调用,那么做成publiced。
封装的目的:
增强安全性和简化编程,使用者不必了解具体的实现细节
对于pyhton。
变量名前加上 _hello 、表示这个一个protected成员
__hello,表示这是一个privated成员,只能在类本身调用,不能a = A() ,a.x这样去使用
但是可以通过object._className_attrName 这样去调用
__foo__ 这种前后双下划线,一般是系统名字
_abc, 表示的是protected类型,只能本代码使用。 不可以from module import a 进行使用
变量与方法都是这样
实现一个缓存机制
2、继承
继承的子类有什么好处呢:
1、会继承父类的属性和方法。
2、可以自己定义,覆盖父类的属性和方法。
写法
class B(A):
def __init()
多继承
class B(A,C,D): # 当使用的method有所不同的时候,假设没有指定,从左往右选第一个出现的基类。
判断一个实例化的对象是否是某个类
isinstance(b,B)
isinstance(123,int)
3、多态
多态,是指子类在继承父类(或实现接口)时重写了父类(或接口)的方法,程序中用父类(或接口)引用去指向子类
的具体实例,从代码形式上看是父类(或接口)引用去调用父类(接口)的方法,但是在实际运行时,系统能够根据
父类(或接口)引用所指的具体子类,去调用对应子类的方法。
它是指对不同类型的变量进行相同的操作,它会根据对象(或类)类型的不同而表现出不同的行为。
比如:
1 + 2 = 3
'1' + '2' = '12'
对数字,用加法实现1+2 = 3,对字符,实现'1'+'2' = '12'
# 它是指对不同类型的变量进行相同的操作,它会根据对象(或类)类型的不同而表现出不同的行为。
# 比如
# 1 + 2 = 3
# '1' + '2' = '12'
#
# 多态:
class User(object):
def __init__(self, name):
self.name = name
def printUser(self):
print('Hello !' + self.name)
class UserVip(User):
def printUser(self):
print('Hello ! 尊敬的Vip用户:' + self.name)
class UserGeneral(User):
def printUser(self):
print('Hello ! 尊敬的用户:' + self.name)
def printUserInfo(user):
user.printUser()
if __name__ == '__main__':
userVip = UserVip('yeleng')
printUserInfo(userVip)
userGeneral = UserGeneral('___yeleng___')
printUserInfo(userGeneral)
# 调同样调方法,但是显示不同的结果
# 重点不在于值不一样了,而是调用的方法不一样了。
# 子类重写了这个被调用的方法。
所有以_开头的方法,都称作魔法方法。
__new__ 是在 __init__ 之前使用的
__new__会返回一个实例,而__init__只能返回None
__new__ 是用来创建类并返回这个类的实例
Example:
class User(object):
def __new__(cls, *args, **kwargs):
# 打印 __new__方法中的相关信息
print('调用了 def __new__ 方法')
print(args)
# 最后返回父类的方法
return super(User, cls).__new__(cls)
def __init__(self, name, age): # __init__ 为构造方法, __del__ 为析构方法
print('调用了 def __init__ 方法')
self.name = name
self.age = age
if __name__ == '__main__':
usr = User('yeleng', 22)
python中的argparse:
argparse就是python自带的命令行参数解析包。
可以用其来方便的读取命令行中的参数。
import argparse
def main():
parser = argparse.ArgumentParser(description="Demo of argparse")
parser.add_argument('-n','--name', default='_Li_')
parser.add_argument('-y','--year', default='20')
args = parser.parse_args()
print(args)
name = args.name
year = args.year
print('Hello {} {}'.format(name,year))
if __name__ == '__main__':
main()
# python3 test_param.py -n 123
# Namespace(name='123', year='20')
# Hello 123 20
# python3 python_argparse.py -n=哭了 -y=5
python的代码性能分析(这一块还不是很会用):
python -m cProfile ns1p_pipeline.py
cprofile 解释器默认的性能分析器。
#把运行花费时间保存
python -m cProfile -o test.out ns1p_pipeline.py.py
#按照运行时间排序
python -c "import pstats; p=pstats.Stats('del.out'); p.sort_stats('time').print_stats()"
返回的东西大概长这样: