HuaPu在学：Python基础知识—PyCharm版【可变字符 & 基本运算符 & 序列】

---

前言

“花圃记录学习日常”。刚开始走上Python之路，以下都是入门基础内容的一些要点笔记。

---

一、可变字符串

之前我们说到在python中字符串定义之后，是不可以修改的，新的字符串其实代表生成了一个新的对象，有了新的变量指向，原来的进行回收。不支持修改，但我们确实需要原地修改，不希望生成新的对象，可以使用io.StringIO对象或者array模块。

>>>import io
>>>s="HuaPu learning"
>>>sio=io.StringIO(s)
>>>sio
<_io.StringIO object at 0x00000246F159E3B0>

>>>sio.getvalue()
'HuaPu learning'
>>>sio.seek(6)
6
>>>sio.write("L")
1
>>>sio.getvalue()
'HuaPu Learning'

二、基本运算符（补充）

1.比较运算符

比较运算符可以连用

2.位操作符

“| ^ &” 按位或（全0为0）、按位异或（相同为1不同为0）、按位与（全1取1），二进制的显示函数bin()。

“<< >>”左移右移，左移1位*2，右移1位/2。

3.运算符的优先级

乘除优先加减
位运算、算术运算>比较运算>赋值运算>逻辑运算

三、序列

序列是一种数据存储的方式，用来存储一系列数据。序列的类型包括字符串、列表、元组、字典、集合。
要强调的是：
1、字符串和列表都是序列类型，前面很多对于字符串的操作，对于列表而言同样也是适用的，例如切片操作。
2、Python中的列表对象大小是可以变化的，根据需要调整。
通过一个例子说明Python内部是如何进行存储：

我们可以这么理解，首先"python中一切皆对象"。我们定义一个列表a=[1,2,3,4]，这其中1，2，3，4是四个对象，他们分别由自己的ID/TYPE/VALUE，我们可以看到的显示的只是VALUE的部分，那么相应的列表本身就是一个对象，这个对象包含了1，2，3，4这四个对象的地址，那么列表这个对象又被a变量指向，也就是说变量a里是列表的地址。

1.列表

列表生成的四种方式：
（1）直接定义
（2）list()强制转换
（3）借助range()随机生成
（4）推导式生成

>>>a=[]
>>>a
[]
>>>a=[1,2,3,4]
>>>a
[1, 2, 3, 4]

>>>b="HuaPu"
>>>list(b)
['H', 'u', 'a', 'P', 'u']

>>>list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>list(range(2,10,2))
[2, 4, 6, 8]
>>>list(range(10,2,-2))
[10, 8, 6, 4]
>>>list(range(-10,-30,-2))
[-10, -12, -14, -16, -18, -20, -22, -24, -26, -28]

>>>c=[x*2 for x in range(100) if x*2%10==0]
>>>c
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190]

列表元素的增加与删除：
（1）.append()函数在列表的尾部增加元素，注意仅能增加一个对象元素
（2）加法操作，加法操作可以直接让两个或者多个列表增加，但会创建多个对象
（3）.extend()函数可以将另一个列表对象增加到源列表的尾部，不创建新的对象
（4）乘法操作，与字符串类似
（5）.insert()函数可以在指定的索引位置插入指定的元素，但这里【注意对于在某一个位置插入元素，会涉及到这个索引值后面的元素的地址的变化，而且是成批量的变化，那么显然如果数据较大，效率就会被拉下来，所以一般我们做尾部的增加或删除或移动是效率比较高】

（6）del删除，实际上是删除指定索引位置上的元素，但仍然还是注意，对于插入也好移动、删除也好，都要做批量的拷贝移动，所以效率会降低。
（7）pop()方法，pop(）删除并返回所删除的元素值。默认是弹出最后一个元素。pop()中是索引不是具体值。
（8）remove()删除首次出现的元素，注意()里面是元素，不是索引值。不存在会报错。

>>>a=[1,2,3]
>>>a
[1, 2, 3]
>>>a.append(4)
>>>a
[1, 2, 3, 4]
>>>id(a)
2503720995584

>>>c=a+[5]
>>>c
[1, 2, 3, 4, 5]
>>>id(c)
2503719409984

>>>a.extend([5,6])
>>>a
[1, 2, 3, 4, 5, 5, 6, 5, 6]
>>>id(a)
2503720995584

列表元素访问和计数：
（1）切片操作即截取子列表[start：end：step]，索引值 a[k]，k是元素的索引值，依然包头不包尾
【注意仍然可以有索引值为负的操作，也就是从右start，偏移量的end超-1.或是起始start<0，都不会报错，自动默认到尾巴或从头开始】

>>>a=[1,2,3,4,5,6,7,8,9]
>>>a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a[1:5:1]
[2, 3, 4, 5]
>>>a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a[-5:-3]
[5, 6]
>>>a[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

（2）.index(value,[start,[end]]),某个value在start到end范围内的首次出现位置。[]代表可选，最外层最大，逐次降低。
（3）.count()某元素出现次数
（4）成员资格判断 in 返回bool值

列表排序：
（1）修改原列表，不生成新对象.sort(列表，reserve=True\Flase)，默认是升序，直接修改原列表
（2）不修改原列表，而是新建列表，即生成新对象sored()，依然默认是升序排列
（3）随机打乱顺序，可以调用模块random，random.shuffle(列表)
（4）reversed（）返回迭代器，那么除了返回逆序的迭代对象之外，需要注意迭代器类似指针操作，从最后一个元素到最后指向开头元素，那么指针实际上最后已经是不能返回最后了，所以只调用一次，再次调用的话就是空的。
（5）返回列表最大最小元素max、min
（6）数据的列表求和sum

>>>a=[1,3,5,8,2,0]
>>>c=reversed(a)
>>>list(c)
[0, 2, 8, 5, 3, 1]
>>>list(c)
[]

2.多维列表

列表的嵌套，可以用来存表格的信息。切片操作也是可以看作嵌套指向。【以下的循环嵌套，是表示先进入第一层列表，再进入下一层】

a=[   
["HuaPu1",22,"青岛"]
,["HuaPu2",23,"北京"]
,["HuaPu3",24,"广州"]
    ]
for m in range(3):
    for n in range(3):
        print("{}".format(a[m][n]),end="\t")
        pass
    print()
    pass
    
HuaPu1	22	青岛	
HuaPu2	23	北京	
HuaPu3	24	广州	

3.元组

元组的最大特点就是“不可改变”，列表属于可变序列，元组属于不可变序列，因此没有增加元素、删除元素、修改元素的操作。

>>>b=(1,2,3)
>>>b[0]=4

Traceback (most recent call last):
  File "<pyshell#43>", line 1, in <module>
    b[0]=4
TypeError: 'tuple' object does not support item assignment

元组支持：索引访问、切片操作、连接操作、成员关系操作、比较运算操作、计数（len()\max()\min()\sum()等）。

元组的创建：
（1）直接定义
直接定义要注意的是（）加与不加都可以使用一样的，但必须用“，”隔开，即使只有一个元素存在也需要，否则解释器将会将他当作数据来处理。
（2）强制转换函数tuple()，可以接受列表、迭代器等各种数据类型转化成元组。

>>>c=(1)
>>>type(c)
<class 'int'>

>>>c=(1,)
>>>type(c)
<class 'tuple'>

>>>a=tuple()
>>>a
()
>>>type(a)
<class 'tuple'>
>>>b=(1,2,3)
>>>b
(1, 2, 3)
>>>type(b)
<class 'tuple'>
>>>c=tuple([1,2,3,4])
>>>c
(1, 2, 3, 4)

（3）生成器推导式创建元组
这与列表的的推导式创建列表是相同的，只不过这里用（）而不是[]。那么在列表里还说过迭代器，迭代器生成的是一个对象，不是元组不是列表，这里的生成器也是一样，既不会是列表，也不是元组，而是要通过一次类型的强制转换。【同样只能访问一次】

s=(x*2 for x in range(10))
s
<generator object <genexpr> at 0x00000279CCA2B4C0>
tuple(s)
(0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
tuple(s)
()

元组的计数与访问：
元组的切片操作与列表是相同的，那么要注意的是元组中的排序只能用内置函数sorted（object对象）来生成一个新的__列表__排序。
zip()函数返回的是元组对象，也就是将多个列表对象的同一位置（索引值）的元素以元组的方式进行打包。

>>>a=(1,2,3)
>>>b=(4,5,6)
>>>c=(7,8,9)
>>>d=zip(a,b,c)
>>>d
<zip object at 0x0000025C3469D2C0>
>>>list(d)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

元组的其他特点：元组的访问速度比列表要快、与整数和字符串一样，可以作为字典的键，列表就不可以。

4.字典

首先字典是以“键值对”的方式出现的。联系之前的字符串、列表、元组我们知道这些序列都可以切片查找，通过索引值，字典则是通过键来找值。键是不可变的，所以键只能是字符串、整数、浮点数、元组等不可变量，且不可重复，后方再次出现一样的键就会覆盖前方，而值是任意的数据类型，且是可以重复的。

字典的创建方式：
（1）直接定义
（2）dict()强制转换
【注意的是，直接定义的形式是 键：值，而dict是dict(键（这个键是字符串得话不需引号）=值）】
（3）zip()函数打包转换
我们知道zip()之前打包功能是针对多个列表，将多个列表相同索引位置的元素取出放到一个元组中，最后返回包含多个元组对象的元组类型，再通过dict()强制转换就可以形成字典，注意有返回值。
【对于没有返回值的函数我们不能赋值给变量，只能是在原对象上修改，变量的指向是不变的】
（4）.fromkeys()生成值为空的字典
None现阶段理解为空即可

>>>a={}
>>>a
{}

>>>a={"name":"HuaPu","age":22}
>>>a
{'name': 'HuaPu', 'age': 22}

>>>a=dict(name="HuaPu",age=22)
>>>a
{'name': 'HuaPu', 'age': 22}

>>>a=dict([("name","HuaPu"),("age",22)])
>>>a
{'name': 'HuaPu', 'age': 22}

>>>a=["name","age"]
>>>b=["HuaPu",22]
>>>c=dict(zip(a,b))
>>>c
{'name': 'HuaPu', 'age': 22}

>>>c["name"]
'HuaPu'

>>>a=dict.fromkeys(["name","age"])
>>>a
{'name': None, 'age': None}

字典的访问：
（1）可以直接通过键访问
（2）.get()函数获取，如果输入不存在的键，直接访问会报错，但get()函数并不会，而是返回None，还可以将不存在的键通过get(）函数返回想要输出的内容，例如字符串。
（3）获取字典所有值和键，单独获得键或值。
（4）len(）键值对的个数
（5）in判断键是否在字典中

>>>a={"name":"HuaPu","age":22}

>>>a["name"]
'HuaPu'
>>>a["age"]
22
>>>a.get("name")
'HuaPu'
>>>a.get("age")
22

>>>a["gender"]
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    a["gender"]
KeyError: 'gender'
>>>a.get("gender")
>>>print(a.get("gender"))
None
>>>a.get("gender","不存在")
'不存在'

>>>a.items()
dict_items([('name', 'HuaPu'), ('age', 22)])
>>>a.keys()
dict_keys(['name', 'age'])
>>>a.values()
dict_values(['HuaPu', 22])

>>>len(a)
2

>>>"gender" in a
False

字典键值对的增加和删除：
（1）可以直接增加
（2）可以通过update()增加多个键值对，也可以理解为字典的合并，与直接添加相比，我们都是与原有的键重复就覆盖，没有就添加。
（3）pop()删除，在列表里我们说列表是一个有序的序列，pop()里面是索引值，没有的话默认是他弹出最后一个，并且返回最后一个元素的值。字典是一个无序的序列，没有索引这一个概念，那么它默认也是从后往前弹，但是也同样可以删除指定键值对，并返回值。
（4）del()删除指定对象，但没有返回值
（5）.popitem()函数逐次弹出键值对，默认调用一次弹出最后一个一次，并返回，直到为空
（6）clear()清空所有

>>>a={"name":"HuaPu","age":22}
>>>a["gender"]="男"
>>>a
{'name': 'HuaPu', 'age': 22, 'gender': '男'}

>>>b={"name":"HuaPu1","job":"student","address":"青岛"}
>>>a.update(b)
>>>a
{'name': 'HuaPu1', 'age': 22, 'gender': '男', 'job': 'student', 'address': '青岛'}

>>>del(a["name"])
>>>a
{'age': 22, 'gender': '男', 'job': 'student', 'address': '青岛'}

>>>a.pop("age")
22
>>>a
{'gender': '男', 'job': 'student', 'address': '青岛'}

>>>a.popitem()
('address', '青岛')
>>>a.popitem()
('job', 'student')
>>>a
{'gender': '男'}

>>>a.clear()
>>>a
{}

序列解包
之前我们在变量的赋值中说过解包，那么序列的解包可以用于元组、列表、字典。元组的例子如下，都是按顺序对应被解包赋值，当然元组的变量外（）也可以是没有的。
对于字典来说，我们默认是将键keys赋给变量，也可以通过.values() .items()获得值或者全部，全部返回的是一个个元组。

>>>i,j,k=(1,2,3)
>>>i
1
>>>j
2
>>>k
3
>>>i,j,k=[1,2,3]
>>>i
1
>>>j
2
>>>k
3

>>>a,b,c={'name': 'HuaPu', 'age': 22, 'gender': '男'}
>>>a
'name'
>>>b
'age'
>>>c
'gender'
>>>a,b,c={'name': 'HuaPu', 'age': 22, 'gender': '男'}.values()
>>>a
'HuaPu'
>>>b
22
>>>c
'男'
>>>a,b,c={'name': 'HuaPu', 'age': 22, 'gender': '男'}.items()
>>>a
('name', 'HuaPu')
>>>b
('age', 22)
>>>c
('gender', '男')

表格数据的字典与列表表示

row1={"name":"花圃1","age":22,"home":"青岛","salary":10000}
row2={"name":"花圃2","age":23,"home":"北京","salary":20000}
row3={"name":"花圃3","age":24,"home":"广州","salary":30000}

lista=[row1,row2,row3]
print("=============================")
print("获得花圃2的家乡:")
print(lista[1].get("home"))
print("=============================")
print("获得每个人的家乡:")
for i in range(3):
    print(lista[i].get("home"),end="\t")
    pass
print()
print("=============================")
print("将表格信息输出:")
for i in range(len(lista)):
    result=[]
    for j in range(len(lista[i])):
        result=list(lista[i].values())
        print(result[j],end="\t")
        pass
    print()
    pass

print("或者  另一种方式直接输出表格所有数据：")
for i in range(len(lista)):
    print(lista[i].get("name"),lista[i].get("age"),lista[i].get("home"),lista[i].get("salary"),end="\n")
    pass

输出结果：

=============================
获得花圃2的家乡:
北京
=============================
获得每个人的家乡:
青岛	北京	广州	
=============================
将表格信息输出:
花圃1	22	青岛	10000	
花圃2	23	北京	20000	
花圃3	24	广州	30000	
或者  另一种方式直接输出表格所有数据：
花圃1 22 青岛 10000
花圃2 23 北京 20000
花圃3 24 广州 30000

字典的底层核心原理

存：
我们知道列表是通过索引值找对应数组中的值，那么字典呢。可以想到的是，如果我们可以把字典中不可变的键转化为数字，进而把数字对应找到索引值，那最后就可以找到对应的值。其次键值对的存储以bucket的方式，会有一系列两两对应的部分，当然会有空白的两两对应的部分，没必要从上到下。那么我们可以通过hash（）这么一个函数，先将键转换成数字，通过bin（）转换成二进制，那么假设生成一个0-7【这里就是数组长度】顺序的bucket空间，对应索引值就是0-7，当一个键经过转换变成二进制后，由于空间是0-7.那么我们取3位二进制，就可全部表示，从键bin（）后的对应数字最后三位开始取值，如是101就对应5，去找5对应的bucket单元，即表元也有其他叫法。找到以后，如果已经有内容，那就在换三位bin（）后的值找，如果bin（）后的数据都不行，那就扩容空间，7变12或者24这么变，12可以用4位二进制数表示，就取bin（）后的后四位，进而依次再寻。

取：
依然是get一个键时，通过hash（）函数转换成数字，bin（）转换成二进制，根据数组的长度，取所要截取的二进制位数，然后对应到bucket中去找，找到之后里面有内容，就把键和值都取出来，此时取出的键进行bin（hash（））转换与原赖德转化二进制数比较，两者相等，我们就认为键相等，后方值是我们要取的值，如果不同就继续向前取值。

（1）键必须是散列的，字符串、元组等。
（2）自定义对象，需要我们支持：
①支持hash（)
②支持__eq__
③a==b真，即为hash（a）==hash（b）真
（3）字典是典型的空间换时间
（4）查询速度键是很快的
（5）不要在遍历字典的同时做字典的修改，因为，添加新建这些操作可能导致散列表的扩容，那么也就是说导致散列表中的键次序发生变化。很会出错。

5.集合

集合实际上是字典的实现，集合内部是”键对象“。无序可变，元素不能重复。
（1）{}创建集合对象，.add()添加集合元素
（2）set（）强制转换集合，有重复只保留一个
（3）.remove（）移除指定对象，clear（）清空全部
（4）交集并集差集 & | - 或者 .intersection() .uion() .difference()