python小笔记

  1 python特点
  2     python使用缩进
  3     多个语句在一行使用;分隔
  4     注释为#,多行注释doc string()
  5 cmd的pip安装
  6     pip install selenium #安装
  7     pip list #查看安装了哪些包
  8     pip uninstall selenium #卸载
  9     py -3 -m pip install selenium #python安装在python3.0上
 10     
 11 打印
 12     print("hello"," ","world");
 13     name=input("输入你的名字");
 14     print(name);
 15     
 16 数据类型
 17     整数 int
 18     浮点数 float
 19     布尔值 bool
 20     空值 None
 21     type{a} #查看a的变量类型
 22     
 23 变量赋值(不区分单双引号)
 24     a=100            #int
 25     b="test"        #字符串
 26     x=y=z=1            #多重赋值
 27     x,y,z=1,2,"str" #多元赋值
 28     int(a);str(a);    #类型转换
 29     
 30 运算符
 31     3 * 5                
 32     3 ** 2            #乘方
 33     5 / 2
 34     5%2
 35     "hello"+"world"
 36     10 // 3    ;        #整除，返回值为帧整数部分；
 37 
 38 注释：
 39     单行注释#
 40     多行注释
 41         """
 42         注释内容
 43         """
 44 转义
 45      46     \n 换行
 47     \也可以续行，表示没有输完
 48     
 49 字符串
 50     print("%d(x)是一个数字,%s(y)是一个字符串"%(x,y));
 51     %d(data)打印数字
 52     %s(string)打印字符串
 53     如果无法确定种类种类则用%r
 54     l=[1,2,3]
 55     print("这个列表的内容是%r" % l )
 56     
 57 字符串操作
 58     #比如a="abc";b="cde"
 59     +    字符串连接
 60     *    字符串重复输出 a*2 ,输出aa
 61     []    索引,a[0]="a",a[-1]="c"
 62     [ : ]
 63     in
 64     not in 
 65     r/R
 66     %   格式字符串
 67     
 68 字符串常见函数方法
 69     L=[‘a‘,‘b‘,‘c‘];
 70         "".join(L)         #拼接成abc
 71         "_".join(L)     #拼接成a_b_c
 72     L="a,b,c"
 73         L.split(",")    #换成list类型，以,分割
 74     str.endswith(obj,beg=0,end=len(string));
 75     
 76     A="abcdefdasd1";
 77         A.find(‘1‘);
 78         "_".join(A);     #输出‘a_b_c_d_e_f_d_a_s_d_1‘
 79         len(A)            #11
 80         A.replace("a","A");#‘AbcdefdAsd1‘
 81         A.split("a");         #[‘‘, ‘bcdefd‘, ‘sd1‘]
 82         A.strip(‘a‘);        #左右各处理掉a字符，‘bcdefdasd1‘
 83         A.startswith(‘a‘,0,len(A));     #true
 84         
 85 列表list
 86     赋值、索引
 87         A[1][1]取索引为1的元素中的索引为1的元素
 88     基本操作
 89     切片，从左边开始取值
 90         比如A=[1,2,3,4,5]
 91         A[1:3] 表示取值为A[1],A[2]
 92         A[x:y] 表示取值A[x]到A[y-1]这个范围内
 93         A[0:-2]从最左边取值到最右倒数第二个但不包含这个数，这里就是[1, 2, 3, 4]
 94 
 95 list函数
 96     len(list)
 97     max(list)/min(list)
 98     list(seq) 元祖转换为列表
 99     
100 list方法
101     list.append(obj);        列表末尾添加新的对象
102     list.count(obj);        对指定元素计数
103     list.extend(seq);        插入序列类的东西到末尾，比如字符串，list
104     list.index(obj);        找到某个元素的位置
105     list.insert(index,obj);    在指定位置插入
106     list.pop(index);        删除某元素
107     list.remove(obj);        删除某元素
108     list.reverse();            反序
109     list.sort();            排序
110     list.clear();            清空
111     list.copy();            建立副本
112     list.strip()         方法用于移除字符串头尾指定的字符（默认为空格）
113 
114 
115 元祖tuple
116     特色：
117     1、和list相似，最大的不同元祖是一种只读且不可读的数据结构
118     2、不可替代元祖中的所有元素，至刻度不可更变
119     3、list与tuple可以相互转换，tuple(list)、list(tuple)
120     
121     赋值：
122     h=(2,[3,4],(23112,2));    #多维列表
123     h=(1,)                    #一个元素时必须要打逗号，因为h=(1)与h=1一致。
124     
125 字典：Dict
126     a={‘x‘:3,    ‘y‘:4,    ‘z‘:5    }
127     #x就是key不能为数字；3表示value值；和json格式相似
128     a[‘xx‘]=333; #表示又插入一个键为‘xx‘,值为‘333‘的元素；
129                 #结果是a字典就是{‘x‘: 3, ‘y‘: 4, ‘z‘: 5, ‘xxx‘: 2333}
130                 
131                 
132     字典的函数方法：
133         dict.clear()
134         dict.copy();
135         dict.get(key,None);        #返回指定键的值，若没有返回"None"
136         key in dict
137         dict.items()            #以列表返回可遍历的(键，值)元祖数组
138         dict.keys()                #以列表返回一个字典所有的键
139         dict.setdefault(key,None)#和get()相似，但如果键不存在字典中，会添加一个key键，值为None
140         dict.update(dict2)        #把字典dict2的键/值对更新到dict里
141         dict.values()            #返回字典中所有的值；
142         dict.pop(key,None)        #删除键Key对应的值，返回被删除的值，key值不存在返回None。如果Key不存在，又没有默认值，则报错。
143         
144 条件语句
145 if y>0:
146     print("y>0")
147 elif y==0:
148     print("y==0")
149 else:
150     print("y<0")
151 ################
152 布尔表现式---逻辑操作符and、or、not、in、not in
153 a=2;b=4;c=6
154 if b>=a and b<=c:
155     print("b is between a and c")
156     
157 if not (b<a or b>c):
158     print("b is still between a and c")
159 ######################
160 while语句
161 i=5
162 while i>0:
163     print("ss")
164     i=i-1
165     
166 ######################
167 For语句
168 for i in [3,4,10,25]:
169     print(i)
170 
171 for i in "helloworld":
172     print(i)
173     
174 for i in range(10):    #i从0取到9 
175     print(i)
176     
177 A=[]
178 for j in [3,4,5,6]:
179     A.append(j**2)
180 
181 
182 range(1,10)            #从1取到10
183 range(1,10,2)        #从1取到10，每隔2取一次值
184 
185 
186 #######################
187 控制流终止
188     continue
189     break
190     
191     
192     
193     
194     
195     
196 ###############################
197 函数
198     def语句
199     def 函数名(参数1,参数2,参数3)
200         语句块
201 
202 def divide(a,b):
203     q=a/b
204     r=a-q*b
205     return q,r
206 
207 #调用
208 x,y=divide(42,5)    #x=8,y=2
209 x=divide(42,5)        #x=(8,2)是tuple元祖
210 
211 def add(a,b=2):        #a为位置参数，b为默认参数、默认取值为2。默认参数在位置参数之后
212     s=a+b
213     return s
214 
215 def fenshu(name,socre=90):
216     print(‘%s的分数为%d‘%(name,score)) 
217 
218     
219 #调用分数
220 fenshu(‘张三‘,)
221 t=(‘李四‘,80)
222 fenshu(*t)    
223     
224 ###############
225 #1、可变参数
226 def func(*a):        #如果输入为1,23,4,4,5；那么a=(1,23,4,4,5)元祖
227     sum=0
228     for n in a:
229         sum=sum+n
230     return sum
231     
232 def fenshu(name,socre=90):
233     print(‘%s的分数为%d‘%(name,score)) 
234 
235     
236 #2、可变参数
237 fenshu(‘张三‘)
238 t=(‘李四‘,80)
239 fenshu(*t)    
240     
241     
242 #################################################    
243 关键字参数
244 def func(**kw)
245 可变参数允许传入0或者任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许我传入0~任意个含参数名的参数，这写关键字参数在内自动组装为一个dict。与可变参数相同，需要使用dict的操作方法来操作dict
246 
247 在调用函数时，我们可以将参数组装成dict，通过func(**dict)的方式传参
248 def func(name,age=20):
249     print("%s age is %d"%(name,age))
250 
251 p={‘name‘:‘bob‘,‘age‘:27}
252 func(**p)
253 
254 参数组合
255     顺序为位置参数、默认参数、可变参数和关键字参数，形式：
256 def func(para,para2=None,*agrs,**kw)
257 #################################################    
258 类、对象
259 class Person():
260     def __init__(self,name,age):  #初始化，绑定实例属性,特殊的方法，类似于java的构造函数,第一个参数必须是self
261         self.name=name
262         self.age=age
263 1、继承
264 class Count():
265     def __init__(self,a,b):        #初始化类的属性
266         self.a=a
267         self.b=b
268     def add(self):                #类中的方法，第一个参数必须是self
269         return self.a+self.b
270 
271 count = Count(3,5);    #实例化对象,是否传参取决于__init__
272 count.add();        #调用对象的方法
273 
274 class Father():        #表示无继承父类，或者说这是继承基类
275     def add(self,a,b):
276         return a+b
277 
278         
279 class Son(Father):
280     def div(self,a,b):
281         return a-b
282 >>> son=Son();        #实例化对象
283 >>> son.add(3,5)
284 >>> son.div(3,5)
285 
286 ##########################################################
287 异常
288 try:
289     open("abc.txt",‘r‘)
290 except IOError:
291     print "异常了!"
292 
293 try:
294     print aa
295 except NameError:
296     print "这是一个 name 异常!"    
297 
298 
299 try:
300     open("abc.txt",‘r‘)
301     print aa
302 except BaseException:
303     print "异常了!"    
304 所有的异常类有了新的基类 BaseException，Exception 同样也继承BaseException，所以我们也可以使用 BaseException 来接收所有的异常。
305 
306 try:
307     print(s)
308 except NameError:
309     print("异常")
310 finally:
311     print("没有异常") #finally如何都都会被执行
312     
313 try:
314     print(s)
315 except NameError:
316     print("异常")
317 else:
318     print("没有异常") #try正确才会执行
319 ###读取文件#######################################################
320 #coding=utf-8
321 import  time
322 
323 files =open(‘C:/Users/Lee/Desktop/test01.txt‘,‘r‘)
324 try:
325    # print(str)
326     for l in files:
327         print(l)
328      #   time.sleep(1)
329 finally:
330     #files.close()
331     print (‘Cleaning up ...closed the file‘)
332 #######################################
333 
334 
335 
336 ######################################
337 
338 引入包
339 import time
340 print(time.ctime())
341 
342 引入自己写的模块
343 
344 
345 ##########################导入写的模块的路径
346 import sys
347 sys.path.append(‘C:\\test\\WorkSpace_Python\\Learn0904‘)
348 print(sys.path)
349 print(sys)
350 
351 
352 ###################################
353 open/文件操作
354 f=open(‘/tmp/hello‘,‘w‘)
355 
356 #open(路径+文件名,读写模式)
357 
358 #读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式        
359 读写模式的类型有：
360 
361 rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
362 w     以写方式打开，
363 a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
364 r+     以读写模式打开
365 w+     以读写模式打开 (参见 w )
366 a+     以读写模式打开 (参见 a )
367 rb     以二进制读模式打开
368 wb     以二进制写模式打开 (参见 w )
369 ab     以二进制追加模式打开 (参见 a )
370 rb+    以二进制读写模式打开 (参见 r+ )
371 wb+    以二进制读写模式打开 (参见 w+ )
372 ab+    以二进制读写模式打开 (参见 a+ )        
373 
374 
375 #举例：读取文件
376 f=open(‘C:/Users/Lee/Desktop/123.csv‘,‘r+‘)
377 str=f.readlines()
378 
379 for i in str:
380     print(i)
381 f.close()
382 
383 #举例：读取csv文件
384 import csv
385 file1=open(‘C:/Users/Lee/Desktop/actual.csv‘,‘r+‘)
386 csv_reader=csv.reader(file1)
387 print(type(csv_reader))
388 for row in csv_reader:
389     print(type(row))
390     print(row[1])
391 file1.close()
392 
393 #写入文件
394 f=open(‘C:/Users/Lee/Desktop/111.csv‘,‘a+‘)
395 num=[1,2,3,4,5]
396 char=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
397 
398 l=[]
399 for i in range(len(num)):
400     m=str(num[i])+‘,‘+char[i]
401     l.append(m)
402 f.write(str(l)+‘\n‘)
403 f.close()
404 
405 #写入csv文件，这里的row_all是获取到的数据库的内容，为元祖
406 l=list(row_all)
407 f=open(‘D:/123.csv‘,‘a+‘,newline=‘‘)
408 writer=csv.writer(f)
409 num=len(l)
410 for i in range(num):
411     writer.writerow(l[i])
412 f.close()
413 
414 
415 #####################################python发送邮件
416 #coding=utf-8
417 import smtplib
418 from email.mime.text import MIMEText
419 from email.header import Header
420 
421 #发送邮箱
422 sender=‘lihujun101@163.com‘
423 #接受邮箱
424 receiver=[‘316947664@qq.com‘]
425 
426 #发送主题
427 subject=‘测试‘
428 #发送邮箱的服务器地址
429 smtpserver=‘smtp.163.com‘
430 #发送邮箱用户/密码
431 user=‘lihujun101@163.com‘
432 pwd=‘li1992hujun‘
433 
434 #邮件正文
435 msg=MIMEText(‘<html><h1>你好!!!‘
436              ‘</h1><a href="http://baidu.com">这是一个链接</a></html>‘,‘html‘,‘utf-8‘)
437 msg[‘From‘]=‘李胡军‘#可以写出来表示发件人名字
438 msg[‘To‘]=‘316947664@qq.com‘
439 msg[‘Subject‘]=Header(subject,‘utf-8‘)
440 
441 smtpObj=smtplib.SMTP(smtpserver,25)
442 
443 smtpObj.login(user,pwd)
444 smtpObj.sendmail(sender,receiver,msg.as_string())
445 
446 ########################################################################
447 ###带附件发送邮件
448 #coding=utf-8
449 import smtplib
450 from email.mime.multipart import MIMEMultipart
451 from email.mime.text import MIMEText
452 from email.header import Header
453 
454 #发送邮箱
455 sender=‘lihujun101@163.com‘
456 #接受邮箱
457 receiver=[‘316947664@qq.com‘]
458 
459 #发送主题
460 subject=‘测试‘
461 #发送邮箱的服务器地址
462 smtpserver=‘smtp.163.com‘
463 #发送邮箱用户/密码
464 user=‘lihujun101@163.com‘
465 pwd=‘li1992hujun‘
466 
467 #邮件正文
468 msg=MIMEMultipart()
469 msg.attach(MIMEText(‘<html><h1>你好!!!‘
470              ‘</h1><a href="http://baidu.com">这是一个链接</a></html>‘,‘html‘,‘utf-8‘))
471 
472 msg[‘From‘]=‘李胡军‘#可以写出来表示发件人名字
473 msg[‘Subject‘]=Header(subject,‘utf-8‘)
474 
475 
476 #附件
477 fj=‘C:\\Windows\\addins\\FXSEXT.ecf‘
478 att=MIMEText(open(fj,‘rb‘).read(),‘base64‘,‘utf-8‘)
479 att["Content-Type"]= ‘application/octet-stream‘
480 att[‘Content-Disposition‘]=‘attachment; filename="test"‘
481 msg.attach(att)
482 
483 #发送
484 smtpObj=smtplib.SMTP(smtpserver,25)
485 smtpObj.login(user,pwd)
486 smtpObj.sendmail(sender,receiver,msg.as_string())
487 
488 ###################################################################################
489 
490 
491 
492 
493 
494 #####lambda函数
495 f=lambda x:x*2
496 ‘‘‘
497 用 lambda 来声明匿名函数，冒号（：）前面 x 表示入参，冒号后面 x*2 表示返回值。lambda 和普通的函数相比，省去了函数名称，“匿名函数”也是由此而来。
498 ‘‘‘
499 等价于
500 def f(x):
501     return x*2
502 
503     
504 #######################################取出文件夹中最新的文件
505 #coding=utf-8
506 import os
507 
508 #定义文件目录
509 lists=os.listdir(‘D:\\123‘)
510 
511 #按时间排序
512 lists.sort(key=lambda fn:os.path.getmtime(‘D:\\123\\‘+fn))
513 
514 print(‘最新文件为：‘+lists[-1])
515 lists.sort()
516 print(os.path.getmtime(‘D:\\123\\‘+lists[-1]))
517 print(lists)
518 
519 ##########################################################
520 from urllib import request
521 
522 with request.urlopen(‘https://api.douban.com/v2/book/2129650‘) as f:
523     data=f.read()
524     print(‘状态:‘,f.status,f.reason)
525     for k ,j in f.getheaders():
526         print(‘%s %s‘%(k,j))
527     print(‘数据:‘,data.decode(‘utf-8‘))
528 
529 req=request.Request(‘http://www.douban.com/‘)
530 req.add_header(‘User-Agent‘, ‘Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25‘)
531 with request.urlopen(req) as m:
532     print(‘状态1：‘,m.status,m.reason)
533     for k,j in m.getheaders():
534         print(‘%s :%s‘ %(k,j))
535     print(‘数据1：‘,data.decode(‘utf-8‘))
536 
537 
538 可以直接作用于for循环的数据类型有以下几种：
539     一类是集合数据类型，如list、tuple、dict、set、str等；
540     一类是generator，包括生成器和带yield的generator function。
541     这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
542     
543 生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
544     可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
545     可以使用isinstance()判断一个对象是否是Iterator对象：
546     
547     
548 map函数/refuce函数/filter函数
549 >>>list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
550 [‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘]
551 
552 reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
553 
554 def is_odd(n):
555     return n % 2 == 1
556 
557 list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
558 # 结果: [1, 5, 9, 15]
559 
560 >>> sorted([36, 5, -12, 9, -21], key=abs)
561 [5, 9, -12, -21, 36]
562 
563 
564 列表生成式：
565 >>> [x * x for x in range(1, 11)]
566 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
567 
568 等价于：
569 >>> L = []
570 >>> for x in range(1, 11):
571 ...    L.append(x * x)
572 ...
573 >>> L
574 
575 
576 
577 闭包：相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”
578     返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
579     
580     
581 匿名函数
582 lambda x: x * x
583 等价于
584 def f(x):
585     return x * x
586     
587     
588     
589 装饰器：
590     这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
591 
592 
593 Python作用域：
594     1、正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等
595     2、类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；
596     3、类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；
597     之所以我们说，private函数和变量“不应该”被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。
598     
599     
600 获取对象信息：
601 1、使用type()判断对象类型
602 2、使用isinstance(‘aaa‘,str)判断对象类型
603 3、使用dir()获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list
604 >>> type(123)
605 <class ‘int‘>
606 >>> type(‘str‘)
607 <class ‘str‘>
608 >>> type(None)
609 <type(None) ‘NoneType‘>
610 >>> isinstance([1, 2, 3], (list, tuple))
611 True    
612 >>> hasattr(obj, ‘x‘) # 有属性‘x‘吗？
613 True
614 >>> obj.x
615 9
616 >>> hasattr(obj, ‘y‘) # 有属性‘y‘吗？
617 False
618 >>> setattr(obj, ‘y‘, 19) # 设置一个属性‘y‘
619 >>> hasattr(obj, ‘y‘) # 有属性‘y‘吗？
620 True
621 >>> getattr(obj, ‘y‘) # 获取属性‘y‘
622 19
623 >>> obj.y # 获取属性‘y‘
624 19    
625     
626     
627     
628 给一个实例绑绑定方法，但是对另外的实例无效
629 >>> def set_age(self, age): # 定义一个函数作为实例方法
630 ...     self.age = age
631 ...
632 >>> from types import MethodType
633 >>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
634 >>> s.set_age(25) # 调用实例方法
635 >>> s.age # 测试结果
636 25
637