python数据类型

数值

内存溢出？？？

int**2 容易内存溢出？？
建议使用额外的空间进行运算
y=func(x)
return y*y

bool类型

bool类型是数值类型的子类型（实际上是int类型的子类），可以与数值类型进行运算，包括逻辑运算和位运算（注意逻辑运算时候的特点，与平常理解的不太一样，其实区别也不大）

1 == True # True
1 is True # False
0 == False # True
0 is False # False

类型转换

注意隐式转换，floar转换成int会被截断，不是四舍五入

# 下面都是可以的
int(float_data)
int(str_data)
float(int_data)
float(str_data)

列表

由一系列按特定顺序排列的元素组成，可以将任何东西加入到列表中，其中的元素可以没有任何关系，
（我的理解是列表相当于matlab中的元胞数组）

索引方式

主要是在后面加上[] 并从0开始索引
注意索引是从0开始的而不是从1开始的

z=[1,2,3,4]
z[0]
z[-2]#-1表示最后一个元素，-2表示导数第二个元素
#切分列表，范围索引
z[0:2]#注意，不包含下标为2的元素，只有[0]和[1]
z[:3]#从开头开始到下标为2，不包括[3]
z[1:]#从下标为1开始，到最后一个结束

#还可以这样初始化
candidates = list(range(0, 5))
candidates

data[:]

b=a[:] # 相当于创建一个副本，不同于b=a

负数索引注意事项

a=list(range(10))

# 中间默认为列表末尾
# 第三个-1 表示反向索引
a[::-1] # 自动反转
a[0:9:-1] # [] 没有值
a[5:0:-1] # [5,4,3,2,1] # 永远是右侧取不到值
a[5::-1] # [5,4,3,2,1,0] ！！！ 自动推导！！！ 反向索引
a[10::-1] # [9,...,0] # 超出是索引范围也可以

a[-3:-1:-1] # [] 没有值
a[-1:-3:-1] # [9,8] !!!

a[-1::-1] # 反向索引，自动推导
a[-1::1] # [9] 正向索引

创建/转换列表

创建空列表
列表在不为空的时候返回true

list_1=[]

转换成列表

aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple) #将元组转换成列表
print ("列表元素 : ", list1)

str="Hello World"
list2=list(str) #将字符串中的每个元素转换成列表
print ("列表元素 : ", list2)

list(range(1,5))#将数字转换成列表 本身range(1,5)不会输出什么信息

列表操作

最大最小值求和

#列表最大值，最小值，总和
min(z)
max(z)
sum(z)

统计次数，索引

#对列表中对象出现次数统计
random_list=[4,1,5,4,10,4]
random_list.count(4)#统计4出现的个数
help(random_list.count)#count函数范围列表中值出现的个数
random_list.index(4,5,6)#index检查元素是否存在，检查范围为[5,6]相当于只有5，表示从下标5开始到结尾结束

列表长度

len(list)

reverse 翻转迭代

数字排序

#对列表进行排序
x=[3,7,2,11,8,10,4]
x.sort()
#对列表操作后，系统不会直接进行输出
#下面是两种输出方法
x
print(x)

sort可以应用于字符串，默认是按首字母的顺序（见下），sort是本地操作，即永久性排序

字符串列表排序

#对字符数组进行排序
y=['Steve', 'Rachel', 'Michael', 'Adam', 'Monica', 'Jessica', 'Lester']
y.sort()
y
print(y)

翻转排序

#反转排序
y.sort(reverse=True)
y
help(y.sort)#sort默认为升序

临时排序

new_list=sorted(y)
new_list
help(sorted)

y#升序
y.sort()#默认为升序，不可打印
y#升序，可打印
sorted(y,reverse=True)#设定为降序，可打印，说明是新生成一个列表
y
sy=sorted(y,reverse=True)#设定为降序，赋值，不可打印，说明是新生成一个列表
sy

添加删除元素

末尾添加元素

#在列表结尾添加一个对象
x
x.append(3)
x

extend()
不同于append

append可以添加单个元素
extend只能添加可迭代对象

#延长列表
x.extend([4,5])#在末尾加4和5
x

列表中插入元素

x=[2,3,4,5]
x.insert(0,1)
print(x)

同时插入多个元素是貌似会当成一个整体

切片赋值操作

http://c.biancheng.net/view/2210.html

列表拼接

list是可变对象 += 是inplace操作，所以id不变

删除列表元素

del

x=[2,3,4,5]
x.insert(0,[1.,10])
del x[0]
print(x)

pop

在不加参数的时候删除末尾的元素

x=[1,2,3,4,5]
print(x)
x_pop=x.pop()
print(x_pop)
print(x)

可以删除任意位置的元素

x.pop(2)
print(x)

注意索引是从1开始的

remove

根据已知的数值来删除，而不是根据索引

#删除列表中的一个对象
x.remove(10)
x

remove只删除一次，如果列表中包含多次，则需要循环进行删除，且元素必须存在

clear

删除列表全部元素

列表翻转

翻转，就是倒序打印，但是不排序

x.reverse()
print(x)

永久性翻转

遍历列表

x=[1,2,3,4,5]
x.insert(0,[11,22])
print(x)

for i in x:
    print(i)

按顺序将x列表中的元素赋值给i,并打印
注意着里边第一个i是一个子列表

range

range(1,5) #只会遍历1-4

range(-1,-10,-1) # -1 ~ -9

指定步长

list(range(2,11,2))#步长为2

列表拷贝copy()浅拷贝，不完全拷贝

不完全拷贝指的是，只复制了最外层的容器，副本中的元素是源容器中元素的引用
!!! 无论是深拷贝还是浅拷贝，id()前后均不相同（注意对可变类型id()不相同，对不可变类型id()相同）
!!! 要讲深浅拷贝的id()变化 和 inplace的id()变化分开来看

a=list(range(10))
b=a.copy() # 是深拷贝

a=[1,2,[3,4]]
b=a.copy()

a[0]=10
a[2][0]=5
print(a) # [10,2,[4,4]]
print(b) # [1,2,[5,4]]

# id()
# !!! 无论是深拷贝还是浅拷贝，id()前后均不想用
# !!! 要讲深浅拷贝的id()变化 和 inplace的id()变化分开来看
id(b) 不等于 id(a)
c=a # id(c)==id(a)
d=list(a) # 当a是list的时候，创建一个副本，id(d) 不等于 id(a)
e=a[:] # 相当于创建一个副本，不同于b=a 且 id(e) 不等于id(a)

元组

元组是一种序列，就想列表一样。元组和列表之间的区别在于，列表可变，元组不可更改。元组用括号，列表使用方括号
元组不可以改变，即元组中的元素不可以改变，但是整个元组可以整体改变

需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串

初始化

#元组初始化
#初始化空元组
emptyTuple=()
#使用元组函数初始化空元组
emptyTuple=tuple()

z=(3,7,4,2)#如果要创建仅包含一个值的元组，则需要在项目后面添加一个逗号
z

tup1=('michael',)#没有逗号就变成了字符串
tup1

访问元组中的值

切片方式

从0开始

z[0]
#-1表示最后一个元素

count 和 index

animals=('lama','sheep','lama',48)
animals.index('lama')#索引默认出现的第一个位置
animals.count('lama')#计算出现的个数

index的高级用法http://c.biancheng.net/view/7118.html

拼接/ +=

tuple可以有+=拼接运算
但是+=不是inplace运算，会生成新的内存地址

切分元组

返回新元组（子集）

#切分元组
z[0:2]#表示下标0和1
z[:3]#表示下标0,1,2
z[-2:-1]#表示的不是最后一个元素，[-1]表示的是最后一个元素，现在表示的是-2这个元素，而不包括-1这个元素

遍历元组

for item in ('lama', 'sheep', 'lama', 48):
    print(item)

元组拆包

x, y = (7, 10);
print("Value of x is {}, the value of y is {}.".format(x, y))#{}表示要显示的元素

a,b,*b=range(5) #拆包后 b 是列表：[2,3,4,5]
# 即使是单个元素也是列表
a,b,*b=range(3) #b:[2]

元组没有copy方法

元组与列表

元组可变，列表不可变
元组比列表更快，如果定义一组常量值，
元组可以作为字典键，列表不可以作为字典键
元组可以是集合中的值{}，列表不可以是集合中的值

！！！

元组中的列表是可变的https://www.byhy.net/tut/py/basic/07/
这是因为python的 对象存储机制与变量引用机制造成的 https://www.bilibili.com/video/BV1QE411N7c5?p=2&spm_id_from=pageDriver

拆包注意事项

a=tuple(range(3)) # 元组
b=list(range(3)) # 列表

# 无论是tuple还是list，拆包之后，不定长数据都是list，即使是一个元素，也是list类型（没有tuple）类型
m,n,*q=a # q:[2],list
x,y,*z=b # z:[2],list

copy()拷贝

list拷贝是深拷贝
tuple没有copy()属性

slice切片

slice 是内置类型（类），创建后返回一个slice对象

# slice(start,stop[step])
slice(None,None,None) 

a=list(range(10))
a[::] # 等价于a[slice(None,None,None)]
a[::2] # 等价于a[slice(None,None,2)] 

# slice 进阶
# 对于二维数据
b[1:4:2,9] # 等价于b[slice(1,4,2),9] # index可以是(slice(1,4,2),9)
b[1:4:2, 7:9] # 等价于b[slice(1,4,2),slice(7,9,None)] # index可以表达成(slice(1,4,2),slice(7,9,None))

slice.indices(len)
# len 表示规定要索引的终止长度

枚举

枚举函数返回一个元组，其中包含每次迭代的计数（从默认为0的开始）和迭代序列获得的值

friends = ('Steve', 'Rachel', 'Michael', 'Monica')
for index, friend in enumerate(friends):# 先定义一个元组然后，enumerate()为枚举函数
    print(index,friend)

斐波那契数列

a,b = 1,1
for i in range(10):
    print("Fib(a): ", a, "b is: ", b)
    a,b = b,a+b  #直接按顺序赋值操作

字符串

正确写法

# 单引号套双引号
'xxx,"yyy",zzz':str
# 双引号套单引号
"xxx,'yyy',zzz":str

大小写

#字符大小写转换
print(firstValue.lower())#变小写
print(firstValue.upper())#变大写
print(firstValue.title())#首字母大写

查找子串

• find() 方法 从头开始
• rfind() 方法 从末尾开始
• index() 方法
• rindex() 方法

r’'非转义

a=r'\n'
b=r'\t'
print(type(a),len(a)) # str, 2
c='\t'
print(c,type(c),len(c)) # 直接显示制表位,str,1 # 因为是一个字节，所以是1位
print(b) # \t

字符串对齐方法

http://c.biancheng.net/view/5664.html

字符编码

查看当前字符编码–chardet模块

import chardet

http://c.biancheng.net/view/4305.html

字符集：用数字代表文字符号的规范

编码：按照规则将字符以二进制存储在计算机中
解码：将存储在计算机中的二进制数按照规则解析成字符

字符集与字符编码之间的关系 – 待思考

字符集规定了字符与二进制之间的对应关系
字符编码规定如何将二进制存储到计算机中
例如：unicode是字符集，只是定义了字符与二进制编码之间的关系，而字符编码机制是utf-8或utf-32等方法，即为了内存效率的问题，并不是直接将字符的二进制编码存储到计算机中，而是通过一套转换机制进行转换，在读取的时候再经过一次逆向转换，（这套转换方法叫做字符编码）（必须使用几个字节存储，解码的时候几个字节为一个单位）
utf-8的编解码机制，见《c语言教程pdf》

字符对象/字节对象/bytes()/encode()/decode()

字符串：以字符串以字符为单位，字符串是不可变对象
字节串：以字节为单位，字节串是不可变对象

bytes()方法

以字节序列（字节串）的形式（二进制形式）存储数据
bytes类型的对象，即字节串，只记录内存中的原始数据，
无论是否是ASCII还是utf-8编码，对于ASCII字符，bytes()或者是encode()转换后，返回的是b'certain_string'形式，否则（非ASCII字符）返回的是b'\x十六进制数\x十六进制数'
在创建字节串对象时，bytes()不接受字符串对象，必须先进行编码

# 要想利用bytes编码字符串，必须指定编码字符集，参数encoding=xxx # 'utf8'
bytes('certain_string',encoding='utf8')

字节串与字符串之间的转换
encode()按指定的字符集(字符编码方式)，将字符编码成对应的字节bytes对象
decode()按指定的字符编码方式，将字节对象转换为字符对象

字节串对象的字面量表示方法

虽然二进制序列是整数序列，（以字节为单位（0-255）），但是在字面量表达（表示）上并不是以整数的表达

• 对于符合ASCII字符编码的字符，直接使用ASCII字符本身进行表达（显示）
• 可转移的制表符、换行符等，利用使用转义字符进行表达（显示）
• 其他字节的值，使用十六进制转义序列

编解码异常

certain_str.encode('utf8',errors='replace') # 当遇见该字符集无法编码的情况时，将无法编码的字符替换为？

certain_bytes.decode('utf8',errors='replace') # 当遇到不属于该字符集的无效的字符时，将无法解码的字符替换成未知字符

chr/ord

都是以unicode字符集作为编码规范的
只能作用于于单个字符，及其对应进制数

https://blog.csdn.net/qq_29720657/article/details/102761356
https://blog.csdn.net/LHJCSDNYL/article/details/122237281
https://blog.csdn.net/authorized_keys/article/details/90079941?

chr()返回十进制或十六进制（可以传入十进制数或十六进制数）的unicode编码
ord()返回unicode编码的进制数

chr/ord/encode/decode的关系？？？

# 对于ASCII字符，可以互相逆推
'h'.encode('utf-8') # b'h'
'h'.encode('utf-8').hex() # '68' # 十六进制数
int('68',16) # 将其转换成十进制数 # 104
chr(104) # 'h'
ord('h') # 104

# 对于非ASCII字符，可能存在问题
'€'.encode('utf8') # b'\xe2\x82\xac'
'€'.encode('utf8').hex() # 'e282ac'
int('€'.encode('utf8').hex(),16) # 14844588
ord('€') # 8346
chr(8346) # '€'???

字节串对象方法

见python进阶

字节/进制/数据

8位二进制 对应 2位十六进制
1个字节=8位(bit)
进制下表示的是仍是数字

字符集规定了 不同字符对应不同的数字，然后数字由（可选的，其实就是规定好的）的进制进行表示

数据是以字节形式存储的，一个字节可以由（可选的不同的）进制进行表示（也就是实际上依然是二进制01存储，但是可以通过不同的进制进行表示）

字节是单位，一个字节可以表示（包括）8位二进制数或2位十六进制数
进制数才是底层存储的数据，十六进制是二进制数的另一种表达方式

字节串对象不等于字符的进制数表示（在显示上）
实际数据传输（硬件、协议）过程中，要看传输的是加工后的字节串，还是原始的进制数

'hello'.encode('utf8') # 编码成字节串对象后仍然是b'hello',这是因所有字符符合ASCII字符集，所以显示的时候，可以直接用原字符串进行表示

# 转换为十六进制数，这才是低层存储的原始数据
'hello'.encode('utf8').hex() # 十六进制数 68656c6c6f

'你'.encode('utf8') # b'\xe4\xbd\xa0'
'你'.encode('utf8').hex() # 十六进制数 'e4bda0'

注意

'你'.encode() # b'\xe4\xbd\xa0' type:bytes
len('你'.encode()) # 3 这是3个字节
'你'.encode().hex() # 'e4bda0' type: str
len('你'.encode().hex()) # 6

hex()/fromhex()

https://www.byhy.net/tut/py/basic/12/
hex()将字节串转换为进制数（注意这里的进制数是字符串的形式）
bytes.fromhex()将进制数(字符串形式)转换字节串（用于构建二进制序列，可以有空格可以没有空格）

进制转换

查看进制转换的函数，可以更好的理解进制数，与编码
https://blog.csdn.net/weixin_43353539/article/details/89444838
https://blog.csdn.net/qq_46119688/article/details/122640639

I/O文本与二进制模式

https://blog.csdn.net/L_fengzifei/article/details/105156001

正则表达式

正则表达式在线验证工具

https://c.runoob.com/front-end/854/
https://regex101.com/

正则

https://www.byhy.net/tut/py/extra/regex/

一般写法

import re
p=re.compile(r'正则表达式',re.M|re.MULTILINE|re.DOTALL)

for match in p.finall(content): # for match in p.finditer(content)
	pass

.certrainStr # 点 匹配符，用于匹配换行符外的任何单个字符

certrainStr.* # 星 匹配符，用于匹配前面的子表达式任意次，注意要加.，可以匹配0次

certainStr.+ # 加 匹配符，用于匹配前面的子表达式任意次，不包括0次

certrainStr.? # 问 匹配符，用于匹配前面的子表达式0次或者1次

certrainStr{1,2} # 花括号，用于匹配前面的字符连续的指定次数，最少1次最多2次

# 上述* + ? （元字符）都是贪婪的匹配，即尽可能多的匹配内容

# 非贪婪方法
certrainStr.*?

# 匹配特殊字符时要用到转义字符\

#匹配其他字符类型
\d # 0-9之间任意数字字符，等价于[0-9]
\D # 匹配任意一个不是0-9之间数字字符，等价于[^0-9]
\s # 匹配任意一个空白字符，空格、tab、换行符，等价于[\t\n\r\f\v]
\S # 匹配任意一个文字字符，等价于[^\t\n\r\f\v]
\w # 匹配任意一个文字字符，包括大小写字母、数字、下划线，等价于[a-zA-Z0-9]
\W # 匹配任意一个非文字字符，等价于表达式[^a-zA-Z0-9]
 
[\certrain] # 匹配任意多个上述提到的字符

[] # 方括号，匹配指定的几个字符，元字符在[]中失效
[^] # 匹配非指定的字符

^ # 匹配文本的开头位置 re.M表示多行模式
$ # 匹配文本的结尾位置

() # 括号，组选择，在根据正则表达式匹配后的结果中再分成组
   # (.*), # 以.*,为正则表达式，并将其中的(.*)内容作为一组，最后的匹配结果就是组
   # 多组匹配时：https://www.byhy.net/tut/py/extra/regex/
   # (?P<name>组正则表达式）

.匹配换行 # https://www.byhy.net/tut/py/extra/regex/
         # compile(r'正则表达式',re.DOTALL)

# https://www.byhy.net/tut/py/extra/regex/
re.split(r'') # 比str.split更加高级的字符分割方法
re.sub()

字典

将键key映射到value的无序数据结构
值可以任何值：列表、函数、字符串、任何东西
key必须是不可变的：数字、字符串、元组

散列对象/散列表

见 python-进阶
见python-数据结构

创建字典

• {} 形式
  创建空字典alien={}

#定义一个字典
webstersDict = {'person': 'a human being, whether an adult or child', 'marathon': 'a running race that is about 26 miles', 'resist': ' to remain strong against the force or effect of (something)', 'run': 'to move with haste; act quickly'}
webstersDict
#一个冒号连接一个key和一个value

• dict() 形式

dict(a=1,b=2) # {'a': 1, 'b': 2} 会自动转换成字符串形式

dict(zip(['a','b'],[1,2]))  # {'a': 1, 'b': 2} 自动拆包

dict([('a',1),('b',2)]) # {'a': 1, 'b': 2}，新式方法

dict({'a':1,'b':2}) 

• fromkeys() 形式

keys=['a','b']
values=1
dict.fromkeys(keys,values) # {'a': 1, 'b': 1} 自动广播 
values=[1,2]
dict.fromkeys(keys,values) # {'a': [1, 2], 'b': [1, 2]}

访问字典

• [] 形式

#访问一个值
#dictionary[key]
webstersDict['person']

• .get() 形式
  返回None，以及异常处理机制

#get()函数，如果键存在，则返回原始设定的值，如果不存在则为键key设定默认值
storyCount.get('Michael')
storyCount.get('Michael',0)
storyCount.get('run',0)#虽然设定了默认值但是不会自动加入到字典中，只是返回设定的默认值

copy()方法

注意，字典的拷贝只能是浅拷贝，不是完全拷贝
注意复制和就地操作的区别
http://c.biancheng.net/view/4380.html

a={'1':100,'2':[1,2]}
b=a.copy()

a['1']=200
a['2'][0]=3

print(a) # {'1':200,'2':[3,2]}
print(b) # {'1':100,'2':[3,2]} # 注意copy之前的区别

更新字典

#更新字典
#直接定义键值和value,默认在末尾添加
webstersDict['shoe'] = 'an external covering for the human foot'
webstersDict
webstersDict['shoe']

update
https://www.byhy.net/tut/py/basic/17/

webstersDict
#同时更新多个键值，更新重复的键时，覆盖掉，最终不会有重复的内容
webstersDict.update({'shirt': 'a long- or short-sleeved garment for the upper part of the body'
                     , 'shoe': 'an external covering for the human foot, usually of leather and consisting of a more or less stiff or heavy sole and a lighter upper part ending a short distance above, at, or below the ankle.'})
webstersDict

删除字典

del webstersDict['resist']
webstersDict

#删除键但同时可以返回值
count=storyCount.pop('the')
count

popitem() # 注意底层逻辑 

打印字典

#遍历字典
#返回键
print(storyCount.keys())
#返回值
print(storyCount.values())

#迭代遍历键
for key in storyCount:
    print(key)

#迭代遍历键值
for key,value in webstersDict.items():#items表示类似集合的对象
    print(key,value)

注意键-值对的遍历顺序与存储顺序不一样，字典没有顺序

遍历字典中的值可能会出现重复，利用set函数消除字典中重复的值

languages={'1':'python','2':'c','3':'c++','4':'python'}
for value in set(languages.values()):
	print(language.title())

set函数可以找出列表中独一无二的元素，并利用这些元素创建一个集合

集合

https://blog.csdn.net/YKenan/article/details/88357847

• set
• frozenset

集合里边不能是可变对象，list，dict不行

创建集合

• {} 形式 s={1,2,3}
• set() 方法 s=set([1,2,3])

删除集合

del函数

添加元素

certain_set.add()

需要注意的是，使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则 Python 解释器会报 TypeError 错误

集合与字典

集合里的元素必须是可散列的（通俗理解就是元素不能是可变对象），set集合本身是不可散列的，但是不可变集合是frozenset是可散列的

注意{}的使用

a={1} # 集合
b={1:x} # 字典
c={} # 空字典
d=set() #空集合，空集合只能用这种方式进行创建，{}这种方式只能表示空字典

交并差集运算

set1 | set2 # 并集
set1 & set2 # 交集
set1 - se2 # set1中的差集

其他方法

http://c.biancheng.net/view/4402.html

frozenset

不可变集合是frozenset

set集合是可变序列
frozenset是不可变序列
所有set支持的方法，如remove()、discard()、add()等，frozenset都不支持，set中不改变自身集合的方法，frozenset都支持

应用场景：当集合的元素不需要改变的时候，用frozenset代替set，更安全

json

序列化：将数据对象转变为对应的字节串
反序列化：将字节串转换为对应的数据对象

json序列化后是一个字符串

json.dumps() # 数据序列化
json.loads() # 数据反序列化

json.dump() # 序列化到文件
json.load() # 反序列化到文件