Python学习笔记（一）——基础知识

 

Life is short, you need python.

 

一、假设 lst 为一列表

1. lst.pop(i)：删除列表中第i+1个元素；

   lst.pop()：删除列表中最后一个元素。

   （其实删除第i+1个元素分为两步：删除元素，列表中位于所删元素之后的所有元素往前一位）

2. python只有list，并没有array，但引用ctypes库可以生成类似于array的对象。方法如下：

   import ctypes

   array = ctypes.py_object * size

   （其中size为建立array的长度）

3. lst.extend(list1): 将list1列表追加在lst后方。而lst.append(x)是将x作为一个元素追加在lst后方，即使x是一个列表，x也是作为一个元素追加在lst后方。因此二者是有区别的。

4. 时间复杂度：

   lst.append(x): O(n);   lst.extend(list):O(n);   lst.insert(x): O(n);  lst.pop(): O(n);

   len(lst): O(1);  

5. lst.index(x)：返回x的位置(subscript)

6. lst.reverse(): 将列表反转。

7. lst.insert(index, x): 在第（index + 1）个出插入元素x。

8. lst.remove(x): 移除 x 元素；del lst[ i ]: 删除第（i + 1）个元素。

二、假设string是一个字符串：

1. r’’或R’’，其中包含的\之后的字符不进行转义：

   >>> print(r'c:\n\td')
   c:\n\td

2. \’ 单引号； \n 换行； \’’ 双引号； \r 回车； \\ 反斜杠； \t 水平制表符；

3. string.rstrip(）：返回去掉句尾的空格。

4. string.rstrip(str): 返回去掉句尾的str字符，默认是空格。

5. string.strip(str): 返回去掉句首和句尾的str字符，默认是空格。

6. split()方法用于将字符串分割成多个字符串组成的列表。split()当不带参数时，默认以空格进行分割，当带参数时，以该参数进行分割。

7. a, b = [1, 2] （或 a, b = (1, 2)） 此时a = 1; b = 2，这也是一种赋值方式。

8. string.isdigit(): 是否为数字；string.isnumeric(): 是否为数字；string.isalpha(): 是否为字母或汉字；string.isspace()：是否为空格。返回类型是布尔型。

9. string.center(width,[fillchar]): 返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。如果 width 小于字符串宽度直接返回字符串，不会截断; fillchar 默认是空格; fillchar 只能是单个字符。

10. string.zfill(width)：返回string的副本，长度为width，不足的用0补齐。

11. 字符串中的编号叫做“索引” (index)。

12. string.join(seq)：以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。 join()方法可以说是 split 的逆方法，方法用于将序列中的元素以指定的字符连接生成一个新的字符串。要连接的元素序列可以是字符串、元组、字典等。但连接的元素不能是数字。

    >>> seq1 = ['Details','is','the','key','to','success']

    >>> " ".join(seq1)

    'Details is the key to success'

    >>> seq2 = {'Hope':1,'for':2,'the':3,'best':4}

    >>> "*".join(seq2)

    'Hope*for*the*best'

13. split()方法用于将字符串分割成多个字符串组成的列表。split()当不带参 数时，默认以空格进行分割，当带参数时，以该参数进行分割。

14. 在字符串中的'\'要写为'\\'。

15. str.lower() 返回字符串str的副本，全部字符小写 。str.upper() 返回字符串str的副本，全部字符大写。因此，这两个函数不改变字符串本身。还有，str.replace() 这个也是返回改变后的string, 不改变string本身。

16. 编码转换(Python 3中，字符串默认使用Unicode编码) ：

    ord('a')：获取字符的整数表示的Unicode码；

    chr(97)：把整数表示的Unicode码转换成对应的字符

三、假设dic是一个字典：

1. for dd in dic:

       print(dd)

   此时此刻输出的是键，而不是键值对组成的元组。

   包括 lst = list(dic)，生成的列表也是只有键没有值。

2. list(dic)：直接这样操作，生成的列表中只有键没有值，而print(dic)却是将整个字典全部打印出。

3. 利用collections库的Counter方法统计字符串每个单词出现的次数。

4. del dic[key]：删除key所在元素，如果key不存在将导致KeyError。

5. 字典中的键是不能重复的，否则新的键值对会覆盖旧的键值对，其实就是改变键所对的值。因此陶陶摘苹果（升级版）不能用字典去做。

6. dic.pop(<key>,<default>)：键存在返回相应值，同时删除键值对；键不存在则返回默认值。

7. 用字典实现加密：

   d = {}

   for c in (65, 97):

       for i in range(26):

           d[chr(i+c)] = chr( (i+13)%26 + c )

   print(''.join([d.get(c, c)  for c in s]))

四、假设set1是一个集合：

1. 集合的元素必须是固定数据类型，可理解为不可变对象；而可变数据类型（可理解为可变对象）并不能作为集合的元素。

2. 映射类型是“键-值”数据项的组合，每个元素是一个键 值对，即元素是(key, value)，元素之间是无序的。

3. sort：以列表为例，会改变列表本身；reverse = True 是从大到小; 不能对字典排序。

   sorted: 以列表为例，不会改变列表本身；reverse = True 也是从大到小；可以对字典进行排序，按字典的key值进行排序。

   ( sorted() 与 ls.sort() ，当不注明 ‘reverse = ’时，默认均为升序，即从小到大。）

intersection, union, diffirence, symmetric

 

 

五、类和对象

1. 类描述的对象包括：数据（属性）；操作（方法，method）。

2. 类用关键字class来定义（惯例：类名一般用大写字母开头）。

3. 属性：在类的定义开始位置初始化类属性， 或在构造函数（__init__）中初始化实例属性；在类的内部通过self访问；在类的外部通过实例访问。类定义的操作是实例的操作，而不是类本身的操作。例如1+2， int+int是没意义的。

4. 约定以两个下划线开头，但不以两个下划线结束的属性或方法 时私有的，其他的为公有的；私有属性或变量不能直接访问，但可以在类体中在其他方法中访问。

5. 子类时必须在其构造函数中调用父类的构造函数，格式： 基类名.__init__(self,实参列表)

6. 如果派生类重新定义从基类中继承的方法，则派生类中定义的方法覆盖基类中继承的方法（继承和重写）。

六、命名规则

1. 变量（标识符）：大写字母、小写字母、数字、下划线(_)和汉字等字符及其组合给变量命名；首字符不能是数字，不包含空格，长度没有限制。

2. 保留字也称为关键字，指被编程语言内部定义并保留使用的标识符。

3. 模块/包名、函数名、变量名：全小写字母，简单有意义，如需要可使 用下划线。

4. 类名：采用PasecalCase命名规则，即可多个单词组成名称，每个单词除第一个字符大写外，其余的字母均小写。

5. 常量名：全大写字母，可使用下划线增加可读性。

七、变量

1. int型，float型：可以把数值或任何符合格式的字符串或其他类型转换成int。

2. 通过“=”给变量重新赋值，不改变原始对象的值，而是创建一个新对象，并指向它；一个变量可以=另外一个变量，那么它们指向的那个对象的引用就增加了一个。

八、函数

1.  lambda函数用于定义简单的、能够在一行内表示的函数，返回一个函数类型。形式如下：<函数名> = lambda <参数列表>: <表达式>

2. 默认值参数必须出现在函数参数列表的最右端，且任何一个默认值参数右边不能有非默认值参数。

3. 若调用函数时指定了参数名称，即在调用函数的括号里将参数赋值，则参数之间的顺序可以任意调整。

4. return语句用来从一个函数中返回，即跳出函数；如果函数没有return语句，Python将认为该函数以return None 结束。函数也可以用return返回多个值，多个值以元组类型保存。

5. 如果希望函数引用全局变量，需要在引用的变量使用前显式声明 (global) 该变量为全局变量。

6. 内置函数map：可以将一个函数作用到一个序列或迭代器对象上。需要指出的是，此时函数是不带形参列表的，即函数后面不带括号，否则会报错。map()对象，只能循环遍历一轮，之后为空。循环取得对象中的值 ，实际上是会调用内部函数__next__，将值改变，或者指向下一个元素。当多次调用，代码认为到达终点了，返回结束，或者__next__指向空，此时可迭代对象（链表） 就算到终点了，不能再用了。

7. 内置函数filter：将一个函数作用到一个序列上，返回该序列中使 该函数返回值为True的元素组成的列表、元组或字符串。

8. zip函数：返回元组列表
   >>>a = [1,2,3]

   >>> b = [4,5,6]

   >>> zipped = zip(a,b) # 打包为元组的列表

   [(1, 4), (2, 5), (3, 6)]

9. 函数的参数列表中，逗号（,） 之后要有空格；函数的参数列表中，默认值等号两边不要添加空格。

10. time.sleep(t)：当前程序挂起 t 秒。

11. random.random()：生成[0.0, 1.0) 随机小数； random.uniform(a, b)：生成 [a, b] 随机小数。random.shuffle(seq)：返回将seq中所有元素随机排序后序列。

12. lambda 函数定义的是匿名函数。即可以在一行内表示的函数。

13. all()：针对组合数据类型，如果每个元素都为True，返回True，否则返回False。0，空字符串''，空列表[]都是False。

14. any()：有一个为True返回True；都为False返回False。

15. import numpy as np

    求平均值：np.mean(lst)

    求方差：np.var(lst)

    求标准差：np.std(lst,ddof=1)   注：ddof参数不可省略，目前必须是1，原因还不清楚。

 

九、元组

1. () 或 tuple()：创建一个空元组。

十、文件处理

1. 类型：文本文件和二进制文件。

2. 写：f.write(s)：把字符串写入到文件f ；f.writelines(lines)：依次把列表lines中的各字符串写入到文件f。

   （write()/writelines()不会添加换行符，可通过添加\n实现换行）

3. f.read() ：从f中读取剩余内容，直至文件结尾，返回一个字符串 ；

   f.readline() ：从f中读取1行内容，返回一个字符串 ；

   f.readlines() ：从f中读取剩余多行内容，返回一个列表。

   f.readall()：读入整个文件内容，返回一个字符串或一个字节流。

4. 打开方式：

   'a'：以追加模式打开文件。文件指针自动移到文件末尾；若文件不存在则创建。

   'b'：以二进制模式打开文件。对应于文本文件：'rb' 'wb' 'ab' 'rb+' 'wb+' 'ab+'。

   'x'：创建写模式，文件存在则FileExistError。

   '+'：与r/w/x/a 在原功能基础上增加同时读写功能。

5.  f.seek(offset, whence=0)  ：改变文件读写位置，whence(0起始，1当前，2末尾)偏移offset个字节，正结束方向移动， 负往开始方向移动。

6. 一维数据由对等关系的有序或无序数据构成，采用线性方式组织，对应于数学中的数组和集合等概念；二维数据，也称表格数据，由关联关系数据构成，采用表格方式组织，对应数学中的矩阵；高维数据由键值对类型的数据构成，采用对象方式组织，属 于整合度更好的数据组织方式。在网络系统中十分常用， HTML、XML、JSON等都是高维数据组织的语法结构。

7.  CSV文件的每一行是一维数据，可用列表类型表示，整个CSV 文件是一个二维数据，由表示每一行的列表类型作为元素， 组成一个二维列表。

十一、迭代器与生成器

1. 迭代器(iterator)：迭代器是访问集合内元素的一种方式。迭代器对象从集合的第一个元素 开始访问，直到所有的元素都被访问一遍后结束。对于无法随机访问的数据结构（比如set）而言，迭代器是唯一的访问元素 的方式。迭代器的另一个优点就是它不要求事先准备好整个迭代过程中所有的元素。这个特点使得它特别适合用于遍历一些巨大的或是无 限的集合，这个特点被称为延迟计算或惰性求值(Lazy evaluation)。迭代器更大的功劳是提供了一个统一的访问集合的接口。只要是实现了 __iter__()方法的对象，就可以使用迭代器进行访问。

2. enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组 合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

3. enumerate(sequence, [start=0])

   >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']

   >>>list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] 

   >>> list(enumerate(seasons, start=1)) # 下标从 1 开始 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

4. 生成器表达式来源于迭代和列表解析式和组合，生成器和列表解析式类似， 只要把一个列表生成式的[ ]中括号改为（）小括号，就创建一个generator。创建一个generator后，基本上通过for循环来迭代。

5. generator和函数的执行流程的区别：函数是顺序执行的，遇到return语句或者最后一行函数语句就返回；变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回；再次被next()调用时候从上次的返回yield语句处继续执行，也就是用多少，取多少，不占内存。

6. 带有yield的函数不再是一个普通的函数，而是一个生成器generator，可用于迭代

7. yield是一个类似return 的关键字，迭代一次遇到yield的时候就返回yield后面或者右面的值。而且下一次迭代的时候，从上一次迭代遇到的yield后面的代码开始执行。

   def fib(max):

      n,a,b =0,0,1

       while n < max:

           yield b

           a,b =b,a+b

           n = n+1

       return 'done'

8. 执行如下：

   a = fib(10)

   print(a)

   print(a.__next__())

   print(“have a rest….")

   print(a.__next__())

9. 把函数改成generator后，基本上很少会用next()来获取下一个返回值，而是直接使用for循环来迭代。

   for i in fib(6):

       print(i)

10. 但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果拿不到返回值，那么就会报错，所以为了不让报错，就要进行异常处理，拿到返回值，如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中

    g = fib(6)

    while True:

        try:

            x = next(g)

            print('generator: ',x)

        except StopIteration as e:

            print("生成器返回值：",e.value)

            break

11. 可以直接作用于for循环的数据类型有以下几种：一类是集合数据类型，如list,tuple,dict,set,str，文件等；一类是generator，包括生成器和带yield的generator function。这些可以直接作用于for 循环的对象统称为可迭代对象：Iterable. 

12. 可以使用isinstance()判断一个对象是否为可Iterable对象。

    >>> from collections import Iterable

    >>> isinstance([], Iterable)

    True

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

14. 可以使用isinstance()判断一个对象是否是Iterator对象：

    >>> from collections import Iterator

    >>> isinstance((x for x in range(10)), Iterator)

    True

15. 生成器都是Iterator对象，但list、dict、str虽然是Iterable（可迭代对象） ，却不是Iterator（迭代器）。 

16. 把list、dict、str等Iterable变成Iterator可以使用iter()函数：

    >>> isinstance(iter([]), Iterator)

    True

十二、基本数据类型：

1. 浮点数有两种表示方法：十进制表示与科学计数法表示。科学计数法使用字母 e 或E表示幂。sys.float_info可知浮点数17位，前十五位准确。用decimal可进行高精度浮点数运算(a = decimal.Decimal('3.14159265')), decimal.getcontext().prec 可以规定位数。

2. 复数的虚部用 J 或 j 表示。用 z.real 和 z.image 获得实数和虚数部分。

3. round(x,[ndigits])：四舍五入。

4. pow(x, y, [z])：相当于 (x**y) % z，幂运算和模运算同时进行，速度很快。

5. math.fsum([x, y,...])：浮点数精确求和。

6. from math import *：引用math库中所有函数。

7. 字符串以Unicode编码储存，因此，字符串的英文字符和中文字符都算作一个字符。

8. hen(x)：返回整数x对应的十六进制的小写形式的字符串。oct(x)：返回整数x对应的八进制的小写形式的字符串。

9. 对于组合数据类型的全局变量，如果函数内部没有被真实创建的同名变量，则函数内部可以直接使用并修改全局变量的值；如果函数内部真实创建了组合数据类型的变量，无论是否有同名全局变量，函数仅对局部变量进行操作，函数退出后局部变量被释放，全局变量的值不变。

10.  

十二、其他

1. a = (1) , 若type(a) , 会输出<class 'int'>; 但a = (1,) ，若type(a)，输出的是<class 'tuple'>

2. math.hypot(x,y): 求(x,y)到原点的距离。

3. 不可变对象：bool, int, float, complex, str, tuple, frozenset; 可变对象：list, set, dict

4. list, str, tuple, dict, set, frozenset 均为可迭代对象；int, float均为不可迭代对象。可迭代对象与不可迭代对象区别之一是是否能被遍历(traversal)。

5. 正则表达式：：一种用来匹配字符串的强有力的武器，用一种描述性的语言来给字符串定义一个规则。正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。

   用‘\d’匹配一个数字，’\w‘ 匹配一个字母或数字，'.' 匹配任意字符 ；

   '00\d'可以匹配'007'，但无法匹配'00A'；

   '\w\w\d'可以匹配'py3'；

   'py.'可以匹配'pyc'、'pyo'、'py!'等等

6.  requests库是一个简洁且简单的处理HTTP请求的第三方库。requests.get()是获取网页最常用的方式，返回的 网页内容会保存为一个Response对象，其中，get()函数的参数url必须链接采用HTTP或HTTPS方式访问。区分一下，re 是Python 标准库，直接通过import re 即可使用。

7. 网络爬虫应用一般分为两个步骤：通过网络连接获取网页内容： requests ； 对获得的网页内容进行处理：beautifulsoup4。

8. Response对象中encoding属性非常重要，它给出了返回页面内容的编码方式，可以通过对encoding属性赋值更改编码方式，以便于处理中文字符。status_code属性返回请求HTTP后的状态，200表示连接成功，404表示失败。text 属性是请求的页面内容，以字符串形式展示。encoding属性非常重要，它给出了返回页面内容的编码方式，可以通 过对encoding属性赋值更改编码方式，以便于处理中文字符。json()方法能够在HTTP响应内容中解析存在的JSON数据，这将带来解析 HTTP的便利。 raise_for_status()方法能在非成功响应后产生异常，即只要返回的请 求状态status_code不是200，这个方法会产生一个异常，用于 try…except语句。调用：import requests

9. beautifulsoup4库，也称为BeautifulSoup库或bs4 库，用于解析和 处理HTML和XML。beautifulsoup4库采用面向对象思想实现，简单说，它把每个页面当做一个对象，通过<a>.<b>的方式调用对象的属性（即包含的内容）， 或者通过<a>.<b>()的方式调用方法（即处理函数）。 beautifulsoup4 库中最主要的是BeautifulSoup 类，每个实例化的对象相当于一个页面。创建的BeautifulSoup 对象是一个树形结构，它包含HTML 页面里的每 一个Tag（标签）对象，如<head>、<body>等。调用：from bs4 import BeautifulSoup

10. 由于HTML语法可以在标签中嵌套其他标签，所以string 属性的返回值 遵循如下原则： 如果标签内部没有其他标签，string 属性返回其中的内容；如果标签内部有其他标签，但只有一个标签，string 属性返回最里面标签的内容；如果标签内部有超过1层嵌套的标签，string 属性返回 None （空字符串）。HTML语法中同一个标签会有很多内容，例如<a>标签，百度首页一共有 13 处，直接调用soup.a 只能返回第一个。

11. matplotlib提供数据绘图功能的第三方库，pyplot子库主要用于实现各种数据展示图形的绘制（引用：import matplotlib.pyplot as plt）。

12. 程序设计的 IPO模式:  I (input)输入数据 ; P(process)处理数据 ; O(output) 输出数据。

13. 程序设计语言包括编译执行和解释执行两种方式, 程序设计语言分为机器语言、汇编语言、高级语言三类。高级语言按照计算机执行方式的不同可分成两类：静态语言——编译；脚本语言——解释。

14. 程序的基本结构：顺序结构，条件结构（分支结构），循环结构（可以证明：任何一个算法都可以由三种结构组合而成）；程序结构描述工具——流程图

15.  文档注释（Docstring）：一般出现在模块头部、函数和类的 头部，可通过help函数直接获取。文件头部须加入‘ # -*- coding: utf-8 -*- ’，方便写中文注释，若否会出错。

16. 现代编程语言从代码层面采用函数和对象两种抽象方式，分别对应面向过程和面向对象两种编程思想。

17. a = 3;b = 4;c = 5; 这种写法也是对的，但不推荐用这种复合语句，即一行中包含多个语句。

18. PIL是Python语言的第三方基础图像处理库（库名：pillow）

19. A~Z: 65~90; a~z: 97~122

20. random.randrange([start], stop[, step])从指定范围内获取一 个随机数，其中step是步长；random.choice(seq)可以从任何序列seq，如list列表中，选取一个 随机的元素返回，可以用于字符串、列表、元组等；

    random.sample(seq, n)从指定序列seq中，随机选择n独立的元素。注： seq原序列不变;

    random.shuffle(seq)随机打乱序列seq中的元素；

    需要强调的是，random.randint是左闭右闭区间。

21. 注释主要有三个用途：标明作者与版权信息；解释代码原理或用途；辅助程序调试。

22. 编程语言索引分两类：一是数字索引，如列表、元组和字符串；二是字符索引，如字典。

23. jieba.lcut(s)：精确模式，返回一个列表类型。

 

补充：

1.三连击（升级版）

（1）三个数A、B、C可能是有公因子，若不考虑会出错，这样子：
（2）当输入123，456，789时，你会发现必须要从1开始搜索，要是从123开始搜就挂了。

代码整理如下：

def main7():
    lst = []
    a, b, c = map(int, input().split())
    if a <= 0:
        print('No!!!')
    i = 2
    while(i<=a):
        if a % i == 0 and b % i == 0 and c % i == 0:
            a //= i
            b //= i
            c //= i
        else:
            i += 1
    
    for i in range(1,333):
        x = i * a
        y = i * b
        z = i * c
        str1 = str(x) + str(y) +str(z)
        set1 = set(str1)
        if len(set1) == 9 and ('0' not in str1) and z<=999 :
            lst.append((x,y,z))
    if lst != []:
        for i in lst:
            print(i[0],i[1],i[2])
    else:
        print('No!!!')
main7()

 

2.Function

(1)注意在定义递归函数传递参数的时候，字典也要跟着传下去，即参数中也要包含’dic‘这个参数。

def w(a,b,c, dic = {}):
    if a <=0 or b <=0 or c<= 0:
        dic[(a,b,c)] = 1
        return dic[(a,b,c)]
    elif a > 20 or b > 20 or c > 20:
        return w(20,20,20,dic)
    elif a<b and b < c:
        try:
            return dic[(a,b,c)]
        except:
            dic[(a,b,c)] = w(a,b,c-1,dic) + w(a,b-1,c-1,dic)-w(a,b-1,c,dic)
            return dic[(a,b,c)]
    else:
        try:
            return dic[(a,b,c)]
        except:
            dic[a,b,c] = w(a-1,b,c,dic)+w(a-1,b-1,c,dic)\
                         +w(a-1,b,c-1,dic)-w(a-1,b-1,c-1,dic)
            return dic[(a,b,c)]
while(True):
    a , b , c = map(int , input().split())
    if a == -1 and b == -1 and c == -1:
        break
    else:
        print("w({}, {}, {}) = {}".format(a,b,c,w(a,b,c)))

3.改变递归深度：

import sys
sys.setrecursionlimit(10000)