(1) cadena
1. Introducir el índice de la cadena
str( ) es una función integrada de python, y es una palabra clave reservada por python. Al definir variables, debe evitar usar str como nombre de variable.
Si la variable str se definió antes de usar la función str( ), TypeError: el objeto 'str' no se puede llamar este error.
Enlace original: https://blog.csdn.net/lifelegendc/article/details/55051374
# 字符串的索引
s = 'good morning'
# 查看类型
print(type(s)) #out=<class 'str'>
s[0] #out='g'
s[-2] #out='n'En segundo lugar, el funcionamiento básico de la cadena.
En la estructura de datos: las cinco operaciones de asignación de cadena StrAssign, comparación de cadena StrCompare, longitud de cadena StrLength, concatenación Concat y subcadena SubString constituyen el subconjunto mínimo de operaciones del tipo cadena, es decir, estas operaciones no pueden ser realizadas por otras operaciones de cadena; por el contrario, otras operaciones de cadenas (excepto la limpieza de cadenas ClearString) y la destrucción de cadenas (DestroyString)) se pueden implementar en este subconjunto mínimo de operaciones.
2* operación de segmentación de cadenas
La fragmentación se usa para extraer la subsecuencia deseada de la secuencia, y su uso es:
var[inferior:superior:paso]
Su rango incluye inferior, pero no incluye superior, es decir, [inferior, superior), el paso indica el tamaño del intervalo de valor, si no, por defecto es 1.
La fragmentación se usa para extraer la subsecuencia deseada de la secuencia;
Uso: var[inferior:superior:paso] Su rango incluye inferior, pero no incluye superior, es decir, [inferior,superior] , el paso indica el tamaño del intervalo de valor, si no, el valor predeterminado es 1.
Se pueden omitir inferior y superior. Omitir inferior significa cortar desde el principio, y omitir superior significa cortar todo el camino hasta el final.
Cuando el valor del paso es negativo, omitir la parte inferior significa cortar desde el final y omitir la parte superior significa cortar todo el camino hasta el principio.
当给定的upper超出字符串的长度（注意：因为不包含upper，所以可以等于）时，Python并不会报错，不过只会计算到结尾。
#字符串的索引
s = 'good morning'
# 查看类型
print(type(s))
s[-3:] #out='ing'
s[:-3] #out='good morn'
s[:] #out='good morning'
s[2:6] #out='od m'
#联系step
print(s[::2]) # go onn
print(s[::-1]) # gninrom doog
print(s[:100]) # good morning'1、索引'
#对于一个有序序列，可以通过索引的方法来访问对应位置的值。字符串便是一个有序序列的例子，Python使用 [] 来对有序序列进行索引。
s = "hello world"
print(s[0]) #'h'
#Python中索引是从 0 开始的，所以索引 0 对应与序列的第 1 个元素。为了得到第 5 个元素，需要使用索引值 4 。
print(s[4]) #'o'
#除了正向索引，Python还引入了负索引值的用法，即从后向前开始计数，例如，索引 -2 表示倒数第 2 个元素：
print(s[-2]) #'l'
#单个索引大于等于字符串的长度时，会报错：
#print(s[11]) #IndexError: string index out of range
'2、分片'
#分片用来从序列中提取出想要的子序列，其用法为：
#'''var[lower:upper:step]'''
#其范围包括 lower ，但不包括 upper ，即 [lower, upper)， step 表示取值间隔大小，如果没有默认为1。
print(s) #'hello world'
print(s[1:3]) #'el' #分片中包含的元素的个数为 3-1=2 。
#也可以使用负索引来指定分片的范围：
print(s[1:-2]) #'ello wor' #包括索引 1 但是不包括索引 -2 。
#lower和upper可以省略，省略lower意味着从开头开始分片，省略upper意味着一直分片到结尾。
print(s[:3]) #'hel'
print(s[-3:]) #'rld'
print(s[:]) #'hello world'
#每隔两个取一个值：
print(s[::2]) #'hlowrd'
#当step的值为负时，省略lower意味着从结尾开始分片，省略upper意味着一直分片到开头。
print(s[::-1]) #'dlrow olleh'
#当给定的upper超出字符串的长度（注意：因为不包含upper，所以可以等于）时，Python并不会报错，不过只会计算到结尾。
print(s[:100]) #'hello world'
Python基础： http://t.csdn.cn/BOFtz
http://t.csdn.cn/A2OH4
（二）列表
介绍列表的方法及示例演示与使用，包括：长度、修改列表、取值、排序。
一、创建列表
#创建列表❤️
empty_list=list()
print(empty_list)
#out=[] 同 empty_list = []
#查看列表长度❤️
#len
a = [1,2,3]
b = [2,3,'hello']
c = a + b
print(c)
#out=[1, 2, 3, 2, 3, 'hello']
len(c) #out=6
print(len(c))
#列表方便扩展❤️
d = b * 2
print(d)
#out=[2, 3, 'hello', 2, 3, 'hello']
d[-1] #out='hello'二、修改列表
#创建列表
empty_list=list()
print(empty_list)
#out=[] 同 empty_list = []
#查看列表长度
#len
a = [1,2,3]
b = [2,3,'hello']
c = a + b
print(c)
#out=[1, 2, 3, 2, 3, 'hello']
len(c) #out=6
print(len(c))
#列表方便扩展
d = b * 2
print(d)
#out=[2, 3, 'hello', 2, 3, 'hello']
d[-1] #out='hello'
❤️#############################################❤️
#修改列表❤️
print(a) #out=[1, 2, 3]
a[0]=100
a #out=[100, 2, 3]
#这种赋值也适用于分片，例如将列表的第2，3两个元素换掉：
a[1:3]=[200,300]
print(a) #out= [100, 200, 300]
#对于连续的分片（即步长为1），Python采用的是整段替换的方法，两者的元素个数并不需要相同。
#例如，将[11,12]替换为[1，2，3，4]
a=[10,11,12,13,14]
a[1:3]=[1,2,3,4]
print(a) #out=[10, 1, 2, 3, 4, 13, 14]
#用这个方法来删除列表中一个连续的分片：
a=[10,1,2,11,12]
print(a[1:3]) #out=[1, 2]
a[1:3]=[]
print(a) #out=[10, 11, 12]对于不连续（间隔step不为1）的片段进行修改时，两者的元素数目必须一致。
a = [10,11,12,13,14]
a[::2] #每隔两个取一个值
print(a[::2])
#out=[10, 12, 14]
a[::2]=[1,2,3]
print(a)
#out=[1, 11, 2, 13, 3]Python提供了删除列表中元素的方法'del':
a = [100,'a','b',200]
del a[0]
print(a) #out=['a', 'b', 200]
#删除间隔的元素
a =['a',1,'b',2,'c']
del a[::2]
print(a) #out=[1, 2]用in来看某个元素是否在某个队列（不仅仅是列表）中，用not in来判断是否不在某个序列中。
a = [1,2,3,4,5]
print(1 in a)
print(1 not in a)
#out=True
# False
#也可以用于字符串
s = 'today is lovely Sunday'
print("'today' in s: ", 'today'in s)
print("'sunday in s: ", 'sunday'in s)
#out='today' in s: True
# 'sunday in s: False列表中可以包含各种对象，甚至可以包含列表：
a = [1,2,'bb',[3,4]]
print(a[3])
print(a[3][1])
#out=[3, 4]
# 4三、列表方法
#列表中某个元素个数
a = [1,2,3,4,5,6,6]
print(len(a)) #out=7，总个数为7
#元素6出现的次数/个数
print(a.count(6)) #out=2
l.index(ob) 返回列表中元素 ob 第一次出现的索引位置，如果 ob 不在 l 中会报错。
print(a.index(6)) #out=5
print(a.index(7)) #out=ValueError: 7 is not in list列表添加元素
#向列表添加单个元素
#a.append(ob)将元素ob添加到列表a的最后。
a = [1,2,3,4,5,6]
a.append(10)
print(a) #out=[1, 2, 3, 4, 5, 6, 10]
#append每次只添加一个元素，并不会因为这个元素是序列而将其展开：
a.append([11,12])
print(a)
#out=[1, 2, 3, 4, 5, 6, 10, [11, 12]]#向列表添加序列
#l.extend(lst)将序列lst的元素依次添加到列表l的最后，作用相当于l += lst。
a = [1,2,3,4,5]
a.extend([7,6,1])
print(a) #out=[1, 2, 3, 4, 5, 7, 6, 1]
#插入元素
#l.insert(idx,ob)在索引idx处插入ob，后的元素依次后移。
a = [1,2,3,4]
#在索引2插入'a'
a.insert(2,'a')
print(a) #out=[1, 2, 'a', 3, 4]移除元素
l.remove(ob)会将列表中第一个出现的ob删除，如果ob不在l中会报错。
a = [1,2,3,4]
#删除第一个1
a.remove(1)
print(a) #out=[2, 3, 4]
#弹出元素
#l.pop(idx)会将索引idx处的元素删除，并返回这个元素。
a=[1,1,2,3,4]
b = a.pop(0)
print(b) #out=1
print('bob:',b,'; result:',a) #out= bob: 1 ; result: [1, 2, 3, 4]排序
list.sort()会将列表中的元素按照一定的规则排序：
a = [10, 1, 11, 13, 11, 2]
a.sort()
print(a)
#out=1, 2, 10, 11, 11, 13]如果不想改变原来列表中的值，可以使用sorted()函数：
a = [10, 1, 11, 13, 11, 2]
b = sorted(a)
print(a) #out=[10, 1, 11, 13, 11, 2]
print(b) #out=[1, 2, 10, 11, 11, 13列表反向
list.reverse()会将列表中的元素从后向前排列。
a = [1,2,3,4,5,6]
a.reverse()
print(a)
#out=[6, 5, 4, 3, 2, 1]如果不想改变原来列表中的值，可以使用这样的方法：
a = [1,2,3,4,5,6]
b = a[::-1]
print(b) #out=[6, 5, 4, 3, 2, 1]
print(a) #out=[1, 2, 3, 4, 5, 6]
#####################################################################################
b = reversed(a)
print(b) #out=<list_reverseiterator object at 0x1063e1400>如果不清楚用法，可以查看帮助：a.sort? 或者 help(a.sort),在 Python Console 输入：a=[1,2,3]; a.sort?
（三）列表VS字符串
列表是可变的(Mutable)
a = [1,2,3,4]
a[0] = 100
print(a) #out = [100, 2, 3, 4]
a.insert(3,200)
print(a) #out = [100, 2, 3, 200, 4]字符串是不可变的(Immutable)
s = 'good afternoon'
s[0]='a'
#out=TypeError: 'str' object does not support item assignment
s.insert(3,'b')
#out=AttributeError: 'str' object has no attribute 'insert'通过索引改变会报错⬆️
字符串方法只是返回一个新字符串，并不改变原来的值：
s = 'hello world'
s.replace('world','Sunday')
print(s.replace('world','Sunday'))
#out = hello Sunday
print(s)
#out = hello world如果想要改变字符串的值，可以采用重新赋值的方法：
s = 'hello world'
s = s.replace('world','flower')
print(s)#out = hello flower面试题：
1. 可变数据类型: list, dictionary, set, numpy array, user defined objects；
2. 不可变数据类型: integer, float, long, complex, string, tuple, frozenset，强调下 tuple 是不可变的。