Python基础学习day03

'''可变字符串
>>> import io
>>> s ='hello,sxt'
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x000002814C5AA040>
>>> sio.getvalue()
'hello,sxt'
>>> sio.seek(7)
7
>>> sio.write('g')
1
>>> sio.getvalue()
'hello,sgt'
>>>
'''
# 基本运算符

 >>> a = 4
>>> 3<a<10
True

# 第3章
序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的
连续的内存空间。比如一个整数序列[10,20,30,40],可以这样示意表示
   10 20 30 40
由于python中一切皆对象，在内存中实际是按照如下方式存储的：
             a = [10,20,30,40]

# 第3章
序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的
连续的内存空间。比如一个整数序列[10,20,30,40],可以这样示意表示
   10 20 30 40
由于python中一切皆对象，在内存中实际是按照如下方式存储的：
             a = [10,20,30,40]
从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。
python 中常用的序列有：
      字符串、列表、元组、字典、集合
列表简介
列表：用于存储任意数目，任意类型的数据集合
列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式：
a = [10, 20, 30, 40]
其中，10,20,30,40这些称为：列表a 的元素。
列表中的元素可以各不相同，可以是任意类型。比如：
a =[10,20,'abc',True]

列表的创建
基本语法[]创建
>>> a = list('gaoqi')
>>> a
list()创建
使用list()可以将任何可迭代的数据转化成列表
['g', 'a', 'o', 'q', 'i']
>>> range(10)
range(0, 10)
>>> a = range(10)
>>> type(a)
<class 'range'>

range()创建整数列表
range()可以帮助我们非常方便的创建整数列表。语法格式为：
        range([start,]end[,step])
start 参数：可选，表示起始数字。默认是0
end 参数：必选，表示结尾数字
step 参数：可选，表示步长，默认为1
python3中range()返回的是一个range对象，而不是列表。需要通过list()方法将其转化成列表对象。
典型示例如下：
>> > list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>> > list(range(0, 10, 1))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>> > list(range(0, 20, 2))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>> > list(range(20, 3, -1))
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
>> > list(range(-10, -33, -1))
[-10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30, -31, -32]
>> >
推导式生成列
>>> a= [x*2 for x in rangde(5)]
>>> a= [x*2 for x in range(5)]
>>> a
[0, 2, 4, 6, 8]
>>> a = [x*2 for x in range(100)]
>>> a
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198]
>>>
>>> a = [x*2 for x in range(100) if x%9==0]
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
>>>

# 列表元素的增加和删除
当列表增加和删除元素时，列表会自动进行内存管理，减少了程序员的负担。
但这个特点涉及列表元素的大量移动，效率低。我们一般只会在列表的尾部添加元素或删除元素，
将大大提高列表的操作效率。
append()方法
原地修改列表，是真正的列表尾部添加新的元素，速度最快，推荐使用。
>>> a = [20,40]
>>> a.append(80)
>>> a
[20, 40, 80]
# 运算符操作
并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。
这样，会涉及大量的复制操作。对于大量元素不建议使用。
>>> a =[20,40]
>>> id(a)
2328498796544
>>> a=a+[50]
>>> id(a)
2328499347392
如上测试，发现变量a的地址发生了变化。也就是创建了新的列表对象。
# extend()方法
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。
>>> a =[20,40]
>>> id(a)
2328498796544
>>> a=a+[50]
>>> id(a)
2328499347392
>>> a=[20,40]
>>> id(a)
>>> a.extend([50,60])
>>> id(a)
2328498796544
>>> a.extend([100,200])
>>> a
[20, 40, 50, 60, 100, 200]
insert()插入元素
使用insert()可以将制定元素插入到列表对象的任意制定位置。这样会使插入位置后面的
所有元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动函数的还有
：remove()、pop()、del()，他们在删除非尾部元素时也会发生操作位置后面元素的移动。
>>> a=[100,20,30]
>>> a.insert(2,500)
>>> a
[100, 20, 500, 30]
# 乘法扩展
使用乘法扩展列表，生成一个新列表，新列表元素时原列表多次重复使用
>>> a = ['sxt',100]
>>> b=a*3
>>> a
['sxt', 100]
>>> b
['sxt', 100, 'sxt', 100, 'sxt', 100]
适用于乘法操作的，还有：字符串、元组。例如：
>>> c='sxt'
>>> d=c*3
>>> c
'sxt'
>>> d
'sxtsxtsxt'

# 列表元素的删除
del 删除
删除列表指定位置的元素
>>> a=[10,20,30]
>>> del a[1]
>>> a
[10, 30]

pop()方法
pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。
>>> a =[10,20,30,40,50]
>>> a.pop()
50
>>>
>>> a =[10,20,30,40,50]
>>> a.pop(3)
40
>>>
# remove(方法)
删除首次出现的指定元素，若不存在，该元素抛出异常
>>> a =[10,20,30,10,20,30,40,50]
>>> a.remove(20)
>>> a
[10, 30, 10, 20, 30, 40, 50]

# index()获得指定元素在索引列表中
index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])
其中，start和end指定了搜索的范围。

# count()获得指定元素出现的次数
# len()获得长度
# 成员资格的判断
a =[1,2,3,4]
2 in a
True
>>> a=[10,20,30,40,50,20,30,40]
>>> a.index(20,30)
>>> a.index(20,3)
5

# 切片操作

# 多维列表
>>> a=[]
>>> a=[
   ['高小一',18,30000,'北京']
   ['高小二',19,20000,'上海']
   ['高小三',20,10000,'深圳']
   ]

 # 元组tuple >>> a=(10,20,30) >>> type(a) <class 'tuple'> >>> b=(20,) >>> type(b) <class 'tuple'> >>> b=20, >>> b= tuple('abcd') >>> b ('a', 'b', 'c', 'd') >>> b=list('abcd') >>> b ['a', 'b', 'c', 'd'] >>> b=tuple(range(3)) >>> b (0, 1, 2)

元组元素的访问和计数
元组的元素不能修改
>>> a=(20,30,40)
>>> a[0]
20
>>> a[1]
30
>>> a[2]
40
>>> a =tuple('abcdefghijklmn')
>>> a
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n')
>>> a[1:10]
('b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j')
>>> a[::-1]
('n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a')
3.列表关于排序的方法list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数sorted(turtle),
并生成新的列表对象。
>>> b=(30,20,40)
>>> sorted(b)
[20, 30, 40]
>>> a=1,20
>>> b=30,20
>>> a+b
(1, 20, 30, 20)
>>> a
(1, 20)
>>> b
(30, 20)
>>> len(a)
2
>>> sum(b)
50
>>> max(a)
20

zip
>>> a=1,20
>>> b=30,20
>>> a+b
(1, 20, 30, 20)
>>> a
(1, 20)
>>> b
(30, 20)
>>> len(a)
2
>>> sum(b)
50
>>> max(a)
20

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，
生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
我们可以通过生成器对象，转化成列表或元组。也可以使用生成器对象的__next__()方法进行遍历，
或者直接作为迭代器对象来使用。元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。
>>> s=(x*2 for in range(5))
>>> s=(x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x00000267B722D900>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> list(s)
[]
>>> s
<generator object <genexpr> at 0x00000267B722D900>
>>> tuple(s)
()
>>> s=(x*2 for x in range(5))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4
元组总结
1.元组的核心特点：不可变序列。
2.元组的访问和处理速度比列表快。
3.与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。