回顾一下py基础(常见变量、读写操作)

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()"

返回的东西大概长这样:

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值