初学python之路-day08前期总结

# 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):