python小笔记

python特点
    python使用缩进
    多个语句在一行使用;分隔
    注释为#,多行注释doc string()
cmd的pip安装
    pip install selenium #安装
    pip list #查看安装了哪些包
    pip uninstall selenium #卸载
    py -3 -m pip install selenium #python安装在python3.0上
    
打印
    print("hello"," ","world");
    name=input("输入你的名字");
    print(name);
    
数据类型
    整数 int
    浮点数 float
    布尔值 bool
    空值 None
    type{a} #查看a的变量类型
    
变量赋值(不区分单双引号)
    a=100            #int
    b="test"        #字符串
    x=y=z=1            #多重赋值
    x,y,z=1,2,"str" #多元赋值
    int(a);str(a);    #类型转换
    
运算符
    3 * 5                
    3 ** 2            #乘方
    5 / 2
    5%2
    "hello"+"world"
    10 // 3    ;        #整除，返回值为帧整数部分；

注释：
    单行注释#
    多行注释
        """
        注释内容
        """
转义
    \
    \n 换行
    \也可以续行，表示没有输完
    
字符串
    print("%d(x)是一个数字,%s(y)是一个字符串"%(x,y));
    %d(data)打印数字
    %s(string)打印字符串
    如果无法确定种类种类则用%r
    l=[1,2,3]
    print("这个列表的内容是%r" % l )
    
字符串操作
    #比如a="abc";b="cde"
    +    字符串连接
    *    字符串重复输出 a*2 ,输出aa
    []    索引,a[0]="a",a[-1]="c"
    [ : ]
    in
    not in 
    r/R
    %   格式字符串
    
字符串常见函数方法
    L=['a','b','c'];
        "".join(L)         #拼接成abc
        "_".join(L)     #拼接成a_b_c
    L="a,b,c"
        L.split(",")    #换成list类型，以,分割
    str.endswith(obj,beg=0,end=len(string));
    
    A="abcdefdasd1";
        A.find('1');
        "_".join(A);     #输出'a_b_c_d_e_f_d_a_s_d_1'
        len(A)            #11
        A.replace("a","A");#'AbcdefdAsd1'
        A.split("a");         #['', 'bcdefd', 'sd1']
        A.strip('a');        #左右各处理掉a字符，'bcdefdasd1'
        A.startswith('a',0,len(A));     #true
        
列表list
    赋值、索引
        A[1][1]取索引为1的元素中的索引为1的元素
    基本操作
    切片，从左边开始取值
        比如A=[1,2,3,4,5]
        A[1:3] 表示取值为A[1],A[2]
        A[x:y] 表示取值A[x]到A[y-1]这个范围内
        A[0:-2]从最左边取值到最右倒数第二个但不包含这个数，这里就是[1, 2, 3, 4]

list函数
    len(list)
    max(list)/min(list)
    list(seq) 元祖转换为列表
    
list方法
    list.append(obj);        列表末尾添加新的对象
    list.count(obj);        对指定元素计数
    list.extend(seq);        插入序列类的东西到末尾，比如字符串，list
    list.index(obj);        找到某个元素的位置
    list.insert(index,obj);    在指定位置插入
    list.pop(index);        删除某元素
    list.remove(obj);        删除某元素
    list.reverse();            反序
    list.sort();            排序
    list.clear();            清空
    list.copy();            建立副本
    list.strip()         方法用于移除字符串头尾指定的字符（默认为空格）


元祖tuple
    特色：
    1、和list相似，最大的不同元祖是一种只读且不可读的数据结构
    2、不可替代元祖中的所有元素，至刻度不可更变
    3、list与tuple可以相互转换，tuple(list)、list(tuple)
    
    赋值：
    h=(2,[3,4],(23112,2));    #多维列表
    h=(1,)                    #一个元素时必须要打逗号，因为h=(1)与h=1一致。
    
字典：Dict
    a={'x':3,    'y':4,    'z':5    }
    #x就是key不能为数字；3表示value值；和json格式相似
    a['xx']=333; #表示又插入一个键为'xx',值为'333'的元素；
                #结果是a字典就是{'x': 3, 'y': 4, 'z': 5, 'xxx': 2333}
                
                
    字典的函数方法：
        dict.clear()
        dict.copy();
        dict.get(key,None);        #返回指定键的值，若没有返回"None"
        key in dict
        dict.items()            #以列表返回可遍历的(键，值)元祖数组
        dict.keys()                #以列表返回一个字典所有的键
        dict.setdefault(key,None)#和get()相似，但如果键不存在字典中，会添加一个key键，值为None
        dict.update(dict2)        #把字典dict2的键/值对更新到dict里
        dict.values()            #返回字典中所有的值；
        dict.pop(key,None)        #删除键Key对应的值，返回被删除的值，key值不存在返回None。如果Key不存在，又没有默认值，则报错。
        
条件语句
if y>0:
    print("y>0")
elif y==0:
    print("y==0")
else:
    print("y<0")
################
布尔表现式---逻辑操作符and、or、not、in、not in
a=2;b=4;c=6
if b>=a and b<=c:
    print("b is between a and c")
    
if not (b<a or b>c):
    print("b is still between a and c")
######################
while语句
i=5
while i>0:
    print("ss")
    i=i-1
    
######################
For语句
for i in [3,4,10,25]:
    print(i)

for i in "helloworld":
    print(i)
    
for i in range(10):    #i从0取到9 
    print(i)
    
A=[]
for j in [3,4,5,6]:
    A.append(j**2)


range(1,10)            #从1取到10
range(1,10,2)        #从1取到10，每隔2取一次值


#######################
控制流终止
    continue
    break
    
    
    
    
    
    
###############################
函数
    def语句
    def 函数名(参数1,参数2,参数3)
        语句块

def divide(a,b):
    q=a/b
    r=a-q*b
    return q,r

#调用
x,y=divide(42,5)    #x=8,y=2
x=divide(42,5)        #x=(8,2)是tuple元祖

def add(a,b=2):        #a为位置参数，b为默认参数、默认取值为2。默认参数在位置参数之后
    s=a+b
    return s

def fenshu(name,socre=90):
    print('%s的分数为%d'%(name,score)) 

    
#调用分数
fenshu('张三',)
t=('李四',80)
fenshu(*t)    
    
###############
#1、可变参数
def func(*a):        #如果输入为1,23,4,4,5；那么a=(1,23,4,4,5)元祖
    sum=0
    for n in a:
        sum=sum+n
    return sum
    
def fenshu(name,socre=90):
    print('%s的分数为%d'%(name,score)) 

    
#2、可变参数
fenshu('张三')
t=('李四',80)
fenshu(*t)    
    
    
#################################################    
关键字参数
def func(**kw)
可变参数允许传入0或者任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许我传入0~任意个含参数名的参数，这写关键字参数在内自动组装为一个dict。与可变参数相同，需要使用dict的操作方法来操作dict

在调用函数时，我们可以将参数组装成dict，通过func(**dict)的方式传参
def func(name,age=20):
    print("%s age is %d"%(name,age))

p={'name':'bob','age':27}
func(**p)

参数组合
    顺序为位置参数、默认参数、可变参数和关键字参数，形式：
def func(para,para2=None,*agrs,**kw)
#################################################    
类、对象
class Person():
    def __init__(self,name,age):  #初始化，绑定实例属性,特殊的方法，类似于java的构造函数,第一个参数必须是self
        self.name=name
        self.age=age
1、继承
class Count():
    def __init__(self,a,b):        #初始化类的属性
        self.a=a
        self.b=b
    def add(self):                #类中的方法，第一个参数必须是self
        return self.a+self.b

count = Count(3,5);    #实例化对象,是否传参取决于__init__
count.add();        #调用对象的方法

class Father():        #表示无继承父类，或者说这是继承基类
    def add(self,a,b):
        return a+b

        
class Son(Father):
    def div(self,a,b):
        return a-b
>>> son=Son();        #实例化对象
>>> son.add(3,5)
>>> son.div(3,5)

##########################################################
异常
try:
    open("abc.txt",'r')
except IOError:
    print "异常了!"

try:
    print aa
except NameError:
    print "这是一个 name 异常!"    


try:
    open("abc.txt",'r')
    print aa
except BaseException:
    print "异常了!"    
所有的异常类有了新的基类 BaseException，Exception 同样也继承BaseException，所以我们也可以使用 BaseException 来接收所有的异常。

try:
    print(s)
except NameError:
    print("异常")
finally:
    print("没有异常") #finally如何都都会被执行
    
try:
    print(s)
except NameError:
    print("异常")
else:
    print("没有异常") #try正确才会执行
###读取文件#######################################################
#coding=utf-8
import  time

files =open('C:/Users/Lee/Desktop/test01.txt','r')
try:
   # print(str)
    for l in files:
        print(l)
     #   time.sleep(1)
finally:
    #files.close()
    print ('Cleaning up ...closed the file')
#######################################



######################################

引入包
import time
print(time.ctime())

引入自己写的模块


##########################导入写的模块的路径
import sys
sys.path.append('C:\\test\\WorkSpace_Python\\Learn0904')
print(sys.path)
print(sys)


###################################
open/文件操作
f=open('/tmp/hello','w')

#open(路径+文件名,读写模式)

#读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式        
读写模式的类型有：

rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w     以写方式打开，
a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+     以读写模式打开
w+     以读写模式打开 (参见 w )
a+     以读写模式打开 (参见 a )
rb     以二进制读模式打开
wb     以二进制写模式打开 (参见 w )
ab     以二进制追加模式打开 (参见 a )
rb+    以二进制读写模式打开 (参见 r+ )
wb+    以二进制读写模式打开 (参见 w+ )
ab+    以二进制读写模式打开 (参见 a+ )        


#举例：读取文件
f=open('C:/Users/Lee/Desktop/123.csv','r+')
str=f.readlines()

for i in str:
    print(i)
f.close()

#举例：读取csv文件
import csv
file1=open('C:/Users/Lee/Desktop/actual.csv','r+')
csv_reader=csv.reader(file1)
print(type(csv_reader))
for row in csv_reader:
    print(type(row))
    print(row[1])
file1.close()

#写入文件
f=open('C:/Users/Lee/Desktop/111.csv','a+')
num=[1,2,3,4,5]
char=['a','b','c','d','e']

l=[]
for i in range(len(num)):
    m=str(num[i])+','+char[i]
    l.append(m)
f.write(str(l)+'\n')
f.close()

#写入csv文件，这里的row_all是获取到的数据库的内容，为元祖
l=list(row_all)
f=open('D:/123.csv','a+',newline='')
writer=csv.writer(f)
num=len(l)
for i in range(num):
    writer.writerow(l[i])
f.close()


#####################################python发送邮件
#coding=utf-8
import smtplib
from email.mime.text import MIMEText
from email.header import Header

#发送邮箱
sender='lihujun101@163.com'
#接受邮箱
receiver=['316947664@qq.com']

#发送主题
subject='测试'
#发送邮箱的服务器地址
smtpserver='smtp.163.com'
#发送邮箱用户/密码
user='lihujun101@163.com'
pwd='li1992hujun'

#邮件正文
msg=MIMEText('<html><h1>你好!!!'
             '</h1><a href="http://baidu.com">这是一个链接</a></html>','html','utf-8')
msg['From']='李胡军'#可以写出来表示发件人名字
msg['To']='316947664@qq.com'
msg['Subject']=Header(subject,'utf-8')

smtpObj=smtplib.SMTP(smtpserver,25)

smtpObj.login(user,pwd)
smtpObj.sendmail(sender,receiver,msg.as_string())

########################################################################
###带附件发送邮件
#coding=utf-8
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.header import Header

#发送邮箱
sender='lihujun101@163.com'
#接受邮箱
receiver=['316947664@qq.com']

#发送主题
subject='测试'
#发送邮箱的服务器地址
smtpserver='smtp.163.com'
#发送邮箱用户/密码
user='lihujun101@163.com'
pwd='li1992hujun'

#邮件正文
msg=MIMEMultipart()
msg.attach(MIMEText('<html><h1>你好!!!'
             '</h1><a href="http://baidu.com">这是一个链接</a></html>','html','utf-8'))

msg['From']='李胡军'#可以写出来表示发件人名字
msg['Subject']=Header(subject,'utf-8')


#附件
fj='C:\\Windows\\addins\\FXSEXT.ecf'
att=MIMEText(open(fj,'rb').read(),'base64','utf-8')
att["Content-Type"]= 'application/octet-stream'
att['Content-Disposition']='attachment; filename="test"'
msg.attach(att)

#发送
smtpObj=smtplib.SMTP(smtpserver,25)
smtpObj.login(user,pwd)
smtpObj.sendmail(sender,receiver,msg.as_string())

###################################################################################





#####lambda函数
f=lambda x:x*2
'''
用 lambda 来声明匿名函数，冒号（：）前面 x 表示入参，冒号后面 x*2 表示返回值。lambda 和普通的函数相比，省去了函数名称，“匿名函数”也是由此而来。
'''
等价于
def f(x):
    return x*2

    
#######################################取出文件夹中最新的文件
#coding=utf-8
import os

#定义文件目录
lists=os.listdir('D:\\123')

#按时间排序
lists.sort(key=lambda fn:os.path.getmtime('D:\\123\\'+fn))

print('最新文件为：'+lists[-1])
lists.sort()
print(os.path.getmtime('D:\\123\\'+lists[-1]))
print(lists)

##########################################################
from urllib import request

with request.urlopen('https://api.douban.com/v2/book/2129650') as f:
    data=f.read()
    print('状态:',f.status,f.reason)
    for k ,j in f.getheaders():
        print('%s %s'%(k,j))
    print('数据:',data.decode('utf-8'))

req=request.Request('http://www.douban.com/')
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')
with request.urlopen(req) as m:
    print('状态1：',m.status,m.reason)
    for k,j in m.getheaders():
        print('%s :%s' %(k,j))
    print('数据1：',data.decode('utf-8'))


可以直接作用于for循环的数据类型有以下几种：
    一类是集合数据类型，如list、tuple、dict、set、str等；
    一类是generator，包括生成器和带yield的generator function。
    这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
    
生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
    可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
    可以使用isinstance()判断一个对象是否是Iterator对象：
    
    
map函数/refuce函数/filter函数
>>>list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]


列表生成式：
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

等价于：
>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L



闭包：相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”
    返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
    
    
匿名函数
lambda x: x * x
等价于
def f(x):
    return x * x
    
    
    
装饰器：
    这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。


Python作用域：
    1、正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等
    2、类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；
    3、类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；
    之所以我们说，private函数和变量“不应该”被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。
    
    
获取对象信息：
1、使用type()判断对象类型
2、使用isinstance('aaa',str)判断对象类型
3、使用dir()获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list
>>> type(123)
<class 'int'>
>>> type('str')
<class 'str'>
>>> type(None)
<type(None) 'NoneType'>
>>> isinstance([1, 2, 3], (list, tuple))
True    
>>> hasattr(obj, 'x') # 有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19    
    
    
    
给一个实例绑绑定方法，但是对另外的实例无效
>>> def set_age(self, age): # 定义一个函数作为实例方法
...     self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25