D1 逻辑运算符、字符串
1. python2与python3共存问题
python2执行文件python.exe 需修改 python2.exe
环境变量需修改 此电脑右键 —> 属性 —> 高级系统设置 —> 环境变量 —> path添加python2x
2. 逻辑运算符优先级
{}
> []
> ()
> f()函数调用
> x[index:index]寻址段
> x[index]下标
> x.attribute属性
>
**幂
> ~x 按位翻转
> +x;-x正负号
> * / 乘除 %取余也叫取模 +-加减
> <<;>>移位
> &按位与
> ^
>
|
> > >= < <= 比较
> !=; ==;
> is; is not 统一性测试
> in ; not in 成员测试
> not
> and
> or
！！！同一优先级 从左到右算
1. 占位符
msg = ‘我叫%s，今年%d岁，学习进度1%%’ %('老男孩'，age)
python 的 and和or 跟印象中的很不相同：
x or y 若x为真，则返回x；若x为假，则返回y。 例如 print（1 or 3） 运行结果：1
x and y 若x为真，则返回y；若x为假，则返回x。 例如 print（1 and 3） 运行结果：3
（并不是 TRUE、FALSE）
若上面的 and， or 用在判断条件上， x、y的值即可代表真假。所以就返回x，y的值，可以另做他用。
（python不能用） x>y?x:y 如果x>y为真 ,则返回x，若为假，则返回y
（类似三元操作符） x if x>y else y 同上。
2. 下标
切片 s[0:3] s[:3] 取 s[0] s[1] s[2] 取头不取尾
s[0:] 后边取到尾
s[:] 从头取到尾，相当于复制。优出，另辟内存，不改变原字符串。
步长 s[0:7:2] 步长2，隔一个取一个
反向步长 s[-1:-6:-1] -1从右向左取
3. 字符串的方法
n=100
n.bit_length() 当十进制用二进制表示时，最少使用的位数
s.capitalize() 首字母大写，其他全小写
s.upper() 全大写
s.lower() 全小写
s.center(30,'*') 总长度30,然后居中。空白处由*填充
s.swapcase() 大小写翻转
s.title() 每个单词首字母大写，其他字母小写 由非字母符号隔开的都默认是不同的单词
s.startswith(‘a’，4, 7) 判断是不是以什么为开头,返回bool值 切片：从哪里开始判断
s.endswith()
s.strip() 去除首尾的(空格，换行符，tap) 左右同时进行， 遇到阻隔则停止。
s.lstrip('*') 从左边去除
s.rstrip()
s.isalpha() 判断是否只由字母组成
s.isdigit() 判断是否只由数字组成
s.isalnum() 判断是否由字母或数字组成
s.find('a',3) 查找元素a的索引 并返回，若找不到，返回-1。 可以设置查找范围（起始、结束）， 默认起始为0，单个表示查找起始位置。
s.index('a') 查找元素a的索引 并返回，若找不到，则报错。
s.count('a'，3) 计算元素a出现的次数，并返回，可以切片设置范围 默认全查，单个表示查找起始位置。若设置结束位置，同切片，不含尾。
len(s) 字符串长度（总字符个数）
s.join(list) join 用字符串s做一个连接符，链接可迭代对象中的每一个元素，形成一个新的字符串 列表或字典中要全是字符串。
s.replace('old','new',n) 替换，以及替换次数，默认全替换
s.split('*'，n) 将字符串s以（*）切割分成列表list，默认以空格为分割 ； 可设置切割次数，默认全切割。
fomat()
1.常规用法 s = "我叫{}，今年{}岁，爱好{}".fomat(‘MT’，‘18’，‘母牛’)
2.索引用法 s = "我叫{0}，今年{1}岁，爱好{2}，我依然叫{0}".fomat(‘MT’，‘18’，‘母牛’)
3.键值对用法 s = "我叫{name}，今年{age}岁，爱好{hobby}，我依然叫{name}".fomat(name=‘MT’，age=‘18’，hobby=‘母牛’)
1. msg = ‘{}{}’.format(‘a’， ‘b’)
2. msg = ‘{0}{1}’.format(‘a’，‘b’)
3. msg = ‘{A}{B}’.format(A=‘a’，B=‘b’)
D2 列表
1. while ... else ...
for ... else ...
正常循环完毕，就接着走else
只要被break打断，则不走else。
enumerate() for k,v in enumerate(li, 1) k的起始值为1
for i in enumerate（li）
若只有一个参数 i，那么接收的就是元组（k，v），完美适用于列表、元组（有序的）
不适用于字典，对字典来说，只能接收到键，接收不到值
2. 列表切片 增，删，改
之中有很多方法，只是一个方法，一个对原列表做的一个动作，并并并没有返回值。返回值为None
若想要看成果， 只需打印原列表即可。 print( li )
关于切片 迭代器也可以用切片，切出来的一样是迭代器。
li[0] 取出单个元素，元素什么数据类型，取出就是什么数据类型
li[:5] 切片取出的仍然是列表，哪怕只切出一个，也仍然是列表
li.append() 添加新元素到列表最后边
li.insert(2，‘a’) 插入新元素到指定索引处，其他元素顺延
li.extend() 按照迭代扩展
li.pop() 按照索引删除元素（可穿参数，参数是索引），默认删除最后一个，有返回值，即所删除的元素
li.remove( 'a' ) 按照元素删除元素，默认删除第一个想要删除的元素
li.clear() 清空列表
del li 从内存中删除列表，可切片删除
del li[:3] 切片删除部分
li[0]=‘a’ 按照索引直接修改某个元素
li[:3]=‘ABC’ 按照迭代修改
li.sort() 从小到大，排序 非数字，按照二进制编码排序（ASCII码）。
li.sort(reverse=True) 从大到小，排序
li.reverse() 翻转
len(li) 长度
li.count(‘a’) 查找某元素的个数
li.index(‘a’) 通过元素查索引
3. 列表的嵌套
4. 元组 元组中单个元素不能改，若某个元素为列表或字典，则可以更改列表或字典
儿子不能改，孙子可能改
5 range() 数字范围，顾首不顾尾 range(100) range(2,55,2) range(55,1,-2)
D3 字典
1. 字典
key --> value 储存大量关系型数据，查询速度快。
数据类型分类：
可变数据类型： list，dict，set （不可哈希）
不可变数据类型： int，bool，str，tuple （可哈希 hash） 哈希表 print( hash('name') )
字典key：不可变数据类型 唯一的（后者覆盖前者）
字典value ： 任意数据类型
字典的顺序：
创建的时候看起来更有序一些
2. for i in dic： i即是键
增加 dict['name']='wusir' 有则修改，无则添加
dict.setdefault('hobby','girl') 只传一个参数时创建一个键key，值为None。传两个参数时即键值对 key-->value
（default默认）没有就新增，已有则无效。
删除 dic.pop('age') 按照键 key 删除键值对，有返回值，返回键所对应的值value （字典中，键key就相当于索引，关联对应的值）
若没有此键，则报错。 可进行处理（传两个参数） dic.pop('hobby', 'abc') 返回设置的值‘abc’
（ 同dic.get() ）
dic.popitem() 随机删除， 返回一个元组（包含所删除的键值对）。
dic.clear() 清空。
del dic['name'] 没有键则报错。
更改 dic['name']='alex' 直接更新。
dic.update(dic2) 将dic2的键值对，覆盖修改并添加到dic dic 原本 dic2 更新内容 更新即换成新的
查找 dic['name'] 返回对应的值value , 没有则报错
列表通过索引找元素，字典通过键（钥匙）找值（数据元素） 
即字典中，键key（钥匙）相当于索引。
即字典中，键key（钥匙）相当于索引。
dic.get('name','abc') 通过键名找值，有键则返回对应的值value（无视设定值），没有返回设定的值（默认None）
dic.keys() 数据类型为dic_keys ，类似列表而非列表（无索引） 可for循环遍历
可以转换成列表 list(dic.keys())
dic.values() 同上
dic.items() 类似的 元组列表 可for循环 也可用两个变量 k v 一起for循环遍历分别获取键，值
————分别赋值 ： a,b=2,3 a,b=(2,3) a,b=[2,3] 一行代码ab互换 ： a,b = b,a
dic={'遥控器': '电视机', 'age':[12, 18, 24, 30], '密码': '用户数据', '钥匙': '箱子'}
l1 = dic['age']
l2 = dic['age'] 跟内存存储方式（内存地址） 有关, 容器类的数据类型，开辟空间大，相当于贴3个标签l1 l2 l3（有标签表指引）（图书丛）。
l3 = dic['age']
D4 编码方式
1. a == b 比较的是数值
a is b 比较的是内存地址
id(a) 查看内存地址
小数据池：
节省内存空间
2. ASCII ： 8位表示1个字节表示1个字符
Unicode： 32位4个字节表示1个字符
utf-8： 英文 1个字节表示1个英文字符 （一个英文字母）（8位一个字节）
欧洲 2个字节表示1个欧文字符 （一个欧文）
中文 3个字节表示1个中文字符 （一个中文）
gbk：国标
英文 ASCII 1个字节（8位）表示1个英文字符
中文 2个字节表示1个中文字符
python3x中的编码
str 在内存(运行内存)中的编码方式是unicode 不能直接存储和发送 （太大）
可以编码为utf-8或gbk 例如 str_utf8 = str.encode('utf-8')
str_gbk = str.encode('gbk')
解码的时候默认unicode解码 str_utf8.decode('utf-8')
bytes类型 他的编码方式是非unicode （utf-8, gbk）
英文： str s = 'abc' 内部编码方式：unicode
bytes s = b'abc' 内部编码方式：非unicode
中文： str s = “中国”
bytes s =b"\xe0\ad0\xe0\ad0\xe0\ad0\"
str 转化bytes ： s.encode('gbk') s.encode('utf-8')
bytes 转化str : s.decode('gbk') s.decode('utf-8')
D5 集合、深浅copy
python中， 空字典为{}， 空集合为 set()
1. 元组 对于一个元素，必须要加一个逗号，不然默认为元素的原数据类型
如 tu = (1) tu = ('a') 等价与 tu = 1 tu = ‘a’
tu = （1，） type（tu）就是元组了（1，） tuple
列表则不用这样，直接就是列表类型
2. 列表 在进行循环遍历时： 最好不要进行删除操作（操作后，索引会变，不处理会出错）。
解决： 可以先把需要的拿出来，添加到新列表，如需要再覆盖原列表。
解决： 倒着删除
在循环字典中，不能增加或删除此字典的键值对。
解决： 在循环时，将需要删除的键值对的键揪出来，存放在一个列表中
循环此列表，依次删除字典中的键值对
元组—>列表 list(tu1) 列表—>元组 tuple（lis1）
3. 字典 dic = dict.fromkeys(iterable, value) 创建一个新字典，键分别为iterable的元素，值同为value。
dic = dict.fromkeys('abc',[]) 则dic = ｛'a': [], 'b': [], 'c':[]｝
4. 集合
集合去重的思想，hash值的唯一性，__eq__ 判断值是否相同。效率极高。
不重复，无序，集合的元素是可哈希的，但整体是不可哈希的。
即集合的元素为：（int，float，str，bool，tuple）。
作用：1。去重 list(set(li)) 虽是无序，但在转化的时候，并不会打乱顺序
2。关系测试
增： set.add('a')
set.update('abc') 迭代增加
删：set.remove('a') 按元素删除
set.pop() 随机删除，返回所删除的元素
set.clear() 清空
del set 直接删除
len（set）
查： for遍历
交集 & ： set1.intersection(set2) 反交集 ^ ： set1.symmetric_difference(set2)
并集 | ： set1.union(set2) 差集 - ： set1-set2
判断子父集：set1.issubset(set2) set1.issuperset(set2)
frozenset（set）
5. 深浅copy。
列表：li = [1,2,[3,4]]
赋值运算，l2 = li 赋值的是内存地址。
b=a.copy()
这是浅copy，只是在内存中重新开辟空间，存放原列表中各元素的内存地址。
（原列表也是存放的各个元素的内存地址。）
（遇到的值，都是指的该值的内存地址。）
import copy # 模块.方法名（）
b=copy.deepcopy(a)
这是深copy，独立全新的。
切片 就相当于 浅copy
（机器代码中是不会出现变量名的；变量名是给我们程序员操作内存来使用的。）
（变量名在运行期间是不占内存的，在编译期间是占内存的。）
对于编译器，它会搜集我们的变量名，比如我们定义了一个全局的int a;那么编译器都为我们做了什么呢？
它会为程序预留4个字节的空间（假设在32位平台），并把我们的变量名“a”保存进符号表，并用这个符号表的索引对应实际的空间。 如果下面出现b = a;那么它就会根据符号表找到变量的真正的物理位置，取得它的值，赋给b。
这是写编译器需要做的，我们需要建立符号表。
但是实际在汇编层次上，操作的都是地址而已，不存在任何名称了。
6. gbk 转化 utf-8
unicode 转化 utf-8 ： s.encode('utf-8')
s.decode('utf-8')
s = b'abcdefg' ('utf-8')
s3 = s.decode('utf-8').encode('gbk')
come on！