PYTHON 基础-DAY3/4 20210403

目录

030 可变字符串

  • 可变字符串:可通过io.StringIO对象或array模块
a='hello,sun'
sio=io.StringIO(a)   #sio即为可变对象
sio.seek(7)          #移动到第七个字符 
sio.write('g')       #修改第七个字符
sio.getvalue()       #不能通过直接调用sio获取数值,需通过getvalue.输出为‘hello,gun’

031 运算符总结、位操作符、优先级问题

  • 运算符总结:
    and,or,not:布尔与,布尔或,布尔非
    Is,is not:同一性判断,是否为同一对象
    <,<=,>,>=<,!=,==:比较值
    |,^,&:按位或,按位异或,按位与
    <<,>>:移位
    ~:按位翻转
    +,-,,/,//%:数值计算(+和可使用于字符串、列表以及元组)
#移位操作
a=3
a<<2 #左移一位相当于乘2,因此结果a=12
a=8
a>>2 #右移一位相当于除2,因此结果a=4
  • 复合运算符
    +=、-=、*=、/=、//=、%=、<<=、>>=、&=、|=、^=
    !注:python无++或–
  • 运算符优先级
    复杂表达式小括号优先,乘法优先加减;位运算和算术运算>比较运算符>赋值运算符
    !bin()可将数字转换为二进制数字

第三章序列

  • 序列:一块用来存放多个值的连续的内存空间
  • 序列包括:字符串、列表、元组、字典、集合

032-039列表

  1. 列表:用于存储任意数目、任意类型的数据集合。是内置可变序列,包含多个元素的有序连续的内存空间

  2. 列表语法的创建(4种方法)

#1)基本语法[]的创建
a=['hello']
a=[] #创建一个空的列表对象
#2)list()创建:将任何可迭代的数据转换为列表
a=list(range(10)) #[0,1,2,3,4,5,6,7,9]
a=list('hello')   #['h','e','l','l','o']
a=list()  #创建一个空的列表对象
#3)range()创建整数列表:range(start,end,step)start不写则默认0,end必写,step不写默认1。range返回的是一个range对象,而不是列表。
list(range(1,4,2)) #[1,3]
#4)推导式生成列表
a=[x*2 for x in range(100) if x%3==0] #循环创建多个元素,通过if过滤元素
  1. 列表元素的增加(5种方法)
    增加和删除列表会对内表进行内存管理,通常在列表尾部添加和删除元素,否则降低效率
a=[20,40]
#1)append()方法
a.append(60) #a=[20,40,60]
#2)+运算符操作:直接拼接,涉及大量的复制操作,对于操作大量元素不建议使用
a=a+[60] #a=[20,40,60],a的内存地址会发生变化,即创建了新的列表对象
#3)extend()方法:将目标列表添加到列表末尾,类似于+运算,但不创建新的列表对象
a.extend([60]) #a=[20,40,60]
#4)insert()插入元素:可将指定元素插入到列表对象的任意指定位置。涉及到大量元素时,应尽量避免使用,影响处理速度。remove()、pop()、del()类似
a=inssrt(2,60) #a=[20,40,60],注意索引从0开始
#5)乘法扩展:使用乘法扩展生成一个新列表,新列表元素时原列表元素多次重复。(适用于元组、列表、字符串)
b=a*3 #a=[20,40,20,40,20,40]
  1. 列表元素的删除(3种方法)
#1)del删除:删除列表指定位置的元素
a=[10,20,30]
del a[1] #a=[10,30]
#2)pop():删除并返回指定位置的元素,如果未指定位置则默认操作列表的最后一个元素
a=[10,20,30]
b=a.pop() #b=30
#3)remove方法:删除首次出现的指定元素,若不存在该元素抛出异常
a=[10,20,30,20]
a.remove(20)   #a=[10,30,20]
a.remove(20)   #a=[10,30]
  1. 列表元素访问和计数
#1)通过索引直接访问元素:[0,列表长度-1],超出范围会出现异常
a=[10,20,30]
b=a[1] #b=20
#2)index():获取指定元素在列表中首次出现的索引,index(value,[start,[end]]),其中start和end指定搜索的范围
a=[10,20,30]
a=index(20,0,2)
#3)len()返回列表长度:即列表中包含元素的个数
#4)成员资格判断:判断列表中是否存在指定的元素,可以使用count()方法,返回0则表示不存在,返回大于0则表示存在。但通常通过in关键词判断,直接返回Ture或False
  1. 切片操作sliice[start: end: step],可快速提取子列表或修改。
    步长省略时可以顺便省略第二个冒号。(同字符串相同)
    切片操作时,起始偏移量和终止偏移量不在[0,len()-1],也不会报错
  2. 列表的遍历
for obj in list:
	print(obj)
  1. 列表排序
    1)修改原列表,不建新列表的排序
a=[30,20,50,40]
a.sort() #升序排列
a.sort(reverse=Ture) #降序排列
import random
random.shuffle(a) #打乱顺序

2)建新列表的排序:sorted(),不对原列表进行修改

a=[30,20,50,40]
b=sorted(a)  #默认升序
c=sorted(a,reverse=Ture)  #降序排列

3)reversed()返回迭代器:与列表对象reverse()不同的是,内置函数reversed()不对原列表做修改,只返回一个逆序排列的迭代器对象list_reverseiterator object

a=[30,20,50,40]
b=reversed(a)
c=list(b) #[50,40,30,20]
  1. 列表相关的其他内置函数汇总
    1)max、min返回列表中的最大和最小值
    2)sum对数值型列表所有元素进行求和,对非数值型列表运算则会报错
  2. 多维列表
    一维列表可存储一维的、线性的数据;二维列表可存储二维的、表格的数据

040-042 元组tuple

  • 元组:不可变序列,不能修改元组中的元素。因此无增加、修改、删除元素
    主要功能:索引访问、切片操作、连接操作、成员关系操作、比较运算操作、计数len()\max( )\min()\sum()
    1)元组的创建
    a.通过()创建元组,小括号可以省略
a=(10,20,30)
a=10,20,30   #若只有一个元素则必须➕(),后面加逗号,如a=(10,)

b.通过tuple()创建元组:tuple(可迭代的对象)

b=tuple('abd') #可接收列表、字符串、其他序列类型、迭代器生成元组

2)元组的元素访问和计数
a.元组的元素不能修改
b.元组的元素访问和列表一样,只不过返回的仍然是元组对象
c.列表关于排序的方法list.sorted()是修改原列表对象,元组没有这样的方法。如果对元组排序,只能使用内置函数sorted(tuple()),并生成新的列表对象
3)zip:zip(list1,list2…)将多个列表对应位置的元素组合成元组,并返回zip对象

a=[10,20]
b=[30,40]
c=[50,60]
d=zip(a,b,c)  #d只是对象
e=list(d) #[(10,20)(30,40)(50,60)]

4)生成器推导式创建元组:与列表推导式类似。列表推导式直接生成列表对象,生成器推导式直接生成生成器对象。可通过生成器对象,转换成列表或元组;也可以使用生成器对象的__next__()方法进行便利,或者直接作为迭代器对象使用。元素访问结束后如需重新访问其中元素,必须重新创建该生成器对象。

#生成器的使用测试
s=(x*2 for x in range(5))
tuple(s) #(0,2,4,6,8)
list(s)  #[] 只能访问一次元素,第二次为空,需要再生成一次

s=(x*2 for x in range(5))
s.__next__() #0
s.__next__() #2
s.__next__() #4   依次取完后需重新生成

总结:
1)元组核心特点:不可变序列
2)元组的访问和处理速度比列表快
3)与整数和字符串一致,元组可作为字典的键,列表不能作为字典的键使用

043-049 字典

字典:“键值对”的无序可变序列,字典中每个元素都是一个“键值对”,包含键对象和值对象,可通过键对象实现快速获取、删除和更新对应的值对象。“键”是任意不可变数据,因此列表、字典、集合这些可变对象不能作为键,并且键不能重复

  1. 字典的创建(3种方式)
    1)通过{}、dict()来创建字典对象
a={'name':'hzh','age':21,'job':'student'}
b=dict(name='hzh',age=21,job='student')
c=dict([('name','hzh'),('age',21),('job','student')])

2)通过zip()创建字典对象

k=['name','age','job']
v=['hzh',21,'student']
p=dict(zip(k,v))

3)通过fromkeys创建值为空的字典

a=dict.fromkeys(['name','age','job']) #a={'name':None,'age':None,'job':None}
  1. 字典元素的访问
    设定字典对象为a={‘name’:‘hzh’,‘age’:21,‘job’:‘student’}
    1)通过获得值,若键不存在,则抛出异常。
a={'name':'hzh','age':21,'job':'student'}
a['name'] #'hzh'
a['s']    #会提示KeyError:‘s’

2)通过get()方法获得值,优点:指定键不存在时返回None,也可以设定指定键不存在时默认返回的对象。<推荐使用>

a={'name':'hzh','age':21,'job':'student'}
a.get('name') #'hzh'

3)列出所有的键值对

a={'name':'hzh','age':21,'job':'student'}
a.items() #dict.items([('name','hzh'),('age',21)('job','student')])

4)列出所有的键,列出所有的值

a={'name':'hzh','age':21,'job':'student'}
a.keys() #dict.keys(['name','age','job'])
a.values() #dict.values(['hzh',21,'student'])

5)len()键值对的个数
6)检测一个是否在字典中,in不能检测值

a={'name':'hzh','age':21,'job':'student'}
'name' in a #Ture
  1. 字典元素的添加、修改、删除
    1)给字典新增“键值对”,如果键已存在,覆盖旧的键值对;如果键不存在,则新增键值对
a={'name':'hzh','age':21,'job':'student'}
a['adress']='sn'
a['age']=22

2)使用update()将新字典中所有键值对全部添加到旧字典对象上。若key又重复,则直接覆盖。

a={'name':'hzh','age':21,'job':'student'}
b={'name':'yy','sex':'female'}
a.update(b) #a={'name':'yy','age':21,'job':'student','sex':'female'}

3)字典中元素的删除,可以使用del()方法;或者clear()删除所有键值对,pop()删除指定的键值对,并返回对应的值对象。

a={'name':'hzh','age':21,'job':'student'}
del(a['name'])  #a={'age':21,'job':'student'}
b=a.pop('name') #b='hzh'

4)popitem():随机删除和返回该键值对。因为字典是**“无序可变序列”**,因此无最后一个元素的概念。可有效处理一个接一个移除并处理项,不用获取键的列表

a={'name':'hzh','age':21,'job':'student'}
a.popitem() #无序序列因此会随机移除
  1. 序列解包:可用于元组、列表、字典,可方便对多个变量赋值
    序列解包用于字典时,默认是对操作。如果需要对键值对进行操作,则使用items()。如果需要对值进行操作,则需要使用values()
x,y,z=10,20,30 #序列解包用于元组
[a,b,c]=[10,20,30] #序列解包用于列表
#序列解包用于字典
a={'name':'hzh','age':21,'job':'student'}
name,age,job=s #默认对键进行操作
name,age,job=s.values() #使用values()对值进行操作
name,age,job=s.items() #使用items()对键值对进行操作
print(name) #('name','hzh')可通过name[0]或name[1]进行访问

表格数据使用字典和列表进行存储,并实现访问(先字典后列表
5. 核心底层原理
字典对象的核心:散列表。散列表是一个稀疏数组(总是有空白元素的数组),数组的每个单元叫做bucket,一个bucket包括两部分对象的引用和值对象的引用。所有的buket结构和大小一致,可通过偏移量读取指定bucket。
1)将键值对放进字典的底层过程
PYTHON 基础-DAY3/4 20210403
计算值对象的散列表值,通过hash()完成,通过bin()转换成二进制便于读取。
!python会根据散列表的拥挤程度扩容,扩容指创造更大的数组将原有的内容拷贝到新数组中(超过2/3自动扩容)
2)根据键查找键值对的底层过程

a={'name':'hzh','age':21}
a.get('name')  #'hzh'   #通过键对象查找键值对,最后提取值对象

PYTHON 基础-DAY3/4 20210403
总结:
1)键必须可散列:数字、字符串、元组都是可散列;自定义对象必须支持以下三点。1 支持hash()函数;2 支持__eq__()方法检测相等行;3 若a==b为真,那么hash(a)==hash(b)为真
2)字典在内存中开销很大,典型的空间换时间
3)键查询速度很快
4)往字典中添加新建可能导致扩容,导致散列表中键的次序变化。因此不要在遍历字典同时对字典进行修改

050 集合

  • 集合:无序可变,元素不能重复。集合底层是字典的实现,集合的所有元素是字典中的键对象,不能重复且唯一。
  • 集合的创建和删除
    1)使用{}创建集合对象,使用**add()**添加元素
a={2,3,5}
a.add(8) #a={8,2,3,5}

2)使用**set()**将列表、元组等可迭代对象转化成集合。如果原数据中存在重复数据,只保留一个

a=['a','b','a']
b=set(a)  #b={'a','b'}

3)使用remove()删除指定元素;clear()清空整个集合

  • 集合相关操作
    |或union():并集
    &或intersection():交集
    -或diference():差集
上一篇:记录学习编程的每一天—Day3


下一篇:C++学习之路DAY3—复合类型