python基础语法学习
该文档是刚开始学习python时的笔记，参考的是廖雪峰python教程，大家有时间也可以看下~
先上一幅图，此为某位大神在python社区发布的，现在找不到链接了，如果大家有发现，可以告诉我哈~~
基本语法
#多行文本的写法 ''' 第一行 第二行 第三行 ''' #默认使用utf8编码，中文会修改为三个字节，每个字母为一个字节，用法类同于b开头的字符串 'abc'.encode() #数组操作 arrya=['A','B','c'] #插入元素 array.insert(index,'D') #显示并删除最后一个元素 array.pop() #显示并删除指定位置元素 array.pop(index) #指定索引位置元素值修改 array[index]='E' #数组的排序 array.sort() ## 切片,取前10条记录，也可以从倒序，最后一个元素为-1 array[0:10] #元组 tuple ，指向是不可变的，只能显示不能修改，代码更安全，如果元素有数组时，是可以修改数组指向值的 array=(1,2,3) #if的用法 age =18 if age >=18: print('') else: print('') #字符串转换为数字 int(str) array =['a','b','c'] for ele in array: print(ele) #生成0－5的整数序列 list(range(5)) ##python中有map的概念 map ={'key':value,'key2':value2} #指定key是否存在于map中,返回boole值 key in map #python中也有set的概念 s =set([1,2,3]) s.add(4) s.remove(4) #set可以做交集和并集 set1 & set2 set1 | set2
类型转换
int('123') int(12.25) str(123) bool('') bool(1)
内置函数
max(1,2,3)
abs(-1)
函数定义,第二个参数为默认值参数，可以不传入值
def function_name(param1,param2=2): XXXXXX; return # 可变参数，接收的为元数组tuple，不允许改变，如果调用者有一个数组，需要将数组转换为可变参数才可以，如数组为array=[],，则使用 function_name(*array)来调用即可; def function_name(*param1) #关键字参数，将在内部组装为一个map,同时也可以个体**map将一个map转换为关键字参数，正常调用为: person("","",city="",job="") def person(name, age,**kw): print('name:', name,'age:', age,'other:', kw) #指定参数名的关键字参数，使用*进行分隔，也可以使用默认值参数 def person(name, age,*, city='Beijing', job): print(name, age, city, job)
高级特性
#切片 array=[1,2,3] array[0:3] #迭代 for ele in array for key in map for value in map.values() for key,value in map.intems() #判定元素是否可迭代 isinstance([1,2,3],Iterable) # 列表生成表达式 [x * x for x in range(1,11)if x %2==0] ==>[4,16,36,64,100] [m+n for m in'ABC'for n in'XYZ'] #所有元素小写，除去不符合要求的除去 L1 =['Hello','World',18,'Apple',None] print([ele.lower()for ele in L1 if isinstance(ele, str)]) #生成器，比如说想要生成100W个数据，但最后才用到了几个，如查在直接以上面的列表表达式的话可能就不合适，所以想在需要的时候再去动态生成会比较好 #直接将上面数组格式的中括号改为小括号即可 gen =(x * x for x in range(1,11)) for g in gen: print(g) #也可以使用next(gen)来遍历，不过到最后一个之后的下一个会报错，所以基本上不使用next()的方法来执行 #同时函数也可以写作是生成器，如: >>>def fib(max): ... n,a,b =0,0,1 ...while n < max: ...print(b) ... a, b = b, a+b ... n+=1 ...return'done' ... >>> fib(3) 1 1 2 #在使用时，如果触发到yield时就会中断返回，到下次时从yield开始向下执行 >>>def fib1(max): ... n, a, b =0,0,1 ...while n < max: ...yield b ... a, b = b, a+b ... n+=1 ...return'done' ... >>> f = fib1(6) >>> f <generator object fib1 at 0x0000000001E5A468> #杨辉三角的写法 >>>def triangle(max): ... lineArray =[1] ...while--max >0: ...yield lineArray ... lineArray =[1]+[lineArray[i]+ lineArray[-i]for i in range(len(lineArray))if i >0]+[1] ... >>> g = triangle(5) >>> g <generator object triangle at 0x0000000001E5A410> >>>next(g) [1]
迭代器
#判定是否可送代,可以遍历的类型为:字符串、集合、元集合、生成器、set、map等，可以通过for遍历的均为可迭代的 >>from collections importIterable >> isinstance([],Iterable) # 可以使用next()来获取下个元素的称之为迭代器，目前来说只有生成器，也就是说迭代器是懒散加载的，在之前并不知道其包含的元素 >>>from collections importIterator >>> isinstance([],Iterator) False >>> isinstance((x for x in range(10)),Iterator) True
函数式编程
可以返回函数，返回的函数在调用时才会开始计算值，所以返回的函数值中不要包含循环变量值，否则会出现异常。
## 返回函数，在返回的函数中不要包含循环的变量 #因为返回的函数中包含有循环变量，到最后计算的时候全更新为相同的值了 >>> >>>def count(): ... fs =[] ...for i in range(1,3): ...def f(): ...return i*i ... fs.append(f) ...return fs >>> f1, f2 = count() >>> f1() 4 >>> f2() 4 >>> ##处理方式就是再加一层函数 >>>def count(): ...def f(j): ...def g(): ...return j*j ...return g ... fs =[] ...for i in range(1,3): ... fs.append(f(i)) ...return fs ... >>> a, b = count() >>> a() 1 >>> b() 4
高级函数
## map 和 reduce ,map将遍历每个元素，对每个元素进行处理，生成一个新的集合，reduce将集合中各个元素进行汇总，返回一个值 # 转换为符点数，利于map、reduce来处理，先将字符串转换为集合，再处理集合 def str2float(floatstr): def char_to_float(element): if str(element).__eq__("."): return-1 returnint(element) arr = map(char_to_float, floatstr) point =0 def to_float(x, n): nonlocal point if n ==-1: point =1 return x if point ==0: return x*10+ n else: point *=10 return x + n/point return reduce(to_float, arr,0.0) print('str2float(\'123.456\') =', str2float('123.456')) ##filter 过滤器，如果函数返回True，则保留，返回False，则排除 #显示所有的回数 def is_palindrome(n): if n <10: returnFalse elementstr = str(n) for i in range(0, elementstr.__len__()): if elementstr[i]!= elementstr[-i -1]: returnFalse returnTrue output = filter(is_palindrome, range(1,1000)) print(list(output)) # 排序 可以带两个参数，key(指定排序字段与字段的处理函数)与 reverse(是否倒序等) L =[('Bob',75),('adam',92),('Bart',66),('Lisa',88)] def by_name(t): return str.lower(t[0]) L2 = sorted(L, key=by_name, reverse=False) print(L2)
匿名函数
# 只对简单方法才可以写匿名函数，如 # 前一部分为参数，后一部分为表达式 >>> >>> func =lambda x: x * x >>> func <function<lambda> at 0x02155618> >>> func(1) 1
装饰器
# 这个方法待测 def log(func): def wrapper(*args,**kw): print('call %s():'% func.__name__) return func(*args,**kw) return wrapper @log def now(): print("2017-04-20") f = now #now() wrapper = log(f) wrapper()
偏函数
其实就是简化函数的参数,固定一部分参数
-
#为 **kw的模式,新生成一个int2的函数,基数为2 int2 = functools.partial(int,base=2) print(int2('11111')) #为 *args,新生成一个比较大小的函数,在左侧加入固定参数 maxAdd10 = functools.partial(max,10) print(maxAdd10(4,5))
2017-04-20 23:20:45 星期四
模块
一个.py的文件可称为一个模块,为了避免模块名冲突,加入了包名,在包中包含了一个__init__.py,称为包名的模板;
作用域
name 特殊变量,可以直接使用
__name 私有变量,不能在外部直接使用
_name 虽然可从外部访问,但应该避免
name 正常变量,可直接使用
安装第三方模块
pip install pillowfrom PIL import image
面向对象编程
# 定义对象,后面的object表明该类是从哪个类继承下来的 >>>classStudent(object): ...def __init__(self,name,score): ...self.name = name ...self.score = score ...def print_score(self): ...print("%s:%s"%(self.name,self.score)) ... >>> bar =Student("list",59) >>> bar.print_score() list:59 ## 不同对象的实例可以绑定不同的属性 >>> bar.score 59 >>> bar.age Traceback(most recent call last): File"<stdin>", line 1,in<module> AttributeError:'Student'object has no attribute 'age' >>> bar.age =10 >>> bar.age 10
继承与多态
与java类型:
class Animal(object):
class Dog(Animal):
Dog继承自Animal,并继承了所有父类的方法;
多态:如一个方法:def run(animal),可以带入animal及dog对象;
获取对象信息
注意:在不知道内部结构的时候才会采取setattr/getattr/hasattr方式取值或设置值,在已知结构的情况下,可以直接使用obj.get_attr/obj.attr来操作;
## 获取类型方式一 >>> type('str') <class'str'> >>> type('str')== str True ## 获取类型方式二 >>> isinstance(123,int) True >>> isinstance('123',str) True ## 对象拥有所有的属性与方法的集合 dir("123") ##是否包含属性或方法 hasattr(obj,"attrname") ## 类似于反射 getattr(obj,"attrname") ## 类似于反射 setattr(obj,"attrname")
类属性与实例属性
实例可以绑定绑定任意的属性;
类属性可被实例及类引用.
>>> >>>classStudent(object): ... name ="class name" ## 类属性可被实例及类引用 >>> instance =Student() >>> instance.name 'class name' >>>Student.name 'class name' ##在实例中修改属性,在实例值改了,使用类调用时还为类属性 >>> instance.name="instance name" >>> instance.name 'instance name' >>>Student.name 'class name' ##删除实例属性后类属性会显示出来了 >>>del instance.name >>> instance.name 'class name'
面向对象高级编程
classStudent(object): # 限制可以加的属性及方法名 __slots__ =('age','name','set_age','set_name') pass def set_age(self, age): self.age = age student =Student() # 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用 student.age =20 print(student.age) # 可以给实例绑定方法,给实例绑定的方法其它实例无法使用 student.set_age =MethodType(set_age, student) student.set_age(50) print(student.age) print('------------------------------------------------------') # 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改 Student.name ='zhangsan' student2 =Student() print(student2.name) def set_name(self, name): self.name = name # 给类绑定方法,所有实例都可使用 Student.set_name = set_name student3 =Student() student3.set_name('lisi') print(student3.name) <pre style="background-color:#2b2b2b;color:#a9b7c6;font-family:'宋体';font-size:12.8pt;"> classStudent(object): # 限制可以加的属性及方法名 __slots__ =('age','name','set_age','set_name') pass def set_age(self, age): self.age = age student =Student() # 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用 student.age =20 print(student.age) # 可以给实例绑定方法,给实例绑定的方法其它实例无法使用 student.set_age =MethodType(set_age, student) student.set_age(50) print(student.age) print('------------------------------------------------------') # 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改 Student.name ='zhangsan' student2 =Student() print(student2.name) def set_name(self, name): self.name = name # 给类绑定方法,所有实例都可使用 Student.set_name = set_name student3 =Student() student3.set_name('lisi') print(student3.name) </pre>
使用@property
# 将geeter方法作为property,将setter方法改为width.setter classScreen(object): @property def width(self): returnself._width @width.setter def width(self, width): self._width = width screen =Screen() scren.width =100
多重继承
# 称之为MixIn模式classClassName(,XXMixIn):
定制类
__str__ 用户打印__init__ 初始化__repr__ 调试打印__iter__ 可使用for...in循环__next__ 拿到循环的下一个值,直到退出__getitem__ 拿到循环的指定索引值__getattr__ 获取属性,可自定义
使用枚举类
# 两种枚举类的定义 @unique classWeekend(Enum): Sunday=0 Monday=1 # 所有成员 for name, member inWeekend.__members__.items(): print(name, member) Month=Enum('Month',('Jan','Feb'))
异常处理
try: print(test_method(0)) except BaseExceptionas e: logging.exception(e) finally: print('finally')
文件操作
with open("D:/a.txt",'r', encoding='utf-8')as f: f.read() f.readline() '大部分的文件操作都在os包下,少部分在shutil下,是对os的一个扩充' print(os.path.abspath('.')) print('---------列出所有的文件---------') print([file for file in os.listdir('.')if os.path.isfile(file)and os.path.splitext(file)[1]=='.py'])
序列化与反序列化存入 file-like-object对象
'序列化与反序列化' data = dict(name='张三') with open('test.txt','wb')as file: pickle.dump(data, file) with open('test.txt','rb')as file: print(pickle.load(file)) student =Student('zhangsan',10) # 将对象序列化字符串 print(json.dumps(student,default=lambda obj: obj.__dict__)) # 将字符串反序列化为dict,指定object_hook参数将dict转换为指定对象 print(json.loads(json.dumps(student,default=lambda obj: obj.__dict__)))
多进程与多线程
在window系统中,多进程与多线程可能会出错,建议使用linux与mac系统完成此类操作
import os from multiprocessing importProcess def run_process(name): print('创建了一个子进程%s(%s)'%(name, os.getpid())) print('进程号为: %s'% os.getpid()) process =Process(target=run_process, args=('test',)) process.start() process.join() print('子进程结果运行') # 不可以通过队列Queue来执行一部分操作
线程与多线程
import threading import time def loop(name): print('Thread %s is running'% threading.current_thread().name) n =0 while n <5: n = n+1 print('Thread %s is running'% threading.current_thread().name) time.sleep(1) print('Thread %s is end'% threading.current_thread().name) print('Thread %s is running'% threading.current_thread().name) thread1 = threading.Thread(target=loop, args=('test-thread',)) thread1.start() thread1.join() print('Thread %s is end'% threading.current_thread().name) ## python的多线程由于全局锁的机制,无法有效利用多核CPU的优势,如果要使用多核,请使用多进程