# 1 # 计算机原理：控制器 运算器 存储器 input设备 output设备  IO流 # 三大核心：CPU 内存 硬盘 # 内存分布：栈区 与 堆区 # 如二进制与十进制的转换，如1111转成十进制为15，1111从左向右可看出2^3+2^2+2^1+2^0为8+4+2+1=15。 # 记住前8位1的二进制代表的数为128、64、32、16、8、4、2、1，其中0的代表0。 # 当然还有种叫取k余法，如十进制中的27转为二进制时27/2=13余1，13/2=6余1，6/2=3余0，3/2=1余1，从后往前，得11011； # 同理，这种方法也适用于转其他进制。 # 二进制：1010  1111  0001  01111011 # 八进制：12       17     1         173 # 十六进制：a      f         1       7b # 十进制： 10    15      1      123 #2 # 两种执行方式: 交互式 | 脚本式 # 交互式：控制台直接编写运行python代码。步骤：1.打开终端；2.进入python解释器；3.编写代码，回车。 # 脚本式：文件编写python代码，把文件作为脚本交给解释器执行。步骤：1.在文件中编写好代码 ；2.打开终端 ； # 3.用指定版本的接收器命令执行文件(文件的绝对路径)。 # 变量： #  -- 声明： 变量名 = 变量值 #  -- 变量值：变量名  类型：type(变量名)  地址：id(变量名) #  -- == | is: == 值比较 | is地址比较 ''' 变量名命名规范    -- 1.只能由数字、字母 及 _ 组成    -- 2.不能以数字开头    -- 3.不能与系统关键字重名    -- 4._开头有特殊含义    -- 5.__开头__结尾的变量，魔法变量    -- 6.支持大小驼峰，但建议 _ 连接语法    -- 7.尽量见名知意 常量：用全大写标示常量，只能自我保障不去修改全大写的变量 数据类型    -- int: 存放所有的整型数据 => py2中分 int | long    -- float： 存放所有的浮点型数据 => %015.3f    -- bool: True | False    -- str: '' | "" | '''''' | """"""    -- list: 按索引存放多个数据    -- dict：按描述信息的key来标示存放多个数据    -- 重点：所有数据都是单独存放，数据的地址是被存放在普通变量 | 集合(list|dict)容器中 运算符    -- 算术运算符：+ | - | * | / | // | % | **    -- 赋值运算符：       -- 1.算术运算符=  a += 1 => a = a + 1       -- 2.链式赋值：a = b = c = 10       -- 3.交叉赋值：a, b = b, a       -- 4.解压赋值：a, _, _, b = [1, 2, 3, 4]    -- 比较运算符：> | < | == | != | >= | <=       -- 30 > num > 20    -- 逻辑运算符       -- 30 > num and num > 20：两边都成立，才成立，前面不成立，则无需判断后面       -- 30 < num or num < 20: 两边都不成功，才不成立，前面成立，则无需判断后面       -- not 0 | not True：真假取反       -- 了解：and 优先级高于 or ''' ''' 流程控制 1.顺序结构、分支结构、循环结构 2.if分支结构 if 条件:     代码块 elif 条件:     代码块 else:     代码块 # 可以被if转换为False：0 | '' | None | [] | {} 3.while循环结构 while 条件:     循环体 # 1）可以通过改变循环变量，使循环条件不满足 # 2）当达到特定条件，直接使用break来强行结束所属循环 break:结束所属循环 continue:结束所属循环的本次循环进入下一次循环 while...else...：当循环正常结束，else分支才会被执行(break结束的循环才叫不正常结束) 4.for循环(迭代器) # for循环：用来循环容器对象的(左右多个值的对象) # range(end)  # [0, end) # range(start, end)  # [start, end) # range(start, end, step)  # [start, end, 步长) ''' ''' 1.数字类型 int | float | bool | complex 2.字符串 常规操作：     -- 索引取值[index] | 切片[s_i:e_i:step] | 拼接 "%s" , ""+""     -- 长度 len() | 成员运算 in , not in | for循环(迭代) 重点： 3.列表 # 列表中的值可以为任意类型 # 增删改查 增：append(obj) | insert(index, obj) | extends(iterable) 删：remove(obj) | pop() | pop(index) | del ls[index] | clear() 改：ls[index] = new_obj 查：ls[index] | ls 4.可变与不可变类型 可变类型：变量存的地址不变，值可以发生改变 不可变类型：变量存的地址不变，值永远不能发生改变(值一旦发生改变，变量存放的地址一定改变) ''' ''' 1.深浅拷贝     ls = [1, 'a', [10]]     值拷贝：直接赋值 ls1 = ls, ls中的任何值发生改变，ls1中的值都会随之改变     浅拷贝：通过copy()方法 ls2 = ls.copy()，ls中存放的值的地址没有改变, 但内部的值发生改变，ls2会随之改变             -- ls = [1, 'a', [10]]  =>  [1, 'a', [100]] = ls2     深拷贝：通过deepcopy()方法 ls3 = deepcopy(ls)，ls中存放的值发生任何改变，ls3都不会随之改变 2.元组类型     t = tuple()     元组：1.就可以理解为不可变的list 2.有序 - 可以索引取值，可以切片 3.不可变 - 长度和内容都不能发生改变     细节：元组中可以存放所有的数据类型，所以存放可变类型数据后，可变类型依然可以发生改变 3.字典类型     d1 = {}     d2 = dict({'a': 1})     d3 = dict(name='Bob')  # 所有的key都会用合法的变量名，最终转化为字符串类型的key     d4 = {}.fromkeys('abc', 0) => {'a': 0, 'b': 0, 'c': 0}     key: 要确保唯一性，所以必须为不可变类型     value：存放可以存放的所有类型数据，所以支持所有类型     字典：1.可变 2.没有索引，通过key取值 3.无序的     增删改查：字典名[key名] | 字典名[key名] = 值 | update(dict) | setdefault(key, d_value) | get(key, default)             | pop(key) | popitem() | clear()     循环：keys() | values() | items()     for k, v in dic.items():  # (k, v)         pass     字典的成员运算：完成的就是 key 在不在 目标字典中 4.集合类型     s = set()     集合：1.可变 - 可增可删  2.无序无索引无key - 不能取值不能改值 3.for可以对集合取值，取值的结果顺序不确定     特定：不能存放重复的数据 ''' # [].copy() # {}.copy() from copy import deepcopy # print({'a': 1, 'b': 2}.pop('a')) # 字典的成员运算：完成的就是 key 在不在 目标字典中 # print(() in {'a': 1, 'b': 2}) # for i in {'1', '2', '3', '4'}: #     print(i) # c = 0 # while c < 3: #     print([1, 2, 3][c]) #     c += 1 # s1.symmetric_difference_update(s2)  # 将集合s1与s2的运算结果设置给s1 ''' 类型转换    1.数字类型：int() | bool() | float()    2.str与int：int('10') | int('-10') | int('0') | float('-.5') | float('3.14') | str(数字)    3.重点 - str与list：    'abc' => ['a', 'b', 'c']: list('abc') | ''.join(['a', 'b', 'c'])    'abc|def|xyz' => ['abc', 'def', 'xyz']: s.split('|') | '|'.join(ls)    4.list、set、tuple：类型()    5.list与dict：    a=1&b=2&c=3 <=> [('a', 1), ('b', 2), ('c', 3)] <=> {'a': 1, 'b': 2, 'c': 3}    dic = {}    for k, v in [('a', 1), ('b', 2), ('c', 3)]:       dic[k] = v    ls = []       for k, v in {'a': 1, 'b': 2, 'c': 3}.items():       ls.appen((k, v))    6.可以通过字典构建任意数据的映射关系    type_map = {
        1: '壹',       '壹': 1,       'owen'：(1, 88888),       'add': add  # add是功能(函数)    } 字符编码：    编码表：人能识别的符号与机器能识别的符号(01组成的二进制码)映射关系    py2：ASCII，常用ASCII表只有英文、数字、英文符号与与机器能识别的符号的对应关系    py3：utf-8，是unicode编码表的一种实现方式，采用变长存储数据，字母数字简单符号1个字节，中文3~6字节    utf-8: 变长，在英文数字较多时，更节省空间，用于传输，cpu与硬盘中采用的编码格式    utf-16: 定长，英文数字汉字都是采用2个字节，读存效率高，内存中采用的编码格式    gbk => utf-8: 转码    普通字符串 => 二进制字符串：编码，目的是用于传输数据 'abc'.encode('utf-8')    二进制字符串 => 普通字符串：解码，目的是用于显示数据 b'abc'.decode('utf-8')

一、 # 普通字符串：u''以字符作为输出单位，

# 二进制字符串：b'' 二进制字符串以字节作为输出单位

原义字符串：r''以字符作为输出单位，所有在普通字符串中能被转义的符号在这都原样输出

二、文件操作的三步骤 # # 1.打开文件: 硬盘空间被操作系统持有，文件对象被应用程序持有 # f = open('source.txt', 'r', encoding='utf-8') # # # # 2.操作文件 # data = f.read()#读  当然还有写  f.write # # # # 3.释放文件：释放操作系统对硬盘空间的持有 # f.close() 基础：

wf.write('123\n')

wf.flush()  # 向操作系统发送一条将内存中写入的数据刷新到硬盘

wf.writelines(['abc\n', 'def\n', 'xyz\n'])  # 一次写多行，行必须用\n标识 #with...open:

with open('target.txt', 'r', encoding='utf-8') as rf:

文件的操作模式:

主模式：r | w | a | x

-- 主模式只能选取一个，规定着主要的操作方式

从模式：t | b | + #     -- 从模式也必须出现，但个数不一定是一个，为主模式额外添加功能

游标操作:

seek(offset, whence):