初学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):

转载于:https://www.cnblogs.com/wangwei5979/p/10752966.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值