python学习笔记

Posted 2020-09-18

python基础语法学习

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

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

基本语法

1. #多行文本的写法
2. ‘‘‘
3. 第一行
4. 第二行
5. 第三行
6. ‘‘‘
7. #默认使用utf8编码，中文会修改为三个字节，每个字母为一个字节，用法类同于b开头的字符串
8. ‘abc‘.encode()
10. #数组操作
11. arrya=[‘A‘,‘B‘,‘c‘]
12. #插入元素
13. array.insert(index,‘D‘)
14. #显示并删除最后一个元素
15. array.pop()
16. #显示并删除指定位置元素
17. array.pop(index)
18. #指定索引位置元素值修改
19. array[index]=‘E‘
20. #数组的排序
21. array.sort()
22. ## 切片,取前10条记录，也可以从倒序，最后一个元素为-1
23. array[0:10]
25. #元组 tuple ，指向是不可变的，只能显示不能修改，代码更安全，如果元素有数组时，是可以修改数组指向值的
26. array=(1,2,3)
28. #if的用法
29. age =18
30. if age >=18:
31. print(‘‘)
32. else:
33. print(‘‘)
35. #字符串转换为数字
36. int(str)
38. array =[‘a‘,‘b‘,‘c‘]
39. for ele in array:
40. print(ele)
42. #生成0－5的整数序列
43. list(range(5))
45. ##python中有map的概念
46. map ={‘key‘:value,‘key2‘:value2}
47. #指定key是否存在于map中,返回boole值
48. key in map
50. #python中也有set的概念
51. s =set([1,2,3])
52. s.add(4)
53. s.remove(4)
55. #set可以做交集和并集
56. set1 & set2
57. 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
5. # 可变参数，接收的为元数组tuple，不允许改变，如果调用者有一个数组，需要将数组转换为可变参数才可以，如数组为array=[],，则使用 function_name(*array)来调用即可;
6. def function_name(*param1)
8. #关键字参数，将在内部组装为一个map,同时也可以个体**map将一个map转换为关键字参数，正常调用为: person("","",city="",job="")
9. def person(name, age,**kw):
10. print(‘name:‘, name,‘age:‘, age,‘other:‘, kw)
13. #指定参数名的关键字参数，使用*进行分隔，也可以使用默认值参数
14. def person(name, age,*, city=‘Beijing‘, job):
15. print(name, age, city, job)

高级特性

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

迭代器

1. #判定是否可送代,可以遍历的类型为:字符串、集合、元集合、生成器、set、map等，可以通过for遍历的均为可迭代的
2. >>from collections importIterable
3. >> isinstance([],Iterable)
5. # 可以使用next()来获取下个元素的称之为迭代器，目前来说只有生成器，也就是说迭代器是懒散加载的，在之前并不知道其包含的元素
6. >>>from collections importIterator
7. >>> isinstance([],Iterator)
8. False
9. >>> isinstance((x for x in range(10)),Iterator)
10. 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
12. >>> f1, f2 = count()
13. >>> f1()
14. 4
15. >>> f2()
16. 4
17. >>>
19. ##处理方式就是再加一层函数
20. >>>def count():
21. ...def f(j):
22. ...def g():
23. ...return j*j
24. ...return g
25. ... fs =[]
26. ...for i in range(1,3):
27. ... fs.append(f(i))
28. ...return fs
29. ...
30. >>> a, b = count()
31. >>> a()
32. 1
33. >>> b()
34. 4

高级函数

1. ## map 和 reduce ,map将遍历每个元素，对每个元素进行处理，生成一个新的集合，reduce将集合中各个元素进行汇总，返回一个值
3. # 转换为符点数，利于map、reduce来处理，先将字符串转换为集合，再处理集合
4. def str2float(floatstr):
6. def char_to_float(element):
7. if str(element).__eq__("."):
8. return-1
9. returnint(element)
11. arr = map(char_to_float, floatstr)
12. point =0
14. def to_float(x, n):
15. nonlocal point
16. if n ==-1:
17. point =1
18. return x
19. if point ==0:
20. return x*10+ n
21. else:
22. point *=10
23. return x + n/point
24. return reduce(to_float, arr,0.0)
25. print(‘str2float(\\‘123.456\\‘) =‘, str2float(‘123.456‘))
29. ##filter 过滤器，如果函数返回True，则保留，返回False，则排除
30. #显示所有的回数
31. def is_palindrome(n):
32. if n <10:
33. returnFalse
34. elementstr = str(n)
35. for i in range(0, elementstr.__len__()):
36. if elementstr[i]!= elementstr[-i -1]:
37. returnFalse
38. returnTrue
40. output = filter(is_palindrome, range(1,1000))
41. print(list(output))
44. # 排序 可以带两个参数，key(指定排序字段与字段的处理函数)与 reverse(是否倒序等)
45. L =[(‘Bob‘,75),(‘adam‘,92),(‘Bart‘,66),(‘Lisa‘,88)]
47. def by_name(t):
48. return str.lower(t[0])
49. L2 = sorted(L, key=by_name, reverse=False)
50. 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
9. @log
10. def now():
11. print("2017-04-20")
12. f = now
14. #now()
15. wrapper = log(f)
16. wrapper()<pre style="background-

偏函数

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

1. #为 **kw的模式,新生成一个int2的函数,基数为2
2. int2 = functools.partial(int,base=2)
3. print(int2(‘11111‘))
5. #为 *args,新生成一个比较大小的函数,在左侧加入固定参数
6. maxAdd10 = functools.partial(max,10)
7. 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
13. ## 不同对象的实例可以绑定不同的属性
14. >>> bar.score
15. 59
16. >>> bar.age
17. Traceback(most recent call last):
18. File"<stdin>", line 1,in<module>
19. AttributeError:‘Student‘object has no attribute ‘age‘
20. >>> bar.age =10
21. >>> bar.age
22. 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
7. ## 获取类型方式二
8. >>> isinstance(123,int)
9. True
10. >>> isinstance(‘123‘,str)
11. True
13. ## 对象拥有所有的属性与方法的集合
14. dir("123")
17. ##是否包含属性或方法
18. hasattr(obj,"attrname")
20. ## 类似于反射
21. getattr(obj,"attrname")
22. ## 类似于反射
23. 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‘
11. ##在实例中修改属性,在实例值改了,使用类调用时还为类属性
12. >>> instance.name="instance name"
13. >>> instance.name
14. ‘instance name‘
15. >>>Student.name
16. ‘class name‘
18. ##删除实例属性后类属性会显示出来了
19. >>>del instance.name
20. >>> instance.name
21. ‘class name‘

面向对象高级编程

2. classStudent(object):
3. # 限制可以加的属性及方法名
4. __slots__ =(‘age‘,‘name‘,‘set_age‘,‘set_name‘)
5. pass
8. def set_age(self, age):
9. self.age = age
11. student =Student()
12. # 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用
13. student.age =20
14. print(student.age)
16. # 可以给实例绑定方法,给实例绑定的方法其它实例无法使用
17. student.set_age =MethodType(set_age, student)
18. student.set_age(50)
19. print(student.age)
21. print(‘------------------------------------------------------‘)
22. # 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改
23. Student.name =‘zhangsan‘
24. student2 =Student()
25. print(student2.name)
28. def set_name(self, name):
29. self.name = name
31. # 给类绑定方法,所有实例都可使用
32. Student.set_name = set_name
33. student3 =Student()
34. student3.set_name(‘lisi‘)
35. print(student3.name)
36. <pre style="background-color:#2b2b2b;color:#a9b7c6;font-family:‘宋体‘;font-size:12.8pt;">
37. classStudent(object):
38. # 限制可以加的属性及方法名
39. __slots__ =(‘age‘,‘name‘,‘set_age‘,‘set_name‘)
40. pass
42. def set_age(self, age):
43. self.age = age
45. student =Student()
46. # 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用
47. student.age =20
48. print(student.age)
50. # 可以给实例绑定方法,给实例绑定的方法其它实例无法使用
51. student.set_age =MethodType(set_age, student)
52. student.set_age(50)
53. print(student.age)
55. print(‘------------------------------------------------------‘)
56. # 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改
57. Student.name =‘zhangsan‘
58. student2 =Student()
59. print(student2.name)
61. def set_name(self, name):
62. self.name = name
64. # 给类绑定方法,所有实例都可使用
65. Student.set_name = set_name
66. student3 =Student()
67. student3.set_name(‘lisi‘)
68. print(student3.name)
69. </pre>

使用@property

1. # 将geeter方法作为property,将setter方法改为width.setter
2. classScreen(object):
3. @property
4. def width(self):
5. returnself._width
7. @width.setter
8. def width(self, width):
9. self._width = width
11. screen =Screen()
12. 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
7. # 所有成员
8. for name, member inWeekend.__members__.items():
9. print(name, member)
11. 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()
6. ‘大部分的文件操作都在os包下,少部分在shutil下,是对os的一个扩充‘
7. print(os.path.abspath(‘.‘))
8. print(‘---------列出所有的文件---------‘)
9. 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)
6. with open(‘test.txt‘,‘rb‘)as file:
7. print(pickle.load(file))
10. student =Student(‘zhangsan‘,10)
11. # 将对象序列化字符串
12. print(json.dumps(student,default=lambda obj: obj.__dict__))
13. # 将字符串反序列化为dict,指定object_hook参数将dict转换为指定对象
14. print(json.loads(json.dumps(student,default=lambda obj: obj.__dict__)))

多进程与多线程

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

1. import os
2. from multiprocessing importProcess
5. def run_process(name):
6. print(‘创建了一个子进程%s(%s)‘%(name, os.getpid()))
9. print(‘进程号为: %s‘% os.getpid())
10. process =Process(target=run_process, args=(‘test‘,))
11. process.start()
12. process.join()
13. print(‘子进程结果运行‘)
15. # 不可以通过队列Queue来执行一部分操作

线程与多线程

1. import threading
2. import time
5. def loop(name):
6. print(‘Thread %s is running‘% threading.current_thread().name)
7. n =0
8. while n <5:
9. n = n+1
10. print(‘Thread %s is running‘% threading.current_thread().name)
11. time.sleep(1)
12. print(‘Thread %s is end‘% threading.current_thread().name)
15. print(‘Thread %s is running‘% threading.current_thread().name)
16. thread1 = threading.Thread(target=loop, args=(‘test-thread‘,))
17. thread1.start()
18. thread1.join()
19. print(‘Thread %s is end‘% threading.current_thread().name)
21. ## python的多线程由于全局锁的机制,无法有效利用多核CPU的优势,如果要使用多核,请使用多进程