python的基础函数

1. range()

range(start,stop[,step])
参数说明:
star: 计数从star开始.默认是从0开始.
stop: 计数到stop结束,但不包括stop.
step: 步长,默认为1，就是 每隔多少个，取一个，一步为step
python中表示范围有一个特性就是顾头不顾尾。

range(10)  #表示从零到9
range(5,10) #表示从零到九，
range(0,10,3) #表示从零到九，每隔3个数字取一个。

使用：比如索一个列表通过索引来便利他的时候就可以联合使用 range 和 len ，通过len求出列表长度，range的顾头不顾尾特性和列表索引从0开始的特性，刚好能够从零遍历到最后一个。

for i in range(len(nums)):
	print(i)
#i就是索引，如果假设nums是列表，他的长度是len(nums),索引刚好是从零 到 len(nums)-1

2. 分片

分片操作是 访问 有序对象的一种操作。
我理解的分片操作是浅操作

1.
list=[1,2,3,4]
list[开始下标:结束下标:步长]
步长可以是负数表示从后往前， 访问结果不包括结束下标的元素（顾头不顾尾）

2.
a=[0,1,2,3,4,5,6,7,8]
b=a[0:4:2]
print(a,id(a))
print(b,id(b))
b.append('ab')
a.append('xy')
print(a,id(a))
print(b,id(b))

结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8] 2652490531336
[0, 2] 2652490532936
[0, 1, 2, 3, 4, 5, 6, 7, 8, 'xy'] 2652490531336
[0, 2, 'ab'] 2652490532936

我感觉用的比较多的还有利用分片进行逆序访问。

str='asdfghjk'
str=[开始:结束:-1]
开始索引必须大于结束索引。

3. 浅拷贝和深拷贝

利用copy.copy() 和 copy.deepcopy()

3.1 可变对象

首先，对于 可变对象 来说 浅拷贝 是开辟一块新区域，指向原对象所指向的对象（或者说浅拷贝出来的对象的地址与原对象的地址不同，但是二者的对象引用是相同的），根据这一点无论哪个对象发生修改，另一个对象都会改变。

• 深拷贝* 是一个，除了所指向的内容相同外，是完全崭新的副本。
  
  上面的x1,x2,x3…是对象引用。
  这样应该会清楚一点了。

下面是一个例子：双层列表的浅拷贝

import copy
l1 = [1,2,['a','b']]#
l2 = l1 #赋值 对象的引用数 增加
l3 = copy.copy(l2)#浅拷贝 对象地址不同，对象引用相同，里面有三个对象引用和l1的一模一样
l4 = copy.deepcopy(l3)#深拷贝 完全独立
1. 
print('l1',l1,id(l1))#
print('l2',l2,id(l2))
print('l3',l3,id(l3))
print('l4',l4,id(l4))

结果：
l1 [1, 2, ['a', 'b']] 3032593827656
l2 [1, 2, ['a', 'b']] 3032593827656
l3 [1, 2, ['a', 'b']] 3032593914632
l4 [1, 2, ['a', 'b']] 3032593913608
2.
l1[2].append('a')
print('l1',l1,id(l1))
print('l2',l2,id(l2))# 对这个可变对象来说当修改这个对象时，因为l1和l2都指向一个对象，所以对象改变，变量指向对象。
print('l3',l3,id(l3))# 第三个对象引用没有改变，但是第三个对象引用下的内容可以改变    
print('l4',l4,id(l4))# 深拷贝是完全独立个体，与l4与l1无关

结果：
l1 [1, 2, ['a', 'b', 'a']] 3032593827656
l2 [1, 2, ['a', 'b', 'a']] 3032593827656
l3 [1, 2, ['a', 'b', 'a']] 3032593914632
l4 [1, 2, ['a', 'b']] 3032593913608
3.
l1.append('a')
print('l1',l1,id(l1))
print('l2',l2,id(l2))
print('l3',l3,id(l3))#
print('l4',l4,id(l4))

结果：
l1 [1, 2, ['a', 'b', 'a'], 'a'] 3032593827656
l2 [1, 2, ['a', 'b', 'a'], 'a'] 3032593827656
l3 [1, 2, ['a', 'b', 'a']] 3032593914632
l4 [1, 2, ['a', 'b']] 3032593913608

[参考] (https://blog.csdn.net/qq_26442553/article/details/82218403)

3.2 不可变对象

不可变对象 的 浅拷贝 或 浅拷贝 ，就像变量之间的 赋值 一样，只是增加了指向对象的 变量数目。

import copy
a=100
b=copy.copy(a)
print(id(a))
print(id(b))
#可以看出，a、b的指向一致
a+=100#修改a的值
print(id(a))#可以看出a仍然指向新对象
print(id(b))#可以看出b仍然指向100
结果：
1787721888
1787721888
1787725088
1787721888
*******************************************************************************
`a=50
b=copy.deepcopy(a)
print(id(a))
print(id(b))
#可以看出，a、b的指向一致
a+=100#修改a的值
print(id(a))#可以看出a仍然指向新对象
print(id(b))#可以看出b仍然指向50
结果：
1787720288
1787720288
1787723488
1787720288

需要注意的是可变对象的浅拷贝，不可变对象的浅拷贝是一种赋值操作（=），赋值操作是增加对对象指向的操作；
不论可变还是不可变对象的深拷贝，拷贝出来的对象都是语言对象独立！！！

---

理解上面这些之后，还得理解对对象进行修改之后是什么变化。

[参考] (https://www.cnblogs.com/blankdog/p/10070129.html)
有很多博客有图片讲解的很清楚
[参考] (https://www.cnblogs.com/blankdog/p/10070129.html)

4. strip,lstrip,rstrip

strip() 删除字符串左右两边给定的字符或者字符串
lstrip() 删除字符串左边给定的字符或者字符串
rstrip() 删除字符串右边给定的字符或者字符串