python 3 笔记

一、python基础I

1. python3 打印使用

   print (var)               #默认是换行的print (var, end = "" )    #不换行print (var1,var2,var3, sep='@')  #插入分隔符

2. 原始字符串

   r"c:\user"

3. 在 python 中，类型属于对象，变量是没有类型的：

   a=[1,2,3]a="Runoob"

4. 保留字

   >>> import keyword>>> keyword.kwlist

5. 导入

   在 python 用 import 或者 from...import 来导入相应的模块。
   将整个模块(somemodule)导入，格式为： import somemodule
   从某个模块中导入某个函数,格式为： from somemodule import somefunction
   从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
   将某个模块中的全部函数导入，格式为： from somemodule import *

6. 注释

   行注释#较长注释 ''' ''' 或者 """ """

7. 帮助信息

   help(max)print(max.__doc__)

8. 标准数据类型（6个）

   • Number（数字）
   • String（字符串）
   • List（列表）
   • Tuple（元组）
   • Sets（集合）
   • Dictionary（字典）

9. Number
   【int、float、bool、complex】
   【使用type()函数来查看类型】
   【type()不会认为子类是一种父类类型。
   isinstance()会认为子类是一种父类类型。】

10. String
    Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
    Python中的字符串不能改变。

11. List
    列表是写在方括号([])之间、用逗号分隔开的元素列表。
    加号（+）是列表连接运算符，星号（*）是重复操作
    List中的元素是可以改变的。

12. Tuple
    元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。
    string、list和tuple都属于sequence（序列）。

13. Sets
    集合（set）是一个无序不重复元素的序列。
    基本功能是进行成员关系测试和删除重复元素。
    可以使用大括号 { } 或者 set() 函数创建集合。
    注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

    print(a - b)     # a和b的差集print(a | b)     # a和b的并集print(a & b)     # a和b的交集print(a ^ b)     # a和b中不同时存在的元素

14. Dictionary（字典）
    字典是一种映射类型，字典用”{ }”标识，它是一个无序的键(key) : 值(value)对集合。
    键(key)必须使用不可变类型。
    在同一个字典中，键(key)必须是唯一的。

15. 小拓展

元组：

    一般来说，函数的返回值一般为一个。    而函数返回多个值的时候，是以元组的方式返回的。    def example(a,b):        return (a,b)    python中的函数还可以接收可变长参数    def test(*args):        print(args)

字典：

如果把一个字典对象作为for的迭代对象，那么这个操作将会遍历字典的键：for c in dict:    print(c,':',dict[c])输入 dict 的键值对，可直接用 items() 函数：for k,v in dict1.items():    print(k,":",v)

列表：

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]print (list[1:3])       # 输出下标1，2的元素

类型：

type 主要用于判断未知数据类型，isinstance 主要用于判断 A 类是否继承于 B 类。

二、python基础II

1. 运算符

   + - * / %** 幂 - 返回x的y次幂// 取整除 - 返回商的整数部分**=//=

   逻辑运算符：

   运算符 逻辑表达式 描述 and x and y 与 or x or y 或 not not x 非

   成员运算符：

   运算符 描述 in 如果在指定的序列中找到值返回 True，否则返回 False。 not in 如果在指定的序列中没有找到值返回 True，否则返回 False。

   身份运算符：

   运算符 描述 is is 是判断两个标识符是不是引用自一个对象。 is not is not 是判断两个标识符是不是引用自不同对象。

   优先级：
   

2. and和or的返回值

   and 和 or 的描述：

   The expression "x and y" first evaluates *x*; if *x* is false, its value is returned; otherwise, *y* is evaluated and the resulting value is returned.The expression "x or y" first evaluates *x*; if *x* is true, its value is returned; otherwise, *y* is evaluated and the resulting value is returned.

   从左到右：
   and会返回遇到的第一个假值。若没有，则返回最后一个值。
   or会返回遇到的第一个真值。若没有，则返回最后一个值。

3. 进制

   2 进制是以 0b 开头的
   8 进制是以 0o 开头的
   16 进制是以 0x 开头的

4. is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

5. 在交互模式中，最后被输出的表达式结果被赋值给变量 _

6. Python 所谓的奇进偶弃，因为浮点数的表示在计算机中并不准确。

   >>> round(10.5)10>>> round(11.5)12

7. python 不支持复数转换为整数或浮点数

8. 随机

   random.randint(x,y)　#随机生一个整数int类型，可以指定这个整数的范围>>> random.randint(1000,9999)8449random.sample(sequence,length) 可以从指定的序列中，随机的抽取length个元素。

9. 格式化字符串
   

   

10. python三引号"""允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

11. Unicode 字符串
    在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

    在Python3中，所有的字符串都是Unicode字符串。

12. Python 的字符串内建函数
    

13. [::2] 表示的是从头到尾，步长为2。第一个冒号两侧的数字是指截取字符串的范围,第二个冒号后面是指截取的步长。

    >>> L=['a','b','c','d','e','f','g']>>> print(L[::2]) ['a', 'c', 'e', 'g']

14. 字符串的分割还有partition()这种方式。

    partition(sep)  --> (head,sep,tail)从左向右遇到分隔符把字符串分割成两部分，返回头、分割符、尾三部分的三元组。如果没有找到分割符，就返回头、尾两个空元素的三元组。

三、python基础III

1. 条件语句

   if condition_1:    statement_block_1elif condition_2:    statement_block_2else:    statement_block_3    ...

2. 条件语句

   while condition :    ...for variable in sequence:    statementselse:    statements

3. range()函数

   for i in range(5):    print(i)for i in range(5, 9):    print(i)for i in range(0, 10, 3):    print(i)for i in range(-10, -100, -30):    print(i)list(range(5))

4. break和continue

5. pass语句

   Python pass是空语句，是为了保持程序结构的完整性。
   pass 不做任何事情，一般用做占位语句

6. 小拓展

   使用内置 enumerate 函数进行遍历:

   sequence = [12, 34, 34, 23, 45, 76, 89]for i, j in enumerate(sequence):    print(i, j)

四、python基础IV

• 迭代器：两个基本的方法：iter() 和 next()。

  dict = {1 : "one",         2 : "two",        3 : "three"}it = iter(dict)for item in it :    print (item, end = " ")    print (dict[item])

• 生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

  在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行。

  import sysdef fibonacci(n): # 生成器函数 - 斐波那契    a, b, counter = 0, 1, 0    while True:        if (counter > n):             return        yield a        a, b = b, a + b        counter += 1f = fibonacci(100) # f 是一个迭代器，由生成器返回生成while True:    try:        print (next(f), end=" ")    except StopIteration:        sys.exit()

• 函数

  def 函数名（参数列表）:    函数体

• 可更改(mutable)与不可更改(immutable)对象

  在 python 中，类型属于对象，变量是没有类型的.
  在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

  python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

以下是调用函数时可使用的正式参数类型：

必需参数关键字参数    def func(str) :        print (str)    func(str = "abcd")默认参数    def func(str = "xyz") :        print (str)    func()不定长参数    def printinfo( arg1, *vartuple ):       print (arg1)       for var in vartuple:          print (var)       return;    printinfo( 70, 60, 50 );

5 . 匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda [arg1 [,arg2,…..argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2;print ("相加后的值为 : ", sum( 10, 20 ))

6 . 变量作用域
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

<font color = blue>**变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。**</font>Python的作用域一共有4种，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内建作用域

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

x = int(2.9)  # 内建作用域g_count = 0  # 全局作用域def outer():    o_count = 1  # 闭包函数外的函数中    def inner():        i_count = 2  # 局部作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问.

7 . 全局变量和局部变量

**定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。****局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。**

8 . global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到`global`和`nonlocal`关键字了。如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了.

9 . 列表方法：

将列表当堆栈使用：append()、pop()

将列表当队列使用：deque()、append()、popleft()

列表推导式：

>>> vec = [2, 4, 6]>>> [3*x for x in vec][6, 12, 18]

10 . del 语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）

11 . 集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号{}创建集合。注意：如果要创建一个空集合，你必须用set()而不是{}；

集合也支持推导式.

12 . 字典
一对大括号创建一个空的字典：{}。

13 . 遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}>>> for k, v in knights.items():        print(k, v)

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):        print(i, v)

同时遍历两个或更多的序列，可以使用 zip()组合：

>>> questions = ['name', 'quest', 'favorite color']>>> answers = ['lancelot', 'the holy grail', 'blue']>>> for q, a in zip(questions, answers):        print('What is your {0}?  It is {1}.'.format(q, a))

要反向遍历一个序列，首先指定这个序列，然后调用 reversed()函数：

>>> for i in reversed(range(1, 10, 2)):    print(i)

要按顺序遍历一个序列，使用 sorted()函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']>>> for f in sorted(set(basket)):    print(f)

五、python基础V

1. Python3 模块

   import 语句
   一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
   这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。

   这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。

   搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量，做一个简单的实验，在交互式解释器中，输入以下代码：

   >>>import sys>>>sys.path

2. from … import 语句

3. from … import * 语句

4. __name__属性

   if __name__ == '__main__':    print('程序自身在运行')else:    print('我来自另一模块')

5. dir() 函数

   内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

   如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

6. 包

   在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

   目录只有包含一个叫做__init__.py 的文件才会被认作是一个包，

7. 从一个包中导入*

   如果包定义文件 __init__.py 存在一个叫做 __all__的列表变量，那么在使用from package import *的时候就把这个列表中的所有名字作为包内容导入。

8. 输入和输出

   Python两种输出值的方式: 表达式语句和 print() 函数。

   第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

   如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

   如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

   • str()： 函数返回一个用户易读的表达形式。
   • repr()： 产生一个解释器易读的表达形式。

   Python提供了input()函数从标准输入读入一行文本，默认的标准输入是键盘。

   input 可以接收一个Python表达式作为输入，并将运算结果返回。

9. 读写文件

   open(filename, mode)

   • filename：filename 变量是一个包含了你要访问的文件名称的字符串值。

   • mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

     read(size)
     write(str)

   为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

   size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

   f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

   f.readlines() 将返回该文件中包含的所有行。
   如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

   f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

   如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

   from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

   seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符seek(x,1) ： 表示从当前位置往后移动x个字符seek(-x,2)：表示从文件的结尾往前移动x个字符

   你处理完一个文件后, 调用 f.close()来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

10. 文件对象还有其他方法, 如 isatty()和 trucate()

11. pickle 模块

    python的pickle模块实现了基本的数据序列和反序列化。

    通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

    通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

    基本接口：

    pickle.dump(obj, file, [,protocol])

    有了 pickle 这个对象, 就能对 file 以读取的形式打开:

    x = pickle.load(file)

12.