首页 > 代码库 > python学习笔记

python学习笔记

python基础语法学习

该文档是刚开始学习python时的笔记,参考的是廖雪峰python教程,大家有时间也可以看下~

先上一幅图,此为某位大神在python社区发布的,现在找不到链接了,如果大家有发现,可以告诉我哈~~

技术分享

基本语法

  1. #多行文本的写法
  2. ‘‘‘
  3. 第一行
  4. 第二行
  5. 第三行
  6. ‘‘‘
  7. #默认使用utf8编码,中文会修改为三个字节,每个字母为一个字节,用法类同于b开头的字符串
  8. ‘abc‘.encode()
  9. #数组操作
  10. arrya=[‘A‘,‘B‘,‘c‘]
  11. #插入元素
  12. array.insert(index,‘D‘)
  13. #显示并删除最后一个元素
  14. array.pop()
  15. #显示并删除指定位置元素
  16. array.pop(index)
  17. #指定索引位置元素值修改
  18. array[index]=‘E‘
  19. #数组的排序
  20. array.sort()
  21. ## 切片,取前10条记录,也可以从倒序,最后一个元素为-1
  22. array[0:10]
  23. #元组 tuple ,指向是不可变的,只能显示不能修改,代码更安全,如果元素有数组时,是可以修改数组指向值的
  24. array=(1,2,3)
  25. #if的用法
  26. age =18
  27. if age >=18:
  28. print(‘‘)
  29. else:
  30. print(‘‘)
  31. #字符串转换为数字
  32. int(str)
  33. array =[‘a‘,‘b‘,‘c‘]
  34. for ele in array:
  35. print(ele)
  36. #生成0-5的整数序列
  37. list(range(5))
  38. ##python中有map的概念
  39. map ={‘key‘:value,‘key2‘:value2}
  40. #指定key是否存在于map中,返回boole值
  41. key in map
  42. #python中也有set的概念
  43. s =set([1,2,3])
  44. s.add(4)
  45. s.remove(4)
  46. #set可以做交集和并集
  47. set1 & set2
  48. set1 | set2

类型转换

  1. int(‘123‘)
  2. int(12.25)
  3. str(123)
  4. bool(‘‘)
  5. bool(1)

内置函数

  1. max(1,2,3)
  2. abs(-1)

函数定义,第二个参数为默认值参数,可以不传入值

  1. def function_name(param1,param2=2):
  2. XXXXXX;
  3. return
  4. # 可变参数,接收的为元数组tuple,不允许改变,如果调用者有一个数组,需要将数组转换为可变参数才可以,如数组为array=[],,则使用 function_name(*array)来调用即可;
  5. def function_name(*param1)
  6. #关键字参数,将在内部组装为一个map,同时也可以个体**map将一个map转换为关键字参数,正常调用为: person("","",city="",job="")
  7. def person(name, age,**kw):
  8. print(‘name:‘, name,‘age:‘, age,‘other:‘, kw)
  9. #指定参数名的关键字参数,使用*进行分隔,也可以使用默认值参数
  10. def person(name, age,*, city=‘Beijing‘, job):
  11. print(name, age, city, job)

高级特性

  1. #切片
  2. array=[1,2,3]
  3. array[0:3]
  4. #迭代
  5. for ele in array
  6. for key in map
  7. for value in map.values()
  8. for key,value in map.intems()
  9. #判定元素是否可迭代
  10. isinstance([1,2,3],Iterable)
  11. # 列表生成表达式
  12. [x * x for x in range(1,11)if x %2==0]
  13. ==>[4,16,36,64,100]
  14. [m+n for m in‘ABC‘for n in‘XYZ‘]
  15. #所有元素小写,除去不符合要求的除去
  16. L1 =[‘Hello‘,‘World‘,18,‘Apple‘,None]
  17. print([ele.lower()for ele in L1 if isinstance(ele, str)])
  18. #生成器,比如说想要生成100W个数据,但最后才用到了几个,如查在直接以上面的列表表达式的话可能就不合适,所以想在需要的时候再去动态生成会比较好
  19. #直接将上面数组格式的中括号改为小括号即可
  20. gen =(x * x for x in range(1,11))
  21. for g in gen:
  22. print(g)
  23. #也可以使用next(gen)来遍历,不过到最后一个之后的下一个会报错,所以基本上不使用next()的方法来执行
  24. #同时函数也可以写作是生成器,如:
  25. >>>def fib(max):
  26. ... n,a,b =0,0,1
  27. ...while n < max:
  28. ...print(b)
  29. ... a, b = b, a+b
  30. ... n+=1
  31. ...return‘done‘
  32. ...
  33. >>> fib(3)
  34. 1
  35. 1
  36. 2
  37. #在使用时,如果触发到yield时就会中断返回,到下次时从yield开始向下执行
  38. >>>def fib1(max):
  39. ... n, a, b =0,0,1
  40. ...while n < max:
  41. ...yield b
  42. ... a, b = b, a+b
  43. ... n+=1
  44. ...return‘done‘
  45. ...
  46. >>> f = fib1(6)
  47. >>> f
  48. <generator object fib1 at 0x0000000001E5A468>
  49. #杨辉三角的写法
  50. >>>def triangle(max):
  51. ... lineArray =[1]
  52. ...while--max >0:
  53. ...yield lineArray
  54. ... lineArray =[1]+[lineArray[i]+ lineArray[-i]for i in range(len(lineArray))if i >0]+[1]
  55. ...
  56. >>> g = triangle(5)
  57. >>> g
  58. <generator object triangle at 0x0000000001E5A410>
  59. >>>next(g)
  60. [1]

迭代器

  1. #判定是否可送代,可以遍历的类型为:字符串、集合、元集合、生成器、set、map等,可以通过for遍历的均为可迭代的
  2. >>from collections importIterable
  3. >> isinstance([],Iterable)
  4. # 可以使用next()来获取下个元素的称之为迭代器,目前来说只有生成器,也就是说迭代器是懒散加载的,在之前并不知道其包含的元素
  5. >>>from collections importIterator
  6. >>> isinstance([],Iterator)
  7. False
  8. >>> isinstance((x for x in range(10)),Iterator)
  9. True

函数式编程

可以返回函数,返回的函数在调用时才会开始计算值,所以返回的函数值中不要包含循环变量值,否则会出现异常。
  1. ## 返回函数,在返回的函数中不要包含循环的变量
  2. #因为返回的函数中包含有循环变量,到最后计算的时候全更新为相同的值了
  3. >>>
  4. >>>def count():
  5. ... fs =[]
  6. ...for i in range(1,3):
  7. ...def f():
  8. ...return i*i
  9. ... fs.append(f)
  10. ...return fs
  11. >>> f1, f2 = count()
  12. >>> f1()
  13. 4
  14. >>> f2()
  15. 4
  16. >>>
  17. ##处理方式就是再加一层函数
  18. >>>def count():
  19. ...def f(j):
  20. ...def g():
  21. ...return j*j
  22. ...return g
  23. ... fs =[]
  24. ...for i in range(1,3):
  25. ... fs.append(f(i))
  26. ...return fs
  27. ...
  28. >>> a, b = count()
  29. >>> a()
  30. 1
  31. >>> b()
  32. 4
高级函数
  1. ## map 和 reduce ,map将遍历每个元素,对每个元素进行处理,生成一个新的集合,reduce将集合中各个元素进行汇总,返回一个值
  2. # 转换为符点数,利于map、reduce来处理,先将字符串转换为集合,再处理集合
  3. def str2float(floatstr):
  4. def char_to_float(element):
  5. if str(element).__eq__("."):
  6. return-1
  7. returnint(element)
  8. arr = map(char_to_float, floatstr)
  9. point =0
  10. def to_float(x, n):
  11. nonlocal point
  12. if n ==-1:
  13. point =1
  14. return x
  15. if point ==0:
  16. return x*10+ n
  17. else:
  18. point *=10
  19. return x + n/point
  20. return reduce(to_float, arr,0.0)
  21. print(‘str2float(\‘123.456\‘) =‘, str2float(‘123.456‘))
  22. ##filter 过滤器,如果函数返回True,则保留,返回False,则排除
  23. #显示所有的回数
  24. def is_palindrome(n):
  25. if n <10:
  26. returnFalse
  27. elementstr = str(n)
  28. for i in range(0, elementstr.__len__()):
  29. if elementstr[i]!= elementstr[-i -1]:
  30. returnFalse
  31. returnTrue
  32. output = filter(is_palindrome, range(1,1000))
  33. print(list(output))
  34. # 排序 可以带两个参数,key(指定排序字段与字段的处理函数)与 reverse(是否倒序等)
  35. L =[(‘Bob‘,75),(‘adam‘,92),(‘Bart‘,66),(‘Lisa‘,88)]
  36. def by_name(t):
  37. return str.lower(t[0])
  38. L2 = sorted(L, key=by_name, reverse=False)
  39. print(L2)
匿名函数
  1. # 只对简单方法才可以写匿名函数,如
  2. # 前一部分为参数,后一部分为表达式
  3. >>>
  4. >>> func =lambda x: x * x
  5. >>> func
  6. <function<lambda> at 0x02155618>
  7. >>> func(1)
  8. 1
装饰器
  1. # 这个方法待测
  2. def log(func):
  3. def wrapper(*args,**kw):
  4. print(‘call %s():‘% func.__name__)
  5. return func(*args,**kw)
  6. return wrapper
  7. @log
  8. def now():
  9. print("2017-04-20")
  10. f = now
  11. #now()
  12. wrapper = log(f)
  13. wrapper()<pre style="background-
偏函数

其实就是简化函数的参数,固定一部分参数

  1. #为 **kw的模式,新生成一个int2的函数,基数为2
  2. int2 = functools.partial(int,base=2)
  3. print(int2(‘11111‘))
  4. #为 *args,新生成一个比较大小的函数,在左侧加入固定参数
  5. maxAdd10 = functools.partial(max,10)
  6. print(maxAdd10(4,5))

2017-04-20 23:20:45 星期四

模块

一个.py的文件可称为一个模块,为了避免模块名冲突,加入了包名,在包中包含了一个__init__.py,称为包名的模板;

作用域

name 特殊变量,可以直接使用
__name 私有变量,不能在外部直接使用
_name 虽然可从外部访问,但应该避免
name 正常变量,可直接使用

安装第三方模块
  1. pip install pillow
  2. from PIL import image

面向对象编程

  1. # 定义对象,后面的object表明该类是从哪个类继承下来的
  2. >>>classStudent(object):
  3. ...def __init__(self,name,score):
  4. ...self.name = name
  5. ...self.score = score
  6. ...def print_score(self):
  7. ...print("%s:%s"%(self.name,self.score))
  8. ...
  9. >>> bar =Student("list",59)
  10. >>> bar.print_score()
  11. list:59
  12. ## 不同对象的实例可以绑定不同的属性
  13. >>> bar.score
  14. 59
  15. >>> bar.age
  16. Traceback(most recent call last):
  17. File"<stdin>", line 1,in<module>
  18. AttributeError:‘Student‘object has no attribute ‘age‘
  19. >>> bar.age =10
  20. >>> bar.age
  21. 10
继承与多态

与java类型:
class Animal(object):
class Dog(Animal):
Dog继承自Animal,并继承了所有父类的方法;
多态:如一个方法:def run(animal),可以带入animal及dog对象;

获取对象信息

注意:在不知道内部结构的时候才会采取setattr/getattr/hasattr方式取值或设置值,在已知结构的情况下,可以直接使用obj.get_attr/obj.attr来操作;

  1. ## 获取类型方式一
  2. >>> type(‘str‘)
  3. <class‘str‘>
  4. >>> type(‘str‘)== str
  5. True
  6. ## 获取类型方式二
  7. >>> isinstance(123,int)
  8. True
  9. >>> isinstance(‘123‘,str)
  10. True
  11. ## 对象拥有所有的属性与方法的集合
  12. dir("123")
  13. ##是否包含属性或方法
  14. hasattr(obj,"attrname")
  15. ## 类似于反射
  16. getattr(obj,"attrname")
  17. ## 类似于反射
  18. setattr(obj,"attrname")
类属性与实例属性

实例可以绑定绑定任意的属性;
类属性可被实例及类引用.

  1. >>>
  2. >>>classStudent(object):
  3. ... name ="class name"
  4. ## 类属性可被实例及类引用
  5. >>> instance =Student()
  6. >>> instance.name
  7. ‘class name‘
  8. >>>Student.name
  9. ‘class name‘
  10. ##在实例中修改属性,在实例值改了,使用类调用时还为类属性
  11. >>> instance.name="instance name"
  12. >>> instance.name
  13. ‘instance name‘
  14. >>>Student.name
  15. ‘class name‘
  16. ##删除实例属性后类属性会显示出来了
  17. >>>del instance.name
  18. >>> instance.name
  19. ‘class name‘

面向对象高级编程

  1. classStudent(object):
  2. # 限制可以加的属性及方法名
  3. __slots__ =(‘age‘,‘name‘,‘set_age‘,‘set_name‘)
  4. pass
  5. def set_age(self, age):
  6. self.age = age
  7. student =Student()
  8. # 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用
  9. student.age =20
  10. print(student.age)
  11. # 可以给实例绑定方法,给实例绑定的方法其它实例无法使用
  12. student.set_age =MethodType(set_age, student)
  13. student.set_age(50)
  14. print(student.age)
  15. print(‘------------------------------------------------------‘)
  16. # 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改
  17. Student.name =‘zhangsan‘
  18. student2 =Student()
  19. print(student2.name)
  20. def set_name(self, name):
  21. self.name = name
  22. # 给类绑定方法,所有实例都可使用
  23. Student.set_name = set_name
  24. student3 =Student()
  25. student3.set_name(‘lisi‘)
  26. print(student3.name)
  27. <pre style="background-color:#2b2b2b;color:#a9b7c6;font-family:‘宋体‘;font-size:12.8pt;">
  28. classStudent(object):
  29. # 限制可以加的属性及方法名
  30. __slots__ =(‘age‘,‘name‘,‘set_age‘,‘set_name‘)
  31. pass
  32. def set_age(self, age):
  33. self.age = age
  34. student =Student()
  35. # 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用
  36. student.age =20
  37. print(student.age)
  38. # 可以给实例绑定方法,给实例绑定的方法其它实例无法使用
  39. student.set_age =MethodType(set_age, student)
  40. student.set_age(50)
  41. print(student.age)
  42. print(‘------------------------------------------------------‘)
  43. # 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改
  44. Student.name =‘zhangsan‘
  45. student2 =Student()
  46. print(student2.name)
  47. def set_name(self, name):
  48. self.name = name
  49. # 给类绑定方法,所有实例都可使用
  50. Student.set_name = set_name
  51. student3 =Student()
  52. student3.set_name(‘lisi‘)
  53. print(student3.name)
  54. </pre>
使用@property
  1. # 将geeter方法作为property,将setter方法改为width.setter
  2. classScreen(object):
  3. @property
  4. def width(self):
  5. returnself._width
  6. @width.setter
  7. def width(self, width):
  8. self._width = width
  9. screen =Screen()
  10. scren.width =100
多重继承
  1. # 称之为MixIn模式
  2. classClassName(,XXMixIn):
定制类
  1. __str__ 用户打印
  2. __init__ 初始化
  3. __repr__ 调试打印
  4. __iter__ 可使用for...in循环
  5. __next__ 拿到循环的下一个值,直到退出
  6. __getitem__ 拿到循环的指定索引值
  7. __getattr__ 获取属性,可自定义
使用枚举类
  1. # 两种枚举类的定义
  2. @unique
  3. classWeekend(Enum):
  4. Sunday=0
  5. Monday=1
  6. # 所有成员
  7. for name, member inWeekend.__members__.items():
  8. print(name, member)
  9. Month=Enum(‘Month‘,(‘Jan‘,‘Feb‘))
异常处理
  1. try:
  2. print(test_method(0))
  3. exceptBaseExceptionas e:
  4. logging.exception(e)
  5. finally:
  6. print(‘finally‘)
文件操作
  1. with open("D:/a.txt",‘r‘, encoding=‘utf-8‘)as f:
  2. f.read()
  3. f.readline()
  4. ‘大部分的文件操作都在os包下,少部分在shutil下,是对os的一个扩充‘
  5. print(os.path.abspath(‘.‘))
  6. print(‘---------列出所有的文件---------‘)
  7. print([file for file in os.listdir(‘.‘)if os.path.isfile(file)and os.path.splitext(file)[1]==‘.py‘])
序列化与反序列化存入 file-like-object对象
  1. ‘序列化与反序列化‘
  2. data = dict(name=‘张三‘)
  3. with open(‘test.txt‘,‘wb‘)as file:
  4. pickle.dump(data, file)
  5. with open(‘test.txt‘,‘rb‘)as file:
  6. print(pickle.load(file))
  7. student =Student(‘zhangsan‘,10)
  8. # 将对象序列化字符串
  9. print(json.dumps(student,default=lambda obj: obj.__dict__))
  10. # 将字符串反序列化为dict,指定object_hook参数将dict转换为指定对象
  11. print(json.loads(json.dumps(student,default=lambda obj: obj.__dict__)))
多进程与多线程

在window系统中,多进程与多线程可能会出错,建议使用linux与mac系统完成此类操作

  1. import os
  2. from multiprocessing importProcess
  3. def run_process(name):
  4. print(‘创建了一个子进程%s(%s)‘%(name, os.getpid()))
  5. print(‘进程号为: %s‘% os.getpid())
  6. process =Process(target=run_process, args=(‘test‘,))
  7. process.start()
  8. process.join()
  9. print(‘子进程结果运行‘)
  10. # 不可以通过队列Queue来执行一部分操作
线程与多线程
  1. import threading
  2. import time
  3. def loop(name):
  4. print(‘Thread %s is running‘% threading.current_thread().name)
  5. n =0
  6. while n <5:
  7. n = n+1
  8. print(‘Thread %s is running‘% threading.current_thread().name)
  9. time.sleep(1)
  10. print(‘Thread %s is end‘% threading.current_thread().name)
  11. print(‘Thread %s is running‘% threading.current_thread().name)
  12. thread1 = threading.Thread(target=loop, args=(‘test-thread‘,))
  13. thread1.start()
  14. thread1.join()
  15. print(‘Thread %s is end‘% threading.current_thread().name)
  16. ## python的多线程由于全局锁的机制,无法有效利用多核CPU的优势,如果要使用多核,请使用多进程

python学习笔记