【学习总结】Python基础知识笔记

变量和简单数据

1.输出方式

 Python 2 和 Python 3 的输出方式不一样

（1）Python 2 ： print "hello,world!"    
 （2）Python 3：print ("hello,world!")

2.变量的输出方式

（1）print(message,"hello")
（2）print(message+"hello")
（3）print("%s hello"%s)
（4）换行输出：print("\n")

                           print('''line1

                           . . . line2

                           . . . line3''')

                         print(r"stringline")

3.变量的命名和使用

只能有字母，数字和下划线，不能以数字打头
中间不能有空格
不能用Python保留用于特殊用途的单词
慎用小写字母和大写O
一般全大写用作全局变量，___xxx为非公开的，不应该被直接引用，__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途

4.字符串

单引号中，某些符合需要用转义，双引号中则不存在这个问题
字符串的方法：title() ： 首字母大写       upper() :全部转换为大写字母    lower() ： 全部转换为小写字母       rstrip() ： 删除字符串右边的空白      lstrip() ：删除字符串左边的空白      strip() ：删除字符串两边的空白
编码：对于单个字符的编码，ord()函数获取字符的整数表示，chr()把编码转换为对于的字符；   Unicode则通过encode()  decode()

5.数字：

整数：加(+)减(-)乘(*)除(/)
浮点数：包含小数位数可能是不确定的
3/2 = 1.5    3//2=1

6.注释 ：在文字前面加#

7.布尔值：可以用 and 、or 和 not运算

8.空值(None):None ≠ 0

列表和元组

1.list

添加 ：.append()
删除： (1)del lists[0]  (2)lists.remove('value')   (3)lists.pop(index)弹出元素
修改： lists[0] = ...
插入：lists.insert(index,value)
组织列表：sort() 对列表元素永久排序   sorted()对列表元素进行临时排序

2.tuple：tuple的元素不可变

3.dict：键-值（key-value）排序是不确定的

根据key获取value:(1)d[key] ; (2)d.get(key) 如果没有则返回 None,设置为空返回默认值则d.get(key,-1) 
判断key是否存在，if key in d
删除key，d.pop(key)

4.set：不存储value，且key不能重复

s.add(key)
s.remove(key)

5.条件判断

         if . . . elif  . . . else . . .

        其中一个条件为真时，不会继续往下进行判断

6.循环：(注意不必要的缩进）

list: for l in lists:
4000

dict : (1)for key,value in d.items:                    (2)for key in d.keys()                (3)for value in d.values()

7.切片：

L[0:3]：表示从索引0开始取，直到索引3为止，但不包括索引3。即索引0,1,2
L[:9]：前九个数
L[-10:]：后十个数
L[:10:2]：前10个数，每两个取一个

8.生成器：g = (x*x for x in range(10))

                 一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator,每次在调用next()的时候执行，遇到yield语句返回，在执行时从上次返回的yield语句处继续执行。

9.迭代器：

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

函数

1.定义函数：

>>> def my_abs(x):
...     if x >= 0:
...         return x
...     else:
...         return -x
...
>>> my_abs(-9)
9
>>> _

2.函数返回值：位置对应

3.传递参数：

位置参数：必须传递
默认参数：该参数具有默认值
可变参数：定义——def person(*k) ；使用——person(1,2,3) or lists =[...] person(*list)
关键字参数：传递给函数的名称-值对 例：定义——def  person(**kw) ； 使用——person(city = 'Beijing') 
命名关键字参数:定义——def person(*,name,age) ；使用—— person(name='Alice',age = 12)
参数定义顺序：必选参数，默认参数，可变参数，命名关键字参数，关键字参数

4.递归函数：（注意跳出条件，防止无休止递归，逻辑清晰，但过深的调用会导致栈溢出）

5.高阶函数

map/reduce：(1)list(map(str,[1,2,3,4,5,6,7,8,9])) ；(2) reduce(f,[x1,x2,x3,x4])
filter：用于过滤序列 list(filter(is_odd,[1,2,4,5,6,9,10,15]))
sorted：sorted(lists,key = str.lower,reverse = True)

6.返回函数：函数作为返回值

7.匿名函数：关键字lamba 例：list(map(lambda x:x*x,[1,2,3,4,5,6,7,8,9]))

8.装饰器： 在代码运行期间动态增加功能的方式 

def log(func):

      def wrapper(*args,**kw):

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

            return func(*args,**kw)

      return wrapper

@ log

def now():

      print('hello')

传递参数：

def log(text):

    def decorator(func):

        def wrapper(*args, **kw):

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

            return func(*args, **kw)

        return wrapper

    return decorator

@log('execute')

def now():

      print('hello')

9.偏函数：通过设定参数的默认值，降低函数调用的难度  例：int2 = functools.partial(int,base = 2) 要导入functools

类

1.创建类：所有类最终都会继承object类

   class People(object):

         def __init__(self,name,score):

                self.name = name

                self.score = score

有了__init__方法，在创建实例的时候，就不能传入空的参数

2.访问限制：通过方法来修改属性的值，同时可把变量名改为__xxx （private）来限制通过外部访问，不同的解释器通过外部访问私有变量时，会变成不一样的名称

3.继承和多态：静态语言 vs 动态语言

可以给子类添加新的属性和方法
可以重写父类的方法
可以将实例作为属性

4.获取对象信息：

type()  例：判断一个对象是否是函数

          >>> import types

          >>> def fn():

          . . .  pass

          . . .  

          >>> type(fn) == types.FunctionType
isinstance()
dir()：获取一个对象的所有属性和方法，返回一个保护字符串的list
hasattr(obj,'x') ：有属性 'x' 吗
setattr(obj,'y',19) ：设置属性 'y' 为19
getattr(obj,'y')：获取属性 'y' 的值

5.面向对象高级编程

使用__slots__：

创建一个实例后，对该实例绑定任何属性对另一个实例没有任何影响
__slots__可以显示实例的属性：

            class Student(object):

                        __slots__ = ('name' , 'age')  # 用tuple定义允许绑定的属性名称

             则 Student 只有属性 name , age

使用@property：负责把一个方法变成属性调用

        class Student(object):

                @property

                def score(self):

                         return self.__socre

                @score.setter

                def score(self,value):

                          if not isinstance(value,int):

                               raise ValueError('score must be an integer!')

                          if value < 0 or value > 100:

                               raise ValueError('score must between 0 ~ 100)

                          self.__socre = value

6.枚举类：

from enum import Enum

Month = Enum('Month' , ('Jan' ,'Feb' , 'Mar' , 'Apr' , ...))

调用：

for name , member in Month.__members__.items():

      pass

更精确地控制枚举类型：

unique

from enum import Enum, unique

@unique

class Weekday(Enum):

         Sun = 0

         Mon = 1

         ...

7.元类：metaclass 控制类的创建行为

                通常，metaclass的类名总是以Metaclass结尾

                # metaclass是类的模板，所以必须从`type`类型派生 

               class ListMetaclass(type):

                       def __new__(cls, name, bases, attrs):

                                attrs['add'] = lambda self, value: self.append(value)

                                return type.__new__(cls, name, bases, attrs)

               有了ListMetaclass ,我们在定义类的时候还有指示使用ListMetaclass来定制类，传入关机中产生metaclass

               class MyList(list, metaclass=ListMetaclass):

                              pass

                那么MyList 的对象就有 add 方法，而普通的list没有add 方法

8.导入类

从一个模块导入一个或多个类：from module_name import name1,name2, ...
导入模块：import module_name
导入模块中所有类：from module_name import *

文件和异常

1.文件读写

读文件

route= ‘/file/test.txt’

f = open(route,'r') #用读的方式打开文件

f.read()

...

f.close()

引入with语句来字段帮我们调用close()方法：

with open(route,'r') as f:

      f.read() #一次性读取所有内容

逐行读取

with open(route,'r') as f:

       for line in f:

              print(line)

一个包含文件各行的内容列表：

lines = f.readlines()

for line in lines:

       print(line)

读取二进制文件

f = open(route,'rb')

字符编码：

f = open(route,'r',encoding = 'gbk')

写文件

写入空文件

with open(route,'w') as f:

       f.write('hello')

写入多行

with open(route,'w') as f:

       f.write('hello')

       f.write(' world')

附加到文件

with open(route,'a') as f:

       f.write('hello)

3.异常处理

try  . . . except . . .

ZeroDivisionError：文件内容为空

FileNotFoundError：未找到文件

4.StringIO 和 BytesIO

StringIO ：在内存中读写str

写

>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('world!')
6
>>> print(f.getvalue())
hello world!

读

>>> from io import StringIO
>>> f = StringIO('Hello!\nHi!\nGoodbye!')
>>> while True:
...     s = f.readline()
...     if s == '':
...         break
...     print(s.strip())
...
Hello!
Hi!
Goodbye!

BytesIO ：实现了在内存中读写bytes，我们创建一个BytesIO，然后写入一些bytes

写：

>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('中文'.encode('utf-8'))
6
>>> print(f.getvalue())
b'\xe4\xb8\xad\xe6\x96\x87

读：

>>> from io import BytesIO
>>> f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
>>> f.read()
b'\xe4\xb8\xad\xe6\x96\x87'

4.操作文件和目录

import os

os.name #操作系统类型

os.environ #环境变量

os.path.abspath('.') #查看当前目录的绝对路径

os.path.join('/Users','test') #在某个目录下创建一个新目录，先把新目录的完整路径表示出来 （把两个路径合成一个时，不要直接拼字符串，而要通过

os.path.join()

函数，这样可以正确处理不同操作系统的路径分隔符）

os.mkdir('/User/test') #然后创建一个目录

os.rmdir('/User/test') #删掉一个目录

os.path.split() #拆分路径 （同样的道理，要拆分路径时，也不要直接去拆字符串，而要通过

os.path.split()

函数，这样可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名）

os.rename('test.txt','test.py') #重命名

os.remove('test.py') #删除文件

5.序列化：从内存中编程可存储或传输的过程称之为序列化

pickle

pickle.dump(value,filename)

pickle.load(pickle_str)

JSON(把对象序列化为标准格式)

json.dumps(value,filename)

json.loads(json_str)

JSON进阶
对类进行序列化，会抛异常，因为类对应的对象不是一个可序列化的JSON对象，只需为类专门写一个转换函数，在把函数传进去即可。

def function_name(std):

        return {

                  'attr1': std.attr1

                  'attr2':std.attr2

                  . . .

         }

json.dumps(class_object, default = function_name)

测试

1.单元测试

（1）import unittest

（2）类继承自unittest.TestCase，以test开头为测试方法

（3）通过断言进行判断

assertEqual(a,b)
assertNotEqual(a,b)
assertTrue(x)
assertFalse(x)
assertIn(item,list)
assertNotIn(item,list)

（4）通过 unittest.main() 运行单元测试

SetUp 与 tearDown

两个方法分别在每调用一个测试方法的前后分别被执行，setup()方法中连接数据库，在teardown()方法中关闭数据库

2.文档测试

在注释中严格按照Python交互命令行的输入和输出来编写注释，doctest进行判断测试结果是否正确，异常时可以用...表示中间一大段烦人的输出。导入doctest模块，并调用doctest.testmod()运行测试