python-整理

逻辑运算符：与或非 and or not
and 如果前面的表达式等价为False,后面就没有必要计算了，这个逻辑表达式最终一定等价为False
or 如果前面的表达式等价为True，后面没有必要计算了，这个逻辑表达式最终一定等价为True
赋值运算符：先算右边后再赋值给左边变量
成员运算符： in 、not in
身份运算符： is 、is not

优先级：
算数运算符 > 位运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
单目 > 双目
记不住用括号，长表达式多用括号，易懂易读

表达式Expression: 由数字、符号、括号、变量等的组合
算数表达式
逻辑表达式
赋值表达式 python中，赋值即定义，如果一个变量已经定义，赋值相当于重新定义

内存管理：
变量无须事先声明，也不需要指定类型，这是动态语言的特性
Python编程中一般无须关心变量的存亡，一般也不用关心内存的管理
Python使用引用计数记录所有对象的引用数，当对象引用数变为0，它就可以被垃圾回收GC
计数增加：赋值给其他变量就增加引用计数，例如x=3; y=x; z=[x,1] ;实参传参，如foo(y)
计数减少：函数运行结束时，局部变量就会被自动销毁，对象引用计数减少；变量被赋值给其他对象，例如：x=3; y=x; x=4;
有关性能的时候，就需要考虑变量的引用问题，但是该释放内存还是尽量不释放内存，看需求

for 循环中的 else 关键字指定循环结束时要执行的代码块

round(-2.5) 4舍 6入 5取偶

类型判断：
type(obj) 返回类型，而不是字符串
isinstance(obj, class_or_tuple) 返回布尔值

列表

一个列队，一个排列整齐的队伍

index(value,[start,[stop]])
L9.index(10) ：查询到第一个后就不再遍历，括号中是value，随着列表中元素的增加，index 函数的效率下降，随着列表元素规模的增加，性能下降，有n元素个，时间复杂度，O(n)。匹配不到，抛出异常ValueError

count(value)
L1.count(100) ：返回列表中匹配value的次数，全部遍历 O(n)，随着列表数据规模的增大，而效率下降

len(list)
返回列表元素的个数

max(list)
返回列表元素最大值

min(list)
返回列表元素最小值

append(obj)
在列表末尾添加新的对象 就地修改

insert(index, obj)
将对象插入列表

extend()
L1.extend(rang(7,10)):在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

[[1]] # [address:401] 401住着1 
# 1 、‘abc’ 字面常量，称为简单类型
# [1] 复杂类型，应用类型
l1 = [[1]] * 5  # [ a401 , a401, a401, a401, a401]  [[1],[1],[1],[1],[1]]
l1[0][0] = 100  # 修改的是 a401地址存储的值
l1 
[[100], [100], [100], [100], [100]]

remove(value) -> None
从左至右查找第一个匹配value的值，找到就移除该元素，并返回None，否则ValuError，就地修改

pop([index]) -> item
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误

reverse()
反向列表中元素

sort( key=None, reverse=False)
对原列表进行排序

copy()
复制列表

clear() -> None
清除列表所有元素，剩下一个空列表

随机数：
random模块
randint(a,b) 返回[a,b]之间的整数
choice(seq) 从非空序列的元素中随机挑选一个元素，random.choice(range(10)) 从0到9中随机挑选一个整数。random.choice([1,3,5,7])
randrange([start,]stop[,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1。random.randrange(1,7,2)
random.shuffle(list) -> None 就地打乱列表元素
sample(population, k) 从样本看空间或总体（序列或者集合类型）中随机取出k个不同的元素，返回一个新的列表

三目运算符：
True if 条件 else False

a = 10
b = 15
if a > b:
    a > b
else:
    a < b

a > b if a > b else a < b

exp1 if contion else exp2
condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。

命名元组namedtuple
namedtuple(typename,field_names,verbose=False,rename=False)
命名元组，返回一个元组的之类，并定义了字段，field_names可以时空白符或逗号分割的字段的字符串，可以是字段的列表
同元组一样，命名元组的属性们的值不可变

from collections import namedtuple
Point = namedtuple('Point' , ['x','y'])
p1 = Point(4, 5)   # 一旦赋值 ，不可修改
p1.x , p1.y  # (4, 5)

Student = namedtuple('Student','name age')
tom = Student('tom',20)
jerry = Student('jerry',18)
tom.name , jerry.age  # ('tom', 18)

class A : 
    def __init__(self, x, y):
        self.x = x 
        self.y = y 
    def __repr__(self):
        return "A (x={}, y={})".format(self.x , self.y)
		
a = A(5,6)	
a.x , a.y  # (5, 6)

字符串

一个个字符组成的有序的序列，是字符的集合
使用单引号、双引号、三引号引住的字符序列，是不可变对象
Python3起，字符串就是Unicode类型

0x31   ==>  0011 0001    49 
0x41   ==>  0100 0001    65
0x61   ==>  0110 0001    97

a = 'abc'
a = f'{a}+++'  # 差值 3.6版本以上
a    ## 'abc+++'

range(5)        # 惰性
range(0, 5) 

list(range(5))  # 立即
[0, 1, 2, 3, 4]

map(str, range(5))   # 惰性，可迭代对象
<map at 0x14ab30181c8>

b = R'c:\windos\nt'
":".join(b)   # 用 : 连接 b 中的每一个字符  
'c:::\\:w:i:n:d:o:s:\\:n:t'

",".join(map(str, range(5)))    # join后必须是str
'0,1,2,3,4'

rsplit(sep=None,maxsplit=-1) -> list of strings
从右向左开始切，但是输出的字符串字符不会反
sep指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit指定分割的次数，-1表示遍历整个字符串

s1 = " I'm \ta super student."
s1.rsplit()  #  ["I'm", 'a', 'super', 'student.']
s1.rsplit('s')   # [" I'm \ta ", 'uper ', 'tudent.']
s1.rsplit('s',maxsplit=1)  #  [" I'm \ta super ", 'tudent.']

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

s1 = " I'm \ta super student."
s1.partition('s')   # (" I'm \ta ", 's', 'uper student.')
s1.partition('stu')  # (" I'm \ta super ", 'stu', 'dent.')

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

splitlines()

"""\    
a
b
c
""".splitlines()   # 开头三引号后加反斜线 ，否则多切出一段
['a', 'b', 'c']

'a\n\nb\r\n\r\nc\rd\te'.splitlines()
('a', ' ', ' b')

'a     b'.partition('t')    # 特殊例子 切割符	
('a     b', '', '')

upper() 全大写
lower() 全小写
swapcase() 交换大小写
title() -> str 标题的每个单词都大写
capitalize() -> str 首个单词大写
center(width[,fillchar]) -> str width打印宽度 fillchar填充的字符
zfill(width) -> str width打印宽度，居右，左边用0填充
ljust(width[,fillchar]) -> str 左对齐
rjust(width[,fillchar]) -> str 右对齐

'abc'.upper().lower()    # upper 统一转大写  lower 统一转小写
'abc'

"abC".swapcase()  #大小写转换
'ABc'

str.upper('abc') , 'abc'.upper()
('ABC', 'ABC')

'user-agent'.capitalize()   #  首字母大写
'User-agent'

'user-agent abc'.title() 
'User-Agent Abc'

"abc".center(20,'0')
'00000000abc000000000'

"abc".ljust(20)
'abc                 '

"abc".rjust(20,"0")
'00000000000000000abc'

"abc".zfill(20)
'00000000000000000abc'

replace(old,new[,count]) -> str
字符串中找到匹配替换为新子串，返回新字符串，count表示替换几次，不指定就是替换全部

'www.magedu.com'.replace('w','p')    # 'ppp.magedu.com'
'www.magedu.com'.replace('w','p',2)  # 'ppw.magedu.com'
'x  y'.replace('  ',' ')   # 'x y'

strip([chars]) -> str
从字符串两端去除指定的字符集chars中的所有字符，如果chars没有指定，去除两端的空白字符

'   \n  a bc \t   '.strip() # 默认拿掉字符串两端的所有空白字符
'a bc'

'   \n  a bc \t   '.strip(' ')
'\n  a bc \t'

' \f i am very very very sorry\t\r\n '.strip('\f\t\n\r yiar')
'm very very very so'

' \f i am very very very sorry\t\r\n '.strip('\f\t\n\ryiar')
' \x0c i am very very very sorry\t\r\n '

lstrip([chars]) -> str 从左边开始
rstrip([chars]) -> str 从右边开始

index(sub[,start[,end]]) -> int
在指定的区间[start,end), 从左至右查找子串sub。找到返回正索引，没找到抛出异常ValueError
rindex(sub[,start[,end]]) -> int
在指定的区间[start,end), 从左至右查找子串sub。找到返回正索引，没找到抛出异常ValueError

count(sub[,start[,end]]) -> int
在指定的区间[start,end), 从左至右统计子串sub出现的次数

len(string)
返回字符串的长度，即字符的个数

find、index和count方法都是O(n), 随着列表数据规模的增大，而效率下降

'\t a bc\r\ndef bc'.index('bc',5)   #12  找不到时，返回ValueError
'\t a bc\r\ndef bc'.count('bc')     #2   返回找到几个 没找到时返回0 不报错
'\t a bc\r\ndef bc'.find('abc')     #-1  没有找到时，返回 小于零的数

endswith(suffix[,start[,end]]) -> bool
在指定的区间[star,end) ,字符串是否是suffix结尾
startswith(suffix[,start[,end]]) -> bool
在指定的区间[star,end) ,字符串是否是suffix开头

s = 'I am very very very very sorry'
s.startswith('very',5)    # True
s.endswith('very',5,9)    # True
s.endswith('sorry',5,100) #True

isalnum() -> bool 是否是字母和数字组成
isalpha() 是否是字母
isdecimal() 是否只包含十进制数字
isdigit() 是否全部数字（0~9）
isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
islower() 是否都是小写
isupper() 是否全部是大写
isspace() 是否只包含空白字符

字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
join 拼接只能使用分隔符，且要求被拼接的是可迭代对象且其元素是字符串
"+" 拼接字符串还算方便，但是非字符串需要先转换为字符串才能拼接

format函数格式字符串语法 ———— Python鼓励使用
"{}{xxx}".format(*args, **kwargs) -> str
args是可变位置参数，是一个元组
kwargs是可变关键字参数，是一个元组
花括号表示占位符
{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
{xxx}表示在关键字参数中搜索名称一致的
{{}}表示打印花括号

位置参数：
"{}:{}".format('192.168.1.100',8888),这就是按照位置顺序用位置参数替换前面的格式字符串的占位符
关键字参数或命名参数：
"{server}{1}{0}".format(8888,'192.168.1.100',server='Web Server Info:'),位置参数按照序号匹配，关键字参数按照名词匹配
访问元素：
"{0[0]}.{0[1]}".format(('magedu','com'))
对象属性访问：

from collections import namedtuple
Point = namedtuple('Point' , 'x y')
p = Point(4, 5)    
"{0.x},{0.y}".format(p)   #'4,5'

'{0}'.format(list(range(5)))
'[0, 1, 2, 3, 4]'

'{0[4]}'.format(list(range(5)))
'4'

from collections import namedtuple   
Student = namedtuple('Stu','name  age')
tom = Student('tom', 20)
"{}".format(tom)
"Stu(name='tom', age=20)"

"{0.name} is {0.age}".format(tom)   # 不使用
'tom is 20'

"{} is {}".format(tom.name, tom.age, tom)
'tom is 20'

ip = [192, 168, 1, 127]	
"{} {} {} {}".format(*ip)  # *ip 192, 168, 1, 127
'192 168 1 127'

"{:x} {{{}}}   {:#x} {:#X}".format(*ip) 
'c0 {168}  0x1 0X7F'

对齐：

'{0}*{1} = {2:<2}'.format(3,2,2*3)  # '3*2 = 6 '
'{0}*{1} = {2:<02}'.format(3,2,2*3)  # '3*2 = 60'
'{0}*{1} = {2:>02}'.format(3,2,2*3)  # '3*2 = 06'
'{:^30}'.format('centered')  # '           centered           '
'{:*^30}'.format('centered') # '***********centered***********'

进制：

"int:{0:d}; hex:{0:x}; oct:{0:o}; bin:{0:b}".format(42)
# 'int:42; hex:2a; oct:52; bin:101010'

"int:{0:d}; hex:{0:#x}; oct:{0:#o}; bin:{0:#b}".format(42)
# 'int:42; hex:0x2a; oct:0o52; bin:0b101010'

octets = [192, 168, 0, 1]
'{:02X}{:02X}{:02X}{:02X}'.format(*octets)
# 'C0A80001'

浮点数

"{}".format(3**0.5)  #'1.7320508075688772'
"{:f}".format(3**0.5)  # '1.732051'  精度默认6
"{:10f}".format(3**0.5)  #'  1.732051'  右对齐，宽度10
"{:2}".format(102.231)  # '102.231'  宽度为2数字
"{:.2}".format(3**0.5)  # '1.7'  2个数字
"{:.2f}".format(3**0.5)   #'1.73' 小数点后2位
"{:3.2f}".format(3**0.5)  # '1.73' 宽度为3，小数点后2位
"{:20.3f}".format(0.2745)  # '               0.275'  宽度为20,小数点后3位
"{:3.3%}".format(1/3)  #'33.333%'

x = 2 ** 0.5 
"{}".format(x)
'1.4142135623730951'

"{:.3f}".format(x)
'1.414'

"{:^20.2}".format(x)
'        1.4         '

"{:*^20.2}".format(x)
'********1.4*********'

"{:4.4%}".format(x)
'141.4214%'

"{:e}".format(x)
'1.414214e+00'

"{:2}".format(x)
'1.4142135623730951'

"{:.2}".format(x)
'1.4'

Python3引入两个新类型 bytes bytearray

bytes 不可变字节序列
bytearray 字节数组 可变

字符串与bytes
字符串是字符组成的有序序列，字符可以使用编码来理解
bytes是字节组成的有序的不可变序列
bytearray是字节组成的有序的可变序列

编码与解码
字符串按照不同的字符集编码encode返回字节序列bytes
encode(encoding='utf-8',errors='strict') -> bytes
字节序列按照不同的字符集编码encode返回字符串
bytes.decde(encoding='utf-8',errors='strict') -> str
bytearray.decde(encoding='utf-8',errors='strict') -> str

ASCII (American Standard Code for Information Interchange, 美国信息交换标准代码) 是基于拉丁字母的一套单字节编码系统
\t 0x09
\r 0x0d
\n 0x0a
0~9 0x30~0x39
A~Z 0x41~0x5A
a~z 0x61~0x7A

a = '\x0d\x0a\x09'
a
'\r\n\t'

x = 'abc'
y = x.encode()  # x必须是字符串类型
x,y
('abc', b'abc')


y.decode() # bytes类型对象.decode()  二进制 => str 
'abc'

hex(123)
'0x7b'

utf-8 中文大多数都是3字节
utf-8 是一种多字节编码，适合于网络传输，所以在网络中大量的使用
unicode是双字节编码
utf-8和GBK都兼容ascii码

字符串'1',可以写成 x = '1' ,y ='\x31'
'\x09' 就是 '\t'
'\x0d\x0a' 就是'\r\n', 但是'\x0d0a'表示'\r0a',所以得一个一个字节描述

bytes() 空bytes
bytes(int) 指定字节的bytes，被0填充
bytes(iterable_of_ints) -> bytes[0,255]的int组成的可迭代对象
bytes(string,encoding[,errors]) -> bytes 等价于string.encode()
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer 从一个字节序列或者buffer复制出一个新的不可变的bytes对象
使用b前缀定义，只允许基本ASCII使用字符形式 b'abc9'，使用16进制表示 b"\x41\x61"

和str类型类似，都是不可变类型，所以方法很多都一样。只不过bytes的方法，输入的是bytes，输出的是bytes
b'abcdef'.replace(b'f',b'k') #b'abcdek'
b'abc'.find(b'b') #1

类方法 bytes.fromhex(string) ，string必须是2个字符的16进制的形式，'6161 6a 6b', 空格将被忽略
bytes.fromhex('6162 09 6a 6b00') # b'ab\tjk\x00'

hex() 返回16进制表示的字符串
'abc'.encode() # b'abc'
'abc'.encode().hex() #' 616263'

索引 b'abcdef'[2] # 99 返回该字节对应的数，int类型 , 'c' => \0x63 => 99

bytearray和bytes类型的方法相同
bytearray(b'abcdef').replace(b'f',b'k') # bytearray(b'abcdek')
bytearray(b'abc').find(b'b') # 1

类方法 bytearray.fromhex(string)
string必须是2个字符的16进制的形式，'6162 6a 6' ，空格将被忽略
bytearray.fromhex('6162 09 6a 6b00') #bytearray(b'ab\tjk\x00')

hex() 返回16进制表示的字符串
bytearray('abc'.encode()) # bytearray(b'abc')
bytearray('abc'.encode()).hex() #'616263'

索引 bytearray(b'abcdef')[2] # 99 返回该字节对应的数，int类型

append(int) 尾部追加一个元素
insert(index, int) 在指定索引位置插入元素
extend(iterable_of_ints) 将一个可迭代的整数集合追加到当前byterray
pop(index=-1) 从指定索引上移除元素，默认从尾部移除
remove(value) 找到第一个value移除，找不到抛ValueError异常
注意：上述方法若需要使用int类型，值在[0,255]
clear() 清空bytearray
reverse() 翻转bytearray,就地修改

b = bytearray()
b.append(97)          # bytearray(b'a')
b.append(99)          # bytearray(b'ac')
b.insert(1,98)        # bytearray(b'abc')
b.extend([65,66,67])  # bytearray(b'abcABC')
b.remove(66)          # bytearray(b'abcAC')
b.pop()               # 67   bytearray(b'abcA')
b.reverse()           # bytearray(b'Acba')
b.clear()             # bytearray(b'')

int和bytes
int.from_bytes(bytes,byteorder) 将一个字节数组表示成整数
int.to_bytes(length,byteorder) bytearray字节序 将一个整数表达成一个指定长度的字节数组

i = int.from_bytes(b'abc','big')
print(i, hex(i))    # 6382179 0x616263
print(i.to_bytes(3,'big'))  # b'abc'

b1 = bytearray()
b1.append(97)  # bytearray(b'a')
b1.extend(range(98,100)) # bytearray(b'abc')

线性结构特征：
可迭代 for ... in
有长度，通过len(x)获取，容器
通过整数下标可以访问元素。正索引、负索引、可以切片
sequence[start:stop]
sequence[start:stop:step]
通过给定的索引区间获得线性结构的一部分数据
start、stop、step为整数，可以是正整数、负整数、零
start为0时，可以省略
stop为末尾时，可以省略
step为1时，可以省略
切片时，索引超过上界（右边界），就取到末尾；超过下界（左边界），取到开头
在序列上使用切片[start:stop],子区间索引范围[start:stop],相当于从start开始指向stop的方向上获取数据
默认step为1，表示向右；步长为负数，表示向左
如果子区间方向和步长方向不一致，直接返回当前类型的"空对象"
如果子区间方向和步长方向一致，则从起点间隔步长取值

b = a[i:j]
表示复制a[i]到a[j-1]，以生成新的list对象
a = [0,1,2,3,4,5,6,7,8,9]
b = a[1:3] # [1,2]
当i，j都缺省时，a[:] 就相当于完整复制一份a

b = a[i:j:s]
表示：i,j与上面的一样，但s表示步进，默认为1
所以 a[i:j:1] 相当于 a[i:j]

当s<0时，i 缺省时，默认为-1. j 缺省时，默认为-len(a)-1
所以a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序

a='abcdef'

b=a[::-1]
print(b)    #fedcba

c=a[::-2]
print(c)   # fdb

封装（装箱）

将多个值使用逗号分割，组合在一起，本质上，返回一个元组，只是省掉了小括号
python特有语法，被很多语言学习和借鉴

t1 = (1, 2) 
t2 = 1, 2
type(t1)  # tuple
type(t2)  # tuple

nums = [1,2]
nums[1],nums[0] = nums[0],nums[1]
print(nums)  # [2, 1]

a, *b = 1,2,3,4,5
a, b  # (1, [2, 3, 4, 5])

a, *b ='xyz'
a, b # ('x', ['y', 'z'])

x, [a, b], z = 1, [2, (3, 5)], (2,6)
x, a, b, z  # (1, 2, (3, 5), (2, 6))

* 代表零个或任意个

for x,*y in ((1,), [2,3], (4,5,7), [6]):
    print(x,y)
1 []
2 [3]
4 [5, 7]
6 []

解构

a,*b = (1,2,3)  # (1, [2, 3])
a,b = (1,2,3)   # ValueError: too many values to unpack (expected 2)
a,b = {'a':10, 'b':20}   #非线性解构也可以解构  解构出key

使用 *变量名接收，但不能单独使用，也不能出现多个
被 *变量名 收集后组成一个列表

head, *mid, tail = range(6)
head, mid, tail  # (0, [1, 2, 3, 4], 5)

丢弃变量
这是一个惯例，一个不成文的约定，不是标准
如果不关系一个变量，就可以定义该变量名为 ""
""是一个合法的标识符，也可以作为一个有效的变量使用，但是定义成下划线就是希望不要被使用，除非你明确的知道这个数据需要使用

lst = [9,8,7,20]
first, *second = lst
head, *_, tail = lst 
print(head)  # 9 
print(tail)  # 20
print(_)  # [8, 7]

"_" 是合法的表示符，看到下划线就知道这个变量就是不想被使用

_, *_, _, c = range(5)
c  # 4 

""这个变量本身无任何语义，没有任何可读性，所以不是用来给人使用的
Python中很多库，都使用这个变量，使用十分广泛。请不要再不明确作用域的情况下，使用""导致和库中"_"冲突

集合set

collection 翻译为集合类型或容器，是一个大概念
set 可变的、无序的、不重复的元素的集合
set() -> new empty set object
set(iterable) -> new set object

s1 = set()  # set()  空集合
s2 = set(range(5))  # {0, 1, 2, 3, 4}
s3 = set(list(range(5)))  # {0, 1, 2, 3, 4}
s4 = {}  # {}
s5 = {9,10,11}  # {9, 10, 11}
s6 = {(1,2), 3, 'a'}  # {(1, 2), 3, 'a'}
s7 = {[1], (1,), 1}   # unhashable type: 'list'

set定义时不能出现 list bytearray dict set 类型 （不可hash）

set的元素要求必须可以hash
元素不可以索引
set可以迭代

set增加
add(elem) 增加一个元素到set中，如果元素存在，什么都不做
update(*others) 合并其他元素到set集合中来，参数others必须是可迭代对象，就地修改

s1 = set(range(5))  # {0, 1, 2, 3, 4}
s1.add(4)           # {0, 1, 2, 3, 4}
s1.add(5)           # {0, 1, 2, 3, 4, 5}
s1.add((1,2))       # {(1, 2), 0, 1, 2, 3, 4, 5} 
s1.add((2,1))       # {(1, 2), (2, 1), 0, 1, 2, 3, 4, 5}
s1.add((1,2))       # {(1, 2), (2, 1), 0, 1, 2, 3, 4, 5}

t2 = 'a','b','c'
s1.add(t2)    # {('a', 'b', 'c'), (1, 2), (2, 1), 0, 1, 2, 3, 4, 5}

s2 = set(range(8))   # {0, 1, 2, 3, 4, 5, 6, 7}
s1.update(s2)   #  {('a', 'b', 'c'), (1, 2), (2, 1), 0, 1, 2, 3, 4, 5, 6, 7}

s1.update(s2, range(10,15))  # {('a', 'b', 'c'), (1, 2), (2, 1), 0, 1, 10, 11, 12, 13, 14, 2, 3, 4, 5, 6, 7}

s3 = set(list(range(100,105)))  # {100, 101, 102, 103, 104}
s2 + s3                         # unsupported operand type(s) for +: 'set' and 'set'

set 不可以相加，加的概念是合并

set删除
remove(elem) 从set中移除一个元素，元素不存在，抛出异常KeyError异常
discard(elem) 从set中移除一个元素，元素不存在，什么都不做
pop() -> item 移除并返回任意的元素
clear() 移除所有元素

s3 = set(list(range(100,105)))  # {100, 101, 102, 103, 104}
s3.remove(102)         # {100, 101, 103, 104}
s3.remove(105)         #  KeyError: 105
s3.discard(105)        # 不出错版本的remove

s3   # {100, 101, 103, 104}
s3.pop()   # 100  随机弹出
s3   # {101, 103, 104}

set 是非线性结构，无法索引，可以迭代所有元素
in 和 not in 判断元素是否在set中

list和set的效率比较

l1 = list(range(100))
l2 = list(range(1000000))
%timeit (-1 in l1)
968 ns ± 9.55 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit (-1 in l2)
9.45 ms ± 67 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

l1 = set(list(range(100)))
l2 = set(list(range(1000000)))
%timeit (-1 in l1)
42.1 ns ± 1.78 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%timeit (-1 in l2)
40.8 ns ± 1.77 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

线性结构的查询时间复杂度是O(n), 即随着数据规模的增大而增加耗时
set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1),查询时间和数据规模无关

可hash
数值型 int float complex
布尔型 True False
字符串 string bytes
tuple
None
以上都是不可变类型，成为可哈希类型，hashable
set的元素要求必须可以hash

解释器每次运行拿到的hash值不一样，去重时，hash值一样，就不添加

集合运算
并集：将两个集合A和B的所有元素合并到一起，组成的集合称作集合A与集合B的并集
union(*others) 返回和多个集合合并后的新的集合
| 运算符重载 等同union
update(*others) 和多个集合合并，就地修改
|= 等同update

交集：集合A和集合B，由所有属于A且属于B的元素组成的集合
intersection(*others) 返回和多个集合的交集
& 等同 intersection
intersection_update(*others) 获取和多个集合的交集并就地修改
&= 等同intersection_update

差集：集合A和集合B，由所有属于A且不属于B的元素组成的集合
difference(*others) 返回和多个集合的差集

•                       等同difference
  

difference_update(*others) 获取和多个集合的差集并就地修改
-= 等同difference_update

对称差集：集合A和集合B，由所有不属于A和B的交集元素组成的集合，记作(A-B)∩(B-A)
symmetric_differece(other) 返回和另一个集合的对称差集
^ 等同symmetric_differece
symmetric_differece_update(other) 获取和另一个集合的对称参集并就地修改
^= 等同symmetric_differece_update

字典dict

key-value键值对的数据集合 可变的、无序的、key不重复
d = dict() 或者 d = {}
dict(**kwargs) 使用 name=value对 初始化一个字典
dict(iterable, **kwargs)使用可迭代对象和 name=value对 构造字典，不过可迭代对象的元素必须是一个二元结构 d = dict(((1,'a'),(2,'b'))) d = dict([(1,'a'),(2,'b')], c=300)
dict(mapping, **kwargs) 使用一个字典构建另一个字典
d = {'a':10, 'b':20, 'c':None, 'd':[1,2,3]}
类方法 dict.fromkeys(iterable, value) d = dict.fromkeys(range(5)) d = dict.fromkeys(range(5), 0)

d[key] 返回key对应的值value, key不存在抛出KeyError异常
get(key[, default]) 返回key对应的值value, key不存在返回缺省值，如果没有设置缺省值就返回None d1.get(4,'kong')
setdefault(key[, default]) 返回key对应的值value; key不存在, 添加kv对, value设置为default, 并返回default, 如果default没有设置, 缺省为None d1.setdefault(2,'ef')

d[key] = value 将key对应的值修改为value, key不存在添加新的kv对
update([other]) -> None 使用另一个字典的kv对更新本字典，key不存在就添加，key存在则覆盖已经存在的key对应的值，就地修改 d2.update({5:'ad'}) d2.update((('red',3),)) d2.update(red=1)

pop(key[, default]) key存在，移除它，并返回它的value; key不存在,返回给定的default; default未设置，key不存在抛出KeyError异常
popitem() 移除并返回一个任意的键值对，字典为empty,抛出异常KeyError异常
clear() 清空字典

a = True
b = [1]
d = {'a':1, 'b':b, 'c':[1, 3, 5]}
a, b, d    # (True, [1], {'a': 1, 'b': [1], 'c': [1, 3, 5]})
del d['c']   # (True, [1], {'a': 1, 'b': [1]})

看着像删除了一个对象，本质上减少了一个对象的引用，del实际上删除的是名称，而不是对象

字典遍历
for ... in dict 遍历item,即kv对 d.keys() d.values()
for item in d.items():
pirint(item)
for item in d.items():
pirint(item[0], item[1])
for k,v in d.items():
pirint(k, v)
for k,_ in d.items():
pirint(k)
for _,v in d.items():
pirint(v)
for 里面允许修改值，但长度不能变化。使用到keys values items ，就不能进行kv对增加和kv对减少
while 里可以删除，修改字典长度。因为没有用到keys values items 方法

Python3中，keys、 values、 items方法返回一个类似一个生成器的可迭代对象，不会把函数的返回结果复制到内存中
Dictionary view对象，可以使用len()、 iter()、 in 操作
字典的entry的动态的视图，字典变化，视图将反映出这些变化
keys返回一个类set对象，也就是可以看做一个set集合。如果values都可以hash，那么items也可以看做是类set对象

字典的key
key的要求和set的元素要求一致，set的元素可以就是看做key，set可以看做dict的简化版
hashable可哈希才可以作为key，可以使用hash()测试

dict从3.6 按录入序记录，但实际hash值千差万别

__EOF__

本文作者：何时&明月
本文链接：https://www.cnblogs.com/kiyalone/p/16175156.html
关于博主：当你发现自己的才华支撑不起野心时，就请安静下来学习吧！
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！