学习笔记python 入门day2

• 常用查找方法

>>>a=dajaicidhdc
>>>len(a)   #字符串长度
>>>a.startswith("字符串开头"）  #判断是否为该字符串开头，返回值true/false
>>>a.endswith("字符串结尾")    #判断是否为该字符串结尾，返回值true/false
>>>a.find('字符串')            #第一次出现指定字符串的位置
>>>a.rfind('字符串')           #最后一次出现指定字符串的位置
>>>a.count('字符串')           #指定字符串出现次数
>>>a.isalnum()                #所有字符全是字母或数字

• 去除strip()

>>>a= *six*
>>>a.strip()         #去首尾空格
>>>a.strip('*')      #去首尾*
>>>a.lstrip('*')     #去左*
>>>a.rstrip('*')     #去右*

• 大小写转换

>>>a="to be or not to be"
>>>a.capitalize()     #产生新的字符串，首字母大写
>>>a.title()          #产生新的字符串，每个单词首字母大写
>>>a.upper()          #产生新的字符串，所有字符转为大写
>>>a.lower()          #产生新的字符串，所有字符转为小写
>>>a.swapcase()       #产生新的，所有字母大小写转换

• 格式排版

>>>str.center(width[width[,fillchar])
#width--字符串的总宽度
#fillchar--填充字符
#无法使左右字符数相等时候，字符串字符数为奇数时左侧字符会比右侧少 1，字符串字符数#为偶数时左侧字符会比右侧多 1
>>>a='lyf'
>>>a.center(6,'*')       #返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。
>>>a.center(6)           #返回一个居中排版的字符串，空格填充
>>>a.ljust(6,'*')        #返回一个左对齐排版的字符串
>>>a.rjust(6,'*')        #返回一个右对齐排版的字符串

其他方法

>>>isalnum()             #是否为字母或数字
>>>isalpha()             #检测字符串是否只由字母组成（含汉字）
>>>isdigit（）           #检测字符串是否只由数字组成
>>>isspace（）           #检测是否为空白符
>>>isupper()             #是否为大写字母
>>>islower()             #是否为小写字母

可变字符串
在python中，字符串是不可变对象，不支持原地修改，如果需要修改其中的值，智能创建新的字符串对象，可使用io.StringIO对象或模块

>>>import io            #导入io模块
>>>a="lyf"              #将lyf赋值给a
>>>b=io.StringIO(a) 
>>>b.getvalue()         #使用IO后，获取新的字符串
>>>b.seek(2）          #索引到第二位(索引从0开始）
>>>b.write("yi")       #移动到索引位置后，替换新的字符
>>>a.getvalue()

>>>'lyyi'

序列
含义：一种数据存储方式，用来存储一系列的数据。在内存中，序列就是用来存放多个值得连续的内存空间。序列中存储的是整数对象的地址，而不是整数对象的值。
序列的结构：字符串、列表、元组、字典、集合

列表的创建

• 基本语法[ ]创建

>>>a=[1,2,3,4]
>>>b=[]      #创建一个空的列表对象

• list()创建
  使用list()可以将任何可迭代的数据转化为列表

>>>a=list()                #创建一个空的列表对象
>>>a=list(range(10))       #整数序列转化为列表
>>>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a=list("zhongxn")       #将字符串转化为列表

>>>['z', 'h', 'o', 'n', 'g', 'x', 'n']

• range()创建整数列表
  语法格式：range([start],end,[step])
  start 参数 ：可选，表示起始数字，默认是0
  end参数：必选，表示结尾数字
  step参数：可选，表示步长，默认为1
  注：start参数不写，默认为0，step参数步长不写默认为1，step参数为负数，则从右往左生成

>>>list(range(3,15,2))
>>>[3, 5, 7, 9, 11, 13]

• 推导式生成列表

>>>c=[x*2 for x in range(5)]     #循环创建多个元素，x的范围为[0,1,2,3,4],再按表达式创建
>>>c
>>>[0, 2, 4, 6, 8]

>>>d=[x*2 for x in range(100) if x%9==0]   #通过if过滤元素
>>>d

列表元素的增加和删除
因为列表增加和删除元素时，列表会自动进行内存管理，但涉及列表元素的大量移动，效率低，故一般在列表的尾部添加元素。

• append（）方法
  原地修改列表对象，是真正的列表尾部添加的对象，这里的对象可以是一个元素、列表、字典或元组等，速度快，推荐使用。

>>>e=[10,20]
>>>id(e)
>>>2657352879880
>>>e.append(20)
>>>[10, 20, 20]
>>>id(e)            #地址没改变
>>>2657352879880

• 运算符操作
  不是真正的尾部天下元素，而是创建新的列表对象，将原列表的元素和新列表的元素依次复制到新的列表对象中，涉及大量的复制操作，当操作大量元素不建议使用。

>>>f=[10,20]
>>>id(f)
>>>2657352709896
>>>f=f+[50]
>>>f
>>>[10, 20, 50]
>>>id(f)                 #地址已改变
>>>2657352742664

• extend（）方法
  将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

>>>g=[10,20]
>>>2657352920520
>>>g.extend([50,60])
>>>[10, 20, 50, 60]
>>>id(g)              #不创建新的列表对象，地址不变
>>>2657352920520

• insert()插入元素（本质是拷贝）

语法：list.insert(index, obj)

插入到列表对象的任意位置，但插入的位置后，里面所有的元素进行移动，会影响处理速度。涉及大量元素是，尽量避免使用。类似发生这种移动的函数还有remove（）、pop （）、del（）

>h=[10,20]
>h.insert(1,5)
>[10, 5, 20]

• 乘法扩展
  使用乘法扩展列表，生成一个新列表，新的列表元素是原列表的多次重复。适用于乘法操作的，还有：字符串、元组

>>>i=['lyf',666]
>>>i=i*3
>>>i
>>>['lyf', 666, 'lyf', 666, 'lyf', 666]

• 列表的删除(本质是拷贝)
  del 方法 删除列表指定位置的元素
  注：避免数组中间元素的删除，因为会涉及后面元素的大量的挪动

>>> a=[10,20,30]
>>> del a[1]
>>> a
[10, 30]

pop() 方法 删除并返回指定位置元素，若没有指定位置，就默认操作列表的最后一个元素

>>> b=[1,2,3,4,5,6]
>>> c=b.pop()
>>> c
6
>>> b
[1, 2, 3, 4, 5]
>>> d=b.pop(1)           #删除指定位置
>>> d
2
>>> b
[1, 3, 4, 5]

remove()方法
删除首次出现的指定元素，若不存在元素就抛出异常。

>>> m=[4,5,6,7,8,9]
>>> m.remove(4)               #这里是元素，不是索引位置
>>> m
[5, 6, 7, 8, 9]
>>> m.remove(100)             #删除的不是该列表的元素，抛出异常
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    m.remove(100)
ValueError: list.remove(x): x not in list
>>> 

列表元素访问和计数

• 列表的访问
  通过索引直接访问元素，索引区间[0，列表长度-1]，超出范围会抛出异常

• index()获得指定元素在列表中首次出现的索引
  语法：index(value,[start,[end]])

>>> x=[1,2,3,6,1,6,2,1]
>>> x.index(6)
3
>>> x.index(1,5)     #从索引位置5开始，第一次出现1的位置
7
>>> x.index(1,2,6)	#从索引位置2到7之间，第一次出现1的位置
4

• count（）获得指定元素在列表中出现的次数

>>> x=[1,2,3,6,1,6,2,1]
>>>> x.count(1)          
3

• len（）返回列表长度，即列表中包含元素的个数

>>> x=[1,2,3,6,1,6,2,1]
>>> len(x)
8

• 成员资格判断
  判断列表中是否存在指定的元素，使用count()，返回0表时不存在，若返回的值大于0，则代表存在。但是一般采用in关键字来判断，直接返回True 或False
  效率更高，推荐使用。

>>> x=[1,2,3,6,1,6,2,1]
>>> 6 in x
True
>>> 4 in x
False
>>> 4 not in x
True
>>> x.count(1)
3
>>> x.count(4)
0
>>> "a" in "aba"
True

切片操作
切片是Pyhton序列及其重要的操作，适用于列表，元组，字符串等。可快速提取子列表或修改
切片的格式：[起始偏移量start：终止偏移量end：[步长step]]
注：当步长省略是顺便可以省略第二个冒号

>>> y=[10,20,30,50,3,9]
>>> y[:]
[10, 20, 30, 50, 3, 9]
>>> y[1:3:1]     #包头不包尾
[20, 30]   
>>> y[0::2]   #从0开始到末尾，步长为2
[10, 30, 3]
>>> y[1:]                #从1开始取
[20, 30, 50, 3, 9]
>>> a[:2]          #从0开始取，到2结束
[10, 20]
>>> 

典型操作（三个量为正数的情况）

其他操作（三个量为负数）的情况

注： 切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]，也不会报错。起始偏移量小于0时则会当成0，终止偏移量大于“长度-1”会被当成-1

>>> y=[10,20,30,50,3,9]
>>> y[1:100]
[20, 30, 50, 3, 9]
>>> y[-3:6:1]
[50, 3, 9]

列表的遍历

>>> y=[10,20,30,50,3,9]
>>>> for a in y:
	print(a)

10
20
30
50
3
9

列表的排序

• 修改原列表，不建新列表的排序

>>> a=[2,3,6,9,2,8,1]
>>> id(a)
2038621417792
>>> a.sort()               #默认升序
>>> a
[1, 2, 2, 3, 6, 8, 9]
>>> id(a)              #地址没有变，对象没有变，顺序重新排
2038621417792
>>> a.sort(reverse=True)   #降序排序
>>> a
[9, 8, 6, 3, 2, 2, 1]
>>> import random
>>> random.shuffle(a)  #随机打乱排序
>>> a
[2, 2, 8, 3, 6, 9, 1]
>>> random.shuffle(a)  #再次打乱
>>> a
[2, 6, 3, 2, 1, 9, 8]

• 建新列表的排序
  使用内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改

>>> a=[6,5,9,2,8,2,5]
>>> id(a)
2038627800448
>>> a=sorted(a)
>>> a
[2, 2, 5, 5, 6, 8, 9]
>>> id(a)
2038628172544             #建立了新对象
>>> c=sorted(a,reverse=True)
>>> c
[9, 8, 6, 5, 5, 2, 2]

• reverse()返回迭代器
  内置reversed()支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数reversed()不对原列表做任何更改，只返回一个逆序列表的迭代器对象。

>>> d=[0,2,9,5,9,2,6]
>>>> e=reversed(d)
>>> e
<list_reverseiterator object at 0x000001DAA7B34DF0>  #不是列表对象，是迭代器，包含了指针，迭代完后，就在列表最前面了
>>>list(e)    #转成列表
[6, 2, 9, 5, 9, 2, 0]
>>> list(e)  #指正到头
[]

列表相关的其他内置函数汇总

• max 和min

>>> d=[0,2,9,5,9,2,6]
>>> max(d)
9
>>> min(d)
0

>>> 

• sum
  对数值型列表的所有元素进行求和和操作，对非数字型列表运算则会报错

>>> d=[0,2,9,5,9,2,6]
>>> sum(d)
33