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

变量和简单数据

1.输出方式

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

 

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

 

 

2.变量的输出方式

 

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

 

                           print('''line1

                           . . . line2

                           . . . line3''')

                         print(r"stringline")

 

 

3.变量的命名和使用

 

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

 

 

4.字符串

 

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

 

 

5.数字：

 

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

 

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

 

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

 

8.空值(None):None ≠ 0

 

列表和元组

 

1.list

 

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

 

 

2.tuple：tuple的元素不可变

 

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

 

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

 

 

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

 

1. s.add(key)
2. s.remove(key)

 

 

5.条件判断

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

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

 

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

 

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

 

7.切片：

 

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

 

 

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

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

 

9.迭代器：

 

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

 

 

函数

 

1.定义函数：

 

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

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

 

3.传递参数：

 

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

 

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

 

5.高阶函数

 

1. map/reduce：(1)list(map(str,[1,2,3,4,5,6,7,8,9])) ；(2) reduce(f,[x1,x2,x3,x4])
2. filter：用于过滤序列 list(filter(is_odd,[1,2,4,5,6,9,10,15]))
3. 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 动态语言

 

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

 

4.获取对象信息：

 

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

          >>> import types
          >>> def fn():
          . . .  pass
          . . .  
          >>> type(fn) == types.FunctionType

1. isinstance()
2. dir()：获取一个对象的所有属性和方法，返回一个保护字符串的list
3. hasattr(obj,'x') ：有属性 'x' 吗
4. setattr(obj,'y',19) ：设置属性 'y' 为19
5. getattr(obj,'y')：获取属性 'y' 的值

 

5.面向对象高级编程

使用__slots__：

 

1. 创建一个实例后，对该实例绑定任何属性对另一个实例没有任何影响
2. __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.导入类

 

1. 从一个模块导入一个或多个类：from module_name import name1,name2, ...
2. 导入模块：import module_name
3. 导入模块中所有类：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()运行测试