Python 笔记

 

一、Python基础

1.输入和输出：print( )   input( )  e.g. input(‘please enter your name:’） #input的数据为字符串，可用a=int(b)来改变数据类型

2.#作注释 四个空格缩进 大小

3.print(‘’’line1

…line2

…line3’’’)  #其中符号…为交互模式自动出现，若引号前加r表示字符串中符号\不转意

4.布尔逻辑算符True、False可用and、or、not运算

5.空值：用None表示

6.变量：输入a=123，内存创建a与123，a指向123

7.输入10/3得到3.333333333335（为浮点数），板除：10//3=3所得为整数（截取整数部分）

8.字符编码：ASCII码一个字节，为英文字母；Unicode通常两个字节；UTF-8将Unicode简化，英文时为一个字节。python以Unicode编码，用ord( )可获得字符编码，chr( )可获得编码对应字符。

9. len( )函数计算字符串长度

10.格式化： '%2d-%03d' % (3, 1)  #其中2表示空一格，03表示加两个0

        '%.2f' % 3.1415926  #其中.2表示保留两位小数

        #字符串中若有%则以%%表示

11.list：classmates = ['Michael', 'Bob', 'Tracy']

       计数：从0开始，classmates[-1]表示倒数第一个

       classmates.append( )追加元素到末尾

       classmates.insert(1,’Mike’)插入元素  #1表示插入位置（插入为第二个元素）

       classmates.pop(i)按索引删除元素  # i表示位置，无i时删除最后一个

       classmates.remove(‘Bob’)按内容删除元素

#可对classmates[1]直接赋值

       #list中可有不同类型数据（包括list，可组成二元数组）

12.tuple：与list基本相同但不能修改（tuple指向元素，则若元素有list，list仍可以改变）

        #tuple只有一个元素时，若输入t=(1)，则t=1；应输入t=(1,)

13.条件判断：if…:  elif…:  elif…else…

            #if x:  print('True')  表示x非空非零时输出True（注意第二行空四格）

14.循环：①for...in...   e.g. for name in names:

                           print(name)     #names可为list或tuple

         #range(101)可生成从0到100的数列

         ②while...

15.dict：e.g. d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

           d['Michael']         95

        in语句判断key是否在dict中（返回bool）： 'Thomas' in d

        get语句判断key是否在dict中：d.get('Thomas')    #返回None时不出现结果

        pop删除key：d.pop('Bob')

        # dict无序

16.set： e.g.s=set([1,1,2,2,3,3])

        s             {1,2,3}    #创建时需提供一个list，集合过滤重复元素，无序

        add(key)  remove(key) 可添加元素到set：s.add(4)

        两个set之间可进行交并集操作：s1&s2   s1|s2

二、函数

1.help()可查看函数作用：help(abs)

2.数据转换：int( )  str( )  float( )  bool( )

3.函数命名：b=abs     b(-10)    10

4.定义函数：def my_abs(x)：          #def后跟函数名、参数、冒号

若保存定义的函数为py文件，则在该目录下启动python，用 from 文件名 import 函 数名 可导入函数

5.空函数：

    def nop( ):

      pass   #pass可作占位符，在内容未想好时使用，函数在执行完无return时返回None

6.函数可返回多个值：return x,y    #返回多个值时实际上返回tuple

7.默认参数：def power(x,n=2) 则在调用power(5)时默认n=2

  默认参数必须指向不变对象：def add_end(L=None)  #否则调用add_end( ) 时创立L指向[ ]

8.可变参数：def calc(*numbers)    #调用时输入calc(1,2,3,4)

           对nus=[1,2,3]可使用 calc(*nus)代入nus中每个元素

9.关键字参数：def person(name, age, **kw)     #可输入任意个参数组装成dict

e.g.person('Bob', 35, city='Beijing')    person('Jack', 24, **extra)       #extra为dict

10.命名关键字参数：传入参数时必须传入参数名，可设置缺省值

def person(name, age, *, city, job)   # *后或可变参数后的参数被视为命名关键字参数

11.参数定义顺序：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

  e.g.def f1(a, b, c=0, *args, **kw)

     f1(*args, **kw)

     a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}  #调用tuple和dict时需注意

12.递归函数：若一个函数在内部调用自身，称为递归函数

   e.g. def fact(n):

         if n==1:

             return 1

         return n * fact(n - 1)     # n较大时可能栈溢出

   尾递归：def fact(n):

               return fact_iter(n, 1)

           def fact_iter(num, product):

               if num == 1:

                   return product

               return fact_iter(num - 1, num * product)

 

三、高级特性

1.切片 L[1:3]     #L中索引从1开始取两个（从0开始取时0可以省略）

      L[-2:]     #取后两个

      L[:10:2]   #前10个数，每两个取一个

  Tuple的切片仍为tuple，对字符串也能进行切片操作

2.迭代：使用for…in遍历list、字符串等，对dict默认情况下迭代key  e.g. for key in d

  for value in d.values( )  for k, v in d.items( )   #调用value、调用value和key

  使用Iterable判断是否可迭代from collections import Iterable

                            >>> isinstance('abc', Iterable)         True

  enumerate函数可将list变为索引-元素对：for i, value in enumerate(['A', 'B', 'C']):

print(i,value)       #得0A1B2C

3.列表生成式：简单创建list     e.g. [x * x for x in range(1, 11) if x % 2 == 0]

  [k + '=' + v for k, v in d.items()]      [m + n for m in 'ABC' for n in 'XYZ']（还可加if判断）

  import os  # 导入os模块

  >>> [d for d in os.listdir('.')]  #可列出当前目录下所有文件

4.生成器generator：不创立完整列表而在循环过程中通过算法推算下一个元素

   ①将列表生成式的[ ]以( )代替即可  e.g.　g = (x * x for x in range(10))

     函数next(g)可取得generator下一个值，generator也可迭代

     a, b = b, a + b ↔ t = (b, a + b)，a=t[0]，b=t[1]    #先计算a+b

   ②一个函数中包含yield时成为generator

     e.g. def fib(max):

            n, a, b = 0, 0, 1

            while n < max:

                yield b          #在遇到yield时返回

                a, b = b, a + b

                n = n + 1

            return 'done'     #返回值需用StopIteration.value捕获，否则打印不出

5.迭代器Iterator：可以被next( )函数调用并不断返回下一个值的对象

   isinstance函数可用于判断对象是否为迭代器：isinstance(iter([ ]), Iterator)

 

四、函数式编程

1.高阶函数：一个函数接收另一个函数作为变量

  def add(x, y, f):

      return f(x) + f(y)   #函数名也是变量，指向函数内容

2.map函数传入函数f和list，产生Iterator（惰性序列）：list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

3.reduce函数将接收两个参数的函数对list作用：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

  需要from functools import reduce才能使用reduce

4.lambda匿名函数：g = lambda x:x*x     #可接收任意多个参数并只返回单个表达式的值

             等价于：def f(x):return x*x

5.filter函数：接收一个函数和一个序列，根据结果是否为True确定是否保留元素，得Iterator

  e.g.def is_odd(n):

 return n % 2 == 1           #return值为True或False

 list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))     #需用list强制返回所有值

6.sorted函数：对list进行排序，可接收key函数（根据函数返回结果排序，返回原值）

  e.g.sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)

     ['Zoo', 'Credit', 'bob', 'about']            #reverse可进行反向排序

7.返回函数：def lazy_sum(*args):

               def sum( ):

                   ax = 0

                   for n in args:

                       ax = ax + n

                   return ax     #返回的函数将用到变量args

               return sum     #每次调用lazy_sum时都返回一个新的sum函数

   注意：返回的函数不能包含循环变量（如for i in…中的i）

8.函数对象属性__name__可用于获取函数名：e.g.  f.__name__       ‘now’

9.装饰器decorator用于在代码运行期间动态增加功能

 e.g. import functools   

     def log(func):                                        #无需输入参数的decorator             

         @functools.wraps(func)                   #用于将返回的函数的名字改回原名

         def wrapper(*args, **kw):                              

             print('call %s():' % func.__name__)            

             return func(*args, **kw)                         

         return wrapper                         #可用于在调用函数时自动生成日志

 

     import functools

     def log(text):                                                 #带参数的decorator

         def decorator(func):

             @functools.wraps(func)

             def wrapper(*args, **kw):

                 print('%s %s():' % (text, func.__name__))

                 return func(*args, **kw)

             return wrapper

         return decorator 

   调用：@log('execute')                                                                            >>> now()

         def now():                                                                                   execute now():

             print('2015-3-25')         #相当于调用now = log('execute')(now)        2015-3-25

   （理解：log先接收’execute’作为text，再在调用decorator时接收now作为func，在调用wrapper时接收now的参数作为(*args,**kw)，实际操作为先执行print，再执行now()）

10.偏函数：可给一个函数的某些参数设置默认值，返回一个新函数

  e.g. int2 = functools.partial(int, base=2)  #固定了函数int( )的关键字参数base

 

五、面向对象编程

1.class Student(object):      #类名通常大写开头，(object)表示继承来源,object为默认来源

     def __init__(self, name, score):   #约定第一个参数为self，__init__函数可声明类属性

         self.name=name              #self相当于java中的this

         self.score=score          #想要属性不被外部修改的话可以前加__，如__score

     def print_self(self):

         print(self.name,’:’,self.name)

 michael=Student(‘Michael’,90)

 michael.print_self( )             #类的方法调用

2.访问限制：实例的变量名如果以__开头，就变成了一个私有变量，内部可以访问但外部不能访问，若要获取、修改私有变量需通过类中方法。

3.继承：子类可以对父类的方法进行重写，并且子类的实例在调用该方法是总是调用子类中的这个方法。一个类可以继承多个父类，并获得父类的全部方法.

class Animal(object):

         def run(self):

             print(‘Animal is running’)

      class Dog(Animal):

         def run(self):

             print(‘Dog is running’)

      dog1=Dog()

      dog1.run()

>>>Dog is running

4.多态：print(isinstance(s,Dog))

isinstance判断一个变量是否为某类型（c为Dog的同时为Animal）

5.实例属性与类属性：

  class Student(object):

      name=’hhh’

  s=Student()

  s.name=’hyh’     #实例属性优先级高于类属性

  s.score=90       #对实例可以任意绑定属性

  print(s.name,’:’,s.score)

 

六、模块

1.一个.py文件就称之为一个模块，为避免模块名冲突，python通过包组织模块，如abc.py记为ruc.abc，每个包下有__init__.py文件，可空可有代码，否则python将其视为普通目录

2.模块调用：已定义hello.py，在xyz.py中：

import hello           hello.say_hello(‘hyh’)      #当前目录下调用

  import irm.hello        irm.hello.say_hello(‘hyh’)  或：

from irm import hello    hello.say_hello(‘hyh’)     #引入下级文件夹中模块

import sys     sys.path.append(‘../’)

import hello   hello.say_hello(‘hyh’)             #引入上级文件夹中模块

import hello as h               #重命名模块

3.from datetime import datetime    #导入datetime模块中datetime类

print(datetime.now( ))            #打印当前日期时间

print(datetime(2017,10,1,12,12,12))   #打印指定日期时间

  我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time，记为0，其之前时间为负数，当前时间就是相对于epoch time的秒数，称为timestamp

  print(datetime.now().timestamp( ))     1506706988.385073     #datetime转为timestamp

  print(datetime.strptime(‘2017-10-1 18:19:59’,’%Y-%m-%d %H:%M:%S’))   

  2017-10-1 18:19:59                        #str转换为时间

4.hashlib: import hashlib

        md5=hashlib.md5()                   #每次update增加 ’ ’ 中内容

        md5.update(‘how to use hashlib - by Michael’.encode(‘utf-8’))

        print(md5.hexdigest( ))                #产生密文

  在存储用户密码时通常存储加密过后的密文，需通过加盐进一步加密

5.urllib: 用于获取网页数据

  from urllib import request

  response=request.urlopen(‘http://www.baidu.com’)

  html=reponse.read()

  print(html.decode(‘utf-8’))

6.beautiful soup(使用需在电脑先安装beautifulsoup)

  from urllib import request

  from bs4 import BeautifulSoup

  response=request.openurl(“http://www.baidu.com”)

  html=response.read( )

  soup=BeautifulSoup(html,’lxml’)

  print(soup.img.name)        #获取标签名（默认对第一个标签作用）

  print(soup.img.attrs)         #获取标签属性（产生dict）

print(soup.img.get(‘src’))     #使用get函数获取标签中某个属性值

  print(soup.title.string)       #获取标签内部文字

  print(soup.select(‘p’))       #对页面中所有p标签查找，返回list，可用get进一步处理

  print(soup.select(‘.itemdesc-2’))   #通过类名查找（类名前加点）

  print(soup.select(‘#searchbox’))   #通过id查找（id前加#）

  print(soup.select(‘#searchbox > a’))  #查找searchbox下的a标签

  print(soup.select(‘#searchbox’)[0].select(‘a’))  #连续select

  print(soup.select(‘#searchbox > form[method=get]’))#查找searchbox下method为get的form

  print(soup.select(‘title’)[0].get_text( ))     #通过get_text()获取select中对象内容

 

七、Python对数据库操作

1.对sqlite操作：

 import sqlite3

 connection=sqlite3.connect(‘test.db’)  #连接到sqlite数据库，若不存在则自动创建

 cursor=connection.cursor( )    #创建一个游标对象

 cursor.execute(sql)    #执行sql语句，sql为字符串格式sql语句

 cursor.execute(‘select * from user where id=?’,(‘1’,))#?位占位符可有多个，之后传入一个tuple

 values=cursor.fetchall()   #fetchall拿到结果集list，其中每一条记录为一个tuple

 cursor.rowcount      #返回最近一次execute影响行数

 cursor.close( )        #关闭游标对象

 connection.commit( )  #只有在提交事务后才更新数据库

 connection.close( )    #关闭数据库连接

2.对mysql操作

import os

import pymysql

connection=pymysql.connect(host=’localhost’,port=3306,user=’root’,passwd=’123456’,db=’testdb’,charset=’utf8’)     #创建数据库连接，需要传入主机、端口、用户名、密码等数据

cursor.execute(‘select * from user where id=%d’ % (1,) )  #使用%作为占位符

3.利用ORM（对象实体关系映射）操作数据库

  import os

  from sqlalchemy import Column,String,Integer,create_engine

  from sqlalchemy.orm import sessionmaker

  from sqlalchemy.ext.declarative import declarative_base

  Base=declarative_base( )   #创建对象的基类，用以将需要映射的类继承

  class User(Base):

      __tablename__=’t_user’        #表名

      id=Column(Integer,primary_key=True)

      name=Column(String(255))      #表的结构

  engine=create_engine(‘mysql+pymysql://root:123456@localhost:3306/testdb’) 

#创建数据库连接：数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名

  Base.metadata.create_all(engine)  #创建t_user表

  DBSession=sessionmaker(bind=engine)  #创建DBSession类型

  session=DBSession( )      #创建Session对象

  user=User(id=1,name=’hyh’)   #创建一个User对象，并输入数据（id不定义也会自动传入）

  session.add(user)   #通过与数据库的会话插入记录

  users1=session.query(User).all( )

users2=session.query(User).filter(User.id==1).one( )   #查询数据

user2.name=’hyhhhh’      #更新数据

session.delete(user)       #删除数据

  session.commit( )   #提交事务

  session.close( )     #关闭连接

 

八、Python中web编程

1.WSGI接口

 from wsgiref.simple_server import make_server

 def application(environ,start_response):

     start_response(‘200 OK’,[(‘Content-Type’,’text/html’)])

     return [b’<h1>Hello,web!</h1>’]

 httpd=make_server(‘‘,8000,application)   #创建服务器，端口8000，处理函数application

 print(‘Serving HTTP on port 8000...’)    

 httpd.server_forever()    #开始监听http请求

2.flask

 from flask import Flask

 app=Flask(__name__)

@app.route(‘/’)    #装饰器使相应的URL将触发相应函数

def hello_world():

return ‘Hello World!’

app.run( )         #运行后启动服务器应用

 

九、变量保存读取

Import pickle

data1=[1,2]

data2={‘a’:1}

save_file=open("save.data","wb")

pickle.dump(data,save_file)

pickle.dump(data2,save_file)

save_file.close()

 

load_file=open("save.data","rb")

data3=pickle.load(load_file)

data4=pickle.load(load_file)

print(data3,data4)